27165 2009-07-10 16:46:50 -0700 Connections-per-host should be tracked closer to the ResourceHandle level, not the Cache 2011-01-11 17:41:29 -0800 1 1 1 Unclassified WebKit Page Loading 528+ (Nightly build) All All RESOLVED FIXED InRadar P2 Normal --- 52264 1 beidson webkit-unassigned abarth aestes ap aroben eric japhet koivisto sam webkit.review.bot oldest_to_newest 131012 0 beidson 2009-07-10 16:46:50 -0700 Connections-per-host should be tracked at the ResourceHandle level, not the Loader The Loader only knows about CachedResources. It misses XHR and MainResources, and possibly others. Therefore it's attempt to keep the max number of connections per host limited can fail when main resources or XHR loads are also going to the same host. If we track connections per host at the ResourceHandle level, we won't get it wrong. This is a followup to https://bugs.webkit.org/show_bug.cgi?id=26496 131017 1 beidson 2009-07-10 16:50:38 -0700 <rdar://problem/7050112> 280736 2 67919 japhet 2010-09-17 10:51:43 -0700 Created attachment 67919 Move connections-per-host counting to ResourceLoader I took a stab at this as part of general loader cleanup. Note that I didn't go all the way down to ResourceHandle, so we'd still be missing a few types of loads. 280754 3 ap 2010-09-17 11:18:18 -0700 - // For named hosts - which are only http(s) hosts - we should always enforce the connection limit. - // For non-named hosts - everything but http(s) - we should only enforce the limit if the document isn't done parsing - // and we don't know all stylesheets yet. This change isn't explained in ChangeLog. Is this really OK to remove? I'm not sure why this is here offhand, but svn history likely has an explanation. 280835 4 67919 abarth 2010-09-17 13:42:44 -0700 Comment on attachment 67919 Move connections-per-host counting to ResourceLoader View in context: https://bugs.webkit.org/attachment.cgi?id=67919&action=prettypatch This is massively more elegant. Is there going to be an issue now that more loads will count against the open connection limit? It seems slightly unfortunate to have the OpenConnectionLimiter be static. It seems like we might want to hang it as an object off the NetworkContext object, but we can think about that in a future patch. > WebCore/loader/ResourceLoader.cpp:132 > + m_deferredRequest = clientRequest; > + setDefersLoading(true); Should these two lines be one atomic operation? I'd have to look at how these two pieces of state interact in the rest of this class. > WebCore/loader/OpenConnectionLimiter.cpp:70 > + int requestCount = requestsPerHostMap().isEmpty() ? 1 : requestsPerHostMap().get(host) + 1; I don't quite understand this line. Why do we need to branch on requestsPerHostMap().isEmpty() ? Do you mean to ask if the requestsPerHostMap map has an entry for |host| ? > WebCore/loader/OpenConnectionLimiter.cpp:97 > + unsigned requestCount = requestsPerHostMap().isEmpty() ? 0 : requestsPerHostMap().get(url.host()); Same question. 280839 5 abarth 2010-09-17 13:45:49 -0700 Here(In reply to comment #3) > - // For named hosts - which are only http(s) hosts - we should always enforce the connection limit. > - // For non-named hosts - everything but http(s) - we should only enforce the limit if the document isn't done parsing > - // and we don't know all stylesheets yet. > > This change isn't explained in ChangeLog. Is this really OK to remove? I'm not sure why this is here offhand, but svn history likely has an explanation. Here's the most recent rationale for that code that I could find: https://bugs.webkit.org/show_bug.cgi?id=27822 There might be more specific information hiding in rdar. 280840 6 ap 2010-09-17 13:53:23 -0700 > Is there going to be an issue now that more loads will count against the open connection limit? The number of connections is limited internally by CFNetwork, and likely by other network back-ends, too. Counting them more precisely just lets us do better scheduling in WebCore. Making no more than the number of requests that's supported by the network back-end also makes its job easier, so we don't run into certain bugs. 280871 7 ap 2010-09-17 14:32:16 -0700 > There might be more specific information hiding in rdar. This is about compatibility with Adobe installer (specifically, Creative Suite 4). It was quite subtle, and someone will just have to re-test for regression - ideally, before this patch is landed. And then we'd have to test MS Outlook Web Access, because it also needed super subtle tweaks in this code. I don't think I have access to the latter, but I could test the former for you, if needed. We can discuss details on IRC. 281382 8 67919 abarth 2010-09-19 22:19:44 -0700 Comment on attachment 67919 Move connections-per-host counting to ResourceLoader View in context: https://bugs.webkit.org/attachment.cgi?id=67919&action=review >> WebCore/loader/OpenConnectionLimiter.cpp:70 >> + int requestCount = requestsPerHostMap().isEmpty() ? 1 : requestsPerHostMap().get(host) + 1; > > I don't quite understand this line. Why do we need to branch on requestsPerHostMap().isEmpty() ? Do you mean to ask if the requestsPerHostMap map has an entry for |host| ? test 281753 9 japhet 2010-09-20 12:42:46 -0700 Sorry for not responding sooner, I forgot to cc: myself to thread :( As posted, this patch is failing fast/loader/early-load-cancel.html because I'm miscounting increments/decrements in some cancelled load cases. Will fix that in the next version I post. (In reply to comment #3) > - // For named hosts - which are only http(s) hosts - we should always enforce the connection limit. > - // For non-named hosts - everything but http(s) - we should only enforce the limit if the document isn't done parsing > - // and we don't know all stylesheets yet. > > This change isn't explained in ChangeLog. Is this really OK to remove? I'm not sure why this is here offhand, but svn history likely has an explanation. I'm not sure it's safe if the concern is non-web content. I'll add it back in (at the new location). Do we want a rule that local urls should never be throttled? (In reply to comment #4) > (From update of attachment 67919 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67919&action=prettypatch > > This is massively more elegant. Is there going to be an issue now that more loads will count against the open connection limit? AFAICT, no. The only potential issue that I see is that there's no longer any prioritization of un-throttling of requests (previously, when we hit the throttle point, we just stop creating SubresourceLoaders and started again later with the highest priority requests. Now they're all on timers). > > It seems slightly unfortunate to have the OpenConnectionLimiter be static. It seems like we might want to hang it as an object off the NetworkContext object, but we can think about that in a future patch. > > > WebCore/loader/ResourceLoader.cpp:132 > > + m_deferredRequest = clientRequest; > > + setDefersLoading(true); > > Should these two lines be one atomic operation? I'd have to look at how these two pieces of state interact in the rest of this class. They're non-atomic in other places in ResourceLoader. I could change that if you think it's important, but setDefersLoading assumes m_deferredRequest is already set. > > > WebCore/loader/OpenConnectionLimiter.cpp:70 > > + int requestCount = requestsPerHostMap().isEmpty() ? 1 : requestsPerHostMap().get(host) + 1; > > I don't quite understand this line. Why do we need to branch on requestsPerHostMap().isEmpty() ? Do you mean to ask if the requestsPerHostMap map has an entry for |host| ? > > > WebCore/loader/OpenConnectionLimiter.cpp:97 > > + unsigned requestCount = requestsPerHostMap().isEmpty() ? 0 : requestsPerHostMap().get(url.host()); > > Same question. These are leftovers from earlier testing that I forgot to remove. 281795 10 68132 japhet 2010-09-20 13:56:30 -0700 Created attachment 68132 Address comments + don't decrement in releaseResources() if m_request.isNull() 283251 11 68132 abarth 2010-09-22 14:25:55 -0700 Comment on attachment 68132 Address comments + don't decrement in releaseResources() if m_request.isNull() View in context: https://bugs.webkit.org/attachment.cgi?id=68132&action=review Looks great. Thanks. This is subtle stuff, so it seems likely we've screwed at least one thing up. > WebCore/loader/ResourceLoader.cpp:133 > + // For http(s) hosts, we should always enforce the connection limit. > + // For non-http(s) hosts, we should only enforce the limit if the document isn't done parsing and we don't know all stylesheets yet. > + bool shouldLimitRequests = clientRequest.url().protocolInHTTPFamily() || (m_frame->document() && (m_frame->document()->parsing() || !m_frame->document()->haveStylesheetsLoaded())); m_frame->document() is always non-NULL. Did you verify that this piece of complexity is still needed? > WebCore/loader/OpenConnectionLimiter.h:45 > +}; Missing newline after this line. > WebCore/loader/OpenConnectionLimiter.cpp:70 > + requestsPerHostMap().set(host, requestsPerHostMap().get(host) + 1); There's now operator[] on this object that returns a non-const reference? requestsPerHostMap()[host]++ ? 283347 12 japhet 2010-09-22 16:23:27 -0700 (In reply to comment #11) > > WebCore/loader/OpenConnectionLimiter.cpp:70 > > + requestsPerHostMap().set(host, requestsPerHostMap().get(host) + 1); > > There's now operator[] on this object that returns a non-const reference? > > requestsPerHostMap()[host]++ ? Are you sure about this? I can't find it anywhere in the HashMap implementation. 283351 13 abarth 2010-09-22 16:26:26 -0700 (In reply to comment #12) > (In reply to comment #11) > > > WebCore/loader/OpenConnectionLimiter.cpp:70 > > > + requestsPerHostMap().set(host, requestsPerHostMap().get(host) + 1); > > > > There's now operator[] on this object that returns a non-const reference? > > > > requestsPerHostMap()[host]++ ? > > Are you sure about this? I can't find it anywhere in the HashMap implementation. Sorry, that was meant as a question, but I fat-fingered "not" into "now". :) 283355 14 japhet 2010-09-22 16:29:01 -0700 (In reply to comment #13) > (In reply to comment #12) > > (In reply to comment #11) > > > > WebCore/loader/OpenConnectionLimiter.cpp:70 > > > > + requestsPerHostMap().set(host, requestsPerHostMap().get(host) + 1); > > > > > > There's now operator[] on this object that returns a non-const reference? > > > > > > requestsPerHostMap()[host]++ ? > > > > Are you sure about this? I can't find it anywhere in the HashMap implementation. > > Sorry, that was meant as a question, but I fat-fingered "not" into "now". :) I no longer feel like I'm missing something obvious :) HashMap doesn't have any functions that return a MappedType&, it appears to always be a copy. I'll leave it as is unless you object strenuously. 283390 15 abarth 2010-09-22 17:34:39 -0700 > HashMap doesn't have any functions that return a MappedType&, it appears to always be a copy. I'll leave it as is unless you object strenuously. SGTM 283546 16 koivisto 2010-09-23 01:13:49 -0700 As far as I can see this patch wipes out the request prioritization in the Loader which is the whole purpose of throttling the requests in the first place. This will lead to massive loading performance regression on any platform that doesn't do separate prioritization in the networking layer level. Please explain why this makes sense. I'm r-'n this for now. 283548 17 abarth 2010-09-23 01:23:48 -0700 > As far as I can see this patch wipes out the request prioritization in the Loader which is the whole purpose of throttling the requests in the first place. Really? I must have misunderstood how the prioritization works. > Please explain why this makes sense. Losing the prioritization makes obviously doesn't make sense, but counting requests at the loader level is pretty non-sensical. Notice that all the folks who are peers with loader have to do a crazy dance to interface with the connection limiter. I suspect the right solution is to either to move the prioritization logic lower in the network stack or to teach the loader how to read back information about the state of the open connection limiter. 283556 18 koivisto 2010-09-23 02:03:16 -0700 (In reply to comment #17) > > As far as I can see this patch wipes out the request prioritization in the Loader which is the whole purpose of throttling the requests in the first place. > > Really? I must have misunderstood how the prioritization works. The idea is that Loader only issues a request to lower levels when there is a free pipe to the host available. New high priority resources can appear at any point of loading as a result of script execution or CSS parsing and we this way we can push these resources to the front of the queue. With this patch ordering is done for resources found in a single runloop cycle only. Any high high priority resource (say script) found afterwards will end up at the end of the queue, loaded after all those 10MB images and delaying the first display for a minute. > Losing the prioritization makes obviously doesn't make sense, but counting requests at the loader level is pretty non-sensical. Notice that all the folks who are peers with loader have to do a crazy dance to interface with the connection limiter. > > I suspect the right solution is to either to move the prioritization logic lower in the network stack or to teach the loader how to read back information about the state of the open connection limiter. If all networking libraries would support per-host prioritization properly then we could just pass the priorities downward and wipe out most of the prioritization related code. That would be the elegant solution. I don't think that is true atm though. What has been discussed, but not implemented yet, is that more loading (XHR, main document,..) should be happening through Loader instead of using ResourceLoaders directly. There would give other benefits too (memory caching, ability to cache parsed forms, validation support...) Moving loading queues as well as the request counting to ResourceLoader level might indeed make sense. Did this patch solve any concrete problems or is it purely about aesthetics? 283560 19 abarth 2010-09-23 02:24:59 -0700 > Did this patch solve any concrete problems or is it purely about aesthetics? The concrete goal is to make the loader not insane. Here's a diagram of the current state of the loader: https://docs1.google.com/drawings/edit?id=1V3JZltHfNU0HN9bPlLrHOC_yYTriPgv4Dv-LRamymFU&hl=en Here's a sketch of one possible future for the loader: https://docs0.google.com/drawings/edit?id=1ko0LFteYpoXdmfYO1rYme6t-QXLPQdI1Z_ysejpOVYk&hl=en That diagram is missing a lot of details and certainly still up for discussion. Our thought process is to try to improve the loader iteratively. This patch is one step in that direction. Of course, the loader is complicated, so we're try to proceed slowly and carefully. Input from folks such as yourself is much appreciated. 283571 20 koivisto 2010-09-23 03:16:54 -0700 Reading the comments above, it was clearly known that this is patch could change behavior in poorly understood ways. That's not good, especially for refactoring patches. > That diagram is missing a lot of details and certainly still up for discussion. Our thought process is to try to improve the loader iteratively. This patch is one step in that direction. Of course, the loader is complicated, so we're try to proceed slowly and carefully. Input from folks such as yourself is much appreciated. The design looks good as far as pictures of boxes go, though obviously it doesn't really capture the real complexity of the loading subsystem. I think this patch could be fixed by reverting the changes to Loader, expect for those that are directly related to moving counting of connections to the new class. The OpenConnectionLimiter should probably also signal Loader when there are more slots available (this is currently achieved by calling Loader::nonCacheRequestComplete() from random places). Still, I'm not sure that keeping per-host data in two places (Loader::Host map for queues, OpenConnectionLimiter for the count) instead of one is an improvement. Perhaps we should move most of the Loader::Host to the ResourceLoader level instead? 283574 21 abarth 2010-09-23 03:24:15 -0700 > Reading the comments above, it was clearly known that this is patch could change behavior in poorly understood ways. That's not good, especially for refactoring patches. The fact that no one understands the loader is certainly a problem for the project. Hopefully we'll be able to improve the design to make it more understandable. > The design looks good as far as pictures of boxes go, though obviously it doesn't really capture the real complexity of the loading subsystem. Definitely. Drawing that picture was more of a high-level organizational roadmap. > I think this patch could be fixed by reverting the changes to Loader, expect for those that are directly related to moving counting of connections to the new class. The OpenConnectionLimiter should probably also signal Loader when there are more slots available (this is currently achieved by calling Loader::nonCacheRequestComplete() from random places). That sounds reasonable. > Still, I'm not sure that keeping per-host data in two places (Loader::Host map for queues, OpenConnectionLimiter for the count) instead of one is an improvement. Perhaps we should move most of the Loader::Host to the ResourceLoader level instead? I certainly think it makes sense to decouple prioritization concerns from caching concerns. It's possible we should put these concerns in a layer above ResourceLoader but below the current next layer. In a sense, that would be generalizing Loader to handle more of the loading subsystem, which I think is the direction you mentioned above. 291153 22 70122 japhet 2010-10-07 11:13:44 -0700 Created attachment 70122 Rewrite - include scheduling (as well as throttling) in OpenConnectionLimiter 291163 23 70122 abarth 2010-10-07 11:34:08 -0700 Comment on attachment 70122 Rewrite - include scheduling (as well as throttling) in OpenConnectionLimiter View in context: https://bugs.webkit.org/attachment.cgi?id=70122&action=review This direction is great. Mostly minor aesthetic comments and a question. > WebCore/loader/MainResourceLoader.cpp:553 > + openConnectionLimiter()->addRequestWithoutSchedule(this); openConnectionLimiter()->addRequest(DoNotSchedule) ? > WebCore/loader/OpenConnectionLimiter.h:2 > + * Copyright (C) 2010 Google Inc. All rights reserved. You probably need the copyright lines from Loader.h/cpp in these files. > WebCore/loader/OpenConnectionLimiter.h:47 > +class OpenConnectionLimiter : public Noncopyable { Maybe OpenConnectionLimiter -> ResourceLoadScheduler ? > WebCore/loader/OpenConnectionLimiter.h:49 > + friend OpenConnectionLimiter* openConnectionLimiter(); Interesting. Yeah, I think that's the pattern we use here. Other code bases would make this a static function, but this seems fine. > WebCore/loader/OpenConnectionLimiter.h:64 > + ~OpenConnectionLimiter(); Add a blank line below here. > WebCore/loader/OpenConnectionLimiter.h:70 > + class Host : public RefCounted<Host> { Host is a confusing name. Maybe HostInformation? This class is just data-only, right? > WebCore/loader/OpenConnectionLimiter.h:81 > + void servePendingRequests(Priority minimumPriority = VeryLow); I see, this isn't model-like. Can we move this into the parent class? That way the parent class is the controller and this class is the model. Also, is there a big benefit to having this be an inner class? It seems like it would be easier if it had it's own header and file. > WebCore/loader/OpenConnectionLimiter.h:82 > + void end(ResourceLoader*, OpenConnectionLimiter::Priority); OpenConnectionLimiter:: isn't needed here. > WebCore/loader/ResourceLoader.h:133 > + friend class OpenConnectionLimiter; sadface > WebCore/loader/OpenConnectionLimiter.cpp:75 > + static OpenConnectionLimiter* openConnectionLimiter = new OpenConnectionLimiter(); DECLARE_STATIC_LOCAL > WebCore/loader/OpenConnectionLimiter.cpp:100 > + m_hosts.checkConsistency(); > + String hostName = url.host(); > + host = m_hosts.get(hostName); > + if (!host) { > + host = Host::create(hostName, maxRequestsInFlightPerHost); > + m_hosts.add(hostName, host); > + } This seems like it should be in a helper function. > WebCore/loader/OpenConnectionLimiter.cpp:128 > + if (url.protocolInHTTPFamily()) { > + m_hosts.checkConsistency(); > + host = m_hosts.get(url.host()); > + } else > + host = m_nonHTTPProtocolHost; Another instance of this url => Host lookup. > WebCore/loader/OpenConnectionLimiter.cpp:145 > + RefPtr<Host> oldHost; > + if (oldURL.protocolInHTTPFamily()) { > + m_hosts.checkConsistency(); > + oldHost = m_hosts.get(oldURL.host()); > + } else > + oldHost = m_nonHTTPProtocolHost; :) > WebCore/loader/OpenConnectionLimiter.cpp:156 > + m_hosts.checkConsistency(); > + String hostName = newURL.host(); > + newHost = m_hosts.get(hostName); > + if (!newHost) { > + newHost = Host::create(hostName, maxRequestsInFlightPerHost); > + m_hosts.add(hostName, newHost); > + } Here's the same thing but with the "create" bit set. > WebCore/loader/OpenConnectionLimiter.cpp:182 > + RefPtr<Host> host; > + KURL url(ParsedURLString, resourceLoader->request().url()); > + if (url.protocolInHTTPFamily()) { > + m_hosts.checkConsistency(); > + String hostName = url.host(); > + host = m_hosts.get(hostName); > + if (!host) { > + host = Host::create(hostName, maxRequestsInFlightPerHost); > + m_hosts.add(hostName, host); > + } > + } else > + host = m_nonHTTPProtocolHost; :) > WebCore/loader/OpenConnectionLimiter.cpp:207 > + host->servePendingRequests(minimumPriority); Yeah, we can probably move this controller logic from Host to here. > WebCore/loader/OpenConnectionLimiter.cpp:299 > +void OpenConnectionLimiter::Host::end(ResourceLoader* resourceLoader, OpenConnectionLimiter::Priority priority) end -> remove ? > LayoutTests/http/tests/xmlhttprequest/logout.html:32 > - xhr.abort(); > + xhr.onload = function() { > + document.getElementById("logout").innerHTML = isAuthenticated() ? "FAIL" : "PASS"; > + > + if (window.layoutTestController) > + layoutTestController.notifyDone(); > + } Is our new behavior more consistent or less consistent with other browsers? 291285 24 japhet 2010-10-07 15:16:24 -0700 > > LayoutTests/http/tests/xmlhttprequest/logout.html:32 > > - xhr.abort(); > > + xhr.onload = function() { > > + document.getElementById("logout").innerHTML = isAuthenticated() ? "FAIL" : "PASS"; > > + > > + if (window.layoutTestController) > > + layoutTestController.notifyDone(); > > + } > > Is our new behavior more consistent or less consistent with other browsers? Assuming the test isn't rewritten, the output for the last PASS/FAIL: FF3/4 passes IE8 passes (but fails a different part) IE9 fails Chrome fails already due to another bug Safari passes, but will fail with this change 291949 25 70314 japhet 2010-10-08 16:30:45 -0700 Created attachment 70314 Rename to ResourceLoadScheduler, etc. 291961 26 70314 abarth 2010-10-08 16:52:07 -0700 Comment on attachment 70314 Rename to ResourceLoadScheduler, etc. View in context: https://bugs.webkit.org/attachment.cgi?id=70314&action=review > WebKit/mac/WebView/WebView.mm:624 > - (void)_dispatchPendingLoadRequests > { > - cache()->loader()->servePendingRequests(); > + resourceLoadScheduler()->servePendingRequests(); > } I wonder why only Mac does this. > WebCore/loader/ResourceLoadScheduler.cpp:66 > +ResourceLoadScheduler::HostInformation* ResourceLoadScheduler::hostForURL(const KURL& url, bool createIfNotFound) using an enum here is probably slightly more readable at the callsites. > WebCore/loader/ResourceLoadScheduler.cpp:71 > + RefPtr<HostInformation> host; Is there any reason to declare this up here instead of on line 74 where it's initialized? > WebCore/loader/ResourceLoadScheduler.cpp:153 > + HostMap::iterator i = m_hosts.begin(); We'd usually call this variable iter to remind ourselves that it's not an index. > WebCore/loader/ResourceLoadScheduler.cpp:158 > + for (unsigned n = 0; n < hostsToServe.size(); ++n) { We'd usually call this one "i" because it is an index. "n" is usually a constant and the total number of things. > WebCore/loader/ResourceLoadScheduler.h:34 > +namespace WebCore { Missing a blank line after this line. > WebCore/loader/loader.cpp:-133 > - AtomicString hostName = url.host(); Does it matter that this used to be an AtomicString? > WebCore/loader/loader.cpp:225 > - m_requestsLoading.remove(loader); > loader->clearClient(); > + m_requestsLoading.remove(loader); Why this re-ordering? 291963 27 70314 abarth 2010-10-08 16:53:37 -0700 Comment on attachment 70314 Rename to ResourceLoadScheduler, etc. I think this is great. My only concern is the issue mentioned in Comment #24. I think we should land this (maybe with the nits above addressed). If the comment #24 issue turns out to be a problem, we'll figure something out. 291965 28 ap 2010-10-08 16:59:28 -0700 Antti, would you like to look over this again before landing? 291970 29 ap 2010-10-08 17:02:16 -0700 Oh, and I just noticed that this fails a test I've written, so I'd like to take a closer look, too. Please don't land this yet. 291972 30 japhet 2010-10-08 17:04:22 -0700 (In reply to comment #29) > Oh, and I just noticed that this fails a test I've written, so I'd like to take a closer look, too. Please don't land this yet. No problem, I was planning on waiting until Monday morning anyway. 292998 31 70314 ap 2010-10-12 11:08:22 -0700 Comment on attachment 70314 Rename to ResourceLoadScheduler, etc. +// Having a limit might still help getting more important resources first This is just copy/pasted, but this comment is nearly incomprehensible. Might? Still? When can we remove the limit? +static const unsigned maxRequestsInFlightForNonHTTPProtocols = 20; I found REQUEST_MANAGEMENT_ENABLED useful before. +static unsigned maxRequestsInFlightPerHost; This has lost an important comment that used to be present in original code (match the parallel connection count used by the networking layer). Ideally, we should be clearer about whether this is about parallel connections or about inflight requests (this is not the same if request pipelining is enabled). +ResourceLoadScheduler::Priority ResourceLoadScheduler::determinePriority(const ResourceRequest& request) const +{ + switch (request.targetType()) { + case ResourceRequest::TargetIsMainFrame: Ugh, this is horrible. ResourceRequest::m_targetType is misguided code - this member variable isn't guaranteed to be accurate. The reason is that Mac WebKit API sends every request to embedder as an NSURLRequest, and the embedder is free to do anything with it. After the call returns, ResourceRequest is re-created from NSURLRequest, so anything ResourceRequest::doUpdateResourceRequest() doesn't know about is lost. It's not good design to have cross-platform code with such strong Mac ties, but that's what we have now (plus misguided code from developers who chose to ignore this limitation after having been told about it). We should at least have comments in ResourceRequestBase.h - or better, come up with a strategy for dealing with this. See also: bug 44722 comment 49. In any case, request.targetType() shouldn't be used in ResourceLoadScheduler now. +ResourceLoadScheduler* resourceLoadScheduler() +{ + DEFINE_STATIC_LOCAL(ResourceLoadScheduler, resourceLoadScheduler, ()); + return &resourceLoadScheduler; +} I'd add ASSERT(isMainThread()) here - we need a lot more of those asserts with additional functionality being available in workers. +ResourceLoadScheduler::ResourceLoadScheduler() + : m_requestTimer(this, &ResourceLoadScheduler::requestTimerFired) + , m_isSuspendingPendingRequests(false) +{ + m_nonHTTPProtocolHost = HostInformation::create(String(), maxRequestsInFlightForNonHTTPProtocols); Why does m_nonHTTPProtocolHost need to be assigned, and not initialized together with m_requestTimer and m_isSuspendingPendingRequests? + HostInformation* oldHost = hostForURL(resourceLoader->request().url()); + ASSERT(oldHost); + HostInformation* newHost = hostForURL(request.url(), true); + + if (oldHost == newHost) + return; Comparing by pointer is slightly surprising - besides AtomicString, this never works. Perhaps a function like urlsAreOnSameHost() would be easier to the eyes? + class HostInformation : public RefCounted<HostInformation> { Why is HostInformation reference counted? It seems to have a clear ownership. + // Try to request important resources immediately Please add periods at the end of sentences, even in moved code. + HostMap::iterator i = m_hosts.begin(); + HostMap::iterator end = m_hosts.end(); + for (;i != end; ++i) There is no reason to define i outside for. Also, I don't see why end is precomputed, but hostsToServe.size() just below the quoted code isn't. - m_handle = ResourceHandle::create(m_frame->loader()->networkingContext(), clientRequest, this, m_defersLoading, m_shouldContentSniff); + resourceLoadScheduler()->add(this); So, ResourceLoader has a circular relationship with ResourceLoadScheduler - you create a ResourceLoader, it registers with ResourceLoadScheduler, and then the scheduler tells the loader to start. And other times, you just start a load and register it with the scheduler after the fact . I didn't expect ResourceLoader to know about scheduling, but perhaps I didn't think about it long enough. Can this be streamlined? + if (!redirectResponse.isNull()) + resourceLoadScheduler()->changeHost(this, request); Since changeHost is only called as a response to a redirect, it should probably have "redirect" in its name somehow. I've been puzzled about what this function did until I saw where it was being called. I'm wondering how changing a host affects scheduling. Clearly, we don't get a chance to re-prioritize the request in WebCore, networking library does everything internally. It may be worth making an experiment - create multiple long-standing connections to host 1, then make a request to host 2 that gets redirected to host 1. Will it load immediately in Safari, Chrome or other browsers, even though the concurrent connection limit is already met? This is probably not going to affect this patch, but is something that's nice to check while we're at it. + enum SchedulePolicy { + Schedule, + AlreadyLoading + }; SchedulePolicy::Schedule looks a little mysterious, maybe ScheduleLoad? I know it's hard to come up with good names for these enums. +ResourceLoadScheduler::HostInformation* ResourceLoadScheduler::hostForURL(const KURL& url, bool createIfNotFound) +{ + if (!url.protocolInHTTPFamily()) + return m_nonHTTPProtocolHost.get(); Should these all be the same (ftp: and data: have little in common)? Is that how existing code works? + const ResourceRequest& request() const { return m_request; } It's a little dangerous to have request() as a public method of ResourceLoader, it's easy to misuse. There are initial request, request as changed by embedder delegate call, and redirected request. There's also m_deferredRequest, which I have no idea about. The fewer "request()" functions a developer has to randomly choose from at any given call site, the better. And if this one has to be made public, it needs a comment explaining which request this is. + * http/tests/xmlhttprequest/logout.html: It is no longer safe + to assume that an async xhr will have any effects synchronously. Did this test pass in Firefox and IE in its original form? If it did, we should probably find a way to keep it working. This patch needs more work (possibly several more iterations), but I really like the goal and the scope of changes that you chose to make. 293377 32 koivisto 2010-10-13 06:03:13 -0700 Looks pretty good. I think the job of determining the resource priority (determinePriority() function) should not be part of the scheduler itself. Instead the priority should be determined in higher level and passed to the scheduler, perhaps as a field in ResourceRequest. 295790 33 japhet 2010-10-18 15:31:15 -0700 Sorry for the delay....a few comments/questions on the less-trivial requests (In reply to comment #31) > (From update of attachment 70314 [details]) > +ResourceLoadScheduler::Priority ResourceLoadScheduler::determinePriority(const ResourceRequest& request) const > +{ > + switch (request.targetType()) { > + case ResourceRequest::TargetIsMainFrame: > > Ugh, this is horrible. ResourceRequest::m_targetType is misguided code - this member variable isn't guaranteed to be accurate. The reason is that Mac WebKit API sends every request to embedder as an NSURLRequest, and the embedder is free to do anything with it. After the call returns, ResourceRequest is re-created from NSURLRequest, so anything ResourceRequest::doUpdateResourceRequest() doesn't know about is lost. > > It's not good design to have cross-platform code with such strong Mac ties, but that's what we have now (plus misguided code from developers who chose to ignore this limitation after having been told about it). We should at least have comments in ResourceRequestBase.h - or better, come up with a strategy for dealing with this. See also: bug 44722 comment 49. > > In any case, request.targetType() shouldn't be used in ResourceLoadScheduler now. > > > - m_handle = ResourceHandle::create(m_frame->loader()->networkingContext(), clientRequest, this, m_defersLoading, m_shouldContentSniff); > > + resourceLoadScheduler()->add(this); > > So, ResourceLoader has a circular relationship with ResourceLoadScheduler - you create a ResourceLoader, it registers with ResourceLoadScheduler, and then the scheduler tells the loader to start. And other times, you just start a load and register it with the scheduler after the fact . I didn't expect ResourceLoader to know about scheduling, but perhaps I didn't think about it long enough. Can this be streamlined? Removing knowledge of the initial scheduling from ResourceLoader would simplify things and make it easier to keep ResourceLoadScheduler from having to know about how priority is calculated, so I think that part makes sense. However, I don't see a good way to keep ResourceLoader from knowing about the end-of-life accounting (unless we come up with a better time to call ResourceLoadScheduler->remove() than the ResourceLoader destructor). Does it seem reasonable to allow ResourceLoader to know about the cross-origin redirect and remove cases, but not know about how the initial scheduling occurs? > > + if (!redirectResponse.isNull()) > + resourceLoadScheduler()->changeHost(this, request); > > Since changeHost is only called as a response to a redirect, it should probably have "redirect" in its name somehow. I've been puzzled about what this function did until I saw where it was being called. > > I'm wondering how changing a host affects scheduling. Clearly, we don't get a chance to re-prioritize the request in WebCore, networking library does everything internally. > > It may be worth making an experiment - create multiple long-standing connections to host 1, then make a request to host 2 that gets redirected to host 1. Will it load immediately in Safari, Chrome or other browsers, even though the concurrent connection limit is already met? This is probably not going to affect this patch, but is something that's nice to check while we're at it. > Agreed on renaming changeHost(). Currently, I don't think we're handling this case correctly (namely, if we have a cross-origin redirect, we continue to account for it under the original host, not the one that it ought to be under for the redirect). This patch, on the other hand, needs to move the request between hosts because we no longer have a host subclass directly receiving callbacks. I'll see if I can get the experiment for you. > > +ResourceLoadScheduler::HostInformation* ResourceLoadScheduler::hostForURL(const KURL& url, bool createIfNotFound) > +{ > + if (!url.protocolInHTTPFamily()) > + return m_nonHTTPProtocolHost.get(); > > Should these all be the same (ftp: and data: have little in common)? Is that how existing code works? It's how the existing code works. I have no strong opinion on how it should work. > > + * http/tests/xmlhttprequest/logout.html: It is no longer safe > + to assume that an async xhr will have any effects synchronously. > > Did this test pass in Firefox and IE in its original form? If it did, we should probably find a way to keep it working. The data I provided before was for the original form. I can get it for the new form of the test if you like, but I was mostly pointing out that behavior on this test isn't standard as is. 304346 34 72883 japhet 2010-11-03 16:32:32 -0700 Created attachment 72883 patch #5 (I think) I believe this address all the comments on the previous versions. Note that this version includes a small yak shave that may belong in a separate patch (removing some duplicate code in creation of NetscapePluginStreamLoader and making it behave more like its sibling, SubresourceLoader). Let me know if you'd prefer I break it out. 305272 35 koivisto 2010-11-05 07:30:48 -0700 Looks really good to me. I'll try it out and let others comment too. 305413 36 72883 ap 2010-11-05 11:35:26 -0700 Comment on attachment 72883 patch #5 (I think) View in context: https://bugs.webkit.org/attachment.cgi?id=72883&action=review >> Did this test pass in Firefox and IE in its original form? If it did, we should probably find a way to keep it working. > The data I provided before was for the original form. I can get it for the new form of the test if you like, but I was mostly pointing out that behavior on this test isn't standard as is. So, we used to be compatible with Firefox and IE8, and no longer are. This seems quite unfortunate. Perhaps credentials should be stored immediately, not waiting for a request to actually start? Or maybe requests with explicit credentials should always get highest priority, to make sure that subsequent ones are properly authenticated (or logged out)? I don't think this difference necessarily warrants r-, but logging out is such a sensitive area that one gets paranoid. > WebCore/ChangeLog:5 > + Need a short description and bug URL (OOPS!) As it says :) > WebCore/loader/loader.cpp:185 > - LOG(ResourceLoading, "Host '%s' received %s. Current count %d\n", m_name.string().latin1().data(), resource->url().latin1().data(), m_requestsLoading.size()); > + LOG(ResourceLoading, "Received %s.", resource->url().latin1().data()); %s should probably be in single quotes, too (I think I omitted those by mistake when recently adding the logging). > WebCore/loader/loader.cpp:224 > + LOG(ResourceLoading, "Failed to load %s (cancelled=%d).\n", resource->url().latin1().data(), cancelled); Ditto. 305633 37 japhet 2010-11-05 16:49:20 -0700 (In reply to comment #36) > (From update of attachment 72883 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=72883&action=review > > >> Did this test pass in Firefox and IE in its original form? If it did, we should probably find a way to keep it working. > > The data I provided before was for the original form. I can get it for the new form of the test if you like, but I was mostly pointing out that behavior on this test isn't standard as is. > > So, we used to be compatible with Firefox and IE8, and no longer are. This seems quite unfortunate. Perhaps credentials should be stored immediately, not waiting for a request to actually start? Or maybe requests with explicit credentials should always get highest priority, to make sure that subsequent ones are properly authenticated (or logged out)? > > I don't think this difference necessarily warrants r-, but logging out is such a sensitive area that one gets paranoid. I just experimented with the suggestion to give High priority to requests with explicit credentials. It appears that this breaks the test, but in a different way. The test currently sends an async request, then logs out, and expects the async request to return 200. With higher priority for explicit credentials, it looks like we end up sending the logout request before the async request. I'm not sure whether we're worried about that case. I'd be happy to also try your suggestion of storing credentials immediately, but I'm having trouble finding the code where we store the credentials. Is that somewhere in WebCore? 305645 38 ap 2010-11-05 17:00:47 -0700 > I'm having trouble finding the code where we store the credentials. Is that somewhere in WebCore? Yes, but it's in platform specific code. For Mac, it's in ResourceHandle::createNSURLConnection(): // If there is already a protection space known for the URL, update stored credentials before sending a request. // This makes it possible to implement logout by sending an XMLHttpRequest with known incorrect credentials, and aborting it immediately // (so that an authentication dialog doesn't pop up). CredentialStorage::set(Credential(d->m_user, d->m_pass, CredentialPersistenceNone), firstRequest().url()); This approach will have the same problem that you described though. 306003 39 72883 eric 2010-11-07 22:53:53 -0800 Comment on attachment 72883 patch #5 (I think) I feel like the schedulePluginStreamLoad abstraction part of this could be landed simply w/o any controversy. Maybe that should be done first if review seems blocked here otherwise. 306071 40 koivisto 2010-11-08 03:42:56 -0800 It would be good to get the whole patch landed as it rots fast (it doesn't apply anymore). I can't evaluate how serious this credentials issue is though. Could it be handled afterwards? 306133 41 72883 ap 2010-11-08 08:38:52 -0800 Comment on attachment 72883 patch #5 (I think) I think that this patch is flawed in that it changes load scheduling instead of just the promised refactoring. It's the fact that XMLHttpRequest loads do not start right away - even when all loader slots are empty - that causes the test regression. That said, this patch still seems like an improvement all things considered. Given Nate's good track record of thoroughness in particular, I think this is OK to land it and investigate XMLHttpRequest scheduling changes in a follow-up bug. 306207 42 japhet 2010-11-08 10:44:00 -0800 (In reply to comment #41) > (From update of attachment 72883 [details]) > I think that this patch is flawed in that it changes load scheduling instead of just the promised refactoring. It's the fact that XMLHttpRequest loads do not start right away - even when all loader slots are empty - that causes the test regression. > > That said, this patch still seems like an improvement all things considered. Given Nate's good track record of thoroughness in particular, I think this is OK to land it and investigate XMLHttpRequest scheduling changes in a follow-up bug. I just experimented with bumping XHRs from Low priority to Medium (which guarantees we'll try to start them immediately), and that causes this test to pass. If it's ok with you, I think I'll add changing the ResourceLoaderScheduler::Low to Medium in DocumentThreadableLoader.cpp to the list of changes before submitting. Sorry for not catching this sooner, I really thought I had tried fixing the problem by just increasing the priority of XHRs. Note, however, that this test could theoretically become flaky if we do hit the number of requests where we start throttling. 306296 43 ap 2010-11-08 12:53:04 -0800 Sounds good to me. 306332 44 webkit.review.bot 2010-11-08 13:41:25 -0800 http://trac.webkit.org/changeset/71562 might have broken Qt Linux Release The following tests are not passing: editing/selection/move-by-line-003.html fast/dom/Document/CaretRangeFromPoint/replace-element.html 306431 45 japhet 2010-11-08 16:02:02 -0800 Landed: http://trac.webkit.org/changeset/71562 Thanks! 306510 46 eric 2010-11-08 17:38:49 -0800 I think this broke windows? Compiling... WebPage.cpp ..\WebProcess\WebPage\WebPage.cpp(121) : error C2259: 'WebKit::WebChromeClient' : cannot instantiate abstract class due to following members: 'void WebCore::ChromeClient::focusedFrameChanged(WebCore::Frame *)' : is abstract C:\cygwin\mnt\svn\webkit-win-ews\WebKitBuild\Include\WebCore/ChromeClient.h(97) : see declaration of 'WebCore::ChromeClient::focusedFrameChanged' PluginView.cpp ..\WebProcess\Plugins\PluginView.cpp(132) : error C2660: 'WebCore::NetscapePlugInStreamLoader::create' : function does not take 2 arguments Generating Code... Project : warning PRJ0018 : The following environment variables were not found: $(PRODUCTION) </pre></table><table width=100% bgcolor=#DFDFE5><tr><td><font face=arial size=+2> Results </font></table><table width=* cellspacing=0 cellpadding=0><tr><td width=0 bgcolor=#EDEDF5>&nbsp;</td><td width=0 bgcolor=#FFFFFF>&nbsp;</td><td width=*><pre>Build log was saved at "file://C:\cygwin\mnt\svn\webkit-win-ews\WebKitBuild\obj\WebKit\Debug\BuildLog.htm" WebKit - 2 error(s), 1 warning(s) 306512 47 eric 2010-11-08 17:39:42 -0800 That log is from the win-ews: http://queues.webkit.org/results/5541055. The other win-ews instance seems to be functioning fine, so it's possible the error is just temporary. 306741 48 aroben 2010-11-09 05:38:00 -0800 (In reply to comment #47) > That log is from the win-ews: http://queues.webkit.org/results/5541055. The other win-ews instance seems to be functioning fine, so it's possible the error is just temporary. The error was fixed in r71548. 325219 49 aestes 2010-12-21 15:00:19 -0800 (In reply to comment #7) > > There might be more specific information hiding in rdar. > > This is about compatibility with Adobe installer (specifically, Creative Suite 4). It was quite subtle, and someone will just have to re-test for regression - ideally, before this patch is landed. > > And then we'd have to test MS Outlook Web Access, because it also needed super subtle tweaks in this code. I don't think I have access to the latter, but I could test the former for you, if needed. We can discuss details on IRC. This did indeed break the Adobe CS 4 installer :( 332826 50 aestes 2011-01-11 17:41:29 -0800 (In reply to comment #49) > This did indeed break the Adobe CS 4 installer :( Filed https://bugs.webkit.org/show_bug.cgi?id=52264 to track this 67919 2010-09-17 10:51:43 -0700 2010-09-20 13:56:30 -0700 Move connections-per-host counting to ResourceLoader ocl.txt text/plain 30898 japhet SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNjc3MjIpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xMDA1LDYgKzEwMDUsNyBAQAogICAgIGxvYWRlci9NYWluUmVzb3VyY2VMb2FkZXIu Y3BwIFwKICAgICBsb2FkZXIvTmF2aWdhdGlvbkFjdGlvbi5jcHAgXAogICAgIGxvYWRlci9OZXRz Y2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAgXAorICAgIGxvYWRlci9PcGVuQ29ubmVjdGlvbkxp bWl0ZXIuY3BwIFwKICAgICBsb2FkZXIvUGluZ0xvYWRlci5jcHAgXAogICAgIGxvYWRlci9QbGFj ZWhvbGRlckRvY3VtZW50LmNwcCBcCiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNrLmNwcCBcCklu ZGV4OiBXZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL0NoYW5nZUxvZwko cmV2aXNpb24gNjc3MjIpCisrKyBXZWJDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAt MSwzICsxLDUzIEBACisyMDEwLTA5LTE3ICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTW92 ZSBjb25uZWN0aW9uLXBlci1ob3N0IHRyYWNraW5nIGRvd24gYSBsYXllciwgZnJvbSB0aGUKKyAg ICAgICAgY2FjaGUgdG8gUmVzb3VyY2VMb2FkZXIuCisKKyAgICAgICAgTm90ZSB0aGF0IHRoaXMg d2lsbCBzdGlsbCBtaXNzIHNvbWUgcmVxdWVzdHMgKHBpbmdzLCBpY29ucywgZXRjKSwKKyAgICAg ICAgYnV0IGl0IHNob3VsZCBiZSByZWxhdGl2ZWx5IGVhc3kgdG8gbW92ZSBmcm9tIGhlcmUgdG8g UmVzb3VyY2VIYW5kbGUKKyAgICAgICAgaWYgZGVzaXJlZC4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjcxNjUKKworICAgICAgICBSZWZhY3RvciBv bmx5LCBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBBbmRyb2lkLm1rOgorICAgICAgICAqIENN YWtlTGlzdHMudHh0OgorICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIFdlYkNv cmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBXZWJDb3JlLnZjcHJv ai9XZWJDb3JlLnZjcHJvajoKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2o6CisgICAgICAgICogbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5jcHA6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6bWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOgorICAgICAg ICAoV2ViQ29yZTo6cmVxdWVzdHNQZXJIb3N0TWFwKToKKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5D b25uZWN0aW9uTGltaXRlcjo6aW5jcmVtZW50SG9zdFJlcXVlc3RDb3VudCk6CisgICAgICAgIChX ZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmRlY3JlbWVudEhvc3RSZXF1ZXN0Q291bnQp OgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpzaG91bGRUaHJvdHRs ZVJlcXVlc3QpOgorICAgICAgICAqIGxvYWRlci9PcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaDogQWRk ZWQuCisgICAgICAgICogbG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlc291cmNlTG9hZGVyOjpSZXNvdXJjZUxvYWRlcik6CisgICAgICAgIChXZWJDb3JlOjpS ZXNvdXJjZUxvYWRlcjo6cmVsZWFzZVJlc291cmNlcyk6IERlY3JlbWVudCBmb3IgY29tcGxldGVk IHJlcXVlc3QuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRlcjo6dGhyb3R0bGVSZXRy eVRpbWVyRmlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkZXI6OmxvYWQpOiBE ZWZlciBhbmQgc2V0IGEgdGltZXIgaWYgd2UndmUgaGl0IHRoZSBjb25uZWN0aW9uIGxpbWl0Lgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkZXI6OndpbGxTZW5kUmVxdWVzdCk6IEluY3Jl bWVudCBmb3IgbmV3IHJlcXVlc3QsIGRlY3JlbWVudCBmb3IgcmVkaXJlY3QgaWYgbmVjZXNzYXJ5 LgorICAgICAgICAqIGxvYWRlci9SZXNvdXJjZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9s b2FkZXIuY3BwOiBSZW1vdmUgY29ubmVjdGlvbi1wZXItaG9zdCBjb3VudGluZyBjb2RlIChzb21l IGFkZGl0aW9uYWwgY2xlYW51cCB0byBjb21lKS4KKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6 TG9hZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGV0ZXJtaW5lUHJpb3JpdHkpOgor ICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpsb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRl cjo6SG9zdDo6SG9zdCk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhvc3Q6OmFkZFJlcXVl c3QpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0 cyk6CisgICAgICAgICogbG9hZGVyL2xvYWRlci5oOiBSZW1vdmUgY29ubmVjdGlvbi1wZXItaG9z dCBjb3VudGluZyBjb2RlIChzb21lIGFkZGl0aW9uYWwgY2xlYW51cCB0byBjb21lKS4KKyAgICAg ICAgKFdlYkNvcmU6OkxvYWRlcjo6SG9zdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Okxv YWRlcjo6SG9zdDo6cHJvY2Vzc2luZ1Jlc291cmNlKToKKyAgICAgICAgKiBwYWdlL0V2ZW50U291 cmNlLmNwcDogUmVtb3ZlIGN1c3RvbSBjb2RlIGZvciBjb3VudGluZyBjb25uZWN0aW9ucyBwZXIg aG9zdC4KKyAgICAgICAgKiB4bWwvWE1MSHR0cFJlcXVlc3QuY3BwOiBSZW1vdmUgY3VzdG9tIGNv ZGUgZm9yIGNvdW50aW5nIGNvbm5lY3Rpb25zIHBlciBob3N0LgorICAgICAgICAqIHhtbC9YTUxI dHRwUmVxdWVzdC5oOgorCiAyMDEwLTA5LTE0ICBQYXZlbCBQb2Rpdmlsb3YgIDxwb2Rpdmlsb3ZA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFBhdmVsIEZlbGRtYW4uCkluZGV4 OiBXZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oJKHJldmlzaW9uIDY3NzIyKQorKysg V2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAt MjM2NDksNiArMjM2NDksMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJ CVJlbGF0aXZlUGF0aD0iLi5cbG9hZGVyXE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHAiDQorCQkJ CT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJc T3BlbkNvbm5lY3Rpb25MaW1pdGVyLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUN CiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcUGluZ0xvYWRlci5jcHAiDQogCQkJCT4NCiAJ CQk8L0ZpbGU+DQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50U291cmNlLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BhZ2UvRXZlbnRTb3VyY2UuY3BwCShyZXZpc2lvbiA2NzcyMikKKysrIFdl YkNvcmUvcGFnZS9FdmVudFNvdXJjZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTExNiw5ICsxMTYs NiBAQAogICAgIG1fbG9hZGVyID0gVGhyZWFkYWJsZUxvYWRlcjo6Y3JlYXRlKHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQoKSwgdGhpcywgcmVxdWVzdCwgb3B0aW9ucyk7CiAKICAgICBtX3JlcXVlc3RJ bkZsaWdodCA9IHRydWU7Ci0KLSAgICBpZiAoIXNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNX b3JrZXJDb250ZXh0KCkpCi0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVl c3RJbkZsaWdodChtX3VybCk7CiB9CiAKIHZvaWQgRXZlbnRTb3VyY2U6OmVuZFJlcXVlc3QoKQpA QCAtMTI4LDkgKzEyNSw2IEBACiAgICAgaWYgKCFtX2ZhaWxTaWxlbnRseSkKICAgICAgICAgZGlz cGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5lcnJvckV2ZW50LCBmYWxzZSwg ZmFsc2UpKTsKIAotICAgIGlmICghc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc1dvcmtlckNv bnRleHQoKSkKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBs ZXRlKG1fdXJsKTsKLQogICAgIGlmIChtX3N0YXRlICE9IENMT1NFRCkKICAgICAgICAgc2NoZWR1 bGVSZWNvbm5lY3QoKTsKICAgICBlbHNlCkluZGV4OiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0JKHJldmlzaW9uIDY3NzIyKQorKysg V2ViQ29yZS9HTlVtYWtlZmlsZS5hbQkod29ya2luZyBjb3B5KQpAQCAtMTg0Myw2ICsxODQzLDgg QEAKIAlXZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmggXAogCVdlYkNvcmUvbG9hZGVy L05ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyLmNwcCBcCiAJV2ViQ29yZS9sb2FkZXIvTmV0c2Nh cGVQbHVnSW5TdHJlYW1Mb2FkZXIuaCBcCisJV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25M aW1pdGVyLmNwcCBcCisJV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmggXAog CVdlYkNvcmUvbG9hZGVyL1BpbmdMb2FkZXIuY3BwIFwKIAlXZWJDb3JlL2xvYWRlci9QaW5nTG9h ZGVyLmggXAogCVdlYkNvcmUvbG9hZGVyL1BsYWNlaG9sZGVyRG9jdW1lbnQuY3BwIFwKSW5kZXg6 IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5neXBp CShyZXZpc2lvbiA2NzcyMikKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3b3JraW5nIGNvcHkp CkBAIC0xOTUzLDYgKzE5NTMsOCBAQAogICAgICAgICAgICAgJ2xvYWRlci9OYXZpZ2F0aW9uQWN0 aW9uLmgnLAogICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5j cHAnLAogICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5oJywK KyAgICAgICAgICAgICdsb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCcsCisgICAgICAg ICAgICAnbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5oJywKICAgICAgICAgICAgICdsb2Fk ZXIvUGluZ0xvYWRlci5jcHAnLAogICAgICAgICAgICAgJ2xvYWRlci9QaW5nTG9hZGVyLmgnLAog ICAgICAgICAgICAgJ2xvYWRlci9QbGFjZWhvbGRlckRvY3VtZW50LmNwcCcsCkluZGV4OiBXZWJD b3JlL0NNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ01ha2VMaXN0cy50eHQJ KHJldmlzaW9uIDY3NzIyKQorKysgV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAkod29ya2luZyBjb3B5 KQpAQCAtMTEwNCw2ICsxMTA0LDcgQEAKICAgICBsb2FkZXIvTWFpblJlc291cmNlTG9hZGVyLmNw cAogICAgIGxvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcAogICAgIGxvYWRlci9OZXRzY2FwZVBs dWdJblN0cmVhbUxvYWRlci5jcHAKKyAgICBsb2FkZXIvT3BlbkNvbm5lY3Rpb25Mb2FkZXIuY3Bw CiAgICAgbG9hZGVyL1BpbmdMb2FkZXIuY3BwCiAgICAgbG9hZGVyL1BsYWNlaG9sZGVyRG9jdW1l bnQuY3BwCiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNrLmNwcApJbmRleDogV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDY3NzIyKQorKysgV2ViQ29y ZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTUx ODIsNiArNTE4Miw4IEBACiAJCUQwN0RFQUJBMEEzNjU1NEEwMENBMzBGOCAvKiBJbnNlcnRMaXN0 Q29tbWFuZC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RDA3REVBQjgwQTM2NTU0QTAwQ0EzMEY4IC8qIEluc2VydExpc3RDb21tYW5kLmggKi87IH07CiAJ CUQwODZGRTk4MDlENTNBQUIwMDVCQzc0RCAvKiBVbmxpbmtDb21tYW5kLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMDg2RkU5NjA5RDUzQUFCMDA1QkM3 NEQgLyogVW5saW5rQ29tbWFuZC5oICovOyB9OwogCQlEMDg2RkU5OTA5RDUzQUFCMDA1QkM3NEQg LyogVW5saW5rQ29tbWFuZC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBEMDg2RkU5NzA5RDUzQUFCMDA1QkM3NEQgLyogVW5saW5rQ29tbWFuZC5jcHAg Ki87IH07CisJCUQwQjAyOEE2MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0 ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwQjAy OEE0MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCAqLzsgfTsKKwkJ RDBCMDI4QTcxMjQxMjE4NTAwOUQ1MTlFIC8qIE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMEIwMjhBNTEyNDEy MTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCAqLzsgfTsKIAkJRDBCMDU1 NjgwOUM2NzAwMTAwMzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMEIwNTU2NjA5QzY3MDAxMDAzMDdFNDMg LyogQ3JlYXRlTGlua0NvbW1hbmQuaCAqLzsgfTsKIAkJRDBCMDU1NjkwOUM2NzAwMTAwMzA3RTQz IC8qIENyZWF0ZUxpbmtDb21tYW5kLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEQwQjA1NTY3MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29t bWFuZC5jcHAgKi87IH07CiAJCUQwRkYyQTVEMTFGOEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVy LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwRkYy QTVCMTFGOEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVyLmNwcCAqLzsgfTsKQEAgLTExMDM5LDYg KzExMDQxLDggQEAKIAkJRDA3REVBQjgwQTM2NTU0QTAwQ0EzMEY4IC8qIEluc2VydExpc3RDb21t YW5kLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNlcnRMaXN0Q29tbWFu ZC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMDg2RkU5NjA5RDUzQUFCMDA1QkM3 NEQgLyogVW5saW5rQ29tbWFuZC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBV bmxpbmtDb21tYW5kLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUQwODZGRTk3MDlE NTNBQUIwMDVCQzc0RCAvKiBVbmxpbmtDb21tYW5kLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IFVubGlua0NvbW1hbmQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQlEMEIwMjhBNDEyNDEyMTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVy LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9wZW5Db25uZWN0aW9uTGltaXRl ci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlEMEIwMjhBNTEyNDEyMTg1MDA5RDUx OUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUQwQjA1NTY2MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFu ZC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDcmVhdGVMaW5rQ29tbWFuZC5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMEIwNTU2NzA5QzY3MDAxMDAzMDdFNDMg LyogQ3JlYXRlTGlua0NvbW1hbmQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gQ3JlYXRlTGlua0NvbW1hbmQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlEMEZGMkE1QjExRjhDNDVBMDA3RTc0RTAgLyogUGluZ0xvYWRlci5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQaW5nTG9hZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKQEAgLTE2NjgzLDYgKzE2Njg3LDggQEAKIAkJCQkwQjkwNTYxODBGMjU3OEJF MDA5NUZGNkEgLyogVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oICovLAogCQkJCTBCOTA1NkY2MEYy Njg1RjMwMDk1RkY2QSAvKiBXb3JrZXJUaHJlYWRhYmxlTG9hZGVyLmNwcCAqLywKIAkJCQkwQjkw NTZGNzBGMjY4NUYzMDA5NUZGNkEgLyogV29ya2VyVGhyZWFkYWJsZUxvYWRlci5oICovLAorCQkJ CUQwQjAyOEE0MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCAqLywK KwkJCQlEMEIwMjhBNTEyNDEyMTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNw cCAqLywKIAkJCSk7CiAJCQlwYXRoID0gbG9hZGVyOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsKQEAgLTIwNTY5LDYgKzIwNTc1LDcgQEAKIAkJCQk4MkUzRDhERjEyMkVBMEQxMDAzQUU1QkMg LyogQ1NTUHJvcGVydHlTb3VyY2VEYXRhLmggaW4gSGVhZGVycyAqLywKIAkJCQk4QTMwOUM5RjEy Mzk1MEJFMDBDQjkyMDQgLyogTmVzdGluZ0xldmVsSW5jcmVtZW50ZXIuaCBpbiBIZWFkZXJzICov LAogCQkJCTkzRTJBMzA3MTIzRTlEQzAwMDlGRTEyQSAvKiBIVE1MUGFyc2VySWRpb21zLmggaW4g SGVhZGVycyAqLywKKwkJCQlEMEIwMjhBNjEyNDEyMTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rp b25MaW1pdGVyLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVu dFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTIzMDQ3LDYgKzIzMDU0LDcgQEAKIAkJCQk5 M0UyQTMwNjEyM0U5REMwMDA5RkUxMkEgLyogSFRNTFBhcnNlcklkaW9tcy5jcHAgaW4gU291cmNl cyAqLywKIAkJCQk4OTNDNDdERjEyM0VGNEE5MDAyQjNEODYgLyogSlNEaXJlY3RvcnlFbnRyeUN1 c3RvbS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk4OTNDNDdDQzEyM0VFQkEyMDAyQjNEODYgLyog SlNFbnRyeUN1c3RvbS5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlEMEIwMjhBNzEyNDEyMTg1MDA5 RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsK IAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDog V2ViQ29yZS9BbmRyb2lkLm1rCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQW5kcm9pZC5tawkocmV2 aXNpb24gNjc3MjIpCisrKyBXZWJDb3JlL0FuZHJvaWQubWsJKHdvcmtpbmcgY29weSkKQEAgLTMz Miw2ICszMzIsNyBAQAogCWxvYWRlci9NYWluUmVzb3VyY2VMb2FkZXIuY3BwIFwKIAlsb2FkZXIv TmF2aWdhdGlvbkFjdGlvbi5jcHAgXAogCWxvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRl ci5jcHAgXAorCWxvYWRlci9PcGVuQ29ubmVjdGlvbkxpbWl0ZXIuY3BwIFwKIAlsb2FkZXIvUGlu Z0xvYWRlci5jcHAgXAogCWxvYWRlci9QbGFjZWhvbGRlckRvY3VtZW50LmNwcCBcCiAJbG9hZGVy L1BvbGljeUNhbGxiYWNrLmNwcCBcCkluZGV4OiBXZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCShyZXZpc2lv biA2NzcyMikKKysrIFdlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMTc5LDcgKzE3OSw2IEBACiAgICAgLCBtX3VwbG9hZEV2ZW50c0FsbG93ZWQodHJ1ZSkK ICAgICAsIG1fdXBsb2FkQ29tcGxldGUoZmFsc2UpCiAgICAgLCBtX3NhbWVPcmlnaW5SZXF1ZXN0 KHRydWUpCi0gICAgLCBtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QoZmFsc2UpCiAgICAgLCBt X3JlY2VpdmVkTGVuZ3RoKDApCiAgICAgLCBtX2xhc3RTZW5kTGluZU51bWJlcigwKQogICAgICwg bV9leGNlcHRpb25Db2RlKDApCkBAIC0xOTMsMTAgKzE5Miw2IEBACiAKIFhNTEh0dHBSZXF1ZXN0 Ojp+WE1MSHR0cFJlcXVlc3QoKQogewotICAgIGlmIChtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVl c3QpIHsKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRl KG1fdXJsKTsKLSAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gZmFsc2U7Ci0g ICAgfQogICAgIGlmIChtX3VwbG9hZCkKICAgICAgICAgbV91cGxvYWQtPmRpc2Nvbm5lY3RYTUxI dHRwUmVxdWVzdCgpOwogCkBAIC02MTcsMTYgKzYxMiw2IEBACiAgICAgICAgICAgICAvLyBhIHJl cXVlc3QgaXMgaW4gcHJvZ3Jlc3MgYmVjYXVzZSB3ZSBuZWVkIHRvIGtlZXAgdGhlIGxpc3RlbmVy cyBhbGl2ZSwKICAgICAgICAgICAgIC8vIGFuZCB0aGV5IGFyZSByZWZlcmVuY2VkIGJ5IHRoZSBK YXZhU2NyaXB0IHdyYXBwZXIuCiAgICAgICAgICAgICBzZXRQZW5kaW5nQWN0aXZpdHkodGhpcyk7 Ci0KLSAgICAgICAgICAgIC8vIEZvciBub3cgd2Ugc2hvdWxkIG9ubHkgYmFsYW5jZSB0aGUgbm9u Q2FjaGVkIHJlcXVlc3QgY291bnQgZm9yIG1haW4tdGhyZWFkIFhIUnMgYW5kIG5vdAotICAgICAg ICAgICAgLy8gV29ya2VyIFhIUnMsIGFzIHRoZSBDYWNoZSBpcyBub3QgdGhyZWFkLXNhZmUuCi0g ICAgICAgICAgICAvLyBUaGlzIHdpbGwgYmVjb21lIGlycmVsZXZhbnQgYWZ0ZXIgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3MTY1IGlzIHJlc29sdmVkLgotICAgICAg ICAgICAgaWYgKCFzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyQ29udGV4dCgpKSB7 Ci0gICAgICAgICAgICAgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKLSAgICAgICAgICAgICAg ICBBU1NFUlQoIW1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCk7Ci0gICAgICAgICAgICAgICAg Y2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdEluRmxpZ2h0KG1fdXJsKTsKLSAgICAg ICAgICAgICAgICBtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QgPSB0cnVlOwotICAgICAgICAg ICAgfQogICAgICAgICB9CiAgICAgfSBlbHNlCiAgICAgICAgIFRocmVhZGFibGVMb2FkZXI6Omxv YWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCByZXF1ZXN0 LCAqdGhpcywgb3B0aW9ucyk7CkBAIC05MTgsMTAgKzkwMyw2IEBACiAKIHZvaWQgWE1MSHR0cFJl cXVlc3Q6OmRpZEZhaWwoY29uc3QgUmVzb3VyY2VFcnJvciYgZXJyb3IpCiB7Ci0gICAgaWYgKG1f ZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCkgewotICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+ bm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUobV91cmwpOwotICAgICAgICBtX2RpZFRlbGxMb2FkZXJB Ym91dFJlcXVlc3QgPSBmYWxzZTsKLSAgICB9CiAKICAgICAvLyBJZiB3ZSBhcmUgYWxyZWFkeSBp biBhbiBlcnJvciBzdGF0ZSwgZm9yIGluc3RhbmNlIHdlIGNhbGxlZCBhYm9ydCgpLCBiYWlsIG91 dCBlYXJseS4KICAgICBpZiAobV9lcnJvcikKQEAgLTk0OCwxMSArOTI5LDYgQEAKIAogdm9pZCBY TUxIdHRwUmVxdWVzdDo6ZGlkRmluaXNoTG9hZGluZyh1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIp CiB7Ci0gICAgaWYgKG1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCkgewotICAgICAgICBjYWNo ZSgpLT5sb2FkZXIoKS0+bm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUobV91cmwpOwotICAgICAgICBt X2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QgPSBmYWxzZTsKLSAgICB9Ci0KICAgICBpZiAobV9l cnJvcikKICAgICAgICAgcmV0dXJuOwogCkluZGV4OiBXZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVz dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmgJKHJldmlzaW9u IDY3NzIyKQorKysgV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuaAkod29ya2luZyBjb3B5KQpA QCAtMTkxLDcgKzE5MSw2IEBACiAgICAgYm9vbCBtX3VwbG9hZENvbXBsZXRlOwogCiAgICAgYm9v bCBtX3NhbWVPcmlnaW5SZXF1ZXN0OwotICAgIGJvb2wgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1 ZXN0OwogCiAgICAgLy8gVXNlZCBmb3Igb25wcm9ncmVzcyB0cmFja2luZwogICAgIGxvbmcgbG9u ZyBtX3JlY2VpdmVkTGVuZ3RoOwpJbmRleDogV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmgJKHJldmlzaW9uIDY3NzIyKQorKysgV2Vi Q29yZS9sb2FkZXIvbG9hZGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTU0LDkgKzU0LDYgQEAKICAg ICAgICAgYm9vbCBpc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMoKSB7IHJldHVybiBtX2lzU3Vz cGVuZGluZ1BlbmRpbmdSZXF1ZXN0czsgfQogICAgICAgICB2b2lkIHN1c3BlbmRQZW5kaW5nUmVx dWVzdHMoKTsKICAgICAgICAgdm9pZCByZXN1bWVQZW5kaW5nUmVxdWVzdHMoKTsKLSAgICAgICAg Ci0gICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0SW5GbGlnaHQoY29uc3QgS1VSTCYpOwotICAg ICAgICB2b2lkIG5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKGNvbnN0IEtVUkwmKTsKIAogICAgIHBy aXZhdGU6CiAgICAgICAgIFByaW9yaXR5IGRldGVybWluZVByaW9yaXR5KGNvbnN0IENhY2hlZFJl c291cmNlKikgY29uc3Q7CkBAIC02NiwyNCArNjMsMjIgQEAKIAogICAgICAgICBjbGFzcyBIb3N0 IDogcHVibGljIFJlZkNvdW50ZWQ8SG9zdD4sIHByaXZhdGUgU3VicmVzb3VyY2VMb2FkZXJDbGll bnQgewogICAgICAgICBwdWJsaWM6Ci0gICAgICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxIb3N0 PiBjcmVhdGUoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0lu RmxpZ2h0KSAKKyAgICAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEhvc3Q+IGNyZWF0ZShjb25z dCBBdG9taWNTdHJpbmcmIG5hbWUpIAogICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIHJl dHVybiBhZG9wdFJlZihuZXcgSG9zdChuYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0KSk7CisgICAg ICAgICAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBIb3N0KG5hbWUpKTsKICAgICAgICAgICAg IH0KICAgICAgICAgICAgIH5Ib3N0KCk7CiAgICAgICAgICAgICAKICAgICAgICAgICAgIGNvbnN0 IEF0b21pY1N0cmluZyYgbmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fbmFtZTsgfQogICAgICAgICAg ICAgdm9pZCBhZGRSZXF1ZXN0KFJlcXVlc3QqLCBQcmlvcml0eSk7Ci0gICAgICAgICAgICB2b2lk IG5vbkNhY2hlUmVxdWVzdEluRmxpZ2h0KCk7Ci0gICAgICAgICAgICB2b2lkIG5vbkNhY2hlUmVx dWVzdENvbXBsZXRlKCk7CiAgICAgICAgICAgICB2b2lkIHNlcnZlUGVuZGluZ1JlcXVlc3RzKFBy aW9yaXR5IG1pbmltdW1Qcmlvcml0eSA9IFZlcnlMb3cpOwogICAgICAgICAgICAgdm9pZCBjYW5j ZWxSZXF1ZXN0cyhDYWNoZWRSZXNvdXJjZUxvYWRlciopOwogICAgICAgICAgICAgYm9vbCBoYXNS ZXF1ZXN0cygpIGNvbnN0OwogCi0gICAgICAgICAgICBib29sIHByb2Nlc3NpbmdSZXNvdXJjZSgp IGNvbnN0IHsgcmV0dXJuIG1fbnVtUmVzb3VyY2VzUHJvY2Vzc2luZyAhPSAwIHx8IG1fbm9uQ2Fj aGVkUmVxdWVzdHNJbkZsaWdodCAhPTA7IH0KKyAgICAgICAgICAgIGJvb2wgcHJvY2Vzc2luZ1Jl c291cmNlKCkgY29uc3QgeyByZXR1cm4gbV9udW1SZXNvdXJjZXNQcm9jZXNzaW5nOyB9CiAKICAg ICAgICAgcHJpdmF0ZToKLSAgICAgICAgICAgIEhvc3QoY29uc3QgQXRvbWljU3RyaW5nJiwgdW5z aWduZWQpOworICAgICAgICAgICAgSG9zdChjb25zdCBBdG9taWNTdHJpbmcmKTsKIAogICAgICAg ICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShTdWJyZXNvdXJjZUxvYWRlcios IGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsKICAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRS ZWNlaXZlRGF0YShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IGNoYXIqLCBpbnQpOwpAQCAtOTIs NyArODcsNyBAQAogICAgICAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VM b2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJik7CiAgICAgICAgICAgICAKICAgICAgICAgICAg IHR5cGVkZWYgRGVxdWU8UmVxdWVzdCo+IFJlcXVlc3RRdWV1ZTsKLSAgICAgICAgICAgIHZvaWQg c2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcsIGJvb2wm IHNlcnZlTG93ZXJQcmlvcml0eSk7CisgICAgICAgICAgICB2b2lkIHNlcnZlUGVuZGluZ1JlcXVl c3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nKTsKICAgICAgICAgICAgIHZvaWQgZGlk RmFpbChTdWJyZXNvdXJjZUxvYWRlciosIGJvb2wgY2FuY2VsbGVkID0gZmFsc2UpOwogICAgICAg ICAgICAgdm9pZCBjYW5jZWxQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1Bl bmRpbmcsIENhY2hlZFJlc291cmNlTG9hZGVyKik7CiAgICAgICAgICAgICAKQEAgLTEwMCw5ICs5 NSw3IEBACiAgICAgICAgICAgICB0eXBlZGVmIEhhc2hNYXA8UmVmUHRyPFN1YnJlc291cmNlTG9h ZGVyPiwgUmVxdWVzdCo+IFJlcXVlc3RNYXA7CiAgICAgICAgICAgICBSZXF1ZXN0TWFwIG1fcmVx dWVzdHNMb2FkaW5nOwogICAgICAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nIG1fbmFtZTsKLSAg ICAgICAgICAgIGNvbnN0IGludCBtX21heFJlcXVlc3RzSW5GbGlnaHQ7CiAgICAgICAgICAgICBp bnQgbV9udW1SZXNvdXJjZXNQcm9jZXNzaW5nOwotICAgICAgICAgICAgaW50IG1fbm9uQ2FjaGVk UmVxdWVzdHNJbkZsaWdodDsKICAgICAgICAgfTsKICAgICAgICAgdHlwZWRlZiBIYXNoTWFwPEF0 b21pY1N0cmluZ0ltcGwqLCBSZWZQdHI8SG9zdD4gPiBIb3N0TWFwOwogICAgICAgICBIb3N0TWFw IG1faG9zdHM7CkluZGV4OiBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRlci5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwCShyZXZpc2lvbiA2Nzcy MikKKysrIFdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpA QCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCiAjaW5jbHVk ZSAiSW5zcGVjdG9yQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkluc3BlY3RvclRpbWVsaW5lQWdl bnQuaCIKKyNpbmNsdWRlICJPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCIKICNpbmNsdWRlICJQYWdl LmgiCiAjaW5jbHVkZSAiUHJvZ3Jlc3NUcmFja2VyLmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5k bGUuaCIKQEAgLTY5LDYgKzcwLDcgQEAKICAgICAsIG1fc2hvdWxkQ29udGVudFNuaWZmKHNob3Vs ZENvbnRlbnRTbmlmZikKICAgICAsIG1fc2hvdWxkQnVmZmVyRGF0YSh0cnVlKQogICAgICwgbV9k ZWZlcnNMb2FkaW5nKGZyYW1lLT5wYWdlKCktPmRlZmVyc0xvYWRpbmcoKSkKKyAgICAsIG1fdGhy b3R0bGVSZXRyeVRpbWVyKHRoaXMsICZSZXNvdXJjZUxvYWRlcjo6dGhyb3R0bGVSZXRyeVRpbWVy RmlyZWQpCiB7CiB9CiAKQEAgLTg3LDYgKzg5LDggQEAKICAgICAvLyBoYXMgYmVlbiBkZWFsbG9j YXRlZCBhbmQgYWxzbyB0byBhdm9pZCByZWVudGVyaW5nIHRoaXMgbWV0aG9kLgogICAgIFJlZlB0 cjxSZXNvdXJjZUxvYWRlcj4gcHJvdGVjdG9yKHRoaXMpOwogCisgICAgT3BlbkNvbm5lY3Rpb25M aW1pdGVyOjpkZWNyZW1lbnRIb3N0UmVxdWVzdENvdW50KG1fcmVxdWVzdC51cmwoKSk7CisKICAg ICBtX2ZyYW1lID0gMDsKICAgICBtX2RvY3VtZW50TG9hZGVyID0gMDsKICAgICAKQEAgLTEwOCwx MyArMTEyLDI3IEBACiAgICAgbV9kZWZlcnJlZFJlcXVlc3QgPSBSZXNvdXJjZVJlcXVlc3QoKTsK IH0KIAordm9pZCBSZXNvdXJjZUxvYWRlcjo6dGhyb3R0bGVSZXRyeVRpbWVyRmlyZWQoVGltZXI8 UmVzb3VyY2VMb2FkZXI+KikKK3sKKyAgICBBU1NFUlQoIW1fZGVmZXJyZWRSZXF1ZXN0LmlzTnVs bCgpKTsKKyAgICBzZXREZWZlcnNMb2FkaW5nKGZhbHNlKTsKK30KKwogYm9vbCBSZXNvdXJjZUxv YWRlcjo6bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHIpCiB7CiAgICAgQVNTRVJUKCFtX2hh bmRsZSk7CiAgICAgQVNTRVJUKG1fZGVmZXJyZWRSZXF1ZXN0LmlzTnVsbCgpKTsKICAgICBBU1NF UlQoIW1fZG9jdW1lbnRMb2FkZXItPmlzU3Vic3RpdHV0ZUxvYWRQZW5kaW5nKHRoaXMpKTsKKyAg ICBBU1NFUlQoIW1fdGhyb3R0bGVSZXRyeVRpbWVyLmlzQWN0aXZlKCkpOwogICAgIAogICAgIFJl c291cmNlUmVxdWVzdCBjbGllbnRSZXF1ZXN0KHIpOworCisgICAgaWYgKE9wZW5Db25uZWN0aW9u TGltaXRlcjo6c2hvdWxkVGhyb3R0bGVSZXF1ZXN0KGNsaWVudFJlcXVlc3QudXJsKCkpKSB7Cisg ICAgICAgIG1fZGVmZXJyZWRSZXF1ZXN0ID0gY2xpZW50UmVxdWVzdDsKKyAgICAgICAgc2V0RGVm ZXJzTG9hZGluZyh0cnVlKTsKKyAgICAgICAgbV90aHJvdHRsZVJldHJ5VGltZXIuc3RhcnRPbmVT aG90KDApOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CiAgICAgCiAgICAgLy8gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2MzkxCiAgICAgLy8gVGhlIHZhcmlv dXMgcGx1Zy1pbiBpbXBsZW1lbnRhdGlvbnMgY2FsbCBkaXJlY3RseSB0byBSZXNvdXJjZUxvYWRl cjo6bG9hZCgpIGluc3RlYWQgb2YgcGlwaW5nIHJlcXVlc3RzCkBAIC0yMjMsNiArMjQxLDEwIEBA CiAKICAgICAgICAgZnJhbWVMb2FkZXIoKS0+bm90aWZpZXIoKS0+d2lsbFNlbmRSZXF1ZXN0KHRo aXMsIHJlcXVlc3QsIHJlZGlyZWN0UmVzcG9uc2UpOwogICAgIH0KKyAgICAKKyAgICBPcGVuQ29u bmVjdGlvbkxpbWl0ZXI6OmluY3JlbWVudEhvc3RSZXF1ZXN0Q291bnQocmVxdWVzdC51cmwoKSk7 CisgICAgaWYgKCFyZWRpcmVjdFJlc3BvbnNlLmlzTnVsbCgpKQorICAgICAgICBPcGVuQ29ubmVj dGlvbkxpbWl0ZXI6OmRlY3JlbWVudEhvc3RSZXF1ZXN0Q291bnQocmVkaXJlY3RSZXNwb25zZS51 cmwoKSk7CiAKICAgICBtX3JlcXVlc3QgPSByZXF1ZXN0OwogfQpJbmRleDogV2ViQ29yZS9sb2Fk ZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIv T3BlbkNvbm5lY3Rpb25MaW1pdGVyLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL2xvYWRlci9P cGVuQ29ubmVjdGlvbkxpbWl0ZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0NiBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBk aXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5v ciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3Jz ZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICoKKyAqLworCisj aW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK2NsYXNz IEtVUkw7CisKK2NsYXNzIE9wZW5Db25uZWN0aW9uTGltaXRlciA6IHB1YmxpYyBOb25jb3B5YWJs ZSB7CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgaW5jcmVtZW50SG9zdFJlcXVlc3RDb3VudChj b25zdCBLVVJMJik7CisgICAgc3RhdGljIHZvaWQgZGVjcmVtZW50SG9zdFJlcXVlc3RDb3VudChj b25zdCBLVVJMJik7CisgICAgc3RhdGljIGJvb2wgc2hvdWxkVGhyb3R0bGVSZXF1ZXN0KGNvbnN0 IEtVUkwmKTsKK3ByaXZhdGU6CisgICAgT3BlbkNvbm5lY3Rpb25MaW1pdGVyKCk7CisgICAgfk9w ZW5Db25uZWN0aW9uTGltaXRlcigpOworfTsKK30KSW5kZXg6IFdlYkNvcmUvbG9hZGVyL1Jlc291 cmNlTG9hZGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIu aAkocmV2aXNpb24gNjc3MjIpCisrKyBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRlci5oCSh3 b3JraW5nIGNvcHkpCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQu aD4KICNpbmNsdWRlICJBdXRoZW50aWNhdGlvbkNoYWxsZW5nZS5oIgogI2luY2x1ZGUgIktVUkwu aCIKKyNpbmNsdWRlICJUaW1lci5oIgogCiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KIApAQCAt MTQ4LDYgKzE0OSw4IEBACiAgICAgICAgIFJlc291cmNlUmVzcG9uc2UgbV9yZXNwb25zZTsKICAg ICAgICAgCiAgICAgcHJpdmF0ZToKKyAgICAgICAgdm9pZCB0aHJvdHRsZVJldHJ5VGltZXJGaXJl ZChUaW1lcjxSZXNvdXJjZUxvYWRlcj4qKTsKKwogICAgICAgICBSZXNvdXJjZVJlcXVlc3QgbV9y ZXF1ZXN0OwogICAgICAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBtX3Jlc291cmNlRGF0YTsKICAg ICAgICAgCkBAIC0xNjIsNiArMTY1LDggQEAKICAgICAgICAgYm9vbCBtX3Nob3VsZEJ1ZmZlckRh dGE7CiAgICAgICAgIGJvb2wgbV9kZWZlcnNMb2FkaW5nOwogICAgICAgICBSZXNvdXJjZVJlcXVl c3QgbV9kZWZlcnJlZFJlcXVlc3Q7CisgICAgICAgIAorICAgICAgICBUaW1lcjxSZXNvdXJjZUxv YWRlcj4gbV90aHJvdHRsZVJldHJ5VGltZXI7CiAgICAgfTsKIAogfQpJbmRleDogV2ViQ29yZS9s b2FkZXIvbG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3Bw CShyZXZpc2lvbiA2NzcyMikKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTQyLDI5ICs0MiwxNSBAQAogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCi0jZGVmaW5lIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFC TEVEIDEKICNkZWZpbmUgUkVRVUVTVF9ERUJVRyAwCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot I2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECi0vLyBNYXRjaCB0aGUgcGFyYWxsZWwgY29u bmVjdGlvbiBjb3VudCB1c2VkIGJ5IHRoZSBuZXR3b3JraW5nIGxheWVyCi1zdGF0aWMgdW5zaWdu ZWQgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3Q7Ci0vLyBIYXZpbmcgYSBsaW1pdCBtaWdodCBz dGlsbCBoZWxwIGdldHRpbmcgbW9yZSBpbXBvcnRhbnQgcmVzb3VyY2VzIGZpcnN0Ci1zdGF0aWMg Y29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAy MDsKLSNlbHNlCi1zdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhv c3QgPSAxMDAwMDsKLXN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9y Tm9uSFRUUFByb3RvY29scyA9IDEwMDAwOwotI2VuZGlmCi0KIExvYWRlcjo6TG9hZGVyKCkKICAg ICA6IG1fcmVxdWVzdFRpbWVyKHRoaXMsICZMb2FkZXI6OnJlcXVlc3RUaW1lckZpcmVkKQogICAg ICwgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMoZmFsc2UpCiB7Ci0gICAgbV9ub25IVFRQ UHJvdG9jb2xIb3N0ID0gSG9zdDo6Y3JlYXRlKEF0b21pY1N0cmluZygpLCBtYXhSZXF1ZXN0c0lu RmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29scyk7Ci0jaWYgUkVRVUVTVF9NQU5BR0VNRU5UX0VOQUJM RUQKLSAgICBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCA9IGluaXRpYWxpemVNYXhpbXVtSFRU UENvbm5lY3Rpb25Db3VudFBlckhvc3QoKTsKLSNlbmRpZgorICAgIG1fbm9uSFRUUFByb3RvY29s SG9zdCA9IEhvc3Q6OmNyZWF0ZShBdG9taWNTdHJpbmcoKSk7CiB9CiAKIExvYWRlcjo6fkxvYWRl cigpCkBAIC05Nyw3ICs4Myw2IEBACiAKIExvYWRlcjo6UHJpb3JpdHkgTG9hZGVyOjpkZXRlcm1p bmVQcmlvcml0eShjb25zdCBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UpIGNvbnN0CiB7Ci0jaWYg UkVRVUVTVF9NQU5BR0VNRU5UX0VOQUJMRUQKICAgICBzd2l0Y2ggKHJlc291cmNlLT50eXBlKCkp IHsKICAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJjZTo6Q1NTU3R5bGVTaGVldDoKICNpZiBFTkFC TEUoWFNMVCkKQEAgLTExNiw5ICsxMDEsNiBAQAogICAgIH0KICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKICAgICByZXR1cm4gTG93OwotI2Vsc2UKLSAgICByZXR1cm4gSGlnaDsKLSNlbmRpZgog fQogCiB2b2lkIExvYWRlcjo6bG9hZChDYWNoZWRSZXNvdXJjZUxvYWRlciogY2FjaGVkUmVzb3Vy Y2VMb2FkZXIsIENhY2hlZFJlc291cmNlKiByZXNvdXJjZSwgYm9vbCBpbmNyZW1lbnRhbCwgU2Vj dXJpdHlDaGVja1BvbGljeSBzZWN1cml0eUNoZWNrLCBib29sIHNlbmRSZXNvdXJjZUxvYWRDYWxs YmFja3MpCkBAIC0xMzMsNyArMTE1LDcgQEAKICAgICAgICAgQXRvbWljU3RyaW5nIGhvc3ROYW1l ID0gdXJsLmhvc3QoKTsKICAgICAgICAgaG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lLmltcGwo KSk7CiAgICAgICAgIGlmICghaG9zdCkgewotICAgICAgICAgICAgaG9zdCA9IEhvc3Q6OmNyZWF0 ZShob3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOworICAgICAgICAgICAgaG9z dCA9IEhvc3Q6OmNyZWF0ZShob3N0TmFtZSk7CiAgICAgICAgICAgICBtX2hvc3RzLmFkZChob3N0 TmFtZS5pbXBsKCksIGhvc3QpOwogICAgICAgICB9CiAgICAgfSBlbHNlIApAQCAtMjEyLDM3ICsx OTQsNiBAQAogICAgICAgICBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CiB9CiAKLXZv aWQgTG9hZGVyOjpub25DYWNoZVJlcXVlc3RJbkZsaWdodChjb25zdCBLVVJMJiB1cmwpCi17Ci0g ICAgaWYgKCF1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkKLSAgICAgICAgcmV0dXJuOwotICAg IAotICAgIEF0b21pY1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7Ci0gICAgbV9ob3N0cy5j aGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgUmVmUHRyPEhvc3Q+IGhvc3QgPSBtX2hvc3RzLmdldCho b3N0TmFtZS5pbXBsKCkpOwotICAgIGlmICghaG9zdCkgewotICAgICAgICBob3N0ID0gSG9zdDo6 Y3JlYXRlKGhvc3ROYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCk7Ci0gICAgICAgIG1f aG9zdHMuYWRkKGhvc3ROYW1lLmltcGwoKSwgaG9zdCk7Ci0gICAgfQotCi0gICAgaG9zdC0+bm9u Q2FjaGVSZXF1ZXN0SW5GbGlnaHQoKTsKLX0KLQotdm9pZCBMb2FkZXI6Om5vbkNhY2hlUmVxdWVz dENvbXBsZXRlKGNvbnN0IEtVUkwmIHVybCkKLXsKLSAgICBpZiAoIXVybC5wcm90b2NvbEluSFRU UEZhbWlseSgpKQotICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgQXRvbWljU3RyaW5nIGhvc3RO YW1lID0gdXJsLmhvc3QoKTsKLSAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3koKTsKLSAgICBS ZWZQdHI8SG9zdD4gaG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lLmltcGwoKSk7Ci0gICAgQVNT RVJUKGhvc3QpOwotICAgIGlmICghaG9zdCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgaG9zdC0+ bm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUoKTsKLX0KLQogdm9pZCBMb2FkZXI6OmNhbmNlbFJlcXVl c3RzKENhY2hlZFJlc291cmNlTG9hZGVyKiBjYWNoZWRSZXNvdXJjZUxvYWRlcikKIHsKICAgICBj YWNoZWRSZXNvdXJjZUxvYWRlci0+Y2xlYXJQZW5kaW5nUHJlbG9hZHMoKTsKQEAgLTI2OCwxMSAr MjE5LDkgQEAKICAgICBBU1NFUlQoY2FjaGVkUmVzb3VyY2VMb2FkZXItPnJlcXVlc3RDb3VudCgp ID09IChjYWNoZWRSZXNvdXJjZUxvYWRlci0+bG9hZEluUHJvZ3Jlc3MoKSA/IDEgOiAwKSk7CiB9 CiAKLUxvYWRlcjo6SG9zdDo6SG9zdChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIHVuc2lnbmVk IG1heFJlcXVlc3RzSW5GbGlnaHQpCitMb2FkZXI6Okhvc3Q6Okhvc3QoY29uc3QgQXRvbWljU3Ry aW5nJiBuYW1lKQogICAgIDogbV9uYW1lKG5hbWUpCi0gICAgLCBtX21heFJlcXVlc3RzSW5GbGln aHQobWF4UmVxdWVzdHNJbkZsaWdodCkKICAgICAsIG1fbnVtUmVzb3VyY2VzUHJvY2Vzc2luZygw KQotICAgICwgbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0KDApCiB7CiB9CiAKQEAgLTI4Nywy MCArMjM2LDcgQEAKIHsKICAgICBtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0uYXBwZW5kKHJl cXVlc3QpOwogfQotICAgIAotdm9pZCBMb2FkZXI6Okhvc3Q6Om5vbkNhY2hlUmVxdWVzdEluRmxp Z2h0KCkKLXsKLSAgICArK21fbm9uQ2FjaGVkUmVxdWVzdHNJbkZsaWdodDsKLX0KIAotdm9pZCBM b2FkZXI6Okhvc3Q6Om5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKCkKLXsKLSAgICAtLW1fbm9uQ2Fj aGVkUmVxdWVzdHNJbkZsaWdodDsKLSAgICBBU1NFUlQobV9ub25DYWNoZWRSZXF1ZXN0c0luRmxp Z2h0ID49IDApOwotCi0gICAgY2FjaGUoKS0+bG9hZGVyKCktPnNjaGVkdWxlU2VydmVQZW5kaW5n UmVxdWVzdHMoKTsKLX0KLQogYm9vbCBMb2FkZXI6Okhvc3Q6Omhhc1JlcXVlc3RzKCkgY29uc3QK IHsKICAgICBpZiAoIW1fcmVxdWVzdHNMb2FkaW5nLmlzRW1wdHkoKSkKQEAgLTMxNywyNiArMjUz LDE3IEBACiAgICAgaWYgKGNhY2hlKCktPmxvYWRlcigpLT5pc1N1c3BlbmRpbmdQZW5kaW5nUmVx dWVzdHMoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgYm9vbCBzZXJ2ZU1vcmUgPSB0cnVlOwot ICAgIGZvciAoaW50IHByaW9yaXR5ID0gSGlnaDsgcHJpb3JpdHkgPj0gbWluaW11bVByaW9yaXR5 ICYmIHNlcnZlTW9yZTsgLS1wcmlvcml0eSkKLSAgICAgICAgc2VydmVQZW5kaW5nUmVxdWVzdHMo bV9yZXF1ZXN0c1BlbmRpbmdbcHJpb3JpdHldLCBzZXJ2ZU1vcmUpOworICAgIGZvciAoaW50IHBy aW9yaXR5ID0gSGlnaDsgcHJpb3JpdHkgPj0gbWluaW11bVByaW9yaXR5OyAtLXByaW9yaXR5KQor ICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0p OwogfQogCi12b2lkIExvYWRlcjo6SG9zdDo6c2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1 ZXVlJiByZXF1ZXN0c1BlbmRpbmcsIGJvb2wmIHNlcnZlTG93ZXJQcmlvcml0eSkKK3ZvaWQgTG9h ZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhSZXF1ZXN0UXVldWUmIHJlcXVlc3RzUGVu ZGluZykKIHsKICAgICB3aGlsZSAoIXJlcXVlc3RzUGVuZGluZy5pc0VtcHR5KCkpIHsgICAgICAg IAogICAgICAgICBSZXF1ZXN0KiByZXF1ZXN0ID0gcmVxdWVzdHNQZW5kaW5nLmZpcnN0KCk7CiAg ICAgICAgIENhY2hlZFJlc291cmNlTG9hZGVyKiBjYWNoZWRSZXNvdXJjZUxvYWRlciA9IHJlcXVl c3QtPmNhY2hlZFJlc291cmNlTG9hZGVyKCk7CiAgICAgICAgIGJvb2wgcmVzb3VyY2VJc0NhY2hl VmFsaWRhdG9yID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+aXNDYWNoZVZhbGlkYXRvcigp OwogCi0gICAgICAgIC8vIEZvciBuYW1lZCBob3N0cyAtIHdoaWNoIGFyZSBvbmx5IGh0dHAocykg aG9zdHMgLSB3ZSBzaG91bGQgYWx3YXlzIGVuZm9yY2UgdGhlIGNvbm5lY3Rpb24gbGltaXQuCi0g ICAgICAgIC8vIEZvciBub24tbmFtZWQgaG9zdHMgLSBldmVyeXRoaW5nIGJ1dCBodHRwKHMpIC0g d2Ugc2hvdWxkIG9ubHkgZW5mb3JjZSB0aGUgbGltaXQgaWYgdGhlIGRvY3VtZW50IGlzbid0IGRv bmUgcGFyc2luZyAKLSAgICAgICAgLy8gYW5kIHdlIGRvbid0IGtub3cgYWxsIHN0eWxlc2hlZXRz IHlldC4KLSAgICAgICAgYm9vbCBzaG91bGRMaW1pdFJlcXVlc3RzID0gIW1fbmFtZS5pc051bGwo KSB8fCBjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZG9jKCktPnBhcnNpbmcoKSB8fCAhY2FjaGVkUmVz b3VyY2VMb2FkZXItPmRvYygpLT5oYXZlU3R5bGVzaGVldHNMb2FkZWQoKTsKLSAgICAgICAgaWYg KHNob3VsZExpbWl0UmVxdWVzdHMgJiYgbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpICsgbV9ub25D YWNoZWRSZXF1ZXN0c0luRmxpZ2h0ID49IG1fbWF4UmVxdWVzdHNJbkZsaWdodCkgewotICAgICAg ICAgICAgc2VydmVMb3dlclByaW9yaXR5ID0gZmFsc2U7Ci0gICAgICAgICAgICByZXR1cm47Ci0g ICAgICAgIH0KICAgICAgICAgcmVxdWVzdHNQZW5kaW5nLnJlbW92ZUZpcnN0KCk7CiAgICAgICAg IAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QgcmVzb3VyY2VSZXF1ZXN0KHJlcXVlc3QtPmNhY2hl ZFJlc291cmNlKCktPnVybCgpKTsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9u TGltaXRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25M aW1pdGVyLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9u TGltaXRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTAxIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlv bi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1l cyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21v dGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lm aWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJ UyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAq IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKyNpbmNsdWRlICJPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCIKKworI2luY2x1ZGUg IktVUkwuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNl UmVxdWVzdEJhc2UuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L1N0cmluZ0hhc2guaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworICAgIAorc3RhdGljIHVu c2lnbmVkIHNfbm9uSFRUUFJlcXVlc3RDb3VudCA9IDA7CisKKy8vIEhhdmluZyBhIGxpbWl0IG1p Z2h0IHN0aWxsIGhlbHAgZ2V0dGluZyBtb3JlIGltcG9ydGFudCByZXNvdXJjZXMgZmlyc3QKK3N0 YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29s cyA9IDIwOworCitzdGF0aWMgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QoKQor eworICAgIC8vIE1hdGNoIHRoZSBwYXJhbGxlbCBjb25uZWN0aW9uIGNvdW50IHVzZWQgYnkgdGhl IG5ldHdvcmtpbmcgbGF5ZXIKKyAgICBzdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJ bkZsaWdodFBlckhvc3QgPSBpbml0aWFsaXplTWF4aW11bUhUVFBDb25uZWN0aW9uQ291bnRQZXJI b3N0KCk7CisgICAgcmV0dXJuIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0OworfQorICAgIAor dHlwZWRlZiBIYXNoTWFwPFN0cmluZywgaW50LCBTdHJpbmdIYXNoPiBSZXF1ZXN0c1Blckhvc3RN YXA7CitzdGF0aWMgUmVxdWVzdHNQZXJIb3N0TWFwJiByZXF1ZXN0c1Blckhvc3RNYXAoKQorewor ICAgIERFRklORV9TVEFUSUNfTE9DQUwoUmVxdWVzdHNQZXJIb3N0TWFwLCByZXF1ZXN0c1Blckhv c3RDb3VudCwgKCkpOworICAgIHJlcXVlc3RzUGVySG9zdENvdW50LmNoZWNrQ29uc2lzdGVuY3ko KTsKKyAgICByZXR1cm4gcmVxdWVzdHNQZXJIb3N0Q291bnQ7Cit9CisKK3ZvaWQgT3BlbkNvbm5l Y3Rpb25MaW1pdGVyOjppbmNyZW1lbnRIb3N0UmVxdWVzdENvdW50KGNvbnN0IEtVUkwmIHVybCkK K3sKKyAgICBpZiAoIXVybC5wcm90b2NvbEluSFRUUEZhbWlseSgpKSB7CisgICAgICAgIHNfbm9u SFRUUFJlcXVlc3RDb3VudCsrOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIFN0cmluZyBo b3N0ID0gdXJsLmhvc3QoKTsKKyAgICBpbnQgcmVxdWVzdENvdW50ID0gcmVxdWVzdHNQZXJIb3N0 TWFwKCkuaXNFbXB0eSgpID8gMSA6IHJlcXVlc3RzUGVySG9zdE1hcCgpLmdldChob3N0KSArIDE7 CisgICAgcmVxdWVzdHNQZXJIb3N0TWFwKCkuc2V0KGhvc3QsIHJlcXVlc3RDb3VudCk7Cit9CisK K3ZvaWQgT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpkZWNyZW1lbnRIb3N0UmVxdWVzdENvdW50KGNv bnN0IEtVUkwmIHVybCkKK3sKKyAgICBpZiAoIXVybC5wcm90b2NvbEluSFRUUEZhbWlseSgpKSB7 CisgICAgICAgIEFTU0VSVChzX25vbkhUVFBSZXF1ZXN0Q291bnQgPiAwKTsKKyAgICAgICAgc19u b25IVFRQUmVxdWVzdENvdW50LS07CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgU3RyaW5n IGhvc3QgPSB1cmwuaG9zdCgpOworICAgIEFTU0VSVChyZXF1ZXN0c1Blckhvc3RNYXAoKS5jb250 YWlucyhob3N0KSk7CisgICAgaW50IHJlcXVlc3RDb3VudCA9IHJlcXVlc3RzUGVySG9zdE1hcCgp LmdldChob3N0KSAtIDE7CisgICAgQVNTRVJUKHJlcXVlc3RDb3VudCA+PSAwKTsKKyAgICAKKyAg ICBpZiAocmVxdWVzdENvdW50KQorICAgICAgICByZXF1ZXN0c1Blckhvc3RNYXAoKS5zZXQoaG9z dCwgcmVxdWVzdENvdW50KTsKKyAgICBlbHNlCisgICAgICAgIHJlcXVlc3RzUGVySG9zdE1hcCgp LnJlbW92ZShob3N0KTsKK30KKworYm9vbCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OnNob3VsZFRo cm90dGxlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwpCit7CisgICAgaWYgKCF1cmwucHJvdG9jb2xJ bkhUVFBGYW1pbHkoKSkKKyAgICAgICAgcmV0dXJuIHNfbm9uSFRUUFJlcXVlc3RDb3VudCA+PSBt YXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29sczsKKworICAgIHVuc2lnbmVkIHJl cXVlc3RDb3VudCA9IHJlcXVlc3RzUGVySG9zdE1hcCgpLmlzRW1wdHkoKSA/IDAgOiByZXF1ZXN0 c1Blckhvc3RNYXAoKS5nZXQodXJsLmhvc3QoKSk7CisgICAgcmV0dXJuIHJlcXVlc3RDb3VudCA+ PSBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCg== 68132 2010-09-20 13:56:30 -0700 2010-10-07 11:13:44 -0700 Address comments + don't decrement in releaseResources() if m_request.isNull() ocl2.txt text/plain 31207 japhet SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNjc4NTcpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xMDA1LDYgKzEwMDUsNyBAQAogICAgIGxvYWRlci9NYWluUmVzb3VyY2VMb2FkZXIu Y3BwIFwKICAgICBsb2FkZXIvTmF2aWdhdGlvbkFjdGlvbi5jcHAgXAogICAgIGxvYWRlci9OZXRz Y2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAgXAorICAgIGxvYWRlci9PcGVuQ29ubmVjdGlvbkxp bWl0ZXIuY3BwIFwKICAgICBsb2FkZXIvUGluZ0xvYWRlci5jcHAgXAogICAgIGxvYWRlci9QbGFj ZWhvbGRlckRvY3VtZW50LmNwcCBcCiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNrLmNwcCBcCklu ZGV4OiBXZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL0NoYW5nZUxvZwko cmV2aXNpb24gNjc4NTcpCisrKyBXZWJDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAt MSwzICsxLDUzIEBACisyMDEwLTA5LTE3ICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTW92 ZSBjb25uZWN0aW9uLXBlci1ob3N0IHRyYWNraW5nIGRvd24gYSBsYXllciwgZnJvbSB0aGUKKyAg ICAgICAgY2FjaGUgdG8gUmVzb3VyY2VMb2FkZXIuCisKKyAgICAgICAgTm90ZSB0aGF0IHRoaXMg d2lsbCBzdGlsbCBtaXNzIHNvbWUgcmVxdWVzdHMgKHBpbmdzLCBpY29ucywgZXRjKSwKKyAgICAg ICAgYnV0IGl0IHNob3VsZCBiZSByZWxhdGl2ZWx5IGVhc3kgdG8gbW92ZSBmcm9tIGhlcmUgdG8g UmVzb3VyY2VIYW5kbGUKKyAgICAgICAgaWYgZGVzaXJlZC4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjcxNjUKKworICAgICAgICBSZWZhY3RvciBv bmx5LCBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBBbmRyb2lkLm1rOgorICAgICAgICAqIENN YWtlTGlzdHMudHh0OgorICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIFdlYkNv cmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBXZWJDb3JlLnZjcHJv ai9XZWJDb3JlLnZjcHJvajoKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2o6CisgICAgICAgICogbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5jcHA6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6bWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOgorICAgICAg ICAoV2ViQ29yZTo6cmVxdWVzdHNQZXJIb3N0TWFwKToKKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5D b25uZWN0aW9uTGltaXRlcjo6aW5jcmVtZW50SG9zdFJlcXVlc3RDb3VudCk6CisgICAgICAgIChX ZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmRlY3JlbWVudEhvc3RSZXF1ZXN0Q291bnQp OgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpzaG91bGRUaHJvdHRs ZVJlcXVlc3QpOgorICAgICAgICAqIGxvYWRlci9PcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaDogQWRk ZWQuCisgICAgICAgICogbG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlc291cmNlTG9hZGVyOjpSZXNvdXJjZUxvYWRlcik6CisgICAgICAgIChXZWJDb3JlOjpS ZXNvdXJjZUxvYWRlcjo6cmVsZWFzZVJlc291cmNlcyk6IERlY3JlbWVudCBmb3IgY29tcGxldGVk IHJlcXVlc3QuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRlcjo6dGhyb3R0bGVSZXRy eVRpbWVyRmlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkZXI6OmxvYWQpOiBE ZWZlciBhbmQgc2V0IGEgdGltZXIgaWYgd2UndmUgaGl0IHRoZSBjb25uZWN0aW9uIGxpbWl0Lgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkZXI6OndpbGxTZW5kUmVxdWVzdCk6IEluY3Jl bWVudCBmb3IgbmV3IHJlcXVlc3QsIGRlY3JlbWVudCBmb3IgcmVkaXJlY3QgaWYgbmVjZXNzYXJ5 LgorICAgICAgICAqIGxvYWRlci9SZXNvdXJjZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9s b2FkZXIuY3BwOiBSZW1vdmUgY29ubmVjdGlvbi1wZXItaG9zdCBjb3VudGluZyBjb2RlIChzb21l IGFkZGl0aW9uYWwgY2xlYW51cCB0byBjb21lKS4KKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6 TG9hZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGV0ZXJtaW5lUHJpb3JpdHkpOgor ICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpsb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRl cjo6SG9zdDo6SG9zdCk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhvc3Q6OmFkZFJlcXVl c3QpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0 cyk6CisgICAgICAgICogbG9hZGVyL2xvYWRlci5oOiBSZW1vdmUgY29ubmVjdGlvbi1wZXItaG9z dCBjb3VudGluZyBjb2RlIChzb21lIGFkZGl0aW9uYWwgY2xlYW51cCB0byBjb21lKS4KKyAgICAg ICAgKFdlYkNvcmU6OkxvYWRlcjo6SG9zdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Okxv YWRlcjo6SG9zdDo6cHJvY2Vzc2luZ1Jlc291cmNlKToKKyAgICAgICAgKiBwYWdlL0V2ZW50U291 cmNlLmNwcDogUmVtb3ZlIGN1c3RvbSBjb2RlIGZvciBjb3VudGluZyBjb25uZWN0aW9ucyBwZXIg aG9zdC4KKyAgICAgICAgKiB4bWwvWE1MSHR0cFJlcXVlc3QuY3BwOiBSZW1vdmUgY3VzdG9tIGNv ZGUgZm9yIGNvdW50aW5nIGNvbm5lY3Rpb25zIHBlciBob3N0LgorICAgICAgICAqIHhtbC9YTUxI dHRwUmVxdWVzdC5oOgorCiAyMDEwLTA5LTIwICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9nYUBw YXJvZ2EuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCkluZGV4OiBXZWJD b3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv V2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oJKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29y ZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAtMjM2NDks NiArMjM2NDksMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0 aXZlUGF0aD0iLi5cbG9hZGVyXE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHAiDQorCQkJCT4NCisJ CQk8L0ZpbGU+DQorCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcT3BlbkNv bm5lY3Rpb25MaW1pdGVyLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCiAJCQkJ UmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcUGluZ0xvYWRlci5jcHAiDQogCQkJCT4NCiAJCQk8L0Zp bGU+DQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50U291cmNlLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BhZ2UvRXZlbnRTb3VyY2UuY3BwCShyZXZpc2lvbiA2Nzg1NykKKysrIFdlYkNvcmUv cGFnZS9FdmVudFNvdXJjZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTExNiw5ICsxMTYsNiBAQAog ICAgIG1fbG9hZGVyID0gVGhyZWFkYWJsZUxvYWRlcjo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNv bnRleHQoKSwgdGhpcywgcmVxdWVzdCwgb3B0aW9ucyk7CiAKICAgICBtX3JlcXVlc3RJbkZsaWdo dCA9IHRydWU7Ci0KLSAgICBpZiAoIXNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNXb3JrZXJD b250ZXh0KCkpCi0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RJbkZs aWdodChtX3VybCk7CiB9CiAKIHZvaWQgRXZlbnRTb3VyY2U6OmVuZFJlcXVlc3QoKQpAQCAtMTI4 LDkgKzEyNSw2IEBACiAgICAgaWYgKCFtX2ZhaWxTaWxlbnRseSkKICAgICAgICAgZGlzcGF0Y2hF dmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5lcnJvckV2ZW50LCBmYWxzZSwgZmFsc2Up KTsKIAotICAgIGlmICghc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc1dvcmtlckNvbnRleHQo KSkKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1f dXJsKTsKLQogICAgIGlmIChtX3N0YXRlICE9IENMT1NFRCkKICAgICAgICAgc2NoZWR1bGVSZWNv bm5lY3QoKTsKICAgICBlbHNlCkluZGV4OiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0JKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbQkod29ya2luZyBjb3B5KQpAQCAtMTg0Myw2ICsxODQzLDggQEAKIAlX ZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmggXAogCVdlYkNvcmUvbG9hZGVyL05ldHNj YXBlUGx1Z0luU3RyZWFtTG9hZGVyLmNwcCBcCiAJV2ViQ29yZS9sb2FkZXIvTmV0c2NhcGVQbHVn SW5TdHJlYW1Mb2FkZXIuaCBcCisJV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVy LmNwcCBcCisJV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmggXAogCVdlYkNv cmUvbG9hZGVyL1BpbmdMb2FkZXIuY3BwIFwKIAlXZWJDb3JlL2xvYWRlci9QaW5nTG9hZGVyLmgg XAogCVdlYkNvcmUvbG9hZGVyL1BsYWNlaG9sZGVyRG9jdW1lbnQuY3BwIFwKSW5kZXg6IFdlYkNv cmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5neXBpCShyZXZp c2lvbiA2Nzg1NykKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3b3JraW5nIGNvcHkpCkBAIC0x OTUzLDYgKzE5NTMsOCBAQAogICAgICAgICAgICAgJ2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmgn LAogICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAnLAog ICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5oJywKKyAgICAg ICAgICAgICdsb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCcsCisgICAgICAgICAgICAn bG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5oJywKICAgICAgICAgICAgICdsb2FkZXIvUGlu Z0xvYWRlci5jcHAnLAogICAgICAgICAgICAgJ2xvYWRlci9QaW5nTG9hZGVyLmgnLAogICAgICAg ICAgICAgJ2xvYWRlci9QbGFjZWhvbGRlckRvY3VtZW50LmNwcCcsCkluZGV4OiBXZWJDb3JlL0NN YWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ01ha2VMaXN0cy50eHQJKHJldmlz aW9uIDY3ODU3KQorKysgV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAkod29ya2luZyBjb3B5KQpAQCAt MTEwNSw2ICsxMTA1LDcgQEAKICAgICBsb2FkZXIvTWFpblJlc291cmNlTG9hZGVyLmNwcAogICAg IGxvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcAogICAgIGxvYWRlci9OZXRzY2FwZVBsdWdJblN0 cmVhbUxvYWRlci5jcHAKKyAgICBsb2FkZXIvT3BlbkNvbm5lY3Rpb25Mb2FkZXIuY3BwCiAgICAg bG9hZGVyL1BpbmdMb2FkZXIuY3BwCiAgICAgbG9hZGVyL1BsYWNlaG9sZGVyRG9jdW1lbnQuY3Bw CiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNrLmNwcApJbmRleDogV2ViQ29yZS9XZWJDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTUxODIsNiAr NTE4Miw4IEBACiAJCUQwN0RFQUJBMEEzNjU1NEEwMENBMzBGOCAvKiBJbnNlcnRMaXN0Q29tbWFu ZC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDA3REVB QjgwQTM2NTU0QTAwQ0EzMEY4IC8qIEluc2VydExpc3RDb21tYW5kLmggKi87IH07CiAJCUQwODZG RTk4MDlENTNBQUIwMDVCQzc0RCAvKiBVbmxpbmtDb21tYW5kLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMDg2RkU5NjA5RDUzQUFCMDA1QkM3NEQgLyog VW5saW5rQ29tbWFuZC5oICovOyB9OwogCQlEMDg2RkU5OTA5RDUzQUFCMDA1QkM3NEQgLyogVW5s aW5rQ29tbWFuZC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBEMDg2RkU5NzA5RDUzQUFCMDA1QkM3NEQgLyogVW5saW5rQ29tbWFuZC5jcHAgKi87IH07 CisJCUQwQjAyOEE2MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwQjAyOEE0MTI0 MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCAqLzsgfTsKKwkJRDBCMDI4 QTcxMjQxMjE4NTAwOUQ1MTlFIC8qIE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMEIwMjhBNTEyNDEyMTg1MDA5 RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCAqLzsgfTsKIAkJRDBCMDU1NjgwOUM2 NzAwMTAwMzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMEIwNTU2NjA5QzY3MDAxMDAzMDdFNDMgLyogQ3Jl YXRlTGlua0NvbW1hbmQuaCAqLzsgfTsKIAkJRDBCMDU1NjkwOUM2NzAwMTAwMzA3RTQzIC8qIENy ZWF0ZUxpbmtDb21tYW5kLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEQwQjA1NTY3MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFuZC5j cHAgKi87IH07CiAJCUQwRkYyQTVEMTFGOEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVyLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwRkYyQTVCMTFG OEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVyLmNwcCAqLzsgfTsKQEAgLTExMDM5LDYgKzExMDQx LDggQEAKIAkJRDA3REVBQjgwQTM2NTU0QTAwQ0EzMEY4IC8qIEluc2VydExpc3RDb21tYW5kLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNlcnRMaXN0Q29tbWFuZC5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMDg2RkU5NjA5RDUzQUFCMDA1QkM3NEQgLyog VW5saW5rQ29tbWFuZC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBVbmxpbmtD b21tYW5kLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUQwODZGRTk3MDlENTNBQUIw MDVCQzc0RCAvKiBVbmxpbmtDb21tYW5kLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFVubGlua0NvbW1hbmQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owor CQlEMEIwMjhBNDEyNDEyMTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9wZW5Db25uZWN0aW9uTGltaXRlci5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlEMEIwMjhBNTEyNDEyMTg1MDA5RDUxOUUgLyog T3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUQwQjA1NTY2MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFuZC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDcmVhdGVMaW5rQ29tbWFuZC5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMEIwNTU2NzA5QzY3MDAxMDAzMDdFNDMgLyogQ3Jl YXRlTGlua0NvbW1hbmQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g Q3JlYXRlTGlua0NvbW1hbmQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMEZG MkE1QjExRjhDNDVBMDA3RTc0RTAgLyogUGluZ0xvYWRlci5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBQaW5nTG9hZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKQEAgLTE2NjgzLDYgKzE2Njg3LDggQEAKIAkJCQkwQjkwNTYxODBGMjU3OEJFMDA5NUZG NkEgLyogVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oICovLAogCQkJCTBCOTA1NkY2MEYyNjg1RjMw MDk1RkY2QSAvKiBXb3JrZXJUaHJlYWRhYmxlTG9hZGVyLmNwcCAqLywKIAkJCQkwQjkwNTZGNzBG MjY4NUYzMDA5NUZGNkEgLyogV29ya2VyVGhyZWFkYWJsZUxvYWRlci5oICovLAorCQkJCUQwQjAy OEE0MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCAqLywKKwkJCQlE MEIwMjhBNTEyNDEyMTg1MDA5RDUxOUUgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCAqLywK IAkJCSk7CiAJCQlwYXRoID0gbG9hZGVyOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAg LTIwNTY5LDYgKzIwNTc1LDcgQEAKIAkJCQk5M0YxOTlFRDA4MjQ1RTU5MDAxRTlBQkMgLyogWFNM VFByb2Nlc3Nvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTFCRTUxMkUwQ0Y2QzUxMjAwMkVBOTU5 IC8qIFhTTFRVbmljb2RlU29ydC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTdERDREODcwRkRGNEQ2 RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuaCBpbiBIZWFkZXJzICovLAorCQkJCUQwQjAyOEE2MTI0 MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCBpbiBIZWFkZXJzICovLAog CQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpA QCAtMjMwNDcsNiArMjMwNTQsNyBAQAogCQkJCTkzRjE5QjA1MDgyNDVFNTkwMDFFOUFCQyAvKiBY U0xUUHJvY2Vzc29yTGlieHNsdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFMUJFNTEyRDBDRjZD NTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVTb3J0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTk3 REQ0RDg2MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRpdG9yLmNwcCBpbiBTb3VyY2VzICovLAor CQkJCUQwQjAyOEE3MTI0MTIxODUwMDlENTE5RSAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vz c2luZyA9IDA7CiAJCX07CkluZGV4OiBXZWJDb3JlL0FuZHJvaWQubWsKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9BbmRyb2lkLm1rCShyZXZpc2lvbiA2Nzg1NykKKysrIFdlYkNvcmUvQW5kcm9pZC5t awkod29ya2luZyBjb3B5KQpAQCAtMzMyLDYgKzMzMiw3IEBACiAJbG9hZGVyL01haW5SZXNvdXJj ZUxvYWRlci5jcHAgXAogCWxvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcCBcCiAJbG9hZGVyL05l dHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyLmNwcCBcCisJbG9hZGVyL09wZW5Db25uZWN0aW9uTGlt aXRlci5jcHAgXAogCWxvYWRlci9QaW5nTG9hZGVyLmNwcCBcCiAJbG9hZGVyL1BsYWNlaG9sZGVy RG9jdW1lbnQuY3BwIFwKIAlsb2FkZXIvUG9saWN5Q2FsbGJhY2suY3BwIFwKSW5kZXg6IFdlYkNv cmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3htbC9YTUxI dHRwUmVxdWVzdC5jcHAJKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29yZS94bWwvWE1MSHR0cFJl cXVlc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNzksNyArMTc5LDYgQEAKICAgICAsIG1fdXBs b2FkRXZlbnRzQWxsb3dlZCh0cnVlKQogICAgICwgbV91cGxvYWRDb21wbGV0ZShmYWxzZSkKICAg ICAsIG1fc2FtZU9yaWdpblJlcXVlc3QodHJ1ZSkKLSAgICAsIG1fZGlkVGVsbExvYWRlckFib3V0 UmVxdWVzdChmYWxzZSkKICAgICAsIG1fcmVjZWl2ZWRMZW5ndGgoMCkKICAgICAsIG1fbGFzdFNl bmRMaW5lTnVtYmVyKDApCiAgICAgLCBtX2V4Y2VwdGlvbkNvZGUoMCkKQEAgLTE5MywxMCArMTky LDYgQEAKIAogWE1MSHR0cFJlcXVlc3Q6On5YTUxIdHRwUmVxdWVzdCgpCiB7Ci0gICAgaWYgKG1f ZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCkgewotICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+ bm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUobV91cmwpOwotICAgICAgICBtX2RpZFRlbGxMb2FkZXJB Ym91dFJlcXVlc3QgPSBmYWxzZTsKLSAgICB9CiAgICAgaWYgKG1fdXBsb2FkKQogICAgICAgICBt X3VwbG9hZC0+ZGlzY29ubmVjdFhNTEh0dHBSZXF1ZXN0KCk7CiAKQEAgLTYxNywxNiArNjEyLDYg QEAKICAgICAgICAgICAgIC8vIGEgcmVxdWVzdCBpcyBpbiBwcm9ncmVzcyBiZWNhdXNlIHdlIG5l ZWQgdG8ga2VlcCB0aGUgbGlzdGVuZXJzIGFsaXZlLAogICAgICAgICAgICAgLy8gYW5kIHRoZXkg YXJlIHJlZmVyZW5jZWQgYnkgdGhlIEphdmFTY3JpcHQgd3JhcHBlci4KICAgICAgICAgICAgIHNl dFBlbmRpbmdBY3Rpdml0eSh0aGlzKTsKLQotICAgICAgICAgICAgLy8gRm9yIG5vdyB3ZSBzaG91 bGQgb25seSBiYWxhbmNlIHRoZSBub25DYWNoZWQgcmVxdWVzdCBjb3VudCBmb3IgbWFpbi10aHJl YWQgWEhScyBhbmQgbm90Ci0gICAgICAgICAgICAvLyBXb3JrZXIgWEhScywgYXMgdGhlIENhY2hl IGlzIG5vdCB0aHJlYWQtc2FmZS4KLSAgICAgICAgICAgIC8vIFRoaXMgd2lsbCBiZWNvbWUgaXJy ZWxldmFudCBhZnRlciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjcx NjUgaXMgcmVzb2x2ZWQuCi0gICAgICAgICAgICBpZiAoIXNjcmlwdEV4ZWN1dGlvbkNvbnRleHQo KS0+aXNXb3JrZXJDb250ZXh0KCkpIHsKLSAgICAgICAgICAgICAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkpOwotICAgICAgICAgICAgICAgIEFTU0VSVCghbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1 ZXN0KTsKLSAgICAgICAgICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+bm9uQ2FjaGVSZXF1ZXN0 SW5GbGlnaHQobV91cmwpOwotICAgICAgICAgICAgICAgIG1fZGlkVGVsbExvYWRlckFib3V0UmVx dWVzdCA9IHRydWU7Ci0gICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICB9IGVsc2UKICAgICAg ICAgVGhyZWFkYWJsZUxvYWRlcjo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseShzY3JpcHRFeGVj dXRpb25Db250ZXh0KCksIHJlcXVlc3QsICp0aGlzLCBvcHRpb25zKTsKQEAgLTkxOCwxMCArOTAz LDYgQEAKIAogdm9pZCBYTUxIdHRwUmVxdWVzdDo6ZGlkRmFpbChjb25zdCBSZXNvdXJjZUVycm9y JiBlcnJvcikKIHsKLSAgICBpZiAobV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0KSB7Ci0gICAg ICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RDb21wbGV0ZShtX3VybCk7Ci0g ICAgICAgIG1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCA9IGZhbHNlOwotICAgIH0KIAogICAg IC8vIElmIHdlIGFyZSBhbHJlYWR5IGluIGFuIGVycm9yIHN0YXRlLCBmb3IgaW5zdGFuY2Ugd2Ug Y2FsbGVkIGFib3J0KCksIGJhaWwgb3V0IGVhcmx5LgogICAgIGlmIChtX2Vycm9yKQpAQCAtOTQ4 LDExICs5MjksNiBAQAogCiB2b2lkIFhNTEh0dHBSZXF1ZXN0OjpkaWRGaW5pc2hMb2FkaW5nKHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllcikKIHsKLSAgICBpZiAobV9kaWRUZWxsTG9hZGVyQWJvdXRS ZXF1ZXN0KSB7Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RDb21w bGV0ZShtX3VybCk7Ci0gICAgICAgIG1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCA9IGZhbHNl OwotICAgIH0KLQogICAgIGlmIChtX2Vycm9yKQogICAgICAgICByZXR1cm47CiAKSW5kZXg6IFdl YkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS94bWwvWE1M SHR0cFJlcXVlc3QuaAkocmV2aXNpb24gNjc4NTcpCisrKyBXZWJDb3JlL3htbC9YTUxIdHRwUmVx dWVzdC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xOTEsNyArMTkxLDYgQEAKICAgICBib29sIG1fdXBs b2FkQ29tcGxldGU7CiAKICAgICBib29sIG1fc2FtZU9yaWdpblJlcXVlc3Q7Ci0gICAgYm9vbCBt X2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3Q7CiAKICAgICAvLyBVc2VkIGZvciBvbnByb2dyZXNz IHRyYWNraW5nCiAgICAgbG9uZyBsb25nIG1fcmVjZWl2ZWRMZW5ndGg7CkluZGV4OiBXZWJDb3Jl L2xvYWRlci9sb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9sb2FkZXIuaAko cmV2aXNpb24gNjc4NTcpCisrKyBXZWJDb3JlL2xvYWRlci9sb2FkZXIuaAkod29ya2luZyBjb3B5 KQpAQCAtNTQsOSArNTQsNiBAQAogICAgICAgICBib29sIGlzU3VzcGVuZGluZ1BlbmRpbmdSZXF1 ZXN0cygpIHsgcmV0dXJuIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzOyB9CiAgICAgICAg IHZvaWQgc3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpOwogICAgICAgICB2b2lkIHJlc3VtZVBlbmRp bmdSZXF1ZXN0cygpOwotICAgICAgICAKLSAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RJbkZs aWdodChjb25zdCBLVVJMJik7Ci0gICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUo Y29uc3QgS1VSTCYpOwogCiAgICAgcHJpdmF0ZToKICAgICAgICAgUHJpb3JpdHkgZGV0ZXJtaW5l UHJpb3JpdHkoY29uc3QgQ2FjaGVkUmVzb3VyY2UqKSBjb25zdDsKQEAgLTY2LDI0ICs2MywyMiBA QAogCiAgICAgICAgIGNsYXNzIEhvc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxIb3N0PiwgcHJpdmF0 ZSBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCB7CiAgICAgICAgIHB1YmxpYzoKLSAgICAgICAgICAg IHN0YXRpYyBQYXNzUmVmUHRyPEhvc3Q+IGNyZWF0ZShjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUs IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHQpIAorICAgICAgICAgICAgc3RhdGljIFBhc3NS ZWZQdHI8SG9zdD4gY3JlYXRlKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkgCiAgICAgICAgICAg ICB7Ci0gICAgICAgICAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBIb3N0KG5hbWUsIG1heFJl cXVlc3RzSW5GbGlnaHQpKTsKKyAgICAgICAgICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEhv c3QobmFtZSkpOwogICAgICAgICAgICAgfQogICAgICAgICAgICAgfkhvc3QoKTsKICAgICAgICAg ICAgIAogICAgICAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKCkgY29uc3QgeyByZXR1 cm4gbV9uYW1lOyB9CiAgICAgICAgICAgICB2b2lkIGFkZFJlcXVlc3QoUmVxdWVzdCosIFByaW9y aXR5KTsKLSAgICAgICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0SW5GbGlnaHQoKTsKLSAgICAg ICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUoKTsKICAgICAgICAgICAgIHZvaWQg c2VydmVQZW5kaW5nUmVxdWVzdHMoUHJpb3JpdHkgbWluaW11bVByaW9yaXR5ID0gVmVyeUxvdyk7 CiAgICAgICAgICAgICB2b2lkIGNhbmNlbFJlcXVlc3RzKENhY2hlZFJlc291cmNlTG9hZGVyKik7 CiAgICAgICAgICAgICBib29sIGhhc1JlcXVlc3RzKCkgY29uc3Q7CiAKLSAgICAgICAgICAgIGJv b2wgcHJvY2Vzc2luZ1Jlc291cmNlKCkgY29uc3QgeyByZXR1cm4gbV9udW1SZXNvdXJjZXNQcm9j ZXNzaW5nICE9IDAgfHwgbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0ICE9MDsgfQorICAgICAg ICAgICAgYm9vbCBwcm9jZXNzaW5nUmVzb3VyY2UoKSBjb25zdCB7IHJldHVybiBtX251bVJlc291 cmNlc1Byb2Nlc3Npbmc7IH0KIAogICAgICAgICBwcml2YXRlOgotICAgICAgICAgICAgSG9zdChj b25zdCBBdG9taWNTdHJpbmcmLCB1bnNpZ25lZCk7CisgICAgICAgICAgICBIb3N0KGNvbnN0IEF0 b21pY1N0cmluZyYpOwogCiAgICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3Bv bnNlKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpOwogICAgICAg ICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29u c3QgY2hhciosIGludCk7CkBAIC05Miw3ICs4Nyw3IEBACiAgICAgICAgICAgICB2aXJ0dWFsIHZv aWQgZGlkRmFpbChTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IFJlc291cmNlRXJyb3ImKTsKICAg ICAgICAgICAgIAogICAgICAgICAgICAgdHlwZWRlZiBEZXF1ZTxSZXF1ZXN0Kj4gUmVxdWVzdFF1 ZXVlOwotICAgICAgICAgICAgdm9pZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhSZXF1ZXN0UXVldWUm IHJlcXVlc3RzUGVuZGluZywgYm9vbCYgc2VydmVMb3dlclByaW9yaXR5KTsKKyAgICAgICAgICAg IHZvaWQgc2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcp OwogICAgICAgICAgICAgdm9pZCBkaWRGYWlsKFN1YnJlc291cmNlTG9hZGVyKiwgYm9vbCBjYW5j ZWxsZWQgPSBmYWxzZSk7CiAgICAgICAgICAgICB2b2lkIGNhbmNlbFBlbmRpbmdSZXF1ZXN0cyhS ZXF1ZXN0UXVldWUmIHJlcXVlc3RzUGVuZGluZywgQ2FjaGVkUmVzb3VyY2VMb2FkZXIqKTsKICAg ICAgICAgICAgIApAQCAtMTAwLDkgKzk1LDcgQEAKICAgICAgICAgICAgIHR5cGVkZWYgSGFzaE1h cDxSZWZQdHI8U3VicmVzb3VyY2VMb2FkZXI+LCBSZXF1ZXN0Kj4gUmVxdWVzdE1hcDsKICAgICAg ICAgICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0c0xvYWRpbmc7CiAgICAgICAgICAgICBjb25zdCBB dG9taWNTdHJpbmcgbV9uYW1lOwotICAgICAgICAgICAgY29uc3QgaW50IG1fbWF4UmVxdWVzdHNJ bkZsaWdodDsKICAgICAgICAgICAgIGludCBtX251bVJlc291cmNlc1Byb2Nlc3Npbmc7Ci0gICAg ICAgICAgICBpbnQgbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0OwogICAgICAgICB9OwogICAg ICAgICB0eXBlZGVmIEhhc2hNYXA8QXRvbWljU3RyaW5nSW1wbCosIFJlZlB0cjxIb3N0PiA+IEhv c3RNYXA7CiAgICAgICAgIEhvc3RNYXAgbV9ob3N0czsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL1Jl c291cmNlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxv YWRlci5jcHAJKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2Fk ZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAiRnJhbWVM b2FkZXJDbGllbnQuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCiAjaW5jbHVk ZSAiSW5zcGVjdG9yVGltZWxpbmVBZ2VudC5oIgorI2luY2x1ZGUgIk9wZW5Db25uZWN0aW9uTGlt aXRlci5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRlICJQcm9ncmVzc1RyYWNrZXIuaCIK ICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgpAQCAtNjksNiArNzAsNyBAQAogICAgICwgbV9z aG91bGRDb250ZW50U25pZmYoc2hvdWxkQ29udGVudFNuaWZmKQogICAgICwgbV9zaG91bGRCdWZm ZXJEYXRhKHRydWUpCiAgICAgLCBtX2RlZmVyc0xvYWRpbmcoZnJhbWUtPnBhZ2UoKS0+ZGVmZXJz TG9hZGluZygpKQorICAgICwgbV90aHJvdHRsZVJldHJ5VGltZXIodGhpcywgJlJlc291cmNlTG9h ZGVyOjp0aHJvdHRsZVJldHJ5VGltZXJGaXJlZCkKIHsKIH0KIApAQCAtODcsNiArODksOSBAQAog ICAgIC8vIGhhcyBiZWVuIGRlYWxsb2NhdGVkIGFuZCBhbHNvIHRvIGF2b2lkIHJlZW50ZXJpbmcg dGhpcyBtZXRob2QuCiAgICAgUmVmUHRyPFJlc291cmNlTG9hZGVyPiBwcm90ZWN0b3IodGhpcyk7 CiAKKyAgICBpZiAoIW1fcmVxdWVzdC5pc051bGwoKSkKKyAgICAgICAgT3BlbkNvbm5lY3Rpb25M aW1pdGVyOjpkZWNyZW1lbnRIb3N0UmVxdWVzdENvdW50KG1fcmVxdWVzdC51cmwoKSk7CisKICAg ICBtX2ZyYW1lID0gMDsKICAgICBtX2RvY3VtZW50TG9hZGVyID0gMDsKICAgICAKQEAgLTEwOCwx MyArMTEzLDMwIEBACiAgICAgbV9kZWZlcnJlZFJlcXVlc3QgPSBSZXNvdXJjZVJlcXVlc3QoKTsK IH0KIAordm9pZCBSZXNvdXJjZUxvYWRlcjo6dGhyb3R0bGVSZXRyeVRpbWVyRmlyZWQoVGltZXI8 UmVzb3VyY2VMb2FkZXI+KikKK3sKKyAgICBBU1NFUlQoIW1fZGVmZXJyZWRSZXF1ZXN0LmlzTnVs bCgpKTsKKyAgICBzZXREZWZlcnNMb2FkaW5nKGZhbHNlKTsKK30KKwogYm9vbCBSZXNvdXJjZUxv YWRlcjo6bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHIpCiB7CiAgICAgQVNTRVJUKCFtX2hh bmRsZSk7CiAgICAgQVNTRVJUKG1fZGVmZXJyZWRSZXF1ZXN0LmlzTnVsbCgpKTsKICAgICBBU1NF UlQoIW1fZG9jdW1lbnRMb2FkZXItPmlzU3Vic3RpdHV0ZUxvYWRQZW5kaW5nKHRoaXMpKTsKKyAg ICBBU1NFUlQoIW1fdGhyb3R0bGVSZXRyeVRpbWVyLmlzQWN0aXZlKCkpOwogICAgIAogICAgIFJl c291cmNlUmVxdWVzdCBjbGllbnRSZXF1ZXN0KHIpOworCisgICAgLy8gRm9yIGh0dHAocykgaG9z dHMsIHdlIHNob3VsZCBhbHdheXMgZW5mb3JjZSB0aGUgY29ubmVjdGlvbiBsaW1pdC4KKyAgICAv LyBGb3Igbm9uLWh0dHAocykgaG9zdHMsIHdlIHNob3VsZCBvbmx5IGVuZm9yY2UgdGhlIGxpbWl0 IGlmIHRoZSBkb2N1bWVudCBpc24ndCBkb25lIHBhcnNpbmcgYW5kIHdlIGRvbid0IGtub3cgYWxs IHN0eWxlc2hlZXRzIHlldC4KKyAgICBib29sIHNob3VsZExpbWl0UmVxdWVzdHMgPSBjbGllbnRS ZXF1ZXN0LnVybCgpLnByb3RvY29sSW5IVFRQRmFtaWx5KCkgfHwgKG1fZnJhbWUtPmRvY3VtZW50 KCkgJiYgKG1fZnJhbWUtPmRvY3VtZW50KCktPnBhcnNpbmcoKSB8fCAhbV9mcmFtZS0+ZG9jdW1l bnQoKS0+aGF2ZVN0eWxlc2hlZXRzTG9hZGVkKCkpKTsKKyAgICBpZiAoc2hvdWxkTGltaXRSZXF1 ZXN0cyAmJiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OnNob3VsZFRocm90dGxlUmVxdWVzdChjbGll bnRSZXF1ZXN0LnVybCgpKSkgeworICAgICAgICBtX2RlZmVycmVkUmVxdWVzdCA9IGNsaWVudFJl cXVlc3Q7CisgICAgICAgIHNldERlZmVyc0xvYWRpbmcodHJ1ZSk7CisgICAgICAgIG1fdGhyb3R0 bGVSZXRyeVRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAg fQogICAgIAogICAgIC8vIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y NjM5MQogICAgIC8vIFRoZSB2YXJpb3VzIHBsdWctaW4gaW1wbGVtZW50YXRpb25zIGNhbGwgZGly ZWN0bHkgdG8gUmVzb3VyY2VMb2FkZXI6OmxvYWQoKSBpbnN0ZWFkIG9mIHBpcGluZyByZXF1ZXN0 cwpAQCAtMjIzLDYgKzI0NSwxMCBAQAogCiAgICAgICAgIGZyYW1lTG9hZGVyKCktPm5vdGlmaWVy KCktPndpbGxTZW5kUmVxdWVzdCh0aGlzLCByZXF1ZXN0LCByZWRpcmVjdFJlc3BvbnNlKTsKICAg ICB9CisgICAgCisgICAgT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjppbmNyZW1lbnRIb3N0UmVxdWVz dENvdW50KHJlcXVlc3QudXJsKCkpOworICAgIGlmICghcmVkaXJlY3RSZXNwb25zZS5pc051bGwo KSkKKyAgICAgICAgT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpkZWNyZW1lbnRIb3N0UmVxdWVzdENv dW50KHJlZGlyZWN0UmVzcG9uc2UudXJsKCkpOwogCiAgICAgbV9yZXF1ZXN0ID0gcmVxdWVzdDsK IH0KSW5kZXg6IFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5oCShyZXZpc2lvbiAw KQorKysgV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmgJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUK KyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJp Z2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20K KyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICog QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us CisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqCisgKi8KKworI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorCituYW1l c3BhY2UgV2ViQ29yZSB7CitjbGFzcyBLVVJMOworCitjbGFzcyBPcGVuQ29ubmVjdGlvbkxpbWl0 ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIHN0YXRpYyB2b2lkIGluY3Jl bWVudEhvc3RSZXF1ZXN0Q291bnQoY29uc3QgS1VSTCYpOworICAgIHN0YXRpYyB2b2lkIGRlY3Jl bWVudEhvc3RSZXF1ZXN0Q291bnQoY29uc3QgS1VSTCYpOworICAgIHN0YXRpYyBib29sIHNob3Vs ZFRocm90dGxlUmVxdWVzdChjb25zdCBLVVJMJik7Citwcml2YXRlOgorICAgIE9wZW5Db25uZWN0 aW9uTGltaXRlcigpOworICAgIH5PcGVuQ29ubmVjdGlvbkxpbWl0ZXIoKTsKK307Cit9CkluZGV4 OiBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv bG9hZGVyL1Jlc291cmNlTG9hZGVyLmgJKHJldmlzaW9uIDY3ODU3KQorKysgV2ViQ29yZS9sb2Fk ZXIvUmVzb3VyY2VMb2FkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsNyBAQAogI2lu Y2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAjaW5jbHVkZSAiQXV0aGVudGljYXRpb25DaGFsbGVu Z2UuaCIKICNpbmNsdWRlICJLVVJMLmgiCisjaW5jbHVkZSAiVGltZXIuaCIKIAogI2luY2x1ZGUg PHd0Zi9Gb3J3YXJkLmg+CiAKQEAgLTE0OCw2ICsxNDksOCBAQAogICAgICAgICBSZXNvdXJjZVJl c3BvbnNlIG1fcmVzcG9uc2U7CiAgICAgICAgIAogICAgIHByaXZhdGU6CisgICAgICAgIHZvaWQg dGhyb3R0bGVSZXRyeVRpbWVyRmlyZWQoVGltZXI8UmVzb3VyY2VMb2FkZXI+Kik7CisKICAgICAg ICAgUmVzb3VyY2VSZXF1ZXN0IG1fcmVxdWVzdDsKICAgICAgICAgUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gbV9yZXNvdXJjZURhdGE7CiAgICAgICAgIApAQCAtMTYyLDYgKzE2NSw4IEBACiAgICAgICAg IGJvb2wgbV9zaG91bGRCdWZmZXJEYXRhOwogICAgICAgICBib29sIG1fZGVmZXJzTG9hZGluZzsK ICAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IG1fZGVmZXJyZWRSZXF1ZXN0OworICAgICAgICAKKyAg ICAgICAgVGltZXI8UmVzb3VyY2VMb2FkZXI+IG1fdGhyb3R0bGVSZXRyeVRpbWVyOwogICAgIH07 CiAKIH0KSW5kZXg6IFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9sb2FkZXIvbG9hZGVyLmNwcAkocmV2aXNpb24gNjc4NTcpCisrKyBXZWJDb3JlL2xvYWRl ci9sb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MiwyOSArNDIsMTUgQEAKICNpbmNsdWRl IDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAotI2RlZmluZSBS RVFVRVNUX01BTkFHRU1FTlRfRU5BQkxFRCAxCiAjZGVmaW5lIFJFUVVFU1RfREVCVUcgMAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLSNpZiBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxFRAotLy8g TWF0Y2ggdGhlIHBhcmFsbGVsIGNvbm5lY3Rpb24gY291bnQgdXNlZCBieSB0aGUgbmV0d29ya2lu ZyBsYXllcgotc3RhdGljIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0OwotLy8g SGF2aW5nIGEgbGltaXQgbWlnaHQgc3RpbGwgaGVscCBnZXR0aW5nIG1vcmUgaW1wb3J0YW50IHJl c291cmNlcyBmaXJzdAotc3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHRG b3JOb25IVFRQUHJvdG9jb2xzID0gMjA7Ci0jZWxzZQotc3RhdGljIGNvbnN0IHVuc2lnbmVkIG1h eFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0ID0gMTAwMDA7Ci1zdGF0aWMgY29uc3QgdW5zaWduZWQg bWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAxMDAwMDsKLSNlbmRpZgot CiBMb2FkZXI6OkxvYWRlcigpCiAgICAgOiBtX3JlcXVlc3RUaW1lcih0aGlzLCAmTG9hZGVyOjpy ZXF1ZXN0VGltZXJGaXJlZCkKICAgICAsIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKGZh bHNlKQogewotICAgIG1fbm9uSFRUUFByb3RvY29sSG9zdCA9IEhvc3Q6OmNyZWF0ZShBdG9taWNT dHJpbmcoKSwgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMpOwotI2lmIFJF UVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECi0gICAgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3Qg PSBpbml0aWFsaXplTWF4aW11bUhUVFBDb25uZWN0aW9uQ291bnRQZXJIb3N0KCk7Ci0jZW5kaWYK KyAgICBtX25vbkhUVFBQcm90b2NvbEhvc3QgPSBIb3N0OjpjcmVhdGUoQXRvbWljU3RyaW5nKCkp OwogfQogCiBMb2FkZXI6On5Mb2FkZXIoKQpAQCAtOTcsNyArODMsNiBAQAogCiBMb2FkZXI6OlBy aW9yaXR5IExvYWRlcjo6ZGV0ZXJtaW5lUHJpb3JpdHkoY29uc3QgQ2FjaGVkUmVzb3VyY2UqIHJl c291cmNlKSBjb25zdAogewotI2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECiAgICAgc3dp dGNoIChyZXNvdXJjZS0+dHlwZSgpKSB7CiAgICAgICAgIGNhc2UgQ2FjaGVkUmVzb3VyY2U6OkNT U1N0eWxlU2hlZXQ6CiAjaWYgRU5BQkxFKFhTTFQpCkBAIC0xMTYsOSArMTAxLDYgQEAKICAgICB9 CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgcmV0dXJuIExvdzsKLSNlbHNlCi0gICAg cmV0dXJuIEhpZ2g7Ci0jZW5kaWYKIH0KIAogdm9pZCBMb2FkZXI6OmxvYWQoQ2FjaGVkUmVzb3Vy Y2VMb2FkZXIqIGNhY2hlZFJlc291cmNlTG9hZGVyLCBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2Us IGJvb2wgaW5jcmVtZW50YWwsIFNlY3VyaXR5Q2hlY2tQb2xpY3kgc2VjdXJpdHlDaGVjaywgYm9v bCBzZW5kUmVzb3VyY2VMb2FkQ2FsbGJhY2tzKQpAQCAtMTMzLDcgKzExNSw3IEBACiAgICAgICAg IEF0b21pY1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7CiAgICAgICAgIGhvc3QgPSBtX2hv c3RzLmdldChob3N0TmFtZS5pbXBsKCkpOwogICAgICAgICBpZiAoIWhvc3QpIHsKLSAgICAgICAg ICAgIGhvc3QgPSBIb3N0OjpjcmVhdGUoaG9zdE5hbWUsIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJI b3N0KTsKKyAgICAgICAgICAgIGhvc3QgPSBIb3N0OjpjcmVhdGUoaG9zdE5hbWUpOwogICAgICAg ICAgICAgbV9ob3N0cy5hZGQoaG9zdE5hbWUuaW1wbCgpLCBob3N0KTsKICAgICAgICAgfQogICAg IH0gZWxzZSAKQEAgLTIxMiwzNyArMTk0LDYgQEAKICAgICAgICAgc2NoZWR1bGVTZXJ2ZVBlbmRp bmdSZXF1ZXN0cygpOwogfQogCi12b2lkIExvYWRlcjo6bm9uQ2FjaGVSZXF1ZXN0SW5GbGlnaHQo Y29uc3QgS1VSTCYgdXJsKQotewotICAgIGlmICghdXJsLnByb3RvY29sSW5IVFRQRmFtaWx5KCkp Ci0gICAgICAgIHJldHVybjsKLSAgICAKLSAgICBBdG9taWNTdHJpbmcgaG9zdE5hbWUgPSB1cmwu aG9zdCgpOwotICAgIG1faG9zdHMuY2hlY2tDb25zaXN0ZW5jeSgpOwotICAgIFJlZlB0cjxIb3N0 PiBob3N0ID0gbV9ob3N0cy5nZXQoaG9zdE5hbWUuaW1wbCgpKTsKLSAgICBpZiAoIWhvc3QpIHsK LSAgICAgICAgaG9zdCA9IEhvc3Q6OmNyZWF0ZShob3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZsaWdo dFBlckhvc3QpOwotICAgICAgICBtX2hvc3RzLmFkZChob3N0TmFtZS5pbXBsKCksIGhvc3QpOwot ICAgIH0KLQotICAgIGhvc3QtPm5vbkNhY2hlUmVxdWVzdEluRmxpZ2h0KCk7Ci19Ci0KLXZvaWQg TG9hZGVyOjpub25DYWNoZVJlcXVlc3RDb21wbGV0ZShjb25zdCBLVVJMJiB1cmwpCi17Ci0gICAg aWYgKCF1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkKLSAgICAgICAgcmV0dXJuOwotICAgIAot ICAgIEF0b21pY1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7Ci0gICAgbV9ob3N0cy5jaGVj a0NvbnNpc3RlbmN5KCk7Ci0gICAgUmVmUHRyPEhvc3Q+IGhvc3QgPSBtX2hvc3RzLmdldChob3N0 TmFtZS5pbXBsKCkpOwotICAgIEFTU0VSVChob3N0KTsKLSAgICBpZiAoIWhvc3QpCi0gICAgICAg IHJldHVybjsKLQotICAgIGhvc3QtPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKCk7Ci19Ci0KIHZv aWQgTG9hZGVyOjpjYW5jZWxSZXF1ZXN0cyhDYWNoZWRSZXNvdXJjZUxvYWRlciogY2FjaGVkUmVz b3VyY2VMb2FkZXIpCiB7CiAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNsZWFyUGVuZGluZ1By ZWxvYWRzKCk7CkBAIC0yNjgsMTEgKzIxOSw5IEBACiAgICAgQVNTRVJUKGNhY2hlZFJlc291cmNl TG9hZGVyLT5yZXF1ZXN0Q291bnQoKSA9PSAoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmxvYWRJblBy b2dyZXNzKCkgPyAxIDogMCkpOwogfQogCi1Mb2FkZXI6Okhvc3Q6Okhvc3QoY29uc3QgQXRvbWlj U3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0KQorTG9hZGVyOjpIb3N0 OjpIb3N0KGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkKICAgICA6IG1fbmFtZShuYW1lKQotICAg ICwgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0KG1heFJlcXVlc3RzSW5GbGlnaHQpCiAgICAgLCBtX251 bVJlc291cmNlc1Byb2Nlc3NpbmcoMCkKLSAgICAsIG1fbm9uQ2FjaGVkUmVxdWVzdHNJbkZsaWdo dCgwKQogewogfQogCkBAIC0yODcsMjAgKzIzNiw3IEBACiB7CiAgICAgbV9yZXF1ZXN0c1BlbmRp bmdbcHJpb3JpdHldLmFwcGVuZChyZXF1ZXN0KTsKIH0KLSAgICAKLXZvaWQgTG9hZGVyOjpIb3N0 Ojpub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpCi17Ci0gICAgKyttX25vbkNhY2hlZFJlcXVlc3Rz SW5GbGlnaHQ7Ci19CiAKLXZvaWQgTG9hZGVyOjpIb3N0Ojpub25DYWNoZVJlcXVlc3RDb21wbGV0 ZSgpCi17Ci0gICAgLS1tX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQ7Ci0gICAgQVNTRVJUKG1f bm9uQ2FjaGVkUmVxdWVzdHNJbkZsaWdodCA+PSAwKTsKLQotICAgIGNhY2hlKCktPmxvYWRlcigp LT5zY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Ci19Ci0KIGJvb2wgTG9hZGVyOjpIb3N0 OjpoYXNSZXF1ZXN0cygpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3JlcXVlc3RzTG9hZGluZy5pc0Vt cHR5KCkpCkBAIC0zMTcsMjYgKzI1MywxNyBAQAogICAgIGlmIChjYWNoZSgpLT5sb2FkZXIoKS0+ aXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIGJv b2wgc2VydmVNb3JlID0gdHJ1ZTsKLSAgICBmb3IgKGludCBwcmlvcml0eSA9IEhpZ2g7IHByaW9y aXR5ID49IG1pbmltdW1Qcmlvcml0eSAmJiBzZXJ2ZU1vcmU7IC0tcHJpb3JpdHkpCi0gICAgICAg IHNlcnZlUGVuZGluZ1JlcXVlc3RzKG1fcmVxdWVzdHNQZW5kaW5nW3ByaW9yaXR5XSwgc2VydmVN b3JlKTsKKyAgICBmb3IgKGludCBwcmlvcml0eSA9IEhpZ2g7IHByaW9yaXR5ID49IG1pbmltdW1Q cmlvcml0eTsgLS1wcmlvcml0eSkKKyAgICAgICAgc2VydmVQZW5kaW5nUmVxdWVzdHMobV9yZXF1 ZXN0c1BlbmRpbmdbcHJpb3JpdHldKTsKIH0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OnNlcnZlUGVu ZGluZ1JlcXVlc3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBib29sJiBzZXJ2ZUxv d2VyUHJpb3JpdHkpCit2b2lkIExvYWRlcjo6SG9zdDo6c2VydmVQZW5kaW5nUmVxdWVzdHMoUmVx dWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcpCiB7CiAgICAgd2hpbGUgKCFyZXF1ZXN0c1BlbmRp bmcuaXNFbXB0eSgpKSB7ICAgICAgICAKICAgICAgICAgUmVxdWVzdCogcmVxdWVzdCA9IHJlcXVl c3RzUGVuZGluZy5maXJzdCgpOwogICAgICAgICBDYWNoZWRSZXNvdXJjZUxvYWRlciogY2FjaGVk UmVzb3VyY2VMb2FkZXIgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZUxvYWRlcigpOwogICAgICAg ICBib29sIHJlc291cmNlSXNDYWNoZVZhbGlkYXRvciA9IHJlcXVlc3QtPmNhY2hlZFJlc291cmNl KCktPmlzQ2FjaGVWYWxpZGF0b3IoKTsKIAotICAgICAgICAvLyBGb3IgbmFtZWQgaG9zdHMgLSB3 aGljaCBhcmUgb25seSBodHRwKHMpIGhvc3RzIC0gd2Ugc2hvdWxkIGFsd2F5cyBlbmZvcmNlIHRo ZSBjb25uZWN0aW9uIGxpbWl0LgotICAgICAgICAvLyBGb3Igbm9uLW5hbWVkIGhvc3RzIC0gZXZl cnl0aGluZyBidXQgaHR0cChzKSAtIHdlIHNob3VsZCBvbmx5IGVuZm9yY2UgdGhlIGxpbWl0IGlm IHRoZSBkb2N1bWVudCBpc24ndCBkb25lIHBhcnNpbmcgCi0gICAgICAgIC8vIGFuZCB3ZSBkb24n dCBrbm93IGFsbCBzdHlsZXNoZWV0cyB5ZXQuCi0gICAgICAgIGJvb2wgc2hvdWxkTGltaXRSZXF1 ZXN0cyA9ICFtX25hbWUuaXNOdWxsKCkgfHwgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRvYygpLT5w YXJzaW5nKCkgfHwgIWNhY2hlZFJlc291cmNlTG9hZGVyLT5kb2MoKS0+aGF2ZVN0eWxlc2hlZXRz TG9hZGVkKCk7Ci0gICAgICAgIGlmIChzaG91bGRMaW1pdFJlcXVlc3RzICYmIG1fcmVxdWVzdHNM b2FkaW5nLnNpemUoKSArIG1fbm9uQ2FjaGVkUmVxdWVzdHNJbkZsaWdodCA+PSBtX21heFJlcXVl c3RzSW5GbGlnaHQpIHsKLSAgICAgICAgICAgIHNlcnZlTG93ZXJQcmlvcml0eSA9IGZhbHNlOwot ICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9CiAgICAgICAgIHJlcXVlc3RzUGVuZGluZy5y ZW1vdmVGaXJzdCgpOwogICAgICAgICAKICAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlc291cmNl UmVxdWVzdChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT51cmwoKSk7CkluZGV4OiBXZWJDb3Jl L2xvYWRlci9PcGVuQ29ubmVjdGlvbkxpbWl0ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv bG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L2xvYWRlci9PcGVuQ29ubmVjdGlvbkxpbWl0ZXIuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDEwMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0Ogor ICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisg KiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdv b2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiT3BlbkNvbm5lY3Rpb25M aW1pdGVyLmgiCisKKyNpbmNsdWRlICJLVVJMLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcu aCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3RCYXNlLmgiCisjaW5jbHVkZSA8d3RmL0hhc2hN YXAuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICAKK3N0YXRpYyB1bnNpZ25lZCBzX25vbkhUVFBSZXF1ZXN0Q291bnQgPSAwOwor CisvLyBIYXZpbmcgYSBsaW1pdCBtaWdodCBzdGlsbCBoZWxwIGdldHRpbmcgbW9yZSBpbXBvcnRh bnQgcmVzb3VyY2VzIGZpcnN0CitzdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZs aWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAyMDsKKworc3RhdGljIHVuc2lnbmVkIG1heFJlcXVl c3RzSW5GbGlnaHRQZXJIb3N0KCkKK3sKKyAgICAvLyBNYXRjaCB0aGUgcGFyYWxsZWwgY29ubmVj dGlvbiBjb3VudCB1c2VkIGJ5IHRoZSBuZXR3b3JraW5nIGxheWVyCisgICAgc3RhdGljIGNvbnN0 IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0ID0gaW5pdGlhbGl6ZU1heGltdW1I VFRQQ29ubmVjdGlvbkNvdW50UGVySG9zdCgpOworICAgIHJldHVybiBtYXhSZXF1ZXN0c0luRmxp Z2h0UGVySG9zdDsKK30KKyAgICAKK3R5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIGludCwgU3RyaW5n SGFzaD4gUmVxdWVzdHNQZXJIb3N0TWFwOworc3RhdGljIFJlcXVlc3RzUGVySG9zdE1hcCYgcmVx dWVzdHNQZXJIb3N0TWFwKCkKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFJlcXVlc3RzUGVy SG9zdE1hcCwgcmVxdWVzdHNQZXJIb3N0Q291bnQsICgpKTsKKyAgICByZXF1ZXN0c1Blckhvc3RD b3VudC5jaGVja0NvbnNpc3RlbmN5KCk7CisgICAgcmV0dXJuIHJlcXVlc3RzUGVySG9zdENvdW50 OworfQorCit2b2lkIE9wZW5Db25uZWN0aW9uTGltaXRlcjo6aW5jcmVtZW50SG9zdFJlcXVlc3RD b3VudChjb25zdCBLVVJMJiB1cmwpCit7CisgICAgaWYgKCF1cmwucHJvdG9jb2xJbkhUVFBGYW1p bHkoKSkgeworICAgICAgICBzX25vbkhUVFBSZXF1ZXN0Q291bnQrKzsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKyAgICBTdHJpbmcgaG9zdCA9IHVybC5ob3N0KCk7CisgICAgcmVxdWVzdHNQZXJI b3N0TWFwKCkuc2V0KGhvc3QsIHJlcXVlc3RzUGVySG9zdE1hcCgpLmdldChob3N0KSArIDEpOwor fQorCit2b2lkIE9wZW5Db25uZWN0aW9uTGltaXRlcjo6ZGVjcmVtZW50SG9zdFJlcXVlc3RDb3Vu dChjb25zdCBLVVJMJiB1cmwpCit7CisgICAgaWYgKCF1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHko KSkgeworICAgICAgICBBU1NFUlQoc19ub25IVFRQUmVxdWVzdENvdW50ID4gMCk7CisgICAgICAg IHNfbm9uSFRUUFJlcXVlc3RDb3VudC0tOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIFN0 cmluZyBob3N0ID0gdXJsLmhvc3QoKTsKKyAgICBBU1NFUlQocmVxdWVzdHNQZXJIb3N0TWFwKCku Y29udGFpbnMoaG9zdCkpOworICAgIGludCByZXF1ZXN0Q291bnQgPSByZXF1ZXN0c1Blckhvc3RN YXAoKS5nZXQoaG9zdCkgLSAxOworICAgIEFTU0VSVChyZXF1ZXN0Q291bnQgPj0gMCk7CisgICAg CisgICAgaWYgKHJlcXVlc3RDb3VudCkKKyAgICAgICAgcmVxdWVzdHNQZXJIb3N0TWFwKCkuc2V0 KGhvc3QsIHJlcXVlc3RDb3VudCk7CisgICAgZWxzZQorICAgICAgICByZXF1ZXN0c1Blckhvc3RN YXAoKS5yZW1vdmUoaG9zdCk7Cit9CisKK2Jvb2wgT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpzaG91 bGRUaHJvdHRsZVJlcXVlc3QoY29uc3QgS1VSTCYgdXJsKQoreworICAgIGlmICghdXJsLnByb3Rv Y29sSW5IVFRQRmFtaWx5KCkpCisgICAgICAgIHJldHVybiBzX25vbkhUVFBSZXF1ZXN0Q291bnQg Pj0gbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHM7CisKKyAgICB1bnNpZ25l ZCByZXF1ZXN0Q291bnQgPSByZXF1ZXN0c1Blckhvc3RNYXAoKS5nZXQodXJsLmhvc3QoKSk7Cisg ICAgcmV0dXJuIHJlcXVlc3RDb3VudCA+PSBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCgpOwor fQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCg== 70122 2010-10-07 11:13:44 -0700 2010-10-08 16:30:45 -0700 Rewrite - include scheduling (as well as throttling) in OpenConnectionLimiter ocl3.txt text/plain 63543 japhet SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTAtMTAtMDcgIE5hdGUgQ2hhcGluICA8amFwaGV0 QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBGdW5jdGlvbiBjYWxsIHVwZGF0ZSBmb3IgCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzE2NS4KKworICAgICAgICAqIFdlYlZpZXcvV2Vi Vmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3Rz XSk6CisKIDIwMTAtMTAtMDUgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcnRpbiBSb2JpbnNvbi4KSW5kZXg6IFdlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3Lm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9X ZWJWaWV3Lm1tCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 Lm1tCSh3b3JraW5nIGNvcHkpCkBAIC0xMzksNiArMTM5LDcgQEAKICNpbXBvcnQgPFdlYkNvcmUv TG9nZ2luZy5oPgogI2ltcG9ydCA8V2ViQ29yZS9NSU1FVHlwZVJlZ2lzdHJ5Lmg+CiAjaW1wb3J0 IDxXZWJDb3JlL05vZGVMaXN0Lmg+CisjaW1wb3J0IDxXZWJDb3JlL09wZW5Db25uZWN0aW9uTGlt aXRlci5oPgogI2ltcG9ydCA8V2ViQ29yZS9QYWdlLmg+CiAjaW1wb3J0IDxXZWJDb3JlL1BhZ2VD YWNoZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9QYWdlR3JvdXAuaD4KQEAgLTYxOSw3ICs2MjAsNyBA QAogCiAtICh2b2lkKV9kaXNwYXRjaFBlbmRpbmdMb2FkUmVxdWVzdHMKIHsKLSAgICBjYWNoZSgp LT5sb2FkZXIoKS0+c2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKKyAgICBvcGVuQ29ubmVjdGlvbkxp bWl0ZXIoKS0+c2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKIH0KIAogLSAodm9pZClfcmVnaXN0ZXJE cmFnZ2VkVHlwZXMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5leHAuaW4KPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9XZWJDb3JlLmV4cC5pbgkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL1dlYkNv cmUuZXhwLmluCSh3b3JraW5nIGNvcHkpCkBAIC00NDMsNiArNDQzLDcgQEAKIF9fWk43V2ViQ29y ZTIwUmVzb3VyY2VSZXNwb25zZUJhc2VDMkV2CiBfX1pON1dlYkNvcmUyMFNwYWNlU3BsaXRTdHJp bmdEYXRhMTJjcmVhdGVWZWN0b3JFdgogX19aTjdXZWJDb3JlMjBwcm90b2NvbElzSmF2YVNjcmlw dEVSS04zV1RGNlN0cmluZ0UKK19fWk43V2ViQ29yZTIxT3BlbkNvbm5lY3Rpb25MaW1pdGVyMjBz ZXJ2ZVBlbmRpbmdSZXF1ZXN0c0VOUzBfOFByaW9yaXR5RQogX19aTjdXZWJDb3JlMjFQbGF0Zm9y bUtleWJvYXJkRXZlbnQyNGRpc2FtYmlndWF0ZUtleURvd25FdmVudEVOUzBfNFR5cGVFYgogX19a TjdXZWJDb3JlMjFQbGF0Zm9ybUtleWJvYXJkRXZlbnRDMUVQN05TRXZlbnQKIF9fWk43V2ViQ29y ZTIxU1ZHRG9jdW1lbnRFeHRlbnNpb25zMjFzYW1wbGVBbmltYXRpb25BdFRpbWVFUktOM1dURjZT dHJpbmdFUE5TXzE0U1ZHU01JTEVsZW1lbnRFZApAQCAtNDU2LDYgKzQ1Nyw3IEBACiBfX1pON1dl YkNvcmUyMWlzQmFja0ZvcndhcmRMb2FkVHlwZUVOU18xM0ZyYW1lTG9hZFR5cGVFCiBfX1pON1dl YkNvcmUyMW1haW5UaHJlYWROb3JtYWxXb3JsZEV2CiBfX1pON1dlYkNvcmUyMW1hcmtlclRleHRG b3JMaXN0SXRlbUVQTlNfN0VsZW1lbnRFCitfX1pON1dlYkNvcmUyMW9wZW5Db25uZWN0aW9uTGlt aXRlckV2CiBfX1pON1dlYkNvcmUyMXJlcG9ydFRocmVhZFZpb2xhdGlvbkVQS2NOU18yMFRocmVh ZFZpb2xhdGlvblJvdW5kRQogX19aTjdXZWJDb3JlMjFzZXRQbGF0Zm9ybVN0cmF0ZWdpZXNFUE5T XzE4UGxhdGZvcm1TdHJhdGVnaWVzRQogX19aTjdXZWJDb3JlMjJTY3JpcHRFeGVjdXRpb25Db250 ZXh0MjZjYW5TdXNwZW5kQWN0aXZlRE9NT2JqZWN0c0V2CkBAIC02NTQsNyArNjU2LDYgQEAKIF9f Wk43V2ViQ29yZTZFZGl0b3I3Q29tbWFuZEMxRXYKIF9fWk43V2ViQ29yZTZFZGl0b3I3Y29tbWFu ZEVSS04zV1RGNlN0cmluZ0UKIF9fWk43V2ViQ29yZTZFZGl0b3I3b3V0ZGVudEV2Ci1fX1pON1dl YkNvcmU2TG9hZGVyMjBzZXJ2ZVBlbmRpbmdSZXF1ZXN0c0VOUzBfOFByaW9yaXR5RQogX19aTjdX ZWJDb3JlNldpZGdldDEyc2V0RnJhbWVSZWN0RVJLTlNfN0ludFJlY3RFCiBfX1pON1dlYkNvcmU2 V2lkZ2V0MTZyZW1vdmVGcm9tUGFyZW50RXYKIF9fWk43V2ViQ29yZTZXaWRnZXQxN2ZyYW1lUmVj dHNDaGFuZ2VkRXYKSW5kZXg6IFdlYkNvcmUvZG9tL0NvbnRhaW5lck5vZGUuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvZG9tL0NvbnRhaW5lck5vZGUuY3BwCShyZXZpc2lvbiA2OTMxMykKKysr IFdlYkNvcmUvZG9tL0NvbnRhaW5lck5vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNSwxMSAr MzUsMTEgQEAKICNpbmNsdWRlICJJbmxpbmVUZXh0Qm94LmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9y SW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiTXV0YXRpb25FdmVudC5oIgorI2luY2x1ZGUg Ik9wZW5Db25uZWN0aW9uTGltaXRlci5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRlICJS ZW5kZXJCb3guaCIKICNpbmNsdWRlICJSZW5kZXJUaGVtZS5oIgogI2luY2x1ZGUgIlJvb3RJbmxp bmVCb3guaCIKLSNpbmNsdWRlICJsb2FkZXIuaCIKICNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUu aD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAKQEAgLTY1Nyw3ICs2NTcsNyBAQAogICAgICAg ICAgICAgICAgIHNfc2hvdWxkUmVFbmFibGVNZW1vcnlDYWNoZUNhbGxzQWZ0ZXJBdHRhY2ggPSB0 cnVlOwogICAgICAgICAgICAgfQogICAgICAgICB9Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigp LT5zdXNwZW5kUGVuZGluZ1JlcXVlc3RzKCk7CisgICAgICAgIG9wZW5Db25uZWN0aW9uTGltaXRl cigpLT5zdXNwZW5kUGVuZGluZ1JlcXVlc3RzKCk7CiAgICAgfQogICAgICsrc19hdHRhY2hEZXB0 aDsKIH0KQEAgLTY3Miw3ICs2NzIsNyBAQAogICAgICAgICAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBk b2N1bWVudCgpLT5wYWdlKCkpCiAgICAgICAgICAgICAgICAgcGFnZS0+c2V0TWVtb3J5Q2FjaGVD bGllbnRDYWxsc0VuYWJsZWQodHJ1ZSk7CiAgICAgICAgIH0KLSAgICAgICAgY2FjaGUoKS0+bG9h ZGVyKCktPnJlc3VtZVBlbmRpbmdSZXF1ZXN0cygpOworICAgICAgICBvcGVuQ29ubmVjdGlvbkxp bWl0ZXIoKS0+cmVzdW1lUGVuZGluZ1JlcXVlc3RzKCk7CiAgICAgfQogICAgIC0tc19hdHRhY2hE ZXB0aDsKIH0KSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9XZWJDb3JlLnBybwkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3 b3JraW5nIGNvcHkpCkBAIC0xMDM5LDYgKzEwMzksNyBAQAogICAgIGxvYWRlci9NYWluUmVzb3Vy Y2VMb2FkZXIuY3BwIFwKICAgICBsb2FkZXIvTmF2aWdhdGlvbkFjdGlvbi5jcHAgXAogICAgIGxv YWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAgXAorICAgIGxvYWRlci9PcGVuQ29u bmVjdGlvbkxpbWl0ZXIuY3BwIFwKICAgICBsb2FkZXIvUGluZ0xvYWRlci5jcHAgXAogICAgIGxv YWRlci9QbGFjZWhvbGRlckRvY3VtZW50LmNwcCBcCiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNr LmNwcCBcCkluZGV4OiBXZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL0No YW5nZUxvZwkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDg4IEBACisyMDEwLTEwLTA3ICBOYXRlIENoYXBpbiAgPGphcGhldEBj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgTW92ZSBjb25uZWN0aW9uLXBlci1ob3N0IGNvdW50aW5nIGFuZCByZXF1ZXN0IHByaW9y aXRpemF0aW9uIG91dAorICAgICAgICBvZiBMb2FkZXIgYW5kIGRvd24gdG8gdGhlIFJlc291cmNl TG9hZGVyIGxldmVsLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNzE2NQorCisgICAgICAgIFJlZmFjdG9yIG9ubHksIHNvIG5vIG5ldyB0ZXN0cy4g QmVjYXVzZSBhc3luYyBYSFJzIGFyZSBzdWJqZWN0IHRvIHByaW9yaXRpemF0aW9uIGFuZAorICAg ICAgICBubyBsb25nZXIgZ3VhcmFudGVlZCB0byBiZSBzdGFydGVkIHN5bmNocm9ub3VzbHksIG9u ZSB0ZXN0IGlzIGJlaW5nIG1vZGlmaWVkLgorCisgICAgICAgICogQW5kcm9pZC5tazoKKyAgICAg ICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAg KiBXZWJDb3JlLmV4cC5pbjoKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogV2Vi Q29yZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2o6CisgICAg ICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGRvbS9D b250YWluZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5lck5vZGU6OnN1c3Bl bmRQb3N0QXR0YWNoQ2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5lck5vZGU6 OnJlc3VtZVBvc3RBdHRhY2hDYWxsYmFja3MpOgorICAgICAgICAqIGxvYWRlci9NYWluUmVzb3Vy Y2VMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFpblJlc291cmNlTG9hZGVyOjpsb2Fk Tm93KTogVGVsbCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIgdGhhdCBhIG1haW4KKyAgICAgICAgICAg ICByZXNvdXJjZSBsb2FkIHdhcyB0cmlnZ2VyZWQuCisgICAgICAgICogbG9hZGVyL09wZW5Db25u ZWN0aW9uTGltaXRlci5jcHA6IEFkZGVkIChtb3ZlZCBmcm9tIGxvYWRlci5jcHAKKyAgICAgICAg ICAgIHVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkKS4KKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5D b25uZWN0aW9uTGltaXRlcjo6ZGV0ZXJtaW5lUHJpb3JpdHkpOiBNb3ZlZCBmcm9tIGxvYWRlci5j cHAsIHNldAorICAgICAgICAgICAgYmFzZWQgb24gUmVzb3VyY2VSZXF1ZXN0IHR5cGUgcmF0aGVy IHRoYW4gQ2FjaGVkUmVzb3VyY2UgdHlwZS4KKyAgICAgICAgKFdlYkNvcmU6Om9wZW5Db25uZWN0 aW9uTGltaXRlcik6IFJldHVybnMgdGhlIHNpbmdsZSBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIgaW5z dGFuY2UuCisgICAgICAgIChXZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Ok9wZW5Db25u ZWN0aW9uTGltaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6 OnNjaGVkdWxlKTogTW92ZWQgZnJvbSBMb2FkZXI6OmxvYWQoKQorICAgICAgICAoV2ViQ29yZTo6 T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjplbmQpOiBSZW1vdmUgYSBSZXNvdXJjZUxvYWRlciBmcm9t IG91ciBjb3VudC4KKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5Db25uZWN0aW9uTGltaXRlcjo6Y2hh bmdlSG9zdCk6IE1vdmUgYSBSZXNvdXJjZUxvYWRlciBmcm9tIG9uZQorICAgICAgICAgICAgIGhv c3QncyBhY2NvdW50aW5nIHRvIGFub3RoZXIgKGZvciBjcm9zcy1vcmlnaW4gcmVkaXJlY3RzKS4K KyAgICAgICAgKFdlYkNvcmU6Ok9wZW5Db25uZWN0aW9uTGltaXRlcjo6YWRkUmVxdWVzdFdpdGhv dXRTY2hlZHVsZSk6IFJlZ2lzdGVyIGEgbWFpbiByZXNvdXJjZQorICAgICAgICAgICAgIGxvYWQs IHNvIHdlIGRvbid0IHVuZGVyY291bnQgcmVxdWVzdHMgaW4gZmxpZ2h0LgorICAgICAgICAoV2Vi Q29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyk6CisgICAg ICAgIChXZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OnN1c3BlbmRQZW5kaW5nUmVxdWVz dHMpOgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpyZXN1bWVQZW5k aW5nUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpz Y2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKToKKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5Db25u ZWN0aW9uTGltaXRlcjo6cmVxdWVzdFRpbWVyRmlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6T3Bl bkNvbm5lY3Rpb25MaW1pdGVyOjpIb3N0OjpIb3N0KToKKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5D b25uZWN0aW9uTGltaXRlcjo6SG9zdDo6fkhvc3QpOgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNv bm5lY3Rpb25MaW1pdGVyOjpIb3N0OjphZGRSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6Ok9w ZW5Db25uZWN0aW9uTGltaXRlcjo6SG9zdDo6YWRkUmVxdWVzdFdpdGhvdXRTY2hlZHVsZSk6Cisg ICAgICAgIChXZWJDb3JlOjpPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Okhvc3Q6Omhhc1JlcXVlc3Rz KToKKyAgICAgICAgKFdlYkNvcmU6Ok9wZW5Db25uZWN0aW9uTGltaXRlcjo6SG9zdDo6c2VydmVQ ZW5kaW5nUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVy OjpIb3N0OjplbmQpOiBSZW1vdmUgdGhlIFJlc291cmNlTG9hZGVyIGlmIHdlIGNhbgorICAgICAg ICAgICAgZmluZCBpdC4KKyAgICAgICAgKiBsb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmg6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpIb3N0Ojpj cmVhdGUpOiBNb3ZlZCBmcm9tIGxvYWRlci5oLgorICAgICAgICAoV2ViQ29yZTo6T3BlbkNvbm5l Y3Rpb25MaW1pdGVyOjpIb3N0OjpuYW1lKTogTW92ZWQgZnJvbSBsb2FkZXIuaC4KKyAgICAgICAg KiBsb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VM b2FkZXI6OnJlbGVhc2VSZXNvdXJjZXMpOiBSZW1vdmUgdGhpcyBmcm9tIE9wZW5Db25uZWN0aW9u TGltaXRlcgorICAgICAgICAgICAgY291bnRpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJj ZUxvYWRlcjo6bG9hZCk6IFNjaGVkdWxlIHRoZSBjcmVhdGlvbiBvZiB0aGUgUmVzb3VyY2VIYW5k bGUsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBkb2luZyBpdCBpbW1lZGlhdGVseS4KKyAgICAg ICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZGVyOjpzdGFydCk6IENyZWF0ZSB0aGUgUmVzb3VyY2VI YW5kbGUsIGNhbGxlZCBieQorICAgICAgICAgICAgT3BlbkNvbm5lY3Rpb25MSW1pdGVyOjpIb3N0 OjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpLgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2Fk ZXI6OndpbGxTZW5kUmVxdWVzdCk6IEVuc3VyZSBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIgY291bnRz CisgICAgICAgICAgICByZWRpcmVjdHMgY29ycmVjdGx5LgorICAgICAgICAqIGxvYWRlci9SZXNv dXJjZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9sb2FkZXIuY3BwOiBNb3ZlIHNjaGVkdWxp bmcgdG8gT3BlbkNvbm5lY3Rpb25MaW1pdGVyLCByZW1vdmUgSG9zdCBzdWJjbGFzcworICAgICAg ICAgICAgYW5kIG1ha2UgTG9hZGVyIHRoZSBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCBpbnN0ZWFk LgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpsb2FkKToKKyAgICAgICAgKFdlYkNvcmU6Okxv YWRlcjo6Y2FuY2VsUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpkaWRGaW5p c2hMb2FkaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGlkRmFpbCk6CisgICAgICAg IChXZWJDb3JlOjpMb2FkZXI6OmRpZFJlY2VpdmVSZXNwb25zZSk6CisgICAgICAgIChXZWJDb3Jl OjpMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGlk UmVjZWl2ZUNhY2hlZE1ldGFkYXRhKToKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmg6CisgICAg ICAgICogcGFnZS9FdmVudFNvdXJjZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFNvdXJj ZTo6Y29ubmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFNvdXJjZTo6ZW5kUmVxdWVzdCk6 CisgICAgICAgICogeG1sL1hNTEh0dHBSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhN TEh0dHBSZXF1ZXN0OjpYTUxIdHRwUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpYTUxIdHRw UmVxdWVzdDo6flhNTEh0dHBSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1 ZXN0OjpjcmVhdGVSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0Ojpk aWRGYWlsKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpkaWRGaW5pc2hMb2Fk aW5nKToKKyAgICAgICAgKiB4bWwvWE1MSHR0cFJlcXVlc3QuaDoKKwogMjAxMC0xMC0wNSAgRGll Z28gR29uemFsZXogIDxkaWVnb2hjZ0B3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEFuZHJlYXMgS2xpbmcuCkluZGV4OiBXZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oJ KHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJv agkod29ya2luZyBjb3B5KQpAQCAtMjM4MzksNiArMjM4MzksMTQgQEAKIAkJCQk+DQogCQkJPC9G aWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cbG9hZGVyXE9wZW5Db25uZWN0 aW9uTGltaXRlci5jcHAiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCisJCQkJUmVs YXRpdmVQYXRoPSIuLlxsb2FkZXJcT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmgiDQorCQkJCT4NCisJ CQk8L0ZpbGU+DQorCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcUGluZ0xv YWRlci5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50 U291cmNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRXZlbnRTb3VyY2UuY3BwCShy ZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvcGFnZS9FdmVudFNvdXJjZS5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTExNiw5ICsxMTYsNiBAQAogICAgIG1fbG9hZGVyID0gVGhyZWFkYWJsZUxvYWRl cjo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgdGhpcywgcmVxdWVzdCwgb3B0aW9u cyk7CiAKICAgICBtX3JlcXVlc3RJbkZsaWdodCA9IHRydWU7Ci0KLSAgICBpZiAoIXNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKS0+aXNXb3JrZXJDb250ZXh0KCkpCi0gICAgICAgIGNhY2hlKCktPmxv YWRlcigpLT5ub25DYWNoZVJlcXVlc3RJbkZsaWdodChtX3VybCk7CiB9CiAKIHZvaWQgRXZlbnRT b3VyY2U6OmVuZFJlcXVlc3QoKQpAQCAtMTI4LDkgKzEyNSw2IEBACiAgICAgaWYgKCFtX2ZhaWxT aWxlbnRseSkKICAgICAgICAgZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMo KS5lcnJvckV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKIAotICAgIGlmICghc2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpLT5pc1dvcmtlckNvbnRleHQoKSkKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCkt Pm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1fdXJsKTsKLQogICAgIGlmIChtX3N0YXRlICE9IENM T1NFRCkKICAgICAgICAgc2NoZWR1bGVSZWNvbm5lY3QoKTsKICAgICBlbHNlCkluZGV4OiBXZWJD b3JlL0dOVW1ha2VmaWxlLmFtCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0J KHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQkod29ya2luZyBjb3B5 KQpAQCAtMTkzOCw2ICsxOTM4LDggQEAKIAlXZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9u LmggXAogCVdlYkNvcmUvbG9hZGVyL05ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyLmNwcCBcCiAJ V2ViQ29yZS9sb2FkZXIvTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXIuaCBcCisJV2ViQ29yZS9s b2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcCBcCisJV2ViQ29yZS9sb2FkZXIvT3BlbkNv bm5lY3Rpb25MaW1pdGVyLmggXAogCVdlYkNvcmUvbG9hZGVyL1BpbmdMb2FkZXIuY3BwIFwKIAlX ZWJDb3JlL2xvYWRlci9QaW5nTG9hZGVyLmggXAogCVdlYkNvcmUvbG9hZGVyL1BsYWNlaG9sZGVy RG9jdW1lbnQuY3BwIFwKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvV2ViQ29yZS5neXBpCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvV2ViQ29y ZS5neXBpCSh3b3JraW5nIGNvcHkpCkBAIC0yMDU0LDYgKzIwNTQsOCBAQAogICAgICAgICAgICAg J2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmgnLAogICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2Fw ZVBsdWdJblN0cmVhbUxvYWRlci5jcHAnLAogICAgICAgICAgICAgJ2xvYWRlci9OZXRzY2FwZVBs dWdJblN0cmVhbUxvYWRlci5oJywKKyAgICAgICAgICAgICdsb2FkZXIvT3BlbkNvbm5lY3Rpb25M aW1pdGVyLmNwcCcsCisgICAgICAgICAgICAnbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5o JywKICAgICAgICAgICAgICdsb2FkZXIvUGluZ0xvYWRlci5jcHAnLAogICAgICAgICAgICAgJ2xv YWRlci9QaW5nTG9hZGVyLmgnLAogICAgICAgICAgICAgJ2xvYWRlci9QbGFjZWhvbGRlckRvY3Vt ZW50LmNwcCcsCkluZGV4OiBXZWJDb3JlL0NNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvQ01ha2VMaXN0cy50eHQJKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9DTWFrZUxp c3RzLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMTE0NCw2ICsxMTQ0LDcgQEAKICAgICBsb2FkZXIv TWFpblJlc291cmNlTG9hZGVyLmNwcAogICAgIGxvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcAog ICAgIGxvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAKKyAgICBsb2FkZXIvT3Bl bkNvbm5lY3Rpb25Mb2FkZXIuY3BwCiAgICAgbG9hZGVyL1BpbmdMb2FkZXIuY3BwCiAgICAgbG9h ZGVyL1BsYWNlaG9sZGVyRG9jdW1lbnQuY3BwCiAgICAgbG9hZGVyL1BvbGljeUNhbGxiYWNrLmNw cApJbmRleDogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlz aW9uIDY5MzEzKQorKysgV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJ KHdvcmtpbmcgY29weSkKQEAgLTUyNjcsNiArNTI2Nyw4IEBACiAJCUQwMDBFRDI4MTFDMUI5Q0Qw MEM0NzcyNiAvKiBTdWJmcmFtZUxvYWRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRDAwMEVEMjYxMUMxQjlDRDAwQzQ3NzI2IC8qIFN1YmZyYW1lTG9h ZGVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ RDAxQTI3QUQxMEM5QkZEODAwMDI2QTQyIC8qIFNwYWNlU3BsaXRTdHJpbmcuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDAxQTI3QUIxMEM5QkZEODAw MDI2QTQyIC8qIFNwYWNlU3BsaXRTdHJpbmcuY3BwICovOyB9OwogCQlEMDFBMjdBRTEwQzlCRkQ4 MDAwMjZBNDIgLyogU3BhY2VTcGxpdFN0cmluZy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gRDAxQTI3QUMxMEM5QkZEODAwMDI2QTQyIC8qIFNwYWNlU3Bs aXRTdHJpbmcuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OworCQlEMDRBRDNBQTEyNTJCMDhGMDA4MDkzMUYgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwNEFEM0E4 MTI1MkIwOEYwMDgwOTMxRiAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuY3BwICovOyB9OworCQlE MDRBRDNBQjEyNTJCMDhGMDA4MDkzMUYgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMDRBRDNBOTEyNTJCMDhG MDA4MDkzMUYgLyogT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRDA1Q0VEMjkwQTQwQkIyQzAwQzVBRjM4IC8q IEZvcm1hdEJsb2NrQ29tbWFuZC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBEMDVDRUQyNzBBNDBCQjJDMDBDNUFGMzggLyogRm9ybWF0QmxvY2tDb21t YW5kLmNwcCAqLzsgfTsKIAkJRDA1Q0VEMkEwQTQwQkIyQzAwQzVBRjM4IC8qIEZvcm1hdEJsb2Nr Q29tbWFuZC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RDA1Q0VEMjgwQTQwQkIyQzAwQzVBRjM4IC8qIEZvcm1hdEJsb2NrQ29tbWFuZC5oICovOyB9Owog CQlEMDZDMEQ4RjBDRkQxMTQ2MDA2NUY0M0YgLyogUmVtb3ZlRm9ybWF0Q29tbWFuZC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDA2QzBEOEQwQ0ZEMTE0 NjAwNjVGNDNGIC8qIFJlbW92ZUZvcm1hdENvbW1hbmQuaCAqLzsgfTsKQEAgLTExMjY3LDYgKzEx MjY5LDggQEAKIAkJRDAwMEVEMjYxMUMxQjlDRDAwQzQ3NzI2IC8qIFN1YmZyYW1lTG9hZGVyLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFN1YmZyYW1lTG9hZGVyLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUQwMUEyN0FCMTBDOUJGRDgwMDAyNkE0MiAvKiBTcGFj ZVNwbGl0U3RyaW5nLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNw YWNlU3BsaXRTdHJpbmcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMDFBMjdB QzEwQzlCRkQ4MDAwMjZBNDIgLyogU3BhY2VTcGxpdFN0cmluZy5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBTcGFjZVNwbGl0U3RyaW5nLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CisJCUQwNEFEM0E4MTI1MkIwOEYwMDgwOTMxRiAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0 ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gT3BlbkNvbm5lY3Rp b25MaW1pdGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRDA0QUQzQTkxMjUy QjA4RjAwODA5MzFGIC8qIE9wZW5Db25uZWN0aW9uTGltaXRlci5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJRDA1Q0VEMjcwQTQwQkIyQzAwQzVBRjM4IC8qIEZvcm1hdEJsb2NrQ29t bWFuZC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRm9ybWF0Qmxv Y2tDb21tYW5kLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDA1Q0VEMjgwQTQw QkIyQzAwQzVBRjM4IC8qIEZvcm1hdEJsb2NrQ29tbWFuZC5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gRm9ybWF0QmxvY2tDb21tYW5kLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUQwNkMwRDhEMENGRDExNDYwMDY1RjQzRiAvKiBSZW1vdmVGb3JtYXRDb21tYW5k LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJlbW92ZUZvcm1hdENvbW1hbmQu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE3MTI0LDYgKzE3MTI4LDggQEAKIAkJ CQk5M0NDRjAyNjBBRjZDNTI5MDAwMThFODkgLyogTmF2aWdhdGlvbkFjdGlvbi5oICovLAogCQkJ CTkzRTIyN0REMEFGNTg5QUQwMEQ0ODMyNCAvKiBOZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5j cHAgKi8sCiAJCQkJNjU2RDM3MkIwQURCQTVERTAwQTQ1NTREIC8qIE5ldHNjYXBlUGx1Z0luU3Ry ZWFtTG9hZGVyLmggKi8sCisJCQkJRDA0QUQzQTgxMjUyQjA4RjAwODA5MzFGIC8qIE9wZW5Db25u ZWN0aW9uTGltaXRlci5jcHAgKi8sCisJCQkJRDA0QUQzQTkxMjUyQjA4RjAwODA5MzFGIC8qIE9w ZW5Db25uZWN0aW9uTGltaXRlci5oICovLAogCQkJCUQwRkYyQTVCMTFGOEM0NUEwMDdFNzRFMCAv KiBQaW5nTG9hZGVyLmNwcCAqLywKIAkJCQlEMEZGMkE1QzExRjhDNDVBMDA3RTc0RTAgLyogUGlu Z0xvYWRlci5oICovLAogCQkJCTM3N0M0Q0RFMTAxNEU5RjYwMEI5QUU0MiAvKiBQbGFjZWhvbGRl ckRvY3VtZW50LmNwcCAqLywKQEAgLTIxMDM3LDYgKzIxMDQzLDcgQEAKIAkJCQk5M0YxOTlFRDA4 MjQ1RTU5MDAxRTlBQkMgLyogWFNMVFByb2Nlc3Nvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTFC RTUxMkUwQ0Y2QzUxMjAwMkVBOTU5IC8qIFhTTFRVbmljb2RlU29ydC5oIGluIEhlYWRlcnMgKi8s CiAJCQkJOTdERDREODcwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuaCBpbiBIZWFkZXJz ICovLAorCQkJCUQwNEFEM0FCMTI1MkIwOEYwMDgwOTMxRiAvKiBPcGVuQ29ubmVjdGlvbkxpbWl0 ZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTQ5ODc3MERDMTI0MkM1MzUwMDIyMjZCQSAvKiBEcmF3 aW5nQnVmZmVyLmggaW4gSGVhZGVycyAqLywKIAkJCQk0OTg3NzBFNDEyNDJDNTM1MDAyMjI2QkEg LyogUE9EQXJlbmEuaCBpbiBIZWFkZXJzICovLAogCQkJCTQ5ODc3MEU1MTI0MkM1MzUwMDIyMjZC QSAvKiBQT0RJbnRlcnZhbC5oIGluIEhlYWRlcnMgKi8sCkBAIC0yMzU5Miw2ICsyMzU5OSw3IEBA CiAJCQkJOTNGMTlCMDUwODI0NUU1OTAwMUU5QUJDIC8qIFhTTFRQcm9jZXNzb3JMaWJ4c2x0LmNw cCBpbiBTb3VyY2VzICovLAogCQkJCUUxQkU1MTJEMENGNkM1MTIwMDJFQTk1OSAvKiBYU0xUVW5p Y29kZVNvcnQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJOTdERDREODYwRkRGNEQ2RTAwRUNGOUE0 IC8qIFhTU0F1ZGl0b3IuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRDA0QUQzQUExMjUyQjA4RjAw ODA5MzFGIC8qIE9wZW5Db25uZWN0aW9uTGltaXRlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk0 OTg3NzBEQjEyNDJDNTM1MDAyMjI2QkEgLyogRHJhd2luZ0J1ZmZlci5jcHAgaW4gU291cmNlcyAq LywKIAkJCQk0OTg3NzBFODEyNDJDNTM1MDAyMjI2QkEgLyogU2hhZGVyLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCTQ5ODc3MEVBMTI0MkM1MzUwMDIyMjZCQSAvKiBTaGFyZWRHcmFwaGljc0NvbnRl eHQzRC5jcHAgaW4gU291cmNlcyAqLywKSW5kZXg6IFdlYkNvcmUvQW5kcm9pZC5tawo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL0FuZHJvaWQubWsJKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9B bmRyb2lkLm1rCSh3b3JraW5nIGNvcHkpCkBAIC0zNjAsNiArMzYwLDcgQEAKIAlsb2FkZXIvTWFp blJlc291cmNlTG9hZGVyLmNwcCBcCiAJbG9hZGVyL05hdmlnYXRpb25BY3Rpb24uY3BwIFwKIAls b2FkZXIvTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXIuY3BwIFwKKwlsb2FkZXIvT3BlbkNvbm5l Y3Rpb25MaW1pdGVyLmNwcCBcCiAJbG9hZGVyL1BpbmdMb2FkZXIuY3BwIFwKIAlsb2FkZXIvUGxh Y2Vob2xkZXJEb2N1bWVudC5jcHAgXAogCWxvYWRlci9Qb2xpY3lDYWxsYmFjay5jcHAgXApJbmRl eDogV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv eG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL3htbC9Y TUxIdHRwUmVxdWVzdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE3OSw3ICsxNzksNiBAQAogICAg ICwgbV91cGxvYWRFdmVudHNBbGxvd2VkKHRydWUpCiAgICAgLCBtX3VwbG9hZENvbXBsZXRlKGZh bHNlKQogICAgICwgbV9zYW1lT3JpZ2luUmVxdWVzdCh0cnVlKQotICAgICwgbV9kaWRUZWxsTG9h ZGVyQWJvdXRSZXF1ZXN0KGZhbHNlKQogICAgICwgbV9yZWNlaXZlZExlbmd0aCgwKQogICAgICwg bV9sYXN0U2VuZExpbmVOdW1iZXIoMCkKICAgICAsIG1fZXhjZXB0aW9uQ29kZSgwKQpAQCAtMTkz LDEwICsxOTIsNiBAQAogCiBYTUxIdHRwUmVxdWVzdDo6flhNTEh0dHBSZXF1ZXN0KCkKIHsKLSAg ICBpZiAobV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0KSB7Ci0gICAgICAgIGNhY2hlKCktPmxv YWRlcigpLT5ub25DYWNoZVJlcXVlc3RDb21wbGV0ZShtX3VybCk7Ci0gICAgICAgIG1fZGlkVGVs bExvYWRlckFib3V0UmVxdWVzdCA9IGZhbHNlOwotICAgIH0KICAgICBpZiAobV91cGxvYWQpCiAg ICAgICAgIG1fdXBsb2FkLT5kaXNjb25uZWN0WE1MSHR0cFJlcXVlc3QoKTsKIApAQCAtNTk5LDE2 ICs1OTQsNiBAQAogICAgICAgICAgICAgLy8gYSByZXF1ZXN0IGlzIGluIHByb2dyZXNzIGJlY2F1 c2Ugd2UgbmVlZCB0byBrZWVwIHRoZSBsaXN0ZW5lcnMgYWxpdmUsCiAgICAgICAgICAgICAvLyBh bmQgdGhleSBhcmUgcmVmZXJlbmNlZCBieSB0aGUgSmF2YVNjcmlwdCB3cmFwcGVyLgogICAgICAg ICAgICAgc2V0UGVuZGluZ0FjdGl2aXR5KHRoaXMpOwotCi0gICAgICAgICAgICAvLyBGb3Igbm93 IHdlIHNob3VsZCBvbmx5IGJhbGFuY2UgdGhlIG5vbkNhY2hlZCByZXF1ZXN0IGNvdW50IGZvciBt YWluLXRocmVhZCBYSFJzIGFuZCBub3QKLSAgICAgICAgICAgIC8vIFdvcmtlciBYSFJzLCBhcyB0 aGUgQ2FjaGUgaXMgbm90IHRocmVhZC1zYWZlLgotICAgICAgICAgICAgLy8gVGhpcyB3aWxsIGJl Y29tZSBpcnJlbGV2YW50IGFmdGVyIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNzE2NSBpcyByZXNvbHZlZC4KLSAgICAgICAgICAgIGlmICghc2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpLT5pc1dvcmtlckNvbnRleHQoKSkgewotICAgICAgICAgICAgICAgIEFTU0VSVChp c01haW5UaHJlYWQoKSk7Ci0gICAgICAgICAgICAgICAgQVNTRVJUKCFtX2RpZFRlbGxMb2FkZXJB Ym91dFJlcXVlc3QpOwotICAgICAgICAgICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNo ZVJlcXVlc3RJbkZsaWdodChtX3VybCk7Ci0gICAgICAgICAgICAgICAgbV9kaWRUZWxsTG9hZGVy QWJvdXRSZXF1ZXN0ID0gdHJ1ZTsKLSAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0gZWxz ZQogICAgICAgICBUaHJlYWRhYmxlTG9hZGVyOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgcmVxdWVzdCwgKnRoaXMsIG9wdGlvbnMpOwpAQCAtOTAw LDEwICs4ODUsNiBAQAogCiB2b2lkIFhNTEh0dHBSZXF1ZXN0OjpkaWRGYWlsKGNvbnN0IFJlc291 cmNlRXJyb3ImIGVycm9yKQogewotICAgIGlmIChtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3Qp IHsKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1f dXJsKTsKLSAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gZmFsc2U7Ci0gICAg fQogCiAgICAgLy8gSWYgd2UgYXJlIGFscmVhZHkgaW4gYW4gZXJyb3Igc3RhdGUsIGZvciBpbnN0 YW5jZSB3ZSBjYWxsZWQgYWJvcnQoKSwgYmFpbCBvdXQgZWFybHkuCiAgICAgaWYgKG1fZXJyb3Ip CkBAIC05MzAsMTEgKzkxMSw2IEBACiAKIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OmRpZEZpbmlzaExv YWRpbmcodW5zaWduZWQgbG9uZyBpZGVudGlmaWVyKQogewotICAgIGlmIChtX2RpZFRlbGxMb2Fk ZXJBYm91dFJlcXVlc3QpIHsKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVx dWVzdENvbXBsZXRlKG1fdXJsKTsKLSAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0 ID0gZmFsc2U7Ci0gICAgfQotCiAgICAgaWYgKG1fZXJyb3IpCiAgICAgICAgIHJldHVybjsKIApJ bmRleDogV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3htbC9YTUxIdHRwUmVxdWVzdC5oCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUveG1sL1hN TEh0dHBSZXF1ZXN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE5Miw3ICsxOTIsNiBAQAogICAgIGJv b2wgbV91cGxvYWRDb21wbGV0ZTsKIAogICAgIGJvb2wgbV9zYW1lT3JpZ2luUmVxdWVzdDsKLSAg ICBib29sIG1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdDsKIAogICAgIC8vIFVzZWQgZm9yIG9u cHJvZ3Jlc3MgdHJhY2tpbmcKICAgICBsb25nIGxvbmcgbV9yZWNlaXZlZExlbmd0aDsKSW5kZXg6 IFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL2xv YWRlci5oCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0yMyw5NCArMjMsMzUgQEAKICNkZWZpbmUgbG9hZGVyX2gKIAogI2luY2x1 ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2lu Y2x1ZGUgIlN1YnJlc291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSAiU3VicmVzb3VyY2VMb2FkZXJD bGllbnQuaCIKLSNpbmNsdWRlICJUaW1lci5oIgotI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2lu Y2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5j bHVkZSA8d3RmL3RleHQvQXRvbWljU3RyaW5nLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQXRvbWlj U3RyaW5nSW1wbC5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCiAgICAgY2xhc3MgQ2FjaGVkUmVzb3VyY2U7CiAgICAgY2xhc3MgQ2FjaGVkUmVzb3Vy Y2VMb2FkZXI7Ci0gICAgY2xhc3MgS1VSTDsKICAgICBjbGFzcyBSZXF1ZXN0OwogCi0gICAgY2xh c3MgTG9hZGVyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBjbGFzcyBMb2FkZXIgOiBwdWJs aWMgTm9uY29weWFibGUsIHByaXZhdGUgU3VicmVzb3VyY2VMb2FkZXJDbGllbnQgewogICAgIHB1 YmxpYzoKLSAgICAgICAgTG9hZGVyKCk7CiAgICAgICAgIH5Mb2FkZXIoKTsKIAogICAgICAgICB2 b2lkIGxvYWQoQ2FjaGVkUmVzb3VyY2VMb2FkZXIqLCBDYWNoZWRSZXNvdXJjZSosIGJvb2wgaW5j cmVtZW50YWwgPSB0cnVlLCBTZWN1cml0eUNoZWNrUG9saWN5ID0gRG9TZWN1cml0eUNoZWNrLCBi b29sIHNlbmRSZXNvdXJjZUxvYWRDYWxsYmFja3MgPSB0cnVlKTsKLQogICAgICAgICB2b2lkIGNh bmNlbFJlcXVlc3RzKENhY2hlZFJlc291cmNlTG9hZGVyKik7Ci0gICAgICAgIAotICAgICAgICBl bnVtIFByaW9yaXR5IHsgVmVyeUxvdywgTG93LCBNZWRpdW0sIEhpZ2ggfTsKLSAgICAgICAgdm9p ZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93 KTsKIAotICAgICAgICBib29sIGlzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cygpIHsgcmV0dXJu IG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzOyB9Ci0gICAgICAgIHZvaWQgc3VzcGVuZFBl bmRpbmdSZXF1ZXN0cygpOwotICAgICAgICB2b2lkIHJlc3VtZVBlbmRpbmdSZXF1ZXN0cygpOwot ICAgICAgICAKLSAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RJbkZsaWdodChjb25zdCBLVVJM Jik7Ci0gICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUoY29uc3QgS1VSTCYpOwot CiAgICAgcHJpdmF0ZToKLSAgICAgICAgUHJpb3JpdHkgZGV0ZXJtaW5lUHJpb3JpdHkoY29uc3Qg Q2FjaGVkUmVzb3VyY2UqKSBjb25zdDsKLSAgICAgICAgdm9pZCBzY2hlZHVsZVNlcnZlUGVuZGlu Z1JlcXVlc3RzKCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlUmVzcG9uc2UoU3Vi cmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJik7CisgICAgICAgIHZpcnR1 YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IGNoYXIqLCBp bnQpOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJl c291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWRGaW5pc2hMb2FkaW5nKFN1YnJlc291cmNlTG9hZGVyKik7CisgICAgICAgIHZpcnR1YWwgdm9p ZCBkaWRGYWlsKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VFcnJvciYpOworICAg ICAgICB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBib29sIGNhbmNlbGxlZCA9IGZh bHNlKTsKICAgICAgICAgCi0gICAgICAgIHZvaWQgcmVxdWVzdFRpbWVyRmlyZWQoVGltZXI8TG9h ZGVyPiopOwotCi0gICAgICAgIGNsYXNzIEhvc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxIb3N0Piwg cHJpdmF0ZSBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCB7Ci0gICAgICAgIHB1YmxpYzoKLSAgICAg ICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEhvc3Q+IGNyZWF0ZShjb25zdCBBdG9taWNTdHJpbmcm IG5hbWUsIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHQpIAotICAgICAgICAgICAgewotICAg ICAgICAgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgSG9zdChuYW1lLCBtYXhSZXF1ZXN0c0lu RmxpZ2h0KSk7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICB+SG9zdCgpOwotICAgICAgICAg ICAgCi0gICAgICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUoKSBjb25zdCB7IHJldHVy biBtX25hbWU7IH0KLSAgICAgICAgICAgIHZvaWQgYWRkUmVxdWVzdChSZXF1ZXN0KiwgUHJpb3Jp dHkpOwotICAgICAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpOwotICAgICAg ICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RDb21wbGV0ZSgpOwotICAgICAgICAgICAgdm9pZCBz ZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93KTsK LSAgICAgICAgICAgIHZvaWQgY2FuY2VsUmVxdWVzdHMoQ2FjaGVkUmVzb3VyY2VMb2FkZXIqKTsK LSAgICAgICAgICAgIGJvb2wgaGFzUmVxdWVzdHMoKSBjb25zdDsKLQotICAgICAgICAgICAgYm9v bCBwcm9jZXNzaW5nUmVzb3VyY2UoKSBjb25zdCB7IHJldHVybiBtX251bVJlc291cmNlc1Byb2Nl c3NpbmcgIT0gMCB8fCBtX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQgIT0wOyB9Ci0KLSAgICAg ICAgcHJpdmF0ZToKLSAgICAgICAgICAgIEhvc3QoY29uc3QgQXRvbWljU3RyaW5nJiwgdW5zaWdu ZWQpOwotCi0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKFN1YnJl c291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpOwotICAgICAgICAgICAgdmly dHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hhcios IGludCk7Ci0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRh KFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7Ci0gICAgICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkRmluaXNoTG9hZGluZyhTdWJyZXNvdXJjZUxvYWRlciopOwotICAgICAgICAg ICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJj ZUVycm9yJik7Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIHR5cGVkZWYgRGVxdWU8UmVxdWVz dCo+IFJlcXVlc3RRdWV1ZTsKLSAgICAgICAgICAgIHZvaWQgc2VydmVQZW5kaW5nUmVxdWVzdHMo UmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcsIGJvb2wmIHNlcnZlTG93ZXJQcmlvcml0eSk7 Ci0gICAgICAgICAgICB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBib29sIGNhbmNl bGxlZCA9IGZhbHNlKTsKLSAgICAgICAgICAgIHZvaWQgY2FuY2VsUGVuZGluZ1JlcXVlc3RzKFJl cXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBDYWNoZWRSZXNvdXJjZUxvYWRlciopOwotICAg ICAgICAgICAgCi0gICAgICAgICAgICBSZXF1ZXN0UXVldWUgbV9yZXF1ZXN0c1BlbmRpbmdbSGln aCArIDFdOwotICAgICAgICAgICAgdHlwZWRlZiBIYXNoTWFwPFJlZlB0cjxTdWJyZXNvdXJjZUxv YWRlcj4sIFJlcXVlc3QqPiBSZXF1ZXN0TWFwOwotICAgICAgICAgICAgUmVxdWVzdE1hcCBtX3Jl cXVlc3RzTG9hZGluZzsKLSAgICAgICAgICAgIGNvbnN0IEF0b21pY1N0cmluZyBtX25hbWU7Ci0g ICAgICAgICAgICBjb25zdCBpbnQgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0OwotICAgICAgICAgICAg aW50IG1fbnVtUmVzb3VyY2VzUHJvY2Vzc2luZzsKLSAgICAgICAgICAgIGludCBtX25vbkNhY2hl ZFJlcXVlc3RzSW5GbGlnaHQ7Ci0gICAgICAgIH07Ci0gICAgICAgIHR5cGVkZWYgSGFzaE1hcDxB dG9taWNTdHJpbmdJbXBsKiwgUmVmUHRyPEhvc3Q+ID4gSG9zdE1hcDsKLSAgICAgICAgSG9zdE1h cCBtX2hvc3RzOwotICAgICAgICBSZWZQdHI8SG9zdD4gbV9ub25IVFRQUHJvdG9jb2xIb3N0Owot ICAgICAgICAKLSAgICAgICAgVGltZXI8TG9hZGVyPiBtX3JlcXVlc3RUaW1lcjsKLQotICAgICAg ICBib29sIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzOworICAgICAgICB0eXBlZGVmIEhh c2hNYXA8UmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiwgUmVxdWVzdCo+IFJlcXVlc3RNYXA7Cisg ICAgICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0c0xvYWRpbmc7CiAgICAgfTsKIAogfQpJbmRleDog V2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv bG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL2xv YWRlci9SZXNvdXJjZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM3LDYgKzM3LDcgQEAK ICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50Lmgi CiAjaW5jbHVkZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCisjaW5jbHVkZSAiT3BlbkNv bm5lY3Rpb25MaW1pdGVyLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgogI2luY2x1ZGUgIlByb2dyZXNz VHJhY2tlci5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCkBAIC05NSw2ICs5Niw4IEBA CiAKICAgICBtX2lkZW50aWZpZXIgPSAwOwogCisgICAgb3BlbkNvbm5lY3Rpb25MaW1pdGVyKCkt PmVuZCh0aGlzKTsKKwogICAgIGlmIChtX2hhbmRsZSkgewogICAgICAgICAvLyBDbGVhciBvdXQg dGhlIFJlc291cmNlSGFuZGxlJ3MgY2xpZW50IHNvIHRoYXQgaXQgZG9lc24ndCB0cnkgdG8gY2Fs bAogICAgICAgICAvLyB1cyBiYWNrIGFmdGVyIHdlIHJlbGVhc2UgaXQsIHVubGVzcyBpdCBoYXMg YmVlbiByZXBsYWNlZCBieSBzb21lb25lIGVsc2UuCkBAIC0xNDMsMTIgKzE0NiwxNyBAQAogICAg ICAgICBtX2RlZmVycmVkUmVxdWVzdCA9IGNsaWVudFJlcXVlc3Q7CiAgICAgICAgIHJldHVybiB0 cnVlOwogICAgIH0KLSAgICAKLSAgICBtX2hhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUo bV9mcmFtZS0+bG9hZGVyKCktPm5ldHdvcmtpbmdDb250ZXh0KCksIGNsaWVudFJlcXVlc3QsIHRo aXMsIG1fZGVmZXJzTG9hZGluZywgbV9zaG91bGRDb250ZW50U25pZmYpOwogCisgICAgb3BlbkNv bm5lY3Rpb25MaW1pdGVyKCktPnNjaGVkdWxlKHRoaXMpOwogICAgIHJldHVybiB0cnVlOwogfQog Cit2b2lkIFJlc291cmNlTG9hZGVyOjpzdGFydCgpCit7CisgICAgaWYgKCFtX3JlYWNoZWRUZXJt aW5hbFN0YXRlKQorICAgICAgICBtX2hhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUobV9m cmFtZS0+bG9hZGVyKCktPm5ldHdvcmtpbmdDb250ZXh0KCksIG1fcmVxdWVzdCwgdGhpcywgbV9k ZWZlcnNMb2FkaW5nLCBtX3Nob3VsZENvbnRlbnRTbmlmZik7Cit9CisKIHZvaWQgUmVzb3VyY2VM b2FkZXI6OnNldERlZmVyc0xvYWRpbmcoYm9vbCBkZWZlcnMpCiB7CiAgICAgbV9kZWZlcnNMb2Fk aW5nID0gZGVmZXJzOwpAQCAtMjIzLDYgKzIzMSw4IEBACiAgICAgICAgIGZyYW1lTG9hZGVyKCkt Pm5vdGlmaWVyKCktPndpbGxTZW5kUmVxdWVzdCh0aGlzLCByZXF1ZXN0LCByZWRpcmVjdFJlc3Bv bnNlKTsKICAgICB9CiAKKyAgICBpZiAoIXJlZGlyZWN0UmVzcG9uc2UuaXNOdWxsKCkpCisgICAg ICAgIG9wZW5Db25uZWN0aW9uTGltaXRlcigpLT5jaGFuZ2VIb3N0KHRoaXMsIHJlcXVlc3QpOwog ICAgIG1fcmVxdWVzdCA9IHJlcXVlc3Q7CiB9CiAKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL01haW5S ZXNvdXJjZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvTWFpblJlc291 cmNlTG9hZGVyLmNwcAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL2xvYWRlci9NYWluUmVz b3VyY2VMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVk ZSAiRnJhbWVMb2FkZXIuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5oIgogI2luY2x1 ZGUgIkhUTUxGb3JtRWxlbWVudC5oIgorI2luY2x1ZGUgIk9wZW5Db25uZWN0aW9uTGltaXRlci5o IgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpZiBQTEFURk9STShRVCkKICNpbmNsdWRlICJQbHVnaW5E YXRhYmFzZS5oIgpAQCAtNTQ5LDYgKzU1MCw3IEBACiAgICAgaWYgKHNob3VsZExvYWRFbXB0eUJl Zm9yZVJlZGlyZWN0ICYmICFzaG91bGRMb2FkRW1wdHkgJiYgZGVmZXJzTG9hZGluZygpKQogICAg ICAgICByZXR1cm4gdHJ1ZTsKIAorICAgIG9wZW5Db25uZWN0aW9uTGltaXRlcigpLT5hZGRSZXF1 ZXN0V2l0aG91dFNjaGVkdWxlKHRoaXMpOwogICAgIGlmIChtX3N1YnN0aXR1dGVEYXRhLmlzVmFs aWQoKSkgCiAgICAgICAgIGhhbmRsZURhdGFMb2FkU29vbihyKTsKICAgICBlbHNlIGlmIChzaG91 bGRMb2FkRW1wdHkgfHwgZnJhbWVMb2FkZXIoKS0+cmVwcmVzZW50YXRpb25FeGlzdHNGb3JVUkxT Y2hlbWUodXJsLnByb3RvY29sKCkpKQpJbmRleDogV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rp b25MaW1pdGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25M aW1pdGVyLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL2xvYWRlci9PcGVuQ29ubmVjdGlvbkxp bWl0ZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqCisgKi8KKworI2lmbmRlZiBPcGVuQ29u bmVjdGlvbkxpbWl0ZXJfaAorI2RlZmluZSBPcGVuQ29ubmVjdGlvbkxpbWl0ZXJfaAorCisjaW5j bHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hT ZXQuaD4KKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9T dHJpbmdIYXNoLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK2NsYXNzIFJlc291cmNlTG9hZGVy OworY2xhc3MgUmVzb3VyY2VSZXF1ZXN0OworCitjbGFzcyBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIg OiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIGZyaWVuZCBPcGVuQ29ubmVjdGlv bkxpbWl0ZXIqIG9wZW5Db25uZWN0aW9uTGltaXRlcigpOworCisgICAgdm9pZCBzY2hlZHVsZShS ZXNvdXJjZUxvYWRlciopOworICAgIHZvaWQgZW5kKFJlc291cmNlTG9hZGVyKik7CisgICAgdm9p ZCBjaGFuZ2VIb3N0KFJlc291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7Cisg ICAgdm9pZCBhZGRSZXF1ZXN0V2l0aG91dFNjaGVkdWxlKFJlc291cmNlTG9hZGVyKik7CisgICAg CisgICAgZW51bSBQcmlvcml0eSB7IFZlcnlMb3csIExvdywgTWVkaXVtLCBIaWdoIH07CisgICAg dm9pZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5 TG93KTsKKworICAgIHZvaWQgc3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpOworICAgIHZvaWQgcmVz dW1lUGVuZGluZ1JlcXVlc3RzKCk7CisKK3ByaXZhdGU6CisgICAgT3BlbkNvbm5lY3Rpb25MaW1p dGVyKCk7CisgICAgfk9wZW5Db25uZWN0aW9uTGltaXRlcigpOworICAgIFByaW9yaXR5IGRldGVy bWluZVByaW9yaXR5KGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIGNvbnN0OworCisgICAgdm9pZCBz Y2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CisgICAgdm9pZCByZXF1ZXN0VGltZXJGaXJl ZChUaW1lcjxPcGVuQ29ubmVjdGlvbkxpbWl0ZXI+Kik7CisKKyAgICBjbGFzcyBIb3N0IDogcHVi bGljIFJlZkNvdW50ZWQ8SG9zdD4geworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NS ZWZQdHI8SG9zdD4gY3JlYXRlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgbWF4UmVxdWVz dHNJbkZsaWdodCkgCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg SG9zdChuYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0KSk7CisgICAgICAgIH0KKyAgICAgICAgfkhv c3QoKTsKKyAgICAgICAgCisgICAgICAgIGNvbnN0IFN0cmluZyYgbmFtZSgpIGNvbnN0IHsgcmV0 dXJuIG1fbmFtZTsgfQorICAgICAgICB2b2lkIGFkZFJlcXVlc3QoUmVzb3VyY2VMb2FkZXIqLCBQ cmlvcml0eSk7CisgICAgICAgIHZvaWQgYWRkUmVxdWVzdFdpdGhvdXRTY2hlZHVsZShSZXNvdXJj ZUxvYWRlciopOworICAgICAgICB2b2lkIHNlcnZlUGVuZGluZ1JlcXVlc3RzKFByaW9yaXR5IG1p bmltdW1Qcmlvcml0eSA9IFZlcnlMb3cpOworICAgICAgICB2b2lkIGVuZChSZXNvdXJjZUxvYWRl ciosIE9wZW5Db25uZWN0aW9uTGltaXRlcjo6UHJpb3JpdHkpOworICAgICAgICBib29sIGhhc1Jl cXVlc3RzKCkgY29uc3Q7CisKKyAgICBwcml2YXRlOgorICAgICAgICBIb3N0KGNvbnN0IFN0cmlu ZyYsIHVuc2lnbmVkKTsgICAgICAgICAgICAKKyAgICAgICAgdHlwZWRlZiBEZXF1ZTxSZWZQdHI8 UmVzb3VyY2VMb2FkZXI+ID4gUmVxdWVzdFF1ZXVlOworICAgICAgICB2b2lkIHNlcnZlUGVuZGlu Z1JlcXVlc3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBib29sJiBzZXJ2ZUxvd2Vy UHJpb3JpdHkpOworICAgICAgICAgICAgICAgICAgICAKKyAgICAgICAgUmVxdWVzdFF1ZXVlIG1f cmVxdWVzdHNQZW5kaW5nW0hpZ2ggKyAxXTsKKyAgICAgICAgdHlwZWRlZiBIYXNoU2V0PFJlZlB0 cjxSZXNvdXJjZUxvYWRlcj4gPiBSZXF1ZXN0TWFwOworICAgICAgICBSZXF1ZXN0TWFwIG1fcmVx dWVzdHNMb2FkaW5nOworICAgICAgICBjb25zdCBTdHJpbmcgbV9uYW1lOworICAgICAgICBjb25z dCBpbnQgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0OworICAgIH07CisKKyAgICB0eXBlZGVmIEhhc2hN YXA8U3RyaW5nLCBSZWZQdHI8SG9zdD4sIFN0cmluZ0hhc2g+IEhvc3RNYXA7CisgICAgSG9zdE1h cCBtX2hvc3RzOworICAgIFJlZlB0cjxIb3N0PiBtX25vbkhUVFBQcm90b2NvbEhvc3Q7CisgICAg ICAgIAorICAgIFRpbWVyPE9wZW5Db25uZWN0aW9uTGltaXRlcj4gbV9yZXF1ZXN0VGltZXI7CisK KyAgICBib29sIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzOworfTsKKworT3BlbkNvbm5l Y3Rpb25MaW1pdGVyKiBvcGVuQ29ubmVjdGlvbkxpbWl0ZXIoKTsKKworfQorCisjZW5kaWYKSW5k ZXg6IFdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuaAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL2xv YWRlci9SZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMzAsMTAgKzEzMCwxMyBA QAogICAgIHByb3RlY3RlZDoKICAgICAgICAgUmVzb3VyY2VMb2FkZXIoRnJhbWUqLCBib29sIHNl bmRSZXNvdXJjZUxvYWRDYWxsYmFja3MsIGJvb2wgc2hvdWxkQ29udGVudFNuaWZmKTsKIAorICAg ICAgICBmcmllbmQgY2xhc3MgT3BlbkNvbm5lY3Rpb25MaW1pdGVyOwogI2lmIEVOQUJMRShPRkZM SU5FX1dFQl9BUFBMSUNBVElPTlMpCiAgICAgICAgIGZyaWVuZCBjbGFzcyBBcHBsaWNhdGlvbkNh Y2hlSG9zdDsgIC8vIGZvciBhY2Nlc3MgdG8gcmVxdWVzdCgpCiAjZW5kaWYKIAorICAgICAgICB2 aXJ0dWFsIHZvaWQgc3RhcnQoKTsKKwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2FuY2VsKGNv bnN0IFJlc291cmNlRXJyb3ImKTsKICAgICAgICAgdm9pZCBkaWRGaW5pc2hMb2FkaW5nT25lUGFy dChkb3VibGUgZmluaXNoVGltZSk7CiAKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmNwcAkocmV2aXNpb24gNjkzMTMp CisrKyBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw0NSAr MjgsMTggQEAKICNpbmNsdWRlICJDYWNoZWRJbWFnZS5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291 cmNlLmgiCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VMb2FkZXIuaCIKLSNpbmNsdWRlICJJbnNw ZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZy YW1lTG9hZGVyLmgiCi0jaW5jbHVkZSAiSFRNTERvY3VtZW50LmgiCiAjaW5jbHVkZSAiUmVxdWVz dC5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1 ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgotI2luY2x1ZGUgIlNlY3VyaXR5 T3JpZ2luLmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0jaW5jbHVkZSAiU3VicmVzb3Vy Y2VMb2FkZXIuaCIKICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9W ZWN0b3IuaD4KIAotI2RlZmluZSBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxFRCAxCi0jZGVmaW5l IFJFUVVFU1RfREVCVUcgMAotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLSNpZiBSRVFVRVNUX01B TkFHRU1FTlRfRU5BQkxFRAotLy8gTWF0Y2ggdGhlIHBhcmFsbGVsIGNvbm5lY3Rpb24gY291bnQg dXNlZCBieSB0aGUgbmV0d29ya2luZyBsYXllcgotc3RhdGljIHVuc2lnbmVkIG1heFJlcXVlc3Rz SW5GbGlnaHRQZXJIb3N0OwotLy8gSGF2aW5nIGEgbGltaXQgbWlnaHQgc3RpbGwgaGVscCBnZXR0 aW5nIG1vcmUgaW1wb3J0YW50IHJlc291cmNlcyBmaXJzdAotc3RhdGljIGNvbnN0IHVuc2lnbmVk IG1heFJlcXVlc3RzSW5GbGlnaHRGb3JOb25IVFRQUHJvdG9jb2xzID0gMjA7Ci0jZWxzZQotc3Rh dGljIGNvbnN0IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0ID0gMTAwMDA7Ci1z dGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2Nv bHMgPSAxMDAwMDsKLSNlbmRpZgotCi1Mb2FkZXI6OkxvYWRlcigpCi0gICAgOiBtX3JlcXVlc3RU aW1lcih0aGlzLCAmTG9hZGVyOjpyZXF1ZXN0VGltZXJGaXJlZCkKLSAgICAsIG1faXNTdXNwZW5k aW5nUGVuZGluZ1JlcXVlc3RzKGZhbHNlKQotewotICAgIG1fbm9uSFRUUFByb3RvY29sSG9zdCA9 IEhvc3Q6OmNyZWF0ZShBdG9taWNTdHJpbmcoKSwgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhU VFBQcm90b2NvbHMpOwotI2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECi0gICAgbWF4UmVx dWVzdHNJbkZsaWdodFBlckhvc3QgPSBpbml0aWFsaXplTWF4aW11bUhUVFBDb25uZWN0aW9uQ291 bnRQZXJIb3N0KCk7Ci0jZW5kaWYKLX0KLQogTG9hZGVyOjp+TG9hZGVyKCkKIHsgICAgCiAgICAg QVNTRVJUX05PVF9SRUFDSEVEKCk7CkBAIC05NSwyOTEgKzY4LDcxIEBACiAgICAgcmV0dXJuIFJl c291cmNlUmVxdWVzdDo6VGFyZ2V0SXNTdWJyZXNvdXJjZTsKIH0KIAotTG9hZGVyOjpQcmlvcml0 eSBMb2FkZXI6OmRldGVybWluZVByaW9yaXR5KGNvbnN0IENhY2hlZFJlc291cmNlKiByZXNvdXJj ZSkgY29uc3QKLXsKLSNpZiBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxFRAotICAgIHN3aXRjaCAo cmVzb3VyY2UtPnR5cGUoKSkgewotICAgICAgICBjYXNlIENhY2hlZFJlc291cmNlOjpDU1NTdHls ZVNoZWV0OgotI2lmIEVOQUJMRShYU0xUKQotICAgICAgICBjYXNlIENhY2hlZFJlc291cmNlOjpY U0xTdHlsZVNoZWV0OgotI2VuZGlmCi0gICAgICAgICAgICByZXR1cm4gSGlnaDsKLSAgICAgICAg Y2FzZSBDYWNoZWRSZXNvdXJjZTo6U2NyaXB0OiAKLSAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJj ZTo6Rm9udFJlc291cmNlOgotICAgICAgICAgICAgcmV0dXJuIE1lZGl1bTsKLSAgICAgICAgY2Fz ZSBDYWNoZWRSZXNvdXJjZTo6SW1hZ2VSZXNvdXJjZToKLSAgICAgICAgICAgIHJldHVybiBMb3c7 Ci0jaWYgRU5BQkxFKExJTktfUFJFRkVUQ0gpCi0gICAgICAgIGNhc2UgQ2FjaGVkUmVzb3VyY2U6 OkxpbmtQcmVmZXRjaDoKLSAgICAgICAgICAgIHJldHVybiBWZXJ5TG93OwotI2VuZGlmCi0gICAg fQotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwotICAgIHJldHVybiBMb3c7Ci0jZWxzZQotICAg IHJldHVybiBIaWdoOwotI2VuZGlmCi19Ci0KIHZvaWQgTG9hZGVyOjpsb2FkKENhY2hlZFJlc291 cmNlTG9hZGVyKiBjYWNoZWRSZXNvdXJjZUxvYWRlciwgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNl LCBib29sIGluY3JlbWVudGFsLCBTZWN1cml0eUNoZWNrUG9saWN5IHNlY3VyaXR5Q2hlY2ssIGJv b2wgc2VuZFJlc291cmNlTG9hZENhbGxiYWNrcykKIHsKICAgICBBU1NFUlQoY2FjaGVkUmVzb3Vy Y2VMb2FkZXIpOwogICAgIFJlcXVlc3QqIHJlcXVlc3QgPSBuZXcgUmVxdWVzdChjYWNoZWRSZXNv dXJjZUxvYWRlciwgcmVzb3VyY2UsIGluY3JlbWVudGFsLCBzZWN1cml0eUNoZWNrLCBzZW5kUmVz b3VyY2VMb2FkQ2FsbGJhY2tzKTsKIAotICAgIFJlZlB0cjxIb3N0PiBob3N0OwotICAgIEtVUkwg dXJsKFBhcnNlZFVSTFN0cmluZywgcmVzb3VyY2UtPnVybCgpKTsKLSAgICBpZiAodXJsLnByb3Rv Y29sSW5IVFRQRmFtaWx5KCkpIHsKLSAgICAgICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5KCk7 Ci0gICAgICAgIEF0b21pY1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7Ci0gICAgICAgIGhv c3QgPSBtX2hvc3RzLmdldChob3N0TmFtZS5pbXBsKCkpOwotICAgICAgICBpZiAoIWhvc3QpIHsK LSAgICAgICAgICAgIGhvc3QgPSBIb3N0OjpjcmVhdGUoaG9zdE5hbWUsIG1heFJlcXVlc3RzSW5G bGlnaHRQZXJIb3N0KTsKLSAgICAgICAgICAgIG1faG9zdHMuYWRkKGhvc3ROYW1lLmltcGwoKSwg aG9zdCk7Ci0gICAgICAgIH0KLSAgICB9IGVsc2UgCi0gICAgICAgIGhvc3QgPSBtX25vbkhUVFBQ cm90b2NvbEhvc3Q7Ci0gICAgCi0gICAgYm9vbCBoYWRSZXF1ZXN0cyA9IGhvc3QtPmhhc1JlcXVl c3RzKCk7Ci0gICAgUHJpb3JpdHkgcHJpb3JpdHkgPSBkZXRlcm1pbmVQcmlvcml0eShyZXNvdXJj ZSk7Ci0gICAgaG9zdC0+YWRkUmVxdWVzdChyZXF1ZXN0LCBwcmlvcml0eSk7CiAgICAgY2FjaGVk UmVzb3VyY2VMb2FkZXItPmluY3JlbWVudFJlcXVlc3RDb3VudChyZXF1ZXN0LT5jYWNoZWRSZXNv dXJjZSgpKTsKKyAgICBib29sIHJlc291cmNlSXNDYWNoZVZhbGlkYXRvciA9IHJlcXVlc3QtPmNh Y2hlZFJlc291cmNlKCktPmlzQ2FjaGVWYWxpZGF0b3IoKTsKIAotICAgIGlmIChwcmlvcml0eSA+ IExvdyB8fCAhdXJsLnByb3RvY29sSW5IVFRQRmFtaWx5KCkgfHwgKHByaW9yaXR5ID09IExvdyAm JiAhaGFkUmVxdWVzdHMpKSB7Ci0gICAgICAgIC8vIFRyeSB0byByZXF1ZXN0IGltcG9ydGFudCBy ZXNvdXJjZXMgaW1tZWRpYXRlbHkKLSAgICAgICAgaG9zdC0+c2VydmVQZW5kaW5nUmVxdWVzdHMo cHJpb3JpdHkpOwotICAgIH0gZWxzZSB7Ci0gICAgICAgIC8vIEhhbmRsZSBhc3luY2hyb25vdXNs eSBzbyBlYXJseSBsb3cgcHJpb3JpdHkgcmVxdWVzdHMgZG9uJ3QgZ2V0IHNjaGVkdWxlZCBiZWZv cmUgbGF0ZXIgaGlnaCBwcmlvcml0eSBvbmVzCi0gICAgICAgIEluc3BlY3Rvckluc3RydW1lbnRh dGlvbjo6ZGlkU2NoZWR1bGVSZXNvdXJjZVJlcXVlc3QoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRv YygpLCByZXNvdXJjZS0+dXJsKCkpOwotICAgICAgICBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVl c3RzKCk7Ci0gICAgfQotfQotICAgIAotdm9pZCBMb2FkZXI6OnNjaGVkdWxlU2VydmVQZW5kaW5n UmVxdWVzdHMoKQotewotICAgIGlmICghbV9yZXF1ZXN0VGltZXIuaXNBY3RpdmUoKSkKLSAgICAg ICAgbV9yZXF1ZXN0VGltZXIuc3RhcnRPbmVTaG90KDApOwotfQorICAgIFJlc291cmNlUmVxdWVz dCByZXNvdXJjZVJlcXVlc3QocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+dXJsKCkpOworICAg IHJlc291cmNlUmVxdWVzdC5zZXRUYXJnZXRUeXBlKGNhY2hlZFJlc291cmNlVHlwZVRvVGFyZ2V0 VHlwZShyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT50eXBlKCkpKTsKKyAgICBpZiAoIXJlcXVl c3QtPmNhY2hlZFJlc291cmNlKCktPmFjY2VwdCgpLmlzRW1wdHkoKSkKKyAgICAgICAgcmVzb3Vy Y2VSZXF1ZXN0LnNldEhUVFBBY2NlcHQocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+YWNjZXB0 KCkpOwogCi12b2lkIExvYWRlcjo6cmVxdWVzdFRpbWVyRmlyZWQoVGltZXI8TG9hZGVyPiopIAot ewotICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Ci19Ci0KLXZvaWQgTG9hZGVyOjpzZXJ2ZVBl bmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkpCi17Ci0gICAgaWYgKG1faXNT dXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKQotICAgICAgICByZXR1cm47Ci0KLSAgICBtX3JlcXVl c3RUaW1lci5zdG9wKCk7Ci0gICAgCi0gICAgbV9ub25IVFRQUHJvdG9jb2xIb3N0LT5zZXJ2ZVBl bmRpbmdSZXF1ZXN0cyhtaW5pbXVtUHJpb3JpdHkpOwotCi0gICAgVmVjdG9yPEhvc3QqPiBob3N0 c1RvU2VydmU7Ci0gICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgSG9zdE1hcDo6 aXRlcmF0b3IgaSA9IG1faG9zdHMuYmVnaW4oKTsKLSAgICBIb3N0TWFwOjppdGVyYXRvciBlbmQg PSBtX2hvc3RzLmVuZCgpOwotICAgIGZvciAoO2kgIT0gZW5kOyArK2kpCi0gICAgICAgIGhvc3Rz VG9TZXJ2ZS5hcHBlbmQoaS0+c2Vjb25kLmdldCgpKTsKLSAgICAgICAgCi0gICAgZm9yICh1bnNp Z25lZCBuID0gMDsgbiA8IGhvc3RzVG9TZXJ2ZS5zaXplKCk7ICsrbikgewotICAgICAgICBIb3N0 KiBob3N0ID0gaG9zdHNUb1NlcnZlW25dOwotICAgICAgICBpZiAoaG9zdC0+aGFzUmVxdWVzdHMo KSkKLSAgICAgICAgICAgIGhvc3QtPnNlcnZlUGVuZGluZ1JlcXVlc3RzKG1pbmltdW1Qcmlvcml0 eSk7Ci0gICAgICAgIGVsc2UgaWYgKCFob3N0LT5wcm9jZXNzaW5nUmVzb3VyY2UoKSl7Ci0gICAg ICAgICAgICBBdG9taWNTdHJpbmcgbmFtZSA9IGhvc3QtPm5hbWUoKTsKLSAgICAgICAgICAgIG1f aG9zdHMucmVtb3ZlKG5hbWUuaW1wbCgpKTsKKyAgICBpZiAocmVzb3VyY2VJc0NhY2hlVmFsaWRh dG9yKSB7CisgICAgICAgIENhY2hlZFJlc291cmNlKiByZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJl cXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnJlc291cmNlVG9SZXZhbGlkYXRlKCk7CisgICAgICAg IEFTU0VSVChyZXNvdXJjZVRvUmV2YWxpZGF0ZS0+Y2FuVXNlQ2FjaGVWYWxpZGF0b3IoKSk7Cisg ICAgICAgIEFTU0VSVChyZXNvdXJjZVRvUmV2YWxpZGF0ZS0+aXNMb2FkZWQoKSk7CisgICAgICAg IGNvbnN0IFN0cmluZyYgbGFzdE1vZGlmaWVkID0gcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlc3Bv bnNlKCkuaHR0cEhlYWRlckZpZWxkKCJMYXN0LU1vZGlmaWVkIik7CisgICAgICAgIGNvbnN0IFN0 cmluZyYgZVRhZyA9IHJlc291cmNlVG9SZXZhbGlkYXRlLT5yZXNwb25zZSgpLmh0dHBIZWFkZXJG aWVsZCgiRVRhZyIpOworICAgICAgICBpZiAoIWxhc3RNb2RpZmllZC5pc0VtcHR5KCkgfHwgIWVU YWcuaXNFbXB0eSgpKSB7CisgICAgICAgICAgICBBU1NFUlQoY2FjaGVkUmVzb3VyY2VMb2FkZXIt PmNhY2hlUG9saWN5KCkgIT0gQ2FjaGVQb2xpY3lSZWxvYWQpOworICAgICAgICAgICAgaWYgKGNh Y2hlZFJlc291cmNlTG9hZGVyLT5jYWNoZVBvbGljeSgpID09IENhY2hlUG9saWN5UmV2YWxpZGF0 ZSkKKyAgICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJD YWNoZS1Db250cm9sIiwgIm1heC1hZ2U9MCIpOworICAgICAgICAgICAgaWYgKCFsYXN0TW9kaWZp ZWQuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQSGVh ZGVyRmllbGQoIklmLU1vZGlmaWVkLVNpbmNlIiwgbGFzdE1vZGlmaWVkKTsKKyAgICAgICAgICAg IGlmICghZVRhZy5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNl dEhUVFBIZWFkZXJGaWVsZCgiSWYtTm9uZS1NYXRjaCIsIGVUYWcpOwogICAgICAgICB9CiAgICAg fQotfQogCi12b2lkIExvYWRlcjo6c3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpCi17Ci0gICAgQVNT RVJUKCFtX2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cyk7Ci0gICAgbV9pc1N1c3BlbmRpbmdQ ZW5kaW5nUmVxdWVzdHMgPSB0cnVlOwotfQotCi12b2lkIExvYWRlcjo6cmVzdW1lUGVuZGluZ1Jl cXVlc3RzKCkKLXsKLSAgICBBU1NFUlQobV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMpOwot ICAgIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzID0gZmFsc2U7Ci0gICAgaWYgKCFtX2hv c3RzLmlzRW1wdHkoKSB8fCBtX25vbkhUVFBQcm90b2NvbEhvc3QtPmhhc1JlcXVlc3RzKCkpCi0g ICAgICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKLX0KLQotdm9pZCBMb2FkZXI6 Om5vbkNhY2hlUmVxdWVzdEluRmxpZ2h0KGNvbnN0IEtVUkwmIHVybCkKLXsKLSAgICBpZiAoIXVy bC5wcm90b2NvbEluSFRUUEZhbWlseSgpKQotICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgQXRv bWljU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3QoKTsKLSAgICBtX2hvc3RzLmNoZWNrQ29uc2lz dGVuY3koKTsKLSAgICBSZWZQdHI8SG9zdD4gaG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lLmlt cGwoKSk7Ci0gICAgaWYgKCFob3N0KSB7Ci0gICAgICAgIGhvc3QgPSBIb3N0OjpjcmVhdGUoaG9z dE5hbWUsIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0KTsKLSAgICAgICAgbV9ob3N0cy5hZGQo aG9zdE5hbWUuaW1wbCgpLCBob3N0KTsKKyAgICBSZWZQdHI8U3VicmVzb3VyY2VMb2FkZXI+IGxv YWRlciA9IFN1YnJlc291cmNlTG9hZGVyOjpjcmVhdGUoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRv YygpLT5mcmFtZSgpLAorICAgICAgICB0aGlzLCByZXNvdXJjZVJlcXVlc3QsIHJlcXVlc3QtPnNo b3VsZERvU2VjdXJpdHlDaGVjaygpLCByZXF1ZXN0LT5zZW5kUmVzb3VyY2VMb2FkQ2FsbGJhY2tz KCkpOworICAgIGlmIChsb2FkZXIpIHsKKyAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcuYWRkKGxv YWRlci5yZWxlYXNlKCksIHJlcXVlc3QpOworICAgICAgICByZXF1ZXN0LT5jYWNoZWRSZXNvdXJj ZSgpLT5zZXRSZXF1ZXN0ZWRGcm9tTmV0d29ya2luZ0xheWVyKCk7CisgICAgfSBlbHNlIHsgICAg ICAgICAgICAKKyAgICAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRlY3JlbWVudFJlcXVlc3RD b3VudChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpKTsKKyAgICAgICAgY2FjaGVkUmVzb3VyY2VM b2FkZXItPnNldExvYWRJblByb2dyZXNzKHRydWUpOworICAgICAgICByZXF1ZXN0LT5jYWNoZWRS ZXNvdXJjZSgpLT5lcnJvcigpOworICAgICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+c2V0TG9h ZEluUHJvZ3Jlc3MoZmFsc2UpOworICAgICAgICBkZWxldGUgcmVxdWVzdDsKICAgICB9Ci0KLSAg ICBob3N0LT5ub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpOwogfQogCi12b2lkIExvYWRlcjo6bm9u Q2FjaGVSZXF1ZXN0Q29tcGxldGUoY29uc3QgS1VSTCYgdXJsKQotewotICAgIGlmICghdXJsLnBy b3RvY29sSW5IVFRQRmFtaWx5KCkpCi0gICAgICAgIHJldHVybjsKLSAgICAKLSAgICBBdG9taWNT dHJpbmcgaG9zdE5hbWUgPSB1cmwuaG9zdCgpOwotICAgIG1faG9zdHMuY2hlY2tDb25zaXN0ZW5j eSgpOwotICAgIFJlZlB0cjxIb3N0PiBob3N0ID0gbV9ob3N0cy5nZXQoaG9zdE5hbWUuaW1wbCgp KTsKLSAgICBBU1NFUlQoaG9zdCk7Ci0gICAgaWYgKCFob3N0KQotICAgICAgICByZXR1cm47Ci0K LSAgICBob3N0LT5ub25DYWNoZVJlcXVlc3RDb21wbGV0ZSgpOwotfQotCiB2b2lkIExvYWRlcjo6 Y2FuY2VsUmVxdWVzdHMoQ2FjaGVkUmVzb3VyY2VMb2FkZXIqIGNhY2hlZFJlc291cmNlTG9hZGVy KQogewogICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5jbGVhclBlbmRpbmdQcmVsb2FkcygpOwog Ci0gICAgaWYgKG1fbm9uSFRUUFByb3RvY29sSG9zdC0+aGFzUmVxdWVzdHMoKSkKLSAgICAgICAg bV9ub25IVFRQUHJvdG9jb2xIb3N0LT5jYW5jZWxSZXF1ZXN0cyhjYWNoZWRSZXNvdXJjZUxvYWRl cik7Ci0gICAgCi0gICAgVmVjdG9yPEhvc3QqPiBob3N0c1RvQ2FuY2VsOwotICAgIG1faG9zdHMu Y2hlY2tDb25zaXN0ZW5jeSgpOwotICAgIEhvc3RNYXA6Oml0ZXJhdG9yIGkgPSBtX2hvc3RzLmJl Z2luKCk7Ci0gICAgSG9zdE1hcDo6aXRlcmF0b3IgZW5kID0gbV9ob3N0cy5lbmQoKTsKLSAgICBm b3IgKDtpICE9IGVuZDsgKytpKQotICAgICAgICBob3N0c1RvQ2FuY2VsLmFwcGVuZChpLT5zZWNv bmQuZ2V0KCkpOwotCi0gICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IGhvc3RzVG9DYW5jZWwu c2l6ZSgpOyArK24pIHsKLSAgICAgICAgSG9zdCogaG9zdCA9IGhvc3RzVG9DYW5jZWxbbl07Ci0g ICAgICAgIGlmIChob3N0LT5oYXNSZXF1ZXN0cygpKQotICAgICAgICAgICAgaG9zdC0+Y2FuY2Vs UmVxdWVzdHMoY2FjaGVkUmVzb3VyY2VMb2FkZXIpOworICAgIFZlY3RvcjxTdWJyZXNvdXJjZUxv YWRlciosIDI1Nj4gbG9hZGVyc1RvQ2FuY2VsOworICAgIFJlcXVlc3RNYXA6Oml0ZXJhdG9yIGVu ZCA9IG1fcmVxdWVzdHNMb2FkaW5nLmVuZCgpOworICAgIGZvciAoUmVxdWVzdE1hcDo6aXRlcmF0 b3IgaSA9IG1fcmVxdWVzdHNMb2FkaW5nLmJlZ2luKCk7IGkgIT0gZW5kOyArK2kpIHsKKyAgICAg ICAgUmVxdWVzdCogciA9IGktPnNlY29uZDsKKyAgICAgICAgaWYgKHItPmNhY2hlZFJlc291cmNl TG9hZGVyKCkgPT0gY2FjaGVkUmVzb3VyY2VMb2FkZXIpCisgICAgICAgICAgICBsb2FkZXJzVG9D YW5jZWwuYXBwZW5kKGktPmZpcnN0LmdldCgpKTsKICAgICB9CiAKLSAgICBzY2hlZHVsZVNlcnZl UGVuZGluZ1JlcXVlc3RzKCk7Ci0gICAgCi0gICAgQVNTRVJUKGNhY2hlZFJlc291cmNlTG9hZGVy LT5yZXF1ZXN0Q291bnQoKSA9PSAoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmxvYWRJblByb2dyZXNz KCkgPyAxIDogMCkpOwotfQotCi1Mb2FkZXI6Okhvc3Q6Okhvc3QoY29uc3QgQXRvbWljU3RyaW5n JiBuYW1lLCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0KQotICAgIDogbV9uYW1lKG5hbWUp Ci0gICAgLCBtX21heFJlcXVlc3RzSW5GbGlnaHQobWF4UmVxdWVzdHNJbkZsaWdodCkKLSAgICAs IG1fbnVtUmVzb3VyY2VzUHJvY2Vzc2luZygwKQotICAgICwgbV9ub25DYWNoZWRSZXF1ZXN0c0lu RmxpZ2h0KDApCi17Ci19Ci0KLUxvYWRlcjo6SG9zdDo6fkhvc3QoKQotewotICAgIEFTU0VSVCht X3JlcXVlc3RzTG9hZGluZy5pc0VtcHR5KCkpOwotICAgIGZvciAodW5zaWduZWQgcCA9IDA7IHAg PD0gSGlnaDsgcCsrKQotICAgICAgICBBU1NFUlQobV9yZXF1ZXN0c1BlbmRpbmdbcF0uaXNFbXB0 eSgpKTsKLX0KLSAgICAKLXZvaWQgTG9hZGVyOjpIb3N0OjphZGRSZXF1ZXN0KFJlcXVlc3QqIHJl cXVlc3QsIFByaW9yaXR5IHByaW9yaXR5KQotewotICAgIG1fcmVxdWVzdHNQZW5kaW5nW3ByaW9y aXR5XS5hcHBlbmQocmVxdWVzdCk7Ci19Ci0gICAgCi12b2lkIExvYWRlcjo6SG9zdDo6bm9uQ2Fj aGVSZXF1ZXN0SW5GbGlnaHQoKQotewotICAgICsrbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0 OwotfQotCi12b2lkIExvYWRlcjo6SG9zdDo6bm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUoKQotewot ICAgIC0tbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0OwotICAgIEFTU0VSVChtX25vbkNhY2hl ZFJlcXVlc3RzSW5GbGlnaHQgPj0gMCk7Ci0KLSAgICBjYWNoZSgpLT5sb2FkZXIoKS0+c2NoZWR1 bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwotfQotCi1ib29sIExvYWRlcjo6SG9zdDo6aGFzUmVx dWVzdHMoKSBjb25zdAotewotICAgIGlmICghbV9yZXF1ZXN0c0xvYWRpbmcuaXNFbXB0eSgpKQot ICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICBmb3IgKHVuc2lnbmVkIHAgPSAwOyBwIDw9IEhpZ2g7 IHArKykgewotICAgICAgICBpZiAoIW1fcmVxdWVzdHNQZW5kaW5nW3BdLmlzRW1wdHkoKSkKLSAg ICAgICAgICAgIHJldHVybiB0cnVlOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsb2Fk ZXJzVG9DYW5jZWwuc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgU3VicmVzb3VyY2VMb2FkZXIqIGxv YWRlciA9IGxvYWRlcnNUb0NhbmNlbFtpXTsKKyAgICAgICAgZGlkRmFpbChsb2FkZXIsIHRydWUp OwogICAgIH0KLSAgICByZXR1cm4gZmFsc2U7Ci19CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpzZXJ2 ZVBlbmRpbmdSZXF1ZXN0cyhMb2FkZXI6OlByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSkKLXsKLSAg ICBpZiAoY2FjaGUoKS0+bG9hZGVyKCktPmlzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cygpKQot ICAgICAgICByZXR1cm47Ci0KLSAgICBib29sIHNlcnZlTW9yZSA9IHRydWU7Ci0gICAgZm9yIChp bnQgcHJpb3JpdHkgPSBIaWdoOyBwcmlvcml0eSA+PSBtaW5pbXVtUHJpb3JpdHkgJiYgc2VydmVN b3JlOyAtLXByaW9yaXR5KQotICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhtX3JlcXVlc3Rz UGVuZGluZ1twcmlvcml0eV0sIHNlcnZlTW9yZSk7CiB9CiAKLXZvaWQgTG9hZGVyOjpIb3N0Ojpz ZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhSZXF1ZXN0UXVldWUmIHJlcXVlc3RzUGVuZGluZywgYm9vbCYg c2VydmVMb3dlclByaW9yaXR5KQordm9pZCBMb2FkZXI6OmRpZEZpbmlzaExvYWRpbmcoU3VicmVz b3VyY2VMb2FkZXIqIGxvYWRlcikKIHsKLSAgICB3aGlsZSAoIXJlcXVlc3RzUGVuZGluZy5pc0Vt cHR5KCkpIHsgICAgICAgIAotICAgICAgICBSZXF1ZXN0KiByZXF1ZXN0ID0gcmVxdWVzdHNQZW5k aW5nLmZpcnN0KCk7Ci0gICAgICAgIENhY2hlZFJlc291cmNlTG9hZGVyKiBjYWNoZWRSZXNvdXJj ZUxvYWRlciA9IHJlcXVlc3QtPmNhY2hlZFJlc291cmNlTG9hZGVyKCk7Ci0gICAgICAgIGJvb2wg cmVzb3VyY2VJc0NhY2hlVmFsaWRhdG9yID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+aXND YWNoZVZhbGlkYXRvcigpOwotCi0gICAgICAgIC8vIEZvciBuYW1lZCBob3N0cyAtIHdoaWNoIGFy ZSBvbmx5IGh0dHAocykgaG9zdHMgLSB3ZSBzaG91bGQgYWx3YXlzIGVuZm9yY2UgdGhlIGNvbm5l Y3Rpb24gbGltaXQuCi0gICAgICAgIC8vIEZvciBub24tbmFtZWQgaG9zdHMgLSBldmVyeXRoaW5n IGJ1dCBodHRwKHMpIC0gd2Ugc2hvdWxkIG9ubHkgZW5mb3JjZSB0aGUgbGltaXQgaWYgdGhlIGRv Y3VtZW50IGlzbid0IGRvbmUgcGFyc2luZyAKLSAgICAgICAgLy8gYW5kIHdlIGRvbid0IGtub3cg YWxsIHN0eWxlc2hlZXRzIHlldC4KLSAgICAgICAgYm9vbCBzaG91bGRMaW1pdFJlcXVlc3RzID0g IW1fbmFtZS5pc051bGwoKSB8fCBjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZG9jKCktPnBhcnNpbmco KSB8fCAhY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRvYygpLT5oYXZlU3R5bGVzaGVldHNMb2FkZWQo KTsKLSAgICAgICAgaWYgKHNob3VsZExpbWl0UmVxdWVzdHMgJiYgbV9yZXF1ZXN0c0xvYWRpbmcu c2l6ZSgpICsgbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxpZ2h0ID49IG1fbWF4UmVxdWVzdHNJbkZs aWdodCkgewotICAgICAgICAgICAgc2VydmVMb3dlclByaW9yaXR5ID0gZmFsc2U7Ci0gICAgICAg ICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAgICAgICAgcmVxdWVzdHNQZW5kaW5nLnJlbW92ZUZp cnN0KCk7Ci0gICAgICAgIAotICAgICAgICBSZXNvdXJjZVJlcXVlc3QgcmVzb3VyY2VSZXF1ZXN0 KHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnVybCgpKTsKLSAgICAgICAgcmVzb3VyY2VSZXF1 ZXN0LnNldFRhcmdldFR5cGUoY2FjaGVkUmVzb3VyY2VUeXBlVG9UYXJnZXRUeXBlKHJlcXVlc3Qt PmNhY2hlZFJlc291cmNlKCktPnR5cGUoKSkpOwotICAgICAgICAKLSAgICAgICAgaWYgKCFyZXF1 ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5hY2NlcHQoKS5pc0VtcHR5KCkpCi0gICAgICAgICAgICBy ZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEFjY2VwdChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5h Y2NlcHQoKSk7Ci0gICAgICAgIAotICAgICAgICAgLy8gRG8gbm90IHNldCB0aGUgcmVmZXJyZXIg b3IgSFRUUCBvcmlnaW4gaGVyZS4gVGhhdCdzIGhhbmRsZWQgYnkgU3VicmVzb3VyY2VMb2FkZXI6 OmNyZWF0ZS4KLSAgICAgICAgCi0gICAgICAgIGlmIChyZXNvdXJjZUlzQ2FjaGVWYWxpZGF0b3Ip IHsKLSAgICAgICAgICAgIENhY2hlZFJlc291cmNlKiByZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJl cXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnJlc291cmNlVG9SZXZhbGlkYXRlKCk7Ci0gICAgICAg ICAgICBBU1NFUlQocmVzb3VyY2VUb1JldmFsaWRhdGUtPmNhblVzZUNhY2hlVmFsaWRhdG9yKCkp OwotICAgICAgICAgICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5pc0xvYWRlZCgpKTsK LSAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgbGFzdE1vZGlmaWVkID0gcmVzb3VyY2VUb1JldmFs aWRhdGUtPnJlc3BvbnNlKCkuaHR0cEhlYWRlckZpZWxkKCJMYXN0LU1vZGlmaWVkIik7Ci0gICAg ICAgICAgICBjb25zdCBTdHJpbmcmIGVUYWcgPSByZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVzcG9u c2UoKS5odHRwSGVhZGVyRmllbGQoIkVUYWciKTsKLSAgICAgICAgICAgIGlmICghbGFzdE1vZGlm aWVkLmlzRW1wdHkoKSB8fCAhZVRhZy5pc0VtcHR5KCkpIHsKLSAgICAgICAgICAgICAgICBBU1NF UlQoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNhY2hlUG9saWN5KCkgIT0gQ2FjaGVQb2xpY3lSZWxv YWQpOwotICAgICAgICAgICAgICAgIGlmIChjYWNoZWRSZXNvdXJjZUxvYWRlci0+Y2FjaGVQb2xp Y3koKSA9PSBDYWNoZVBvbGljeVJldmFsaWRhdGUpCi0gICAgICAgICAgICAgICAgICAgIHJlc291 cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIkNhY2hlLUNvbnRyb2wiLCAibWF4LWFnZT0w Iik7Ci0gICAgICAgICAgICAgICAgaWYgKCFsYXN0TW9kaWZpZWQuaXNFbXB0eSgpKQotICAgICAg ICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJJZi1Nb2Rp ZmllZC1TaW5jZSIsIGxhc3RNb2RpZmllZCk7Ci0gICAgICAgICAgICAgICAgaWYgKCFlVGFnLmlz RW1wdHkoKSkKLSAgICAgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFk ZXJGaWVsZCgiSWYtTm9uZS1NYXRjaCIsIGVUYWcpOwotICAgICAgICAgICAgfQotICAgICAgICB9 Ci0KLSAgICAgICAgUmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBsb2FkZXIgPSBTdWJyZXNvdXJj ZUxvYWRlcjo6Y3JlYXRlKGNhY2hlZFJlc291cmNlTG9hZGVyLT5kb2MoKS0+ZnJhbWUoKSwKLSAg ICAgICAgICAgIHRoaXMsIHJlc291cmNlUmVxdWVzdCwgcmVxdWVzdC0+c2hvdWxkRG9TZWN1cml0 eUNoZWNrKCksIHJlcXVlc3QtPnNlbmRSZXNvdXJjZUxvYWRDYWxsYmFja3MoKSk7Ci0gICAgICAg IGlmIChsb2FkZXIpIHsKLSAgICAgICAgICAgIG1fcmVxdWVzdHNMb2FkaW5nLmFkZChsb2FkZXIu cmVsZWFzZSgpLCByZXF1ZXN0KTsKLSAgICAgICAgICAgIHJlcXVlc3QtPmNhY2hlZFJlc291cmNl KCktPnNldFJlcXVlc3RlZEZyb21OZXR3b3JraW5nTGF5ZXIoKTsKLSNpZiBSRVFVRVNUX0RFQlVH Ci0gICAgICAgICAgICBwcmludGYoIkhPU1QgJXMgQ09VTlQgJWQgTE9BRElORyAlc1xuIiwgcmVz b3VyY2VSZXF1ZXN0LnVybCgpLmhvc3QoKS5sYXRpbjEoKS5kYXRhKCksIG1fcmVxdWVzdHNMb2Fk aW5nLnNpemUoKSwgcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+dXJsKCkubGF0aW4xKCkuZGF0 YSgpKTsKLSNlbmRpZgotICAgICAgICB9IGVsc2UgeyAgICAgICAgICAgIAotICAgICAgICAgICAg Y2FjaGVkUmVzb3VyY2VMb2FkZXItPmRlY3JlbWVudFJlcXVlc3RDb3VudChyZXF1ZXN0LT5jYWNo ZWRSZXNvdXJjZSgpKTsKLSAgICAgICAgICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRMb2Fk SW5Qcm9ncmVzcyh0cnVlKTsKLSAgICAgICAgICAgIHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCkt PmVycm9yKCk7Ci0gICAgICAgICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+c2V0TG9hZEluUHJv Z3Jlc3MoZmFsc2UpOwotICAgICAgICAgICAgZGVsZXRlIHJlcXVlc3Q7Ci0gICAgICAgIH0KLSAg ICB9Ci19Ci0KLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRGaW5pc2hMb2FkaW5nKFN1YnJlc291cmNl TG9hZGVyKiBsb2FkZXIpCi17Ci0gICAgUmVmUHRyPEhvc3Q+IG15UHJvdGVjdG9yKHRoaXMpOwot CiAgICAgUmVxdWVzdE1hcDo6aXRlcmF0b3IgaSA9IG1fcmVxdWVzdHNMb2FkaW5nLmZpbmQobG9h ZGVyKTsKICAgICBpZiAoaSA9PSBtX3JlcXVlc3RzTG9hZGluZy5lbmQoKSkKICAgICAgICAgcmV0 dXJuOwpAQCAtNDA1LDI3ICsxNTgsMTcgQEAKICAgICB9CiAKICAgICBkZWxldGUgcmVxdWVzdDsK LQotICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRMb2FkSW5Qcm9ncmVzcyhmYWxzZSk7Ci0g ICAgCisgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPnNldExvYWRJblByb2dyZXNzKGZhbHNlKTsg ICAgCiAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNoZWNrRm9yUGVuZGluZ1ByZWxvYWRzKCk7 Ci0KLSNpZiBSRVFVRVNUX0RFQlVHCi0gICAgS1VSTCB1KFBhcnNlZFVSTFN0cmluZywgcmVzb3Vy Y2UtPnVybCgpKTsKLSAgICBwcmludGYoIkhPU1QgJXMgQ09VTlQgJWQgUkVDRUlWRUQgJXNcbiIs IHUuaG9zdCgpLmxhdGluMSgpLmRhdGEoKSwgbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpLCByZXNv dXJjZS0+dXJsKCkubGF0aW4xKCkuZGF0YSgpKTsKLSNlbmRpZgotICAgIHNlcnZlUGVuZGluZ1Jl cXVlc3RzKCk7CiB9CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRGYWlsKFN1YnJlc291cmNlTG9h ZGVyKiBsb2FkZXIsIGNvbnN0IFJlc291cmNlRXJyb3ImKQordm9pZCBMb2FkZXI6OmRpZEZhaWwo U3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgY29uc3QgUmVzb3VyY2VFcnJvciYpCiB7CiAgICAg ZGlkRmFpbChsb2FkZXIpOwogfQogCi12b2lkIExvYWRlcjo6SG9zdDo6ZGlkRmFpbChTdWJyZXNv dXJjZUxvYWRlciogbG9hZGVyLCBib29sIGNhbmNlbGxlZCkKK3ZvaWQgTG9hZGVyOjpkaWRGYWls KFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIsIGJvb2wgY2FuY2VsbGVkKQogewotICAgIFJlZlB0 cjxIb3N0PiBteVByb3RlY3Rvcih0aGlzKTsKLQogICAgIGxvYWRlci0+Y2xlYXJDbGllbnQoKTsK IAogICAgIFJlcXVlc3RNYXA6Oml0ZXJhdG9yIGkgPSBtX3JlcXVlc3RzTG9hZGluZy5maW5kKGxv YWRlcik7CkBAIC00NTgsMTQgKzIwMSwxMCBAQAogICAgIGRlbGV0ZSByZXF1ZXN0OwogICAgIAog ICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5jaGVja0ZvclBlbmRpbmdQcmVsb2FkcygpOwotCi0g ICAgc2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKIH0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZFJl Y2VpdmVSZXNwb25zZShTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyLCBjb25zdCBSZXNvdXJjZVJl c3BvbnNlJiByZXNwb25zZSkKK3ZvaWQgTG9hZGVyOjpkaWRSZWNlaXZlUmVzcG9uc2UoU3VicmVz b3VyY2VMb2FkZXIqIGxvYWRlciwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVzcG9uc2UpCiB7 Ci0gICAgUmVmUHRyPEhvc3Q+IHByb3RlY3Rvcih0aGlzKTsKLQogICAgIFJlcXVlc3QqIHJlcXVl c3QgPSBtX3JlcXVlc3RzTG9hZGluZy5nZXQobG9hZGVyKTsKICAgICAKICAgICAvLyBGSVhNRTog VGhpcyBpcyBhIHdvcmthcm91bmQgZm9yIDxyZGFyOi8vcHJvYmxlbS81MjM2ODQzPgpAQCAtNDgy LDggKzIyMSw4IEBACiAgICAgaWYgKHJlc291cmNlLT5pc0NhY2hlVmFsaWRhdG9yKCkpIHsKICAg ICAgICAgaWYgKHJlc3BvbnNlLmh0dHBTdGF0dXNDb2RlKCkgPT0gMzA0KSB7CiAgICAgICAgICAg ICAvLyAzMDQgTm90IG1vZGlmaWVkIC8gVXNlIGxvY2FsIGNvcHkKLSAgICAgICAgICAgIG1fcmVx dWVzdHNMb2FkaW5nLnJlbW92ZShsb2FkZXIpOwogICAgICAgICAgICAgbG9hZGVyLT5jbGVhckNs aWVudCgpOworICAgICAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcucmVtb3ZlKGxvYWRlcik7CiAg ICAgICAgICAgICByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZUxvYWRlcigpLT5kZWNyZW1lbnRSZXF1 ZXN0Q291bnQocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKSk7CiAKICAgICAgICAgICAgIC8vIEV4 aXN0aW5nIHJlc291cmNlIGlzIG9rLCBqdXN0IHVzZSBpdCB1cGRhdGluZyB0aGUgZXhwaXJhdGlv biB0aW1lLgpAQCAtNDk0LDcgKzIzMyw2IEBACiAKICAgICAgICAgICAgIGRlbGV0ZSByZXF1ZXN0 OwogCi0gICAgICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwogICAgICAgICAgICAgcmV0 dXJuOwogICAgICAgICB9IAogICAgICAgICAvLyBEaWQgbm90IGdldCAzMDQgcmVzcG9uc2UsIGNv bnRpbnVlIGFzIGEgcmVndWxhciByZXNvdXJjZSBsb2FkLgpAQCAtNTI1LDEwICsyNjMsOCBAQAog ICAgIH0KIH0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNl TG9hZGVyKiBsb2FkZXIsIGNvbnN0IGNoYXIqIGRhdGEsIGludCBzaXplKQordm9pZCBMb2FkZXI6 OmRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIsIGNvbnN0IGNoYXIqIGRh dGEsIGludCBzaXplKQogewotICAgIFJlZlB0cjxIb3N0PiBwcm90ZWN0b3IodGhpcyk7Ci0KICAg ICBSZXF1ZXN0KiByZXF1ZXN0ID0gbV9yZXF1ZXN0c0xvYWRpbmcuZ2V0KGxvYWRlcik7CiAgICAg aWYgKCFyZXF1ZXN0KQogICAgICAgICByZXR1cm47CkBAIC01NTQsMTAgKzI5MCw4IEBACiAgICAg ICAgIHJlc291cmNlLT5kYXRhKGxvYWRlci0+cmVzb3VyY2VEYXRhKCksIGZhbHNlKTsKIH0KICAg ICAKLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEoU3VicmVzb3Vy Y2VMb2FkZXIqIGxvYWRlciwgY29uc3QgY2hhciogZGF0YSwgaW50IHNpemUpCit2b2lkIExvYWRl cjo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIsIGNv bnN0IGNoYXIqIGRhdGEsIGludCBzaXplKQogewotICAgIFJlZlB0cjxIb3N0PiBwcm90ZWN0b3Io dGhpcyk7Ci0KICAgICBSZXF1ZXN0KiByZXF1ZXN0ID0gbV9yZXF1ZXN0c0xvYWRpbmcuZ2V0KGxv YWRlcik7CiAgICAgaWYgKCFyZXF1ZXN0KQogICAgICAgICByZXR1cm47CkBAIC01NjcsNDEgKzMw MSw1IEBACiAKICAgICByZXNvdXJjZS0+c2V0U2VyaWFsaXplZENhY2hlZE1ldGFkYXRhKGRhdGEs IHNpemUpOwogfQotICAgIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmNhbmNlbFBlbmRpbmdSZXF1ZXN0 cyhSZXF1ZXN0UXVldWUmIHJlcXVlc3RzUGVuZGluZywgQ2FjaGVkUmVzb3VyY2VMb2FkZXIqIGNh Y2hlZFJlc291cmNlTG9hZGVyKQotewotICAgIFJlcXVlc3RRdWV1ZSByZW1haW5pbmc7Ci0gICAg UmVxdWVzdFF1ZXVlOjppdGVyYXRvciBlbmQgPSByZXF1ZXN0c1BlbmRpbmcuZW5kKCk7Ci0gICAg Zm9yIChSZXF1ZXN0UXVldWU6Oml0ZXJhdG9yIGl0ID0gcmVxdWVzdHNQZW5kaW5nLmJlZ2luKCk7 IGl0ICE9IGVuZDsgKytpdCkgewotICAgICAgICBSZXF1ZXN0KiByZXF1ZXN0ID0gKml0OwotICAg ICAgICBpZiAocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2VMb2FkZXIoKSA9PSBjYWNoZWRSZXNvdXJj ZUxvYWRlcikgewotICAgICAgICAgICAgY2FjaGUoKS0+cmVtb3ZlKHJlcXVlc3QtPmNhY2hlZFJl c291cmNlKCkpOwotICAgICAgICAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRlY3JlbWVudFJl cXVlc3RDb3VudChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpKTsKLSAgICAgICAgICAgIGRlbGV0 ZSByZXF1ZXN0OwotICAgICAgICB9IGVsc2UKLSAgICAgICAgICAgIHJlbWFpbmluZy5hcHBlbmQo cmVxdWVzdCk7Ci0gICAgfQotICAgIHJlcXVlc3RzUGVuZGluZy5zd2FwKHJlbWFpbmluZyk7Ci19 CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpjYW5jZWxSZXF1ZXN0cyhDYWNoZWRSZXNvdXJjZUxvYWRl ciogY2FjaGVkUmVzb3VyY2VMb2FkZXIpCi17Ci0gICAgZm9yICh1bnNpZ25lZCBwID0gMDsgcCA8 PSBIaWdoOyBwKyspCi0gICAgICAgIGNhbmNlbFBlbmRpbmdSZXF1ZXN0cyhtX3JlcXVlc3RzUGVu ZGluZ1twXSwgY2FjaGVkUmVzb3VyY2VMb2FkZXIpOwotCi0gICAgVmVjdG9yPFN1YnJlc291cmNl TG9hZGVyKiwgMjU2PiBsb2FkZXJzVG9DYW5jZWw7Ci0KLSAgICBSZXF1ZXN0TWFwOjppdGVyYXRv ciBlbmQgPSBtX3JlcXVlc3RzTG9hZGluZy5lbmQoKTsKLSAgICBmb3IgKFJlcXVlc3RNYXA6Oml0 ZXJhdG9yIGkgPSBtX3JlcXVlc3RzTG9hZGluZy5iZWdpbigpOyBpICE9IGVuZDsgKytpKSB7Ci0g ICAgICAgIFJlcXVlc3QqIHIgPSBpLT5zZWNvbmQ7Ci0gICAgICAgIGlmIChyLT5jYWNoZWRSZXNv dXJjZUxvYWRlcigpID09IGNhY2hlZFJlc291cmNlTG9hZGVyKQotICAgICAgICAgICAgbG9hZGVy c1RvQ2FuY2VsLmFwcGVuZChpLT5maXJzdC5nZXQoKSk7Ci0gICAgfQotCi0gICAgZm9yICh1bnNp Z25lZCBpID0gMDsgaSA8IGxvYWRlcnNUb0NhbmNlbC5zaXplKCk7ICsraSkgewotICAgICAgICBT dWJyZXNvdXJjZUxvYWRlciogbG9hZGVyID0gbG9hZGVyc1RvQ2FuY2VsW2ldOwotICAgICAgICBk aWRGYWlsKGxvYWRlciwgdHJ1ZSk7Ci0gICAgfQotfQotCiB9IC8vbmFtZXNwYWNlIFdlYkNvcmUK SW5kZXg6IFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9sb2FkZXIvT3BlbkNvbm5lY3Rpb25MaW1pdGVyLmNwcAkocmV2aXNpb24g MCkKKysrIFdlYkNvcmUvbG9hZGVyL09wZW5Db25uZWN0aW9uTGltaXRlci5jcHAJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMzE1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNv cHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIg dGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1 dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBm cm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJt aXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IK KyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJP cGVuQ29ubmVjdGlvbkxpbWl0ZXIuaCIKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVk ZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkluc3BlY3Rv ckluc3RydW1lbnRhdGlvbi5oIgorI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlICJSZXNvdXJj ZUxvYWRlci5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdEJhc2UuaCIKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCisvLyBIYXZpbmcgYSBsaW1pdCBtaWdodCBzdGlsbCBoZWxwIGdldHRpbmcg bW9yZSBpbXBvcnRhbnQgcmVzb3VyY2VzIGZpcnN0CitzdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4 UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAyMDsKK3N0YXRpYyB1bnNpZ25l ZCBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdDsKKworT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpQ cmlvcml0eSBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmRldGVybWluZVByaW9yaXR5KGNvbnN0IFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCkgY29uc3QKK3sKKyAgICBzd2l0Y2ggKHJlcXVlc3QudGFy Z2V0VHlwZSgpKSB7CisgICAgY2FzZSBSZXNvdXJjZVJlcXVlc3Q6OlRhcmdldElzTWFpbkZyYW1l OgorICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N1YmZyYW1lOgorICAgIGNhc2Ug UmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N0eWxlU2hlZXQ6CisgICAgICAgIHJldHVybiBIaWdo OworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1NjcmlwdDogCisgICAgY2FzZSBS ZXNvdXJjZVJlcXVlc3Q6OlRhcmdldElzRm9udFJlc291cmNlOgorICAgICAgICByZXR1cm4gTWVk aXVtOworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N1YnJlc291cmNlOgorICAg IGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc0ltYWdlOgorICAgIGNhc2UgUmVzb3VyY2VS ZXF1ZXN0OjpUYXJnZXRJc09iamVjdDoKKyAgICBjYXNlIFJlc291cmNlUmVxdWVzdDo6VGFyZ2V0 SXNNZWRpYToKKyAgICBjYXNlIFJlc291cmNlUmVxdWVzdDo6VGFyZ2V0SXNXb3JrZXI6CisgICAg Y2FzZSBSZXNvdXJjZVJlcXVlc3Q6OlRhcmdldElzU2hhcmVkV29ya2VyOgorICAgICAgICByZXR1 cm4gTG93OworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1ByZWZldGNoOgorICAg ICAgICByZXR1cm4gVmVyeUxvdzsKKyAgICB9CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisg ICAgcmV0dXJuIExvdzsKK30KKworT3BlbkNvbm5lY3Rpb25MaW1pdGVyKiBvcGVuQ29ubmVjdGlv bkxpbWl0ZXIoKQoreworICAgIHN0YXRpYyBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIqIG9wZW5Db25u ZWN0aW9uTGltaXRlciA9IG5ldyBPcGVuQ29ubmVjdGlvbkxpbWl0ZXIoKTsKKyAgICByZXR1cm4g b3BlbkNvbm5lY3Rpb25MaW1pdGVyOworfQorCitPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Ok9wZW5D b25uZWN0aW9uTGltaXRlcigpCisgICAgOiBtX3JlcXVlc3RUaW1lcih0aGlzLCAmT3BlbkNvbm5l Y3Rpb25MaW1pdGVyOjpyZXF1ZXN0VGltZXJGaXJlZCkKKyAgICAsIG1faXNTdXNwZW5kaW5nUGVu ZGluZ1JlcXVlc3RzKGZhbHNlKQoreworICAgIG1fbm9uSFRUUFByb3RvY29sSG9zdCA9IEhvc3Q6 OmNyZWF0ZShTdHJpbmcoKSwgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMp OworICAgIG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0ID0gaW5pdGlhbGl6ZU1heGltdW1IVFRQ Q29ubmVjdGlvbkNvdW50UGVySG9zdCgpOworfQorCit2b2lkIE9wZW5Db25uZWN0aW9uTGltaXRl cjo6c2NoZWR1bGUoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyKQoreworICAgIEFTU0VS VChyZXNvdXJjZUxvYWRlcik7CisKKyAgICBSZWZQdHI8SG9zdD4gaG9zdDsKKyAgICBLVVJMIHVy bChQYXJzZWRVUkxTdHJpbmcsIHJlc291cmNlTG9hZGVyLT5yZXF1ZXN0KCkudXJsKCkpOworICAg IGlmICh1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkgeworICAgICAgICBtX2hvc3RzLmNoZWNr Q29uc2lzdGVuY3koKTsKKyAgICAgICAgU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3QoKTsKKyAg ICAgICAgaG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lKTsKKyAgICAgICAgaWYgKCFob3N0KSB7 CisgICAgICAgICAgICBob3N0ID0gSG9zdDo6Y3JlYXRlKGhvc3ROYW1lLCBtYXhSZXF1ZXN0c0lu RmxpZ2h0UGVySG9zdCk7CisgICAgICAgICAgICBtX2hvc3RzLmFkZChob3N0TmFtZSwgaG9zdCk7 CisgICAgICAgIH0KKyAgICB9IGVsc2UgCisgICAgICAgIGhvc3QgPSBtX25vbkhUVFBQcm90b2Nv bEhvc3Q7CisgICAgCisgICAgYm9vbCBoYWRSZXF1ZXN0cyA9IGhvc3QtPmhhc1JlcXVlc3RzKCk7 CisgICAgUHJpb3JpdHkgcHJpb3JpdHkgPSBkZXRlcm1pbmVQcmlvcml0eShyZXNvdXJjZUxvYWRl ci0+cmVxdWVzdCgpKTsKKyAgICBob3N0LT5hZGRSZXF1ZXN0KHJlc291cmNlTG9hZGVyLCBwcmlv cml0eSk7CisKKyAgICBpZiAocHJpb3JpdHkgPiBMb3cgfHwgIXVybC5wcm90b2NvbEluSFRUUEZh bWlseSgpIHx8IChwcmlvcml0eSA9PSBMb3cgJiYgIWhhZFJlcXVlc3RzKSkgeworICAgICAgICAv LyBUcnkgdG8gcmVxdWVzdCBpbXBvcnRhbnQgcmVzb3VyY2VzIGltbWVkaWF0ZWx5CisgICAgICAg IGhvc3QtPnNlcnZlUGVuZGluZ1JlcXVlc3RzKHByaW9yaXR5KTsKKyAgICB9IGVsc2UgeworICAg ICAgICAvLyBIYW5kbGUgYXN5bmNocm9ub3VzbHkgc28gZWFybHkgbG93IHByaW9yaXR5IHJlcXVl c3RzIGRvbid0IGdldCBzY2hlZHVsZWQgYmVmb3JlIGxhdGVyIGhpZ2ggcHJpb3JpdHkgb25lcwor ICAgICAgICBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OmRpZFNjaGVkdWxlUmVzb3VyY2VSZXF1 ZXN0KHJlc291cmNlTG9hZGVyLT5mcmFtZUxvYWRlcigpID8gcmVzb3VyY2VMb2FkZXItPmZyYW1l TG9hZGVyKCktPmZyYW1lKCktPmRvY3VtZW50KCkgOiAwLCByZXNvdXJjZUxvYWRlci0+cmVxdWVz dCgpLnVybCgpKTsKKyAgICAgICAgc2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOworICAg IH0KK30KKwordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmVuZChSZXNvdXJjZUxvYWRlciog cmVzb3VyY2VMb2FkZXIpCit7CisgICAgQVNTRVJUKHJlc291cmNlTG9hZGVyKTsKKworICAgIFJl ZlB0cjxIb3N0PiBob3N0OworICAgIEtVUkwgdXJsKFBhcnNlZFVSTFN0cmluZywgcmVzb3VyY2VM b2FkZXItPnJlcXVlc3QoKS51cmwoKSk7CisgICAgaWYgKHVybC5wcm90b2NvbEluSFRUUEZhbWls eSgpKSB7CisgICAgICAgIG1faG9zdHMuY2hlY2tDb25zaXN0ZW5jeSgpOworICAgICAgICBob3N0 ID0gbV9ob3N0cy5nZXQodXJsLmhvc3QoKSk7CisgICAgfSBlbHNlIAorICAgICAgICBob3N0ID0g bV9ub25IVFRQUHJvdG9jb2xIb3N0OworCisgICAgaWYgKGhvc3QpCisgICAgICAgIGhvc3QtPmVu ZChyZXNvdXJjZUxvYWRlciwgZGV0ZXJtaW5lUHJpb3JpdHkocmVzb3VyY2VMb2FkZXItPnJlcXVl c3QoKSkpOworICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKK30KKwordm9pZCBP cGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmNoYW5nZUhvc3QoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNl TG9hZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit7CisgICAgS1VSTCBvbGRV UkwoUGFyc2VkVVJMU3RyaW5nLCByZXNvdXJjZUxvYWRlci0+cmVxdWVzdCgpLnVybCgpKTsKKyAg ICBLVVJMIG5ld1VSTChQYXJzZWRVUkxTdHJpbmcsIHJlcXVlc3QudXJsKCkpOworCisgICAgUmVm UHRyPEhvc3Q+IG9sZEhvc3Q7CisgICAgaWYgKG9sZFVSTC5wcm90b2NvbEluSFRUUEZhbWlseSgp KSB7CisgICAgICAgIG1faG9zdHMuY2hlY2tDb25zaXN0ZW5jeSgpOworICAgICAgICBvbGRIb3N0 ID0gbV9ob3N0cy5nZXQob2xkVVJMLmhvc3QoKSk7CisgICAgfSBlbHNlIAorICAgICAgICBvbGRI b3N0ID0gbV9ub25IVFRQUHJvdG9jb2xIb3N0OworICAgIEFTU0VSVChvbGRIb3N0KTsKKworICAg IFJlZlB0cjxIb3N0PiBuZXdIb3N0OworICAgIGlmIChuZXdVUkwucHJvdG9jb2xJbkhUVFBGYW1p bHkoKSkgeworICAgICAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3koKTsKKyAgICAgICAgU3Ry aW5nIGhvc3ROYW1lID0gbmV3VVJMLmhvc3QoKTsKKyAgICAgICAgbmV3SG9zdCA9IG1faG9zdHMu Z2V0KGhvc3ROYW1lKTsKKyAgICAgICAgaWYgKCFuZXdIb3N0KSB7CisgICAgICAgICAgICBuZXdI b3N0ID0gSG9zdDo6Y3JlYXRlKGhvc3ROYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCk7 CisgICAgICAgICAgICBtX2hvc3RzLmFkZChob3N0TmFtZSwgbmV3SG9zdCk7CisgICAgICAgIH0K KyAgICB9IGVsc2UgCisgICAgICAgIG5ld0hvc3QgPSBtX25vbkhUVFBQcm90b2NvbEhvc3Q7CisK KyAgICBpZiAob2xkSG9zdCA9PSBuZXdIb3N0KQorICAgICAgICByZXR1cm47CisKKyAgICBvbGRI b3N0LT5lbmQocmVzb3VyY2VMb2FkZXIsIGRldGVybWluZVByaW9yaXR5KHJlc291cmNlTG9hZGVy LT5yZXF1ZXN0KCkpKTsKKyAgICBuZXdIb3N0LT5hZGRSZXF1ZXN0V2l0aG91dFNjaGVkdWxlKHJl c291cmNlTG9hZGVyKTsKK30KKwordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OmFkZFJlcXVl c3RXaXRob3V0U2NoZWR1bGUoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyKQoreworICAg IEFTU0VSVChyZXNvdXJjZUxvYWRlcik7CisKKyAgICBSZWZQdHI8SG9zdD4gaG9zdDsKKyAgICBL VVJMIHVybChQYXJzZWRVUkxTdHJpbmcsIHJlc291cmNlTG9hZGVyLT5yZXF1ZXN0KCkudXJsKCkp OworICAgIGlmICh1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkgeworICAgICAgICBtX2hvc3Rz LmNoZWNrQ29uc2lzdGVuY3koKTsKKyAgICAgICAgU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3Qo KTsKKyAgICAgICAgaG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lKTsKKyAgICAgICAgaWYgKCFo b3N0KSB7CisgICAgICAgICAgICBob3N0ID0gSG9zdDo6Y3JlYXRlKGhvc3ROYW1lLCBtYXhSZXF1 ZXN0c0luRmxpZ2h0UGVySG9zdCk7CisgICAgICAgICAgICBtX2hvc3RzLmFkZChob3N0TmFtZSwg aG9zdCk7CisgICAgICAgIH0KKyAgICB9IGVsc2UgCisgICAgICAgIGhvc3QgPSBtX25vbkhUVFBQ cm90b2NvbEhvc3Q7CisKKyAgICBBU1NFUlQoaG9zdCk7CisgICAgaG9zdC0+YWRkUmVxdWVzdFdp dGhvdXRTY2hlZHVsZShyZXNvdXJjZUxvYWRlcik7Cit9CisKK3ZvaWQgT3BlbkNvbm5lY3Rpb25M aW1pdGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkpCit7 CisgICAgaWYgKG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKQorICAgICAgICByZXR1cm47 CisKKyAgICBtX3JlcXVlc3RUaW1lci5zdG9wKCk7CisgICAgCisgICAgbV9ub25IVFRQUHJvdG9j b2xIb3N0LT5zZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhtaW5pbXVtUHJpb3JpdHkpOworCisgICAgVmVj dG9yPEhvc3QqPiBob3N0c1RvU2VydmU7CisgICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5KCk7 CisgICAgSG9zdE1hcDo6aXRlcmF0b3IgaSA9IG1faG9zdHMuYmVnaW4oKTsKKyAgICBIb3N0TWFw OjppdGVyYXRvciBlbmQgPSBtX2hvc3RzLmVuZCgpOworICAgIGZvciAoO2kgIT0gZW5kOyArK2kp CisgICAgICAgIGhvc3RzVG9TZXJ2ZS5hcHBlbmQoaS0+c2Vjb25kLmdldCgpKTsKKyAgICAgICAg CisgICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IGhvc3RzVG9TZXJ2ZS5zaXplKCk7ICsrbikg eworICAgICAgICBIb3N0KiBob3N0ID0gaG9zdHNUb1NlcnZlW25dOworICAgICAgICBpZiAoaG9z dC0+aGFzUmVxdWVzdHMoKSkKKyAgICAgICAgICAgIGhvc3QtPnNlcnZlUGVuZGluZ1JlcXVlc3Rz KG1pbmltdW1Qcmlvcml0eSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIG1faG9zdHMucmVt b3ZlKGhvc3QtPm5hbWUoKSk7CisgICAgfQorfQorCit2b2lkIE9wZW5Db25uZWN0aW9uTGltaXRl cjo6c3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpCit7CisgICAgQVNTRVJUKCFtX2lzU3VzcGVuZGlu Z1BlbmRpbmdSZXF1ZXN0cyk7CisgICAgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMgPSB0 cnVlOworfQorCit2b2lkIE9wZW5Db25uZWN0aW9uTGltaXRlcjo6cmVzdW1lUGVuZGluZ1JlcXVl c3RzKCkKK3sKKyAgICBBU1NFUlQobV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMpOworICAg IG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzID0gZmFsc2U7CisgICAgaWYgKCFtX2hvc3Rz LmlzRW1wdHkoKSB8fCBtX25vbkhUVFBQcm90b2NvbEhvc3QtPmhhc1JlcXVlc3RzKCkpCisgICAg ICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKK30KKyAgICAKK3ZvaWQgT3BlbkNv bm5lY3Rpb25MaW1pdGVyOjpzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCkKK3sKKyAgICBp ZiAoIW1fcmVxdWVzdFRpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fcmVxdWVzdFRpbWVyLnN0 YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6OnJlcXVlc3RU aW1lckZpcmVkKFRpbWVyPE9wZW5Db25uZWN0aW9uTGltaXRlcj4qKSAKK3sKKyAgICBzZXJ2ZVBl bmRpbmdSZXF1ZXN0cygpOworfQorCitPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Okhvc3Q6Okhvc3Qo Y29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0KQorICAgIDog bV9uYW1lKG5hbWUpCisgICAgLCBtX21heFJlcXVlc3RzSW5GbGlnaHQobWF4UmVxdWVzdHNJbkZs aWdodCkKK3sKK30KKworT3BlbkNvbm5lY3Rpb25MaW1pdGVyOjpIb3N0Ojp+SG9zdCgpCit7Cisg ICAgQVNTRVJUKG1fcmVxdWVzdHNMb2FkaW5nLmlzRW1wdHkoKSk7CisgICAgZm9yICh1bnNpZ25l ZCBwID0gMDsgcCA8PSBIaWdoOyBwKyspCisgICAgICAgIEFTU0VSVChtX3JlcXVlc3RzUGVuZGlu Z1twXS5pc0VtcHR5KCkpOworfQorICAgIAordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Okhv c3Q6OmFkZFJlcXVlc3QoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyLCBQcmlvcml0eSBw cmlvcml0eSkKK3sKKyAgICBtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0uYXBwZW5kKHJlc291 cmNlTG9hZGVyKTsKK30KKwordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6Okhvc3Q6OmFkZFJl cXVlc3RXaXRob3V0U2NoZWR1bGUoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyKQorewor ICAgIG1fcmVxdWVzdHNMb2FkaW5nLmFkZChyZXNvdXJjZUxvYWRlcik7Cit9CisKK2Jvb2wgT3Bl bkNvbm5lY3Rpb25MaW1pdGVyOjpIb3N0OjpoYXNSZXF1ZXN0cygpIGNvbnN0Cit7CisgICAgaWYg KCFtX3JlcXVlc3RzTG9hZGluZy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAg IGZvciAodW5zaWduZWQgcCA9IDA7IHAgPD0gSGlnaDsgcCsrKSB7CisgICAgICAgIGlmICghbV9y ZXF1ZXN0c1BlbmRpbmdbcF0uaXNFbXB0eSgpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7Cisg ICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKwordm9pZCBPcGVuQ29ubmVjdGlvbkxpbWl0ZXI6 Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKE9wZW5Db25uZWN0aW9uTGltaXRlcjo6UHJpb3Jp dHkgbWluaW11bVByaW9yaXR5KQoreworICAgIGJvb2wgc2VydmVNb3JlID0gdHJ1ZTsKKyAgICBm b3IgKGludCBwcmlvcml0eSA9IEhpZ2g7IHByaW9yaXR5ID49IG1pbmltdW1Qcmlvcml0eSAmJiBz ZXJ2ZU1vcmU7IC0tcHJpb3JpdHkpCisgICAgICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKG1fcmVx dWVzdHNQZW5kaW5nW3ByaW9yaXR5XSwgc2VydmVNb3JlKTsKK30KKwordm9pZCBPcGVuQ29ubmVj dGlvbkxpbWl0ZXI6Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKFJlcXVlc3RRdWV1ZSYgcmVx dWVzdHNQZW5kaW5nLCBib29sJiBzZXJ2ZUxvd2VyUHJpb3JpdHkpCit7CisgICAgd2hpbGUgKCFy ZXF1ZXN0c1BlbmRpbmcuaXNFbXB0eSgpKSB7ICAgICAgICAKKyAgICAgICAgUmVmUHRyPFJlc291 cmNlTG9hZGVyPiByZXNvdXJjZUxvYWRlciA9IHJlcXVlc3RzUGVuZGluZy5maXJzdCgpOworCisg ICAgICAgIC8vIEZvciBuYW1lZCBob3N0cyAtIHdoaWNoIGFyZSBvbmx5IGh0dHAocykgaG9zdHMg LSB3ZSBzaG91bGQgYWx3YXlzIGVuZm9yY2UgdGhlIGNvbm5lY3Rpb24gbGltaXQuCisgICAgICAg IC8vIEZvciBub24tbmFtZWQgaG9zdHMgLSBldmVyeXRoaW5nIGJ1dCBodHRwKHMpIC0gd2Ugc2hv dWxkIG9ubHkgZW5mb3JjZSB0aGUgbGltaXQgaWYgdGhlIGRvY3VtZW50IGlzbid0IGRvbmUgcGFy c2luZyAKKyAgICAgICAgLy8gYW5kIHdlIGRvbid0IGtub3cgYWxsIHN0eWxlc2hlZXRzIHlldC4K KyAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gcmVzb3VyY2VMb2FkZXItPmZyYW1lTG9hZGVy KCkgPyByZXNvdXJjZUxvYWRlci0+ZnJhbWVMb2FkZXIoKS0+ZnJhbWUoKS0+ZG9jdW1lbnQoKSA6 IDA7CisgICAgICAgIGJvb2wgc2hvdWxkTGltaXRSZXF1ZXN0cyA9ICFtX25hbWUuaXNOdWxsKCkg fHwgKGRvY3VtZW50ICYmIChkb2N1bWVudC0+cGFyc2luZygpIHx8ICFkb2N1bWVudC0+aGF2ZVN0 eWxlc2hlZXRzTG9hZGVkKCkpKTsKKyAgICAgICAgaWYgKHNob3VsZExpbWl0UmVxdWVzdHMgJiYg bV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpID49IG1fbWF4UmVxdWVzdHNJbkZsaWdodCkgeworICAg ICAgICAgICAgc2VydmVMb3dlclByaW9yaXR5ID0gZmFsc2U7CisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIH0KKyAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcuYWRkKHJlc291cmNlTG9hZGVy KTsKKyAgICAgICAgcmVxdWVzdHNQZW5kaW5nLnJlbW92ZUZpcnN0KCk7ICAgICAgIAorICAgICAg ICByZXNvdXJjZUxvYWRlci0+c3RhcnQoKTsKKyAgICB9Cit9CisKK3ZvaWQgT3BlbkNvbm5lY3Rp b25MaW1pdGVyOjpIb3N0OjplbmQoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyLCBPcGVu Q29ubmVjdGlvbkxpbWl0ZXI6OlByaW9yaXR5IHByaW9yaXR5KQoreworICAgIGlmIChtX3JlcXVl c3RzTG9hZGluZy5jb250YWlucyhyZXNvdXJjZUxvYWRlcikpIHsKKyAgICAgICAgbV9yZXF1ZXN0 c0xvYWRpbmcucmVtb3ZlKHJlc291cmNlTG9hZGVyKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIFJlcXVlc3RRdWV1ZTo6aXRlcmF0b3IgZW5kID0gbV9yZXF1ZXN0c1BlbmRpbmdbcHJp b3JpdHldLmVuZCgpOworICAgIGZvciAoUmVxdWVzdFF1ZXVlOjppdGVyYXRvciBpdCA9IG1fcmVx dWVzdHNQZW5kaW5nW3ByaW9yaXR5XS5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAg ICAgaWYgKCppdCA9PSByZXNvdXJjZUxvYWRlcikgeworICAgICAgICAgICAgbV9yZXF1ZXN0c1Bl bmRpbmdbcHJpb3JpdHldLnJlbW92ZShpdCk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAg IH0KKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IExheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvbG9nb3V0Lmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9sb2dvdXQuaHRtbAkocmV2aXNpb24g NjkzMTMpCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2xvZ291dC5o dG1sCSh3b3JraW5nIGNvcHkpCkBAIC0yNCw3ICsyNCwxMiBAQAogICAgIC8vIGxvZ291dC5odG1s IGRvZXNuJ3QgZXZlbiBleGlzdCAtIHdlIGRvbid0IG5lZWQgdG8gc2VuZCB0aGlzIHJlcXVlc3Qg dG8gc2VydmVyLgogICAgIHhoci5vcGVuKCJHRVQiLCAicmVzb3VyY2VzL2xvZ291dC9zdWJkaXJl Y3RvcnkvbG9nb3V0Lmh0bWwiLCB0cnVlLCAibG9nb3V0IiwgImxvZ291dCIpOwogICAgIHhoci5z ZW5kKCIiKTsKLSAgICB4aHIuYWJvcnQoKTsKKyAgICB4aHIub25sb2FkID0gZnVuY3Rpb24oKSB7 CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsb2dvdXQiKS5pbm5lckhUTUwgPSBp c0F1dGhlbnRpY2F0ZWQoKSA/ICJGQUlMIiA6ICJQQVNTIjsKKworICAgICAgICBpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu bm90aWZ5RG9uZSgpOworICAgIH0KIH0KIAogZnVuY3Rpb24gaXNBdXRoZW50aWNhdGVkKCkKQEAg LTQ0LDEzICs0OSw5IEBACiByLm9wZW4oIkdFVCIsICJyZXNvdXJjZXMvbG9nb3V0L3Jlc291cmNl LnBocD9pc0F1dGhlbnRpY2F0ZWQiLCB0cnVlKTsKIHIub25sb2FkID0gZnVuY3Rpb24oKSB7CiAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImFzeW5jIikuaW5uZXJIVE1MID0gci5zdGF0dXMg PT0gMjAwID8gIlBBU1MiIDogIkZBSUwiOwotCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKLSAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwogfQog ci5zZW5kKCIiKTsKIAogbG9nb3V0KCk7Ci1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibG9nb3V0 IikuaW5uZXJIVE1MID0gaXNBdXRoZW50aWNhdGVkKCkgPyAiRkFJTCIgOiAiUEFTUyI7CiA8L3Nj cmlwdD4KIDwvYm9keT4KSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDY5MzEzKQorKysgTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTIgQEAKKzIwMTAtMTAtMDcgIE5h dGUgQ2hhcGluICA8amFwaGV0QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZXdyaXRlIHRlc3QgZm9yIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzE2NQorCisgICAgICAgICogaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9sb2dvdXQuaHRtbDogSXQgaXMgbm8gbG9uZ2VyIHNhZmUKKyAgICAgICAg dG8gYXNzdW1lIHRoYXQgYW4gYXN5bmMgeGhyIHdpbGwgaGF2ZSBhbnkgZWZmZWN0cyBzeW5jaHJv bm91c2x5LgorCiAyMDEwLTEwLTA3ICBOaWtvbGFzIFppbW1lcm1hbm4gIDxuemltbWVybWFubkBy aW0uY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERpcmsgU2NodWx6ZS4K 70314 2010-10-08 16:30:45 -0700 2010-11-03 16:32:32 -0700 Rename to ResourceLoadScheduler, etc. ocl4.txt text/plain 62423 japhet SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTAtMTAtMDcgIE5hdGUgQ2hhcGluICA8amFwaGV0 QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBGdW5jdGlvbiBjYWxsIHVwZGF0ZSBmb3IgCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzE2NS4KKworICAgICAgICAqIFdlYlZpZXcvV2Vi Vmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3Rz XSk6CisKIDIwMTAtMTAtMDUgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcnRpbiBSb2JpbnNvbi4KSW5kZXg6IFdlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3Lm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9X ZWJWaWV3Lm1tCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 Lm1tCSh3b3JraW5nIGNvcHkpCkBAIC0xNDYsNiArMTQ2LDcgQEAKICNpbXBvcnQgPFdlYkNvcmUv UHJvZ3Jlc3NUcmFja2VyLmg+CiAjaW1wb3J0IDxXZWJDb3JlL1JlbmRlcldpZGdldC5oPgogI2lt cG9ydCA8V2ViQ29yZS9SZXNvdXJjZUhhbmRsZS5oPgorI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJj ZUxvYWRTY2hlZHVsZXIuaD4KICNpbXBvcnQgPFdlYkNvcmUvUnVudGltZUFwcGxpY2F0aW9uQ2hl Y2tzLmg+CiAjaW1wb3J0IDxXZWJDb3JlL1NjaGVtZVJlZ2lzdHJ5Lmg+CiAjaW1wb3J0IDxXZWJD b3JlL1NjcmlwdENvbnRyb2xsZXIuaD4KQEAgLTYxOSw3ICs2MjAsNyBAQAogCiAtICh2b2lkKV9k aXNwYXRjaFBlbmRpbmdMb2FkUmVxdWVzdHMKIHsKLSAgICBjYWNoZSgpLT5sb2FkZXIoKS0+c2Vy dmVQZW5kaW5nUmVxdWVzdHMoKTsKKyAgICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c2VydmVQ ZW5kaW5nUmVxdWVzdHMoKTsKIH0KIAogLSAodm9pZClfcmVnaXN0ZXJEcmFnZ2VkVHlwZXMKSW5k ZXg6IFdlYkNvcmUvV2ViQ29yZS5leHAuaW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LmV4cC5pbgkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL1dlYkNvcmUuZXhwLmluCSh3b3Jr aW5nIGNvcHkpCkBAIC00NDMsNiArNDQzLDcgQEAKIF9fWk43V2ViQ29yZTIwUmVzb3VyY2VSZXNw b25zZUJhc2VDMkV2CiBfX1pON1dlYkNvcmUyMFNwYWNlU3BsaXRTdHJpbmdEYXRhMTJjcmVhdGVW ZWN0b3JFdgogX19aTjdXZWJDb3JlMjBwcm90b2NvbElzSmF2YVNjcmlwdEVSS04zV1RGNlN0cmlu Z0UKK19fWk43V2ViQ29yZTIxUmVzb3VyY2VMb2FkU2NoZWR1bGVyMjBzZXJ2ZVBlbmRpbmdSZXF1 ZXN0c0VOUzBfOFByaW9yaXR5RQogX19aTjdXZWJDb3JlMjFQbGF0Zm9ybUtleWJvYXJkRXZlbnQy NGRpc2FtYmlndWF0ZUtleURvd25FdmVudEVOUzBfNFR5cGVFYgogX19aTjdXZWJDb3JlMjFQbGF0 Zm9ybUtleWJvYXJkRXZlbnRDMUVQN05TRXZlbnQKIF9fWk43V2ViQ29yZTIxU1ZHRG9jdW1lbnRF eHRlbnNpb25zMjFzYW1wbGVBbmltYXRpb25BdFRpbWVFUktOM1dURjZTdHJpbmdFUE5TXzE0U1ZH U01JTEVsZW1lbnRFZApAQCAtNDU3LDYgKzQ1OCw3IEBACiBfX1pON1dlYkNvcmUyMW1haW5UaHJl YWROb3JtYWxXb3JsZEV2CiBfX1pON1dlYkNvcmUyMW1hcmtlclRleHRGb3JMaXN0SXRlbUVQTlNf N0VsZW1lbnRFCiBfX1pON1dlYkNvcmUyMXJlcG9ydFRocmVhZFZpb2xhdGlvbkVQS2NOU18yMFRo cmVhZFZpb2xhdGlvblJvdW5kRQorX19aTjdXZWJDb3JlMjFyZXNvdXJjZUxvYWRTY2hlZHVsZXJF dgogX19aTjdXZWJDb3JlMjFzZXRQbGF0Zm9ybVN0cmF0ZWdpZXNFUE5TXzE4UGxhdGZvcm1TdHJh dGVnaWVzRQogX19aTjdXZWJDb3JlMjJTY3JpcHRFeGVjdXRpb25Db250ZXh0MjZjYW5TdXNwZW5k QWN0aXZlRE9NT2JqZWN0c0V2CiBfX1pON1dlYkNvcmUyMmFwcGxpY2F0aW9uSXNBcHBsZU1haWxF dgpAQCAtNjU0LDcgKzY1Niw2IEBACiBfX1pON1dlYkNvcmU2RWRpdG9yN0NvbW1hbmRDMUV2CiBf X1pON1dlYkNvcmU2RWRpdG9yN2NvbW1hbmRFUktOM1dURjZTdHJpbmdFCiBfX1pON1dlYkNvcmU2 RWRpdG9yN291dGRlbnRFdgotX19aTjdXZWJDb3JlNkxvYWRlcjIwc2VydmVQZW5kaW5nUmVxdWVz dHNFTlMwXzhQcmlvcml0eUUKIF9fWk43V2ViQ29yZTZXaWRnZXQxMnNldEZyYW1lUmVjdEVSS05T XzdJbnRSZWN0RQogX19aTjdXZWJDb3JlNldpZGdldDE2cmVtb3ZlRnJvbVBhcmVudEV2CiBfX1pO N1dlYkNvcmU2V2lkZ2V0MTdmcmFtZVJlY3RzQ2hhbmdlZEV2CkluZGV4OiBXZWJDb3JlL2RvbS9D b250YWluZXJOb2RlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Db250YWluZXJOb2Rl LmNwcAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL2RvbS9Db250YWluZXJOb2RlLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMzUsMTEgKzM1LDExIEBACiAjaW5jbHVkZSAiSW5saW5lVGV4dEJv eC5oIgogI2luY2x1ZGUgIkluc3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIk11 dGF0aW9uRXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKICNpbmNs dWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUmVuZGVyQm94LmgiCiAjaW5jbHVkZSAiUmVuZGVyVGhl bWUuaCIKICNpbmNsdWRlICJSb290SW5saW5lQm94LmgiCi0jaW5jbHVkZSAibG9hZGVyLmgiCiAj aW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCkBA IC02NTcsNyArNjU3LDcgQEAKICAgICAgICAgICAgICAgICBzX3Nob3VsZFJlRW5hYmxlTWVtb3J5 Q2FjaGVDYWxsc0FmdGVyQXR0YWNoID0gdHJ1ZTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQot ICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+c3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpOworICAg ICAgICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpOwog ICAgIH0KICAgICArK3NfYXR0YWNoRGVwdGg7CiB9CkBAIC02NzIsNyArNjcyLDcgQEAKICAgICAg ICAgICAgIGlmIChQYWdlKiBwYWdlID0gZG9jdW1lbnQoKS0+cGFnZSgpKQogICAgICAgICAgICAg ICAgIHBhZ2UtPnNldE1lbW9yeUNhY2hlQ2xpZW50Q2FsbHNFbmFibGVkKHRydWUpOwogICAgICAg ICB9Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5yZXN1bWVQZW5kaW5nUmVxdWVzdHMoKTsK KyAgICAgICAgcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPnJlc3VtZVBlbmRpbmdSZXF1ZXN0cygp OwogICAgIH0KICAgICAtLXNfYXR0YWNoRGVwdGg7CiB9CkluZGV4OiBXZWJDb3JlL1dlYkNvcmUu cHJvCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5wcm8JKHJldmlzaW9uIDY5MzEzKQor KysgV2ViQ29yZS9XZWJDb3JlLnBybwkod29ya2luZyBjb3B5KQpAQCAtMTA0OCw2ICsxMDQ4LDcg QEAKICAgICBsb2FkZXIvUmVxdWVzdC5jcHAgXAogICAgIGxvYWRlci9SZXNvdXJjZUxvYWRlci5j cHAgXAogICAgIGxvYWRlci9SZXNvdXJjZUxvYWROb3RpZmllci5jcHAgXAorICAgIGxvYWRlci9S ZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwIFwKICAgICBsb2FkZXIvU2lua0RvY3VtZW50LmNwcCBc CiAgICAgbG9hZGVyL1N1YmZyYW1lTG9hZGVyLmNwcCBcCiAgICAgbG9hZGVyL1N1YnJlc291cmNl TG9hZGVyLmNwcCBcCkluZGV4OiBXZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL0NoYW5nZUxvZwkocmV2aXNpb24gNjkzNDYpCisrKyBXZWJDb3JlL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDgyIEBACisyMDEwLTEwLTA3ICBOYXRlIENoYXBpbiAgPGph cGhldEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgTW92ZSBjb25uZWN0aW9uLXBlci1ob3N0IGNvdW50aW5nIGFuZCByZXF1ZXN0 IHByaW9yaXRpemF0aW9uIG91dAorICAgICAgICBvZiBMb2FkZXIgYW5kIGRvd24gdG8gdGhlIFJl c291cmNlTG9hZGVyIGxldmVsLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yNzE2NQorCisgICAgICAgIFJlZmFjdG9yIG9ubHksIHNvIG5vIG5ldyB0 ZXN0cy4gQmVjYXVzZSBhc3luYyBYSFJzIGFyZSBzdWJqZWN0IHRvIHByaW9yaXRpemF0aW9uIGFu ZAorICAgICAgICBubyBsb25nZXIgZ3VhcmFudGVlZCB0byBiZSBzdGFydGVkIHN5bmNocm9ub3Vz bHksIG9uZSB0ZXN0IGlzIGJlaW5nIG1vZGlmaWVkLgorCisgICAgICAgICogQW5kcm9pZC5tazoK KyAgICAgICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAg ICAgICAgKiBXZWJDb3JlLmV4cC5pbjoKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAg ICogV2ViQ29yZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2o6 CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAq IGRvbS9Db250YWluZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5lck5vZGU6 OnN1c3BlbmRQb3N0QXR0YWNoQ2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5l ck5vZGU6OnJlc3VtZVBvc3RBdHRhY2hDYWxsYmFja3MpOgorICAgICAgICAqIGxvYWRlci9NYWlu UmVzb3VyY2VMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFpblJlc291cmNlTG9hZGVy Ojpsb2FkTm93KToKKyAgICAgICAgKiBsb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcDog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmRldGVybWlu ZVByaW9yaXR5KTogTW92ZWQgZnJvbSBsb2FkZXIuY3BwLCBzZXQKKyAgICAgICAgICAgIGJhc2Vk IG9uIFJlc291cmNlUmVxdWVzdCB0eXBlIHJhdGhlciB0aGFuIENhY2hlZFJlc291cmNlIHR5cGUu CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6Omhvc3RGb3JVUkwpOgor ICAgICAgICAoV2ViQ29yZTo6cmVzb3VyY2VMb2FkU2NoZWR1bGVyKTogUmV0dXJucyB0aGUgc2lu Z2xlIFJlc291cmNlTG9hZFNjaGVkdWxlciBpbnN0YW5jZQorICAgICAgICAoV2ViQ29yZTo6UmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXIpOgorICAgICAgICAoV2Vi Q29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjphZGQpOiBXYXMgYXBwcm94aW1hdGVseSBMb2Fk ZXI6OmxvYWQoKQorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpyZW1v dmUpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpjaGFuZ2VIb3N0 KTogTW92ZSBhIFJlc291cmNlTG9hZGVyIGZyb20gb25lCisgICAgICAgICAgICAgSG9zdEluZm9y bWF0aW9uIHRvIGFub3RoZXIgKGZvciBjcm9zcy1vcmlnaW4gcmVkaXJlY3RzKS4KKyAgICAgICAg KFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6c2VydmVQZW5kaW5nUmVxdWVzdHMpOgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzdXNwZW5kUGVuZGluZ1Jl cXVlc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6cmVzdW1l UGVuZGluZ1JlcXVlc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxl cjo6c2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cyk6CisgICAgICAgIChXZWJDb3JlOjpSZXNv dXJjZUxvYWRTY2hlZHVsZXI6OnJlcXVlc3RUaW1lckZpcmVkKToKKyAgICAgICAgKFdlYkNvcmU6 OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjpIb3N0SW5mb3JtYXRpb24p OgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5mb3JtYXRp b246On5Ib3N0SW5mb3JtYXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2No ZWR1bGVyOjpIb3N0SW5mb3JtYXRpb246OmFkZCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6cmVtb3ZlKToKKyAgICAgICAgKFdlYkNv cmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjpoYXNSZXF1ZXN0cyk6 CisgICAgICAgICogbG9hZGVyL1Jlc291cmNlTG9hZFNjaGVkdWxlci5oOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjpjcmVh dGUpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5mb3Jt YXRpb246Om5hbWUpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpI b3N0SW5mb3JtYXRpb246OmxpbWl0UmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3Vy Y2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5mb3JtYXRpb246OnJlcXVlc3RzUGVuZGluZyk6CisgICAg ICAgICogbG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlc291 cmNlTG9hZGVyOjpyZWxlYXNlUmVzb3VyY2VzKTogUmVtb3ZlIHRoaXMgZnJvbSBSZXNvdXJjZUxv YWRTY2hlZHVsZXIncyBjb3VudGluZy4KKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZGVy Ojpsb2FkKTogU2NoZWR1bGUgdGhlIGNyZWF0aW9uIG9mIHRoZSBSZXNvdXJjZUhhbmRsZSwgcmF0 aGVyIHRoYW4KKyAgICAgICAgICAgIGRvaW5nIGl0IGltbWVkaWF0ZWx5LgorICAgICAgICAoV2Vi Q29yZTo6UmVzb3VyY2VMb2FkZXI6OnN0YXJ0KTogQ3JlYXRlIHRoZSBSZXNvdXJjZUhhbmRsZSwg Y2FsbGVkIGJ5IFJlc291cmNlTG9hZFNjaGVkdWxlci4KKyAgICAgICAgKFdlYkNvcmU6OlJlc291 cmNlTG9hZGVyOjp3aWxsU2VuZFJlcXVlc3QpOiBFbnN1cmUgUmVzb3VyY2VMb2FkU2NoZWR1bGVy IGNvdW50cyByZWRpcmVjdHMKKyAgICAgICAgICAgIGNvcnJlY3RseS4KKyAgICAgICAgKiBsb2Fk ZXIvUmVzb3VyY2VMb2FkZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmNwcDpNb3ZlIHNj aGVkdWxpbmcgdG8gUmVzb3VyY2VMb2FkU2NoZWR1bGVyLCByZW1vdmUgSG9zdCBzdWJjbGFzcwor ICAgICAgICAgICAgYW5kIG1ha2UgTG9hZGVyIHRoZSBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCBp bnN0ZWFkLgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpsb2FkKToKKyAgICAgICAgKFdlYkNv cmU6OkxvYWRlcjo6Y2FuY2VsUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpk aWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGlkRmFpbCk6Cisg ICAgICAgIChXZWJDb3JlOjpMb2FkZXI6OmRpZFJlY2VpdmVSZXNwb25zZSk6CisgICAgICAgIChX ZWJDb3JlOjpMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRl cjo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKToKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmg6 CisgICAgICAgICogcGFnZS9FdmVudFNvdXJjZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFdmVu dFNvdXJjZTo6Y29ubmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFNvdXJjZTo6ZW5kUmVx dWVzdCk6CisgICAgICAgICogeG1sL1hNTEh0dHBSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlhNTEh0dHBSZXF1ZXN0OjpYTUxIdHRwUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpY TUxIdHRwUmVxdWVzdDo6flhNTEh0dHBSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0 dHBSZXF1ZXN0OjpjcmVhdGVSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1 ZXN0OjpkaWRGYWlsKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpkaWRGaW5p c2hMb2FkaW5nKToKKyAgICAgICAgKiB4bWwvWE1MSHR0cFJlcXVlc3QuaDoKKwogMjAxMC0xMC0w NyAgQWJoaXNoZWsgQXJ5YSAgPGluZmVybm9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmll d2VkIGJ5IERhdmUgSHlhdHQuCkluZGV4OiBXZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUu dmNwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3By b2oJKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZj cHJvagkod29ya2luZyBjb3B5KQpAQCAtMjM5MjMsNiArMjM5MjMsMTQgQEAKIAkJCQk+DQogCQkJ PC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cbG9hZGVyXFJlc291cmNl TG9hZFNjaGVkdWxlci5jcHAiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCisJCQkJ UmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcIFJlc291cmNlTG9hZFNjaGVkdWxlci5oIg0KKwkJCQk+ DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5cbG9hZGVyXFNp bmtEb2N1bWVudC5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpJbmRleDogV2ViQ29yZS9wYWdl L0V2ZW50U291cmNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRXZlbnRTb3VyY2Uu Y3BwCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvcGFnZS9FdmVudFNvdXJjZS5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTExNiw5ICsxMTYsNiBAQAogICAgIG1fbG9hZGVyID0gVGhyZWFkYWJs ZUxvYWRlcjo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgdGhpcywgcmVxdWVzdCwg b3B0aW9ucyk7CiAKICAgICBtX3JlcXVlc3RJbkZsaWdodCA9IHRydWU7Ci0KLSAgICBpZiAoIXNj cmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNXb3JrZXJDb250ZXh0KCkpCi0gICAgICAgIGNhY2hl KCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RJbkZsaWdodChtX3VybCk7CiB9CiAKIHZvaWQg RXZlbnRTb3VyY2U6OmVuZFJlcXVlc3QoKQpAQCAtMTI4LDkgKzEyNSw2IEBACiAgICAgaWYgKCFt X2ZhaWxTaWxlbnRseSkKICAgICAgICAgZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50 TmFtZXMoKS5lcnJvckV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKIAotICAgIGlmICghc2NyaXB0RXhl Y3V0aW9uQ29udGV4dCgpLT5pc1dvcmtlckNvbnRleHQoKSkKLSAgICAgICAgY2FjaGUoKS0+bG9h ZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1fdXJsKTsKLQogICAgIGlmIChtX3N0YXRl ICE9IENMT1NFRCkKICAgICAgICAgc2NoZWR1bGVSZWNvbm5lY3QoKTsKICAgICBlbHNlCkluZGV4 OiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvR05VbWFrZWZp bGUuYW0JKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQkod29ya2lu ZyBjb3B5KQpAQCAtMTk1Niw2ICsxOTU2LDggQEAKIAlXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxv YWRlci5oIFwKIAlXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWROb3RpZmllci5jcHAgXAogCVdl YkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZE5vdGlmaWVyLmggXAorCVdlYkNvcmUvbG9hZGVyL1Jl c291cmNlTG9hZFNjaGVkdWxlci5jcHAgXAorCVdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZFNj aGVkdWxlci5oIFwKIAlXZWJDb3JlL2xvYWRlci9TaW5rRG9jdW1lbnQuY3BwIFwKIAlXZWJDb3Jl L2xvYWRlci9TaW5rRG9jdW1lbnQuaCBcCiAJV2ViQ29yZS9sb2FkZXIvU3ViZnJhbWVMb2FkZXIu Y3BwIFwKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv V2ViQ29yZS5neXBpCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3 b3JraW5nIGNvcHkpCkBAIC0yMDcyLDYgKzIwNzIsOCBAQAogICAgICAgICAgICAgJ2xvYWRlci9S ZXNvdXJjZUxvYWRlci5oJywKICAgICAgICAgICAgICdsb2FkZXIvUmVzb3VyY2VMb2FkTm90aWZp ZXIuY3BwJywKICAgICAgICAgICAgICdsb2FkZXIvUmVzb3VyY2VMb2FkTm90aWZpZXIuaCcsCisg ICAgICAgICAgICAnbG9hZGVyL1Jlc291cmNlTG9hZFNjaGVkdWxlci5jcHAnLAorICAgICAgICAg ICAgJ2xvYWRlci9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCcsCiAgICAgICAgICAgICAnbG9hZGVy L1NpbmtEb2N1bWVudC5jcHAnLAogICAgICAgICAgICAgJ2xvYWRlci9TaW5rRG9jdW1lbnQuaCcs CiAgICAgICAgICAgICAnbG9hZGVyL1N1YmZyYW1lTG9hZGVyLmNwcCcsCkluZGV4OiBXZWJDb3Jl L0NNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ01ha2VMaXN0cy50eHQJKHJl dmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAkod29ya2luZyBjb3B5KQpA QCAtMTE1Miw2ICsxMTUyLDcgQEAKICAgICBsb2FkZXIvTmF2aWdhdGlvblNjaGVkdWxlci5jcHAK ICAgICBsb2FkZXIvUmVxdWVzdC5jcHAKICAgICBsb2FkZXIvUmVzb3VyY2VMb2FkTm90aWZpZXIu Y3BwCisgICAgbG9hZGVyL1Jlc291cmNlTG9hZFNjaGVkdWxlci5jcHAKICAgICBsb2FkZXIvUmVz b3VyY2VMb2FkZXIuY3BwCiAgICAgbG9hZGVyL1NpbmtEb2N1bWVudC5jcHAKICAgICBsb2FkZXIv U3ViZnJhbWVMb2FkZXIuY3BwCkluZGV4OiBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAtNTI3Nyw2ICs1Mjc3LDggQEAKIAkJ RDA4NkZFOTkwOUQ1M0FBQjAwNUJDNzREIC8qIFVubGlua0NvbW1hbmQuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDA4NkZFOTcwOUQ1M0FBQjAwNUJD NzREIC8qIFVubGlua0NvbW1hbmQuY3BwICovOyB9OwogCQlEMEIwNTU2ODA5QzY3MDAxMDAzMDdF NDMgLyogQ3JlYXRlTGlua0NvbW1hbmQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEQwQjA1NTY2MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29t bWFuZC5oICovOyB9OwogCQlEMEIwNTU2OTA5QzY3MDAxMDAzMDdFNDMgLyogQ3JlYXRlTGlua0Nv bW1hbmQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RDBCMDU1NjcwOUM2NzAwMTAwMzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmNwcCAqLzsgfTsK KwkJRDBDRTU4RjgxMjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMENFNThGNjEy NUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCAqLzsgfTsKKwkJRDBD RTU4RjkxMjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDBDRTU4RjcxMjVFNENDMjAw RjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJV VEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUQwRkYyQTVEMTFGOEM0NUEwMDdFNzRFMCAvKiBQ aW5nTG9hZGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEQwRkYyQTVCMTFGOEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVyLmNwcCAqLzsgfTsKIAkJ RDBGRjJBNUUxMUY4QzQ1QTAwN0U3NEUwIC8qIFBpbmdMb2FkZXIuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQwRkYyQTVDMTFGOEM0NUEwMDdFNzRFMCAv KiBQaW5nTG9hZGVyLmggKi87IH07CiAJCUQyM0NBNTVEMEFCMEVBQUUwMDUxMDhBNSAvKiBKU1Jh bmdlRXhjZXB0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBEMjNDQTU1QzBBQjBFQUFFMDA1MTA4QTUgLyogSlNSYW5nZUV4Y2VwdGlvbi5oICovOyB9 OwpAQCAtMTEyNzcsNiArMTEyNzksOCBAQAogCQlEMDg2RkU5NzA5RDUzQUFCMDA1QkM3NEQgLyog VW5saW5rQ29tbWFuZC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBV bmxpbmtDb21tYW5kLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDBCMDU1NjYw OUM2NzAwMTAwMzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IENyZWF0ZUxpbmtDb21tYW5kLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUQwQjA1NTY3MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFuZC5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBDcmVhdGVMaW5rQ29tbWFu ZC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUQwQ0U1OEY2MTI1RTRDQzIwMEYz RjE5OSAvKiBSZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJRDBDRTU4RjcxMjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNj aGVkdWxlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZXNvdXJjZUxvYWRT Y2hlZHVsZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDBGRjJBNUIxMUY4QzQ1 QTAwN0U3NEUwIC8qIFBpbmdMb2FkZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gUGluZ0xvYWRlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUQw RkYyQTVDMTFGOEM0NUEwMDdFNzRFMCAvKiBQaW5nTG9hZGVyLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IFBpbmdMb2FkZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJRDIzQ0E1NDgwQUIwRTk4MzAwNTEwOEE1IC8qIFJhbmdlRXhjZXB0aW9uLmlkbCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5 cGUgPSB0ZXh0OyBwYXRoID0gUmFuZ2VFeGNlcHRpb24uaWRsOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwpAQCAtMTcxNDIsNiArMTcxNDYsOCBAQAogCQkJCTY1NkQzNzI3MEFEQkE1REUwMEE0 NTU0RCAvKiBSZXNvdXJjZUxvYWRlci5oICovLAogCQkJCTk3M0UzMjU0MTA4ODNCN0MwMDVCQzQ5 MyAvKiBSZXNvdXJjZUxvYWROb3RpZmllci5jcHAgKi8sCiAJCQkJOTczRTMyNTUxMDg4M0I3QzAw NUJDNDkzIC8qIFJlc291cmNlTG9hZE5vdGlmaWVyLmggKi8sCisJCQkJRDBDRTU4RjYxMjVFNEND MjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5jcHAgKi8sCisJCQkJRDBDRTU4Rjcx MjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5oICovLAogCQkJCTUxMzI3 RDVGMTFBMzNBMkIwMDRGOUQ2NSAvKiBTaW5rRG9jdW1lbnQuY3BwICovLAogCQkJCTUxMzI3RDVF MTFBMzNBMkIwMDRGOUQ2NSAvKiBTaW5rRG9jdW1lbnQuaCAqLywKIAkJCQlEMDAwRUQyNTExQzFC OUNEMDBDNDc3MjYgLyogU3ViZnJhbWVMb2FkZXIuY3BwICovLApAQCAtMjEwOTEsNiArMjEwOTcs NyBAQAogCQkJCTg5MEFFMEUxMTI1NkEwNzkwMEY1OTY4QyAvKiBEaXJlY3RvcnlSZWFkZXJCYXNl LmggaW4gSGVhZGVycyAqLywKIAkJCQk4MkFCMTc3NDEyNUM4MjY3MDBDNTA2OUQgLyogSW5zcGVj dG9yU3R5bGVTaGVldC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJODJBQjE3NzYxMjVDODI2NzAwQzUw NjlEIC8qIEluc3BlY3RvclV0aWxpdGllcy5oIGluIEhlYWRlcnMgKi8sCisJCQkJRDBDRTU4Rjkx MjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxlci5oIGluIEhlYWRlcnMgKi8s CiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07 CkBAIC0yMzY0MCw2ICsyMzY0Nyw3IEBACiAJCQkJODkzQzQ4NTMxMjQ5OUIwNjAwMkIzRDg2IC8q IEpTRW50cnlTeW5jQ3VzdG9tLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTgyQUIxNzczMTI1Qzgy NjcwMEM1MDY5RCAvKiBJbnNwZWN0b3JTdHlsZVNoZWV0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJ CTgyQUIxNzc1MTI1QzgyNjcwMEM1MDY5RCAvKiBJbnNwZWN0b3JVdGlsaXRpZXMuY3BwIGluIFNv dXJjZXMgKi8sCisJCQkJRDBDRTU4RjgxMjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNj aGVkdWxlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVu dFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKSW5kZXg6IFdlYkNvcmUvQW5kcm9pZC5tawo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL0FuZHJvaWQubWsJKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29y ZS9BbmRyb2lkLm1rCSh3b3JraW5nIGNvcHkpCkBAIC0zNjgsNiArMzY4LDcgQEAKIAlsb2FkZXIv TmF2aWdhdGlvblNjaGVkdWxlci5jcHAgXAogCWxvYWRlci9SZXF1ZXN0LmNwcCBcCiAJbG9hZGVy L1Jlc291cmNlTG9hZE5vdGlmaWVyLmNwcCBcCisJbG9hZGVyL1Jlc291cmNlTG9hZFNjaGVkdWxl ci5jcHAgXAogCWxvYWRlci9SZXNvdXJjZUxvYWRlci5jcHAgXAogCWxvYWRlci9TdWJmcmFtZUxv YWRlci5jcHAgXAogCWxvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5jcHAgXApJbmRleDogV2ViQ29y ZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUveG1sL1hNTEh0 dHBSZXF1ZXN0LmNwcAkocmV2aXNpb24gNjkzMTMpCisrKyBXZWJDb3JlL3htbC9YTUxIdHRwUmVx dWVzdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE3OSw3ICsxNzksNiBAQAogICAgICwgbV91cGxv YWRFdmVudHNBbGxvd2VkKHRydWUpCiAgICAgLCBtX3VwbG9hZENvbXBsZXRlKGZhbHNlKQogICAg ICwgbV9zYW1lT3JpZ2luUmVxdWVzdCh0cnVlKQotICAgICwgbV9kaWRUZWxsTG9hZGVyQWJvdXRS ZXF1ZXN0KGZhbHNlKQogICAgICwgbV9yZWNlaXZlZExlbmd0aCgwKQogICAgICwgbV9sYXN0U2Vu ZExpbmVOdW1iZXIoMCkKICAgICAsIG1fZXhjZXB0aW9uQ29kZSgwKQpAQCAtMTkzLDEwICsxOTIs NiBAQAogCiBYTUxIdHRwUmVxdWVzdDo6flhNTEh0dHBSZXF1ZXN0KCkKIHsKLSAgICBpZiAobV9k aWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0KSB7Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5u b25DYWNoZVJlcXVlc3RDb21wbGV0ZShtX3VybCk7Ci0gICAgICAgIG1fZGlkVGVsbExvYWRlckFi b3V0UmVxdWVzdCA9IGZhbHNlOwotICAgIH0KICAgICBpZiAobV91cGxvYWQpCiAgICAgICAgIG1f dXBsb2FkLT5kaXNjb25uZWN0WE1MSHR0cFJlcXVlc3QoKTsKIApAQCAtNTk5LDE2ICs1OTQsNiBA QAogICAgICAgICAgICAgLy8gYSByZXF1ZXN0IGlzIGluIHByb2dyZXNzIGJlY2F1c2Ugd2UgbmVl ZCB0byBrZWVwIHRoZSBsaXN0ZW5lcnMgYWxpdmUsCiAgICAgICAgICAgICAvLyBhbmQgdGhleSBh cmUgcmVmZXJlbmNlZCBieSB0aGUgSmF2YVNjcmlwdCB3cmFwcGVyLgogICAgICAgICAgICAgc2V0 UGVuZGluZ0FjdGl2aXR5KHRoaXMpOwotCi0gICAgICAgICAgICAvLyBGb3Igbm93IHdlIHNob3Vs ZCBvbmx5IGJhbGFuY2UgdGhlIG5vbkNhY2hlZCByZXF1ZXN0IGNvdW50IGZvciBtYWluLXRocmVh ZCBYSFJzIGFuZCBub3QKLSAgICAgICAgICAgIC8vIFdvcmtlciBYSFJzLCBhcyB0aGUgQ2FjaGUg aXMgbm90IHRocmVhZC1zYWZlLgotICAgICAgICAgICAgLy8gVGhpcyB3aWxsIGJlY29tZSBpcnJl bGV2YW50IGFmdGVyIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzE2 NSBpcyByZXNvbHZlZC4KLSAgICAgICAgICAgIGlmICghc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgp LT5pc1dvcmtlckNvbnRleHQoKSkgewotICAgICAgICAgICAgICAgIEFTU0VSVChpc01haW5UaHJl YWQoKSk7Ci0gICAgICAgICAgICAgICAgQVNTRVJUKCFtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVl c3QpOwotICAgICAgICAgICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RJ bkZsaWdodChtX3VybCk7Ci0gICAgICAgICAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1 ZXN0ID0gdHJ1ZTsKLSAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0gZWxzZQogICAgICAg ICBUaHJlYWRhYmxlTG9hZGVyOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQoKSwgcmVxdWVzdCwgKnRoaXMsIG9wdGlvbnMpOwpAQCAtOTAwLDEwICs4ODUs NiBAQAogCiB2b2lkIFhNTEh0dHBSZXF1ZXN0OjpkaWRGYWlsKGNvbnN0IFJlc291cmNlRXJyb3Im IGVycm9yKQogewotICAgIGlmIChtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QpIHsKLSAgICAg ICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1fdXJsKTsKLSAg ICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gZmFsc2U7Ci0gICAgfQogCiAgICAg Ly8gSWYgd2UgYXJlIGFscmVhZHkgaW4gYW4gZXJyb3Igc3RhdGUsIGZvciBpbnN0YW5jZSB3ZSBj YWxsZWQgYWJvcnQoKSwgYmFpbCBvdXQgZWFybHkuCiAgICAgaWYgKG1fZXJyb3IpCkBAIC05MzAs MTEgKzkxMSw2IEBACiAKIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OmRpZEZpbmlzaExvYWRpbmcodW5z aWduZWQgbG9uZyBpZGVudGlmaWVyKQogewotICAgIGlmIChtX2RpZFRlbGxMb2FkZXJBYm91dFJl cXVlc3QpIHsKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBs ZXRlKG1fdXJsKTsKLSAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gZmFsc2U7 Ci0gICAgfQotCiAgICAgaWYgKG1fZXJyb3IpCiAgICAgICAgIHJldHVybjsKIApJbmRleDogV2Vi Q29yZS94bWwvWE1MSHR0cFJlcXVlc3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3htbC9YTUxI dHRwUmVxdWVzdC5oCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUveG1sL1hNTEh0dHBSZXF1 ZXN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE5Miw3ICsxOTIsNiBAQAogICAgIGJvb2wgbV91cGxv YWRDb21wbGV0ZTsKIAogICAgIGJvb2wgbV9zYW1lT3JpZ2luUmVxdWVzdDsKLSAgICBib29sIG1f ZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdDsKIAogICAgIC8vIFVzZWQgZm9yIG9ucHJvZ3Jlc3Mg dHJhY2tpbmcKICAgICBsb25nIGxvbmcgbV9yZWNlaXZlZExlbmd0aDsKSW5kZXg6IFdlYkNvcmUv bG9hZGVyL2xvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCShy ZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCSh3b3JraW5nIGNvcHkp CkBAIC0yMyw5NCArMjMsMzUgQEAKICNkZWZpbmUgbG9hZGVyX2gKIAogI2luY2x1ZGUgIkZyYW1l TG9hZGVyVHlwZXMuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlN1 YnJlc291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSAiU3VicmVzb3VyY2VMb2FkZXJDbGllbnQuaCIK LSNpbmNsdWRlICJUaW1lci5oIgotI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0 Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5jbHVkZSA8d3Rm L3RleHQvQXRvbWljU3RyaW5nLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQXRvbWljU3RyaW5nSW1w bC5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAg ICAgY2xhc3MgQ2FjaGVkUmVzb3VyY2U7CiAgICAgY2xhc3MgQ2FjaGVkUmVzb3VyY2VMb2FkZXI7 Ci0gICAgY2xhc3MgS1VSTDsKICAgICBjbGFzcyBSZXF1ZXN0OwogCi0gICAgY2xhc3MgTG9hZGVy IDogcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBjbGFzcyBMb2FkZXIgOiBwdWJsaWMgTm9uY29w eWFibGUsIHByaXZhdGUgU3VicmVzb3VyY2VMb2FkZXJDbGllbnQgewogICAgIHB1YmxpYzoKLSAg ICAgICAgTG9hZGVyKCk7CiAgICAgICAgIH5Mb2FkZXIoKTsKIAogICAgICAgICB2b2lkIGxvYWQo Q2FjaGVkUmVzb3VyY2VMb2FkZXIqLCBDYWNoZWRSZXNvdXJjZSosIGJvb2wgaW5jcmVtZW50YWwg PSB0cnVlLCBTZWN1cml0eUNoZWNrUG9saWN5ID0gRG9TZWN1cml0eUNoZWNrLCBib29sIHNlbmRS ZXNvdXJjZUxvYWRDYWxsYmFja3MgPSB0cnVlKTsKLQogICAgICAgICB2b2lkIGNhbmNlbFJlcXVl c3RzKENhY2hlZFJlc291cmNlTG9hZGVyKik7Ci0gICAgICAgIAotICAgICAgICBlbnVtIFByaW9y aXR5IHsgVmVyeUxvdywgTG93LCBNZWRpdW0sIEhpZ2ggfTsKLSAgICAgICAgdm9pZCBzZXJ2ZVBl bmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93KTsKIAotICAg ICAgICBib29sIGlzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cygpIHsgcmV0dXJuIG1faXNTdXNw ZW5kaW5nUGVuZGluZ1JlcXVlc3RzOyB9Ci0gICAgICAgIHZvaWQgc3VzcGVuZFBlbmRpbmdSZXF1 ZXN0cygpOwotICAgICAgICB2b2lkIHJlc3VtZVBlbmRpbmdSZXF1ZXN0cygpOwotICAgICAgICAK LSAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RJbkZsaWdodChjb25zdCBLVVJMJik7Ci0gICAg ICAgIHZvaWQgbm9uQ2FjaGVSZXF1ZXN0Q29tcGxldGUoY29uc3QgS1VSTCYpOwotCiAgICAgcHJp dmF0ZToKLSAgICAgICAgUHJpb3JpdHkgZGV0ZXJtaW5lUHJpb3JpdHkoY29uc3QgQ2FjaGVkUmVz b3VyY2UqKSBjb25zdDsKLSAgICAgICAgdm9pZCBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3Rz KCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlUmVzcG9uc2UoU3VicmVzb3VyY2VM b2FkZXIqLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWRSZWNlaXZlRGF0YShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IGNoYXIqLCBpbnQpOworICAg ICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNlTG9h ZGVyKiwgY29uc3QgY2hhciosIGludCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGaW5pc2hM b2FkaW5nKFN1YnJlc291cmNlTG9hZGVyKik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGYWls KFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VFcnJvciYpOworICAgICAgICB2b2lk IGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBib29sIGNhbmNlbGxlZCA9IGZhbHNlKTsKICAg ICAgICAgCi0gICAgICAgIHZvaWQgcmVxdWVzdFRpbWVyRmlyZWQoVGltZXI8TG9hZGVyPiopOwot Ci0gICAgICAgIGNsYXNzIEhvc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxIb3N0PiwgcHJpdmF0ZSBT dWJyZXNvdXJjZUxvYWRlckNsaWVudCB7Ci0gICAgICAgIHB1YmxpYzoKLSAgICAgICAgICAgIHN0 YXRpYyBQYXNzUmVmUHRyPEhvc3Q+IGNyZWF0ZShjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIHVu c2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHQpIAotICAgICAgICAgICAgewotICAgICAgICAgICAg ICAgIHJldHVybiBhZG9wdFJlZihuZXcgSG9zdChuYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0KSk7 Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICB+SG9zdCgpOwotICAgICAgICAgICAgCi0gICAg ICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUoKSBjb25zdCB7IHJldHVybiBtX25hbWU7 IH0KLSAgICAgICAgICAgIHZvaWQgYWRkUmVxdWVzdChSZXF1ZXN0KiwgUHJpb3JpdHkpOwotICAg ICAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpOwotICAgICAgICAgICAgdm9p ZCBub25DYWNoZVJlcXVlc3RDb21wbGV0ZSgpOwotICAgICAgICAgICAgdm9pZCBzZXJ2ZVBlbmRp bmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93KTsKLSAgICAgICAg ICAgIHZvaWQgY2FuY2VsUmVxdWVzdHMoQ2FjaGVkUmVzb3VyY2VMb2FkZXIqKTsKLSAgICAgICAg ICAgIGJvb2wgaGFzUmVxdWVzdHMoKSBjb25zdDsKLQotICAgICAgICAgICAgYm9vbCBwcm9jZXNz aW5nUmVzb3VyY2UoKSBjb25zdCB7IHJldHVybiBtX251bVJlc291cmNlc1Byb2Nlc3NpbmcgIT0g MCB8fCBtX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQgIT0wOyB9Ci0KLSAgICAgICAgcHJpdmF0 ZToKLSAgICAgICAgICAgIEhvc3QoY29uc3QgQXRvbWljU3RyaW5nJiwgdW5zaWduZWQpOwotCi0g ICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKFN1YnJlc291cmNlTG9h ZGVyKiwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpOwotICAgICAgICAgICAgdmlydHVhbCB2b2lk IGRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7Ci0g ICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291 cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7Ci0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQg ZGlkRmluaXNoTG9hZGluZyhTdWJyZXNvdXJjZUxvYWRlciopOwotICAgICAgICAgICAgdmlydHVh bCB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJik7 Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIHR5cGVkZWYgRGVxdWU8UmVxdWVzdCo+IFJlcXVl c3RRdWV1ZTsKLSAgICAgICAgICAgIHZvaWQgc2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1 ZXVlJiByZXF1ZXN0c1BlbmRpbmcsIGJvb2wmIHNlcnZlTG93ZXJQcmlvcml0eSk7Ci0gICAgICAg ICAgICB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBib29sIGNhbmNlbGxlZCA9IGZh bHNlKTsKLSAgICAgICAgICAgIHZvaWQgY2FuY2VsUGVuZGluZ1JlcXVlc3RzKFJlcXVlc3RRdWV1 ZSYgcmVxdWVzdHNQZW5kaW5nLCBDYWNoZWRSZXNvdXJjZUxvYWRlciopOwotICAgICAgICAgICAg Ci0gICAgICAgICAgICBSZXF1ZXN0UXVldWUgbV9yZXF1ZXN0c1BlbmRpbmdbSGlnaCArIDFdOwot ICAgICAgICAgICAgdHlwZWRlZiBIYXNoTWFwPFJlZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4sIFJl cXVlc3QqPiBSZXF1ZXN0TWFwOwotICAgICAgICAgICAgUmVxdWVzdE1hcCBtX3JlcXVlc3RzTG9h ZGluZzsKLSAgICAgICAgICAgIGNvbnN0IEF0b21pY1N0cmluZyBtX25hbWU7Ci0gICAgICAgICAg ICBjb25zdCBpbnQgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0OwotICAgICAgICAgICAgaW50IG1fbnVt UmVzb3VyY2VzUHJvY2Vzc2luZzsKLSAgICAgICAgICAgIGludCBtX25vbkNhY2hlZFJlcXVlc3Rz SW5GbGlnaHQ7Ci0gICAgICAgIH07Ci0gICAgICAgIHR5cGVkZWYgSGFzaE1hcDxBdG9taWNTdHJp bmdJbXBsKiwgUmVmUHRyPEhvc3Q+ID4gSG9zdE1hcDsKLSAgICAgICAgSG9zdE1hcCBtX2hvc3Rz OwotICAgICAgICBSZWZQdHI8SG9zdD4gbV9ub25IVFRQUHJvdG9jb2xIb3N0OwotICAgICAgICAK LSAgICAgICAgVGltZXI8TG9hZGVyPiBtX3JlcXVlc3RUaW1lcjsKLQotICAgICAgICBib29sIG1f aXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzOworICAgICAgICB0eXBlZGVmIEhhc2hNYXA8UmVm UHRyPFN1YnJlc291cmNlTG9hZGVyPiwgUmVxdWVzdCo+IFJlcXVlc3RNYXA7CisgICAgICAgIFJl cXVlc3RNYXAgbV9yZXF1ZXN0c0xvYWRpbmc7CiAgICAgfTsKIAogfQpJbmRleDogV2ViQ29yZS9s b2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xv YWRlci9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9s b2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwy NzYgQEAKKy8qCisgICAgQ29weXJpZ2h0IChDKSAxOTk4IExhcnMgS25vbGwgKGtub2xsQG1waS1o ZC5tcGcuZGUpCisgICAgQ29weXJpZ2h0IChDKSAyMDAxIERpcmsgTXVlbGxlciAobXVlbGxlckBr ZGUub3JnKQorICAgIENvcHlyaWdodCAoQykgMjAwMiBXYWxkbyBCYXN0aWFuIChiYXN0aWFuQGtk ZS5vcmcpCisgICAgQ29weXJpZ2h0IChDKSAyMDA2IFNhbXVlbCBXZWluaWcgKHNhbS53ZWluaWdA Z21haWwuY29tKQorICAgIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiwgMjAwNywgMjAw OCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgICAgQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisKKyAgICBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAg ICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIKKyAgICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V CisgICAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisK KyAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0 aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICAgIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKKworI2luY2x1ZGUgIkRvY3Vt ZW50LmgiCisjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2lu Y2x1ZGUgIkluc3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgorI2luY2x1ZGUgIktVUkwuaCIKKyNp bmNsdWRlICJSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdEJhc2Uu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBIYXZpbmcgYSBsaW1pdCBtaWdodCBzdGls bCBoZWxwIGdldHRpbmcgbW9yZSBpbXBvcnRhbnQgcmVzb3VyY2VzIGZpcnN0CitzdGF0aWMgY29u c3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAyMDsK K3N0YXRpYyB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdDsKKworUmVzb3VyY2VM b2FkU2NoZWR1bGVyOjpQcmlvcml0eSBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmRldGVybWluZVBy aW9yaXR5KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkgY29uc3QKK3sKKyAgICBzd2l0 Y2ggKHJlcXVlc3QudGFyZ2V0VHlwZSgpKSB7CisgICAgY2FzZSBSZXNvdXJjZVJlcXVlc3Q6OlRh cmdldElzTWFpbkZyYW1lOgorICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N1YmZy YW1lOgorICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N0eWxlU2hlZXQ6CisgICAg ICAgIHJldHVybiBIaWdoOworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1Njcmlw dDogCisgICAgY2FzZSBSZXNvdXJjZVJlcXVlc3Q6OlRhcmdldElzRm9udFJlc291cmNlOgorICAg ICAgICByZXR1cm4gTWVkaXVtOworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N1 YnJlc291cmNlOgorICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc0ltYWdlOgorICAg IGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc09iamVjdDoKKyAgICBjYXNlIFJlc291cmNl UmVxdWVzdDo6VGFyZ2V0SXNNZWRpYToKKyAgICBjYXNlIFJlc291cmNlUmVxdWVzdDo6VGFyZ2V0 SXNXb3JrZXI6CisgICAgY2FzZSBSZXNvdXJjZVJlcXVlc3Q6OlRhcmdldElzU2hhcmVkV29ya2Vy OgorICAgICAgICByZXR1cm4gTG93OworICAgIGNhc2UgUmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJ c1ByZWZldGNoOgorICAgICAgICByZXR1cm4gVmVyeUxvdzsKKyAgICB9CisgICAgQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIExvdzsKK30KKworUmVzb3VyY2VMb2FkU2NoZWR1bGVy OjpIb3N0SW5mb3JtYXRpb24qIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6aG9zdEZvclVSTChjb25z dCBLVVJMJiB1cmwsIGJvb2wgY3JlYXRlSWZOb3RGb3VuZCkKK3sKKyAgICBpZiAoIXVybC5wcm90 b2NvbEluSFRUUEZhbWlseSgpKQorICAgICAgICByZXR1cm4gbV9ub25IVFRQUHJvdG9jb2xIb3N0 LmdldCgpOworCisgICAgUmVmUHRyPEhvc3RJbmZvcm1hdGlvbj4gaG9zdDsKKyAgICBtX2hvc3Rz LmNoZWNrQ29uc2lzdGVuY3koKTsKKyAgICBTdHJpbmcgaG9zdE5hbWUgPSB1cmwuaG9zdCgpOwor ICAgIGhvc3QgPSBtX2hvc3RzLmdldChob3N0TmFtZSk7CisgICAgaWYgKCFob3N0ICYmIGNyZWF0 ZUlmTm90Rm91bmQpIHsKKyAgICAgICAgaG9zdCA9IEhvc3RJbmZvcm1hdGlvbjo6Y3JlYXRlKGhv c3ROYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCk7CisgICAgICAgIG1faG9zdHMuYWRk KGhvc3ROYW1lLCBob3N0KTsKKyAgICB9CisgICAgcmV0dXJuIGhvc3QuZ2V0KCk7Cit9CisKK1Jl c291cmNlTG9hZFNjaGVkdWxlciogcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKK3sKKyAgICBERUZJ TkVfU1RBVElDX0xPQ0FMKFJlc291cmNlTG9hZFNjaGVkdWxlciwgcmVzb3VyY2VMb2FkU2NoZWR1 bGVyLCAoKSk7CisgICAgcmV0dXJuICZyZXNvdXJjZUxvYWRTY2hlZHVsZXI7Cit9CisKK1Jlc291 cmNlTG9hZFNjaGVkdWxlcjo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKKyAgICA6IG1fcmVxdWVz dFRpbWVyKHRoaXMsICZSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnJlcXVlc3RUaW1lckZpcmVkKQor ICAgICwgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMoZmFsc2UpCit7CisgICAgbV9ub25I VFRQUHJvdG9jb2xIb3N0ID0gSG9zdEluZm9ybWF0aW9uOjpjcmVhdGUoU3RyaW5nKCksIG1heFJl cXVlc3RzSW5GbGlnaHRGb3JOb25IVFRQUHJvdG9jb2xzKTsKKyAgICBtYXhSZXF1ZXN0c0luRmxp Z2h0UGVySG9zdCA9IGluaXRpYWxpemVNYXhpbXVtSFRUUENvbm5lY3Rpb25Db3VudFBlckhvc3Qo KTsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmFkZChSZXNvdXJjZUxvYWRlciog cmVzb3VyY2VMb2FkZXIsIFNjaGVkdWxlUG9saWN5IHNjaGVkdWxlUG9saWN5KQoreworICAgIEFT U0VSVChyZXNvdXJjZUxvYWRlcik7CisKKyAgICBLVVJMIHVybChQYXJzZWRVUkxTdHJpbmcsIHJl c291cmNlTG9hZGVyLT5yZXF1ZXN0KCkudXJsKCkpOworICAgIEhvc3RJbmZvcm1hdGlvbiogaG9z dCA9IGhvc3RGb3JVUkwodXJsLCB0cnVlKTsgICAgCisgICAgYm9vbCBoYWRSZXF1ZXN0cyA9IGhv c3QtPmhhc1JlcXVlc3RzKCk7CisgICAgUHJpb3JpdHkgcHJpb3JpdHkgPSBkZXRlcm1pbmVQcmlv cml0eShyZXNvdXJjZUxvYWRlci0+cmVxdWVzdCgpKTsKKyAgICBob3N0LT5hZGQocmVzb3VyY2VM b2FkZXIsIHNjaGVkdWxlUG9saWN5LCBwcmlvcml0eSk7CisgICAgCisgICAgaWYgKHNjaGVkdWxl UG9saWN5ID09IEFscmVhZHlMb2FkaW5nKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAocHJp b3JpdHkgPiBMb3cgfHwgIXVybC5wcm90b2NvbEluSFRUUEZhbWlseSgpIHx8IChwcmlvcml0eSA9 PSBMb3cgJiYgIWhhZFJlcXVlc3RzKSkgeworICAgICAgICAvLyBUcnkgdG8gcmVxdWVzdCBpbXBv cnRhbnQgcmVzb3VyY2VzIGltbWVkaWF0ZWx5CisgICAgICAgIHNlcnZlUGVuZGluZ1JlcXVlc3Rz KGhvc3QsIHByaW9yaXR5KTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBIYW5kbGUgYXN5bmNo cm9ub3VzbHkgc28gZWFybHkgbG93IHByaW9yaXR5IHJlcXVlc3RzIGRvbid0IGdldCBzY2hlZHVs ZWQgYmVmb3JlIGxhdGVyIGhpZ2ggcHJpb3JpdHkgb25lcworICAgICAgICBJbnNwZWN0b3JJbnN0 cnVtZW50YXRpb246OmRpZFNjaGVkdWxlUmVzb3VyY2VSZXF1ZXN0KHJlc291cmNlTG9hZGVyLT5m cmFtZUxvYWRlcigpID8gcmVzb3VyY2VMb2FkZXItPmZyYW1lTG9hZGVyKCktPmZyYW1lKCktPmRv Y3VtZW50KCkgOiAwLCByZXNvdXJjZUxvYWRlci0+cmVxdWVzdCgpLnVybCgpKTsKKyAgICAgICAg c2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOworICAgIH0KK30KKwordm9pZCBSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6OnJlbW92ZShSZXNvdXJjZUxvYWRlciogcmVzb3VyY2VMb2FkZXIpCit7 CisgICAgQVNTRVJUKHJlc291cmNlTG9hZGVyKTsKKworICAgIEhvc3RJbmZvcm1hdGlvbiogaG9z dCA9IGhvc3RGb3JVUkwocmVzb3VyY2VMb2FkZXItPnJlcXVlc3QoKS51cmwoKSk7CisgICAgaWYg KGhvc3QpCisgICAgICAgIGhvc3QtPnJlbW92ZShyZXNvdXJjZUxvYWRlciwgZGV0ZXJtaW5lUHJp b3JpdHkocmVzb3VyY2VMb2FkZXItPnJlcXVlc3QoKSkpOworICAgIHNjaGVkdWxlU2VydmVQZW5k aW5nUmVxdWVzdHMoKTsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmNoYW5nZUhv c3QoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QpCit7CisgICAgSG9zdEluZm9ybWF0aW9uKiBvbGRIb3N0ID0gaG9zdEZvclVSTChy ZXNvdXJjZUxvYWRlci0+cmVxdWVzdCgpLnVybCgpKTsKKyAgICBBU1NFUlQob2xkSG9zdCk7Cisg ICAgSG9zdEluZm9ybWF0aW9uKiBuZXdIb3N0ID0gaG9zdEZvclVSTChyZXF1ZXN0LnVybCgpLCB0 cnVlKTsKKworICAgIGlmIChvbGRIb3N0ID09IG5ld0hvc3QpCisgICAgICAgIHJldHVybjsKKwor ICAgIG9sZEhvc3QtPnJlbW92ZShyZXNvdXJjZUxvYWRlciwgZGV0ZXJtaW5lUHJpb3JpdHkocmVz b3VyY2VMb2FkZXItPnJlcXVlc3QoKSkpOworICAgIG5ld0hvc3QtPmFkZChyZXNvdXJjZUxvYWRl ciwgQWxyZWFkeUxvYWRpbmcpOworfQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6c2Vy dmVQZW5kaW5nUmVxdWVzdHMoUHJpb3JpdHkgbWluaW11bVByaW9yaXR5KQoreworICAgIGlmICht X2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cykKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9y ZXF1ZXN0VGltZXIuc3RvcCgpOworICAgIAorICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKG1fbm9u SFRUUFByb3RvY29sSG9zdC5nZXQoKSwgbWluaW11bVByaW9yaXR5KTsKKworICAgIFZlY3RvcjxI b3N0SW5mb3JtYXRpb24qPiBob3N0c1RvU2VydmU7CisgICAgbV9ob3N0cy5jaGVja0NvbnNpc3Rl bmN5KCk7CisgICAgSG9zdE1hcDo6aXRlcmF0b3IgaSA9IG1faG9zdHMuYmVnaW4oKTsKKyAgICBI b3N0TWFwOjppdGVyYXRvciBlbmQgPSBtX2hvc3RzLmVuZCgpOworICAgIGZvciAoO2kgIT0gZW5k OyArK2kpCisgICAgICAgIGhvc3RzVG9TZXJ2ZS5hcHBlbmQoaS0+c2Vjb25kLmdldCgpKTsKKyAg ICAgICAgCisgICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IGhvc3RzVG9TZXJ2ZS5zaXplKCk7 ICsrbikgeworICAgICAgICBIb3N0SW5mb3JtYXRpb24qIGhvc3QgPSBob3N0c1RvU2VydmVbbl07 CisgICAgICAgIGlmIChob3N0LT5oYXNSZXF1ZXN0cygpKQorICAgICAgICAgICAgc2VydmVQZW5k aW5nUmVxdWVzdHMoaG9zdCwgbWluaW11bVByaW9yaXR5KTsKKyAgICAgICAgZWxzZQorICAgICAg ICAgICAgbV9ob3N0cy5yZW1vdmUoaG9zdC0+bmFtZSgpKTsKKyAgICB9Cit9CisKK3ZvaWQgUmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhIb3N0SW5mb3JtYXRpb24q IGhvc3QsIFByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSkKK3sKKyAgICBmb3IgKGludCBwcmlvcml0 eSA9IEhpZ2g7IHByaW9yaXR5ID49IG1pbmltdW1Qcmlvcml0eTsgLS1wcmlvcml0eSkgeworICAg ICAgICBIb3N0SW5mb3JtYXRpb246OlJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nID0gaG9z dC0+cmVxdWVzdHNQZW5kaW5nKChQcmlvcml0eSkgcHJpb3JpdHkpOworICAgICAgICAKKyAgICAg ICAgd2hpbGUgKCFyZXF1ZXN0c1BlbmRpbmcuaXNFbXB0eSgpKSB7CisgICAgICAgICAgICBSZWZQ dHI8UmVzb3VyY2VMb2FkZXI+IHJlc291cmNlTG9hZGVyID0gcmVxdWVzdHNQZW5kaW5nLmZpcnN0 KCk7CisKKyAgICAgICAgICAgIC8vIEZvciBuYW1lZCBob3N0cyAtIHdoaWNoIGFyZSBvbmx5IGh0 dHAocykgaG9zdHMgLSB3ZSBzaG91bGQgYWx3YXlzIGVuZm9yY2UgdGhlIGNvbm5lY3Rpb24gbGlt aXQuCisgICAgICAgICAgICAvLyBGb3Igbm9uLW5hbWVkIGhvc3RzIC0gZXZlcnl0aGluZyBidXQg aHR0cChzKSAtIHdlIHNob3VsZCBvbmx5IGVuZm9yY2UgdGhlIGxpbWl0IGlmIHRoZSBkb2N1bWVu dCBpc24ndCBkb25lIHBhcnNpbmcgCisgICAgICAgICAgICAvLyBhbmQgd2UgZG9uJ3Qga25vdyBh bGwgc3R5bGVzaGVldHMgeWV0LgorICAgICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gcmVz b3VyY2VMb2FkZXItPmZyYW1lTG9hZGVyKCkgPyByZXNvdXJjZUxvYWRlci0+ZnJhbWVMb2FkZXIo KS0+ZnJhbWUoKS0+ZG9jdW1lbnQoKSA6IDA7CisgICAgICAgICAgICBib29sIHNob3VsZExpbWl0 UmVxdWVzdHMgPSAhaG9zdC0+bmFtZSgpLmlzTnVsbCgpIHx8IChkb2N1bWVudCAmJiAoZG9jdW1l bnQtPnBhcnNpbmcoKSB8fCAhZG9jdW1lbnQtPmhhdmVTdHlsZXNoZWV0c0xvYWRlZCgpKSk7Cisg ICAgICAgICAgICBpZiAoc2hvdWxkTGltaXRSZXF1ZXN0cyAmJiBob3N0LT5saW1pdFJlcXVlc3Rz KCkpCisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgaG9zdC0+YWRkKHJlc291 cmNlTG9hZGVyLmdldCgpLCBBbHJlYWR5TG9hZGluZyk7CisgICAgICAgICAgICByZXF1ZXN0c1Bl bmRpbmcucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAgICAgIHJlc291cmNlTG9hZGVyLT5zdGFydCgp OworICAgICAgICB9CisgICAgfQorfQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6c3Vz cGVuZFBlbmRpbmdSZXF1ZXN0cygpCit7CisgICAgQVNTRVJUKCFtX2lzU3VzcGVuZGluZ1BlbmRp bmdSZXF1ZXN0cyk7CisgICAgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMgPSB0cnVlOwor fQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6cmVzdW1lUGVuZGluZ1JlcXVlc3RzKCkK K3sKKyAgICBBU1NFUlQobV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMpOworICAgIG1faXNT dXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzID0gZmFsc2U7CisgICAgaWYgKCFtX2hvc3RzLmlzRW1w dHkoKSB8fCBtX25vbkhUVFBQcm90b2NvbEhvc3QtPmhhc1JlcXVlc3RzKCkpCisgICAgICAgIHNj aGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKK30KKyAgICAKK3ZvaWQgUmVzb3VyY2VMb2Fk U2NoZWR1bGVyOjpzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCkKK3sKKyAgICBpZiAoIW1f cmVxdWVzdFRpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fcmVxdWVzdFRpbWVyLnN0YXJ0T25l U2hvdCgwKTsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnJlcXVlc3RUaW1lckZp cmVkKFRpbWVyPFJlc291cmNlTG9hZFNjaGVkdWxlcj4qKSAKK3sKKyAgICBzZXJ2ZVBlbmRpbmdS ZXF1ZXN0cygpOworfQorCisjaWZuZGVmIE5ERUJVRwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVs ZXI6OmFzc2VydExvYWRlckJlaW5nQ291bnRlZChSZXNvdXJjZUxvYWRlciogcmVzb3VyY2VMb2Fk ZXIpCit7CisgICAgSG9zdEluZm9ybWF0aW9uKiBob3N0ID0gaG9zdEZvclVSTChyZXNvdXJjZUxv YWRlci0+cmVxdWVzdCgpLnVybCgpKTsKKyAgICBBU1NFUlQoaG9zdCk7CisgICAgaG9zdC0+YXNz ZXJ0TG9hZGVyQmVpbmdDb3VudGVkKHJlc291cmNlTG9hZGVyKTsKK30KKwordm9pZCBSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6YXNzZXJ0TG9hZGVyQmVpbmdDb3VudGVk KFJlc291cmNlTG9hZGVyKiByZXNvdXJjZUxvYWRlcikKK3sKKyAgICBBU1NFUlQobV9yZXF1ZXN0 c0xvYWRpbmcuY29udGFpbnMocmVzb3VyY2VMb2FkZXIpKTsKK30KKyNlbmRpZgorCitSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6SG9zdEluZm9ybWF0aW9uKGNvbnN0IFN0 cmluZyYgbmFtZSwgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodCkKKyAgICA6IG1fbmFtZShu YW1lKQorICAgICwgbV9tYXhSZXF1ZXN0c0luRmxpZ2h0KG1heFJlcXVlc3RzSW5GbGlnaHQpCit7 Cit9CisKK1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjp+SG9zdEluZm9y bWF0aW9uKCkKK3sKKyAgICBBU1NFUlQobV9yZXF1ZXN0c0xvYWRpbmcuaXNFbXB0eSgpKTsKKyAg ICBmb3IgKHVuc2lnbmVkIHAgPSAwOyBwIDw9IEhpZ2g7IHArKykKKyAgICAgICAgQVNTRVJUKG1f cmVxdWVzdHNQZW5kaW5nW3BdLmlzRW1wdHkoKSk7Cit9CisgICAgCit2b2lkIFJlc291cmNlTG9h ZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjphZGQoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNl TG9hZGVyLCBTY2hlZHVsZVBvbGljeSBzY2hlZHVsZVBvbGljeSwgUHJpb3JpdHkgcHJpb3JpdHkp Cit7CisgICAgaWYgKHNjaGVkdWxlUG9saWN5ID09IFNjaGVkdWxlKQorICAgICAgICBtX3JlcXVl c3RzUGVuZGluZ1twcmlvcml0eV0uYXBwZW5kKHJlc291cmNlTG9hZGVyKTsKKyAgICBlbHNlCisg ICAgICAgIG1fcmVxdWVzdHNMb2FkaW5nLmFkZChyZXNvdXJjZUxvYWRlcik7Cit9CisgICAgCit2 b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjpyZW1vdmUoUmVzb3Vy Y2VMb2FkZXIqIHJlc291cmNlTG9hZGVyLCBQcmlvcml0eSBwcmlvcml0eSkKK3sKKyAgICBpZiAo bV9yZXF1ZXN0c0xvYWRpbmcuY29udGFpbnMocmVzb3VyY2VMb2FkZXIpKSB7CisgICAgICAgIG1f cmVxdWVzdHNMb2FkaW5nLnJlbW92ZShyZXNvdXJjZUxvYWRlcik7CisgICAgICAgIHJldHVybjsK KyAgICB9CisgICAgCisgICAgUmVxdWVzdFF1ZXVlOjppdGVyYXRvciBlbmQgPSBtX3JlcXVlc3Rz UGVuZGluZ1twcmlvcml0eV0uZW5kKCk7CisgICAgZm9yIChSZXF1ZXN0UXVldWU6Oml0ZXJhdG9y IGl0ID0gbV9yZXF1ZXN0c1BlbmRpbmdbcHJpb3JpdHldLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytp dCkgeworICAgICAgICBpZiAoKml0ID09IHJlc291cmNlTG9hZGVyKSB7CisgICAgICAgICAgICBt X3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0ucmVtb3ZlKGl0KTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorICAgIH0KK30KKworYm9vbCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6Okhv c3RJbmZvcm1hdGlvbjo6aGFzUmVxdWVzdHMoKSBjb25zdAoreworICAgIGlmICghbV9yZXF1ZXN0 c0xvYWRpbmcuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBmb3IgKHVuc2ln bmVkIHAgPSAwOyBwIDw9IEhpZ2g7IHArKykgeworICAgICAgICBpZiAoIW1fcmVxdWVzdHNQZW5k aW5nW3BdLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUv bG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9S ZXNvdXJjZUxvYWRlci5jcHAJKHJldmlzaW9uIDY5MzEzKQorKysgV2ViQ29yZS9sb2FkZXIvUmVz b3VyY2VMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOSw4ICszOSw5IEBACiAjaW5jbHVk ZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgogI2luY2x1 ZGUgIlByb2dyZXNzVHJhY2tlci5oIgorI2luY2x1ZGUgIlJlc291cmNlRXJyb3IuaCIKICNpbmNs dWRlICJSZXNvdXJjZUhhbmRsZS5oIgotI2luY2x1ZGUgIlJlc291cmNlRXJyb3IuaCIKKyNpbmNs dWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2lu Y2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgogCkBAIC05NSw2ICs5Niw4IEBACiAKICAgICBtX2lkZW50 aWZpZXIgPSAwOwogCisgICAgcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPnJlbW92ZSh0aGlzKTsK KwogICAgIGlmIChtX2hhbmRsZSkgewogICAgICAgICAvLyBDbGVhciBvdXQgdGhlIFJlc291cmNl SGFuZGxlJ3MgY2xpZW50IHNvIHRoYXQgaXQgZG9lc24ndCB0cnkgdG8gY2FsbAogICAgICAgICAv LyB1cyBiYWNrIGFmdGVyIHdlIHJlbGVhc2UgaXQsIHVubGVzcyBpdCBoYXMgYmVlbiByZXBsYWNl ZCBieSBzb21lb25lIGVsc2UuCkBAIC0xNDMsMTIgKzE0NiwyMSBAQAogICAgICAgICBtX2RlZmVy cmVkUmVxdWVzdCA9IGNsaWVudFJlcXVlc3Q7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0K LSAgICAKLSAgICBtX2hhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUobV9mcmFtZS0+bG9h ZGVyKCktPm5ldHdvcmtpbmdDb250ZXh0KCksIGNsaWVudFJlcXVlc3QsIHRoaXMsIG1fZGVmZXJz TG9hZGluZywgbV9zaG91bGRDb250ZW50U25pZmYpOwogCisgICAgcmVzb3VyY2VMb2FkU2NoZWR1 bGVyKCktPmFkZCh0aGlzKTsKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAordm9pZCBSZXNvdXJjZUxv YWRlcjo6c3RhcnQoKQoreworI2lmbmRlZiBOREVCVUcKKyAgICByZXNvdXJjZUxvYWRTY2hlZHVs ZXIoKS0+YXNzZXJ0TG9hZGVyQmVpbmdDb3VudGVkKHRoaXMpOworI2VuZGlmCisKKyAgICBpZiAo IW1fcmVhY2hlZFRlcm1pbmFsU3RhdGUpCisgICAgICAgIG1faGFuZGxlID0gUmVzb3VyY2VIYW5k bGU6OmNyZWF0ZShtX2ZyYW1lLT5sb2FkZXIoKS0+bmV0d29ya2luZ0NvbnRleHQoKSwgbV9yZXF1 ZXN0LCB0aGlzLCBtX2RlZmVyc0xvYWRpbmcsIG1fc2hvdWxkQ29udGVudFNuaWZmKTsKK30KKwog dm9pZCBSZXNvdXJjZUxvYWRlcjo6c2V0RGVmZXJzTG9hZGluZyhib29sIGRlZmVycykKIHsKICAg ICBtX2RlZmVyc0xvYWRpbmcgPSBkZWZlcnM7CkBAIC0yMjMsNiArMjM1LDggQEAKICAgICAgICAg ZnJhbWVMb2FkZXIoKS0+bm90aWZpZXIoKS0+d2lsbFNlbmRSZXF1ZXN0KHRoaXMsIHJlcXVlc3Qs IHJlZGlyZWN0UmVzcG9uc2UpOwogICAgIH0KIAorICAgIGlmICghcmVkaXJlY3RSZXNwb25zZS5p c051bGwoKSkKKyAgICAgICAgcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPmNoYW5nZUhvc3QodGhp cywgcmVxdWVzdCk7CiAgICAgbV9yZXF1ZXN0ID0gcmVxdWVzdDsKIH0KIApJbmRleDogV2ViQ29y ZS9sb2FkZXIvTWFpblJlc291cmNlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xv YWRlci9NYWluUmVzb3VyY2VMb2FkZXIuY3BwCShyZXZpc2lvbiA2OTMxMykKKysrIFdlYkNvcmUv bG9hZGVyL01haW5SZXNvdXJjZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0 LDcgQEAKICNlbmRpZgogI2luY2x1ZGUgIlJlc291cmNlRXJyb3IuaCIKICNpbmNsdWRlICJSZXNv dXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgIlJlc291cmNlTG9hZFNjaGVkdWxlci5oIgogI2luY2x1 ZGUgIlNjaGVtZVJlZ2lzdHJ5LmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlIDx3 dGYvQ3VycmVudFRpbWUuaD4KQEAgLTU0OSw2ICs1NTAsNyBAQAogICAgIGlmIChzaG91bGRMb2Fk RW1wdHlCZWZvcmVSZWRpcmVjdCAmJiAhc2hvdWxkTG9hZEVtcHR5ICYmIGRlZmVyc0xvYWRpbmco KSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAKKyAgICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+ YWRkKHRoaXMsIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6QWxyZWFkeUxvYWRpbmcpOwogICAgIGlm IChtX3N1YnN0aXR1dGVEYXRhLmlzVmFsaWQoKSkgCiAgICAgICAgIGhhbmRsZURhdGFMb2FkU29v bihyKTsKICAgICBlbHNlIGlmIChzaG91bGRMb2FkRW1wdHkgfHwgZnJhbWVMb2FkZXIoKS0+cmVw cmVzZW50YXRpb25FeGlzdHNGb3JVUkxTY2hlbWUodXJsLnByb3RvY29sKCkpKQpJbmRleDogV2Vi Q29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9sb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L2xvYWRlci9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwx MTggQEAKKy8qCisgICAgQ29weXJpZ2h0IChDKSAxOTk4IExhcnMgS25vbGwgKGtub2xsQG1waS1o ZC5tcGcuZGUpCisgICAgQ29weXJpZ2h0IChDKSAyMDAxIERpcmsgTXVlbGxlciA8bXVlbGxlckBr ZGUub3JnPgorICAgIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNiwgMjAwNywgMjAwOCBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgICAgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAgICBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAg ICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICAgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBD T1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICAgIEJvc3Rv biwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgUmVzb3VyY2VMb2FkU2NoZWR1 bGVyX2gKKyNkZWZpbmUgUmVzb3VyY2VMb2FkU2NoZWR1bGVyX2gKKworI2luY2x1ZGUgIlBsYXRm b3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4K KyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CisjaW5j bHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5o PgorCituYW1lc3BhY2UgV2ViQ29yZSB7CitjbGFzcyBLVVJMOworY2xhc3MgUmVzb3VyY2VMb2Fk ZXI7CitjbGFzcyBSZXNvdXJjZVJlcXVlc3Q7CisKK2NsYXNzIFJlc291cmNlTG9hZFNjaGVkdWxl ciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAgZW51bSBTY2hlZHVsZVBvbGlj eSB7CisgICAgICAgIFNjaGVkdWxlLAorICAgICAgICBBbHJlYWR5TG9hZGluZworICAgIH07CisK KyAgICBmcmllbmQgUmVzb3VyY2VMb2FkU2NoZWR1bGVyKiByZXNvdXJjZUxvYWRTY2hlZHVsZXIo KTsKKworICAgIHZvaWQgYWRkKFJlc291cmNlTG9hZGVyKiwgU2NoZWR1bGVQb2xpY3kgPSBTY2hl ZHVsZSk7CisgICAgdm9pZCByZW1vdmUoUmVzb3VyY2VMb2FkZXIqKTsKKyAgICB2b2lkIGNoYW5n ZUhvc3QoUmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAKKyAg ICBlbnVtIFByaW9yaXR5IHsgVmVyeUxvdywgTG93LCBNZWRpdW0sIEhpZ2ggfTsKKyAgICB2b2lk IHNlcnZlUGVuZGluZ1JlcXVlc3RzKFByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSA9IFZlcnlMb3cp OworCisgICAgdm9pZCBzdXNwZW5kUGVuZGluZ1JlcXVlc3RzKCk7CisgICAgdm9pZCByZXN1bWVQ ZW5kaW5nUmVxdWVzdHMoKTsKKyAgICAKKyNpZm5kZWYgTkRFQlVHCisgICAgdm9pZCBhc3NlcnRM b2FkZXJCZWluZ0NvdW50ZWQoUmVzb3VyY2VMb2FkZXIqKTsKKyNlbmRpZgorCitwcml2YXRlOgor ICAgIFJlc291cmNlTG9hZFNjaGVkdWxlcigpOworICAgIH5SZXNvdXJjZUxvYWRTY2hlZHVsZXIo KTsKKworICAgIFByaW9yaXR5IGRldGVybWluZVByaW9yaXR5KGNvbnN0IFJlc291cmNlUmVxdWVz dCYpIGNvbnN0OworCisgICAgdm9pZCBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Cisg ICAgdm9pZCByZXF1ZXN0VGltZXJGaXJlZChUaW1lcjxSZXNvdXJjZUxvYWRTY2hlZHVsZXI+Kik7 CisKKyAgICBjbGFzcyBIb3N0SW5mb3JtYXRpb24gOiBwdWJsaWMgUmVmQ291bnRlZDxIb3N0SW5m b3JtYXRpb24+IHsKKyAgICBwdWJsaWM6CisgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEhvc3RJ bmZvcm1hdGlvbj4gY3JlYXRlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgbWF4UmVxdWVz dHNJbkZsaWdodCkgCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg SG9zdEluZm9ybWF0aW9uKG5hbWUsIG1heFJlcXVlc3RzSW5GbGlnaHQpKTsKKyAgICAgICAgfQor ICAgICAgICB+SG9zdEluZm9ybWF0aW9uKCk7CisgICAgICAgIAorICAgICAgICBjb25zdCBTdHJp bmcmIG5hbWUoKSBjb25zdCB7IHJldHVybiBtX25hbWU7IH0KKyAgICAgICAgdm9pZCBhZGQoUmVz b3VyY2VMb2FkZXIqLCBTY2hlZHVsZVBvbGljeSwgUHJpb3JpdHkgPSBWZXJ5TG93KTsKKyAgICAg ICAgdm9pZCByZW1vdmUoUmVzb3VyY2VMb2FkZXIqLCBQcmlvcml0eSk7CisgICAgICAgIGJvb2wg aGFzUmVxdWVzdHMoKSBjb25zdDsKKyAgICAgICAgYm9vbCBsaW1pdFJlcXVlc3RzKCkgY29uc3Qg eyByZXR1cm4gbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpID49IG1fbWF4UmVxdWVzdHNJbkZsaWdo dDsgfQorICAgICAgICAKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgIHZvaWQgYXNzZXJ0TG9hZGVy QmVpbmdDb3VudGVkKFJlc291cmNlTG9hZGVyKik7CisjZW5kaWYKKworICAgICAgICB0eXBlZGVm IERlcXVlPFJlZlB0cjxSZXNvdXJjZUxvYWRlcj4gPiBSZXF1ZXN0UXVldWU7CisgICAgICAgIFJl cXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nKFByaW9yaXR5IHByaW9yaXR5KSB7IHJldHVybiBt X3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV07IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIEhv c3RJbmZvcm1hdGlvbihjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCk7CisgICAgICAgICAgICAgICAg ICAgIAorICAgICAgICBSZXF1ZXN0UXVldWUgbV9yZXF1ZXN0c1BlbmRpbmdbSGlnaCArIDFdOwor ICAgICAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPFJlc291cmNlTG9hZGVyPiA+IFJlcXVlc3RN YXA7CisgICAgICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0c0xvYWRpbmc7CisgICAgICAgIGNvbnN0 IFN0cmluZyBtX25hbWU7CisgICAgICAgIGNvbnN0IGludCBtX21heFJlcXVlc3RzSW5GbGlnaHQ7 CisgICAgfTsKKyAgICAKKyAgICBIb3N0SW5mb3JtYXRpb24qIGhvc3RGb3JVUkwoY29uc3QgS1VS TCYsIGJvb2wgY3JlYXRlSWZOb3RGb3VuZCA9IGZhbHNlKTsKKyAgICB2b2lkIHNlcnZlUGVuZGlu Z1JlcXVlc3RzKEhvc3RJbmZvcm1hdGlvbiosIFByaW9yaXR5KTsKKworICAgIHR5cGVkZWYgSGFz aE1hcDxTdHJpbmcsIFJlZlB0cjxIb3N0SW5mb3JtYXRpb24+LCBTdHJpbmdIYXNoPiBIb3N0TWFw OworICAgIEhvc3RNYXAgbV9ob3N0czsKKyAgICBSZWZQdHI8SG9zdEluZm9ybWF0aW9uPiBtX25v bkhUVFBQcm90b2NvbEhvc3Q7CisgICAgICAgIAorICAgIFRpbWVyPFJlc291cmNlTG9hZFNjaGVk dWxlcj4gbV9yZXF1ZXN0VGltZXI7CisKKyAgICBib29sIG1faXNTdXNwZW5kaW5nUGVuZGluZ1Jl cXVlc3RzOworfTsKKworUmVzb3VyY2VMb2FkU2NoZWR1bGVyKiByZXNvdXJjZUxvYWRTY2hlZHVs ZXIoKTsKKworfQorCisjZW5kaWYKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVy LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuaAkocmV2aXNp b24gNjkzMTMpCisrKyBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNv cHkpCkBAIC00MCw3ICs0MCw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotICAgIGNsYXNz IEFwcGxpY2F0aW9uQ2FjaGVIb3N0OwogICAgIGNsYXNzIERvY3VtZW50TG9hZGVyOwogICAgIGNs YXNzIEZyYW1lOwogICAgIGNsYXNzIEZyYW1lTG9hZGVyOwpAQCAtMTIyLDIyICsxMjEsMjIgQEAK ICAgICAgICAgdmlydHVhbCBBc3luY0ZpbGVTdHJlYW0qIGNyZWF0ZUFzeW5jRmlsZVN0cmVhbShG aWxlU3RyZWFtQ2xpZW50Kik7CiAjZW5kaWYKIAorICAgICAgICBjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QoKSBjb25zdCB7IHJldHVybiBtX3JlcXVlc3Q7IH0KICAgICAgICAgUmVzb3Vy Y2VIYW5kbGUqIGhhbmRsZSgpIGNvbnN0IHsgcmV0dXJuIG1faGFuZGxlLmdldCgpOyB9CiAgICAg ICAgIGJvb2wgc2VuZFJlc291cmNlTG9hZENhbGxiYWNrcygpIGNvbnN0IHsgcmV0dXJuIG1fc2Vu ZFJlc291cmNlTG9hZENhbGxiYWNrczsgfQogCisgICAgICAgIC8vIENhbGxlZCBieSBSZXNvdXJj ZUxvYWRTY2hlZHVsZXIgdG8gY3JlYXRlIGEgUmVzb3VyY2VIYW5kbGUgYW5kIGFjdHVhbGx5IGJl Z2luIHRoZSBsb2FkLgorICAgICAgICB2b2lkIHN0YXJ0KCk7CisKICAgICAgICAgdm9pZCBzZXRT aG91bGRCdWZmZXJEYXRhKGJvb2wgc2hvdWxkQnVmZmVyRGF0YSk7CiAKICAgICBwcm90ZWN0ZWQ6 CiAgICAgICAgIFJlc291cmNlTG9hZGVyKEZyYW1lKiwgYm9vbCBzZW5kUmVzb3VyY2VMb2FkQ2Fs bGJhY2tzLCBib29sIHNob3VsZENvbnRlbnRTbmlmZik7CiAKLSNpZiBFTkFCTEUoT0ZGTElORV9X RUJfQVBQTElDQVRJT05TKQotICAgICAgICBmcmllbmQgY2xhc3MgQXBwbGljYXRpb25DYWNoZUhv c3Q7ICAvLyBmb3IgYWNjZXNzIHRvIHJlcXVlc3QoKQotI2VuZGlmCiAKICAgICAgICAgdmlydHVh bCB2b2lkIGRpZENhbmNlbChjb25zdCBSZXNvdXJjZUVycm9yJik7CiAgICAgICAgIHZvaWQgZGlk RmluaXNoTG9hZGluZ09uZVBhcnQoZG91YmxlIGZpbmlzaFRpbWUpOwogCi0gICAgICAgIGNvbnN0 IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCgpIGNvbnN0IHsgcmV0dXJuIG1fcmVxdWVzdDsgfQog ICAgICAgICBib29sIHJlYWNoZWRUZXJtaW5hbFN0YXRlKCkgY29uc3QgeyByZXR1cm4gbV9yZWFj aGVkVGVybWluYWxTdGF0ZTsgfQogICAgICAgICBib29sIGNhbmNlbGxlZCgpIGNvbnN0IHsgcmV0 dXJuIG1fY2FuY2VsbGVkOyB9CiAgICAgICAgIGJvb2wgZGVmZXJzTG9hZGluZygpIGNvbnN0IHsg cmV0dXJuIG1fZGVmZXJzTG9hZGluZzsgfQpJbmRleDogV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCShyZXZpc2lvbiA2OTMx MykKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4LDQ1 ICsyOCwxOCBAQAogI2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCiAjaW5jbHVkZSAiQ2FjaGVkUmVz b3VyY2UuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUxvYWRlci5oIgotI2luY2x1ZGUgIklu c3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAi RnJhbWVMb2FkZXIuaCIKLSNpbmNsdWRlICJIVE1MRG9jdW1lbnQuaCIKICNpbmNsdWRlICJSZXF1 ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJl cXVlc3QuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNlLmgiCi0jaW5jbHVkZSAiU2VjdXJp dHlPcmlnaW4uaCIKICNpbmNsdWRlICJTaGFyZWRCdWZmZXIuaCIKLSNpbmNsdWRlICJTdWJyZXNv dXJjZUxvYWRlci5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgogCi0jZGVmaW5lIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVEIDEKLSNkZWZp bmUgUkVRVUVTVF9ERUJVRyAwCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotI2lmIFJFUVVFU1Rf TUFOQUdFTUVOVF9FTkFCTEVECi0vLyBNYXRjaCB0aGUgcGFyYWxsZWwgY29ubmVjdGlvbiBjb3Vu dCB1c2VkIGJ5IHRoZSBuZXR3b3JraW5nIGxheWVyCi1zdGF0aWMgdW5zaWduZWQgbWF4UmVxdWVz dHNJbkZsaWdodFBlckhvc3Q7Ci0vLyBIYXZpbmcgYSBsaW1pdCBtaWdodCBzdGlsbCBoZWxwIGdl dHRpbmcgbW9yZSBpbXBvcnRhbnQgcmVzb3VyY2VzIGZpcnN0Ci1zdGF0aWMgY29uc3QgdW5zaWdu ZWQgbWF4UmVxdWVzdHNJbkZsaWdodEZvck5vbkhUVFBQcm90b2NvbHMgPSAyMDsKLSNlbHNlCi1z dGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QgPSAxMDAwMDsK LXN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFByb3Rv Y29scyA9IDEwMDAwOwotI2VuZGlmCi0KLUxvYWRlcjo6TG9hZGVyKCkKLSAgICA6IG1fcmVxdWVz dFRpbWVyKHRoaXMsICZMb2FkZXI6OnJlcXVlc3RUaW1lckZpcmVkKQotICAgICwgbV9pc1N1c3Bl bmRpbmdQZW5kaW5nUmVxdWVzdHMoZmFsc2UpCi17Ci0gICAgbV9ub25IVFRQUHJvdG9jb2xIb3N0 ID0gSG9zdDo6Y3JlYXRlKEF0b21pY1N0cmluZygpLCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9u SFRUUFByb3RvY29scyk7Ci0jaWYgUkVRVUVTVF9NQU5BR0VNRU5UX0VOQUJMRUQKLSAgICBtYXhS ZXF1ZXN0c0luRmxpZ2h0UGVySG9zdCA9IGluaXRpYWxpemVNYXhpbXVtSFRUUENvbm5lY3Rpb25D b3VudFBlckhvc3QoKTsKLSNlbmRpZgotfQotCiBMb2FkZXI6On5Mb2FkZXIoKQogeyAgICAKICAg ICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKQEAgLTk1LDI5MSArNjgsNzEgQEAKICAgICByZXR1cm4g UmVzb3VyY2VSZXF1ZXN0OjpUYXJnZXRJc1N1YnJlc291cmNlOwogfQogCi1Mb2FkZXI6OlByaW9y aXR5IExvYWRlcjo6ZGV0ZXJtaW5lUHJpb3JpdHkoY29uc3QgQ2FjaGVkUmVzb3VyY2UqIHJlc291 cmNlKSBjb25zdAotewotI2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECi0gICAgc3dpdGNo IChyZXNvdXJjZS0+dHlwZSgpKSB7Ci0gICAgICAgIGNhc2UgQ2FjaGVkUmVzb3VyY2U6OkNTU1N0 eWxlU2hlZXQ6Ci0jaWYgRU5BQkxFKFhTTFQpCi0gICAgICAgIGNhc2UgQ2FjaGVkUmVzb3VyY2U6 OlhTTFN0eWxlU2hlZXQ6Ci0jZW5kaWYKLSAgICAgICAgICAgIHJldHVybiBIaWdoOwotICAgICAg ICBjYXNlIENhY2hlZFJlc291cmNlOjpTY3JpcHQ6IAotICAgICAgICBjYXNlIENhY2hlZFJlc291 cmNlOjpGb250UmVzb3VyY2U6Ci0gICAgICAgICAgICByZXR1cm4gTWVkaXVtOwotICAgICAgICBj YXNlIENhY2hlZFJlc291cmNlOjpJbWFnZVJlc291cmNlOgotICAgICAgICAgICAgcmV0dXJuIExv dzsKLSNpZiBFTkFCTEUoTElOS19QUkVGRVRDSCkKLSAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJj ZTo6TGlua1ByZWZldGNoOgotICAgICAgICAgICAgcmV0dXJuIFZlcnlMb3c7Ci0jZW5kaWYKLSAg ICB9Ci0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci0gICAgcmV0dXJuIExvdzsKLSNlbHNlCi0g ICAgcmV0dXJuIEhpZ2g7Ci0jZW5kaWYKLX0KLQogdm9pZCBMb2FkZXI6OmxvYWQoQ2FjaGVkUmVz b3VyY2VMb2FkZXIqIGNhY2hlZFJlc291cmNlTG9hZGVyLCBDYWNoZWRSZXNvdXJjZSogcmVzb3Vy Y2UsIGJvb2wgaW5jcmVtZW50YWwsIFNlY3VyaXR5Q2hlY2tQb2xpY3kgc2VjdXJpdHlDaGVjaywg Ym9vbCBzZW5kUmVzb3VyY2VMb2FkQ2FsbGJhY2tzKQogewogICAgIEFTU0VSVChjYWNoZWRSZXNv dXJjZUxvYWRlcik7CiAgICAgUmVxdWVzdCogcmVxdWVzdCA9IG5ldyBSZXF1ZXN0KGNhY2hlZFJl c291cmNlTG9hZGVyLCByZXNvdXJjZSwgaW5jcmVtZW50YWwsIHNlY3VyaXR5Q2hlY2ssIHNlbmRS ZXNvdXJjZUxvYWRDYWxsYmFja3MpOwogCi0gICAgUmVmUHRyPEhvc3Q+IGhvc3Q7Ci0gICAgS1VS TCB1cmwoUGFyc2VkVVJMU3RyaW5nLCByZXNvdXJjZS0+dXJsKCkpOwotICAgIGlmICh1cmwucHJv dG9jb2xJbkhUVFBGYW1pbHkoKSkgewotICAgICAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3ko KTsKLSAgICAgICAgQXRvbWljU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3QoKTsKLSAgICAgICAg aG9zdCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lLmltcGwoKSk7Ci0gICAgICAgIGlmICghaG9zdCkg ewotICAgICAgICAgICAgaG9zdCA9IEhvc3Q6OmNyZWF0ZShob3N0TmFtZSwgbWF4UmVxdWVzdHNJ bkZsaWdodFBlckhvc3QpOwotICAgICAgICAgICAgbV9ob3N0cy5hZGQoaG9zdE5hbWUuaW1wbCgp LCBob3N0KTsKLSAgICAgICAgfQotICAgIH0gZWxzZSAKLSAgICAgICAgaG9zdCA9IG1fbm9uSFRU UFByb3RvY29sSG9zdDsKLSAgICAKLSAgICBib29sIGhhZFJlcXVlc3RzID0gaG9zdC0+aGFzUmVx dWVzdHMoKTsKLSAgICBQcmlvcml0eSBwcmlvcml0eSA9IGRldGVybWluZVByaW9yaXR5KHJlc291 cmNlKTsKLSAgICBob3N0LT5hZGRSZXF1ZXN0KHJlcXVlc3QsIHByaW9yaXR5KTsKICAgICBjYWNo ZWRSZXNvdXJjZUxvYWRlci0+aW5jcmVtZW50UmVxdWVzdENvdW50KHJlcXVlc3QtPmNhY2hlZFJl c291cmNlKCkpOworICAgIGJvb2wgcmVzb3VyY2VJc0NhY2hlVmFsaWRhdG9yID0gcmVxdWVzdC0+ Y2FjaGVkUmVzb3VyY2UoKS0+aXNDYWNoZVZhbGlkYXRvcigpOwogCi0gICAgaWYgKHByaW9yaXR5 ID4gTG93IHx8ICF1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSB8fCAocHJpb3JpdHkgPT0gTG93 ICYmICFoYWRSZXF1ZXN0cykpIHsKLSAgICAgICAgLy8gVHJ5IHRvIHJlcXVlc3QgaW1wb3J0YW50 IHJlc291cmNlcyBpbW1lZGlhdGVseQotICAgICAgICBob3N0LT5zZXJ2ZVBlbmRpbmdSZXF1ZXN0 cyhwcmlvcml0eSk7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgLy8gSGFuZGxlIGFzeW5jaHJvbm91 c2x5IHNvIGVhcmx5IGxvdyBwcmlvcml0eSByZXF1ZXN0cyBkb24ndCBnZXQgc2NoZWR1bGVkIGJl Zm9yZSBsYXRlciBoaWdoIHByaW9yaXR5IG9uZXMKLSAgICAgICAgSW5zcGVjdG9ySW5zdHJ1bWVu dGF0aW9uOjpkaWRTY2hlZHVsZVJlc291cmNlUmVxdWVzdChjYWNoZWRSZXNvdXJjZUxvYWRlci0+ ZG9jKCksIHJlc291cmNlLT51cmwoKSk7Ci0gICAgICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVx dWVzdHMoKTsKLSAgICB9Ci19Ci0gICAgCi12b2lkIExvYWRlcjo6c2NoZWR1bGVTZXJ2ZVBlbmRp bmdSZXF1ZXN0cygpCi17Ci0gICAgaWYgKCFtX3JlcXVlc3RUaW1lci5pc0FjdGl2ZSgpKQotICAg ICAgICBtX3JlcXVlc3RUaW1lci5zdGFydE9uZVNob3QoMCk7Ci19CisgICAgUmVzb3VyY2VSZXF1 ZXN0IHJlc291cmNlUmVxdWVzdChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT51cmwoKSk7Cisg ICAgcmVzb3VyY2VSZXF1ZXN0LnNldFRhcmdldFR5cGUoY2FjaGVkUmVzb3VyY2VUeXBlVG9UYXJn ZXRUeXBlKHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnR5cGUoKSkpOworICAgIGlmICghcmVx dWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+YWNjZXB0KCkuaXNFbXB0eSgpKQorICAgICAgICByZXNv dXJjZVJlcXVlc3Quc2V0SFRUUEFjY2VwdChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5hY2Nl cHQoKSk7CiAKLXZvaWQgTG9hZGVyOjpyZXF1ZXN0VGltZXJGaXJlZChUaW1lcjxMb2FkZXI+Kikg Ci17Ci0gICAgc2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKLX0KLQotdm9pZCBMb2FkZXI6OnNlcnZl UGVuZGluZ1JlcXVlc3RzKFByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSkKLXsKLSAgICBpZiAobV9p c1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMpCi0gICAgICAgIHJldHVybjsKLQotICAgIG1fcmVx dWVzdFRpbWVyLnN0b3AoKTsKLSAgICAKLSAgICBtX25vbkhUVFBQcm90b2NvbEhvc3QtPnNlcnZl UGVuZGluZ1JlcXVlc3RzKG1pbmltdW1Qcmlvcml0eSk7Ci0KLSAgICBWZWN0b3I8SG9zdCo+IGhv c3RzVG9TZXJ2ZTsKLSAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3koKTsKLSAgICBIb3N0TWFw OjppdGVyYXRvciBpID0gbV9ob3N0cy5iZWdpbigpOwotICAgIEhvc3RNYXA6Oml0ZXJhdG9yIGVu ZCA9IG1faG9zdHMuZW5kKCk7Ci0gICAgZm9yICg7aSAhPSBlbmQ7ICsraSkKLSAgICAgICAgaG9z dHNUb1NlcnZlLmFwcGVuZChpLT5zZWNvbmQuZ2V0KCkpOwotICAgICAgICAKLSAgICBmb3IgKHVu c2lnbmVkIG4gPSAwOyBuIDwgaG9zdHNUb1NlcnZlLnNpemUoKTsgKytuKSB7Ci0gICAgICAgIEhv c3QqIGhvc3QgPSBob3N0c1RvU2VydmVbbl07Ci0gICAgICAgIGlmIChob3N0LT5oYXNSZXF1ZXN0 cygpKQotICAgICAgICAgICAgaG9zdC0+c2VydmVQZW5kaW5nUmVxdWVzdHMobWluaW11bVByaW9y aXR5KTsKLSAgICAgICAgZWxzZSBpZiAoIWhvc3QtPnByb2Nlc3NpbmdSZXNvdXJjZSgpKXsKLSAg ICAgICAgICAgIEF0b21pY1N0cmluZyBuYW1lID0gaG9zdC0+bmFtZSgpOwotICAgICAgICAgICAg bV9ob3N0cy5yZW1vdmUobmFtZS5pbXBsKCkpOworICAgIGlmIChyZXNvdXJjZUlzQ2FjaGVWYWxp ZGF0b3IpIHsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlVG9SZXZhbGlkYXRlID0g cmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+cmVzb3VyY2VUb1JldmFsaWRhdGUoKTsKKyAgICAg ICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5jYW5Vc2VDYWNoZVZhbGlkYXRvcigpKTsK KyAgICAgICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5pc0xvYWRlZCgpKTsKKyAgICAg ICAgY29uc3QgU3RyaW5nJiBsYXN0TW9kaWZpZWQgPSByZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVz cG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkxhc3QtTW9kaWZpZWQiKTsKKyAgICAgICAgY29uc3Qg U3RyaW5nJiBlVGFnID0gcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlc3BvbnNlKCkuaHR0cEhlYWRl ckZpZWxkKCJFVGFnIik7CisgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlzRW1wdHkoKSB8fCAh ZVRhZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgIEFTU0VSVChjYWNoZWRSZXNvdXJjZUxvYWRl ci0+Y2FjaGVQb2xpY3koKSAhPSBDYWNoZVBvbGljeVJlbG9hZCk7CisgICAgICAgICAgICBpZiAo Y2FjaGVkUmVzb3VyY2VMb2FkZXItPmNhY2hlUG9saWN5KCkgPT0gQ2FjaGVQb2xpY3lSZXZhbGlk YXRlKQorICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQo IkNhY2hlLUNvbnRyb2wiLCAibWF4LWFnZT0wIik7CisgICAgICAgICAgICBpZiAoIWxhc3RNb2Rp ZmllZC5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBI ZWFkZXJGaWVsZCgiSWYtTW9kaWZpZWQtU2luY2UiLCBsYXN0TW9kaWZpZWQpOworICAgICAgICAg ICAgaWYgKCFlVGFnLmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Qu c2V0SFRUUEhlYWRlckZpZWxkKCJJZi1Ob25lLU1hdGNoIiwgZVRhZyk7CiAgICAgICAgIH0KICAg ICB9Ci19CiAKLXZvaWQgTG9hZGVyOjpzdXNwZW5kUGVuZGluZ1JlcXVlc3RzKCkKLXsKLSAgICBB U1NFUlQoIW1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKTsKLSAgICBtX2lzU3VzcGVuZGlu Z1BlbmRpbmdSZXF1ZXN0cyA9IHRydWU7Ci19Ci0KLXZvaWQgTG9hZGVyOjpyZXN1bWVQZW5kaW5n UmVxdWVzdHMoKQotewotICAgIEFTU0VSVChtX2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cyk7 Ci0gICAgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMgPSBmYWxzZTsKLSAgICBpZiAoIW1f aG9zdHMuaXNFbXB0eSgpIHx8IG1fbm9uSFRUUFByb3RvY29sSG9zdC0+aGFzUmVxdWVzdHMoKSkK LSAgICAgICAgc2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwotfQotCi12b2lkIExvYWRl cjo6bm9uQ2FjaGVSZXF1ZXN0SW5GbGlnaHQoY29uc3QgS1VSTCYgdXJsKQotewotICAgIGlmICgh dXJsLnByb3RvY29sSW5IVFRQRmFtaWx5KCkpCi0gICAgICAgIHJldHVybjsKLSAgICAKLSAgICBB dG9taWNTdHJpbmcgaG9zdE5hbWUgPSB1cmwuaG9zdCgpOwotICAgIG1faG9zdHMuY2hlY2tDb25z aXN0ZW5jeSgpOwotICAgIFJlZlB0cjxIb3N0PiBob3N0ID0gbV9ob3N0cy5nZXQoaG9zdE5hbWUu aW1wbCgpKTsKLSAgICBpZiAoIWhvc3QpIHsKLSAgICAgICAgaG9zdCA9IEhvc3Q6OmNyZWF0ZSho b3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOwotICAgICAgICBtX2hvc3RzLmFk ZChob3N0TmFtZS5pbXBsKCksIGhvc3QpOworICAgIFJlZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4g bG9hZGVyID0gU3VicmVzb3VyY2VMb2FkZXI6OmNyZWF0ZShjYWNoZWRSZXNvdXJjZUxvYWRlci0+ ZG9jKCktPmZyYW1lKCksCisgICAgICAgIHRoaXMsIHJlc291cmNlUmVxdWVzdCwgcmVxdWVzdC0+ c2hvdWxkRG9TZWN1cml0eUNoZWNrKCksIHJlcXVlc3QtPnNlbmRSZXNvdXJjZUxvYWRDYWxsYmFj a3MoKSk7CisgICAgaWYgKGxvYWRlcikgeworICAgICAgICBtX3JlcXVlc3RzTG9hZGluZy5hZGQo bG9hZGVyLnJlbGVhc2UoKSwgcmVxdWVzdCk7CisgICAgICAgIHJlcXVlc3QtPmNhY2hlZFJlc291 cmNlKCktPnNldFJlcXVlc3RlZEZyb21OZXR3b3JraW5nTGF5ZXIoKTsKKyAgICB9IGVsc2UgeyAg ICAgICAgICAgIAorICAgICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZGVjcmVtZW50UmVxdWVz dENvdW50KHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCkpOworICAgICAgICBjYWNoZWRSZXNvdXJj ZUxvYWRlci0+c2V0TG9hZEluUHJvZ3Jlc3ModHJ1ZSk7CisgICAgICAgIHJlcXVlc3QtPmNhY2hl ZFJlc291cmNlKCktPmVycm9yKCk7CisgICAgICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRM b2FkSW5Qcm9ncmVzcyhmYWxzZSk7CisgICAgICAgIGRlbGV0ZSByZXF1ZXN0OwogICAgIH0KLQot ICAgIGhvc3QtPm5vbkNhY2hlUmVxdWVzdEluRmxpZ2h0KCk7CiB9CiAKLXZvaWQgTG9hZGVyOjpu b25DYWNoZVJlcXVlc3RDb21wbGV0ZShjb25zdCBLVVJMJiB1cmwpCi17Ci0gICAgaWYgKCF1cmwu cHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkKLSAgICAgICAgcmV0dXJuOwotICAgIAotICAgIEF0b21p Y1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7Ci0gICAgbV9ob3N0cy5jaGVja0NvbnNpc3Rl bmN5KCk7Ci0gICAgUmVmUHRyPEhvc3Q+IGhvc3QgPSBtX2hvc3RzLmdldChob3N0TmFtZS5pbXBs KCkpOwotICAgIEFTU0VSVChob3N0KTsKLSAgICBpZiAoIWhvc3QpCi0gICAgICAgIHJldHVybjsK LQotICAgIGhvc3QtPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKCk7Ci19Ci0KIHZvaWQgTG9hZGVy OjpjYW5jZWxSZXF1ZXN0cyhDYWNoZWRSZXNvdXJjZUxvYWRlciogY2FjaGVkUmVzb3VyY2VMb2Fk ZXIpCiB7CiAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNsZWFyUGVuZGluZ1ByZWxvYWRzKCk7 CiAKLSAgICBpZiAobV9ub25IVFRQUHJvdG9jb2xIb3N0LT5oYXNSZXF1ZXN0cygpKQotICAgICAg ICBtX25vbkhUVFBQcm90b2NvbEhvc3QtPmNhbmNlbFJlcXVlc3RzKGNhY2hlZFJlc291cmNlTG9h ZGVyKTsKLSAgICAKLSAgICBWZWN0b3I8SG9zdCo+IGhvc3RzVG9DYW5jZWw7Ci0gICAgbV9ob3N0 cy5jaGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgSG9zdE1hcDo6aXRlcmF0b3IgaSA9IG1faG9zdHMu YmVnaW4oKTsKLSAgICBIb3N0TWFwOjppdGVyYXRvciBlbmQgPSBtX2hvc3RzLmVuZCgpOwotICAg IGZvciAoO2kgIT0gZW5kOyArK2kpCi0gICAgICAgIGhvc3RzVG9DYW5jZWwuYXBwZW5kKGktPnNl Y29uZC5nZXQoKSk7Ci0KLSAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwgaG9zdHNUb0NhbmNl bC5zaXplKCk7ICsrbikgewotICAgICAgICBIb3N0KiBob3N0ID0gaG9zdHNUb0NhbmNlbFtuXTsK LSAgICAgICAgaWYgKGhvc3QtPmhhc1JlcXVlc3RzKCkpCi0gICAgICAgICAgICBob3N0LT5jYW5j ZWxSZXF1ZXN0cyhjYWNoZWRSZXNvdXJjZUxvYWRlcik7CisgICAgVmVjdG9yPFN1YnJlc291cmNl TG9hZGVyKiwgMjU2PiBsb2FkZXJzVG9DYW5jZWw7CisgICAgUmVxdWVzdE1hcDo6aXRlcmF0b3Ig ZW5kID0gbV9yZXF1ZXN0c0xvYWRpbmcuZW5kKCk7CisgICAgZm9yIChSZXF1ZXN0TWFwOjppdGVy YXRvciBpID0gbV9yZXF1ZXN0c0xvYWRpbmcuYmVnaW4oKTsgaSAhPSBlbmQ7ICsraSkgeworICAg ICAgICBSZXF1ZXN0KiByID0gaS0+c2Vjb25kOworICAgICAgICBpZiAoci0+Y2FjaGVkUmVzb3Vy Y2VMb2FkZXIoKSA9PSBjYWNoZWRSZXNvdXJjZUxvYWRlcikKKyAgICAgICAgICAgIGxvYWRlcnNU b0NhbmNlbC5hcHBlbmQoaS0+Zmlyc3QuZ2V0KCkpOwogICAgIH0KIAotICAgIHNjaGVkdWxlU2Vy dmVQZW5kaW5nUmVxdWVzdHMoKTsKLSAgICAKLSAgICBBU1NFUlQoY2FjaGVkUmVzb3VyY2VMb2Fk ZXItPnJlcXVlc3RDb3VudCgpID09IChjYWNoZWRSZXNvdXJjZUxvYWRlci0+bG9hZEluUHJvZ3Jl c3MoKSA/IDEgOiAwKSk7Ci19Ci0KLUxvYWRlcjo6SG9zdDo6SG9zdChjb25zdCBBdG9taWNTdHJp bmcmIG5hbWUsIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHQpCi0gICAgOiBtX25hbWUobmFt ZSkKLSAgICAsIG1fbWF4UmVxdWVzdHNJbkZsaWdodChtYXhSZXF1ZXN0c0luRmxpZ2h0KQotICAg ICwgbV9udW1SZXNvdXJjZXNQcm9jZXNzaW5nKDApCi0gICAgLCBtX25vbkNhY2hlZFJlcXVlc3Rz SW5GbGlnaHQoMCkKLXsKLX0KLQotTG9hZGVyOjpIb3N0Ojp+SG9zdCgpCi17Ci0gICAgQVNTRVJU KG1fcmVxdWVzdHNMb2FkaW5nLmlzRW1wdHkoKSk7Ci0gICAgZm9yICh1bnNpZ25lZCBwID0gMDsg cCA8PSBIaWdoOyBwKyspCi0gICAgICAgIEFTU0VSVChtX3JlcXVlc3RzUGVuZGluZ1twXS5pc0Vt cHR5KCkpOwotfQotICAgIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmFkZFJlcXVlc3QoUmVxdWVzdCog cmVxdWVzdCwgUHJpb3JpdHkgcHJpb3JpdHkpCi17Ci0gICAgbV9yZXF1ZXN0c1BlbmRpbmdbcHJp b3JpdHldLmFwcGVuZChyZXF1ZXN0KTsKLX0KLSAgICAKLXZvaWQgTG9hZGVyOjpIb3N0Ojpub25D YWNoZVJlcXVlc3RJbkZsaWdodCgpCi17Ci0gICAgKyttX25vbkNhY2hlZFJlcXVlc3RzSW5GbGln aHQ7Ci19Ci0KLXZvaWQgTG9hZGVyOjpIb3N0Ojpub25DYWNoZVJlcXVlc3RDb21wbGV0ZSgpCi17 Ci0gICAgLS1tX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQ7Ci0gICAgQVNTRVJUKG1fbm9uQ2Fj aGVkUmVxdWVzdHNJbkZsaWdodCA+PSAwKTsKLQotICAgIGNhY2hlKCktPmxvYWRlcigpLT5zY2hl ZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Ci19Ci0KLWJvb2wgTG9hZGVyOjpIb3N0OjpoYXNS ZXF1ZXN0cygpIGNvbnN0Ci17Ci0gICAgaWYgKCFtX3JlcXVlc3RzTG9hZGluZy5pc0VtcHR5KCkp Ci0gICAgICAgIHJldHVybiB0cnVlOwotICAgIGZvciAodW5zaWduZWQgcCA9IDA7IHAgPD0gSGln aDsgcCsrKSB7Ci0gICAgICAgIGlmICghbV9yZXF1ZXN0c1BlbmRpbmdbcF0uaXNFbXB0eSgpKQot ICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGxv YWRlcnNUb0NhbmNlbC5zaXplKCk7ICsraSkgeworICAgICAgICBTdWJyZXNvdXJjZUxvYWRlciog bG9hZGVyID0gbG9hZGVyc1RvQ2FuY2VsW2ldOworICAgICAgICBkaWRGYWlsKGxvYWRlciwgdHJ1 ZSk7CiAgICAgfQotICAgIHJldHVybiBmYWxzZTsKLX0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OnNl cnZlUGVuZGluZ1JlcXVlc3RzKExvYWRlcjo6UHJpb3JpdHkgbWluaW11bVByaW9yaXR5KQotewot ICAgIGlmIChjYWNoZSgpLT5sb2FkZXIoKS0+aXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKCkp Ci0gICAgICAgIHJldHVybjsKLQotICAgIGJvb2wgc2VydmVNb3JlID0gdHJ1ZTsKLSAgICBmb3Ig KGludCBwcmlvcml0eSA9IEhpZ2g7IHByaW9yaXR5ID49IG1pbmltdW1Qcmlvcml0eSAmJiBzZXJ2 ZU1vcmU7IC0tcHJpb3JpdHkpCi0gICAgICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKG1fcmVxdWVz dHNQZW5kaW5nW3ByaW9yaXR5XSwgc2VydmVNb3JlKTsKIH0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6 OnNlcnZlUGVuZGluZ1JlcXVlc3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBib29s JiBzZXJ2ZUxvd2VyUHJpb3JpdHkpCit2b2lkIExvYWRlcjo6ZGlkRmluaXNoTG9hZGluZyhTdWJy ZXNvdXJjZUxvYWRlciogbG9hZGVyKQogewotICAgIHdoaWxlICghcmVxdWVzdHNQZW5kaW5nLmlz RW1wdHkoKSkgeyAgICAgICAgCi0gICAgICAgIFJlcXVlc3QqIHJlcXVlc3QgPSByZXF1ZXN0c1Bl bmRpbmcuZmlyc3QoKTsKLSAgICAgICAgQ2FjaGVkUmVzb3VyY2VMb2FkZXIqIGNhY2hlZFJlc291 cmNlTG9hZGVyID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2VMb2FkZXIoKTsKLSAgICAgICAgYm9v bCByZXNvdXJjZUlzQ2FjaGVWYWxpZGF0b3IgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5p c0NhY2hlVmFsaWRhdG9yKCk7Ci0KLSAgICAgICAgLy8gRm9yIG5hbWVkIGhvc3RzIC0gd2hpY2gg YXJlIG9ubHkgaHR0cChzKSBob3N0cyAtIHdlIHNob3VsZCBhbHdheXMgZW5mb3JjZSB0aGUgY29u bmVjdGlvbiBsaW1pdC4KLSAgICAgICAgLy8gRm9yIG5vbi1uYW1lZCBob3N0cyAtIGV2ZXJ5dGhp bmcgYnV0IGh0dHAocykgLSB3ZSBzaG91bGQgb25seSBlbmZvcmNlIHRoZSBsaW1pdCBpZiB0aGUg ZG9jdW1lbnQgaXNuJ3QgZG9uZSBwYXJzaW5nIAotICAgICAgICAvLyBhbmQgd2UgZG9uJ3Qga25v dyBhbGwgc3R5bGVzaGVldHMgeWV0LgotICAgICAgICBib29sIHNob3VsZExpbWl0UmVxdWVzdHMg PSAhbV9uYW1lLmlzTnVsbCgpIHx8IGNhY2hlZFJlc291cmNlTG9hZGVyLT5kb2MoKS0+cGFyc2lu ZygpIHx8ICFjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZG9jKCktPmhhdmVTdHlsZXNoZWV0c0xvYWRl ZCgpOwotICAgICAgICBpZiAoc2hvdWxkTGltaXRSZXF1ZXN0cyAmJiBtX3JlcXVlc3RzTG9hZGlu Zy5zaXplKCkgKyBtX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQgPj0gbV9tYXhSZXF1ZXN0c0lu RmxpZ2h0KSB7Ci0gICAgICAgICAgICBzZXJ2ZUxvd2VyUHJpb3JpdHkgPSBmYWxzZTsKLSAgICAg ICAgICAgIHJldHVybjsKLSAgICAgICAgfQotICAgICAgICByZXF1ZXN0c1BlbmRpbmcucmVtb3Zl Rmlyc3QoKTsKLSAgICAgICAgCi0gICAgICAgIFJlc291cmNlUmVxdWVzdCByZXNvdXJjZVJlcXVl c3QocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+dXJsKCkpOwotICAgICAgICByZXNvdXJjZVJl cXVlc3Quc2V0VGFyZ2V0VHlwZShjYWNoZWRSZXNvdXJjZVR5cGVUb1RhcmdldFR5cGUocmVxdWVz dC0+Y2FjaGVkUmVzb3VyY2UoKS0+dHlwZSgpKSk7Ci0gICAgICAgIAotICAgICAgICBpZiAoIXJl cXVlc3QtPmNhY2hlZFJlc291cmNlKCktPmFjY2VwdCgpLmlzRW1wdHkoKSkKLSAgICAgICAgICAg IHJlc291cmNlUmVxdWVzdC5zZXRIVFRQQWNjZXB0KHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCkt PmFjY2VwdCgpKTsKLSAgICAgICAgCi0gICAgICAgICAvLyBEbyBub3Qgc2V0IHRoZSByZWZlcnJl ciBvciBIVFRQIG9yaWdpbiBoZXJlLiBUaGF0J3MgaGFuZGxlZCBieSBTdWJyZXNvdXJjZUxvYWRl cjo6Y3JlYXRlLgotICAgICAgICAKLSAgICAgICAgaWYgKHJlc291cmNlSXNDYWNoZVZhbGlkYXRv cikgewotICAgICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlVG9SZXZhbGlkYXRlID0g cmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+cmVzb3VyY2VUb1JldmFsaWRhdGUoKTsKLSAgICAg ICAgICAgIEFTU0VSVChyZXNvdXJjZVRvUmV2YWxpZGF0ZS0+Y2FuVXNlQ2FjaGVWYWxpZGF0b3Io KSk7Ci0gICAgICAgICAgICBBU1NFUlQocmVzb3VyY2VUb1JldmFsaWRhdGUtPmlzTG9hZGVkKCkp OwotICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBsYXN0TW9kaWZpZWQgPSByZXNvdXJjZVRvUmV2 YWxpZGF0ZS0+cmVzcG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkxhc3QtTW9kaWZpZWQiKTsKLSAg ICAgICAgICAgIGNvbnN0IFN0cmluZyYgZVRhZyA9IHJlc291cmNlVG9SZXZhbGlkYXRlLT5yZXNw b25zZSgpLmh0dHBIZWFkZXJGaWVsZCgiRVRhZyIpOwotICAgICAgICAgICAgaWYgKCFsYXN0TW9k aWZpZWQuaXNFbXB0eSgpIHx8ICFlVGFnLmlzRW1wdHkoKSkgewotICAgICAgICAgICAgICAgIEFT U0VSVChjYWNoZWRSZXNvdXJjZUxvYWRlci0+Y2FjaGVQb2xpY3koKSAhPSBDYWNoZVBvbGljeVJl bG9hZCk7Ci0gICAgICAgICAgICAgICAgaWYgKGNhY2hlZFJlc291cmNlTG9hZGVyLT5jYWNoZVBv bGljeSgpID09IENhY2hlUG9saWN5UmV2YWxpZGF0ZSkKLSAgICAgICAgICAgICAgICAgICAgcmVz b3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiQ2FjaGUtQ29udHJvbCIsICJtYXgtYWdl PTAiKTsKLSAgICAgICAgICAgICAgICBpZiAoIWxhc3RNb2RpZmllZC5pc0VtcHR5KCkpCi0gICAg ICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIklmLU1v ZGlmaWVkLVNpbmNlIiwgbGFzdE1vZGlmaWVkKTsKLSAgICAgICAgICAgICAgICBpZiAoIWVUYWcu aXNFbXB0eSgpKQotICAgICAgICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEhl YWRlckZpZWxkKCJJZi1Ob25lLU1hdGNoIiwgZVRhZyk7Ci0gICAgICAgICAgICB9Ci0gICAgICAg IH0KLQotICAgICAgICBSZWZQdHI8U3VicmVzb3VyY2VMb2FkZXI+IGxvYWRlciA9IFN1YnJlc291 cmNlTG9hZGVyOjpjcmVhdGUoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRvYygpLT5mcmFtZSgpLAot ICAgICAgICAgICAgdGhpcywgcmVzb3VyY2VSZXF1ZXN0LCByZXF1ZXN0LT5zaG91bGREb1NlY3Vy aXR5Q2hlY2soKSwgcmVxdWVzdC0+c2VuZFJlc291cmNlTG9hZENhbGxiYWNrcygpKTsKLSAgICAg ICAgaWYgKGxvYWRlcikgewotICAgICAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcuYWRkKGxvYWRl ci5yZWxlYXNlKCksIHJlcXVlc3QpOwotICAgICAgICAgICAgcmVxdWVzdC0+Y2FjaGVkUmVzb3Vy Y2UoKS0+c2V0UmVxdWVzdGVkRnJvbU5ldHdvcmtpbmdMYXllcigpOwotI2lmIFJFUVVFU1RfREVC VUcKLSAgICAgICAgICAgIHByaW50ZigiSE9TVCAlcyBDT1VOVCAlZCBMT0FESU5HICVzXG4iLCBy ZXNvdXJjZVJlcXVlc3QudXJsKCkuaG9zdCgpLmxhdGluMSgpLmRhdGEoKSwgbV9yZXF1ZXN0c0xv YWRpbmcuc2l6ZSgpLCByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT51cmwoKS5sYXRpbjEoKS5k YXRhKCkpOwotI2VuZGlmCi0gICAgICAgIH0gZWxzZSB7ICAgICAgICAgICAgCi0gICAgICAgICAg ICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZGVjcmVtZW50UmVxdWVzdENvdW50KHJlcXVlc3QtPmNh Y2hlZFJlc291cmNlKCkpOwotICAgICAgICAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPnNldExv YWRJblByb2dyZXNzKHRydWUpOwotICAgICAgICAgICAgcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2Uo KS0+ZXJyb3IoKTsKLSAgICAgICAgICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRMb2FkSW5Q cm9ncmVzcyhmYWxzZSk7Ci0gICAgICAgICAgICBkZWxldGUgcmVxdWVzdDsKLSAgICAgICAgfQot ICAgIH0KLX0KLQotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZEZpbmlzaExvYWRpbmcoU3VicmVzb3Vy Y2VMb2FkZXIqIGxvYWRlcikKLXsKLSAgICBSZWZQdHI8SG9zdD4gbXlQcm90ZWN0b3IodGhpcyk7 Ci0KICAgICBSZXF1ZXN0TWFwOjppdGVyYXRvciBpID0gbV9yZXF1ZXN0c0xvYWRpbmcuZmluZChs b2FkZXIpOwogICAgIGlmIChpID09IG1fcmVxdWVzdHNMb2FkaW5nLmVuZCgpKQogICAgICAgICBy ZXR1cm47CkBAIC00MDUsMjcgKzE1OCwxNyBAQAogICAgIH0KIAogICAgIGRlbGV0ZSByZXF1ZXN0 OwotCi0gICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPnNldExvYWRJblByb2dyZXNzKGZhbHNlKTsK LSAgICAKKyAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+c2V0TG9hZEluUHJvZ3Jlc3MoZmFsc2Up OyAgICAKICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+Y2hlY2tGb3JQZW5kaW5nUHJlbG9hZHMo KTsKLQotI2lmIFJFUVVFU1RfREVCVUcKLSAgICBLVVJMIHUoUGFyc2VkVVJMU3RyaW5nLCByZXNv dXJjZS0+dXJsKCkpOwotICAgIHByaW50ZigiSE9TVCAlcyBDT1VOVCAlZCBSRUNFSVZFRCAlc1xu IiwgdS5ob3N0KCkubGF0aW4xKCkuZGF0YSgpLCBtX3JlcXVlc3RzTG9hZGluZy5zaXplKCksIHJl c291cmNlLT51cmwoKS5sYXRpbjEoKS5kYXRhKCkpOwotI2VuZGlmCi0gICAgc2VydmVQZW5kaW5n UmVxdWVzdHMoKTsKIH0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZEZhaWwoU3VicmVzb3VyY2VM b2FkZXIqIGxvYWRlciwgY29uc3QgUmVzb3VyY2VFcnJvciYpCit2b2lkIExvYWRlcjo6ZGlkRmFp bChTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyLCBjb25zdCBSZXNvdXJjZUVycm9yJikKIHsKICAg ICBkaWRGYWlsKGxvYWRlcik7CiB9CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRGYWlsKFN1YnJl c291cmNlTG9hZGVyKiBsb2FkZXIsIGJvb2wgY2FuY2VsbGVkKQordm9pZCBMb2FkZXI6OmRpZEZh aWwoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgYm9vbCBjYW5jZWxsZWQpCiB7Ci0gICAgUmVm UHRyPEhvc3Q+IG15UHJvdGVjdG9yKHRoaXMpOwotCiAgICAgbG9hZGVyLT5jbGVhckNsaWVudCgp OwogCiAgICAgUmVxdWVzdE1hcDo6aXRlcmF0b3IgaSA9IG1fcmVxdWVzdHNMb2FkaW5nLmZpbmQo bG9hZGVyKTsKQEAgLTQ1OCwxNCArMjAxLDEwIEBACiAgICAgZGVsZXRlIHJlcXVlc3Q7CiAgICAg CiAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNoZWNrRm9yUGVuZGluZ1ByZWxvYWRzKCk7Ci0K LSAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwogfQogCi12b2lkIExvYWRlcjo6SG9zdDo6ZGlk UmVjZWl2ZVJlc3BvbnNlKFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIsIGNvbnN0IFJlc291cmNl UmVzcG9uc2UmIHJlc3BvbnNlKQordm9pZCBMb2FkZXI6OmRpZFJlY2VpdmVSZXNwb25zZShTdWJy ZXNvdXJjZUxvYWRlciogbG9hZGVyLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSkK IHsKLSAgICBSZWZQdHI8SG9zdD4gcHJvdGVjdG9yKHRoaXMpOwotCiAgICAgUmVxdWVzdCogcmVx dWVzdCA9IG1fcmVxdWVzdHNMb2FkaW5nLmdldChsb2FkZXIpOwogICAgIAogICAgIC8vIEZJWE1F OiBUaGlzIGlzIGEgd29ya2Fyb3VuZCBmb3IgPHJkYXI6Ly9wcm9ibGVtLzUyMzY4NDM+CkBAIC00 ODIsOCArMjIxLDggQEAKICAgICBpZiAocmVzb3VyY2UtPmlzQ2FjaGVWYWxpZGF0b3IoKSkgewog ICAgICAgICBpZiAocmVzcG9uc2UuaHR0cFN0YXR1c0NvZGUoKSA9PSAzMDQpIHsKICAgICAgICAg ICAgIC8vIDMwNCBOb3QgbW9kaWZpZWQgLyBVc2UgbG9jYWwgY29weQotICAgICAgICAgICAgbV9y ZXF1ZXN0c0xvYWRpbmcucmVtb3ZlKGxvYWRlcik7CiAgICAgICAgICAgICBsb2FkZXItPmNsZWFy Q2xpZW50KCk7CisgICAgICAgICAgICBtX3JlcXVlc3RzTG9hZGluZy5yZW1vdmUobG9hZGVyKTsK ICAgICAgICAgICAgIHJlcXVlc3QtPmNhY2hlZFJlc291cmNlTG9hZGVyKCktPmRlY3JlbWVudFJl cXVlc3RDb3VudChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpKTsKIAogICAgICAgICAgICAgLy8g RXhpc3RpbmcgcmVzb3VyY2UgaXMgb2ssIGp1c3QgdXNlIGl0IHVwZGF0aW5nIHRoZSBleHBpcmF0 aW9uIHRpbWUuCkBAIC00OTQsNyArMjMzLDYgQEAKIAogICAgICAgICAgICAgZGVsZXRlIHJlcXVl c3Q7CiAKLSAgICAgICAgICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CiAgICAgICAgICAgICBy ZXR1cm47CiAgICAgICAgIH0gCiAgICAgICAgIC8vIERpZCBub3QgZ2V0IDMwNCByZXNwb25zZSwg Y29udGludWUgYXMgYSByZWd1bGFyIHJlc291cmNlIGxvYWQuCkBAIC01MjUsMTAgKzI2Myw4IEBA CiAgICAgfQogfQogCi12b2lkIExvYWRlcjo6SG9zdDo6ZGlkUmVjZWl2ZURhdGEoU3VicmVzb3Vy Y2VMb2FkZXIqIGxvYWRlciwgY29uc3QgY2hhciogZGF0YSwgaW50IHNpemUpCit2b2lkIExvYWRl cjo6ZGlkUmVjZWl2ZURhdGEoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgY29uc3QgY2hhciog ZGF0YSwgaW50IHNpemUpCiB7Ci0gICAgUmVmUHRyPEhvc3Q+IHByb3RlY3Rvcih0aGlzKTsKLQog ICAgIFJlcXVlc3QqIHJlcXVlc3QgPSBtX3JlcXVlc3RzTG9hZGluZy5nZXQobG9hZGVyKTsKICAg ICBpZiAoIXJlcXVlc3QpCiAgICAgICAgIHJldHVybjsKQEAgLTU1NCwxMCArMjkwLDggQEAKICAg ICAgICAgcmVzb3VyY2UtPmRhdGEobG9hZGVyLT5yZXNvdXJjZURhdGEoKSwgZmFsc2UpOwogfQog ICAgIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShTdWJyZXNv dXJjZUxvYWRlciogbG9hZGVyLCBjb25zdCBjaGFyKiBkYXRhLCBpbnQgc2l6ZSkKK3ZvaWQgTG9h ZGVyOjpkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwg Y29uc3QgY2hhciogZGF0YSwgaW50IHNpemUpCiB7Ci0gICAgUmVmUHRyPEhvc3Q+IHByb3RlY3Rv cih0aGlzKTsKLQogICAgIFJlcXVlc3QqIHJlcXVlc3QgPSBtX3JlcXVlc3RzTG9hZGluZy5nZXQo bG9hZGVyKTsKICAgICBpZiAoIXJlcXVlc3QpCiAgICAgICAgIHJldHVybjsKQEAgLTU2Nyw0MSAr MzAxLDUgQEAKIAogICAgIHJlc291cmNlLT5zZXRTZXJpYWxpemVkQ2FjaGVkTWV0YWRhdGEoZGF0 YSwgc2l6ZSk7CiB9Ci0gICAgCi12b2lkIExvYWRlcjo6SG9zdDo6Y2FuY2VsUGVuZGluZ1JlcXVl c3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBDYWNoZWRSZXNvdXJjZUxvYWRlciog Y2FjaGVkUmVzb3VyY2VMb2FkZXIpCi17Ci0gICAgUmVxdWVzdFF1ZXVlIHJlbWFpbmluZzsKLSAg ICBSZXF1ZXN0UXVldWU6Oml0ZXJhdG9yIGVuZCA9IHJlcXVlc3RzUGVuZGluZy5lbmQoKTsKLSAg ICBmb3IgKFJlcXVlc3RRdWV1ZTo6aXRlcmF0b3IgaXQgPSByZXF1ZXN0c1BlbmRpbmcuYmVnaW4o KTsgaXQgIT0gZW5kOyArK2l0KSB7Ci0gICAgICAgIFJlcXVlc3QqIHJlcXVlc3QgPSAqaXQ7Ci0g ICAgICAgIGlmIChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZUxvYWRlcigpID09IGNhY2hlZFJlc291 cmNlTG9hZGVyKSB7Ci0gICAgICAgICAgICBjYWNoZSgpLT5yZW1vdmUocmVxdWVzdC0+Y2FjaGVk UmVzb3VyY2UoKSk7Ci0gICAgICAgICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZGVjcmVtZW50 UmVxdWVzdENvdW50KHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCkpOwotICAgICAgICAgICAgZGVs ZXRlIHJlcXVlc3Q7Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgcmVtYWluaW5nLmFwcGVu ZChyZXF1ZXN0KTsKLSAgICB9Ci0gICAgcmVxdWVzdHNQZW5kaW5nLnN3YXAocmVtYWluaW5nKTsK LX0KIAotdm9pZCBMb2FkZXI6Okhvc3Q6OmNhbmNlbFJlcXVlc3RzKENhY2hlZFJlc291cmNlTG9h ZGVyKiBjYWNoZWRSZXNvdXJjZUxvYWRlcikKLXsKLSAgICBmb3IgKHVuc2lnbmVkIHAgPSAwOyBw IDw9IEhpZ2g7IHArKykKLSAgICAgICAgY2FuY2VsUGVuZGluZ1JlcXVlc3RzKG1fcmVxdWVzdHNQ ZW5kaW5nW3BdLCBjYWNoZWRSZXNvdXJjZUxvYWRlcik7Ci0KLSAgICBWZWN0b3I8U3VicmVzb3Vy Y2VMb2FkZXIqLCAyNTY+IGxvYWRlcnNUb0NhbmNlbDsKLQotICAgIFJlcXVlc3RNYXA6Oml0ZXJh dG9yIGVuZCA9IG1fcmVxdWVzdHNMb2FkaW5nLmVuZCgpOwotICAgIGZvciAoUmVxdWVzdE1hcDo6 aXRlcmF0b3IgaSA9IG1fcmVxdWVzdHNMb2FkaW5nLmJlZ2luKCk7IGkgIT0gZW5kOyArK2kpIHsK LSAgICAgICAgUmVxdWVzdCogciA9IGktPnNlY29uZDsKLSAgICAgICAgaWYgKHItPmNhY2hlZFJl c291cmNlTG9hZGVyKCkgPT0gY2FjaGVkUmVzb3VyY2VMb2FkZXIpCi0gICAgICAgICAgICBsb2Fk ZXJzVG9DYW5jZWwuYXBwZW5kKGktPmZpcnN0LmdldCgpKTsKLSAgICB9Ci0KLSAgICBmb3IgKHVu c2lnbmVkIGkgPSAwOyBpIDwgbG9hZGVyc1RvQ2FuY2VsLnNpemUoKTsgKytpKSB7Ci0gICAgICAg IFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIgPSBsb2FkZXJzVG9DYW5jZWxbaV07Ci0gICAgICAg IGRpZEZhaWwobG9hZGVyLCB0cnVlKTsKLSAgICB9Ci19Ci0KIH0gLy9uYW1lc3BhY2UgV2ViQ29y ZQpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9sb2dvdXQuaHRt bAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2xv Z291dC5odG1sCShyZXZpc2lvbiA2OTMxMykKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMveG1s aHR0cHJlcXVlc3QvbG9nb3V0Lmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTI0LDcgKzI0LDEyIEBA CiAgICAgLy8gbG9nb3V0Lmh0bWwgZG9lc24ndCBldmVuIGV4aXN0IC0gd2UgZG9uJ3QgbmVlZCB0 byBzZW5kIHRoaXMgcmVxdWVzdCB0byBzZXJ2ZXIuCiAgICAgeGhyLm9wZW4oIkdFVCIsICJyZXNv dXJjZXMvbG9nb3V0L3N1YmRpcmVjdG9yeS9sb2dvdXQuaHRtbCIsIHRydWUsICJsb2dvdXQiLCAi bG9nb3V0Iik7CiAgICAgeGhyLnNlbmQoIiIpOwotICAgIHhoci5hYm9ydCgpOworICAgIHhoci5v bmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxv Z291dCIpLmlubmVySFRNTCA9IGlzQXV0aGVudGljYXRlZCgpID8gIkZBSUwiIDogIlBBU1MiOwor CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgfQogfQogCiBmdW5jdGlvbiBp c0F1dGhlbnRpY2F0ZWQoKQpAQCAtNDQsMTMgKzQ5LDkgQEAKIHIub3BlbigiR0VUIiwgInJlc291 cmNlcy9sb2dvdXQvcmVzb3VyY2UucGhwP2lzQXV0aGVudGljYXRlZCIsIHRydWUpOwogci5vbmxv YWQgPSBmdW5jdGlvbigpIHsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYXN5bmMiKS5p bm5lckhUTUwgPSByLnN0YXR1cyA9PSAyMDAgPyAiUEFTUyIgOiAiRkFJTCI7Ci0KLSAgICBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5ub3RpZnlEb25lKCk7CiB9CiByLnNlbmQoIiIpOwogCiBsb2dvdXQoKTsKLWRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJsb2dvdXQiKS5pbm5lckhUTUwgPSBpc0F1dGhlbnRpY2F0ZWQoKSA/ICJG QUlMIiA6ICJQQVNTIjsKIDwvc2NyaXB0PgogPC9ib2R5PgpJbmRleDogTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNjkz MTMpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwx MiBAQAorMjAxMC0xMC0wNyAgTmF0ZSBDaGFwaW4gIDxqYXBoZXRAY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJld3JpdGUgdGVz dCBmb3IgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3MTY1CisKKyAg ICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2xvZ291dC5odG1sOiBJdCBpcyBubyBs b25nZXIgc2FmZQorICAgICAgICB0byBhc3N1bWUgdGhhdCBhbiBhc3luYyB4aHIgd2lsbCBoYXZl IGFueSBlZmZlY3RzIHN5bmNocm9ub3VzbHkuCisKIDIwMTAtMTAtMDcgIE5pa29sYXMgWmltbWVy bWFubiAgPG56aW1tZXJtYW5uQHJpbS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGlyayBT Y2h1bHplLgo= 72883 2010-11-03 16:32:32 -0700 2010-11-08 08:38:52 -0800 patch #5 (I think) rls.txt text/plain 75708 japhet SW5kZXg6IFdlYktpdC9tYWMvUGx1Z2lucy9XZWJOZXRzY2FwZVBsdWdpblN0cmVhbS5tbQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvbWFjL1BsdWdpbnMvV2ViTmV0c2NhcGVQbHVnaW5TdHJlYW0ubW0J KHJldmlzaW9uIDcxMjU2KQorKysgV2ViS2l0L21hYy9QbHVnaW5zL1dlYk5ldHNjYXBlUGx1Z2lu U3RyZWFtLm1tCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBACiAjaW1wb3J0IDxXZWJD b3JlL0RvY3VtZW50TG9hZGVyLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0ZyYW1lLmg+CiAjaW1wb3J0 IDxXZWJDb3JlL0ZyYW1lTG9hZGVyLmg+CisjaW1wb3J0IDxXZWJDb3JlL1Jlc291cmNlTG9hZFNj aGVkdWxlci5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8 V2ViQ29yZS9XZWJDb3JlT2JqQ0V4dHJhcy5oPgogI2ltcG9ydCA8V2ViQ29yZS9XZWJDb3JlVVJM UmVzcG9uc2UuaD4KQEAgLTI4MiwxMSArMjgzLDcgQEAKICAgICBBU1NFUlQoIW1fZnJhbWVMb2Fk ZXIpOwogICAgIEFTU0VSVCghbV9sb2FkZXIpOwogICAgIAotICAgIG1fbG9hZGVyID0gTmV0c2Nh cGVQbHVnSW5TdHJlYW1Mb2FkZXI6OmNyZWF0ZShjb3JlKFttX3BsdWdpblZpZXcuZ2V0KCkgd2Vi RnJhbWVdKSwgdGhpcyk7Ci0gICAgbV9sb2FkZXItPnNldFNob3VsZEJ1ZmZlckRhdGEoZmFsc2Up OwotICAgIAotICAgIG1fbG9hZGVyLT5kb2N1bWVudExvYWRlcigpLT5hZGRQbHVnSW5TdHJlYW1M b2FkZXIobV9sb2FkZXIuZ2V0KCkpOwotICAgIG1fbG9hZGVyLT5sb2FkKG1fcmVxdWVzdC5nZXQo KSk7CisgICAgbV9sb2FkZXIgPSByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c2NoZWR1bGVQbHVn aW5TdHJlYW1Mb2FkKGNvcmUoW21fcGx1Z2luVmlldy5nZXQoKSB3ZWJGcmFtZV0pLCB0aGlzLCBt X3JlcXVlc3QuZ2V0KCkpOwogfQogCiB2b2lkIFdlYk5ldHNjYXBlUGx1Z2luU3RyZWFtOjpzdG9w KCkKSW5kZXg6IFdlYktpdC9tYWMvUGx1Z2lucy9Ib3N0ZWQvSG9zdGVkTmV0c2NhcGVQbHVnaW5T dHJlYW0ubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L21hYy9QbHVnaW5zL0hvc3RlZC9Ib3N0ZWRO ZXRzY2FwZVBsdWdpblN0cmVhbS5tbQkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJLaXQvbWFjL1Bs dWdpbnMvSG9zdGVkL0hvc3RlZE5ldHNjYXBlUGx1Z2luU3RyZWFtLm1tCSh3b3JraW5nIGNvcHkp CkBAIC0zOSw2ICszOSw3IEBACiAjaW1wb3J0IDxXZWJDb3JlL0RvY3VtZW50TG9hZGVyLmg+CiAj aW1wb3J0IDxXZWJDb3JlL0ZyYW1lLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0ZyYW1lTG9hZGVyLmg+ CisjaW1wb3J0IDxXZWJDb3JlL1Jlc291cmNlTG9hZFNjaGVkdWxlci5oPgogI2ltcG9ydCA8V2Vi Q29yZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8V2ViQ29yZS9XZWJDb3JlVVJMUmVzcG9u c2UuaD4KICNpbXBvcnQgPHd0Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuaD4KQEAgLTIxMywxMSAr MjE0LDcgQEAKICAgICBBU1NFUlQoIW1fZnJhbWVMb2FkZXIpOwogICAgIEFTU0VSVCghbV9sb2Fk ZXIpOwogICAgIAotICAgIG1fbG9hZGVyID0gTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXI6OmNy ZWF0ZShjb3JlKFttX2luc3RhbmNlLT5wbHVnaW5WaWV3KCkgd2ViRnJhbWVdKSwgdGhpcyk7Ci0g ICAgbV9sb2FkZXItPnNldFNob3VsZEJ1ZmZlckRhdGEoZmFsc2UpOwotICAgIAotICAgIG1fbG9h ZGVyLT5kb2N1bWVudExvYWRlcigpLT5hZGRQbHVnSW5TdHJlYW1Mb2FkZXIobV9sb2FkZXIuZ2V0 KCkpOwotICAgIG1fbG9hZGVyLT5sb2FkKG1fcmVxdWVzdC5nZXQoKSk7CisgICAgbV9sb2FkZXIg PSByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c2NoZWR1bGVQbHVnaW5TdHJlYW1Mb2FkKFttX2lu c3RhbmNlLT5wbHVnaW5WaWV3KCkgd2ViRnJhbWVdKSwgdGhpcywgbV9yZXF1ZXN0LmdldCgpKTsK IH0KIAogdm9pZCBIb3N0ZWROZXRzY2FwZVBsdWdpblN0cmVhbTo6c3RvcCgpCkluZGV4OiBXZWJL aXQvbWFjL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL0NoYW5nZUxvZwkocmV2 aXNpb24gNzEyNzUpCisrKyBXZWJLaXQvbWFjL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAt MSwzICsxLDE2IEBACisyMDEwLTExLTAzICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW50 ZXJmYWNlIGNoYW5nZXMgaW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI3MTY1CisKKyAgICAgICAgKiBQbHVnaW5zL0hvc3RlZC9Ib3N0ZWROZXRzY2FwZVBsdWdpblN0 cmVhbS5tbToKKyAgICAgICAgKFdlYktpdDo6SG9zdGVkTmV0c2NhcGVQbHVnaW5TdHJlYW06OnN0 YXJ0KTogTW92ZSBkdXBsaWNhdGUgY29kZSBpbnRvIE5ldHNjYXBlUGx1Z2luU3RyZWFtTG9hZGVy CisgICAgICAgICogUGx1Z2lucy9XZWJOZXRzY2FwZVBsdWdpblN0cmVhbS5tbToKKyAgICAgICAg KFdlYk5ldHNjYXBlUGx1Z2luU3RyZWFtOjpzdGFydCk6IE1vdmUgZHVwbGljYXRlIGNvZGUgaW50 byBOZXRzY2FwZVBsdWdpblN0cmVhbUxvYWRlcgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5t bToKKyAgICAgICAgKC1bV2ViVmlldyBfZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3RzXSk6IFVz ZSByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKSBpbnN0ZWFkIG9mIGNhY2hlKCktPmxvYWRlcigpLgor CiAyMDEwLTExLTAyICBEYW5pZWwgQmF0ZXMgIDxkYmF0ZXNAcmltLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcu bW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0JKHJldmlzaW9u IDcxMjU2KQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0JKHdvcmtpbmcgY29weSkK QEAgLTE0Nyw2ICsxNDcsNyBAQAogI2ltcG9ydCA8V2ViQ29yZS9SZW5kZXJWaWV3Lmg+CiAjaW1w b3J0IDxXZWJDb3JlL1JlbmRlcldpZGdldC5oPgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZUhh bmRsZS5oPgorI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuaD4KICNpbXBv cnQgPFdlYkNvcmUvUnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzLmg+CiAjaW1wb3J0IDxXZWJDb3Jl L1NjaGVtZVJlZ2lzdHJ5Lmg+CiAjaW1wb3J0IDxXZWJDb3JlL1NjcmlwdENvbnRyb2xsZXIuaD4K QEAgLTYyMSw3ICs2MjIsNyBAQAogCiAtICh2b2lkKV9kaXNwYXRjaFBlbmRpbmdMb2FkUmVxdWVz dHMKIHsKLSAgICBjYWNoZSgpLT5sb2FkZXIoKS0+c2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKKyAg ICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKIH0KIAog LSAodm9pZClfcmVnaXN0ZXJEcmFnZ2VkVHlwZXMKSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5leHAu aW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgkocmV2aXNpb24gNzEyNTYp CisrKyBXZWJDb3JlL1dlYkNvcmUuZXhwLmluCSh3b3JraW5nIGNvcHkpCkBAIC00NzYsNiArNDc2 LDggQEAKIF9fWk43V2ViQ29yZTIwU3BhY2VTcGxpdFN0cmluZ0RhdGExMmNyZWF0ZVZlY3RvckV2 CiBfX1pON1dlYkNvcmUyMHByb3RvY29sSXNKYXZhU2NyaXB0RVJLTjNXVEY2U3RyaW5nRQogX19a TjdXZWJDb3JlMjFCYWNrRm9yd2FyZENvbnRyb2xsZXIxMWl0ZW1BdEluZGV4RWkKK19fWk43V2Vi Q29yZTIxUmVzb3VyY2VMb2FkU2NoZWR1bGVyMjBzZXJ2ZVBlbmRpbmdSZXF1ZXN0c0VOUzBfOFBy aW9yaXR5RQorX19aTjdXZWJDb3JlMjFSZXNvdXJjZUxvYWRTY2hlZHVsZXIyNHNjaGVkdWxlUGx1 Z2luU3RyZWFtTG9hZEVQTlNfNUZyYW1lRVBOU18zMk5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVy Q2xpZW50RVJLTlNfMTVSZXNvdXJjZVJlcXVlc3RFCiBfX1pON1dlYkNvcmUyMVBsYXRmb3JtS2V5 Ym9hcmRFdmVudDI0ZGlzYW1iaWd1YXRlS2V5RG93bkV2ZW50RU5TMF80VHlwZUViCiBfX1pON1dl YkNvcmUyMVBsYXRmb3JtS2V5Ym9hcmRFdmVudEMxRVA3TlNFdmVudAogX19aTjdXZWJDb3JlMjFT VkdEb2N1bWVudEV4dGVuc2lvbnMyMXNhbXBsZUFuaW1hdGlvbkF0VGltZUVSS04zV1RGNlN0cmlu Z0VQTlNfMTRTVkdTTUlMRWxlbWVudEVkCkBAIC00OTAsNiArNDkyLDcgQEAKIF9fWk43V2ViQ29y ZTIxbWFpblRocmVhZE5vcm1hbFdvcmxkRXYKIF9fWk43V2ViQ29yZTIxbWFya2VyVGV4dEZvckxp c3RJdGVtRVBOU183RWxlbWVudEUKIF9fWk43V2ViQ29yZTIxcmVwb3J0VGhyZWFkVmlvbGF0aW9u RVBLY05TXzIwVGhyZWFkVmlvbGF0aW9uUm91bmRFCitfX1pON1dlYkNvcmUyMXJlc291cmNlTG9h ZFNjaGVkdWxlckV2CiBfX1pON1dlYkNvcmUyMXNldFBsYXRmb3JtU3RyYXRlZ2llc0VQTlNfMThQ bGF0Zm9ybVN0cmF0ZWdpZXNFCiBfX1pON1dlYkNvcmUyMlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQy NmNhblN1c3BlbmRBY3RpdmVET01PYmplY3RzRXYKIF9fWk43V2ViQ29yZTIyYXBwbGljYXRpb25J c0FwcGxlTWFpbEV2CkBAIC01MjIsNyArNTI1LDYgQEAKIF9fWk43V2ViQ29yZTI1YWRkTGFuZ3Vh Z2VDaGFuZ2VPYnNlcnZlckVQdlBGdlMwX0UKIF9fWk43V2ViQ29yZTI1Y29udGV4dE1lbnVJdGVt VGFnT3V0bGluZUV2CiBfX1pON1dlYkNvcmUyNkNTU011dGFibGVTdHlsZURlY2xhcmF0aW9uQzFF dgotX19aTjdXZWJDb3JlMjZOZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlcjZjcmVhdGVFUE5TXzVG cmFtZUVQTlNfMzJOZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlckNsaWVudEUKIF9fWk43V2ViQ29y ZTI2VXNlclR5cGluZ0dlc3R1cmVJbmRpY2F0b3IyN3Byb2Nlc3NpbmdVc2VyVHlwaW5nR2VzdHVy ZUV2CiBfX1pON1dlYkNvcmUyNlVzZXJUeXBpbmdHZXN0dXJlSW5kaWNhdG9yMjhmb2N1c2VkRWxl bWVudEF0R2VzdHVyZVN0YXJ0RXYKIF9fWk43V2ViQ29yZTI2Y29udGV4dE1lbnVJdGVtVGFnRm9u dE1lbnVFdgpAQCAtNjk5LDcgKzcwMSw2IEBACiBfX1pON1dlYkNvcmU2RWRpdG9yN0NvbW1hbmRD MUV2CiBfX1pON1dlYkNvcmU2RWRpdG9yN2NvbW1hbmRFUktOM1dURjZTdHJpbmdFCiBfX1pON1dl YkNvcmU2RWRpdG9yN291dGRlbnRFdgotX19aTjdXZWJDb3JlNkxvYWRlcjIwc2VydmVQZW5kaW5n UmVxdWVzdHNFTlMwXzhQcmlvcml0eUUKIF9fWk43V2ViQ29yZTZXaWRnZXQxMnNldEZyYW1lUmVj dEVSS05TXzdJbnRSZWN0RQogX19aTjdXZWJDb3JlNldpZGdldDE2cmVtb3ZlRnJvbVBhcmVudEV2 CiBfX1pON1dlYkNvcmU2V2lkZ2V0MTdmcmFtZVJlY3RzQ2hhbmdlZEV2CkluZGV4OiBXZWJDb3Jl L2RvbS9Db250YWluZXJOb2RlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Db250YWlu ZXJOb2RlLmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL2RvbS9Db250YWluZXJOb2Rl LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzUsMTEgKzM1LDExIEBACiAjaW5jbHVkZSAiSW5saW5l VGV4dEJveC5oIgogI2luY2x1ZGUgIkluc3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgogI2luY2x1 ZGUgIk11dGF0aW9uRXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIK ICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUmVuZGVyQm94LmgiCiAjaW5jbHVkZSAiUmVu ZGVyVGhlbWUuaCIKICNpbmNsdWRlICJSb290SW5saW5lQm94LmgiCi0jaW5jbHVkZSAibG9hZGVy LmgiCiAjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5o PgogCkBAIC02NTUsNyArNjU1LDcgQEAKICAgICAgICAgICAgICAgICBzX3Nob3VsZFJlRW5hYmxl TWVtb3J5Q2FjaGVDYWxsc0FmdGVyQXR0YWNoID0gdHJ1ZTsKICAgICAgICAgICAgIH0KICAgICAg ICAgfQotICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+c3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygp OworICAgICAgICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c3VzcGVuZFBlbmRpbmdSZXF1ZXN0 cygpOwogICAgIH0KICAgICArK3NfYXR0YWNoRGVwdGg7CiB9CkBAIC02NzAsNyArNjcwLDcgQEAK ICAgICAgICAgICAgIGlmIChQYWdlKiBwYWdlID0gZG9jdW1lbnQoKS0+cGFnZSgpKQogICAgICAg ICAgICAgICAgIHBhZ2UtPnNldE1lbW9yeUNhY2hlQ2xpZW50Q2FsbHNFbmFibGVkKHRydWUpOwog ICAgICAgICB9Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5yZXN1bWVQZW5kaW5nUmVxdWVz dHMoKTsKKyAgICAgICAgcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPnJlc3VtZVBlbmRpbmdSZXF1 ZXN0cygpOwogICAgIH0KICAgICAtLXNfYXR0YWNoRGVwdGg7CiB9CkluZGV4OiBXZWJDb3JlL3Bs dWdpbnMvUGx1Z2luU3RyZWFtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsdWdpbnMvUGx1 Z2luU3RyZWFtLmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL3BsdWdpbnMvUGx1Z2lu U3RyZWFtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKICNpbmNsdWRlICJQbHVnaW5EZWJ1Zy5o IgorI2luY2x1ZGUgIlJlc291cmNlTG9hZFNjaGVkdWxlci5oIgogI2luY2x1ZGUgIlNoYXJlZEJ1 ZmZlci5oIgogI2luY2x1ZGUgIlN1YnJlc291cmNlTG9hZGVyLmgiCiAjaW5jbHVkZSA8U3RyaW5n RXh0cmFzLmg+CkBAIC05MywxMiArOTQsNyBAQAogdm9pZCBQbHVnaW5TdHJlYW06OnN0YXJ0KCkK IHsKICAgICBBU1NFUlQoIW1fbG9hZE1hbnVhbGx5KTsKLQotICAgIG1fbG9hZGVyID0gTmV0c2Nh cGVQbHVnSW5TdHJlYW1Mb2FkZXI6OmNyZWF0ZShtX2ZyYW1lLCB0aGlzKTsKLQotICAgIG1fbG9h ZGVyLT5zZXRTaG91bGRCdWZmZXJEYXRhKGZhbHNlKTsKLSAgICBtX2xvYWRlci0+ZG9jdW1lbnRM b2FkZXIoKS0+YWRkUGx1Z0luU3RyZWFtTG9hZGVyKG1fbG9hZGVyLmdldCgpKTsKLSAgICBtX2xv YWRlci0+bG9hZChtX3Jlc291cmNlUmVxdWVzdCk7CisgICAgbV9sb2FkZXIgPSByZXNvdXJjZUxv YWRTY2hlZHVsZXIoKS0+c2NoZWR1bGVQbHVnaW5TdHJlYW1Mb2FkKG1fZnJhbWUsIHRoaXMsIG1f cmVzb3VyY2VSZXF1ZXN0KTsKIH0KIAogdm9pZCBQbHVnaW5TdHJlYW06OnN0b3AoKQpJbmRleDog V2ViQ29yZS9XZWJDb3JlLnBybwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNvcmUucHJvCShy ZXZpc2lvbiA3MTI1NikKKysrIFdlYkNvcmUvV2ViQ29yZS5wcm8JKHdvcmtpbmcgY29weSkKQEAg LTEwNjQsNiArMTA2NCw3IEBACiAgICAgbG9hZGVyL1JlcXVlc3QuY3BwIFwKICAgICBsb2FkZXIv UmVzb3VyY2VMb2FkZXIuY3BwIFwKICAgICBsb2FkZXIvUmVzb3VyY2VMb2FkTm90aWZpZXIuY3Bw IFwKKyAgICBsb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBcCiAgICAgbG9hZGVyL1Np bmtEb2N1bWVudC5jcHAgXAogICAgIGxvYWRlci9TdWJmcmFtZUxvYWRlci5jcHAgXAogICAgIGxv YWRlci9TdWJyZXNvdXJjZUxvYWRlci5jcHAgXApJbmRleDogV2ViQ29yZS9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDcxMjc1KQorKysgV2ViQ29y ZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw5MCBAQAorMjAxMC0xMS0wMyAg TmF0ZSBDaGFwaW4gIDxqYXBoZXRAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5lZWQgYSBzaG9ydCBkZXNjcmlwdGlvbiBhbmQg YnVnIFVSTCAoT09QUyEpCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAgICAg ICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAg KiBXZWJDb3JlLmV4cC5pbjoKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogV2Vi Q29yZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2o6CisgICAg ICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGRvbS9D b250YWluZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5lck5vZGU6OnN1c3Bl bmRQb3N0QXR0YWNoQ2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRhaW5lck5vZGU6 OnJlc3VtZVBvc3RBdHRhY2hDYWxsYmFja3MpOgorICAgICAgICAqIGxvYWRlci9Eb2N1bWVudFRo cmVhZGFibGVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRUaHJlYWRhYmxl TG9hZGVyOjpsb2FkUmVxdWVzdCk6CisgICAgICAgICogbG9hZGVyL01haW5SZXNvdXJjZUxvYWRl ci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNYWluUmVzb3VyY2VMb2FkZXI6OmxvYWROb3cpOgor ICAgICAgICAqIGxvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHA6CisgICAgICAg IChXZWJDb3JlOjpOZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlcjo6Y3JlYXRlKToKKyAgICAgICAg KiBsb2FkZXIvTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXIuaDoKKyAgICAgICAgKiBsb2FkZXIv UmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNv dXJjZUxvYWRTY2hlZHVsZXI6Omhvc3RGb3JVUkwpOgorICAgICAgICAoV2ViQ29yZTo6cmVzb3Vy Y2VMb2FkU2NoZWR1bGVyKTogUmV0dXJucyB0aGUgc2luZ2xlIFJlc291cmNlTG9hZFNjaGVkdWxl ciBpbnN0YW5jZQorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpSZXNv dXJjZUxvYWRTY2hlZHVsZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1 bGVyOjpzY2hlZHVsZVN1YnJlc291cmNlTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6OnNjaGVkdWxlUGx1Z2luU3RyZWFtTG9hZCk6CisgICAgICAgIChXZWJD b3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmFkZE1haW5SZXNvdXJjZUxvYWQpOgorICAgICAg ICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzY2hlZHVsZUxvYWQpOgorICAgICAg ICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpyZW1vdmUpOgorICAgICAgICAoV2Vi Q29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpjcm9zc09yaWdpblJlZGlyZWN0UmVjZWl2ZWQp OgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdS ZXF1ZXN0cyk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnN1c3Bl bmRQZW5kaW5nUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1 bGVyOjpyZXN1bWVQZW5kaW5nUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VM b2FkU2NoZWR1bGVyOjpzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKToKKyAgICAgICAgKFdl YkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6cmVxdWVzdFRpbWVyRmlyZWQpOgorICAgICAg ICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjphc3NlcnRMb2FkZXJCZWluZ0NvdW50 ZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5mb3Jt YXRpb246OmFzc2VydExvYWRlckJlaW5nQ291bnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNv dXJjZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6SG9zdEluZm9ybWF0aW9uKToKKyAg ICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9zdEluZm9ybWF0aW9uOjp+ SG9zdEluZm9ybWF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZFNjaGVkdWxl cjo6SG9zdEluZm9ybWF0aW9uOjpzY2hlZHVsZSk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJj ZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6YWRkTG9hZEluUHJvZ3Jlc3MpOgorICAg ICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5mb3JtYXRpb246OnJl bW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZv cm1hdGlvbjo6aGFzUmVxdWVzdHMpOgorICAgICAgICAqIGxvYWRlci9SZXNvdXJjZUxvYWRTY2hl ZHVsZXIuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6 Okhvc3RJbmZvcm1hdGlvbjo6bmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRT Y2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6bGltaXRSZXF1ZXN0cyk6CisgICAgICAgIChXZWJD b3JlOjpSZXNvdXJjZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6cmVxdWVzdHNQZW5k aW5nKToKKyAgICAgICAgKiBsb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVzb3VyY2VMb2FkZXI6OnJlbGVhc2VSZXNvdXJjZXMpOiBSZW1vdmUgdGhpcyBmcm9t IFJlc291cmNlTG9hZFNjaGVkdWxlcidzIGNvdW50aW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVz b3VyY2VMb2FkZXI6OmxvYWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VMb2FkZXI6OnN0 YXJ0KTogQ3JlYXRlIHRoZSBSZXNvdXJjZUhhbmRsZSwgY2FsbGVkIGJ5IFJlc291cmNlTG9hZFNj aGVkdWxlci4KKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZGVyOjp3aWxsU2VuZFJlcXVl c3QpOiBFbnN1cmUgUmVzb3VyY2VMb2FkU2NoZWR1bGVyIGNvdW50cyByZWRpcmVjdHMKKyAgICAg ICAgICAgIGNvcnJlY3RseS4KKyAgICAgICAgKiBsb2FkZXIvUmVzb3VyY2VMb2FkZXIuaDoKKyAg ICAgICAgKFdlYkNvcmU6OlJlc291cmNlTG9hZGVyOjp1cmwpOgorICAgICAgICAqIGxvYWRlci9p Y29uL0ljb25Mb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SWNvbkxvYWRlcjo6c3RhcnRM b2FkaW5nKToKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmNwcDogTW92ZSBzY2hlZHVsaW5nIHRv IFJlc291cmNlTG9hZFNjaGVkdWxlciwgcmVtb3ZlIEhvc3Qgc3ViY2xhc3MKKyAgICAgICAgICAg IGFuZCBtYWtlIExvYWRlciB0aGUgU3VicmVzb3VyY2VMb2FkZXJDbGllbnQgaW5zdGVhZC4KKyAg ICAgICAgKFdlYkNvcmU6OmRldGVybWluZVByaW9yaXR5KToKKyAgICAgICAgKFdlYkNvcmU6Okxv YWRlcjo6bG9hZCk6IFNjaGVkdWxlIHRoZSBjcmVhdGlvbiBvZiB0aGUgUmVzb3VyY2VIYW5kbGUs IHJhdGhlciB0aGFuCisgICAgICAgICAgICBkb2luZyBpdCBpbW1lZGlhdGVseS4KKyAgICAgICAg KFdlYkNvcmU6OkxvYWRlcjo6Y2FuY2VsUmVxdWVzdHMpOgorICAgICAgICAoV2ViQ29yZTo6TG9h ZGVyOjpkaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkxvYWRlcjo6ZGlkRmFp bCk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6OmRpZFJlY2VpdmVSZXNwb25zZSk6CisgICAg ICAgIChXZWJDb3JlOjpMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6 OkxvYWRlcjo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKToKKyAgICAgICAgKiBsb2FkZXIvbG9h ZGVyLmg6CisgICAgICAgICogcGFnZS9FdmVudFNvdXJjZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpFdmVudFNvdXJjZTo6Y29ubmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFNvdXJjZTo6 ZW5kUmVxdWVzdCk6CisgICAgICAgICogcGx1Z2lucy9QbHVnaW5TdHJlYW0uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6UGx1Z2luU3RyZWFtOjpzdGFydCk6CisgICAgICAgICogeG1sL1hNTEh0dHBS ZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpYTUxIdHRwUmVx dWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpYTUxIdHRwUmVxdWVzdDo6flhNTEh0dHBSZXF1ZXN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpjcmVhdGVSZXF1ZXN0KToKKyAg ICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpkaWRGYWlsKToKKyAgICAgICAgKFdlYkNv cmU6OlhNTEh0dHBSZXF1ZXN0OjpkaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKiB4bWwvWE1M SHR0cFJlcXVlc3QuaDoKKwogMjAxMC0xMS0wMyAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29n bGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUnVzc2VsbC4KSW5kZXg6IFdl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJD b3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC0yMzk4 MCw2ICsyMzk4MCwxNCBAQAogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCisJCQkJUmVs YXRpdmVQYXRoPSIuLlxsb2FkZXJcUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCINCisJCQkJPg0K KwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGxvYWRlclwgUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCiAJ CQkJUmVsYXRpdmVQYXRoPSIuLlxsb2FkZXJcU2lua0RvY3VtZW50LmNwcCINCiAJCQkJPg0KIAkJ CTwvRmlsZT4NCkluZGV4OiBXZWJDb3JlL3BhZ2UvRXZlbnRTb3VyY2UuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGFnZS9FdmVudFNvdXJjZS5jcHAJKHJldmlzaW9uIDcxMjU2KQorKysgV2Vi Q29yZS9wYWdlL0V2ZW50U291cmNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDkgKzExNiw2 IEBACiAgICAgbV9sb2FkZXIgPSBUaHJlYWRhYmxlTG9hZGVyOjpjcmVhdGUoc2NyaXB0RXhlY3V0 aW9uQ29udGV4dCgpLCB0aGlzLCByZXF1ZXN0LCBvcHRpb25zKTsKIAogICAgIG1fcmVxdWVzdElu RmxpZ2h0ID0gdHJ1ZTsKLQotICAgIGlmICghc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc1dv cmtlckNvbnRleHQoKSkKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVz dEluRmxpZ2h0KG1fdXJsKTsKIH0KIAogdm9pZCBFdmVudFNvdXJjZTo6ZW5kUmVxdWVzdCgpCkBA IC0xMjgsOSArMTI1LDYgQEAKICAgICBpZiAoIW1fZmFpbFNpbGVudGx5KQogICAgICAgICBkaXNw YXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLmVycm9yRXZlbnQsIGZhbHNlLCBm YWxzZSkpOwogCi0gICAgaWYgKCFzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyQ29u dGV4dCgpKQotICAgICAgICBjYWNoZSgpLT5sb2FkZXIoKS0+bm9uQ2FjaGVSZXF1ZXN0Q29tcGxl dGUobV91cmwpOwotCiAgICAgaWYgKG1fc3RhdGUgIT0gQ0xPU0VEKQogICAgICAgICBzY2hlZHVs ZVJlY29ubmVjdCgpOwogICAgIGVsc2UKSW5kZXg6IFdlYkNvcmUvR05VbWFrZWZpbGUuYW0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQkocmV2aXNpb24gNzEyNTYpCisrKyBX ZWJDb3JlL0dOVW1ha2VmaWxlLmFtCSh3b3JraW5nIGNvcHkpCkBAIC0xOTg2LDYgKzE5ODYsOCBA QAogCVdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmggXAogCVdlYkNvcmUvbG9hZGVyL1Jl c291cmNlTG9hZE5vdGlmaWVyLmNwcCBcCiAJV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkTm90 aWZpZXIuaCBcCisJV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBcCisJ V2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggXAogCVdlYkNvcmUvbG9hZGVy L1NpbmtEb2N1bWVudC5jcHAgXAogCVdlYkNvcmUvbG9hZGVyL1NpbmtEb2N1bWVudC5oIFwKIAlX ZWJDb3JlL2xvYWRlci9TdWJmcmFtZUxvYWRlci5jcHAgXApJbmRleDogV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHJldmlzaW9uIDcxMjU2 KQorKysgV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtpbmcgY29weSkKQEAgLTIwOTMsNiArMjA5 Myw4IEBACiAgICAgICAgICAgICAnbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgnLAogICAgICAgICAg ICAgJ2xvYWRlci9SZXNvdXJjZUxvYWROb3RpZmllci5jcHAnLAogICAgICAgICAgICAgJ2xvYWRl ci9SZXNvdXJjZUxvYWROb3RpZmllci5oJywKKyAgICAgICAgICAgICdsb2FkZXIvUmVzb3VyY2VM b2FkU2NoZWR1bGVyLmNwcCcsCisgICAgICAgICAgICAnbG9hZGVyL1Jlc291cmNlTG9hZFNjaGVk dWxlci5oJywKICAgICAgICAgICAgICdsb2FkZXIvU2lua0RvY3VtZW50LmNwcCcsCiAgICAgICAg ICAgICAnbG9hZGVyL1NpbmtEb2N1bWVudC5oJywKICAgICAgICAgICAgICdsb2FkZXIvU3ViZnJh bWVMb2FkZXIuY3BwJywKSW5kZXg6IFdlYkNvcmUvQ01ha2VMaXN0cy50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL0NN YWtlTGlzdHMudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xMTY4LDYgKzExNjgsNyBAQAogICAgIGxv YWRlci9OYXZpZ2F0aW9uU2NoZWR1bGVyLmNwcAogICAgIGxvYWRlci9SZXF1ZXN0LmNwcAogICAg IGxvYWRlci9SZXNvdXJjZUxvYWROb3RpZmllci5jcHAKKyAgICBsb2FkZXIvUmVzb3VyY2VMb2Fk U2NoZWR1bGVyLmNwcAogICAgIGxvYWRlci9SZXNvdXJjZUxvYWRlci5jcHAKICAgICBsb2FkZXIv U2lua0RvY3VtZW50LmNwcAogICAgIGxvYWRlci9TdWJmcmFtZUxvYWRlci5jcHAKSW5kZXg6IFdl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiA3MTI1NikK KysrIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNv cHkpCkBAIC01MzE5LDYgKzUzMTksOCBAQAogCQlEMDg2RkU5OTA5RDUzQUFCMDA1QkM3NEQgLyog VW5saW5rQ29tbWFuZC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBEMDg2RkU5NzA5RDUzQUFCMDA1QkM3NEQgLyogVW5saW5rQ29tbWFuZC5jcHAgKi87 IH07CiAJCUQwQjA1NTY4MDlDNjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFuZC5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDBCMDU1NjYwOUM2 NzAwMTAwMzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmggKi87IH07CiAJCUQwQjA1NTY5MDlD NjcwMDEwMDMwN0U0MyAvKiBDcmVhdGVMaW5rQ29tbWFuZC5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEMEIwNTU2NzA5QzY3MDAxMDAzMDdFNDMgLyog Q3JlYXRlTGlua0NvbW1hbmQuY3BwICovOyB9OworCQlEMENFNThGODEyNUU0Q0MyMDBGM0YxOTkg LyogUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEQwQ0U1OEY2MTI1RTRDQzIwMEYzRjE5OSAvKiBSZXNvdXJjZUxv YWRTY2hlZHVsZXIuY3BwICovOyB9OworCQlEMENFNThGOTEyNUU0Q0MyMDBGM0YxOTkgLyogUmVz b3VyY2VMb2FkU2NoZWR1bGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBEMENFNThGNzEyNUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VMb2FkU2NoZWR1 bGVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJ RDBGRjJBNUQxMUY4QzQ1QTAwN0U3NEUwIC8qIFBpbmdMb2FkZXIuY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRDBGRjJBNUIxMUY4QzQ1QTAwN0U3NEUw IC8qIFBpbmdMb2FkZXIuY3BwICovOyB9OwogCQlEMEZGMkE1RTExRjhDNDVBMDA3RTc0RTAgLyog UGluZ0xvYWRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRDBGRjJBNUMxMUY4QzQ1QTAwN0U3NEUwIC8qIFBpbmdMb2FkZXIuaCAqLzsgfTsKIAkJRDIz Q0E1NUQwQUIwRUFBRTAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNlcHRpb24uaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQyM0NBNTVDMEFCMEVBQUUwMDUxMDhB NSAvKiBKU1JhbmdlRXhjZXB0aW9uLmggKi87IH07CkBAIC0xMTM2NSw2ICsxMTM2Nyw4IEBACiAJ CUQwODZGRTk3MDlENTNBQUIwMDVCQzc0RCAvKiBVbmxpbmtDb21tYW5kLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVubGlua0NvbW1hbmQuY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlEMEIwNTU2NjA5QzY3MDAxMDAzMDdFNDMgLyogQ3JlYXRlTGlu a0NvbW1hbmQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ3JlYXRlTGlua0Nv bW1hbmQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDBCMDU1NjcwOUM2NzAwMTAw MzA3RTQzIC8qIENyZWF0ZUxpbmtDb21tYW5kLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IENyZWF0ZUxpbmtDb21tYW5kLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJRDBDRTU4RjYxMjVFNENDMjAwRjNGMTk5IC8qIFJlc291cmNlTG9hZFNjaGVkdWxl ci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZXNvdXJjZUxvYWRT Y2hlZHVsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlEMENFNThGNzEyNUU0 Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IFJlc291cmNlTG9hZFNjaGVkdWxlci5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlEMEZGMkE1QjExRjhDNDVBMDA3RTc0RTAgLyogUGluZ0xvYWRlci5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQaW5nTG9hZGVyLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDBGRjJBNUMxMUY4QzQ1QTAwN0U3NEUwIC8qIFBp bmdMb2FkZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGluZ0xvYWRlci5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMjNDQTU0ODBBQjBFOTgzMDA1MTA4QTUg LyogUmFuZ2VFeGNlcHRpb24uaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBSYW5nZUV4Y2Vw dGlvbi5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xNzI4MCw2ICsxNzI4NCw4 IEBACiAJCQkJNjU2RDM3MjcwQURCQTVERTAwQTQ1NTREIC8qIFJlc291cmNlTG9hZGVyLmggKi8s CiAJCQkJOTczRTMyNTQxMDg4M0I3QzAwNUJDNDkzIC8qIFJlc291cmNlTG9hZE5vdGlmaWVyLmNw cCAqLywKIAkJCQk5NzNFMzI1NTEwODgzQjdDMDA1QkM0OTMgLyogUmVzb3VyY2VMb2FkTm90aWZp ZXIuaCAqLywKKwkJCQlEMENFNThGNjEyNUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VMb2FkU2No ZWR1bGVyLmNwcCAqLywKKwkJCQlEMENFNThGNzEyNUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VM b2FkU2NoZWR1bGVyLmggKi8sCiAJCQkJNTEzMjdENUYxMUEzM0EyQjAwNEY5RDY1IC8qIFNpbmtE b2N1bWVudC5jcHAgKi8sCiAJCQkJNTEzMjdENUUxMUEzM0EyQjAwNEY5RDY1IC8qIFNpbmtEb2N1 bWVudC5oICovLAogCQkJCUQwMDBFRDI1MTFDMUI5Q0QwMEM0NzcyNiAvKiBTdWJmcmFtZUxvYWRl ci5jcHAgKi8sCkBAIC0yMDY1MSw2ICsyMDY1Nyw3IEBACiAJCQkJNTE0Qzc2N0IwQ0U5MjNBMTAw N0VGM0NEIC8qIFJlc291cmNlSGFuZGxlSW50ZXJuYWwuaCBpbiBIZWFkZXJzICovLAogCQkJCTY1 NkQzNzNGMEFEQkE1REUwMEE0NTU0RCAvKiBSZXNvdXJjZUxvYWRlci5oIGluIEhlYWRlcnMgKi8s CiAJCQkJOTczRTMyNTcxMDg4M0I3QzAwNUJDNDkzIC8qIFJlc291cmNlTG9hZE5vdGlmaWVyLmgg aW4gSGVhZGVycyAqLywKKwkJCQlEMENFNThGOTEyNUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VM b2FkU2NoZWR1bGVyLmggaW4gSGVhZGVycyAqLywKIAkJCQk4QTgxQkY4NTExRENGRDkwMDBEQTJC OTggLyogUmVzb3VyY2VMb2FkVGltaW5nLmggaW4gSGVhZGVycyAqLywKIAkJCQk0OTI4NjM5OTEy NTNCOEZDMDBGNzkyRDYgLyogUmVzb3VyY2VSYXdIZWFkZXJzLmggaW4gSGVhZGVycyAqLywKIAkJ CQk1MTRDNzY1MjBDRTkyMzRFMDA3RUYzQ0QgLyogUmVzb3VyY2VSZXF1ZXN0LmggaW4gSGVhZGVy cyAqLywKQEAgLTIzODI4LDYgKzIzODM1LDcgQEAKIAkJCQk5M0YxOUIwNTA4MjQ1RTU5MDAxRTlB QkMgLyogWFNMVFByb2Nlc3NvckxpYnhzbHQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTFCRTUx MkQwQ0Y2QzUxMjAwMkVBOTU5IC8qIFhTTFRVbmljb2RlU29ydC5jcHAgaW4gU291cmNlcyAqLywK IAkJCQk5N0RENEQ4NjBGREY0RDZFMDBFQ0Y5QTQgLyogWFNTQXVkaXRvci5jcHAgaW4gU291cmNl cyAqLywKKwkJCQlEMENFNThGODEyNUU0Q0MyMDBGM0YxOTkgLyogUmVzb3VyY2VMb2FkU2NoZWR1 bGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9z dHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3Qu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAkocmV2aXNp b24gNzEyNTYpCisrKyBXZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTE3OCw3ICsxNzgsNiBAQAogICAgICwgbV91cGxvYWRFdmVudHNBbGxvd2VkKHRydWUp CiAgICAgLCBtX3VwbG9hZENvbXBsZXRlKGZhbHNlKQogICAgICwgbV9zYW1lT3JpZ2luUmVxdWVz dCh0cnVlKQotICAgICwgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0KGZhbHNlKQogICAgICwg bV9yZWNlaXZlZExlbmd0aCgwKQogICAgICwgbV9sYXN0U2VuZExpbmVOdW1iZXIoMCkKICAgICAs IG1fZXhjZXB0aW9uQ29kZSgwKQpAQCAtMTkyLDEwICsxOTEsNiBAQAogCiBYTUxIdHRwUmVxdWVz dDo6flhNTEh0dHBSZXF1ZXN0KCkKIHsKLSAgICBpZiAobV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1 ZXN0KSB7Ci0gICAgICAgIGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RDb21wbGV0 ZShtX3VybCk7Ci0gICAgICAgIG1fZGlkVGVsbExvYWRlckFib3V0UmVxdWVzdCA9IGZhbHNlOwot ICAgIH0KICAgICBpZiAobV91cGxvYWQpCiAgICAgICAgIG1fdXBsb2FkLT5kaXNjb25uZWN0WE1M SHR0cFJlcXVlc3QoKTsKIApAQCAtNTk4LDE2ICs1OTMsNiBAQAogICAgICAgICAgICAgLy8gYSBy ZXF1ZXN0IGlzIGluIHByb2dyZXNzIGJlY2F1c2Ugd2UgbmVlZCB0byBrZWVwIHRoZSBsaXN0ZW5l cnMgYWxpdmUsCiAgICAgICAgICAgICAvLyBhbmQgdGhleSBhcmUgcmVmZXJlbmNlZCBieSB0aGUg SmF2YVNjcmlwdCB3cmFwcGVyLgogICAgICAgICAgICAgc2V0UGVuZGluZ0FjdGl2aXR5KHRoaXMp OwotCi0gICAgICAgICAgICAvLyBGb3Igbm93IHdlIHNob3VsZCBvbmx5IGJhbGFuY2UgdGhlIG5v bkNhY2hlZCByZXF1ZXN0IGNvdW50IGZvciBtYWluLXRocmVhZCBYSFJzIGFuZCBub3QKLSAgICAg ICAgICAgIC8vIFdvcmtlciBYSFJzLCBhcyB0aGUgQ2FjaGUgaXMgbm90IHRocmVhZC1zYWZlLgot ICAgICAgICAgICAgLy8gVGhpcyB3aWxsIGJlY29tZSBpcnJlbGV2YW50IGFmdGVyIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzE2NSBpcyByZXNvbHZlZC4KLSAgICAg ICAgICAgIGlmICghc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc1dvcmtlckNvbnRleHQoKSkg ewotICAgICAgICAgICAgICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0gICAgICAgICAgICAg ICAgQVNTRVJUKCFtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QpOwotICAgICAgICAgICAgICAg IGNhY2hlKCktPmxvYWRlcigpLT5ub25DYWNoZVJlcXVlc3RJbkZsaWdodChtX3VybCk7Ci0gICAg ICAgICAgICAgICAgbV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gdHJ1ZTsKLSAgICAgICAg ICAgIH0KICAgICAgICAgfQogICAgIH0gZWxzZQogICAgICAgICBUaHJlYWRhYmxlTG9hZGVyOjps b2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgcmVxdWVz dCwgKnRoaXMsIG9wdGlvbnMpOwpAQCAtODk5LDEwICs4ODQsNiBAQAogCiB2b2lkIFhNTEh0dHBS ZXF1ZXN0OjpkaWRGYWlsKGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9yKQogewotICAgIGlmICht X2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QpIHsKLSAgICAgICAgY2FjaGUoKS0+bG9hZGVyKCkt Pm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1fdXJsKTsKLSAgICAgICAgbV9kaWRUZWxsTG9hZGVy QWJvdXRSZXF1ZXN0ID0gZmFsc2U7Ci0gICAgfQogCiAgICAgLy8gSWYgd2UgYXJlIGFscmVhZHkg aW4gYW4gZXJyb3Igc3RhdGUsIGZvciBpbnN0YW5jZSB3ZSBjYWxsZWQgYWJvcnQoKSwgYmFpbCBv dXQgZWFybHkuCiAgICAgaWYgKG1fZXJyb3IpCkBAIC05MjksMTEgKzkxMCw2IEBACiAKIHZvaWQg WE1MSHR0cFJlcXVlc3Q6OmRpZEZpbmlzaExvYWRpbmcodW5zaWduZWQgbG9uZyBpZGVudGlmaWVy KQogewotICAgIGlmIChtX2RpZFRlbGxMb2FkZXJBYm91dFJlcXVlc3QpIHsKLSAgICAgICAgY2Fj aGUoKS0+bG9hZGVyKCktPm5vbkNhY2hlUmVxdWVzdENvbXBsZXRlKG1fdXJsKTsKLSAgICAgICAg bV9kaWRUZWxsTG9hZGVyQWJvdXRSZXF1ZXN0ID0gZmFsc2U7Ci0gICAgfQotCiAgICAgaWYgKG1f ZXJyb3IpCiAgICAgICAgIHJldHVybjsKIApJbmRleDogV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVl c3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5oCShyZXZpc2lv biA3MTI1NikKKysrIFdlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmgJKHdvcmtpbmcgY29weSkK QEAgLTE4Niw3ICsxODYsNiBAQAogICAgIGJvb2wgbV91cGxvYWRDb21wbGV0ZTsKIAogICAgIGJv b2wgbV9zYW1lT3JpZ2luUmVxdWVzdDsKLSAgICBib29sIG1fZGlkVGVsbExvYWRlckFib3V0UmVx dWVzdDsKIAogICAgIC8vIFVzZWQgZm9yIG9ucHJvZ3Jlc3MgdHJhY2tpbmcKICAgICBsb25nIGxv bmcgbV9yZWNlaXZlZExlbmd0aDsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5oCShyZXZpc2lvbiA3MTI1NikKKysrIFdl YkNvcmUvbG9hZGVyL2xvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMyw5NCArMjMsMzUgQEAK ICNkZWZpbmUgbG9hZGVyX2gKIAogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKLSNpbmNs dWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlN1YnJlc291cmNlTG9hZGVyLmgiCiAj aW5jbHVkZSAiU3VicmVzb3VyY2VMb2FkZXJDbGllbnQuaCIKLSNpbmNsdWRlICJUaW1lci5oIgot I2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVk ZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQXRvbWljU3RyaW5nLmg+ Ci0jaW5jbHVkZSA8d3RmL3RleHQvQXRvbWljU3RyaW5nSW1wbC5oPgorI2luY2x1ZGUgPHd0Zi9S ZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgY2xhc3MgQ2FjaGVkUmVzb3Vy Y2U7CiAgICAgY2xhc3MgQ2FjaGVkUmVzb3VyY2VMb2FkZXI7Ci0gICAgY2xhc3MgS1VSTDsKICAg ICBjbGFzcyBSZXF1ZXN0OwogCi0gICAgY2xhc3MgTG9hZGVyIDogcHVibGljIE5vbmNvcHlhYmxl IHsKKyAgICBjbGFzcyBMb2FkZXIgOiBwdWJsaWMgTm9uY29weWFibGUsIHByaXZhdGUgU3VicmVz b3VyY2VMb2FkZXJDbGllbnQgewogICAgIHB1YmxpYzoKLSAgICAgICAgTG9hZGVyKCk7CiAgICAg ICAgIH5Mb2FkZXIoKTsKIAogICAgICAgICB2b2lkIGxvYWQoQ2FjaGVkUmVzb3VyY2VMb2FkZXIq LCBDYWNoZWRSZXNvdXJjZSosIGJvb2wgaW5jcmVtZW50YWwgPSB0cnVlLCBTZWN1cml0eUNoZWNr UG9saWN5ID0gRG9TZWN1cml0eUNoZWNrLCBib29sIHNlbmRSZXNvdXJjZUxvYWRDYWxsYmFja3Mg PSB0cnVlKTsKLQogICAgICAgICB2b2lkIGNhbmNlbFJlcXVlc3RzKENhY2hlZFJlc291cmNlTG9h ZGVyKik7Ci0gICAgICAgIAotICAgICAgICBlbnVtIFByaW9yaXR5IHsgVmVyeUxvdywgTG93LCBN ZWRpdW0sIEhpZ2ggfTsKLSAgICAgICAgdm9pZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0 eSBtaW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93KTsKIAotICAgICAgICBib29sIGlzU3VzcGVuZGlu Z1BlbmRpbmdSZXF1ZXN0cygpIHsgcmV0dXJuIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3Rz OyB9Ci0gICAgICAgIHZvaWQgc3VzcGVuZFBlbmRpbmdSZXF1ZXN0cygpOwotICAgICAgICB2b2lk IHJlc3VtZVBlbmRpbmdSZXF1ZXN0cygpOwotICAgICAgICAKLSAgICAgICAgdm9pZCBub25DYWNo ZVJlcXVlc3RJbkZsaWdodChjb25zdCBLVVJMJik7Ci0gICAgICAgIHZvaWQgbm9uQ2FjaGVSZXF1 ZXN0Q29tcGxldGUoY29uc3QgS1VSTCYpOwotCiAgICAgcHJpdmF0ZToKLSAgICAgICAgUHJpb3Jp dHkgZGV0ZXJtaW5lUHJpb3JpdHkoY29uc3QgQ2FjaGVkUmVzb3VyY2UqKSBjb25zdDsKLSAgICAg ICAgdm9pZCBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CisgICAgICAgIHZpcnR1YWwg dm9pZCBkaWRSZWNlaXZlUmVzcG9uc2UoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJj ZVJlc3BvbnNlJik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShTdWJyZXNv dXJjZUxvYWRlciosIGNvbnN0IGNoYXIqLCBpbnQpOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlk UmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGlu dCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGaW5pc2hMb2FkaW5nKFN1YnJlc291cmNlTG9h ZGVyKik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKFN1YnJlc291cmNlTG9hZGVyKiwg Y29uc3QgUmVzb3VyY2VFcnJvciYpOworICAgICAgICB2b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VM b2FkZXIqLCBib29sIGNhbmNlbGxlZCA9IGZhbHNlKTsKICAgICAgICAgCi0gICAgICAgIHZvaWQg cmVxdWVzdFRpbWVyRmlyZWQoVGltZXI8TG9hZGVyPiopOwotCi0gICAgICAgIGNsYXNzIEhvc3Qg OiBwdWJsaWMgUmVmQ291bnRlZDxIb3N0PiwgcHJpdmF0ZSBTdWJyZXNvdXJjZUxvYWRlckNsaWVu dCB7Ci0gICAgICAgIHB1YmxpYzoKLSAgICAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPEhvc3Q+ IGNyZWF0ZShjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5G bGlnaHQpIAotICAgICAgICAgICAgewotICAgICAgICAgICAgICAgIHJldHVybiBhZG9wdFJlZihu ZXcgSG9zdChuYW1lLCBtYXhSZXF1ZXN0c0luRmxpZ2h0KSk7Ci0gICAgICAgICAgICB9Ci0gICAg ICAgICAgICB+SG9zdCgpOwotICAgICAgICAgICAgCi0gICAgICAgICAgICBjb25zdCBBdG9taWNT dHJpbmcmIG5hbWUoKSBjb25zdCB7IHJldHVybiBtX25hbWU7IH0KLSAgICAgICAgICAgIHZvaWQg YWRkUmVxdWVzdChSZXF1ZXN0KiwgUHJpb3JpdHkpOwotICAgICAgICAgICAgdm9pZCBub25DYWNo ZVJlcXVlc3RJbkZsaWdodCgpOwotICAgICAgICAgICAgdm9pZCBub25DYWNoZVJlcXVlc3RDb21w bGV0ZSgpOwotICAgICAgICAgICAgdm9pZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBt aW5pbXVtUHJpb3JpdHkgPSBWZXJ5TG93KTsKLSAgICAgICAgICAgIHZvaWQgY2FuY2VsUmVxdWVz dHMoQ2FjaGVkUmVzb3VyY2VMb2FkZXIqKTsKLSAgICAgICAgICAgIGJvb2wgaGFzUmVxdWVzdHMo KSBjb25zdDsKLQotICAgICAgICAgICAgYm9vbCBwcm9jZXNzaW5nUmVzb3VyY2UoKSBjb25zdCB7 IHJldHVybiBtX251bVJlc291cmNlc1Byb2Nlc3NpbmcgIT0gMCB8fCBtX25vbkNhY2hlZFJlcXVl c3RzSW5GbGlnaHQgIT0wOyB9Ci0KLSAgICAgICAgcHJpdmF0ZToKLSAgICAgICAgICAgIEhvc3Qo Y29uc3QgQXRvbWljU3RyaW5nJiwgdW5zaWduZWQpOwotCi0gICAgICAgICAgICB2aXJ0dWFsIHZv aWQgZGlkUmVjZWl2ZVJlc3BvbnNlKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgUmVzb3VyY2VS ZXNwb25zZSYpOwotICAgICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKFN1YnJl c291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7Ci0gICAgICAgICAgICB2aXJ0dWFsIHZv aWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hh ciosIGludCk7Ci0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRmluaXNoTG9hZGluZyhTdWJy ZXNvdXJjZUxvYWRlciopOwotICAgICAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoU3VicmVz b3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJik7Ci0gICAgICAgICAgICAKLSAgICAg ICAgICAgIHR5cGVkZWYgRGVxdWU8UmVxdWVzdCo+IFJlcXVlc3RRdWV1ZTsKLSAgICAgICAgICAg IHZvaWQgc2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcs IGJvb2wmIHNlcnZlTG93ZXJQcmlvcml0eSk7Ci0gICAgICAgICAgICB2b2lkIGRpZEZhaWwoU3Vi cmVzb3VyY2VMb2FkZXIqLCBib29sIGNhbmNlbGxlZCA9IGZhbHNlKTsKLSAgICAgICAgICAgIHZv aWQgY2FuY2VsUGVuZGluZ1JlcXVlc3RzKFJlcXVlc3RRdWV1ZSYgcmVxdWVzdHNQZW5kaW5nLCBD YWNoZWRSZXNvdXJjZUxvYWRlciopOwotICAgICAgICAgICAgCi0gICAgICAgICAgICBSZXF1ZXN0 UXVldWUgbV9yZXF1ZXN0c1BlbmRpbmdbSGlnaCArIDFdOwotICAgICAgICAgICAgdHlwZWRlZiBI YXNoTWFwPFJlZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4sIFJlcXVlc3QqPiBSZXF1ZXN0TWFwOwot ICAgICAgICAgICAgUmVxdWVzdE1hcCBtX3JlcXVlc3RzTG9hZGluZzsKLSAgICAgICAgICAgIGNv bnN0IEF0b21pY1N0cmluZyBtX25hbWU7Ci0gICAgICAgICAgICBjb25zdCBpbnQgbV9tYXhSZXF1 ZXN0c0luRmxpZ2h0OwotICAgICAgICAgICAgaW50IG1fbnVtUmVzb3VyY2VzUHJvY2Vzc2luZzsK LSAgICAgICAgICAgIGludCBtX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQ7Ci0gICAgICAgIH07 Ci0gICAgICAgIHR5cGVkZWYgSGFzaE1hcDxBdG9taWNTdHJpbmdJbXBsKiwgUmVmUHRyPEhvc3Q+ ID4gSG9zdE1hcDsKLSAgICAgICAgSG9zdE1hcCBtX2hvc3RzOwotICAgICAgICBSZWZQdHI8SG9z dD4gbV9ub25IVFRQUHJvdG9jb2xIb3N0OwotICAgICAgICAKLSAgICAgICAgVGltZXI8TG9hZGVy PiBtX3JlcXVlc3RUaW1lcjsKLQotICAgICAgICBib29sIG1faXNTdXNwZW5kaW5nUGVuZGluZ1Jl cXVlc3RzOworICAgICAgICB0eXBlZGVmIEhhc2hNYXA8UmVmUHRyPFN1YnJlc291cmNlTG9hZGVy PiwgUmVxdWVzdCo+IFJlcXVlc3RNYXA7CisgICAgICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0c0xv YWRpbmc7CiAgICAgfTsKIAogfQpJbmRleDogV2ViQ29yZS9sb2FkZXIvTmV0c2NhcGVQbHVnSW5T dHJlYW1Mb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL05ldHNjYXBlUGx1 Z0luU3RyZWFtTG9hZGVyLmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL2xvYWRlci9O ZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDkgKzQ0 LDEyIEBACiB7CiB9CiAKLVBhc3NSZWZQdHI8TmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXI+IE5l dHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyOjpjcmVhdGUoRnJhbWUqIGZyYW1lLCBOZXRzY2FwZVBs dWdJblN0cmVhbUxvYWRlckNsaWVudCogY2xpZW50KQorUGFzc1JlZlB0cjxOZXRzY2FwZVBsdWdJ blN0cmVhbUxvYWRlcj4gTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXI6OmNyZWF0ZShGcmFtZSog ZnJhbWUsIE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCkKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYobmV3IE5ldHNj YXBlUGx1Z0luU3RyZWFtTG9hZGVyKGZyYW1lLCBjbGllbnQpKTsKKyAgICBSZWZQdHI8TmV0c2Nh cGVQbHVnSW5TdHJlYW1Mb2FkZXI+IGxvYWRlcihhZG9wdFJlZihuZXcgTmV0c2NhcGVQbHVnSW5T dHJlYW1Mb2FkZXIoZnJhbWUsIGNsaWVudCkpKTsKKyAgICBsb2FkZXItPnNldFNob3VsZEJ1ZmZl ckRhdGEoZmFsc2UpOworICAgIGxvYWRlci0+ZG9jdW1lbnRMb2FkZXIoKS0+YWRkUGx1Z0luU3Ry ZWFtTG9hZGVyKGxvYWRlci5nZXQoKSk7CisgICAgcmV0dXJuIGxvYWRlci0+bG9hZChyZXF1ZXN0 KSA/IGxvYWRlci5yZWxlYXNlKCkgOiAwOwogfQogCiBib29sIE5ldHNjYXBlUGx1Z0luU3RyZWFt TG9hZGVyOjppc0RvbmUoKSBjb25zdApJbmRleDogV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2Fk U2NoZWR1bGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRT Y2hlZHVsZXIuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2Fk U2NoZWR1bGVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMTIgQEAKKy8qCisgICAgQ29w eXJpZ2h0IChDKSAxOTk4IExhcnMgS25vbGwgKGtub2xsQG1waS1oZC5tcGcuZGUpCisgICAgQ29w eXJpZ2h0IChDKSAyMDAxIERpcmsgTXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICAgIENvcHly aWdodCAoQykgMjAwMiBXYWxkbyBCYXN0aWFuIChiYXN0aWFuQGtkZS5vcmcpCisgICAgQ29weXJp Z2h0IChDKSAyMDA2IFNhbXVlbCBXZWluaWcgKHNhbS53ZWluaWdAZ21haWwuY29tKQorICAgIENv cHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiwgMjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgICAgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAgICBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgICB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisKKyAgICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICAgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisgICAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICAgIEJvc3RvbiwgTUEgMDIx MTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZXNv dXJjZUxvYWRTY2hlZHVsZXIuaCIKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAi RnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkluc3BlY3Rvcklu c3RydW1lbnRhdGlvbi5oIgorI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlICJMb2dnaW5nLmgi CisjaW5jbHVkZSAiTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXIuaCIKKyNpbmNsdWRlICJSZXNv dXJjZUxvYWRlci5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgorI2luY2x1ZGUgIlN1 YnJlc291cmNlTG9hZGVyLmgiCisKKyNkZWZpbmUgUkVRVUVTVF9NQU5BR0VNRU5UX0VOQUJMRUQg MQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKyNpZiBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxF RAorc3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHRGb3JOb25IVFRQUHJv dG9jb2xzID0gMjA7CisvLyBNYXRjaCB0aGUgcGFyYWxsZWwgY29ubmVjdGlvbiBjb3VudCB1c2Vk IGJ5IHRoZSBuZXR3b3JraW5nIGxheWVyLgorc3RhdGljIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5G bGlnaHRQZXJIb3N0OworI2Vsc2UKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhSZXF1ZXN0c0lu RmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29scyA9IDEwMDAwOworc3RhdGljIGNvbnN0IHVuc2lnbmVk IG1heFJlcXVlc3RzSW5GbGlnaHRQZXJIb3N0ID0gMTAwMDA7CisjZW5kaWYKKworUmVzb3VyY2VM b2FkU2NoZWR1bGVyOjpIb3N0SW5mb3JtYXRpb24qIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6aG9z dEZvclVSTChjb25zdCBLVVJMJiB1cmwsIENyZWF0ZUhvc3RQb2xpY3kgY3JlYXRlSG9zdFBvbGlj eSkKK3sKKyAgICBpZiAoIXVybC5wcm90b2NvbEluSFRUUEZhbWlseSgpKQorICAgICAgICByZXR1 cm4gbV9ub25IVFRQUHJvdG9jb2xIb3N0OworCisgICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5 KCk7CisgICAgU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3QoKTsKKyAgICBIb3N0SW5mb3JtYXRp b24qIGhvc3QgPSBtX2hvc3RzLmdldChob3N0TmFtZSk7CisgICAgaWYgKCFob3N0ICYmIGNyZWF0 ZUhvc3RQb2xpY3kgPT0gQ3JlYXRlSWZOb3RGb3VuZCkgeworICAgICAgICBob3N0ID0gbmV3IEhv c3RJbmZvcm1hdGlvbihob3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOworICAg ICAgICBtX2hvc3RzLmFkZChob3N0TmFtZSwgaG9zdCk7CisgICAgfQorICAgIHJldHVybiBob3N0 OworfQorCitSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIHJlc291cmNlTG9hZFNjaGVkdWxlcigpCit7 CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFJl c291cmNlTG9hZFNjaGVkdWxlciwgcmVzb3VyY2VMb2FkU2NoZWR1bGVyLCAoKSk7CisgICAgcmV0 dXJuICZyZXNvdXJjZUxvYWRTY2hlZHVsZXI7Cit9CisKK1Jlc291cmNlTG9hZFNjaGVkdWxlcjo6 UmVzb3VyY2VMb2FkU2NoZWR1bGVyKCkKKyAgICA6IG1fbm9uSFRUUFByb3RvY29sSG9zdChuZXcg SG9zdEluZm9ybWF0aW9uKFN0cmluZygpLCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFBy b3RvY29scykpCisgICAgLCBtX3JlcXVlc3RUaW1lcih0aGlzLCAmUmVzb3VyY2VMb2FkU2NoZWR1 bGVyOjpyZXF1ZXN0VGltZXJGaXJlZCkKKyAgICAsIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVl c3RzKGZhbHNlKQoreworI2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECisgICAgbWF4UmVx dWVzdHNJbkZsaWdodFBlckhvc3QgPSBpbml0aWFsaXplTWF4aW11bUhUVFBDb25uZWN0aW9uQ291 bnRQZXJIb3N0KCk7CisjZW5kaWYKK30KKworUGFzc1JlZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4g UmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzY2hlZHVsZVN1YnJlc291cmNlTG9hZChGcmFtZSogZnJh bWUsIFN1YnJlc291cmNlTG9hZGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFJlc291cmNlUmVxdWVz dCYgcmVxdWVzdCwgUHJpb3JpdHkgcHJpb3JpdHksIFNlY3VyaXR5Q2hlY2tQb2xpY3kgc2VjdXJp dHlDaGVjaywgYm9vbCBzZW5kUmVzb3VyY2VMb2FkQ2FsbGJhY2tzLCBib29sIHNob3VsZENvbnRl bnRTbmlmZikKK3sKKyAgICBQYXNzUmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBsb2FkZXIgPSBT dWJyZXNvdXJjZUxvYWRlcjo6Y3JlYXRlKGZyYW1lLCBjbGllbnQsIHJlcXVlc3QsIHNlY3VyaXR5 Q2hlY2ssIHNlbmRSZXNvdXJjZUxvYWRDYWxsYmFja3MsIHNob3VsZENvbnRlbnRTbmlmZik7Cisg ICAgaWYgKGxvYWRlcikKKyAgICAgICAgc2NoZWR1bGVMb2FkKGxvYWRlci5nZXQoKSwgcHJpb3Jp dHkpOworICAgIHJldHVybiBsb2FkZXI7Cit9CisgICAgCitQYXNzUmVmUHRyPE5ldHNjYXBlUGx1 Z0luU3RyZWFtTG9hZGVyPiBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnNjaGVkdWxlUGx1Z2luU3Ry ZWFtTG9hZChGcmFtZSogZnJhbWUsIE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyQ2xpZW50KiBj bGllbnQsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3sKKyAgICBQYXNzUmVmUHRy PE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyPiBsb2FkZXIgPSBOZXRzY2FwZVBsdWdJblN0cmVh bUxvYWRlcjo6Y3JlYXRlKGZyYW1lLCBjbGllbnQsIHJlcXVlc3QpOworICAgIGlmIChsb2FkZXIp CisgICAgICAgIHNjaGVkdWxlTG9hZChsb2FkZXIuZ2V0KCksIExvdyk7CisgICAgcmV0dXJuIGxv YWRlcjsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmFkZE1haW5SZXNvdXJjZUxv YWQoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyKQoreworICAgIGhvc3RGb3JVUkwocmVz b3VyY2VMb2FkZXItPnVybCgpLCBDcmVhdGVJZk5vdEZvdW5kKS0+YWRkTG9hZEluUHJvZ3Jlc3Mo cmVzb3VyY2VMb2FkZXIpOworfQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6c2NoZWR1 bGVMb2FkKFJlc291cmNlTG9hZGVyKiByZXNvdXJjZUxvYWRlciwgUHJpb3JpdHkgcHJpb3JpdHkp Cit7CisgICAgQVNTRVJUKHJlc291cmNlTG9hZGVyKTsKKyNpZiAhUkVRVUVTVF9NQU5BR0VNRU5U X0VOQUJMRUQKKyAgICBwcmlvcml0eSA9IEhpZ2g7CisjZW5kaWYKKworICAgIExPRyhSZXNvdXJj ZUxvYWRpbmcsICJSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmxvYWQgcmVzb3VyY2UgJXAgJyVzJyIs IHJlc291cmNlTG9hZGVyLCByZXNvdXJjZUxvYWRlci0+dXJsKCkuc3RyaW5nKCkubGF0aW4xKCku ZGF0YSgpKTsKKyAgICBIb3N0SW5mb3JtYXRpb24qIGhvc3QgPSBob3N0Rm9yVVJMKHJlc291cmNl TG9hZGVyLT51cmwoKSwgQ3JlYXRlSWZOb3RGb3VuZCk7ICAgIAorICAgIGJvb2wgaGFkUmVxdWVz dHMgPSBob3N0LT5oYXNSZXF1ZXN0cygpOworICAgIGhvc3QtPnNjaGVkdWxlKHJlc291cmNlTG9h ZGVyLCBwcmlvcml0eSk7CisKKyAgICBpZiAocHJpb3JpdHkgPiBMb3cgfHwgIXJlc291cmNlTG9h ZGVyLT51cmwoKS5wcm90b2NvbEluSFRUUEZhbWlseSgpIHx8IChwcmlvcml0eSA9PSBMb3cgJiYg IWhhZFJlcXVlc3RzKSkgeworICAgICAgICAvLyBUcnkgdG8gcmVxdWVzdCBpbXBvcnRhbnQgcmVz b3VyY2VzIGltbWVkaWF0ZWx5LgorICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhob3N0LCBw cmlvcml0eSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gSGFuZGxlIGFzeW5jaHJvbm91c2x5 IHNvIGVhcmx5IGxvdyBwcmlvcml0eSByZXF1ZXN0cyBkb24ndCBnZXQgc2NoZWR1bGVkIGJlZm9y ZSBsYXRlciBoaWdoIHByaW9yaXR5IG9uZXMuCisgICAgICAgIEluc3BlY3Rvckluc3RydW1lbnRh dGlvbjo6ZGlkU2NoZWR1bGVSZXNvdXJjZVJlcXVlc3QocmVzb3VyY2VMb2FkZXItPmZyYW1lTG9h ZGVyKCkgPyByZXNvdXJjZUxvYWRlci0+ZnJhbWVMb2FkZXIoKS0+ZnJhbWUoKS0+ZG9jdW1lbnQo KSA6IDAsIHJlc291cmNlTG9hZGVyLT51cmwoKSk7CisgICAgICAgIHNjaGVkdWxlU2VydmVQZW5k aW5nUmVxdWVzdHMoKTsKKyAgICB9Cit9CisKK3ZvaWQgUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpy ZW1vdmUoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVyKQoreworICAgIEFTU0VSVChyZXNv dXJjZUxvYWRlcik7CisKKyAgICBIb3N0SW5mb3JtYXRpb24qIGhvc3QgPSBob3N0Rm9yVVJMKHJl c291cmNlTG9hZGVyLT51cmwoKSk7CisgICAgaWYgKGhvc3QpCisgICAgICAgIGhvc3QtPnJlbW92 ZShyZXNvdXJjZUxvYWRlcik7CisgICAgc2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwor fQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6Y3Jvc3NPcmlnaW5SZWRpcmVjdFJlY2Vp dmVkKFJlc291cmNlTG9hZGVyKiByZXNvdXJjZUxvYWRlciwgY29uc3QgS1VSTCYgcmVkaXJlY3RV UkwpCit7CisgICAgSG9zdEluZm9ybWF0aW9uKiBvbGRIb3N0ID0gaG9zdEZvclVSTChyZXNvdXJj ZUxvYWRlci0+dXJsKCkpOworICAgIEFTU0VSVChvbGRIb3N0KTsKKyAgICBIb3N0SW5mb3JtYXRp b24qIG5ld0hvc3QgPSBob3N0Rm9yVVJMKHJlZGlyZWN0VVJMLCBDcmVhdGVJZk5vdEZvdW5kKTsK KworICAgIGlmIChvbGRIb3N0LT5uYW1lKCkgPT0gbmV3SG9zdC0+bmFtZSgpKQorICAgICAgICBy ZXR1cm47CisgICAgCisgICAgbmV3SG9zdC0+YWRkTG9hZEluUHJvZ3Jlc3MocmVzb3VyY2VMb2Fk ZXIpOworICAgIG9sZEhvc3QtPnJlbW92ZShyZXNvdXJjZUxvYWRlcik7Cit9CisKK3ZvaWQgUmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhQcmlvcml0eSBtaW5pbXVt UHJpb3JpdHkpCit7CisgICAgTE9HKFJlc291cmNlTG9hZGluZywgIlJlc291cmNlTG9hZFNjaGVk dWxlcjo6c2VydmVQZW5kaW5nUmVxdWVzdHMuIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3Rz PSVkIiwgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMpOyAKKyAgICBpZiAobV9pc1N1c3Bl bmRpbmdQZW5kaW5nUmVxdWVzdHMpCisgICAgICAgIHJldHVybjsKKworICAgIG1fcmVxdWVzdFRp bWVyLnN0b3AoKTsKKyAgICAKKyAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhtX25vbkhUVFBQcm90 b2NvbEhvc3QsIG1pbmltdW1Qcmlvcml0eSk7CisKKyAgICBWZWN0b3I8SG9zdEluZm9ybWF0aW9u Kj4gaG9zdHNUb1NlcnZlOworICAgIG1faG9zdHMuY2hlY2tDb25zaXN0ZW5jeSgpOworICAgIEhv c3RNYXA6Oml0ZXJhdG9yIGVuZCA9IG1faG9zdHMuZW5kKCk7CisgICAgZm9yIChIb3N0TWFwOjpp dGVyYXRvciBpdGVyID0gbV9ob3N0cy5iZWdpbigpOyBpdGVyICE9IGVuZDsgKytpdGVyKQorICAg ICAgICBob3N0c1RvU2VydmUuYXBwZW5kKGl0ZXItPnNlY29uZCk7CisKKyAgICBpbnQgc2l6ZSA9 IGhvc3RzVG9TZXJ2ZS5zaXplKCk7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBzaXplOyArK2kp IHsKKyAgICAgICAgSG9zdEluZm9ybWF0aW9uKiBob3N0ID0gaG9zdHNUb1NlcnZlW2ldOworICAg ICAgICBpZiAoaG9zdC0+aGFzUmVxdWVzdHMoKSkKKyAgICAgICAgICAgIHNlcnZlUGVuZGluZ1Jl cXVlc3RzKGhvc3QsIG1pbmltdW1Qcmlvcml0eSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAg IGRlbGV0ZSBtX2hvc3RzLnRha2UoaG9zdC0+bmFtZSgpKTsKKyAgICB9Cit9CisKK3ZvaWQgUmVz b3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhIb3N0SW5mb3JtYXRpb24q IGhvc3QsIFByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSkKK3sKKyAgICBMT0coUmVzb3VyY2VMb2Fk aW5nLCAiUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyBIb3N0SW5m b3JtYXRpb24ubV9uYW1lPSclcyciLCBob3N0LT5uYW1lKCkubGF0aW4xKCkuZGF0YSgpKTsKKwor ICAgIGZvciAoaW50IHByaW9yaXR5ID0gSGlnaDsgcHJpb3JpdHkgPj0gbWluaW11bVByaW9yaXR5 OyAtLXByaW9yaXR5KSB7CisgICAgICAgIEhvc3RJbmZvcm1hdGlvbjo6UmVxdWVzdFF1ZXVlJiBy ZXF1ZXN0c1BlbmRpbmcgPSBob3N0LT5yZXF1ZXN0c1BlbmRpbmcoKFByaW9yaXR5KSBwcmlvcml0 eSk7CisgICAgICAgIEhvc3RJbmZvcm1hdGlvbjo6UmVxdWVzdFF1ZXVlIGRlZmVycmVkUmVxdWVz dHM7CisKKyAgICAgICAgd2hpbGUgKCFyZXF1ZXN0c1BlbmRpbmcuaXNFbXB0eSgpKSB7CisgICAg ICAgICAgICBSZWZQdHI8UmVzb3VyY2VMb2FkZXI+IHJlc291cmNlTG9hZGVyID0gcmVxdWVzdHNQ ZW5kaW5nLmZpcnN0KCk7CisKKyAgICAgICAgICAgIC8vIEZvciBuYW1lZCBob3N0cyAtIHdoaWNo IGFyZSBvbmx5IGh0dHAocykgaG9zdHMgLSB3ZSBzaG91bGQgYWx3YXlzIGVuZm9yY2UgdGhlIGNv bm5lY3Rpb24gbGltaXQuCisgICAgICAgICAgICAvLyBGb3Igbm9uLW5hbWVkIGhvc3RzIC0gZXZl cnl0aGluZyBidXQgaHR0cChzKSAtIHdlIHNob3VsZCBvbmx5IGVuZm9yY2UgdGhlIGxpbWl0IGlm IHRoZSBkb2N1bWVudCBpc24ndCBkb25lIHBhcnNpbmcgCisgICAgICAgICAgICAvLyBhbmQgd2Ug ZG9uJ3Qga25vdyBhbGwgc3R5bGVzaGVldHMgeWV0LgorICAgICAgICAgICAgRG9jdW1lbnQqIGRv Y3VtZW50ID0gcmVzb3VyY2VMb2FkZXItPmZyYW1lTG9hZGVyKCkgPyByZXNvdXJjZUxvYWRlci0+ ZnJhbWVMb2FkZXIoKS0+ZnJhbWUoKS0+ZG9jdW1lbnQoKSA6IDA7CisgICAgICAgICAgICBib29s IHNob3VsZExpbWl0UmVxdWVzdHMgPSAhaG9zdC0+bmFtZSgpLmlzTnVsbCgpIHx8IChkb2N1bWVu dCAmJiAoZG9jdW1lbnQtPnBhcnNpbmcoKSB8fCAhZG9jdW1lbnQtPmhhdmVTdHlsZXNoZWV0c0xv YWRlZCgpKSk7CisgICAgICAgICAgICBpZiAoc2hvdWxkTGltaXRSZXF1ZXN0cyAmJiBob3N0LT5s aW1pdFJlcXVlc3RzKCkpIHsKKyAgICAgICAgICAgICAgICB3aGlsZSAoIWRlZmVycmVkUmVxdWVz dHMuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgICAgICByZXF1ZXN0c1BlbmRpbmcuYXBwZW5k KGRlZmVycmVkUmVxdWVzdHMudGFrZUZpcnN0KCkpOworICAgICAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgKHJlc291cmNlTG9hZGVyLT5zdGFydCgp KQorICAgICAgICAgICAgICAgIGhvc3QtPmFkZExvYWRJblByb2dyZXNzKHJlc291cmNlTG9hZGVy LmdldCgpKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBkZWZlcnJlZFJlcXVl c3RzLmFwcGVuZChyZXNvdXJjZUxvYWRlcik7CisgICAgICAgICAgICByZXF1ZXN0c1BlbmRpbmcu cmVtb3ZlRmlyc3QoKTsKKyAgICAgICAgfQorCisgICAgICAgIHJlcXVlc3RzUGVuZGluZy5zd2Fw KGRlZmVycmVkUmVxdWVzdHMpOworICAgIH0KK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVs ZXI6OnN1c3BlbmRQZW5kaW5nUmVxdWVzdHMoKQoreworICAgIEFTU0VSVCghbV9pc1N1c3BlbmRp bmdQZW5kaW5nUmVxdWVzdHMpOworICAgIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzID0g dHJ1ZTsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OnJlc3VtZVBlbmRpbmdSZXF1 ZXN0cygpCit7CisgICAgQVNTRVJUKG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKTsKKyAg ICBtX2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cyA9IGZhbHNlOworICAgIGlmICghbV9ob3N0 cy5pc0VtcHR5KCkgfHwgbV9ub25IVFRQUHJvdG9jb2xIb3N0LT5oYXNSZXF1ZXN0cygpKQorICAg ICAgICBzY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Cit9CisgICAgCit2b2lkIFJlc291 cmNlTG9hZFNjaGVkdWxlcjo6c2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpCit7CisgICAg TE9HKFJlc291cmNlTG9hZGluZywgIlJlc291cmNlTG9hZFNjaGVkdWxlcjo6c2NoZWR1bGVTZXJ2 ZVBlbmRpbmdSZXF1ZXN0cywgbV9yZXF1ZXN0VGltZXIuaXNBY3RpdmUoKT0ldSIsIG1fcmVxdWVz dFRpbWVyLmlzQWN0aXZlKCkpOworICAgIGlmICghbV9yZXF1ZXN0VGltZXIuaXNBY3RpdmUoKSkK KyAgICAgICAgbV9yZXF1ZXN0VGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIFJlc291 cmNlTG9hZFNjaGVkdWxlcjo6cmVxdWVzdFRpbWVyRmlyZWQoVGltZXI8UmVzb3VyY2VMb2FkU2No ZWR1bGVyPiopIAoreworICAgIExPRyhSZXNvdXJjZUxvYWRpbmcsICJSZXNvdXJjZUxvYWRTY2hl ZHVsZXI6OnJlcXVlc3RUaW1lckZpcmVkXG4iKTsKKyAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cygp OworfQorCisjaWZuZGVmIE5ERUJVRwordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OmFzc2Vy dExvYWRlckJlaW5nQ291bnRlZChSZXNvdXJjZUxvYWRlciogcmVzb3VyY2VMb2FkZXIpCit7Cisg ICAgSG9zdEluZm9ybWF0aW9uKiBob3N0ID0gaG9zdEZvclVSTChyZXNvdXJjZUxvYWRlci0+dXJs KCkpOworICAgIEFTU0VSVChob3N0KTsKKyAgICBob3N0LT5hc3NlcnRMb2FkZXJCZWluZ0NvdW50 ZWQocmVzb3VyY2VMb2FkZXIpOworfQorCit2b2lkIFJlc291cmNlTG9hZFNjaGVkdWxlcjo6SG9z dEluZm9ybWF0aW9uOjphc3NlcnRMb2FkZXJCZWluZ0NvdW50ZWQoUmVzb3VyY2VMb2FkZXIqIHJl c291cmNlTG9hZGVyKQoreworICAgIC8vIElmIGEgbG9hZCBpcyBiZWluZyBzdGFydGVkLCBpdCBz aG91bGQgYmUgYXQgdGhlIGZyb250IG9mIHRoZSBoaWdoZXN0IHByaW9yaXR5IHF1ZXVlCisgICAg Ly8gdGhhdCBhY3R1YWxseSBjb250YWlucyBhIHJlcXVlc3QuCisgICAgZm9yIChpbnQgcHJpb3Jp dHkgPSBIaWdoOyBwcmlvcml0eSA+PSBWZXJ5TG93OyAtLXByaW9yaXR5KSB7ICAKKyAgICAgICAg aWYgKCFtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0uaXNFbXB0eSgpKSB7CisgICAgICAgICAg ICBBU1NFUlQobV9yZXF1ZXN0c1BlbmRpbmdbcHJpb3JpdHldLmZpcnN0KCkuZ2V0KCkgPT0gcmVz b3VyY2VMb2FkZXIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisg ICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cit9CisjZW5kaWYKKworUmVzb3VyY2VMb2FkU2NoZWR1 bGVyOjpIb3N0SW5mb3JtYXRpb246Okhvc3RJbmZvcm1hdGlvbihjb25zdCBTdHJpbmcmIG5hbWUs IHVuc2lnbmVkIG1heFJlcXVlc3RzSW5GbGlnaHQpCisgICAgOiBtX25hbWUobmFtZSkKKyAgICAs IG1fbWF4UmVxdWVzdHNJbkZsaWdodChtYXhSZXF1ZXN0c0luRmxpZ2h0KQoreworfQorCitSZXNv dXJjZUxvYWRTY2hlZHVsZXI6Okhvc3RJbmZvcm1hdGlvbjo6fkhvc3RJbmZvcm1hdGlvbigpCit7 CisgICAgQVNTRVJUKG1fcmVxdWVzdHNMb2FkaW5nLmlzRW1wdHkoKSk7CisgICAgZm9yICh1bnNp Z25lZCBwID0gMDsgcCA8PSBIaWdoOyBwKyspCisgICAgICAgIEFTU0VSVChtX3JlcXVlc3RzUGVu ZGluZ1twXS5pc0VtcHR5KCkpOworfQorICAgIAordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6 Okhvc3RJbmZvcm1hdGlvbjo6c2NoZWR1bGUoUmVzb3VyY2VMb2FkZXIqIHJlc291cmNlTG9hZGVy LCBQcmlvcml0eSBwcmlvcml0eSkKK3sKKyAgICBtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0u YXBwZW5kKHJlc291cmNlTG9hZGVyKTsKK30KKyAgICAKK3ZvaWQgUmVzb3VyY2VMb2FkU2NoZWR1 bGVyOjpIb3N0SW5mb3JtYXRpb246OmFkZExvYWRJblByb2dyZXNzKFJlc291cmNlTG9hZGVyKiBy ZXNvdXJjZUxvYWRlcikKK3sKKyAgICBMT0coUmVzb3VyY2VMb2FkaW5nLCAiSG9zdEluZm9ybWF0 aW9uICclcycgbG9hZGluZyAnJXMnLiBDdXJyZW50IGNvdW50ICVkIiwgbV9uYW1lLmxhdGluMSgp LmRhdGEoKSwgcmVzb3VyY2VMb2FkZXItPnVybCgpLnN0cmluZygpLmxhdGluMSgpLmRhdGEoKSwg bV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpKTsKKyAgICBtX3JlcXVlc3RzTG9hZGluZy5hZGQocmVz b3VyY2VMb2FkZXIpOworfQorICAgIAordm9pZCBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6Okhvc3RJ bmZvcm1hdGlvbjo6cmVtb3ZlKFJlc291cmNlTG9hZGVyKiByZXNvdXJjZUxvYWRlcikKK3sKKyAg ICBpZiAobV9yZXF1ZXN0c0xvYWRpbmcuY29udGFpbnMocmVzb3VyY2VMb2FkZXIpKSB7CisgICAg ICAgIG1fcmVxdWVzdHNMb2FkaW5nLnJlbW92ZShyZXNvdXJjZUxvYWRlcik7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisgICAgCisgICAgZm9yIChpbnQgcHJpb3JpdHkgPSBIaWdoOyBwcmlvcml0 eSA+PSBWZXJ5TG93OyAtLXByaW9yaXR5KSB7ICAKKyAgICAgICAgUmVxdWVzdFF1ZXVlOjppdGVy YXRvciBlbmQgPSBtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0eV0uZW5kKCk7CisgICAgICAgIGZv ciAoUmVxdWVzdFF1ZXVlOjppdGVyYXRvciBpdCA9IG1fcmVxdWVzdHNQZW5kaW5nW3ByaW9yaXR5 XS5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgICAgIGlmICgqaXQgPT0gcmVz b3VyY2VMb2FkZXIpIHsKKyAgICAgICAgICAgICAgICBtX3JlcXVlc3RzUGVuZGluZ1twcmlvcml0 eV0ucmVtb3ZlKGl0KTsKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICB9Cisg ICAgICAgIH0KKyAgICB9Cit9CisKK2Jvb2wgUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpIb3N0SW5m b3JtYXRpb246Omhhc1JlcXVlc3RzKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fcmVxdWVzdHNMb2Fk aW5nLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgZm9yICh1bnNpZ25lZCBw ID0gMDsgcCA8PSBIaWdoOyBwKyspIHsKKyAgICAgICAgaWYgKCFtX3JlcXVlc3RzUGVuZGluZ1tw XS5pc0VtcHR5KCkpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJu IGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL2xvYWRl ci9pY29uL0ljb25Mb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL2ljb24v SWNvbkxvYWRlci5jcHAJKHJldmlzaW9uIDcxMjU2KQorKysgV2ViQ29yZS9sb2FkZXIvaWNvbi9J Y29uTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUg Ikljb25EYXRhYmFzZS5oIgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJSZXNvdXJj ZUhhbmRsZS5oIgorI2luY2x1ZGUgIlJlc291cmNlTG9hZFNjaGVkdWxlci5oIgogI2luY2x1ZGUg IlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNs dWRlICJTaGFyZWRCdWZmZXIuaCIKQEAgLTY4LDcgKzY5LDcgQEAKICAgICAvLyBTdWJyZXNvdXJj ZUxvYWRlcjo6Y3JlYXRlIHJldHVybnMuCiAgICAgbV9sb2FkSXNJblByb2dyZXNzID0gdHJ1ZTsK IAotICAgIFJlZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4gbG9hZGVyID0gU3VicmVzb3VyY2VMb2Fk ZXI6OmNyZWF0ZShtX2ZyYW1lLCB0aGlzLCBtX2ZyYW1lLT5sb2FkZXIoKS0+aWNvblVSTCgpKTsK KyAgICBSZWZQdHI8U3VicmVzb3VyY2VMb2FkZXI+IGxvYWRlciA9IHJlc291cmNlTG9hZFNjaGVk dWxlcigpLT5zY2hlZHVsZVN1YnJlc291cmNlTG9hZChtX2ZyYW1lLCB0aGlzLCBtX2ZyYW1lLT5s b2FkZXIoKS0+aWNvblVSTCgpKTsKICAgICBpZiAoIWxvYWRlcikKICAgICAgICAgTE9HX0VSUk9S KCJGYWlsZWQgdG8gc3RhcnQgbG9hZCBmb3IgaWNvbiBhdCB1cmwgJXMiLCBtX2ZyYW1lLT5sb2Fk ZXIoKS0+aWNvblVSTCgpLnN0cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKIApJbmRleDogV2ViQ29y ZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVy L1Jlc291cmNlTG9hZGVyLmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL2xvYWRlci9S ZXNvdXJjZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM5LDggKzM5LDkgQEAKICNpbmNs dWRlICJJbnNwZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5j bHVkZSAiUHJvZ3Jlc3NUcmFja2VyLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VFcnJvci5oIgogI2lu Y2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCi0jaW5jbHVkZSAiUmVzb3VyY2VFcnJvci5oIgorI2lu Y2x1ZGUgIlJlc291cmNlTG9hZFNjaGVkdWxlci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAj aW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCiAKQEAgLTk1LDYgKzk2LDggQEAKIAogICAgIG1faWRl bnRpZmllciA9IDA7CiAKKyAgICByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+cmVtb3ZlKHRoaXMp OworCiAgICAgaWYgKG1faGFuZGxlKSB7CiAgICAgICAgIC8vIENsZWFyIG91dCB0aGUgUmVzb3Vy Y2VIYW5kbGUncyBjbGllbnQgc28gdGhhdCBpdCBkb2Vzbid0IHRyeSB0byBjYWxsCiAgICAgICAg IC8vIHVzIGJhY2sgYWZ0ZXIgd2UgcmVsZWFzZSBpdCwgdW5sZXNzIGl0IGhhcyBiZWVuIHJlcGxh Y2VkIGJ5IHNvbWVvbmUgZWxzZS4KQEAgLTEzMSwyMSArMTM0LDMyIEBACiAgICAgICAgIHJldHVy biBmYWxzZTsKICAgICB9CiAgICAgCi0gICAgaWYgKG1fZG9jdW1lbnRMb2FkZXItPnNjaGVkdWxl QXJjaGl2ZUxvYWQodGhpcywgY2xpZW50UmVxdWVzdCwgci51cmwoKSkpCi0gICAgICAgIHJldHVy biB0cnVlOwotICAgIAogI2lmIEVOQUJMRShPRkZMSU5FX1dFQl9BUFBMSUNBVElPTlMpCiAgICAg aWYgKG1fZG9jdW1lbnRMb2FkZXItPmFwcGxpY2F0aW9uQ2FjaGVIb3N0KCktPm1heWJlTG9hZFJl c291cmNlKHRoaXMsIGNsaWVudFJlcXVlc3QsIHIudXJsKCkpKQogICAgICAgICByZXR1cm4gdHJ1 ZTsKICNlbmRpZgogCi0gICAgaWYgKG1fZGVmZXJzTG9hZGluZykgeworICAgIGlmIChtX2RlZmVy c0xvYWRpbmcpCiAgICAgICAgIG1fZGVmZXJyZWRSZXF1ZXN0ID0gY2xpZW50UmVxdWVzdDsKKwor ICAgIHJldHVybiB0cnVlOworfQorCitib29sIFJlc291cmNlTG9hZGVyOjpzdGFydCgpCit7Cisg ICAgQVNTRVJUKCFtX2hhbmRsZSk7CisjaWZuZGVmIE5ERUJVRworICAgIHJlc291cmNlTG9hZFNj aGVkdWxlcigpLT5hc3NlcnRMb2FkZXJCZWluZ0NvdW50ZWQodGhpcyk7CisjZW5kaWYKKyAgICAK KyAgICBpZiAobV9kb2N1bWVudExvYWRlci0+c2NoZWR1bGVBcmNoaXZlTG9hZCh0aGlzLCBtX3Jl cXVlc3QsIG1fcmVxdWVzdC51cmwoKSkpCiAgICAgICAgIHJldHVybiB0cnVlOwotICAgIH0KLSAg ICAKLSAgICBtX2hhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUobV9mcmFtZS0+bG9hZGVy KCktPm5ldHdvcmtpbmdDb250ZXh0KCksIGNsaWVudFJlcXVlc3QsIHRoaXMsIG1fZGVmZXJzTG9h ZGluZywgbV9zaG91bGRDb250ZW50U25pZmYpOwogCisgICAgaWYgKG1fZGVmZXJzTG9hZGluZykK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFtX3JlYWNoZWRUZXJtaW5hbFN0YXRl KQorICAgICAgICBtX2hhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUobV9mcmFtZS0+bG9h ZGVyKCktPm5ldHdvcmtpbmdDb250ZXh0KCksIG1fcmVxdWVzdCwgdGhpcywgbV9kZWZlcnNMb2Fk aW5nLCBtX3Nob3VsZENvbnRlbnRTbmlmZik7CiAgICAgcmV0dXJuIHRydWU7CiB9CiAKQEAgLTIy Myw2ICsyMzcsOCBAQAogICAgICAgICBmcmFtZUxvYWRlcigpLT5ub3RpZmllcigpLT53aWxsU2Vu ZFJlcXVlc3QodGhpcywgcmVxdWVzdCwgcmVkaXJlY3RSZXNwb25zZSk7CiAgICAgfQogCisgICAg aWYgKCFyZWRpcmVjdFJlc3BvbnNlLmlzTnVsbCgpKQorICAgICAgICByZXNvdXJjZUxvYWRTY2hl ZHVsZXIoKS0+Y3Jvc3NPcmlnaW5SZWRpcmVjdFJlY2VpdmVkKHRoaXMsIHJlcXVlc3QudXJsKCkp OwogICAgIG1fcmVxdWVzdCA9IHJlcXVlc3Q7CiB9CiAKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL01h aW5SZXNvdXJjZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvTWFpblJl c291cmNlTG9hZGVyLmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJDb3JlL2xvYWRlci9NYWlu UmVzb3VyY2VMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00NCw2ICs0NCw3IEBACiAjZW5k aWYKICNpbmNsdWRlICJSZXNvdXJjZUVycm9yLmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUu aCIKKyNpbmNsdWRlICJSZXNvdXJjZUxvYWRTY2hlZHVsZXIuaCIKICNpbmNsdWRlICJTY2hlbWVS ZWdpc3RyeS5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSA8d3RmL0N1cnJlbnRU aW1lLmg+CkBAIC01NDgsNiArNTQ5LDcgQEAKICAgICBpZiAoc2hvdWxkTG9hZEVtcHR5QmVmb3Jl UmVkaXJlY3QgJiYgIXNob3VsZExvYWRFbXB0eSAmJiBkZWZlcnNMb2FkaW5nKCkpCiAgICAgICAg IHJldHVybiB0cnVlOwogCisgICAgcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPmFkZE1haW5SZXNv dXJjZUxvYWQodGhpcyk7CiAgICAgaWYgKG1fc3Vic3RpdHV0ZURhdGEuaXNWYWxpZCgpKSAKICAg ICAgICAgaGFuZGxlRGF0YUxvYWRTb29uKHIpOwogICAgIGVsc2UgaWYgKHNob3VsZExvYWRFbXB0 eSB8fCBmcmFtZUxvYWRlcigpLT5yZXByZXNlbnRhdGlvbkV4aXN0c0ZvclVSTFNjaGVtZSh1cmwu cHJvdG9jb2woKSkpCkluZGV4OiBXZWJDb3JlL2xvYWRlci9OZXRzY2FwZVBsdWdJblN0cmVhbUxv YWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL05ldHNjYXBlUGx1Z0luU3RyZWFt TG9hZGVyLmgJKHJldmlzaW9uIDcxMjU2KQorKysgV2ViQ29yZS9sb2FkZXIvTmV0c2NhcGVQbHVn SW5TdHJlYW1Mb2FkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcsNyBAQAogCiAgICAg Y2xhc3MgTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXIgOiBwdWJsaWMgUmVzb3VyY2VMb2FkZXIg ewogICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8TmV0c2NhcGVQbHVnSW5T dHJlYW1Mb2FkZXI+IGNyZWF0ZShGcmFtZSosIE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyQ2xp ZW50Kik7CisgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9h ZGVyPiBjcmVhdGUoRnJhbWUqLCBOZXRzY2FwZVBsdWdJblN0cmVhbUxvYWRlckNsaWVudCosIGNv bnN0IFJlc291cmNlUmVxdWVzdCYpOwogICAgICAgICB2aXJ0dWFsIH5OZXRzY2FwZVBsdWdJblN0 cmVhbUxvYWRlcigpOwogCiAgICAgICAgIGJvb2wgaXNEb25lKCkgY29uc3Q7CkluZGV4OiBXZWJD b3JlL2xvYWRlci9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L2xvYWRlci9SZXNvdXJjZUxvYWRTY2hlZHVsZXIuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUv bG9hZGVyL1Jlc291cmNlTG9hZFNjaGVkdWxlci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDEy MSBAQAorLyoKKyAgICBDb3B5cmlnaHQgKEMpIDE5OTggTGFycyBLbm9sbCAoa25vbGxAbXBpLWhk Lm1wZy5kZSkKKyAgICBDb3B5cmlnaHQgKEMpIDIwMDEgRGlyayBNdWVsbGVyIDxtdWVsbGVyQGtk ZS5vcmc+CisgICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA2LCAyMDA3LCAyMDA4IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAgICBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKworICAgIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAgICBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICAgIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAg IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKworICAgIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICAgTUVSQ0hBTlRBQklMSVRZIG9y IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAgICBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgIFlvdSBz aG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljIExpY2Vuc2UKKyAgICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgICAgQm9zdG9u LCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBSZXNvdXJjZUxvYWRTY2hlZHVs ZXJfaAorI2RlZmluZSBSZXNvdXJjZUxvYWRTY2hlZHVsZXJfaAorCisjaW5jbHVkZSAiRnJhbWVM b2FkZXJUeXBlcy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiVGlt ZXIuaCIKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgor I2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Cisj aW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K2NsYXNzIEZyYW1lOworY2xhc3MgS1VSTDsKK2NsYXNzIE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9h ZGVyOworY2xhc3MgTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXJDbGllbnQ7CitjbGFzcyBSZXNv dXJjZUxvYWRlcjsKK2NsYXNzIFJlc291cmNlUmVxdWVzdDsKK2NsYXNzIFN1YnJlc291cmNlTG9h ZGVyOworY2xhc3MgU3VicmVzb3VyY2VMb2FkZXJDbGllbnQ7CisKK2NsYXNzIFJlc291cmNlTG9h ZFNjaGVkdWxlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAgZnJpZW5kIFJl c291cmNlTG9hZFNjaGVkdWxlciogcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CisgICAgCisgICAg ZW51bSBQcmlvcml0eSB7IFZlcnlMb3csIExvdywgTWVkaXVtLCBIaWdoIH07CisgICAgUGFzc1Jl ZlB0cjxTdWJyZXNvdXJjZUxvYWRlcj4gc2NoZWR1bGVTdWJyZXNvdXJjZUxvYWQoRnJhbWUqLCBT dWJyZXNvdXJjZUxvYWRlckNsaWVudCosIGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIFByaW9yaXR5 ID0gTG93LCBTZWN1cml0eUNoZWNrUG9saWN5ID0gRG9TZWN1cml0eUNoZWNrLCBib29sIHNlbmRS ZXNvdXJjZUxvYWRDYWxsYmFja3MgPSB0cnVlLCBib29sIHNob3VsZENvbnRlbnRTbmlmZiA9IHRy dWUpOworICAgIFBhc3NSZWZQdHI8TmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXI+IHNjaGVkdWxl UGx1Z2luU3RyZWFtTG9hZChGcmFtZSosIE5ldHNjYXBlUGx1Z0luU3RyZWFtTG9hZGVyQ2xpZW50 KiwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdm9pZCBhZGRNYWluUmVzb3VyY2VMb2Fk KFJlc291cmNlTG9hZGVyKik7CisgICAgdm9pZCByZW1vdmUoUmVzb3VyY2VMb2FkZXIqKTsKKyAg ICB2b2lkIGNyb3NzT3JpZ2luUmVkaXJlY3RSZWNlaXZlZChSZXNvdXJjZUxvYWRlciosIGNvbnN0 IEtVUkwmIHJlZGlyZWN0VVJMKTsKKyAgICAKKyAgICB2b2lkIHNlcnZlUGVuZGluZ1JlcXVlc3Rz KFByaW9yaXR5IG1pbmltdW1Qcmlvcml0eSA9IFZlcnlMb3cpOworICAgIHZvaWQgc3VzcGVuZFBl bmRpbmdSZXF1ZXN0cygpOworICAgIHZvaWQgcmVzdW1lUGVuZGluZ1JlcXVlc3RzKCk7CisgICAg CisjaWZuZGVmIE5ERUJVRworICAgIHZvaWQgYXNzZXJ0TG9hZGVyQmVpbmdDb3VudGVkKFJlc291 cmNlTG9hZGVyKik7CisjZW5kaWYKKworcHJpdmF0ZToKKyAgICBSZXNvdXJjZUxvYWRTY2hlZHVs ZXIoKTsKKyAgICB+UmVzb3VyY2VMb2FkU2NoZWR1bGVyKCk7CisKKyAgICB2b2lkIHNjaGVkdWxl TG9hZChSZXNvdXJjZUxvYWRlciosIFByaW9yaXR5KTsKKyAgICB2b2lkIHNjaGVkdWxlU2VydmVQ ZW5kaW5nUmVxdWVzdHMoKTsKKyAgICB2b2lkIHJlcXVlc3RUaW1lckZpcmVkKFRpbWVyPFJlc291 cmNlTG9hZFNjaGVkdWxlcj4qKTsKKworICAgIGNsYXNzIEhvc3RJbmZvcm1hdGlvbiA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CisgICAgcHVibGljOgorICAgICAgICBIb3N0SW5mb3JtYXRpb24oY29u c3QgU3RyaW5nJiwgdW5zaWduZWQpOworICAgICAgICB+SG9zdEluZm9ybWF0aW9uKCk7CisgICAg ICAgIAorICAgICAgICBjb25zdCBTdHJpbmcmIG5hbWUoKSBjb25zdCB7IHJldHVybiBtX25hbWU7 IH0KKyAgICAgICAgdm9pZCBzY2hlZHVsZShSZXNvdXJjZUxvYWRlciosIFByaW9yaXR5ID0gVmVy eUxvdyk7CisgICAgICAgIHZvaWQgYWRkTG9hZEluUHJvZ3Jlc3MoUmVzb3VyY2VMb2FkZXIqKTsK KyAgICAgICAgdm9pZCByZW1vdmUoUmVzb3VyY2VMb2FkZXIqKTsKKyAgICAgICAgYm9vbCBoYXNS ZXF1ZXN0cygpIGNvbnN0OworICAgICAgICBib29sIGxpbWl0UmVxdWVzdHMoKSBjb25zdCB7IHJl dHVybiBtX3JlcXVlc3RzTG9hZGluZy5zaXplKCkgPj0gbV9tYXhSZXF1ZXN0c0luRmxpZ2h0OyB9 CisgICAgICAgIAorI2lmbmRlZiBOREVCVUcKKyAgICAgICAgdm9pZCBhc3NlcnRMb2FkZXJCZWlu Z0NvdW50ZWQoUmVzb3VyY2VMb2FkZXIqKTsKKyNlbmRpZgorCisgICAgICAgIHR5cGVkZWYgRGVx dWU8UmVmUHRyPFJlc291cmNlTG9hZGVyPiA+IFJlcXVlc3RRdWV1ZTsKKyAgICAgICAgUmVxdWVz dFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcoUHJpb3JpdHkgcHJpb3JpdHkpIHsgcmV0dXJuIG1fcmVx dWVzdHNQZW5kaW5nW3ByaW9yaXR5XTsgfQorCisgICAgcHJpdmF0ZTogICAgICAgICAgICAgICAg ICAgIAorICAgICAgICBSZXF1ZXN0UXVldWUgbV9yZXF1ZXN0c1BlbmRpbmdbSGlnaCArIDFdOwor ICAgICAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPFJlc291cmNlTG9hZGVyPiA+IFJlcXVlc3RN YXA7CisgICAgICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0c0xvYWRpbmc7CisgICAgICAgIGNvbnN0 IFN0cmluZyBtX25hbWU7CisgICAgICAgIGNvbnN0IGludCBtX21heFJlcXVlc3RzSW5GbGlnaHQ7 CisgICAgfTsKKworICAgIGVudW0gQ3JlYXRlSG9zdFBvbGljeSB7CisgICAgICAgIENyZWF0ZUlm Tm90Rm91bmQsCisgICAgICAgIEZpbmRPbmx5CisgICAgfTsKKyAgICAKKyAgICBIb3N0SW5mb3Jt YXRpb24qIGhvc3RGb3JVUkwoY29uc3QgS1VSTCYsIENyZWF0ZUhvc3RQb2xpY3kgPSBGaW5kT25s eSk7CisgICAgdm9pZCBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhIb3N0SW5mb3JtYXRpb24qLCBQcmlv cml0eSk7CisKKyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBIb3N0SW5mb3JtYXRpb24qLCBT dHJpbmdIYXNoPiBIb3N0TWFwOworICAgIEhvc3RNYXAgbV9ob3N0czsKKyAgICBIb3N0SW5mb3Jt YXRpb24qIG1fbm9uSFRUUFByb3RvY29sSG9zdDsKKyAgICAgICAgCisgICAgVGltZXI8UmVzb3Vy Y2VMb2FkU2NoZWR1bGVyPiBtX3JlcXVlc3RUaW1lcjsKKworICAgIGJvb2wgbV9pc1N1c3BlbmRp bmdQZW5kaW5nUmVxdWVzdHM7Cit9OworCitSZXNvdXJjZUxvYWRTY2hlZHVsZXIqIHJlc291cmNl TG9hZFNjaGVkdWxlcigpOworCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9sb2FkZXIvUmVz b3VyY2VMb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRl ci5oCShyZXZpc2lvbiA3MTI1NikKKysrIFdlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgJ KHdvcmtpbmcgY29weSkKQEAgLTEyMiw5ICsxMjIsMTMgQEAKICAgICAgICAgdmlydHVhbCBBc3lu Y0ZpbGVTdHJlYW0qIGNyZWF0ZUFzeW5jRmlsZVN0cmVhbShGaWxlU3RyZWFtQ2xpZW50Kik7CiAj ZW5kaWYKIAorICAgICAgICBjb25zdCBLVVJMJiB1cmwoKSBjb25zdCB7IHJldHVybiBtX3JlcXVl c3QudXJsKCk7IH0gCiAgICAgICAgIFJlc291cmNlSGFuZGxlKiBoYW5kbGUoKSBjb25zdCB7IHJl dHVybiBtX2hhbmRsZS5nZXQoKTsgfQogICAgICAgICBib29sIHNlbmRSZXNvdXJjZUxvYWRDYWxs YmFja3MoKSBjb25zdCB7IHJldHVybiBtX3NlbmRSZXNvdXJjZUxvYWRDYWxsYmFja3M7IH0KIAor ICAgICAgICAvLyBDYWxsZWQgYnkgUmVzb3VyY2VMb2FkU2NoZWR1bGVyIHRvIGNyZWF0ZSBhIFJl c291cmNlSGFuZGxlIGFuZCBhY3R1YWxseSBiZWdpbiB0aGUgbG9hZC4KKyAgICAgICAgYm9vbCBz dGFydCgpOworCiAgICAgICAgIHZvaWQgc2V0U2hvdWxkQnVmZmVyRGF0YShib29sIHNob3VsZEJ1 ZmZlckRhdGEpOwogCiAgICAgcHJvdGVjdGVkOgpJbmRleDogV2ViQ29yZS9sb2FkZXIvbG9hZGVy LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCShyZXZpc2lvbiA3 MTI1NikKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4 LDQ1ICsyOCwyMCBAQAogI2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCiAjaW5jbHVkZSAiQ2FjaGVk UmVzb3VyY2UuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUxvYWRlci5oIgotI2luY2x1ZGUg Ikluc3BlY3Rvckluc3RydW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVk ZSAiRnJhbWVMb2FkZXIuaCIKLSNpbmNsdWRlICJIVE1MRG9jdW1lbnQuaCIKICNpbmNsdWRlICJM b2dnaW5nLmgiCiAjaW5jbHVkZSAiUmVxdWVzdC5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxl LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmgiCiAjaW5jbHVkZSAiUmVzb3Vy Y2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgotI2luY2x1ZGUgIlNl Y3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0jaW5jbHVkZSAiU3Vi cmVzb3VyY2VMb2FkZXIuaCIKICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUg PHd0Zi9WZWN0b3IuaD4KIAotI2RlZmluZSBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxFRCAxCi0K IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotI2lmIFJFUVVFU1RfTUFOQUdFTUVOVF9FTkFCTEVECi0v LyBNYXRjaCB0aGUgcGFyYWxsZWwgY29ubmVjdGlvbiBjb3VudCB1c2VkIGJ5IHRoZSBuZXR3b3Jr aW5nIGxheWVyCi1zdGF0aWMgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3Q7Ci0v LyBIYXZpbmcgYSBsaW1pdCBtaWdodCBzdGlsbCBoZWxwIGdldHRpbmcgbW9yZSBpbXBvcnRhbnQg cmVzb3VyY2VzIGZpcnN0Ci1zdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4UmVxdWVzdHNJbkZsaWdo dEZvck5vbkhUVFBQcm90b2NvbHMgPSAyMDsKLSNlbHNlCi1zdGF0aWMgY29uc3QgdW5zaWduZWQg bWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QgPSAxMDAwMDsKLXN0YXRpYyBjb25zdCB1bnNpZ25l ZCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29scyA9IDEwMDAwOwotI2VuZGlm Ci0KLUxvYWRlcjo6TG9hZGVyKCkKLSAgICA6IG1fcmVxdWVzdFRpbWVyKHRoaXMsICZMb2FkZXI6 OnJlcXVlc3RUaW1lckZpcmVkKQotICAgICwgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMo ZmFsc2UpCi17Ci0gICAgbV9ub25IVFRQUHJvdG9jb2xIb3N0ID0gSG9zdDo6Y3JlYXRlKEF0b21p Y1N0cmluZygpLCBtYXhSZXF1ZXN0c0luRmxpZ2h0Rm9yTm9uSFRUUFByb3RvY29scyk7Ci0jaWYg UkVRVUVTVF9NQU5BR0VNRU5UX0VOQUJMRUQKLSAgICBtYXhSZXF1ZXN0c0luRmxpZ2h0UGVySG9z dCA9IGluaXRpYWxpemVNYXhpbXVtSFRUUENvbm5lY3Rpb25Db3VudFBlckhvc3QoKTsKLSNlbmRp ZgotfQotCiBMb2FkZXI6On5Mb2FkZXIoKQogeyAgICAKICAgICBBU1NFUlRfTk9UX1JFQUNIRUQo KTsKQEAgLTk1LDMwNyArNzAsMTAyIEBACiAgICAgcmV0dXJuIFJlc291cmNlUmVxdWVzdDo6VGFy Z2V0SXNTdWJyZXNvdXJjZTsKIH0KIAotTG9hZGVyOjpQcmlvcml0eSBMb2FkZXI6OmRldGVybWlu ZVByaW9yaXR5KGNvbnN0IENhY2hlZFJlc291cmNlKiByZXNvdXJjZSkgY29uc3QKK3N0YXRpYyBS ZXNvdXJjZUxvYWRTY2hlZHVsZXI6OlByaW9yaXR5IGRldGVybWluZVByaW9yaXR5KGNvbnN0IENh Y2hlZFJlc291cmNlKiByZXNvdXJjZSkKIHsKLSNpZiBSRVFVRVNUX01BTkFHRU1FTlRfRU5BQkxF RAogICAgIHN3aXRjaCAocmVzb3VyY2UtPnR5cGUoKSkgewogICAgICAgICBjYXNlIENhY2hlZFJl c291cmNlOjpDU1NTdHlsZVNoZWV0OgogI2lmIEVOQUJMRShYU0xUKQogICAgICAgICBjYXNlIENh Y2hlZFJlc291cmNlOjpYU0xTdHlsZVNoZWV0OgogI2VuZGlmCi0gICAgICAgICAgICByZXR1cm4g SGlnaDsKLSAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJjZTo6U2NyaXB0OiAKKyAgICAgICAgICAg IHJldHVybiBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OkhpZ2g7CisgICAgICAgIGNhc2UgQ2FjaGVk UmVzb3VyY2U6OlNjcmlwdDoKICAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJjZTo6Rm9udFJlc291 cmNlOgotICAgICAgICAgICAgcmV0dXJuIE1lZGl1bTsKKyAgICAgICAgICAgIHJldHVybiBSZXNv dXJjZUxvYWRTY2hlZHVsZXI6Ok1lZGl1bTsKICAgICAgICAgY2FzZSBDYWNoZWRSZXNvdXJjZTo6 SW1hZ2VSZXNvdXJjZToKLSAgICAgICAgICAgIHJldHVybiBMb3c7CisgICAgICAgICAgICByZXR1 cm4gUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpMb3c7CiAjaWYgRU5BQkxFKExJTktfUFJFRkVUQ0gp CiAgICAgICAgIGNhc2UgQ2FjaGVkUmVzb3VyY2U6OkxpbmtQcmVmZXRjaDoKLSAgICAgICAgICAg IHJldHVybiBWZXJ5TG93OworICAgICAgICAgICAgcmV0dXJuIFJlc291cmNlTG9hZFNjaGVkdWxl cjo6VmVyeUxvdzsKICNlbmRpZgogICAgIH0KICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSAg ICByZXR1cm4gTG93OwotI2Vsc2UKLSAgICByZXR1cm4gSGlnaDsKLSNlbmRpZgorICAgIHJldHVy biBSZXNvdXJjZUxvYWRTY2hlZHVsZXI6OkxvdzsKIH0KIAogdm9pZCBMb2FkZXI6OmxvYWQoQ2Fj aGVkUmVzb3VyY2VMb2FkZXIqIGNhY2hlZFJlc291cmNlTG9hZGVyLCBDYWNoZWRSZXNvdXJjZSog cmVzb3VyY2UsIGJvb2wgaW5jcmVtZW50YWwsIFNlY3VyaXR5Q2hlY2tQb2xpY3kgc2VjdXJpdHlD aGVjaywgYm9vbCBzZW5kUmVzb3VyY2VMb2FkQ2FsbGJhY2tzKQogewotICAgIExPRyhSZXNvdXJj ZUxvYWRpbmcsICJMb2FkZXI6OmxvYWQgcmVzb3VyY2UgJXAgJyVzJyIsIHJlc291cmNlLCByZXNv dXJjZS0+dXJsKCkubGF0aW4xKCkuZGF0YSgpKTsKIAogICAgIEFTU0VSVChjYWNoZWRSZXNvdXJj ZUxvYWRlcik7CiAgICAgUmVxdWVzdCogcmVxdWVzdCA9IG5ldyBSZXF1ZXN0KGNhY2hlZFJlc291 cmNlTG9hZGVyLCByZXNvdXJjZSwgaW5jcmVtZW50YWwsIHNlY3VyaXR5Q2hlY2ssIHNlbmRSZXNv dXJjZUxvYWRDYWxsYmFja3MpOwogCi0gICAgUmVmUHRyPEhvc3Q+IGhvc3Q7Ci0gICAgS1VSTCB1 cmwoUGFyc2VkVVJMU3RyaW5nLCByZXNvdXJjZS0+dXJsKCkpOwotICAgIGlmICh1cmwucHJvdG9j b2xJbkhUVFBGYW1pbHkoKSkgewotICAgICAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3koKTsK LSAgICAgICAgQXRvbWljU3RyaW5nIGhvc3ROYW1lID0gdXJsLmhvc3QoKTsKLSAgICAgICAgaG9z dCA9IG1faG9zdHMuZ2V0KGhvc3ROYW1lLmltcGwoKSk7Ci0gICAgICAgIGlmICghaG9zdCkgewot ICAgICAgICAgICAgaG9zdCA9IEhvc3Q6OmNyZWF0ZShob3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZs aWdodFBlckhvc3QpOwotICAgICAgICAgICAgbV9ob3N0cy5hZGQoaG9zdE5hbWUuaW1wbCgpLCBo b3N0KTsKLSAgICAgICAgfQotICAgIH0gZWxzZSAKLSAgICAgICAgaG9zdCA9IG1fbm9uSFRUUFBy b3RvY29sSG9zdDsKLSAgICAKLSAgICBib29sIGhhZFJlcXVlc3RzID0gaG9zdC0+aGFzUmVxdWVz dHMoKTsKLSAgICBQcmlvcml0eSBwcmlvcml0eSA9IGRldGVybWluZVByaW9yaXR5KHJlc291cmNl KTsKLSAgICBob3N0LT5hZGRSZXF1ZXN0KHJlcXVlc3QsIHByaW9yaXR5KTsKICAgICBjYWNoZWRS ZXNvdXJjZUxvYWRlci0+aW5jcmVtZW50UmVxdWVzdENvdW50KHJlcXVlc3QtPmNhY2hlZFJlc291 cmNlKCkpOwogCi0gICAgaWYgKHByaW9yaXR5ID4gTG93IHx8ICF1cmwucHJvdG9jb2xJbkhUVFBG YW1pbHkoKSB8fCAocHJpb3JpdHkgPT0gTG93ICYmICFoYWRSZXF1ZXN0cykpIHsKLSAgICAgICAg Ly8gVHJ5IHRvIHJlcXVlc3QgaW1wb3J0YW50IHJlc291cmNlcyBpbW1lZGlhdGVseQotICAgICAg ICBob3N0LT5zZXJ2ZVBlbmRpbmdSZXF1ZXN0cyhwcmlvcml0eSk7Ci0gICAgfSBlbHNlIHsKLSAg ICAgICAgLy8gSGFuZGxlIGFzeW5jaHJvbm91c2x5IHNvIGVhcmx5IGxvdyBwcmlvcml0eSByZXF1 ZXN0cyBkb24ndCBnZXQgc2NoZWR1bGVkIGJlZm9yZSBsYXRlciBoaWdoIHByaW9yaXR5IG9uZXMK LSAgICAgICAgSW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uOjpkaWRTY2hlZHVsZVJlc291cmNlUmVx dWVzdChjYWNoZWRSZXNvdXJjZUxvYWRlci0+ZG9jKCksIHJlc291cmNlLT51cmwoKSk7Ci0gICAg ICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKLSAgICB9Ci19Ci0gICAgCi12b2lk IExvYWRlcjo6c2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpCi17Ci0gICAgTE9HKFJlc291 cmNlTG9hZGluZywgIkxvYWRlcjo6c2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cywgbV9yZXF1 ZXN0VGltZXIuaXNBY3RpdmUoKT0ldSIsIG1fcmVxdWVzdFRpbWVyLmlzQWN0aXZlKCkpOwotICAg IGlmICghbV9yZXF1ZXN0VGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV9yZXF1ZXN0VGltZXIu c3RhcnRPbmVTaG90KDApOwotfQorICAgIFJlc291cmNlUmVxdWVzdCByZXNvdXJjZVJlcXVlc3Qo cmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+dXJsKCkpOworICAgIHJlc291cmNlUmVxdWVzdC5z ZXRUYXJnZXRUeXBlKGNhY2hlZFJlc291cmNlVHlwZVRvVGFyZ2V0VHlwZShyZXF1ZXN0LT5jYWNo ZWRSZXNvdXJjZSgpLT50eXBlKCkpKTsKIAotdm9pZCBMb2FkZXI6OnJlcXVlc3RUaW1lckZpcmVk KFRpbWVyPExvYWRlcj4qKSAKLXsKLSAgICBMT0coUmVzb3VyY2VMb2FkaW5nLCAiTG9hZGVyOjpy ZXF1ZXN0VGltZXJGaXJlZFxuIik7Ci0gICAgc2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKLX0KKyAg ICBpZiAoIXJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPmFjY2VwdCgpLmlzRW1wdHkoKSkKKyAg ICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBBY2NlcHQocmVxdWVzdC0+Y2FjaGVkUmVzb3Vy Y2UoKS0+YWNjZXB0KCkpOwogCi12b2lkIExvYWRlcjo6c2VydmVQZW5kaW5nUmVxdWVzdHMoUHJp b3JpdHkgbWluaW11bVByaW9yaXR5KQotewotICAgIExPRyhSZXNvdXJjZUxvYWRpbmcsICJMb2Fk ZXI6OnNlcnZlUGVuZGluZ1JlcXVlc3RzLiBtX2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cz0l ZCIsIG1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKTsKLSAgICBpZiAobV9pc1N1c3BlbmRp bmdQZW5kaW5nUmVxdWVzdHMpCi0gICAgICAgIHJldHVybjsKLQotICAgIG1fcmVxdWVzdFRpbWVy LnN0b3AoKTsKLSAgICAKLSAgICBtX25vbkhUVFBQcm90b2NvbEhvc3QtPnNlcnZlUGVuZGluZ1Jl cXVlc3RzKG1pbmltdW1Qcmlvcml0eSk7Ci0KLSAgICBWZWN0b3I8SG9zdCo+IGhvc3RzVG9TZXJ2 ZTsKLSAgICBtX2hvc3RzLmNoZWNrQ29uc2lzdGVuY3koKTsKLSAgICBIb3N0TWFwOjppdGVyYXRv ciBpID0gbV9ob3N0cy5iZWdpbigpOwotICAgIEhvc3RNYXA6Oml0ZXJhdG9yIGVuZCA9IG1faG9z dHMuZW5kKCk7Ci0gICAgZm9yICg7aSAhPSBlbmQ7ICsraSkKLSAgICAgICAgaG9zdHNUb1NlcnZl LmFwcGVuZChpLT5zZWNvbmQuZ2V0KCkpOwotICAgICAgICAKLSAgICBmb3IgKHVuc2lnbmVkIG4g PSAwOyBuIDwgaG9zdHNUb1NlcnZlLnNpemUoKTsgKytuKSB7Ci0gICAgICAgIEhvc3QqIGhvc3Qg PSBob3N0c1RvU2VydmVbbl07Ci0gICAgICAgIGlmIChob3N0LT5oYXNSZXF1ZXN0cygpKQotICAg ICAgICAgICAgaG9zdC0+c2VydmVQZW5kaW5nUmVxdWVzdHMobWluaW11bVByaW9yaXR5KTsKLSAg ICAgICAgZWxzZSBpZiAoIWhvc3QtPnByb2Nlc3NpbmdSZXNvdXJjZSgpKXsKLSAgICAgICAgICAg IEF0b21pY1N0cmluZyBuYW1lID0gaG9zdC0+bmFtZSgpOwotICAgICAgICAgICAgbV9ob3N0cy5y ZW1vdmUobmFtZS5pbXBsKCkpOworICAgIGlmIChyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5p c0NhY2hlVmFsaWRhdG9yKCkpIHsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlVG9S ZXZhbGlkYXRlID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+cmVzb3VyY2VUb1JldmFsaWRh dGUoKTsKKyAgICAgICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5jYW5Vc2VDYWNoZVZh bGlkYXRvcigpKTsKKyAgICAgICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5pc0xvYWRl ZCgpKTsKKyAgICAgICAgY29uc3QgU3RyaW5nJiBsYXN0TW9kaWZpZWQgPSByZXNvdXJjZVRvUmV2 YWxpZGF0ZS0+cmVzcG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkxhc3QtTW9kaWZpZWQiKTsKKyAg ICAgICAgY29uc3QgU3RyaW5nJiBlVGFnID0gcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlc3BvbnNl KCkuaHR0cEhlYWRlckZpZWxkKCJFVGFnIik7CisgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlz RW1wdHkoKSB8fCAhZVRhZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgIEFTU0VSVChjYWNoZWRS ZXNvdXJjZUxvYWRlci0+Y2FjaGVQb2xpY3koKSAhPSBDYWNoZVBvbGljeVJlbG9hZCk7CisgICAg ICAgICAgICBpZiAoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNhY2hlUG9saWN5KCkgPT0gQ2FjaGVQ b2xpY3lSZXZhbGlkYXRlKQorICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQ SGVhZGVyRmllbGQoIkNhY2hlLUNvbnRyb2wiLCAibWF4LWFnZT0wIik7CisgICAgICAgICAgICBp ZiAoIWxhc3RNb2RpZmllZC5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1 ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiSWYtTW9kaWZpZWQtU2luY2UiLCBsYXN0TW9kaWZpZWQp OworICAgICAgICAgICAgaWYgKCFlVGFnLmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICByZXNv dXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJJZi1Ob25lLU1hdGNoIiwgZVRhZyk7CiAg ICAgICAgIH0KICAgICB9Ci19Ci0KLXZvaWQgTG9hZGVyOjpzdXNwZW5kUGVuZGluZ1JlcXVlc3Rz KCkKLXsKLSAgICBBU1NFUlQoIW1faXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVlc3RzKTsKLSAgICBt X2lzU3VzcGVuZGluZ1BlbmRpbmdSZXF1ZXN0cyA9IHRydWU7Ci19Ci0KLXZvaWQgTG9hZGVyOjpy ZXN1bWVQZW5kaW5nUmVxdWVzdHMoKQotewotICAgIEFTU0VSVChtX2lzU3VzcGVuZGluZ1BlbmRp bmdSZXF1ZXN0cyk7Ci0gICAgbV9pc1N1c3BlbmRpbmdQZW5kaW5nUmVxdWVzdHMgPSBmYWxzZTsK LSAgICBpZiAoIW1faG9zdHMuaXNFbXB0eSgpIHx8IG1fbm9uSFRUUFByb3RvY29sSG9zdC0+aGFz UmVxdWVzdHMoKSkKLSAgICAgICAgc2NoZWR1bGVTZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOwotfQot Ci12b2lkIExvYWRlcjo6bm9uQ2FjaGVSZXF1ZXN0SW5GbGlnaHQoY29uc3QgS1VSTCYgdXJsKQot ewotICAgIGlmICghdXJsLnByb3RvY29sSW5IVFRQRmFtaWx5KCkpCi0gICAgICAgIHJldHVybjsK ICAgICAKLSAgICBBdG9taWNTdHJpbmcgaG9zdE5hbWUgPSB1cmwuaG9zdCgpOwotICAgIG1faG9z dHMuY2hlY2tDb25zaXN0ZW5jeSgpOwotICAgIFJlZlB0cjxIb3N0PiBob3N0ID0gbV9ob3N0cy5n ZXQoaG9zdE5hbWUuaW1wbCgpKTsKLSAgICBpZiAoIWhvc3QpIHsKLSAgICAgICAgaG9zdCA9IEhv c3Q6OmNyZWF0ZShob3N0TmFtZSwgbWF4UmVxdWVzdHNJbkZsaWdodFBlckhvc3QpOwotICAgICAg ICBtX2hvc3RzLmFkZChob3N0TmFtZS5pbXBsKCksIGhvc3QpOwotICAgIH0KKyNpZiBFTkFCTEUo TElOS19QUkVGRVRDSCkKKyAgICBpZiAocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+dHlwZSgp ID09IENhY2hlZFJlc291cmNlOjpMaW5rUHJlZmV0Y2gpCisgICAgICAgIHJlc291cmNlUmVxdWVz dC5zZXRIVFRQSGVhZGVyRmllbGQoIlgtUHVycG9zZSIsICJwcmVmZXRjaCIpOworI2VuZGlmCiAK LSAgICBob3N0LT5ub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpOworICAgIFJlZlB0cjxTdWJyZXNv dXJjZUxvYWRlcj4gbG9hZGVyID0gcmVzb3VyY2VMb2FkU2NoZWR1bGVyKCktPnNjaGVkdWxlU3Vi cmVzb3VyY2VMb2FkKGNhY2hlZFJlc291cmNlTG9hZGVyLT5kb2MoKS0+ZnJhbWUoKSwKKyAgICAg ICAgdGhpcywgcmVzb3VyY2VSZXF1ZXN0LCBkZXRlcm1pbmVQcmlvcml0eShyZXNvdXJjZSksIHJl cXVlc3QtPnNob3VsZERvU2VjdXJpdHlDaGVjaygpLCByZXF1ZXN0LT5zZW5kUmVzb3VyY2VMb2Fk Q2FsbGJhY2tzKCkpOworICAgIGlmIChsb2FkZXIpIHsKKyAgICAgICAgbV9yZXF1ZXN0c0xvYWRp bmcuYWRkKGxvYWRlci5yZWxlYXNlKCksIHJlcXVlc3QpOworICAgICAgICByZXF1ZXN0LT5jYWNo ZWRSZXNvdXJjZSgpLT5zZXRSZXF1ZXN0ZWRGcm9tTmV0d29ya2luZ0xheWVyKCk7CisgICAgfSBl bHNlIHsKKyAgICAgICAgLy8gRklYTUU6IFdoYXQgaWYgcmVzb3VyY2VzIGluIG90aGVyIGZyYW1l cyB3ZXJlIHdhaXRpbmcgZm9yIHRoaXMgcmV2YWxpZGF0aW9uPyAKKyAgICAgICAgTE9HKFJlc291 cmNlTG9hZGluZywgIkNhbm5vdCBzdGFydCBsb2FkaW5nICclcyciLCByZXF1ZXN0LT5jYWNoZWRS ZXNvdXJjZSgpLT51cmwoKS5sYXRpbjEoKS5kYXRhKCkpOyAgICAgICAgICAgICAKKyAgICAgICAg Y2FjaGVkUmVzb3VyY2VMb2FkZXItPmRlY3JlbWVudFJlcXVlc3RDb3VudChyZXF1ZXN0LT5jYWNo ZWRSZXNvdXJjZSgpKTsKKyAgICAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPnNldExvYWRJblBy b2dyZXNzKHRydWUpOworICAgICAgICBpZiAocmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlkYXRl KCkpIAorICAgICAgICAgICAgY2FjaGUoKS0+cmV2YWxpZGF0aW9uRmFpbGVkKHJlc291cmNlKTsg CisgICAgICAgIHJlc291cmNlLT5lcnJvcigpOworICAgICAgICBjYWNoZWRSZXNvdXJjZUxvYWRl ci0+c2V0TG9hZEluUHJvZ3Jlc3MoZmFsc2UpOworICAgICAgICBkZWxldGUgcmVxdWVzdDsKKyAg ICB9CiB9CiAKLXZvaWQgTG9hZGVyOjpub25DYWNoZVJlcXVlc3RDb21wbGV0ZShjb25zdCBLVVJM JiB1cmwpCi17Ci0gICAgaWYgKCF1cmwucHJvdG9jb2xJbkhUVFBGYW1pbHkoKSkKLSAgICAgICAg cmV0dXJuOwotICAgIAotICAgIEF0b21pY1N0cmluZyBob3N0TmFtZSA9IHVybC5ob3N0KCk7Ci0g ICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgUmVmUHRyPEhvc3Q+IGhvc3QgPSBt X2hvc3RzLmdldChob3N0TmFtZS5pbXBsKCkpOwotICAgIEFTU0VSVChob3N0KTsKLSAgICBpZiAo IWhvc3QpCi0gICAgICAgIHJldHVybjsKLQotICAgIGhvc3QtPm5vbkNhY2hlUmVxdWVzdENvbXBs ZXRlKCk7Ci19Ci0KIHZvaWQgTG9hZGVyOjpjYW5jZWxSZXF1ZXN0cyhDYWNoZWRSZXNvdXJjZUxv YWRlciogY2FjaGVkUmVzb3VyY2VMb2FkZXIpCiB7CiAgICAgY2FjaGVkUmVzb3VyY2VMb2FkZXIt PmNsZWFyUGVuZGluZ1ByZWxvYWRzKCk7CiAKLSAgICBpZiAobV9ub25IVFRQUHJvdG9jb2xIb3N0 LT5oYXNSZXF1ZXN0cygpKQotICAgICAgICBtX25vbkhUVFBQcm90b2NvbEhvc3QtPmNhbmNlbFJl cXVlc3RzKGNhY2hlZFJlc291cmNlTG9hZGVyKTsKLSAgICAKLSAgICBWZWN0b3I8SG9zdCo+IGhv c3RzVG9DYW5jZWw7Ci0gICAgbV9ob3N0cy5jaGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgSG9zdE1h cDo6aXRlcmF0b3IgaSA9IG1faG9zdHMuYmVnaW4oKTsKLSAgICBIb3N0TWFwOjppdGVyYXRvciBl bmQgPSBtX2hvc3RzLmVuZCgpOwotICAgIGZvciAoO2kgIT0gZW5kOyArK2kpCi0gICAgICAgIGhv c3RzVG9DYW5jZWwuYXBwZW5kKGktPnNlY29uZC5nZXQoKSk7Ci0KLSAgICBmb3IgKHVuc2lnbmVk IG4gPSAwOyBuIDwgaG9zdHNUb0NhbmNlbC5zaXplKCk7ICsrbikgewotICAgICAgICBIb3N0KiBo b3N0ID0gaG9zdHNUb0NhbmNlbFtuXTsKLSAgICAgICAgaWYgKGhvc3QtPmhhc1JlcXVlc3RzKCkp Ci0gICAgICAgICAgICBob3N0LT5jYW5jZWxSZXF1ZXN0cyhjYWNoZWRSZXNvdXJjZUxvYWRlcik7 CisgICAgVmVjdG9yPFN1YnJlc291cmNlTG9hZGVyKiwgMjU2PiBsb2FkZXJzVG9DYW5jZWw7Cisg ICAgUmVxdWVzdE1hcDo6aXRlcmF0b3IgZW5kID0gbV9yZXF1ZXN0c0xvYWRpbmcuZW5kKCk7Cisg ICAgZm9yIChSZXF1ZXN0TWFwOjppdGVyYXRvciBpID0gbV9yZXF1ZXN0c0xvYWRpbmcuYmVnaW4o KTsgaSAhPSBlbmQ7ICsraSkgeworICAgICAgICBSZXF1ZXN0KiByID0gaS0+c2Vjb25kOworICAg ICAgICBpZiAoci0+Y2FjaGVkUmVzb3VyY2VMb2FkZXIoKSA9PSBjYWNoZWRSZXNvdXJjZUxvYWRl cikKKyAgICAgICAgICAgIGxvYWRlcnNUb0NhbmNlbC5hcHBlbmQoaS0+Zmlyc3QuZ2V0KCkpOwog ICAgIH0KIAotICAgIHNjaGVkdWxlU2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKLSAgICAKLSAgICBB U1NFUlQoY2FjaGVkUmVzb3VyY2VMb2FkZXItPnJlcXVlc3RDb3VudCgpID09IChjYWNoZWRSZXNv dXJjZUxvYWRlci0+bG9hZEluUHJvZ3Jlc3MoKSA/IDEgOiAwKSk7Ci19Ci0KLUxvYWRlcjo6SG9z dDo6SG9zdChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIG1heFJlcXVlc3RzSW5G bGlnaHQpCi0gICAgOiBtX25hbWUobmFtZSkKLSAgICAsIG1fbWF4UmVxdWVzdHNJbkZsaWdodCht YXhSZXF1ZXN0c0luRmxpZ2h0KQotICAgICwgbV9udW1SZXNvdXJjZXNQcm9jZXNzaW5nKDApCi0g ICAgLCBtX25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQoMCkKLXsKLX0KLQotTG9hZGVyOjpIb3N0 Ojp+SG9zdCgpCi17Ci0gICAgQVNTRVJUKG1fcmVxdWVzdHNMb2FkaW5nLmlzRW1wdHkoKSk7Ci0g ICAgZm9yICh1bnNpZ25lZCBwID0gMDsgcCA8PSBIaWdoOyBwKyspCi0gICAgICAgIEFTU0VSVCht X3JlcXVlc3RzUGVuZGluZ1twXS5pc0VtcHR5KCkpOwotfQotICAgIAotdm9pZCBMb2FkZXI6Okhv c3Q6OmFkZFJlcXVlc3QoUmVxdWVzdCogcmVxdWVzdCwgUHJpb3JpdHkgcHJpb3JpdHkpCi17Ci0g ICAgbV9yZXF1ZXN0c1BlbmRpbmdbcHJpb3JpdHldLmFwcGVuZChyZXF1ZXN0KTsKLX0KLSAgICAK LXZvaWQgTG9hZGVyOjpIb3N0Ojpub25DYWNoZVJlcXVlc3RJbkZsaWdodCgpCi17Ci0gICAgKytt X25vbkNhY2hlZFJlcXVlc3RzSW5GbGlnaHQ7Ci19Ci0KLXZvaWQgTG9hZGVyOjpIb3N0Ojpub25D YWNoZVJlcXVlc3RDb21wbGV0ZSgpCi17Ci0gICAgLS1tX25vbkNhY2hlZFJlcXVlc3RzSW5GbGln aHQ7Ci0gICAgQVNTRVJUKG1fbm9uQ2FjaGVkUmVxdWVzdHNJbkZsaWdodCA+PSAwKTsKLQotICAg IGNhY2hlKCktPmxvYWRlcigpLT5zY2hlZHVsZVNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7Ci19Ci0K LWJvb2wgTG9hZGVyOjpIb3N0OjpoYXNSZXF1ZXN0cygpIGNvbnN0Ci17Ci0gICAgaWYgKCFtX3Jl cXVlc3RzTG9hZGluZy5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybiB0cnVlOwotICAgIGZvciAo dW5zaWduZWQgcCA9IDA7IHAgPD0gSGlnaDsgcCsrKSB7Ci0gICAgICAgIGlmICghbV9yZXF1ZXN0 c1BlbmRpbmdbcF0uaXNFbXB0eSgpKQotICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgZm9y ICh1bnNpZ25lZCBpID0gMDsgaSA8IGxvYWRlcnNUb0NhbmNlbC5zaXplKCk7ICsraSkgeworICAg ICAgICBTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyID0gbG9hZGVyc1RvQ2FuY2VsW2ldOworICAg ICAgICBkaWRGYWlsKGxvYWRlciwgdHJ1ZSk7CiAgICAgfQotICAgIHJldHVybiBmYWxzZTsKIH0K IAotdm9pZCBMb2FkZXI6Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKExvYWRlcjo6UHJpb3Jp dHkgbWluaW11bVByaW9yaXR5KQordm9pZCBMb2FkZXI6OmRpZEZpbmlzaExvYWRpbmcoU3VicmVz b3VyY2VMb2FkZXIqIGxvYWRlcikKIHsKLSAgICBMT0coUmVzb3VyY2VMb2FkaW5nLCAiSG9zdDo6 c2VydmVQZW5kaW5nUmVxdWVzdHMgJyVzJyIsIG1fbmFtZS5zdHJpbmcoKS5sYXRpbjEoKS5kYXRh KCkpOwotICAgIGlmIChjYWNoZSgpLT5sb2FkZXIoKS0+aXNTdXNwZW5kaW5nUGVuZGluZ1JlcXVl c3RzKCkpIHsKLSAgICAgICAgTE9HKFJlc291cmNlTG9hZGluZywgIi4uLmlzU3VzcGVuZGluZ1Bl bmRpbmdSZXF1ZXN0cyIpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgYm9vbCBzZXJ2 ZU1vcmUgPSB0cnVlOwotICAgIGZvciAoaW50IHByaW9yaXR5ID0gSGlnaDsgcHJpb3JpdHkgPj0g bWluaW11bVByaW9yaXR5ICYmIHNlcnZlTW9yZTsgLS1wcmlvcml0eSkKLSAgICAgICAgc2VydmVQ ZW5kaW5nUmVxdWVzdHMobV9yZXF1ZXN0c1BlbmRpbmdbcHJpb3JpdHldLCBzZXJ2ZU1vcmUpOwot fQotCi12b2lkIExvYWRlcjo6SG9zdDo6c2VydmVQZW5kaW5nUmVxdWVzdHMoUmVxdWVzdFF1ZXVl JiByZXF1ZXN0c1BlbmRpbmcsIGJvb2wmIHNlcnZlTG93ZXJQcmlvcml0eSkKLXsKLSAgICB3aGls ZSAoIXJlcXVlc3RzUGVuZGluZy5pc0VtcHR5KCkpIHsgICAgICAgIAotICAgICAgICBSZXF1ZXN0 KiByZXF1ZXN0ID0gcmVxdWVzdHNQZW5kaW5nLmZpcnN0KCk7Ci0gICAgICAgIENhY2hlZFJlc291 cmNlTG9hZGVyKiBjYWNoZWRSZXNvdXJjZUxvYWRlciA9IHJlcXVlc3QtPmNhY2hlZFJlc291cmNl TG9hZGVyKCk7Ci0gICAgICAgIGJvb2wgcmVzb3VyY2VJc0NhY2hlVmFsaWRhdG9yID0gcmVxdWVz dC0+Y2FjaGVkUmVzb3VyY2UoKS0+aXNDYWNoZVZhbGlkYXRvcigpOwotCi0gICAgICAgIC8vIEZv ciBuYW1lZCBob3N0cyAtIHdoaWNoIGFyZSBvbmx5IGh0dHAocykgaG9zdHMgLSB3ZSBzaG91bGQg YWx3YXlzIGVuZm9yY2UgdGhlIGNvbm5lY3Rpb24gbGltaXQuCi0gICAgICAgIC8vIEZvciBub24t bmFtZWQgaG9zdHMgLSBldmVyeXRoaW5nIGJ1dCBodHRwKHMpIC0gd2Ugc2hvdWxkIG9ubHkgZW5m b3JjZSB0aGUgbGltaXQgaWYgdGhlIGRvY3VtZW50IGlzbid0IGRvbmUgcGFyc2luZyAKLSAgICAg ICAgLy8gYW5kIHdlIGRvbid0IGtub3cgYWxsIHN0eWxlc2hlZXRzIHlldC4KLSAgICAgICAgYm9v bCBzaG91bGRMaW1pdFJlcXVlc3RzID0gIW1fbmFtZS5pc051bGwoKSB8fCBjYWNoZWRSZXNvdXJj ZUxvYWRlci0+ZG9jKCktPnBhcnNpbmcoKSB8fCAhY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRvYygp LT5oYXZlU3R5bGVzaGVldHNMb2FkZWQoKTsKLSAgICAgICAgaWYgKHNob3VsZExpbWl0UmVxdWVz dHMgJiYgbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpICsgbV9ub25DYWNoZWRSZXF1ZXN0c0luRmxp Z2h0ID49IG1fbWF4UmVxdWVzdHNJbkZsaWdodCkgewotICAgICAgICAgICAgc2VydmVMb3dlclBy aW9yaXR5ID0gZmFsc2U7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAgICAgICAg cmVxdWVzdHNQZW5kaW5nLnJlbW92ZUZpcnN0KCk7Ci0gICAgICAgIAotICAgICAgICBSZXNvdXJj ZVJlcXVlc3QgcmVzb3VyY2VSZXF1ZXN0KHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnVybCgp KTsKLSAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldFRhcmdldFR5cGUoY2FjaGVkUmVzb3VyY2VU eXBlVG9UYXJnZXRUeXBlKHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnR5cGUoKSkpOwotICAg ICAgICAKLSAgICAgICAgaWYgKCFyZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5hY2NlcHQoKS5p c0VtcHR5KCkpCi0gICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEFjY2VwdChyZXF1 ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT5hY2NlcHQoKSk7Ci0gICAgICAgIAotICAgICAgICAgLy8g RG8gbm90IHNldCB0aGUgcmVmZXJyZXIgb3IgSFRUUCBvcmlnaW4gaGVyZS4gVGhhdCdzIGhhbmRs ZWQgYnkgU3VicmVzb3VyY2VMb2FkZXI6OmNyZWF0ZS4KLSAgICAgICAgCi0gICAgICAgIGlmIChy ZXNvdXJjZUlzQ2FjaGVWYWxpZGF0b3IpIHsKLSAgICAgICAgICAgIENhY2hlZFJlc291cmNlKiBy ZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnJlc291cmNl VG9SZXZhbGlkYXRlKCk7Ci0gICAgICAgICAgICBBU1NFUlQocmVzb3VyY2VUb1JldmFsaWRhdGUt PmNhblVzZUNhY2hlVmFsaWRhdG9yKCkpOwotICAgICAgICAgICAgQVNTRVJUKHJlc291cmNlVG9S ZXZhbGlkYXRlLT5pc0xvYWRlZCgpKTsKLSAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgbGFzdE1v ZGlmaWVkID0gcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlc3BvbnNlKCkuaHR0cEhlYWRlckZpZWxk KCJMYXN0LU1vZGlmaWVkIik7Ci0gICAgICAgICAgICBjb25zdCBTdHJpbmcmIGVUYWcgPSByZXNv dXJjZVRvUmV2YWxpZGF0ZS0+cmVzcG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkVUYWciKTsKLSAg ICAgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlzRW1wdHkoKSB8fCAhZVRhZy5pc0VtcHR5KCkp IHsKLSAgICAgICAgICAgICAgICBBU1NFUlQoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmNhY2hlUG9s aWN5KCkgIT0gQ2FjaGVQb2xpY3lSZWxvYWQpOwotICAgICAgICAgICAgICAgIGlmIChjYWNoZWRS ZXNvdXJjZUxvYWRlci0+Y2FjaGVQb2xpY3koKSA9PSBDYWNoZVBvbGljeVJldmFsaWRhdGUpCi0g ICAgICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIkNh Y2hlLUNvbnRyb2wiLCAibWF4LWFnZT0wIik7Ci0gICAgICAgICAgICAgICAgaWYgKCFsYXN0TW9k aWZpZWQuaXNFbXB0eSgpKQotICAgICAgICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0 SFRUUEhlYWRlckZpZWxkKCJJZi1Nb2RpZmllZC1TaW5jZSIsIGxhc3RNb2RpZmllZCk7Ci0gICAg ICAgICAgICAgICAgaWYgKCFlVGFnLmlzRW1wdHkoKSkKLSAgICAgICAgICAgICAgICAgICAgcmVz b3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiSWYtTm9uZS1NYXRjaCIsIGVUYWcpOwot ICAgICAgICAgICAgfQotICAgICAgICB9Ci0KLSNpZiBFTkFCTEUoTElOS19QUkVGRVRDSCkKLSAg ICAgICAgaWYgKHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnR5cGUoKSA9PSBDYWNoZWRSZXNv dXJjZTo6TGlua1ByZWZldGNoKQotICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBI ZWFkZXJGaWVsZCgiWC1QdXJwb3NlIiwgInByZWZldGNoIik7Ci0jZW5kaWYKLQotICAgICAgICBS ZWZQdHI8U3VicmVzb3VyY2VMb2FkZXI+IGxvYWRlciA9IFN1YnJlc291cmNlTG9hZGVyOjpjcmVh dGUoY2FjaGVkUmVzb3VyY2VMb2FkZXItPmRvYygpLT5mcmFtZSgpLAotICAgICAgICAgICAgdGhp cywgcmVzb3VyY2VSZXF1ZXN0LCByZXF1ZXN0LT5zaG91bGREb1NlY3VyaXR5Q2hlY2soKSwgcmVx dWVzdC0+c2VuZFJlc291cmNlTG9hZENhbGxiYWNrcygpKTsKLSAgICAgICAgaWYgKGxvYWRlcikg ewotICAgICAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcuYWRkKGxvYWRlci5yZWxlYXNlKCksIHJl cXVlc3QpOwotICAgICAgICAgICAgcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+c2V0UmVxdWVz dGVkRnJvbU5ldHdvcmtpbmdMYXllcigpOwotICAgICAgICAgICAgTE9HKFJlc291cmNlTG9hZGlu ZywgIkhvc3QgJyVzJyBsb2FkaW5nICclcycuIEN1cnJlbnQgY291bnQgJWQiLCBtX25hbWUuc3Ry aW5nKCkubGF0aW4xKCkuZGF0YSgpLCByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpLT51cmwoKS5s YXRpbjEoKS5kYXRhKCksIG1fcmVxdWVzdHNMb2FkaW5nLnNpemUoKSk7Ci0gICAgICAgIH0gZWxz ZSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogV2hhdCBpZiByZXNvdXJjZXMgaW4gb3RoZXIgZnJh bWVzIHdlcmUgd2FpdGluZyBmb3IgdGhpcyByZXZhbGlkYXRpb24/Ci0gICAgICAgICAgICBMT0co UmVzb3VyY2VMb2FkaW5nLCAiSG9zdCAnJXMnIGNhbm5vdCBzdGFydCBsb2FkaW5nICclcyciLCBt X25hbWUuc3RyaW5nKCkubGF0aW4xKCkuZGF0YSgpLCByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgp LT51cmwoKS5sYXRpbjEoKS5kYXRhKCkpOwotICAgICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIHJl c291cmNlID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKTsKLSAgICAgICAgICAgIGNhY2hlZFJl c291cmNlTG9hZGVyLT5kZWNyZW1lbnRSZXF1ZXN0Q291bnQocmVzb3VyY2UpOwotICAgICAgICAg ICAgY2FjaGVkUmVzb3VyY2VMb2FkZXItPnNldExvYWRJblByb2dyZXNzKHRydWUpOwotICAgICAg ICAgICAgaWYgKHJlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKQotICAgICAgICAgICAg ICAgIGNhY2hlKCktPnJldmFsaWRhdGlvbkZhaWxlZChyZXNvdXJjZSk7Ci0gICAgICAgICAgICBy ZXNvdXJjZS0+ZXJyb3IoKTsKLSAgICAgICAgICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRM b2FkSW5Qcm9ncmVzcyhmYWxzZSk7Ci0gICAgICAgICAgICBkZWxldGUgcmVxdWVzdDsKLSAgICAg ICAgfQotICAgIH0KLX0KLQotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZEZpbmlzaExvYWRpbmcoU3Vi cmVzb3VyY2VMb2FkZXIqIGxvYWRlcikKLXsKLSAgICBSZWZQdHI8SG9zdD4gbXlQcm90ZWN0b3Io dGhpcyk7Ci0KICAgICBSZXF1ZXN0TWFwOjppdGVyYXRvciBpID0gbV9yZXF1ZXN0c0xvYWRpbmcu ZmluZChsb2FkZXIpOwogICAgIGlmIChpID09IG1fcmVxdWVzdHNMb2FkaW5nLmVuZCgpKQogICAg ICAgICByZXR1cm47CkBAIC00MTIsNyArMTgyLDcgQEAKICAgICBDYWNoZWRSZXNvdXJjZSogcmVz b3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOwogICAgIEFTU0VSVCghcmVzb3VyY2Ut PnJlc291cmNlVG9SZXZhbGlkYXRlKCkpOwogCi0gICAgTE9HKFJlc291cmNlTG9hZGluZywgIkhv c3QgJyVzJyByZWNlaXZlZCAlcy4gQ3VycmVudCBjb3VudCAlZFxuIiwgbV9uYW1lLnN0cmluZygp LmxhdGluMSgpLmRhdGEoKSwgcmVzb3VyY2UtPnVybCgpLmxhdGluMSgpLmRhdGEoKSwgbV9yZXF1 ZXN0c0xvYWRpbmcuc2l6ZSgpKTsKKyAgICBMT0coUmVzb3VyY2VMb2FkaW5nLCAiUmVjZWl2ZWQg JXMuIiwgcmVzb3VyY2UtPnVybCgpLmxhdGluMSgpLmRhdGEoKSk7CiAKICAgICAvLyBJZiB3ZSBn b3QgYSA0eHggcmVzcG9uc2UsIHdlJ3JlIHByZXRlbmRpbmcgdG8gaGF2ZSByZWNlaXZlZCBhIG5l dHdvcmsKICAgICAvLyBlcnJvciwgc28gd2UgY2FuJ3Qgc2VuZCB0aGUgc3VjY2Vzc2Z1bCBkYXRh KCkgYW5kIGZpbmlzaCgpIGNhbGxiYWNrcy4KQEAgLTQyMywyMyArMTkzLDE3IEBACiAgICAgfQog CiAgICAgZGVsZXRlIHJlcXVlc3Q7Ci0KLSAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+c2V0TG9h ZEluUHJvZ3Jlc3MoZmFsc2UpOwotICAgIAorICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5zZXRM b2FkSW5Qcm9ncmVzcyhmYWxzZSk7ICAgIAogICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5jaGVj a0ZvclBlbmRpbmdQcmVsb2FkcygpOwotCi0gICAgc2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKIH0K IAotdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwg Y29uc3QgUmVzb3VyY2VFcnJvciYpCit2b2lkIExvYWRlcjo6ZGlkRmFpbChTdWJyZXNvdXJjZUxv YWRlciogbG9hZGVyLCBjb25zdCBSZXNvdXJjZUVycm9yJikKIHsKICAgICBkaWRGYWlsKGxvYWRl cik7CiB9CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRGYWlsKFN1YnJlc291cmNlTG9hZGVyKiBs b2FkZXIsIGJvb2wgY2FuY2VsbGVkKQordm9pZCBMb2FkZXI6OmRpZEZhaWwoU3VicmVzb3VyY2VM b2FkZXIqIGxvYWRlciwgYm9vbCBjYW5jZWxsZWQpCiB7Ci0gICAgUmVmUHRyPEhvc3Q+IG15UHJv dGVjdG9yKHRoaXMpOwotCiAgICAgbG9hZGVyLT5jbGVhckNsaWVudCgpOwogCiAgICAgUmVxdWVz dE1hcDo6aXRlcmF0b3IgaSA9IG1fcmVxdWVzdHNMb2FkaW5nLmZpbmQobG9hZGVyKTsKQEAgLTQ1 Nyw3ICsyMjEsNyBAQAogCiAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlID0gcmVxdWVzdC0+ Y2FjaGVkUmVzb3VyY2UoKTsKIAotICAgIExPRyhSZXNvdXJjZUxvYWRpbmcsICJIb3N0ICclcycg ZmFpbGVkIHRvIGxvYWQgJXMgKGNhbmNlbGxlZD0lZCkuIEN1cnJlbnQgY291bnQgJWRcbiIsIG1f bmFtZS5zdHJpbmcoKS5sYXRpbjEoKS5kYXRhKCksIHJlc291cmNlLT51cmwoKS5sYXRpbjEoKS5k YXRhKCksIGNhbmNlbGxlZCwgbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpKTsKKyAgICBMT0coUmVz b3VyY2VMb2FkaW5nLCAiRmFpbGVkIHRvIGxvYWQgJXMgKGNhbmNlbGxlZD0lZCkuXG4iLCByZXNv dXJjZS0+dXJsKCkubGF0aW4xKCkuZGF0YSgpLCBjYW5jZWxsZWQpOwogCiAgICAgaWYgKHJlc291 cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKQogICAgICAgICBjYWNoZSgpLT5yZXZhbGlkYXRp b25GYWlsZWQocmVzb3VyY2UpOwpAQCAtNDc0LDE0ICsyMzgsMTAgQEAKICAgICBkZWxldGUgcmVx dWVzdDsKICAgICAKICAgICBjYWNoZWRSZXNvdXJjZUxvYWRlci0+Y2hlY2tGb3JQZW5kaW5nUHJl bG9hZHMoKTsKLQotICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CiB9CiAKLXZvaWQgTG9hZGVy OjpIb3N0OjpkaWRSZWNlaXZlUmVzcG9uc2UoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgY29u c3QgUmVzb3VyY2VSZXNwb25zZSYgcmVzcG9uc2UpCit2b2lkIExvYWRlcjo6ZGlkUmVjZWl2ZVJl c3BvbnNlKFN1YnJlc291cmNlTG9hZGVyKiBsb2FkZXIsIGNvbnN0IFJlc291cmNlUmVzcG9uc2Um IHJlc3BvbnNlKQogewotICAgIFJlZlB0cjxIb3N0PiBwcm90ZWN0b3IodGhpcyk7Ci0KICAgICBS ZXF1ZXN0KiByZXF1ZXN0ID0gbV9yZXF1ZXN0c0xvYWRpbmcuZ2V0KGxvYWRlcik7CiAgICAgCiAg ICAgLy8gRklYTUU6IFRoaXMgaXMgYSB3b3JrYXJvdW5kIGZvciA8cmRhcjovL3Byb2JsZW0vNTIz Njg0Mz4KQEAgLTUxMCw3ICsyNzAsNiBAQAogCiAgICAgICAgICAgICBkZWxldGUgcmVxdWVzdDsK IAotICAgICAgICAgICAgc2VydmVQZW5kaW5nUmVxdWVzdHMoKTsKICAgICAgICAgICAgIHJldHVy bjsKICAgICAgICAgfSAKICAgICAgICAgLy8gRGlkIG5vdCBnZXQgMzA0IHJlc3BvbnNlLCBjb250 aW51ZSBhcyBhIHJlZ3VsYXIgcmVzb3VyY2UgbG9hZC4KQEAgLTU0MSwxMCArMzAwLDggQEAKICAg ICB9CiB9CiAKLXZvaWQgTG9hZGVyOjpIb3N0OjpkaWRSZWNlaXZlRGF0YShTdWJyZXNvdXJjZUxv YWRlciogbG9hZGVyLCBjb25zdCBjaGFyKiBkYXRhLCBpbnQgc2l6ZSkKK3ZvaWQgTG9hZGVyOjpk aWRSZWNlaXZlRGF0YShTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyLCBjb25zdCBjaGFyKiBkYXRh LCBpbnQgc2l6ZSkKIHsKLSAgICBSZWZQdHI8SG9zdD4gcHJvdGVjdG9yKHRoaXMpOwotCiAgICAg UmVxdWVzdCogcmVxdWVzdCA9IG1fcmVxdWVzdHNMb2FkaW5nLmdldChsb2FkZXIpOwogICAgIGlm ICghcmVxdWVzdCkKICAgICAgICAgcmV0dXJuOwpAQCAtNTcwLDEwICszMjcsOCBAQAogICAgICAg ICByZXNvdXJjZS0+ZGF0YShsb2FkZXItPnJlc291cmNlRGF0YSgpLCBmYWxzZSk7CiB9CiAgICAg Ci12b2lkIExvYWRlcjo6SG9zdDo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNl TG9hZGVyKiBsb2FkZXIsIGNvbnN0IGNoYXIqIGRhdGEsIGludCBzaXplKQordm9pZCBMb2FkZXI6 OmRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyLCBjb25z dCBjaGFyKiBkYXRhLCBpbnQgc2l6ZSkKIHsKLSAgICBSZWZQdHI8SG9zdD4gcHJvdGVjdG9yKHRo aXMpOwotCiAgICAgUmVxdWVzdCogcmVxdWVzdCA9IG1fcmVxdWVzdHNMb2FkaW5nLmdldChsb2Fk ZXIpOwogICAgIGlmICghcmVxdWVzdCkKICAgICAgICAgcmV0dXJuOwpAQCAtNTgzLDQxICszMzgs NSBAQAogCiAgICAgcmVzb3VyY2UtPnNldFNlcmlhbGl6ZWRDYWNoZWRNZXRhZGF0YShkYXRhLCBz aXplKTsKIH0KLSAgICAKLXZvaWQgTG9hZGVyOjpIb3N0OjpjYW5jZWxQZW5kaW5nUmVxdWVzdHMo UmVxdWVzdFF1ZXVlJiByZXF1ZXN0c1BlbmRpbmcsIENhY2hlZFJlc291cmNlTG9hZGVyKiBjYWNo ZWRSZXNvdXJjZUxvYWRlcikKLXsKLSAgICBSZXF1ZXN0UXVldWUgcmVtYWluaW5nOwotICAgIFJl cXVlc3RRdWV1ZTo6aXRlcmF0b3IgZW5kID0gcmVxdWVzdHNQZW5kaW5nLmVuZCgpOwotICAgIGZv ciAoUmVxdWVzdFF1ZXVlOjppdGVyYXRvciBpdCA9IHJlcXVlc3RzUGVuZGluZy5iZWdpbigpOyBp dCAhPSBlbmQ7ICsraXQpIHsKLSAgICAgICAgUmVxdWVzdCogcmVxdWVzdCA9ICppdDsKLSAgICAg ICAgaWYgKHJlcXVlc3QtPmNhY2hlZFJlc291cmNlTG9hZGVyKCkgPT0gY2FjaGVkUmVzb3VyY2VM b2FkZXIpIHsKLSAgICAgICAgICAgIGNhY2hlKCktPnJlbW92ZShyZXF1ZXN0LT5jYWNoZWRSZXNv dXJjZSgpKTsKLSAgICAgICAgICAgIGNhY2hlZFJlc291cmNlTG9hZGVyLT5kZWNyZW1lbnRSZXF1 ZXN0Q291bnQocmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKSk7Ci0gICAgICAgICAgICBkZWxldGUg cmVxdWVzdDsKLSAgICAgICAgfSBlbHNlCi0gICAgICAgICAgICByZW1haW5pbmcuYXBwZW5kKHJl cXVlc3QpOwotICAgIH0KLSAgICByZXF1ZXN0c1BlbmRpbmcuc3dhcChyZW1haW5pbmcpOwotfQog Ci12b2lkIExvYWRlcjo6SG9zdDo6Y2FuY2VsUmVxdWVzdHMoQ2FjaGVkUmVzb3VyY2VMb2FkZXIq IGNhY2hlZFJlc291cmNlTG9hZGVyKQotewotICAgIGZvciAodW5zaWduZWQgcCA9IDA7IHAgPD0g SGlnaDsgcCsrKQotICAgICAgICBjYW5jZWxQZW5kaW5nUmVxdWVzdHMobV9yZXF1ZXN0c1BlbmRp bmdbcF0sIGNhY2hlZFJlc291cmNlTG9hZGVyKTsKLQotICAgIFZlY3RvcjxTdWJyZXNvdXJjZUxv YWRlciosIDI1Nj4gbG9hZGVyc1RvQ2FuY2VsOwotCi0gICAgUmVxdWVzdE1hcDo6aXRlcmF0b3Ig ZW5kID0gbV9yZXF1ZXN0c0xvYWRpbmcuZW5kKCk7Ci0gICAgZm9yIChSZXF1ZXN0TWFwOjppdGVy YXRvciBpID0gbV9yZXF1ZXN0c0xvYWRpbmcuYmVnaW4oKTsgaSAhPSBlbmQ7ICsraSkgewotICAg ICAgICBSZXF1ZXN0KiByID0gaS0+c2Vjb25kOwotICAgICAgICBpZiAoci0+Y2FjaGVkUmVzb3Vy Y2VMb2FkZXIoKSA9PSBjYWNoZWRSZXNvdXJjZUxvYWRlcikKLSAgICAgICAgICAgIGxvYWRlcnNU b0NhbmNlbC5hcHBlbmQoaS0+Zmlyc3QuZ2V0KCkpOwotICAgIH0KLQotICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBsb2FkZXJzVG9DYW5jZWwuc2l6ZSgpOyArK2kpIHsKLSAgICAgICAgU3Vi cmVzb3VyY2VMb2FkZXIqIGxvYWRlciA9IGxvYWRlcnNUb0NhbmNlbFtpXTsKLSAgICAgICAgZGlk RmFpbChsb2FkZXIsIHRydWUpOwotICAgIH0KLX0KLQogfSAvL25hbWVzcGFjZSBXZWJDb3JlCklu ZGV4OiBXZWJDb3JlL2xvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5jcHAJKHJldmlz aW9uIDcxMjU2KQorKysgV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAj aW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgorI2lu Y2x1ZGUgIlJlc291cmNlTG9hZFNjaGVkdWxlci5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVxdWVz dC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU3VicmVzb3VyY2VM b2FkZXIuaCIKQEAgLTMxOSw3ICszMjAsNyBAQAogCiAgICAgICAgIC8vIENsZWFyIHRoZSBsb2Fk ZXIgc28gdGhhdCBhbnkgY2FsbGJhY2tzIGZyb20gU3VicmVzb3VyY2VMb2FkZXI6OmNyZWF0ZSB3 aWxsIG5vdCBoYXZlIHRoZSBvbGQgbG9hZGVyLgogICAgICAgICBtX2xvYWRlciA9IDA7Ci0gICAg ICAgIG1fbG9hZGVyID0gU3VicmVzb3VyY2VMb2FkZXI6OmNyZWF0ZShtX2RvY3VtZW50LT5mcmFt ZSgpLCB0aGlzLCByZXF1ZXN0LCBzZWN1cml0eUNoZWNrLCBzZW5kTG9hZENhbGxiYWNrcywgc25p ZmZDb250ZW50KTsKKyAgICAgICAgbV9sb2FkZXIgPSByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+ c2NoZWR1bGVTdWJyZXNvdXJjZUxvYWQobV9kb2N1bWVudC0+ZnJhbWUoKSwgdGhpcywgcmVxdWVz dCwgUmVzb3VyY2VMb2FkU2NoZWR1bGVyOjpMb3csIHNlY3VyaXR5Q2hlY2ssIHNlbmRMb2FkQ2Fs bGJhY2tzLCBzbmlmZkNvbnRlbnQpOwogICAgICAgICByZXR1cm47CiAgICAgfQogICAgIApJbmRl eDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9sb2dvdXQuaHRtbAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2xvZ291dC5o dG1sCShyZXZpc2lvbiA3MTI1NikKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3QvbG9nb3V0Lmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTI0LDcgKzI0LDEyIEBACiAgICAg Ly8gbG9nb3V0Lmh0bWwgZG9lc24ndCBldmVuIGV4aXN0IC0gd2UgZG9uJ3QgbmVlZCB0byBzZW5k IHRoaXMgcmVxdWVzdCB0byBzZXJ2ZXIuCiAgICAgeGhyLm9wZW4oIkdFVCIsICJyZXNvdXJjZXMv bG9nb3V0L3N1YmRpcmVjdG9yeS9sb2dvdXQuaHRtbCIsIHRydWUsICJsb2dvdXQiLCAibG9nb3V0 Iik7CiAgICAgeGhyLnNlbmQoIiIpOwotICAgIHhoci5hYm9ydCgpOworICAgIHhoci5vbmxvYWQg PSBmdW5jdGlvbigpIHsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxvZ291dCIp LmlubmVySFRNTCA9IGlzQXV0aGVudGljYXRlZCgpID8gIkZBSUwiIDogIlBBU1MiOworCisgICAg ICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgfQogfQogCiBmdW5jdGlvbiBpc0F1dGhl bnRpY2F0ZWQoKQpAQCAtNDQsMTMgKzQ5LDkgQEAKIHIub3BlbigiR0VUIiwgInJlc291cmNlcy9s b2dvdXQvcmVzb3VyY2UucGhwP2lzQXV0aGVudGljYXRlZCIsIHRydWUpOwogci5vbmxvYWQgPSBm dW5jdGlvbigpIHsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYXN5bmMiKS5pbm5lckhU TUwgPSByLnN0YXR1cyA9PSAyMDAgPyAiUEFTUyIgOiAiRkFJTCI7Ci0KLSAgICBpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3Rp ZnlEb25lKCk7CiB9CiByLnNlbmQoIiIpOwogCiBsb2dvdXQoKTsKLWRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJsb2dvdXQiKS5pbm5lckhUTUwgPSBpc0F1dGhlbnRpY2F0ZWQoKSA/ICJGQUlMIiA6 ICJQQVNTIjsKIDwvc2NyaXB0PgogPC9ib2R5PgpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNzEyNTYpCisr KyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxMiBAQAor MjAxMC0xMS0wNyAgTmF0ZSBDaGFwaW4gIDxqYXBoZXRAY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJld3JpdGUgdGVzdCBmb3Ig aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3MTY1CisKKyAgICAgICAg KiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2xvZ291dC5odG1sOiBJdCBpcyBubyBsb25nZXIg c2FmZQorICAgICAgICB0byBhc3N1bWUgdGhhdCBhbiBhc3luYyB4aHIgd2lsbCBoYXZlIGFueSBl ZmZlY3RzIHN5bmNocm9ub3VzbHkuCisKIDIwMTAtMTEtMDMgIE5hdGUgQ2hhcGluICA8amFwaGV0 QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBbGV4ZXkgUHJvc2t1cnlha292 LgpJbmRleDogV2ViS2l0Mi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0Mi9DaGFuZ2VM b2cJKHJldmlzaW9uIDcxMjc2KQorKysgV2ViS2l0Mi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkK QEAgLTEsMyArMSwxMyBAQAorMjAxMC0xMS0wMyAgTmF0ZSBDaGFwaW4gIDxqYXBoZXRAY2hyb21p dW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEZ1bmN0aW9uIGNhbGwgdXBkYXRlIGZvciAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTI3MTY1LgorCisgICAgICAgICogV2ViUHJvY2Vzcy9QbHVnaW5z L1BsdWdpblZpZXcuY3BwOgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5WaWV3OjpTdHJlYW06OnN0 YXJ0KToKKwogMjAxMC0xMS0wMyAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCkluZGV4OiBXZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9QbHVnaW5WaWV3LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9QbHVnaW5WaWV3LmNwcAkocmV2aXNpb24gNzEyNTYpCisrKyBXZWJLaXQy L1dlYlByb2Nlc3MvUGx1Z2lucy9QbHVnaW5WaWV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDUs NiArNDUsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvUHJveHlTZXJ2ZXIuaD4KICNpbmNsdWRlIDxX ZWJDb3JlL1JlbmRlckVtYmVkZGVkT2JqZWN0Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9SZW5kZXJM YXllci5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VMb2FkU2NoZWR1bGVyLmg+CiAjaW5j bHVkZSA8V2ViQ29yZS9TY3JvbGxWaWV3Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9TZXR0aW5ncy5o PgogCkBAIC0xMjksMTEgKzEzMCw3IEBACiAgICAgRnJhbWUqIGZyYW1lID0gbV9wbHVnaW5WaWV3 LT5tX3BsdWdpbkVsZW1lbnQtPmRvY3VtZW50KCktPmZyYW1lKCk7CiAgICAgQVNTRVJUKGZyYW1l KTsKIAotICAgIG1fbG9hZGVyID0gTmV0c2NhcGVQbHVnSW5TdHJlYW1Mb2FkZXI6OmNyZWF0ZShm cmFtZSwgdGhpcyk7Ci0gICAgbV9sb2FkZXItPnNldFNob3VsZEJ1ZmZlckRhdGEoZmFsc2UpOwot ICAgIAotICAgIG1fbG9hZGVyLT5kb2N1bWVudExvYWRlcigpLT5hZGRQbHVnSW5TdHJlYW1Mb2Fk ZXIobV9sb2FkZXIuZ2V0KCkpOwotICAgIG1fbG9hZGVyLT5sb2FkKG1fcmVxdWVzdCk7CisgICAg bV9sb2FkZXIgPSByZXNvdXJjZUxvYWRTY2hlZHVsZXIoKS0+c2NoZWR1bGVQbHVnaW5TdHJlYW1M b2FkKGZyYW1lLCB0aGlzLCBtX3JlcXVlc3QpOwogfQogCiB2b2lkIFBsdWdpblZpZXc6OlN0cmVh bTo6Y2FuY2VsKCkK