24853 2009-03-26 13:41:18 -0700 Provide a way for WebKit clients to specify a more granular policy for cross-origin XHR access 2009-08-19 23:30:35 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 28134 1 rafaelw aa aa abarth ap darin fishd levin mike mitz sam oldest_to_newest 115397 0 rafaelw 2009-03-26 13:41:18 -0700 This change creates a platform-pluggable SecurityOriginDelegate which allows the client to whitelist URLs for access & request in special circumstances. This is necessary for the chromium extensions mechanism to have static, installed pages that have been granted permissions to make out-bound XHR requests. I have consulted with Adam Barth (abarth, cc'd above) on the design of this change. 115398 1 28979 rafaelw 2009-03-26 13:43:51 -0700 Created attachment 28979 Create SecurityOriginDelegate that is called from SecurityOrigin::canAccess() & canRequest() 115404 2 fishd 2009-03-26 13:52:02 -0700 I think there is a desire to not have platform depend on other parts of WebCore. There was an email from Dave Hyatt on this subject to webkit-dev some while back. (The Chromium port clearly violates that with ChromiumBridge, but that is fairly isolated.) 115413 3 abarth 2009-03-26 14:19:18 -0700 Maybe we'd prefer to have this be a client (akin to FrameLoaderClient)? Note that there can be several frames associated with a single SecurityOrigin. (Also, we should pass SecurityOrigins by pointer instead of by constant reference.) 115426 4 fishd 2009-03-26 14:39:07 -0700 Other issues: Do we need to worry about SecurityOrigin usage by worker threads? 115429 5 abarth 2009-03-26 14:41:28 -0700 Here is some discussion we had by email: On Thu, Mar 26, 2009 at 2:30 PM, abarth wrote: > We could also have this discussion in the bug so it will be archived. > I wonder if we should somehow separate the "policy" part of > SecurityOrigin (who can access whom) from the "data" part (who am I). > > Adam > > >On Thu, Mar 26, 2009 at 2:24 PM, fishd wrote: >> That could work. By the way, is SecurityOrigin used on worker threads? How >> should this kind of thing work there? >> +weinig since I'm sure he may be interested in any proposed changes to >> SecurityOrigin. >> -Darin >> >> >> On Thu, Mar 26, 2009 at 2:22 PM, abarth wrote: >>> >>> I'm not sure we want to add these functions to FrameLoaderClient. >>> Maybe FrameLoaderClient can give us a SecurityOriginClient that >>> SecurityOrigin can hang on to and use to answer these questions? 115430 6 ap 2009-03-26 14:44:47 -0700 Yes, it seems wrong to have delegate calls that can be invoked on arbitrary threads (which would happen here). 115543 7 28979 ap 2009-03-27 08:20:10 -0700 Comment on attachment 28979 Create SecurityOriginDelegate that is called from SecurityOrigin::canAccess() & canRequest() > This is necessary for the chromium extensions mechanism to have static, > installed pages that have been granted permissions to make out-bound XHR > requests. Perhaps you could use a custom URL scheme for such static pages? These are registered via FrameLoader::registerURLSchemeAsLocal() (it needs to be invoked before secondary threads are spawned). r-, as this feature doesn't seem to warrant introducing callbacks that work from multiple threads. 115565 8 abarth 2009-03-27 10:11:49 -0700 (In reply to comment #7) > Perhaps you could use a custom URL scheme for such static pages? These are > registered via FrameLoader::registerURLSchemeAsLocal() (it needs to be invoked > before secondary threads are spawned). I'm not sure that will work for this use case because extensions aren't given universal access. They're granted access to specific domains. 115864 9 aa 2009-03-30 12:12:47 -0700 So, what should be our next step with this enhancement? To back up and give context, we are working on extensions ("add-ons") for Chromium. One feature we would like to provide these extensions is the ability to use XHR with multiple origins. But instead of giving every extension blanket access to all origins, we want the extension to declare the sets of origins it wants access to. In order to implement this, we need WebCore to ask us whether it is OK for a particular page to use XHR with a particular origin, instead of deciding based only on its own built-in policy. Perhaps a more targeted change, that only affects XHR would be better. For example, we don't really need (and probably don't want) the ability to do cross-frame scripting. It seems like this change would allow that. To answer Darin Fisher's question: we do want this to affect workers. Extensions should be able to use workers, and those workers should be able to perform cross-origin XHR, if the extension has declared it needs access to those origins. 115873 10 sam 2009-03-30 13:36:08 -0700 Would passing in the set of allowed origins work? 115882 11 aa 2009-03-30 14:11:07 -0700 (In reply to comment #10) > Would passing in the set of allowed origins work? That is a possibility, but note that the set is defined using a syntax, it isn't just a list (http://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/extensions/url_pattern.h?revision=9813&view=markup). To me it seems cleaner to have WebCore call out for this. But if we wanted to pass it in, were would be the right place to do that, and where would we store the state? 115888 12 ap 2009-03-30 14:28:18 -0700 (In reply to comment #11) > To me it seems cleaner to have WebCore call out for this. I agree that this is cleaner, too bad this code is executed from multiple threads. Perhaps the real solution is to move it out of XMLHttpRequest, so that it would only ever work on the main thread? We need to do eventually this anyway, see bug 24462. > But if we wanted to pass it in, were would be the right place to do that, > and where would we store the state? FrameLoader::registerURLSchemeAsLocal() is clearly the example to follow in that case, for consistency is nothing else. 115938 13 sam 2009-03-30 16:59:52 -0700 If we really do need to use a client here, we should probably follow the strategy of passing in the client into the origin. 116707 14 aa 2009-04-06 19:02:38 -0700 Picking this up again... (In reply to comment #7) > Perhaps you could use a custom URL scheme for such static pages? These are > registered via FrameLoader::registerURLSchemeAsLocal() (it needs to be invoked > before secondary threads are spawned). > > r-, as this feature doesn't seem to warrant introducing callbacks that work > from multiple threads. Our feature requires a client as we want to implement logic to decide whether an origin is allowed, not just a static set (and it doesn't seem right to pull that logic into WebCore). It is unfortunate to have client callbacks happening on multiple threads, but we can document this in comments. Also, when the work to move preflight into the main thread lands, it seems like it will automatically solve that issue, no matter what we do now. It doesn't seem like we need to block this issue on that one. (In reply to comment #2) > I think there is a desire to not have platform depend on other parts of > WebCore. There was an email from Dave Hyatt on this subject to webkit-dev some > while back. > > (The Chromium port clearly violates that with ChromiumBridge, but that is > fairly isolated.) (In reply to comment #13) > If we really do need to use a client here, we should probably follow the > strategy of passing in the client into the origin. So here is a proposal that I think addresses these two issues. Sam and Darin, can you comment? a) Move SecurityOriginDelegate.h into page/, next to SecurityOrigin.h (and rename it SecurityOriginClient). That way we don't have the issue Darin brought up. b) Add a setClient() method to SecurityOrigin. c) Add a securityOriginClient() method to FrameLoaderClient d) Use frameLoader->client()->securityOriginClient() in Document.cpp and WorkerContext.cpp to populate the SecurityOrigins they create with client s. Thoughts? 117287 15 ap 2009-04-12 23:52:14 -0700 > c) Add a securityOriginClient() method to FrameLoaderClient Can't we just add these methods to FrameLoaderClient? They seem to fit well there. 117293 16 aa 2009-04-13 01:34:09 -0700 (In reply to comment #15) > > c) Add a securityOriginClient() method to FrameLoaderClient > > Can't we just add these methods to FrameLoaderClient? They seem to fit well > there. > It isn't currently possible to access FrameLoaderClient from the XHR code where these checks are being done. There is an idea to refactor things such that the checking would be done in DocumentThreadableLoader, where FrameLoaderClient is accessible, but that hasn't been done yet. On IRC, Alexey and I worked out essentially two possible paths forward: a) Do the refactor to move access checking for XHR into DocumentThreadableLoader, then add methods to FrameLoaderClient to fill these needs. b) Push static data into WebCore, similar to how FrameLoader::registerURLSchemesAsLocal() works today. We'd have to push the data in a form that WebCore understands, either by teaching it how to understand Chromium URL patterns, or pre-processing to something like a regex. 117304 17 fishd 2009-04-13 08:05:47 -0700 > > Can't we just add these methods to FrameLoaderClient? They seem to fit well > > there. That's what I think we should do too. > It isn't currently possible to access FrameLoaderClient from the XHR code > where these checks are being done. There is an idea to refactor things such > that the checking would be done in DocumentThreadableLoader, where > FrameLoaderClient is accessible, but that hasn't been done yet. I believe that refactoring is required anyways for workers. Presently, SecurityOrigin is not safe to use on multiple threads. It calls FrameLoader::shouldTreatURLSchemeAsLocal, which is not thread safe. That method uses a lazily allocated static hash map that can also be modified at runtime. So, using SecurityOrigin from multiple threads is clearly a bug. I'm pretty convinced that the correct solution to both that problem and the one that is the subject of this bug, is to move XHR security checking off of the worker thread. > b) Push static data into WebCore, similar to how > FrameLoader::registerURLSchemesAsLocal() works today. We'd have to push the > data in a form that WebCore understands, either by teaching it how to > understand Chromium URL patterns, or pre-processing to something like a regex. This solution has the subtle downside that the rules would apply to any frame in the system that loads the URL of the privileged extension. It would be more secure to only grant the special rights to the particular frame(s) that you are loading the extension into. 140828 18 aa 2009-08-17 13:59:20 -0700 Hello all, I'm returning to this work now. I've already refactored the access control code out onto the main thread (https://bugs.webkit.org/show_bug.cgi?id=28134), so it should be possible to implement this now without having delegates getting called on multiple threads. However, Darin Adler and Maciej both have suggested that they have a minor preference that this be implemented with more of the logic in WebKit than outside of it. So I have a proposal I would like feedback on: * Add static state to SecurityOrigin.cpp that keeps track of which origins each origin can access. This state would look something like: map<origin, list<OriginAccessInfo>> where OriginAccessInfo is something like: struct OriginAccessInfo { string domain; bool subdomains; // whether subdomain access is also allowed bool secure; // http vs https } * Add static members to SecurityOrigin.h to manipulate this list * Plumb this through the mac WebKit API as SPI so that it can be tested * In SecurityOrigin::canLoad(), consult this state to determine if an origin is accessible. Is this feasible? Do people prefer it to the earlier one (putting a new callback method on FrameLoaderClient)? 141071 19 35037 aa 2009-08-18 04:59:14 -0700 Created attachment 35037 Implements the concept of 'security origin access white lists'. This patch adds the concept of a whitelist of origins that each origin can access in addition to those that the normal security policies would allow. Clients of WebCore can add items to this list to enable particular origins to break out of same-origin in a controlled way. The particular features of the whitelist were chosen because they are the features needed by this code's first client -- Chromium extensions. But I think that the feature is pretty useful and might be used by other clients in the future. I haven't yet implemented the WebKit frontends for any platforms other than mac. I wanted to get feedback on this first. 141200 20 aa 2009-08-18 13:43:43 -0700 Adding a few Darins. Darin Adler, cc'ing you because you recommend I take this approach in #webkit. Darin Fisher, cc'ing you just to circle back from when we talked about this months ago. 141284 21 darin 2009-08-18 15:17:40 -0700 This does sound like what we discussed. Calling this on a single WebView seems a little strange, because JavaScript often causes one WebView to affect another; they tend to work in groups that need to share the same security settings. We normally use WebPreferences for such settings, to make it easy to share them among many WebView objects. I do think that it's probably better to code this so it's easier to use correctly. If we did it with a delegate it would provide a lot of flexibility, but it would be a bit too much "do it yourself", and make it less likely that people would get it right. 141285 22 abarth 2009-08-18 15:22:42 -0700 (In reply to comment #21) > Calling this on a single WebView seems a little strange, because JavaScript > often causes one WebView to affect another; Where do we pipe in the noAccess schemes? Seems like we should put this API in the same place as that one. 141287 23 darin 2009-08-18 15:25:04 -0700 (In reply to comment #22) > Where do we pipe in the noAccess schemes? Seems like we should put this API in > the same place as that one. Currently those are per-process global. +[WebView registerURLAsLocal:] Doing that may be a mistake we should not repeat. Not sure. 141294 24 aa 2009-08-18 15:32:47 -0700 (In reply to comment #21) > This does sound like what we discussed. Cool. > Calling this on a single WebView seems a little strange, because JavaScript > often causes one WebView to affect another; they tend to work in groups that > need to share the same security settings. We normally use WebPreferences for > such settings, to make it easy to share them among many WebView objects. The method is static on WebView (I think, I'm new to Objective-C), so it's not being called for a _single_ WebView. I'm happy to move it wherever though. Would you prefer it on WebPreferences? 141298 25 darin 2009-08-18 15:39:15 -0700 (In reply to comment #24) > The method is static on WebView (I think, I'm new to Objective-C), so it's not > being called for a _single_ WebView. I missed that! You're right. It's a class method. > I'm happy to move it wherever though. Would you prefer it on WebPreferences? We can start with this. 141386 26 35037 abarth 2009-08-18 21:05:37 -0700 Comment on attachment 35037 Implements the concept of 'security origin access white lists'. I've only looked at the SecurityOrigin pieces. In general, this approach seems good. There are a couple of details that we should change: 1) OriginAccessWhiteListEntry should be in its own file. In general, WebKit is one class per file. 2) I'm not a big fan of m_secure. Seems like what you really want to do is pass in m_scheme. Then you can pass in "https" when you were previously passing m_secure = true and "http" when you were previously passing m_secure = false. 3) Some style issues: + OriginAccessWhiteList* list = originAccessMap().get(toString()); + if (list) + for (size_t i = 0; i < list->size(); ++i) + if (list->at(i)->matchesOrigin(*targetOrigin)) + return true; A more WebKity way to write this would be: if (OriginAccessWhiteList* list = originAccessMap().get(toString())) { for (size_t i = 0; i < list->size(); ++i) { if (list->at(i)->matchesOrigin(*targetOrigin)) return true; } } + if (!list) + { + list = new OriginAccessWhiteList(); + originAccessMap().set(source.toString(), list); + } should be if (!list) { list = new OriginAccessWhiteList(); originAccessMap().set(source.toString(), list); } (several other occurances of this same style issue) 4) SecurityOrigin::resetOriginAccessWhiteLists is kind of ugly because it has a lot of delete operators. Why not make OriginAccessWhiteListEntry a value type and store it directly in the Vector instead of storing pointers? The current design seems like a premature optimization. 5) WebKit leaks a lot at exit. I don't think we should be that concerned about it here. 6) Why do we do the work to figure out whether m_host is an IP address ever time we call matchesOrigin? Seems like we should do that in the constructor. We should probably make it an error to supply an IP address and includeSubdomains by making this an ASSERT. 141544 27 35037 levin 2009-08-19 12:17:39 -0700 Comment on attachment 35037 Implements the concept of 'security origin access white lists'. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > + * page/SecurityOrigin.cpp: Implement origin acces whitelists. typo: acces Typically these comments are a bit more granular. For example, see http://trac.webkit.org/changeset/47469 But at the same time not everyone does them. > diff --git a/WebCore/page/SecurityOrigin.cpp b/WebCore/page/SecurityOrigin.cpp > +class OriginAccessWhiteListEntry { > +public: > + OriginAccessWhiteListEntry(const String& host, bool includeSubdomains, bool secure) : m_host(host), m_includeSubdomains(includeSubdomains), m_secure(secure) { } As mentioned before: formatting and bool -> enum. > + bool matchesOrigin(const SecurityOrigin& origin) > + if (origin.host().length() > m_host.length() && origin.host()[origin.host().length() - m_host.length() - 1] == '.' && origin.host().endsWith(m_host, true)) I think you want "origin.host().endsWith(m_host, false)" (caseSensitive = false). > + return true; > +static OriginAccessMap& originAccessMap() > +{ It would be nice to add an assert that this is only accessed on the main thread. #include <wtf/threading.h> ASSERT(isMainThread()); > +void SecurityOrigin::whiteListAccessToOrigin(const SecurityOrigin& source, const String& domain, bool includeSubdomains, bool secure) > +{ > + // FIXME: We leak these objects at process shutdown. Is that OK? > + OriginAccessWhiteList* list = originAccessMap().get(source.toString()); Doing toString multiple times seems non-ideal. It would be nice to add Assert(!source.isEmpty()); if (source.m_noAccess) return; > diff --git a/WebCore/page/SecurityOrigin.h b/WebCore/page/SecurityOrigin.h > + static void whiteListAccessToOrigin(const SecurityOrigin& source, const String& domain, bool includeSubdomains, bool secure); Consider s/domain/allowedDomain/ > > diff --git a/WebKit/mac/WebView/WebViewPrivate.h b/WebKit/mac/WebView/WebViewPrivate.h > +// Whitelists access from an origin (sourceOrigin) to a set of one or more origins described by the parameters: > +// - host: The host to grant access to. > +// - includeSubdomains: If host is a domain, setting this to YES will whitelist host and all its subdomains, recursively. > +// - secure: Whether to grant access to https or http origins. If yes, only https origins will be whitelisted. If no, only http origins will be. > ++ (void)_whiteListAccessToOrigin:(NSString*)sourceOrigin host:(NSString*)host includeSubdomains:(BOOL)includeSubdomains secure:(BOOL)secure; It seems odd that the api name is "_whiteListAccessToOrigin" but the origin that is allowed is called host. I'd recommend this + (void)_whiteListAccessFromOrigin:(NSString*)sourceOrigin allowedHost:(NSString*)host includeSubdomains:(BOOL)includeSubdomains secure:(BOOL)secure; so that it reads better. It current reads like the first parameter is the origin that you're allowing access to. (Consider this name change in other places too if you think it reads better.) > diff --git a/WebKitTools/DumpRenderTree/mac/LayoutTestControllerMac.mm b/WebKitTools/DumpRenderTree/mac/LayoutTestControllerMac.mm > +void LayoutTestController::resetOriginAccessWhiteLists() > +{ > + [WebView _resetOriginAccessWhiteLists]; > +} It seems that this [WebView _resetOriginAccessWhiteLists]; should be done in WebKitTools/DumpRenderTree/mac/DumpRenderTree.mm static void resetWebViewToConsistentStateBeforeTesting() A that point there is no reason to expose this from layout test controller. 141615 28 35151 aa 2009-08-19 15:33:10 -0700 Created attachment 35151 New patch Addressed comments, added WebKit frontends and integration with DRT for qt and gtk. Did not do Windows because it looks pretty hairy and other things (database) also aren't done yet. 141627 29 35151 darin 2009-08-19 16:05:01 -0700 Comment on attachment 35151 New patch > +OriginAccessEntry::OriginAccessEntry(const String& protocol, const String& host, SubdomainSetting subdomainSetting) : m_protocol(protocol), m_host(host), m_allowSubdomains(subdomainSetting) { We normally use a vertical format that puts each of these onto a separate line. > + ASSERT(protocol == "http" || protocol == "https"); A while back I had a patch that added a protocolIsInHTTPFamily() function for strings to KURL.h. Looking, though, it seems I did not land it. > + UChar last = m_host[m_host.length() - 1]; Can host be an empty string? Does this work properly in that case? I guess it does. > + m_hostIsIPAddress = last >= '0' && last <= '9'; CType.h's isASCIIDigit is the normal way we'd do this. > + if (m_protocol != origin.protocol()) Are these made canonically lowercase? > + if (m_host == origin.host()) Same question again. > + // FIXME: This hasn't actually been tested as I can't figure out a way to test it with the layout test system. This is good to note, but maybe not with a comment in the source code. > +#include "CString.h" You should be including PlatformString.h here in CrossOriginAccess.h, not CString.h. > + OriginAccessEntry(const String& protocol, const String& host, SubdomainSetting subdomainSetting); Normally we would omit the subdomainSetting argument name. > + bool matchesOrigin(const SecurityOrigin& origin); Normally we would omit the origin argument name. And make this a const member function. > +// static > +void SecurityOrigin::whiteListAccessFromOrigin(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomains, bool allowDestinationSubdomains) We don't normally include that "// static" comment, and while it's nice to know, it's not that useful to have it for this one function and not for the many other static member functions. > + String sourceString = sourceOrigin.toString(); > + OriginAccessWhiteList* list = originAccessMap().get(sourceString); Applies to other call sites too. If the sourceString is empty or null then this will crash. So we either need to know it's not empty or have a check for empty string. Inelegant, I know. > + list = new OriginAccessWhiteList(); No need for the parentheses here. > + for (OriginAccessMap::iterator iter = map.begin(); iter != map.end(); ++iter) { > + OriginAccessWhiteList* list = iter->second; > + delete list; > + } There's a function template that does this. It's called deleteAllValues. > ++ (void)_whiteListAccessFromOrigin:(NSString*)sourceOrigin destinationProtocol:(NSString*)destinationProtocol destinationHost:(NSString*)destinationHost allowDestinationSubdomains:(BOOL)allowDestinationSubdomains; The semicolon at the end of this line is incorrect, albeit tolerated by the compiler. The confusing WebKit style rule is that for Objective-C types such as NSString, we put the * after a space. I know, it's strange, but it's how we do it. > +2009-08-19 Aaron Boodman <aa@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + https://bugs.webkit.org/show_bug.cgi?id=24853: Provide a way for WebKit clients to > + specify a more granular policy for cross-origin XHR access. > + > + * DumpRenderTree/LayoutTestController.cpp: Expose whiteListAccessFromOrigin() to layout tests. > + (whiteListAccessFromOriginCallback): Ditto. > + (LayoutTestController::staticFunctions): Ditto. > + * DumpRenderTree/LayoutTestController.h: Ditto. > + * DumpRenderTree/gtk/LayoutTestControllerGtk.cpp: Ditto. > + (LayoutTestController::whiteListAccessToOrigin): Ditto. > + * DumpRenderTree/mac/LayoutTestControllerMac.mm: Ditto. > + (LayoutTestController::whiteListAccessFromOrigin): Ditto. > + * DumpRenderTree/qt/jsobjects.cpp: Ditto. > + (LayoutTestController::whiteListAccessFromOrigin): Ditto. > + * DumpRenderTree/win/LayoutTestControllerWin.cpp: Stub out whiteListAccessFromOrigin(). > + (LayoutTestController::whiteListAccessFromOrigin): Ditto. > + * DumpRenderTree/gtk/DumpRenderTree.cpp: Reset origin access lists before each test. > + (resetWebViewToConsistentStateBeforeTesting): Ditto. > + * DumpRenderTree/mac/DumpRenderTree.mm: Ditto. > + (resetWebViewToConsistentStateBeforeTesting): Ditto. > + * DumpRenderTree/qt/DumpRenderTree.cpp: Ditto. > + (WebCore::DumpRenderTree::resetToConsistentStateBeforeTesting): Ditto. > + > +2009-08-18 Aaron Boodman <aa@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + https://bugs.webkit.org/show_bug.cgi?id=24853: Provide a way for WebKit clients to > + specify a more granular policy for cross-origin XHR access. > + > + * DumpRenderTree/LayoutTestController.cpp: Add plumbing to be able to manipulate > + origin access whitelists from layout tests. > + (whiteListAccessToOriginCallback): Ditto. > + (resetOriginAccessWhiteListsCallback): Ditto. > + (LayoutTestController::staticFunctions): Ditto. > + * DumpRenderTree/LayoutTestController.h: Ditto. > + * DumpRenderTree/mac/LayoutTestControllerMac.mm: Ditto. > + (LayoutTestController::whiteListAccessToOrigin): Ditto. > + (LayoutTestController::resetOriginAccessWhiteLists): Ditto. > + Double change log. Looks good. review- because of the comments above 141631 30 levin 2009-08-19 16:24:49 -0700 Darin's comments include what I would have said and more. The only thing to add is that the current patch only fixes up the osx build system. The new files need to be added to the other build systems as well. 141655 31 35161 aa 2009-08-19 17:21:51 -0700 Created attachment 35161 Now with even more code! 141661 32 aa 2009-08-19 17:26:25 -0700 (In reply to comment #29) > > + ASSERT(protocol == "http" || protocol == "https"); > > A while back I had a patch that added a protocolIsInHTTPFamily() function for > strings to KURL.h. Looking, though, it seems I did not land it. Ok, so I just left this as-is. > > + UChar last = m_host[m_host.length() - 1]; > > Can host be an empty string? Does this work properly in that case? I guess it > does. Thanks for pointing this out. It was working that way correctly only by chance, I have fixed it. > > + if (m_protocol != origin.protocol()) > > Are these made canonically lowercase? > > > + if (m_host == origin.host()) > > Same question again. I have now manually forced the state in OriginAccessEntry to be lower-case. For the SecurityOrigin input to ::matchesOrigin(), SecurityOrigin currently lower-cases all the components on construction, and I want to avoid duplicating that. I've added ASSERTs that this remains true in the future. > > +// static > > +void SecurityOrigin::whiteListAccessFromOrigin(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomains, bool allowDestinationSubdomains) > > We don't normally include that "// static" comment, and while it's nice to > know, it's not that useful to have it for this one function and not for the > many other static member functions. I only did this because the rest of this file has a bunch of // static comments. Anyway, I've removed it. > > + String sourceString = sourceOrigin.toString(); > > + OriginAccessWhiteList* list = originAccessMap().get(sourceString); > > Applies to other call sites too. If the sourceString is empty or null then this > will crash. So we either need to know it's not empty or have a check for empty > string. Inelegant, I know. I already had an ASSERT here that sourceOrigin is non-empty. Is there more that I should do? > > + for (OriginAccessMap::iterator iter = map.begin(); iter != map.end(); ++iter) { > > + OriginAccessWhiteList* list = iter->second; > > + delete list; > > + } > > There's a function template that does this. It's called deleteAllValues. Cool, thanks for the pointer. (In reply to comment #30) > Darin's comments include what I would have said and more. > > The only thing to add is that the current patch only fixes up the osx build > system. The new files need to be added to the other build systems as well. Myriad build systems updated. All other comments addressed I think. 141664 33 darin 2009-08-19 17:38:31 -0700 (In reply to comment #32) > > > + String sourceString = sourceOrigin.toString(); > > > + OriginAccessWhiteList* list = originAccessMap().get(sourceString); > > > > Applies to other call sites too. If the sourceString is empty or null then this > > will crash. So we either need to know it's not empty or have a check for empty > > string. Inelegant, I know. > > I already had an ASSERT here that sourceOrigin is non-empty. Is there more that > I should do? If the assert is correct, then the code is fine. But asserting something doesn't make it so. I assume there's a simple reason to know it won't be empty; you don't have to convince me, I just want to be sure you know it to be true. 141665 34 35166 aa 2009-08-19 17:39:03 -0700 Created attachment 35166 rebase patch to HEAD This just updates the patch to apply cleanly to current HEAD. 141669 35 35166 levin 2009-08-19 17:41:10 -0700 Comment on attachment 35166 rebase patch to HEAD Looks good to me modulo a few nits.... WebCore/ChangeLog: It appears to be missing a few file names. > diff --git a/WebCore/GNUmakefile.am b/WebCore/GNUmakefile.am > WebCore/page/Navigator.h \ > WebCore/page/NavigatorBase.cpp \ > WebCore/page/NavigatorBase.h \ > + WebCore/page/OriginAccessEntry.h \ > + WebCore/page/OriginAccessEntry.cpp \ cpp then h > diff --git a/WebCore/WebCore.base.exp b/WebCore/WebCore.base.exp > +__ZN7WebCore14SecurityOrigin27resetOriginAccessWhiteListsEv > +__ZN7WebCore14SecurityOrigin25whiteListAccessFromOriginERKS0_RKNS_6StringES5_b These seem out of sort order 27 after 25. > diff --git a/WebCore/page/OriginAccessEntry.cpp b/WebCore/page/OriginAccessEntry.cpp > new file mode 100644 > index 0000000..c0e92fe > --- /dev/null > +++ b/WebCore/page/OriginAccessEntry.cpp > @@ -0,0 +1,80 @@ > +/* > + * Copyright (C) 2009 Apple Inc. All rights reserved. Consider using http://trac.webkit.org/browser/trunk/WebCore/loader/ThreadableLoader.h as a basis for your copyright. > +#include "config.h" > +#include "CType.h" > +#include "OriginAccessEntry.h" OriginAccessEntry.h should be immediately after config.h (like Google style except add in a config.h first). Then a blank like and CType.h, SecurityOrigin.h > diff --git a/WebCore/page/OriginAccessEntry.h b/WebCore/page/OriginAccessEntry.h > +/* > + * Copyright (C) 2009 Apple Inc. All rights reserved. Same copyright comment. > diff --git a/WebCore/page/SecurityOrigin.cpp b/WebCore/page/SecurityOrigin.cpp > #include "CString.h" > #include "FrameLoader.h" > +#include "OriginAccessEntry.h" Should be after KURL.h > #include "KURL.h" > diff --git a/WebCore/page/SecurityOrigin.h b/WebCore/page/SecurityOrigin.h > + static void whiteListAccessFromOrigin(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomains, bool allowDestinationSubdomains); Omit param name: sourceOrigin since it doesn't add any information. > diff --git a/WebKit/gtk/webkit/webkitprivate.cpp b/WebKit/gtk/webkit/webkitprivate.cpp > #include "ResourceHandleClient.h" > #include "ResourceHandleInternal.h" > #include <runtime/InitializeThreading.h> > +#include "SecurityOrigin.h" This include is out of order. 141679 36 35172 aa 2009-08-19 18:20:47 -0700 Created attachment 35172 New patch 141680 37 aa 2009-08-19 18:22:09 -0700 (In reply to comment #33) > If the assert is correct, then the code is fine. But asserting something > doesn't make it so. I assume there's a simple reason to know it won't be empty; > you don't have to convince me, I just want to be sure you know it to be true. My thinking was that this is API and that it should just be part of the contract that callers do not pass empty strings. On second thought though, I think since clients will likely be passing in computed data, it would be nice to fail somewhat more gracefully than crashing. So I've fixed that. (In reply to comment #35) > WebCore/ChangeLog: > It appears to be missing a few file names. I think they are all there, though the formatting was weird. Fixed. > > diff --git a/WebCore/page/SecurityOrigin.h b/WebCore/page/SecurityOrigin.h > > + static void whiteListAccessFromOrigin(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomains, bool allowDestinationSubdomains); > > Omit param name: sourceOrigin > since it doesn't add any information. I feel like it clarifies a little, especially in contrast with destination* param names. Do you mind if I leave it? > > diff --git a/WebKit/gtk/webkit/webkitprivate.cpp b/WebKit/gtk/webkit/webkitprivate.cpp > > #include "ResourceHandleClient.h" > > #include "ResourceHandleInternal.h" > > #include <runtime/InitializeThreading.h> > > +#include "SecurityOrigin.h" > > This include is out of order. It is? It seems OK. All else done. 141682 38 aa 2009-08-19 18:29:57 -0700 Note: Please do not commit-queue+ this, as I am out for the rest of the night, and am quite certain the non-mac world will catch on fire when this is submitted. I want to be there when it does so I can put it out. 141687 39 35172 abarth 2009-08-19 18:38:14 -0700 Comment on attachment 35172 New patch Marking as commit-queue- per aa's request. Note that you should feel free to do this yourself. :) 141708 40 35172 abarth 2009-08-19 19:30:54 -0700 Comment on attachment 35172 New patch The SecurityOrigin and OriginAccessEntry parts look great! Two nits: m_allowSubdomains should be m_subdomainSetting + // Special case: Include subdomains and empty host means "all hosts, including ip addresses". Please note this in the header. 141718 41 35181 aa 2009-08-19 20:16:43 -0700 Created attachment 35181 New patch Made abarth's comment. 141730 42 35181 levin 2009-08-19 21:23:48 -0700 Comment on attachment 35181 New patch Only one minor nit which would be nice for someone to fix on landing.... (I'm willing to do so). > diff --git a/WebKit/gtk/webkit/webkitprivate.cpp b/WebKit/gtk/webkit/webkitprivate.cpp > #include "ResourceHandleClient.h" > #include "ResourceHandleInternal.h" > #include <runtime/InitializeThreading.h> > +#include "SecurityOrigin.h" The <> headers come after the "" headers. > > Omit param name: sourceOrigin > I feel like it clarifies... You are right. I read it too quickly as securityOrigin. > I think they are all there, though the formatting was weird. Fixed Thanks. I must have read it too quickly again. 141745 43 levin 2009-08-19 23:30:35 -0700 Committed as http://trac.webkit.org/changeset/47548 > The <> headers come after the "" headers. Once I got in this file, I saw that it didn't follow the standard header ordering and Aaron's change followed the style of the file better so I left this as it was in the patch. 28979 2009-03-26 13:43:51 -0700 2009-08-18 04:59:52 -0700 Create SecurityOriginDelegate that is called from SecurityOrigin::canAccess() & canRequest() security_origin_delegate_patch.txt text/plain 14194 rafaelw SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lv biA0MjAwNykKKysrIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3 b3JraW5nIGNvcHkpCkBAIC00MzE2LDYgKzQzMTYsOCBAQAogCQlEMjNDQTU1RDBBQjBFQUFFMDA1 MTA4QTUgLyogSlNSYW5nZUV4Y2VwdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRDIzQ0E1NUMwQUIwRUFBRTAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNl cHRpb24uaCAqLzsgfTsKIAkJRDIzQ0E1NUYwQUIwRUFCNjAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNl cHRpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RDIzQ0E1NUUwQUIwRUFCNjAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNlcHRpb24uY3BwICovOyB9Owog CQlEMjNDQTU2QzBBQjBFQjhEMDA1MTA4QTUgLyogUmFuZ2VFeGNlcHRpb24uaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEQyM0NBNTZCMEFCMEVCOEQwMDUx MDhBNSAvKiBSYW5nZUV4Y2VwdGlvbi5oICovOyB9OworCQlENjg0RjIwQTBGN0MxNkZCMDA2OTU3 MTYgLyogU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBENjg0RjIwODBGN0MxNkZCMDA2OTU3MTYgLyogU2VjdXJp dHlPcmlnaW5EZWxlZ2F0ZS5jcHAgKi87IH07CisJCUQ2ODRGMjBCMEY3QzE2RkIwMDY5NTcxNiAv KiBTZWN1cml0eU9yaWdpbkRlbGVnYXRlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBENjg0RjIwOTBGN0MxNkZCMDA2OTU3MTYgLyogU2VjdXJpdHlPcmln aW5EZWxlZ2F0ZS5oICovOyB9OwogCQlEQjIzQzJDQjBBNTA4RDI5MDAyNDg5RUIgLyogSW5kZW50 T3V0ZGVudENvbW1hbmQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gREIyM0MyQzkwQTUwOEQyOTAwMjQ4OUVCIC8qIEluZGVudE91dGRlbnRDb21tYW5k LmNwcCAqLzsgfTsKIAkJREIyM0MyQ0MwQTUwOEQyOTAwMjQ4OUVCIC8qIEluZGVudE91dGRlbnRD b21tYW5kLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBE QjIzQzJDQTBBNTA4RDI5MDAyNDg5RUIgLyogSW5kZW50T3V0ZGVudENvbW1hbmQuaCAqLzsgfTsK IAkJREQwNUZFMEQwQjhCQTNDNjAwOUFDREZFIC8qIFdlYkNvcmVPYmpDRXh0cmFzLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBERDA1RkUwQjBCOEJBM0M2 MDA5QUNERkUgLyogV2ViQ29yZU9iakNFeHRyYXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtOTE2Nyw2ICs5MTY5LDggQEAKIAkJRDIzQ0E1NUMw QUIwRUFBRTAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNlcHRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IEpTUmFuZ2VFeGNlcHRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJRDIzQ0E1NUUwQUIwRUFCNjAwNTEwOEE1IC8qIEpTUmFuZ2VFeGNlcHRpb24uY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTUmFuZ2VFeGNlcHRpb24u Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMjNDQTU2QjBBQjBFQjhEMDA1MTA4 QTUgLyogUmFuZ2VFeGNlcHRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IFJhbmdlRXhjZXB0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUQ2ODRGMjA4 MEY3QzE2RkIwMDY5NTcxNiAvKiBTZWN1cml0eU9yaWdpbkRlbGVnYXRlLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNlY3VyaXR5T3JpZ2luRGVsZWdhdGUuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlENjg0RjIwOTBGN0MxNkZCMDA2OTU3MTYgLyog U2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBTZWN1cml0eU9yaWdpbkRlbGVnYXRlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CURCMjNDMkM5MEE1MDhEMjkwMDI0ODlFQiAvKiBJbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSW5kZW50T3V0ZGVudENvbW1hbmQu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEQjIzQzJDQTBBNTA4RDI5MDAyNDg5 RUIgLyogSW5kZW50T3V0ZGVudENvbW1hbmQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEluZGVudE91dGRlbnRDb21tYW5kLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUREMDVGRTBCMEI4QkEzQzYwMDlBQ0RGRSAvKiBXZWJDb3JlT2JqQ0V4dHJhcy5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2ViQ29yZU9iakNFeHRyYXMuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEzODk1LDYgKzEzODk5LDggQEAKIAkJCQlFNEQ2ODc3 ODBFRDdBRTRGMDA2RUE5NzggLyogUHVyZ2VhYmxlQnVmZmVyLmggKi8sCiAJCQkJMUM2M0EyNDYw RjcxNjQ2NjAwQzA5RDVBIC8qIFJ1bkxvb3BUaW1lci5oICovLAogCQkJCUY1ODc4NjYyMDJERTNC MTEwMUVBNDEyMiAvKiBTU0xLZXlHZW5lcmF0b3IuaCAqLywKKwkJCQlENjg0RjIwODBGN0MxNkZC MDA2OTU3MTYgLyogU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5jcHAgKi8sCisJCQkJRDY4NEYyMDkw RjdDMTZGQjAwNjk1NzE2IC8qIFNlY3VyaXR5T3JpZ2luRGVsZWdhdGUuaCAqLywKIAkJCQk5M0Mw OUM4NTBCMDY1N0FBMDA1QUJENEQgLyogU2Nyb2xsVHlwZXMuaCAqLywKIAkJCQlCQzI0NDFDMzBF OEI2NUQwMDA1NTMyMEYgLyogU2Nyb2xsVmlldy5jcHAgKi8sCiAJCQkJQkM2RDZFMjUwOUFGOTQz NTAwRjU5NzU5IC8qIFNjcm9sbFZpZXcuaCAqLywKQEAgLTE2OTA5LDYgKzE2OTE1LDcgQEAKIAkJ CQlGRTZGRDQ4ODBGNjc2RTU3MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICov LAogCQkJCUZFNkZENDhFMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmggaW4gSGVh ZGVycyAqLywKIAkJCQkxQzYzQTI0ODBGNzE2NDY2MDBDMDlENUEgLyogUnVuTG9vcFRpbWVyLmgg aW4gSGVhZGVycyAqLywKKwkJCQlENjg0RjIwQjBGN0MxNkZCMDA2OTU3MTYgLyogU2VjdXJpdHlP cmlnaW5EZWxlZ2F0ZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxv eW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0xODkxMyw2ICsxODkyMCw3IEBACiAJ CQkJRkU2RkQ0ODcwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCUZFNkZENDhEMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmNwcCBp biBTb3VyY2VzICovLAogCQkJCTFDNjNBMjQ5MEY3MTY0NjYwMEMwOUQ1QSAvKiBSdW5Mb29wVGlt ZXJDRi5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlENjg0RjIwQTBGN0MxNkZCMDA2OTU3MTYgLyog U2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5P bmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTE4OTc5LDYgKzE4 OTg3LDcgQEAKIAkJCQlERUFEX0NPREVfU1RSSVBQSU5HID0gIiQoREVBRF9DT0RFX1NUUklQUElO R19kZWJ1ZykiOwogCQkJCURFQlVHX0RFRklORVMgPSAiJChERUJVR19ERUZJTkVTX2RlYnVnKSI7 CiAJCQkJR0NDX09QVElNSVpBVElPTl9MRVZFTCA9ICIkKEdDQ19PUFRJTUlaQVRJT05fTEVWRUxf ZGVidWcpIjsKKwkJCQlHQ0NfVFJFQVRfV0FSTklOR1NfQVNfRVJST1JTID0gTk87CiAJCQkJU1RS SVBfSU5TVEFMTEVEX1BST0RVQ1QgPSAiJChTVFJJUF9JTlNUQUxMRURfUFJPRFVDVF9kZWJ1Zyki OwogCQkJfTsKIAkJCW5hbWUgPSBEZWJ1ZzsKSW5kZXg6IFdlYkNvcmUvcGFnZS9TZWN1cml0eU9y aWdpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAko cmV2aXNpb24gNDIwMDcpCisrKyBXZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKICNp bmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJT ZWN1cml0eU9yaWdpbkRlbGVnYXRlLmgiCiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0xMjQsNiArMTI1LDkgQEAgYm9vbCBTZWN1cml0eU9y aWdpbjo6Y2FuQWNjZXNzKGNvbnN0IFNlYwogICAgIGlmIChtX3VuaXZlcnNhbEFjY2VzcykKICAg ICAgICAgcmV0dXJuIHRydWU7CiAKKyAgICBpZiAoU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZTo6aXNB Y2Nlc3NXaGl0ZWxpc3RlZCgqdGhpcywgKm90aGVyKSkKKyAgICAgICAgcmV0dXJuIHRydWU7Cisg ICAgCiAgICAgaWYgKG1fbm9BY2Nlc3MgfHwgb3RoZXItPm1fbm9BY2Nlc3MpCiAgICAgICAgIHJl dHVybiBmYWxzZTsKIApAQCAtMTY1LDEwICsxNjksMTUgQEAgYm9vbCBTZWN1cml0eU9yaWdpbjo6 Y2FuUmVxdWVzdChjb25zdCBLVQogICAgIGlmIChtX3VuaXZlcnNhbEFjY2VzcykKICAgICAgICAg cmV0dXJuIHRydWU7CiAKKyAgICBSZWZQdHI8U2VjdXJpdHlPcmlnaW4+IHRhcmdldE9yaWdpbiA9 IFNlY3VyaXR5T3JpZ2luOjpjcmVhdGUodXJsKTsKKyAgICAKKyAgICBpZiAoU2VjdXJpdHlPcmln aW5EZWxlZ2F0ZTo6aXNSZXF1ZXN0V2hpdGVsaXN0ZWQoKnRoaXMsICoodGFyZ2V0T3JpZ2luLmdl dCgpKSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIAogICAgIGlmIChtX25vQWNjZXNzKQog ICAgICAgICByZXR1cm4gZmFsc2U7CiAKLSAgICBSZWZQdHI8U2VjdXJpdHlPcmlnaW4+IHRhcmdl dE9yaWdpbiA9IFNlY3VyaXR5T3JpZ2luOjpjcmVhdGUodXJsKTsKKyAgICAKIAogICAgIC8vIFdl IGNhbGwgaXNTYW1lU2NoZW1lSG9zdFBvcnQgaGVyZSBpbnN0ZWFkIG9mIGNhbkFjY2VzcyBiZWNh dXNlIHdlIHdhbnQKICAgICAvLyB0byBpZ25vcmUgZG9jdW1lbnQuZG9tYWluIGVmZmVjdHMuCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL1NlY3VyaXR5T3JpZ2luRGVsZWdhdGUuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5jcHAJKHJldmlz aW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL1NlY3VyaXR5T3JpZ2luRGVsZWdhdGUuY3BwCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFw cGxlIENvbXB1dGVyLCBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJ UycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICog Q09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkK KyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJTZWN1cml0eU9yaWdpbkRlbGVnYXRlLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworYm9vbCBTZWN1cml0eU9yaWdpbkRlbGVnYXRlOjppc0FjY2Vzc1do aXRlbGlzdGVkKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2UsIAorICAgIGNvbnN0IFNlY3Vy aXR5T3JpZ2luJiB0YXJnZXQpIAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBTZWN1 cml0eU9yaWdpbkRlbGVnYXRlOjppc1JlcXVlc3RXaGl0ZWxpc3RlZChjb25zdCBTZWN1cml0eU9y aWdpbiYgc291cmNlLCAKKyAgICBjb25zdCBTZWN1cml0eU9yaWdpbiYgdGFyZ2V0KSAKK3sKKyAg ICByZXR1cm4gZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNv cmUvcGxhdGZvcm0vU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvcGxhdGZvcm0vU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZS5oCShyZXZpc2lvbiAwKQorKysgV2Vi Q29yZS9wbGF0Zm9ybS9TZWN1cml0eU9yaWdpbkRlbGVnYXRlLmgJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsNTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQXBwbGUgQ29tcHV0ZXIsIElu Yy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBTZWN1cml0eU9yaWdpbkRl bGVnYXRlX2gKKyNkZWZpbmUgU2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZV9oCisKKyNpbmNsdWRlICJT ZWN1cml0eU9yaWdpbi5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFNlY3VyaXR5 T3JpZ2luRGVsZWdhdGUgeworcHVibGljOgorCisgICAgLy8gQ2hlY2sgdG8gc2VlIGlmIGFjY2Vz cyBmcm9tIHxzb3VyY2V8IHRvIHx0YXJnZXR8IGlzIHdoaXRlbGlzdGVkIGJ5IHRoZSBjbGllbnQK KyAgICAvLyBTZWN1cml0eU9yaWdpbjo6Y2FuQWNjZXNzKCkgY2hlY2tzIGhlcmUgYmVmb3JlIGRv aW5nIGl0J3Mgb3duIHNhbWUtb3JpZ2luIHBvbGljeQorICAgIC8vIGNoZWNrcy4KKyAgICAvLyBS ZXR1cm5zIFRSVUUgaWYgdGhlIGFjY2VzcyBpcyB3aGl0ZWxpc3RlZAorICAgIC8vIFJldHVybnMg RkFMU0UgaWYgdGhlIFNlY3VyaXR5T3JpZ2luOjpjYW5BY2Nlc3MoKSBzaG91bGQgcHJvY2VkZSB3 aXRoIGl0J3Mgbm9ybWFsIGNoZWNrCisgICAgc3RhdGljIGJvb2wgaXNBY2Nlc3NXaGl0ZWxpc3Rl ZChjb25zdCBTZWN1cml0eU9yaWdpbiYgc291cmNlLCBjb25zdCBTZWN1cml0eU9yaWdpbiYgdGFy Z2V0KTsKKworICAgIC8vIENoZWNrIHRvIHNlZSBpZiBhIHJlcXVlc3QgZnJvbSB8c291cmNlfCB0 byB8dGFyZ2V0fCBpcyB3aGl0ZWxpc3RlZCBieSB0aGUgY2xpZW50CisgICAgLy8gU2VjdXJpdHlP cmlnaW46OmNhblJlcXVlc3QoKSBjaGVja3MgaGVyZSBiZWZvcmUgZG9pbmcgaXQncyBvd24gc2Ft ZS1vcmlnaW4gcG9saWN5CisgICAgLy8gY2hlY2tzLgorICAgIC8vIFJldHVybnMgVFJVRSBpZiB0 aGUgcmVxdWVzdCBpcyB3aGl0ZWxpc3RlZAorICAgIC8vIFJldHVybnMgRkFMU0UgaWYgdGhlIFNl Y3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0KCkgc2hvdWxkIHByb2NlZGUgd2l0aCBpdCdzIG5vcm1h bCBjaGVjaworICAgIHN0YXRpYyBib29sIGlzUmVxdWVzdFdoaXRlbGlzdGVkKGNvbnN0IFNlY3Vy aXR5T3JpZ2luJiBzb3VyY2UsIGNvbnN0IFNlY3VyaXR5T3JpZ2luJiB0YXJnZXQpOworfTsKKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gU2VjdXJpdHlPcmlnaW5EZWxlZ2F0 ZV9oCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0Nocm9taXVtQnJpZGdlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DaHJvbWl1bUJyaWRnZS5oCShy ZXZpc2lvbiA0MjAwNykKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2hyb21pdW1Ccmlk Z2UuaAkod29ya2luZyBjb3B5KQpAQCAtNTUsNiArNTUsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgY2xhc3MgSW1hZ2U7CiAgICAgY2xhc3MgSW50UmVjdDsKICAgICBjbGFzcyBLVVJMOwor ICAgIGNsYXNzIFNlY3VyaXR5T3JpZ2luOwogICAgIGNsYXNzIFN0cmluZzsKICAgICBjbGFzcyBX aWRnZXQ7CiAKQEAgLTExOSw2ICsxMjAsMTIgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICAvLyBSZXNvdXJjZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxJbWFnZT4gbG9hZFBs YXRmb3JtSW1hZ2VSZXNvdXJjZShjb25zdCBjaGFyKiBuYW1lKTsKIAorICAgICAgICAvLyBTZWN1 cml0eU9yaWdpbkRlbGVnYXRlIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQorICAgICAgICBzdGF0aWMgYm9vbCBpc0FjY2Vzc1doaXRlbGlzdGVkKGNvbnN0IFNl Y3VyaXR5T3JpZ2luJiBzb3VyY2UsCisgICAgICAgICAgICBjb25zdCBTZWN1cml0eU9yaWdpbiYg dGFyZ2V0KTsKKyAgICAgICAgc3RhdGljIGJvb2wgaXNSZXF1ZXN0V2hpdGVsaXN0ZWQoY29uc3Qg U2VjdXJpdHlPcmlnaW4mIHNvdXJjZSwKKyAgICAgICAgICAgIGNvbnN0IFNlY3VyaXR5T3JpZ2lu JiB0YXJnZXQpOworCiAgICAgICAgIC8vIFNjcmVlbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAgICAgIHN0YXRpYyBpbnQg c2NyZWVuRGVwdGgoV2lkZ2V0Kik7CiAgICAgICAgIHN0YXRpYyBpbnQgc2NyZWVuRGVwdGhQZXJD b21wb25lbnQoV2lkZ2V0Kik7CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL1NlY3Vy aXR5T3JpZ2luRGVsZWdhdGVDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0 Zm9ybS9jaHJvbWl1bS9TZWN1cml0eU9yaWdpbkRlbGVnYXRlQ2hyb21pdW0uY3BwCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9TZWN1cml0eU9yaWdpbkRlbGVnYXRl Q2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDUwIEBACisvKgorICogQ29weXJp Z2h0IChjKSAyMDA4LCAyMDA5LCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTZWN1cml0eU9yaWdpbkRlbGVnYXRlLmgiCisKKyNp bmNsdWRlICJDaHJvbWl1bUJyaWRnZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2Jvb2wg U2VjdXJpdHlPcmlnaW5EZWxlZ2F0ZTo6aXNBY2Nlc3NXaGl0ZWxpc3RlZChjb25zdCBTZWN1cml0 eU9yaWdpbiYgc291cmNlLCAKKyAgICBjb25zdCBTZWN1cml0eU9yaWdpbiYgdGFyZ2V0KSAKK3sK KyAgICByZXR1cm4gQ2hyb21pdW1CcmlkZ2U6OmlzQWNjZXNzV2hpdGVsaXN0ZWQoc291cmNlLCB0 YXJnZXQpOworfQorCitib29sIFNlY3VyaXR5T3JpZ2luRGVsZWdhdGU6OmlzUmVxdWVzdFdoaXRl bGlzdGVkKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2UsIAorICAgIGNvbnN0IFNlY3VyaXR5 T3JpZ2luJiB0YXJnZXQpIAoreworICAgIHJldHVybiBDaHJvbWl1bUJyaWRnZTo6aXNSZXF1ZXN0 V2hpdGVsaXN0ZWQoc291cmNlLCB0YXJnZXQpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl Cg== 35037 2009-08-18 04:59:14 -0700 2009-08-19 15:33:10 -0700 Implements the concept of 'security origin access white lists'. bug24853.patch text/plain 32306 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjYTQyYjU3Li5mN2I1NjQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTggIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTggIFNoaW5pY2hpcm8gSGFtYWpp ICA8aGFtYWppQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRl bC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTJiYTQyZgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1hbGwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTEgQEAKK1Rlc3RzIHRoZSBzcGVjaWFs IGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLgorCitUZXN0aW5nOiBodHRwOi8vbG9j YWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNT OiBQQVNTCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4w LjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzog UEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291 cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLWFsbC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQyNWRmYjkK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctYWxsLmh0bWwKQEAgLTAsMCArMSw1OCBAQAorPHA+VGVzdHMg dGhlIHNwZWNpYWwgY2FzZSBvZiB3aGl0ZWxpc3RpbmcgYWxsIG9yaWdpbnMuPC9wPgorCis8cHJl IGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRU ZXN0Q29udHJvbGxlci5yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK2xheW91dFRlc3RD b250cm9sbGVyLndoaXRlTGlzdEFjY2Vzc1RvT3JpZ2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAi LCAiIiwgdHJ1ZSwgZmFsc2UpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNz VG9PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICIiLCB0cnVlLCBmYWxzZSk7CisKK2Z1 bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25z b2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobWVzc2FnZSArICdcbicp KTsKK30KKworZnVuY3Rpb24gdGVzdERvbWFpbigpCit7CisgICAgdmFyIHVybCA9ICJodHRwOi8v bG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiOworICAgIGxv ZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBYTUxI dHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0cnkg eworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKCJQQVNTOiAiICsgcmVxLnJl c3BvbnNlVGV4dCk7CisgICAgfSBjYXRjaCAoZSkgeworICAgICAgICBsb2coIkZBSUw6ICIgKyBl KTsKKyAgICB9CisKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChhc3luYykiKTsKKyAg ICByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCB0 cnVlKTsKKyAgICByZXEub25sb2FkID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGxvZygiUEFTUzog IiArIHJlcS5yZXNwb25zZVRleHQpOworICAgICAgICB0ZXN0SVBBZGRyZXNzKCk7CisgICAgfTsK KyAgICByZXEub25lcnJvciA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coIkZBSUw6ICIgKyBy ZXEuc3RhdHVzKTsKKyAgICAgICAgdGVzdElQQWRkcmVzcygpOworICAgIH07CisgICAgcmVxLnNl bmQobnVsbCk7Cit9CisKK2Z1bmN0aW9uIHRlc3RJUEFkZHJlc3MoKQoreworICAgIHZhciBpZnJh bWUgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJpZnJhbWUiKTsKKyAgICBkb2N1bWVudC5ib2R5 LmFwcGVuZENoaWxkKGlmcmFtZSk7CisgICAgaWZyYW1lLnNyYyA9ICJodHRwOi8vbG9jYWxob3N0 OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRk cmVzcy10ZXN0Lmh0bWwiOworICAgIHdpbmRvdy5hZGRFdmVudExpc3RlbmVyKCJtZXNzYWdlIiwg ZnVuY3Rpb24oZSkgeworICAgICAgICBpZiAoZS5kYXRhID09ICJET05FIikgeworICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIucmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIH0g ZWxzZQorICAgICAgICAgICAgbG9nKGUuZGF0YSk7CisgICAgfSwgZmFsc2UpOworfQorCit0ZXN0 RG9tYWluKCk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctZXhhY3QtbWF0Y2gtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjMyZTVhNDQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2gtZXhwZWN0 ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGlu ZyBvcmlnaW5zIHVzaW5nIGV4YWN0IG1hdGNoaW5nLgorCitUZXN0aW5nOiBodHRwOi8vbG9jYWxo b3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNTOiBQ QVNTCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3Vy Y2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0 Y2guaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1leGFjdC1tYXRjaC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmVkZDAxMjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbApAQCAt MCwwICsxLDYyIEBACis8cD5UZXN0cyB0aGUgYmVoYXZpb3Igb2Ygd2hpdGVsaXN0aW5nIG9yaWdp bnMgdXNpbmcgZXhhY3QgbWF0Y2hpbmcuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4K KzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNldE9y aWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFj Y2Vzc1RvT3JpZ2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAibG9jYWxob3N0IiwgZmFsc2Us IGZhbHNlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSht ZXNzYWdlICsgJ1xuJykpOworfQorCitmdW5jdGlvbiB0ZXN0KHVybCwgZXhwZWN0U3VjY2VzcykK K3sKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEg PSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7 CisgICAgdHJ5IHsKKyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygoZXhwZWN0 U3VjY2VzcyA/ICJQQVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAg fSBjYXRjaCAoZSkgeworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQ QVNTOiAiKSArIGUpOworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFz eW5jKSIpOworICAgIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJH RVQiLCB1cmwsIHRydWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAg bG9nKChleHBlY3RTdWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VU ZXh0KTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5vbmVycm9yID0gZnVu Y3Rpb24oKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6 ICIpICsgcmVxLnN0YXR1cyk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEu c2VuZChudWxsKTsKK30KKwordmFyIHRlc3RzID0gWworICAgIFsiaHR0cDovL2xvY2FsaG9zdDo4 MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAvLyBGSVhN RTogSXMgaXQgcG9zc2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBb Imh0dHA6Ly9sb2NhbGhvc3Q6ODAwMS94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIs IGZhbHNlXSwKKyAgICAvLyBbImh0dHA6Ly9mb28ubG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVl c3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0sCisgICAgLy8gWyJodHRwczovL2xvY2FsaG9z dDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdCitdOworCit2 YXIgY3VycmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVzdCgpCit7CisgICAgaWYgKGN1 cnJlbnRUZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0LmFwcGx5KG51bGwsIHRlc3Rz W2N1cnJlbnRUZXN0KytdKTsKKyAgICBlbHNlIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIucmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CisgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICB9Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUzM2M0YTgKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgdGhhdCBvcmln aW4gd2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBodHRwIFVSTHMuCisKK1Rl c3Rpbmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0 LnR4dCAoc3luYykKK1BBU1M6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3QgRXhj ZXB0aW9uIDEwMQorVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0 L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBz Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctaHR0cHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4y YjhkNWNmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRw cmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKQEAgLTAsMCArMSw2MCBAQAor PHA+VGVzdHMgdGhhdCBvcmlnaW4gd2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRj aCBodHRwIFVSTHMuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+Cits YXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53 YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHMoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFjY2Vzc1RvT3JpZ2lu KCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAibG9jYWxob3N0IiwgZmFsc2UsIHRydWUpOworCitm dW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29u c29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2UgKyAnXG4n KSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQoreworICAgIGxvZygi VGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBYTUxIdHRw UmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0cnkgewor ICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIlBB U1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNoIChlKSB7 CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsgZSk7 CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMpIik7CisgICAg cmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgdHJ1 ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4cGVjdFN1 Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOworICAgICAg ICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigpIHsKKyAg ICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyByZXEuc3Rh dHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5kKG51bGwpOwor fQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJl cXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KKyAgICAvLyBGSVhNRTogSXMgaXQgcG9z c2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHBzOi8vbG9j YWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQorXTsK KwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQoreworICAgIGlm IChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShudWxsLCB0 ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZSB7CisgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgfQorfQorCituZXh0VGVzdCgpOworPC9zY3Jp cHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29y aWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjAwOTk0 NzQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1 ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDcgQEAKK1Rlc3RzIG9yaWdpbiB3aGl0ZWxpc3Rpbmcgd2l0aCBJUCBhZGRyZXNzZXMuCisK K1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv Z2V0LnR4dCAoc3luYykKK1BBU1M6IFBBU1MKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAw MC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGlu Zy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZGU2ODMyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorU3Bl Y2lmeWluZyB0aGF0IGFuIElQIGFkZHJlc3Mgc2hvdWxkIG1hdGNoIHN1YmRvbWFpbnMgZG9lc24n dCBtYWtlIHNlbnNlLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBpdCBkb2Vzbid0IGRvIGFueXRo aW5nLgorCitUZXN0aW5nOiBodHRwOi8vMTI3LjAuMC4xOjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQgKHN5bmMpCitGQUlMOiBFcnJvcjogTkVUV09SS19FUlI6IFhNTEh0dHBS ZXF1ZXN0IEV4Y2VwdGlvbiAxMDEKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxo dHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoYXN5bmMpCitGQUlMOiAwCisKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdp dGgtc3ViZG9tYWlucy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmYw MzY1MjIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHBy ZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5o dG1sCkBAIC0wLDAgKzEsMjQgQEAKKzxwPlNwZWNpZnlpbmcgdGhhdCBhbiBJUCBhZGRyZXNzIHNo b3VsZCBtYXRjaCBzdWJkb21haW5zIGRvZXNuJ3QgbWFrZSBzZW5zZS4gVGhpcyB0ZXN0IHZlcmlm aWVzIHRoYXQgaXQgZG9lc24ndCBkbyBhbnl0aGluZy48L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48 L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlv dXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci5y ZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRl TGlzdEFjY2Vzc1RvT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiKi4wLjAuMSIsIHRy dWUsIGZhbHNlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9k ZShtZXNzYWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgiaWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJh bWUuc3JjID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZl bnRMaXN0ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJE T05FIikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHMoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgIH0gZWxzZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0Pgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQxZDY4MmUKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaXAtYWRkcmVzc2VzLmh0bWwKQEAgLTAsMCArMSwyNCBAQAorPHA+VGVzdHMgb3JpZ2luIHdo aXRlbGlzdGluZyB3aXRoIElQIGFkZHJlc3Nlcy48L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3By ZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRU ZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNl dE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc1RvT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiMTI3LjAuMC4xIiwgZmFs c2UsIGZhbHNlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9k ZShtZXNzYWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgiaWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJh bWUuc3JjID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZl bnRMaXN0ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJE T05FIikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHMoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgIH0gZWxzZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0Pgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlNjJlNGUKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3Rpbmctc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitU ZXN0cyBvcmlnaW4gd2hpdGVsaXN0aW5nIHN1YmRvbWFpbiBiZWhhdmlvci4KKworVGVzdGluZzog aHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChz eW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHBy ZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLXN1YmRvbWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVl c3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uYzRjMjJhMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5z Lmh0bWwKQEAgLTAsMCArMSw2MiBAQAorPHA+VGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyBzdWJk b21haW4gYmVoYXZpb3IuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+ CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxl ci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci5yZXNldE9yaWdpbkFjY2Vz c1doaXRlTGlzdHMoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFjY2Vzc1RvT3Jp Z2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAibG9jYWxob3N0IiwgdHJ1ZSwgZmFsc2UpOwor CitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgn Y29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2UgKyAn XG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQoreworICAgIGxv ZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBYTUxI dHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0cnkg eworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8g IlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNoIChl KSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsg ZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMpIik7Cisg ICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwg dHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4cGVj dFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOworICAg ICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigpIHsK KyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyByZXEu c3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5kKG51bGwp OworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0 cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8vIEZJWE1FOiBJcyBpdCBw b3NzaWJsZSB0byBzZXR1cCB0aGUgZm9sbG93aW5nIHRlc3RzPworICAgIC8vIFsiaHR0cDovL2Zv by5sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVd CisgICAgLy8gWyJodHRwOi8vYmFyLmZvby5sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9y ZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisgICAgLy8gWyJodHRwOi8vZm9vbG9jYWxob3N0Ojgw MDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KK107CisKK3ZhciBj dXJyZW50VGVzdCA9IDA7CisKK2Z1bmN0aW9uIG5leHRUZXN0KCkKK3sKKyAgICBpZiAoY3VycmVu dFRlc3QgPCB0ZXN0cy5sZW5ndGgpCisgICAgICAgIHRlc3QuYXBwbHkobnVsbCwgdGVzdHNbY3Vy cmVudFRlc3QrK10pOworICAgIGVsc2UgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5y ZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOworICAgIH0KK30KKworbmV4dFRlc3QoKTsKKzwvc2NyaXB0PgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1MTc1 MDg5Li42MDI3ZDMwIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3Jl L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDA5LTA4LTE4ICBBYXJvbiBCb29kbWFuICA8 YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1Mzog UHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1v cmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAg ICBUZXN0czogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFs bC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13 aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKKyAgICAgICAgICAg ICAgIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRy ZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1s aHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbAorICAgICAg ICAgICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1 YmRvbWFpbnMuaHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDogRXhwb3J0IG1ldGhv ZHMgdG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMgdG8gZW5hYmxlCisgICAg ICAgIHRlc3RpbmcgdmlhIGxheW91dCB0ZXN0cy4KKyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3Jp Z2luLmNwcDogSW1wbGVtZW50IG9yaWdpbiBhY2NlcyB3aGl0ZWxpc3RzLgorICAgICAgICAoV2Vi Q29yZTo6T3JpZ2luQWNjZXNzV2hpdGVMaXN0RW50cnk6Ok9yaWdpbkFjY2Vzc1doaXRlTGlzdEVu dHJ5KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RFbnRy eTo6bWF0Y2hlc09yaWdpbik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6b3JpZ2luQWNjZXNz TWFwKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6Y2FuUmVxdWVz dCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFj Y2Vzc1RvT3JpZ2luKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6 cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKTogRGl0dG8uCisgICAgICAgICogcGFnZS9TZWN1 cml0eU9yaWdpbi5oOiBEaXR0by4KKwogMjAwOS0wOC0xOCAgS2VudCBUYW11cmEgIDx0a2VudEBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1n aXQgYS9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAgYi9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAK aW5kZXggMmU3NzNlNi4uNmU4YTEwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmJhc2Uu ZXhwCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cApAQCAtMzEzLDYgKzMxMyw5IEBAIF9f Wk43V2ViQ29yZTE0UmVzb3VyY2VMb2FkZXIxNGNhbmNlbGxlZEVycm9yRXYKIF9fWk43V2ViQ29y ZTE0UmVzb3VyY2VMb2FkZXIxOXNldFNob3VsZEJ1ZmZlckRhdGFFYgogX19aTjdXZWJDb3JlMTRT ZWN1cml0eU9yaWdpbjI0cmVnaXN0ZXJVUkxTY2hlbWVBc0xvY2FsRVJLTlNfNlN0cmluZ0UKIF9f Wk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFCitfX1pON1dlYkNv cmUxNFNlY3VyaXR5T3JpZ2luMTZjcmVhdGVGcm9tU3RyaW5nRVJLTlNfNlN0cmluZ0UKK19fWk43 V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4yM3doaXRlTGlzdEFjY2Vzc1RvT3JpZ2luRVJLUzBfUktO U182U3RyaW5nRWJiCitfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luMjdyZXNldE9yaWdpbkFj Y2Vzc1doaXRlTGlzdHNFdgogX19aTjdXZWJDb3JlMTVBcmNoaXZlUmVzb3VyY2U2Y3JlYXRlRU4z V1RGMTBQYXNzUmVmUHRySU5TXzEyU2hhcmVkQnVmZmVyRUVFUktOU180S1VSTEVSS05TXzZTdHJp bmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBfX1pON1dlYkNvcmUxNUJhY2tGb3J3 YXJkTGlzdDEwcmVtb3ZlSXRlbUVQTlNfMTFIaXN0b3J5SXRlbUUKIF9fWk43V2ViQ29yZTE1QmFj a0ZvcndhcmRMaXN0MTBzZXRFbmFibGVkRWIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1 cml0eU9yaWdpbi5jcHAgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCmluZGV4IDgy NzRlMGUuLjU3MzMxNDggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5j cHAKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcApAQCAtMzYsNiArMzYsNTgg QEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RF bnRyeSB7CitwdWJsaWM6CisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0RW50cnkoY29uc3QgU3Ry aW5nJiBob3N0LCBib29sIGluY2x1ZGVTdWJkb21haW5zLCBib29sIHNlY3VyZSkgOiBtX2hvc3Qo aG9zdCksIG1faW5jbHVkZVN1YmRvbWFpbnMoaW5jbHVkZVN1YmRvbWFpbnMpLCBtX3NlY3VyZShz ZWN1cmUpIHsgfQorCisgICAgYm9vbCBtYXRjaGVzT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2lu JiBvcmlnaW4pCisgICAgeworICAgICAgICBpZiAobV9zZWN1cmUgJiYgb3JpZ2luLnByb3RvY29s KCkgIT0gImh0dHBzIikKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICBpZiAo IW1fc2VjdXJlICYmIG9yaWdpbi5wcm90b2NvbCgpICE9ICJodHRwIikKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKworICAgICAgICAvLyBTcGVjaWFsIGNhc2U6IEluY2x1ZGUgc3ViZG9tYWlu cyBhbmQgZW1wdHkgaG9zdCBtZWFucyAiYWxsIGhvc3RzLCBpbmNsdWRpbmcgaXAgYWRkcmVzc2Vz Ii4KKyAgICAgICAgaWYgKG1faW5jbHVkZVN1YmRvbWFpbnMgJiYgbV9ob3N0LmlzRW1wdHkoKSkK KyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAgICAgIC8vIEV4YWN0IG1hdGNoLgorICAg ICAgICBpZiAobV9ob3N0ID09IG9yaWdpbi5ob3N0KCkpCisgICAgICAgICAgICByZXR1cm4gdHJ1 ZTsKKworICAgICAgICAvLyBPdGhlcndpc2Ugd2UgY2FuIG9ubHkgbWF0Y2ggaWYgd2UncmUgbWF0 Y2hpbmcgc3ViZG9tYWlucy4KKyAgICAgICAgaWYgKCFtX2luY2x1ZGVTdWJkb21haW5zKQorICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIC8vIERvbid0IHRyeSB0byBkbyBzdWJk b21haW4gbWF0Y2hpbmcgb24gSVAgYWRkcmVzc2VzLiBBc3N1bWUgdGhhdCBhbnkgaG9zdCB0aGF0 IGVuZHMgd2l0aCBhIGRpZ2l0IGlzIHRyeWluZyB0byBiZSBhbiBJUCBhZGRyZXNzLgorICAgICAg ICBVQ2hhciBsYXN0ID0gbV9ob3N0W21faG9zdC5sZW5ndGgoKSAtIDFdOworICAgICAgICBpZiAo bGFzdCA+PSAnMCcgJiYgbGFzdCA8PSAnOScpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisK KyAgICAgICAgLy8gTWF0Y2ggc3ViZG9tYWlucy4KKyAgICAgICAgLy8gRklYTUU6IFRoaXMgaGFz bid0IGFjdHVhbGx5IGJlZW4gdGVzdGVkIGFzIEkgY2FuJ3QgZmlndXJlIG91dCBhIHdheSB0byB0 ZXN0IGl0IHdpdGggdGhlIGxheW91dCB0ZXN0IHN5c3RlbS4KKyAgICAgICAgaWYgKG9yaWdpbi5o b3N0KCkubGVuZ3RoKCkgPiBtX2hvc3QubGVuZ3RoKCkgJiYgb3JpZ2luLmhvc3QoKVtvcmlnaW4u aG9zdCgpLmxlbmd0aCgpIC0gbV9ob3N0Lmxlbmd0aCgpIC0gMV0gPT0gJy4nICYmIG9yaWdpbi5o b3N0KCkuZW5kc1dpdGgobV9ob3N0LCB0cnVlKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOwor CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1f aG9zdDsKKyAgICBib29sIG1faW5jbHVkZVN1YmRvbWFpbnM7CisgICAgYm9vbCBtX3NlY3VyZTsK K307CisKK3R5cGVkZWYgVmVjdG9yPE9yaWdpbkFjY2Vzc1doaXRlTGlzdEVudHJ5Kj4gT3JpZ2lu QWNjZXNzV2hpdGVMaXN0OwordHlwZWRlZiBIYXNoTWFwPFN0cmluZywgT3JpZ2luQWNjZXNzV2hp dGVMaXN0Kj4gT3JpZ2luQWNjZXNzTWFwOworCitzdGF0aWMgT3JpZ2luQWNjZXNzTWFwJiBvcmln aW5BY2Nlc3NNYXAoKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoT3JpZ2luQWNjZXNzTWFw LCBvcmlnaW5BY2Nlc3NNYXAsICgpKTsKKyAgICByZXR1cm4gb3JpZ2luQWNjZXNzTWFwOworfQor CiBzdGF0aWMgVVJMU2NoZW1lc01hcCYgbG9jYWxTY2hlbWVzKCkKIHsKICAgICBERUZJTkVfU1RB VElDX0xPQ0FMKFVSTFNjaGVtZXNNYXAsIGxvY2FsU2NoZW1lcywgKCkpOwpAQCAtMTk4LDcgKzI1 MCwxNiBAQCBib29sIFNlY3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCkg Y29uc3QKIAogICAgIC8vIFdlIGNhbGwgaXNTYW1lU2NoZW1lSG9zdFBvcnQgaGVyZSBpbnN0ZWFk IG9mIGNhbkFjY2VzcyBiZWNhdXNlIHdlIHdhbnQKICAgICAvLyB0byBpZ25vcmUgZG9jdW1lbnQu ZG9tYWluIGVmZmVjdHMuCi0gICAgcmV0dXJuIGlzU2FtZVNjaGVtZUhvc3RQb3J0KHRhcmdldE9y aWdpbi5nZXQoKSk7CisgICAgaWYgKGlzU2FtZVNjaGVtZUhvc3RQb3J0KHRhcmdldE9yaWdpbi5n ZXQoKSkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0 KiBsaXN0ID0gb3JpZ2luQWNjZXNzTWFwKCkuZ2V0KHRvU3RyaW5nKCkpOworICAgIGlmIChsaXN0 KQorICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGxpc3QtPnNpemUoKTsgKytpKQorICAg ICAgICAgICAgaWYgKGxpc3QtPmF0KGkpLT5tYXRjaGVzT3JpZ2luKCp0YXJnZXRPcmlnaW4pKQor ICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZhbHNlOwogfQogCiB2 b2lkIFNlY3VyaXR5T3JpZ2luOjpncmFudExvYWRMb2NhbFJlc291cmNlcygpCkBAIC00MTQsNCAr NDc1LDMzIEBAIGJvb2wgU2VjdXJpdHlPcmlnaW46OnNob3VsZFRyZWF0VVJMU2NoZW1lQXNOb0Fj Y2Vzcyhjb25zdCBTdHJpbmcmIHNjaGVtZSkKICAgICByZXR1cm4gbm9BY2Nlc3NTY2hlbWVzKCku Y29udGFpbnMoc2NoZW1lKTsKIH0KIAorLy8gc3RhdGljCit2b2lkIFNlY3VyaXR5T3JpZ2luOjp3 aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihjb25zdCBTZWN1cml0eU9yaWdpbiYgc291cmNlLCBjb25z dCBTdHJpbmcmIGRvbWFpbiwgYm9vbCBpbmNsdWRlU3ViZG9tYWlucywgYm9vbCBzZWN1cmUpCit7 CisgICAgLy8gRklYTUU6IFdlIGxlYWsgdGhlc2Ugb2JqZWN0cyBhdCBwcm9jZXNzIHNodXRkb3du LiBJcyB0aGF0IE9LPworICAgIE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9yaWdpbkFj Y2Vzc01hcCgpLmdldChzb3VyY2UudG9TdHJpbmcoKSk7CisgICAgaWYgKCFsaXN0KQorICAgIHsK KyAgICAgICAgbGlzdCA9IG5ldyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3QoKTsKKyAgICAgICAgb3Jp Z2luQWNjZXNzTWFwKCkuc2V0KHNvdXJjZS50b1N0cmluZygpLCBsaXN0KTsKKyAgICB9CisgICAg bGlzdC0+YXBwZW5kKG5ldyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RFbnRyeShkb21haW4sIGluY2x1 ZGVTdWJkb21haW5zLCBzZWN1cmUpKTsKK30KKworLy8gc3RhdGljCit2b2lkIFNlY3VyaXR5T3Jp Z2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKQoreworICAgIE9yaWdpbkFjY2Vzc01h cCYgbWFwID0gb3JpZ2luQWNjZXNzTWFwKCk7CisgICAgZm9yIChPcmlnaW5BY2Nlc3NNYXA6Oml0 ZXJhdG9yIGl0ZXIgPSBtYXAuYmVnaW4oKTsgaXRlciAhPSBtYXAuZW5kKCk7ICsraXRlcikKKyAg ICB7CisgICAgICAgIE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IGl0ZXItPnNlY29uZDsK KyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBsaXN0LT5zaXplKCk7ICsraSkKKyAgICAg ICAgICAgIGRlbGV0ZSBsaXN0LT5hdChpKTsKKworICAgICAgICBkZWxldGUgbGlzdDsKKyAgICB9 CisKKyAgICBtYXAuY2xlYXIoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uaAppbmRleCAzMzVlZDI4Li43YzcwMjIxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvU2VjdXJpdHlPcmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApA QCAtMTQxLDYgKzE0MSw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RhdGljIHZv aWQgcmVnaXN0ZXJVUkxTY2hlbWVBc05vQWNjZXNzKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBz dGF0aWMgYm9vbCBzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29uc3QgU3RyaW5nJik7 CiAKKyAgICAgICAgc3RhdGljIHZvaWQgd2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4oY29uc3QgU2Vj dXJpdHlPcmlnaW4mIHNvdXJjZSwgY29uc3QgU3RyaW5nJiBkb21haW4sIGJvb2wgaW5jbHVkZVN1 YmRvbWFpbnMsIGJvb2wgc2VjdXJlKTsKKyAgICAgICAgc3RhdGljIHZvaWQgcmVzZXRPcmlnaW5B Y2Nlc3NXaGl0ZUxpc3RzKCk7CisKICAgICBwcml2YXRlOgogICAgICAgICBleHBsaWNpdCBTZWN1 cml0eU9yaWdpbihjb25zdCBLVVJMJik7CiAgICAgICAgIGV4cGxpY2l0IFNlY3VyaXR5T3JpZ2lu KGNvbnN0IFNlY3VyaXR5T3JpZ2luKik7CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxv ZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IGU0YzFhYjEuLmNhNWNlMjYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMDktMDgtMTggIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZv ciBXZWJLaXQgY2xpZW50cyB0bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xp Y3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIgYWNjZXNzLgorCisgICAgICAgICogV2ViVmlldy9XZWJW aWV3Lm1tOgorICAgICAgICAoK1tXZWJWaWV3IF93aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbjpob3N0 OmluY2x1ZGVTdWJkb21haW5zOnNlY3VyZTpdKTogU1BJIHRvIGFsbG93CisgICAgICAgIHRlc3Rp bmcgb3JpZ2luIGFjY2VzcyB3aGl0ZWxpc3RzIHZpYSBsYXlvdXQgdGVzdHMuCisgICAgICAgICgr W1dlYlZpZXcgX3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0c10pOiBEaXR0by4KKyAgICAgICAg KiBXZWJWaWV3L1dlYlZpZXdQcml2YXRlLmg6IERpdHRvLgorCiAyMDA5LTA4LTE3ICBEYXJpbiBB ZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2Vpbmln LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0gYi9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViVmlldy5tbQppbmRleCAzYTNjYjU5Li43MDlmNzdjIDEwMDY0NAotLS0gYS9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2Vi Vmlldy5tbQpAQCAtMjA5Miw2ICsyMDkyLDE1IEBAIHN0YXRpYyBpbmxpbmUgSU1QIGdldE1ldGhv ZChpZCBvLCBTRUwgcykKICAgICByZXR1cm4gX3ByaXZhdGUgPyBfcHJpdmF0ZS0+aW5zZXJ0aW9u UGFzdGVib2FyZCA6IG5pbDsKIH0KIAorKyAodm9pZClfd2hpdGVMaXN0QWNjZXNzVG9PcmlnaW46 KE5TU3RyaW5nKilzb3VyY2VPcmlnaW4gaG9zdDooTlNTdHJpbmcqKWhvc3QgaW5jbHVkZVN1YmRv bWFpbnM6KEJPT0wpaW5jbHVkZVN1YmRvbWFpbnMgc2VjdXJlOihCT09MKXNlY3VyZQoreworICAg IFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbigqU2VjdXJpdHlPcmlnaW46 OmNyZWF0ZUZyb21TdHJpbmcoc291cmNlT3JpZ2luKSwgaG9zdCwgaW5jbHVkZVN1YmRvbWFpbnMs IHNlY3VyZSk7Cit9CisKKysgKHZvaWQpX3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cworewor ICAgIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK30KIAog LSAodm9pZClfdXBkYXRlQWN0aXZlU3RhdGUKIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3UHJpdmF0ZS5oIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRl LmgKaW5kZXggMzYyYjJlNi4uM2U4NWU1MCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlZpZXdQcml2YXRlLmgKKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRl LmgKQEAgLTQ0Myw2ICs0NDMsMTUgQEAgQ291bGQgYmUgd29ydGggYWRkaW5nIHRvIHRoZSBBUEku CiAvLyBXaGljaCBwYXN0ZWJvYXJkIHRleHQgaXMgY29taW5nIGZyb20gaW4gZWRpdGluZyBkZWxl Z2F0ZSBtZXRob2RzIHN1Y2ggYXMgc2hvdWxkSW5zZXJ0Tm9kZS4KIC0gKE5TUGFzdGVib2FyZCAq KV9pbnNlcnRpb25QYXN0ZWJvYXJkOwogCisvLyBXaGl0ZWxpc3RzIGFjY2VzcyBmcm9tIGFuIG9y aWdpbiAoc291cmNlT3JpZ2luKSB0byBhIHNldCBvZiBvbmUgb3IgbW9yZSBvcmlnaW5zIGRlc2Ny aWJlZCBieSB0aGUgcGFyYW1ldGVyczoKKy8vIC0gaG9zdDogVGhlIGhvc3QgdG8gZ3JhbnQgYWNj ZXNzIHRvLgorLy8gLSBpbmNsdWRlU3ViZG9tYWluczogSWYgaG9zdCBpcyBhIGRvbWFpbiwgc2V0 dGluZyB0aGlzIHRvIFlFUyB3aWxsIHdoaXRlbGlzdCBob3N0IGFuZCBhbGwgaXRzIHN1YmRvbWFp bnMsIHJlY3Vyc2l2ZWx5LgorLy8gLSBzZWN1cmU6IFdoZXRoZXIgdG8gZ3JhbnQgYWNjZXNzIHRv IGh0dHBzIG9yIGh0dHAgb3JpZ2lucy4gSWYgeWVzLCBvbmx5IGh0dHBzIG9yaWdpbnMgd2lsbCBi ZSB3aGl0ZWxpc3RlZC4gSWYgbm8sIG9ubHkgaHR0cCBvcmlnaW5zIHdpbGwgYmUuCisrICh2b2lk KV93aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbjooTlNTdHJpbmcqKXNvdXJjZU9yaWdpbiBob3N0OihO U1N0cmluZyopaG9zdCBpbmNsdWRlU3ViZG9tYWluczooQk9PTClpbmNsdWRlU3ViZG9tYWlucyBz ZWN1cmU6KEJPT0wpc2VjdXJlOworCisvLyBDbGVhcnMgYWxsIHdoaXRlbGlzdHMgY3JlYXRlZCBi eSBfd2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4uCisrICh2b2lkKV9yZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHM7CisKIEBlbmQKIAogQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpbnRpbmdQ cml2YXRlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMv Q2hhbmdlTG9nCmluZGV4IGQ3ZjFlODMuLjNiOTQ1YjQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAor MjAwOS0wOC0xOCAgQWFyb24gQm9vZG1hbiAgPGFhQGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ4NTM6IFByb3ZpZGUgYSB3YXkgZm9yIFdlYktpdCBjbGll bnRzIHRvCisgICAgICAgIHNwZWNpZnkgYSBtb3JlIGdyYW51bGFyIHBvbGljeSBmb3IgY3Jvc3Mt b3JpZ2luIFhIUiBhY2Nlc3MuCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5jcHA6IEFkZCBwbHVtYmluZyB0byBiZSBhYmxlIHRvIG1hbmlwdWxhdGUKKyAg ICAgICAgb3JpZ2luIGFjY2VzcyB3aGl0ZWxpc3RzIGZyb20gbGF5b3V0IHRlc3RzLgorICAgICAg ICAod2hpdGVMaXN0QWNjZXNzVG9PcmlnaW5DYWxsYmFjayk6IERpdHRvLgorICAgICAgICAocmVz ZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzQ2FsbGJhY2spOiBEaXR0by4KKyAgICAgICAgKExheW91 dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOiBEaXR0by4KKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOiBEaXR0by4KKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06IERpdHRvLgorICAgICAg ICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc1RvT3JpZ2luKTogRGl0dG8u CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxp c3RzKTogRGl0dG8uCisKIDIwMDktMDgtMTcgIFNoaW5pY2hpcm8gSGFtYWppICA8aGFtYWppQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRl eCBmODY0MGZhLi44Nzg4ZTBhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC04NzQsNiArODc0LDMwIEBAIHN0YXRpYyBK U1ZhbHVlUmVmIHdhaXRGb3JQb2xpY3lEZWxlZ2F0ZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250 ZXh0LCBKU09iamVjdFJlCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQp OwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiB3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbkNhbGxiYWNr KEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVj dCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpT VmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRDb3VudCAhPSA0KQorICAg ICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBKU1JldGFp blB0cjxKU1N0cmluZ1JlZj4gc291cmNlT3JpZ2luKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5 KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0 aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gaG9zdChBZG9wdCwgSlNWYWx1ZVRv U3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VS VCghKmV4Y2VwdGlvbik7CisgICAgYm9vbCBpbmNsdWRlU3ViZG9tYWlucyA9IEpTVmFsdWVUb0Jv b2xlYW4oY29udGV4dCwgYXJndW1lbnRzWzJdKTsKKyAgICBib29sIHNlY3VyZSA9IEpTVmFsdWVU b0Jvb2xlYW4oY29udGV4dCwgYXJndW1lbnRzWzNdKTsKKworICAgIExheW91dFRlc3RDb250cm9s bGVyKiBjb250cm9sbGVyID0gc3RhdGljX2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09i amVjdEdldFByaXZhdGUodGhpc09iamVjdCkpOworICAgIGNvbnRyb2xsZXItPndoaXRlTGlzdEFj Y2Vzc1RvT3JpZ2luKHNvdXJjZU9yaWdpbi5nZXQoKSwgaG9zdC5nZXQoKSwgaW5jbHVkZVN1YmRv bWFpbnMsIHNlY3VyZSk7CisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQp OworfQorCitzdGF0aWMgSlNWYWx1ZVJlZiByZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNDYWxs YmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYsIEpTT2JqZWN0UmVmIHRoaXNP YmplY3QsIHNpemVfdCwgY29uc3QgSlNWYWx1ZVJlZltdLCBKU1ZhbHVlUmVmKikKK3sKKyAgICBM YXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RD b250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9s bGVyLT5yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKKyAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIC8vIFN0YXRpYyBWYWx1ZXMKIAogc3RhdGljIEpT VmFsdWVSZWYgZ2V0R2xvYmFsRmxhZ0NhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09i amVjdFJlZiB0aGlzT2JqZWN0LCBKU1N0cmluZ1JlZiBwcm9wZXJ0eU5hbWUsIEpTVmFsdWVSZWYq IGV4Y2VwdGlvbikKQEAgLTk4NCw2ICsxMDA4LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0 VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgInF1ZXVlTm9uTG9h ZGluZ1NjcmlwdCIsIHF1ZXVlTm9uTG9hZGluZ1NjcmlwdENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgInF1ZXVlUmVsb2FkIiwgcXVldWVSZWxvYWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAg ICB7ICJyZXBhaW50U3dlZXBIb3Jpem9udGFsbHkiLCByZXBhaW50U3dlZXBIb3Jpem9udGFsbHlD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMi LCByZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJzZXRBY2NlcHRzRWRpdGluZyIsIHNldEFjY2VwdHNFZGl0aW5nQ2FsbGJhY2ssIGtKU1Byb3Bl cnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwK ICAgICAgICAgeyAic2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQiLCBzZXRBdXRob3JBbmRV c2VyU3R5bGVzRW5hYmxlZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldEFwcENhY2hl TWF4aW11bVNpemUiLCBzZXRBcHBDYWNoZU1heGltdW1TaXplQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwgCkBA IC0xMDE0LDYgKzEwMzksNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxl cjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAid2FpdEZvclBvbGljeURlbGVnYXRlIiwg d2FpdEZvclBvbGljeURlbGVnYXRlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAid2FpdFVu dGlsRG9uZSIsIHdhaXRVbnRpbERvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJ3aW5k b3dDb3VudCIsIHdpbmRvd0NvdW50Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAid2hpdGVM aXN0QWNjZXNzVG9PcmlnaW4iLCB3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbkNhbGxiYWNrLCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRl IH0sCiAgICAgICAgIHsgMCwgMCwgMCB9CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggOGFlYmVkNC4uNzhmM2Vj MSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCkBAIC0xNzgsNyArMTc4LDEwIEBAIHB1YmxpYzoKICAgICBib29sIHBhdXNlQW5pbWF0 aW9uQXRUaW1lT25FbGVtZW50V2l0aElkKEpTU3RyaW5nUmVmIGFuaW1hdGlvbk5hbWUsIGRvdWJs ZSB0aW1lLCBKU1N0cmluZ1JlZiBlbGVtZW50SWQpOwogICAgIGJvb2wgcGF1c2VUcmFuc2l0aW9u QXRUaW1lT25FbGVtZW50V2l0aElkKEpTU3RyaW5nUmVmIHByb3BlcnR5TmFtZSwgZG91YmxlIHRp bWUsIEpTU3RyaW5nUmVmIGVsZW1lbnRJZCk7CiAgICAgdW5zaWduZWQgbnVtYmVyT2ZBY3RpdmVB bmltYXRpb25zKCkgY29uc3Q7Ci0gICAgCisKKyAgICB2b2lkIHdoaXRlTGlzdEFjY2Vzc1RvT3Jp Z2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdSZWYgaG9zdCwgYm9vbCBpbmNs dWRlU3ViZG9tYWlucywgYm9vbCBzZWN1cmUpOworICAgIHZvaWQgcmVzZXRPcmlnaW5BY2Nlc3NX aGl0ZUxpc3RzKCk7CisKIHByaXZhdGU6CiAgICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9v bCBtX2R1bXBBc1BERjsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQppbmRleCBhMDkzZGZkLi4xOGZjM2Y0IDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRy b2xsZXJNYWMubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRl c3RDb250cm9sbGVyTWFjLm1tCkBAIC00MzcsMyArNDM3LDE3IEBAIHZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OndhaXRGb3JQb2xpY3lEZWxlZ2F0ZSgpCiAgICAgW3BvbGljeURlbGVnYXRlIHNl dENvbnRyb2xsZXJUb05vdGlmeURvbmU6dGhpc107CiAgICAgW1ttYWluRnJhbWUgd2ViVmlld10g c2V0UG9saWN5RGVsZWdhdGU6cG9saWN5RGVsZWdhdGVdOwogfQorCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihKU1N0cmluZ1JlZiBzb3VyY2VPcmln aW4sIEpTU3RyaW5nUmVmIGhvc3QsIGJvb2wgaW5jbHVkZVN1YmRvbWFpbnMsIGJvb2wgc2VjdXJl KQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gc291cmNlT3JpZ2luQ0YoQWRvcHRDRiwg SlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgc291cmNlT3JpZ2luKSk7 CisgICAgTlNTdHJpbmcgKnNvdXJjZU9yaWdpbk5TID0gKE5TU3RyaW5nICopc291cmNlT3JpZ2lu Q0YuZ2V0KCk7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBob3N0Q0YoQWRvcHRDRiwgSlNT dHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgaG9zdCkpOworICAgIE5TU3Ry aW5nICpob3N0TlMgPSAoTlNTdHJpbmcgKilob3N0Q0YuZ2V0KCk7CisgICAgW1dlYlZpZXcgX3do aXRlTGlzdEFjY2Vzc1RvT3JpZ2luOnNvdXJjZU9yaWdpbk5TIGhvc3Q6aG9zdE5TIGluY2x1ZGVT dWJkb21haW5zOmluY2x1ZGVTdWJkb21haW5zIHNlY3VyZTpzZWN1cmVdOworfQorCit2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKQoreworICAg IFtXZWJWaWV3IF9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNdOworfQo= 35151 2009-08-19 15:33:10 -0700 2009-08-19 17:21:51 -0700 New patch patch.txt text/plain 50416 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjYTQyYjU3Li41Njg1ZjMyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTggIFNoaW5pY2hpcm8gSGFtYWpp ICA8aGFtYWppQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRl bC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTJiYTQyZgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1hbGwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTEgQEAKK1Rlc3RzIHRoZSBzcGVjaWFs IGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLgorCitUZXN0aW5nOiBodHRwOi8vbG9j YWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNT OiBQQVNTCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4w LjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzog UEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291 cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLWFsbC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUwNzg1ZTEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctYWxsLmh0bWwKQEAgLTAsMCArMSw1NiBAQAorPHA+VGVzdHMg dGhlIHNwZWNpYWwgY2FzZSBvZiB3aGl0ZWxpc3RpbmcgYWxsIG9yaWdpbnMuPC9wPgorCis8cHJl IGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRU ZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCJodHRwOi8vMTI3LjAuMC4x OjgwMDAiLCAiaHR0cCIsICIiLCB0cnVlKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIiIsIHRy dWUpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3REb21haW4oKQoreworICAgIHZhciB1cmwg PSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IjsKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEg PSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7 CisgICAgdHJ5IHsKKyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygiUEFTUzog IiArIHJlcS5yZXNwb25zZVRleHQpOworICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAgICAgbG9nKCJG QUlMOiAiICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5 bmMpIik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdF VCIsIHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBs b2coIlBBU1M6ICIgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAgICAgdGVzdElQQWRkcmVzcygp OworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKCJG QUlMOiAiICsgcmVxLnN0YXR1cyk7CisgICAgICAgIHRlc3RJUEFkZHJlc3MoKTsKKyAgICB9Owor ICAgIHJlcS5zZW5kKG51bGwpOworfQorCitmdW5jdGlvbiB0ZXN0SVBBZGRyZXNzKCkKK3sKKyAg ICB2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiaWZyYW1lIik7CisgICAgZG9j dW1lbnQuYm9keS5hcHBlbmRDaGlsZChpZnJhbWUpOworICAgIGlmcmFtZS5zcmMgPSAiaHR0cDov L2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9vcmlnaW4td2hpdGVsaXN0 aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKKyAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcigi bWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICAgICAgaWYgKGUuZGF0YSA9PSAiRE9ORSIpCisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIGVs c2UKKyAgICAgICAgICAgIGxvZyhlLmRhdGEpOworICAgIH0sIGZhbHNlKTsKK30KKwordGVzdERv bWFpbigpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2gtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi4zMmU1YTQ0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDcgQEAKK1Rlc3RzIHRoZSBiZWhhdmlvciBvZiB3aGl0ZWxpc3Rpbmcg b3JpZ2lucyB1c2luZyBleGFjdCBtYXRjaGluZy4KKworVGVzdGluZzogaHR0cDovL2xvY2FsaG9z dDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFT UworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNl cy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNo Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi5mZWNkOGQxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwKQEAgLTAs MCArMSw1OSBAQAorPHA+VGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5z IHVzaW5nIGV4YWN0IG1hdGNoaW5nLjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8 c2NyaXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENv bnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0 QWNjZXNzRnJvbU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHAiLCAibG9jYWxo b3N0IiwgZmFsc2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHRO b2RlKG1lc3NhZ2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNj ZXNzKQoreworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFy IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZh bHNlKTsKKyAgICB0cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChl eHBlY3RTdWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsK KyAgICB9IGNhdGNoIChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAi IDogIlBBU1M6ICIpICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsg IiAoYXN5bmMpIik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9w ZW4oIkdFVCIsIHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAg ICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNw b25zZVRleHQpOworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3Ig PSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAi UEFTUzogIikgKyByZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAg IHJlcS5zZW5kKG51bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxo b3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8v IEZJWE1FOiBJcyBpdCBwb3NzaWJsZSB0byBzZXR1cCB0aGUgZm9sbG93aW5nIHRlc3RzPworICAg IC8vIFsiaHR0cDovL2xvY2FsaG9zdDo4MDAxL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQu dHh0IiwgZmFsc2VdLAorICAgIC8vIFsiaHR0cDovL2Zvby5sb2NhbGhvc3Q6ODAwMC94bWxodHRw cmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNlXSwKKyAgICAvLyBbImh0dHBzOi8vbG9j YWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KK107 CisKK3ZhciBjdXJyZW50VGVzdCA9IDA7CisKK2Z1bmN0aW9uIG5leHRUZXN0KCkKK3sKKyAgICBp ZiAoY3VycmVudFRlc3QgPCB0ZXN0cy5sZW5ndGgpCisgICAgICAgIHRlc3QuYXBwbHkobnVsbCwg dGVzdHNbY3VycmVudFRlc3QrK10pOworICAgIGVsc2UKKyAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIubm90aWZ5RG9uZSgpOworfQorCituZXh0VGVzdCgpOworPC9zY3JpcHQ+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRw cmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMzNjNGE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0 dHBzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK1Rlc3RzIHRoYXQgb3JpZ2luIHdoaXRl bGlzdGluZyBmb3IgaHR0cHMgZG9lcyBub3QgbWF0Y2ggaHR0cCBVUkxzLgorCitUZXN0aW5nOiBo dHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5 bmMpCitQQVNTOiBFcnJvcjogTkVUV09SS19FUlI6IFhNTEh0dHBSZXF1ZXN0IEV4Y2VwdGlvbiAx MDEKK1Rlc3Rpbmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJj ZXMvZ2V0LnR4dCAoYXN5bmMpCitQQVNTOiAwCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LWh0dHBzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTBlNjA2ZQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv b3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sCkBAIC0wLDAgKzEsNTcgQEAKKzxwPlRlc3Rz IHRoYXQgb3JpZ2luIHdoaXRlbGlzdGluZyBmb3IgaHR0cHMgZG9lcyBub3QgbWF0Y2ggaHR0cCBV UkxzLjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVz dENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigi aHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHBzIiwgImxvY2FsaG9zdCIsIGZhbHNlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0KHVybCwgZXhwZWN0U3VjY2VzcykKK3sKKyAgICBsb2co IlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEgPSBuZXcgWE1MSHR0 cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7CisgICAgdHJ5IHsK KyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQ QVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgfSBjYXRjaCAoZSkg eworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNTOiAiKSArIGUp OworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOworICAg IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIHRy dWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKChleHBlY3RT dWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAg ICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7Cisg ICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsgcmVxLnN0 YXR1cyk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEuc2VuZChudWxsKTsK K30KKwordmFyIHRlc3RzID0gWworICAgIFsiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHBy ZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdCisgICAgLy8gRklYTUU6IElzIGl0IHBv c3NpYmxlIHRvIHNldHVwIHRoZSBmb2xsb3dpbmcgdGVzdHM/CisgICAgLy8gWyJodHRwczovL2xv Y2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KK107 CisKK3ZhciBjdXJyZW50VGVzdCA9IDA7CisKK2Z1bmN0aW9uIG5leHRUZXN0KCkKK3sKKyAgICBp ZiAoY3VycmVudFRlc3QgPCB0ZXN0cy5sZW5ndGgpCisgICAgICAgIHRlc3QuYXBwbHkobnVsbCwg dGVzdHNbY3VycmVudFRlc3QrK10pOworICAgIGVsc2UKKyAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIubm90aWZ5RG9uZSgpOworfQorCituZXh0VGVzdCgpOworPC9zY3JpcHQ+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaXAtYWRkcmVzc2VzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjAwOTk0NzQKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13 aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK1Rl c3RzIG9yaWdpbiB3aGl0ZWxpc3Rpbmcgd2l0aCBJUCBhZGRyZXNzZXMuCisKK1Rlc3Rpbmc6IGh0 dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3lu YykKK1BBU1M6IFBBU1MKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVx dWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGlu Zy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMtd2l0aC1zdWJkb21haW5zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5jZGU2ODMyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRo LXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorU3BlY2lmeWluZyB0aGF0 IGFuIElQIGFkZHJlc3Mgc2hvdWxkIG1hdGNoIHN1YmRvbWFpbnMgZG9lc24ndCBtYWtlIHNlbnNl LiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBpdCBkb2Vzbid0IGRvIGFueXRoaW5nLgorCitUZXN0 aW5nOiBodHRwOi8vMTI3LjAuMC4xOjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50 eHQgKHN5bmMpCitGQUlMOiBFcnJvcjogTkVUV09SS19FUlI6IFhNTEh0dHBSZXF1ZXN0IEV4Y2Vw dGlvbiAxMDEKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9y ZXNvdXJjZXMvZ2V0LnR4dCAoYXN5bmMpCitGQUlMOiAwCisKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRy ZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0 dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlu cy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg1MGQxNjIKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sCkBAIC0wLDAg KzEsMjIgQEAKKzxwPlNwZWNpZnlpbmcgdGhhdCBhbiBJUCBhZGRyZXNzIHNob3VsZCBtYXRjaCBz dWJkb21haW5zIGRvZXNuJ3QgbWFrZSBzZW5zZS4gVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgaXQg ZG9lc24ndCBkbyBhbnl0aGluZy48L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3Jp cHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJv bGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nl c3NGcm9tT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiaHR0cCIsICIqLjAuMC4xIiwg dHJ1ZSk7CisKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobWVz c2FnZSArICdcbicpKTsKK30KKwordmFyIGlmcmFtZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQo ImlmcmFtZSIpOworZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChpZnJhbWUpOworaWZyYW1lLnNy YyA9ICJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzcy10ZXN0Lmh0bWwiOword2luZG93LmFkZEV2ZW50TGlz dGVuZXIoIm1lc3NhZ2UiLCBmdW5jdGlvbihlKSB7CisgICAgaWYgKGUuZGF0YSA9PSAiRE9ORSIp CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICBlbHNlCisg ICAgICAgIGxvZyhlLmRhdGEpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uYTNhM2FmNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMuaHRtbApAQCAtMCwwICsxLDIyIEBACis8cD5UZXN0cyBvcmlnaW4gd2hpdGVsaXN0aW5nIHdp dGggSVAgYWRkcmVzc2VzLjwvcD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdD4K K2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RDb250cm9sbGVy LndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIjEyNy4wLjAuMSIsIGZh bHNlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNz YWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgi aWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJhbWUuc3Jj ID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvb3JpZ2lu LXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZlbnRMaXN0 ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJET05FIikK KyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIGVsc2UKKyAg ICAgICAgbG9nKGUuZGF0YSk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1z dWJkb21haW5zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZTYyZTRlCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgb3JpZ2luIHdo aXRlbGlzdGluZyBzdWJkb21haW4gYmVoYXZpb3IuCisKK1Rlc3Rpbmc6IGh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3luYykKK1BBU1M6IFBB U1MKK1Rlc3Rpbmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJj ZXMvZ2V0LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5z Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3Rpbmctc3ViZG9tYWlucy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjYxNjEwZTQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmctc3ViZG9tYWlucy5odG1sCkBAIC0wLDAg KzEsNTkgQEAKKzxwPlRlc3RzIG9yaWdpbiB3aGl0ZWxpc3Rpbmcgc3ViZG9tYWluIGJlaGF2aW9y LjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVzdENv bnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9u ZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigiaHR0 cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHAiLCAibG9jYWxob3N0IiwgdHJ1ZSk7CisKK2Z1bmN0 aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xl JykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobWVzc2FnZSArICdcbicpKTsK K30KKworZnVuY3Rpb24gdGVzdCh1cmwsIGV4cGVjdFN1Y2Nlc3MpCit7CisgICAgbG9nKCJUZXN0 aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIgcmVxID0gbmV3IFhNTEh0dHBSZXF1 ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFsc2UpOworICAgIHRyeSB7CisgICAg ICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzog IiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOworICAgIH0gY2F0Y2ggKGUpIHsKKyAg ICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyBlKTsKKyAg ICB9CisKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChhc3luYykiKTsKKyAgICByZXEg PSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCB0cnVlKTsK KyAgICByZXEub25sb2FkID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2Vz cyA/ICJQQVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgICAgIG5l eHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEub25lcnJvciA9IGZ1bmN0aW9uKCkgeworICAgICAg ICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNTOiAiKSArIHJlcS5zdGF0dXMp OworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLnNlbmQobnVsbCk7Cit9CisK K3ZhciB0ZXN0cyA9IFsKKyAgICBbImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVz dC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisgICAgLy8gRklYTUU6IElzIGl0IHBvc3NpYmxl IHRvIHNldHVwIHRoZSBmb2xsb3dpbmcgdGVzdHM/CisgICAgLy8gWyJodHRwOi8vZm9vLmxvY2Fs aG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAv LyBbImh0dHA6Ly9iYXIuZm9vLmxvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNl cy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAvLyBbImh0dHA6Ly9mb29sb2NhbGhvc3Q6ODAwMC94bWxo dHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNlXQorXTsKKwordmFyIGN1cnJlbnRU ZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQoreworICAgIGlmIChjdXJyZW50VGVzdCA8 IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShudWxsLCB0ZXN0c1tjdXJyZW50VGVz dCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25l KCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L3BsYXRmb3JtL3dpbi9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQK aW5kZXggN2ExNjJmMy4uNTI4NjlmMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v d2luL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQKQEAgLTY0 MCwzICs2NDAsMTEgQEAgbWVkaWEvdmlkZW8tcGxheWVkLWNvbGxhcHNlLmh0bWwKICMgVGhlc2Ug dHdvIGNyYXNoIGZyb20gdGhlIHNhbWUgcmVncmVzc2lvbi4KIG1lZGlhL3Vuc3VwcG9ydGVkLXJ0 c3AuaHRtbAogbWVkaWEvdmlkZW8tc291cmNlLWVycm9yLmh0bWwKKworIyBNaXNzaW5nIExheW91 dFRlc3RDb250cm9sbGVyIGltcGxlbWVudGF0aW9uCitodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctYWxsLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv b3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC5odG1sCitodHRwL3Rlc3RzL3htbGh0dHBy ZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMuaHRtbAoraHR0cC90ZXN0cy94bWxodHRw cmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy5odG1sCitodHRwL3Rlc3Rz L3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3Vi ZG9tYWlucy5odG1sCitodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctc3ViZG9tYWlucy5odG1sCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNv cmUvQ2hhbmdlTG9nCmluZGV4IDUxNzUwODkuLjEzNDczZDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv Q2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMDkt MDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0 bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdp biBYSFIgYWNjZXNzLgorCisgICAgICAgIFRlc3RzOiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctYWxsLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aHR0cHMuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmln aW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMuaHRtbAorICAgICAg ICAgICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlw LWFkZHJlc3Nlcy5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3Rpbmctc3ViZG9tYWlucy5odG1sCisKKyAgICAgICAgKiBXZWJDb3Jl LmJhc2UuZXhwOiBFeHBvcnQgbWV0aG9kcyB0byBtYW5pcHVsYXRlIG9yaWdpbiBhY2Nlc3Mgd2hp dGVsaXN0cyB0byBlbmFibGUKKyAgICAgICAgdGVzdGluZyB2aWEgbGF5b3V0IHRlc3RzLgorICAg ICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajogQWRkIE9yaWdpbkFjY2Vz c0VudHJ5LioKKyAgICAgICAgKFdlYkNvcmU6Om9yaWdpbkFjY2Vzc01hcCk6IEltcGxlbWVudCBv cmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMuCisgICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdp bjo6Y2FuUmVxdWVzdCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46 OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNl Y3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMpOiBEaXR0by4KKyAgICAg ICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6IERpdHRvLgorICAgICAgICAqIHBhZ2UvT3JpZ2lu QWNjZXNzRW50cnkuaDogRGl0dG8uCisgICAgICAgICogcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5j cHA6IERpdHRvLgorCiAyMDA5LTA4LTE4ICBLZW50IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9y Zz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL1dlYkNv cmUvV2ViQ29yZS5iYXNlLmV4cCBiL1dlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAppbmRleCAyZTc3 M2U2Li43YjMzNmNkIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKKysrIGIv V2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCkBAIC0zMTMsNiArMzEzLDkgQEAgX19aTjdXZWJDb3Jl MTRSZXNvdXJjZUxvYWRlcjE0Y2FuY2VsbGVkRXJyb3JFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJj ZUxvYWRlcjE5c2V0U2hvdWxkQnVmZmVyRGF0YUViCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3Jp Z2luMjRyZWdpc3RlclVSTFNjaGVtZUFzTG9jYWxFUktOU182U3RyaW5nRQogX19aTjdXZWJDb3Jl MTRTZWN1cml0eU9yaWdpbjZjcmVhdGVFUktOU180S1VSTEUKK19fWk43V2ViQ29yZTE0U2VjdXJp dHlPcmlnaW4xNmNyZWF0ZUZyb21TdHJpbmdFUktOU182U3RyaW5nRQorX19aTjdXZWJDb3JlMTRT ZWN1cml0eU9yaWdpbjI3cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzRXYKK19fWk43V2ViQ29y ZTE0U2VjdXJpdHlPcmlnaW4yNXdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW5FUktTMF9SS05TXzZT dHJpbmdFUzVfYgogX19aTjdXZWJDb3JlMTVBcmNoaXZlUmVzb3VyY2U2Y3JlYXRlRU4zV1RGMTBQ YXNzUmVmUHRySU5TXzEyU2hhcmVkQnVmZmVyRUVFUktOU180S1VSTEVSS05TXzZTdHJpbmdFU0Ff U0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBfX1pON1dlYkNvcmUxNUJhY2tGb3J3YXJkTGlz dDEwcmVtb3ZlSXRlbUVQTlNfMTFIaXN0b3J5SXRlbUUKIF9fWk43V2ViQ29yZTE1QmFja0Zvcndh cmRMaXN0MTBzZXRFbmFibGVkRWIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKaW5kZXggOTE3YmVlOS4uY2ZlMzdhZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oKQEAgLTIxLDYgKzIxLDggQEAKIC8qIEVuZCBQQlhBZ2dyZWdhdGVU YXJnZXQgc2VjdGlvbiAqLwogCiAvKiBCZWdpbiBQQlhCdWlsZEZpbGUgc2VjdGlvbiAqLworCQkw MDE0NjBBRDEwM0M4QTJFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDAxNDYwQUIxMDNDOEEyRTAw MEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCAqLzsgfTsKKwkJMDAxNDYwQUUxMDNDOEEy RTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDE0NjBBQzEwM0M4QTJFMDAwQjIwREIgLyogT3JpZ2lu QWNjZXNzRW50cnkuaCAqLzsgfTsKIAkJMDYwMjdDQUQwQjFDQkZDMDAwODg0QjJEIC8qIENvbnRl eHRNZW51SXRlbS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMDYwMjdDQUMwQjFDQkZDMDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbS5oICovOyBzZXR0 aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTA2MDI3Q0IzMEIxQ0Mw M0QwMDg4NEIyRCAvKiBDb250ZXh0TWVudUl0ZW1NYWMubW0gaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwNjAyN0NCMjBCMUNDMDNEMDA4ODRCMkQgLyogQ29u dGV4dE1lbnVJdGVtTWFjLm1tICovOyB9OwogCQkwNjIyODc4NDBCNERCMzIyMDAwQzM0REYgLyog Rm9jdXNEaXJlY3Rpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDA2MjI4NzgzMEI0REIzMjIwMDBDMzRERiAvKiBGb2N1c0RpcmVjdGlvbi5oICovOyBz ZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC01MDA1LDYgKzUw MDcsOCBAQAogLyogRW5kIFBCWENvcHlGaWxlc0J1aWxkUGhhc2Ugc2VjdGlvbiAqLwogCiAvKiBC ZWdpbiBQQlhGaWxlUmVmZXJlbmNlIHNlY3Rpb24gKi8KKwkJMDAxNDYwQUIxMDNDOEEyRTAwMEIy MERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IE9yaWdpbkFjY2Vzc0VudHJ5LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKKwkJMDAxNDYwQUMxMDNDOEEyRTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9yaWdpbkFjY2Vzc0VudHJ5Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTA2MDI3Q0FDMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250 ZXh0TWVudUl0ZW0uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvbnRleHRN ZW51SXRlbS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwNjAyN0NCMjBCMUNDMDNE MDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVtTWFjLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLm9iamNwcDsgcGF0aCA9IENvbnRleHRNZW51SXRlbU1hYy5tbTsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJMDYyMjg3ODMwQjREQjMyMjAwMEMzNERGIC8qIEZvY3VzRGlyZWN0aW9u LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGb2N1c0RpcmVjdGlvbi5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTA2NzksNiArMTA2ODMsOCBAQAogCQkJCUE5 QzZFNjVEMEQ3NDY2OTQwMDY0NDJFOSAvKiBOYXZpZ2F0b3IuaWRsICovLAogCQkJCUUxMjcxOUM5 MEVFRUMyMTMwMEY2MTIxMyAvKiBOYXZpZ2F0b3JCYXNlLmNwcCAqLywKIAkJCQlFMTI3MTlDNjBF RUVDMTY4MDBGNjEyMTMgLyogTmF2aWdhdG9yQmFzZS5oICovLAorCQkJCTAwMTQ2MEFCMTAzQzhB MkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi8sCisJCQkJMDAxNDYwQUMxMDND OEEyRTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmggKi8sCiAJCQkJNjVGRUE4NjgwOTgz M0FERTAwQkVENEFCIC8qIFBhZ2UuY3BwICovLAogCQkJCTY1QTIxNDY3MDk3QTMyOTEwMEI5MDUw QSAvKiBQYWdlLmggKi8sCiAJCQkJOTMwMkIwQkMwRDc5RjgyOTAwQzdFRTgzIC8qIFBhZ2VHcm91 cC5jcHAgKi8sCkBAIC0xNzMxMiw2ICsxNzMxOCw3IEBACiAJCQkJNDE2RTI5QTYxMDJGQTk2MjAw N0ZDMTRFIC8qIFdvcmtlclJlcG9ydGluZ1Byb3h5LmggaW4gSGVhZGVycyAqLywKIAkJCQlCNUMx MTIzQzEwMkI2QzQ2MDAwOTY1NzggLyogU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIGluIEhl YWRlcnMgKi8sCiAJCQkJRDhCNjE1MkYxMDMyNDk1MTAwQzg1NTRBIC8qIENvb2tpZS5oIGluIEhl YWRlcnMgKi8sCisJCQkJMDAxNDYwQUUxMDNDOEEyRTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0Vu dHJ5LmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rw cm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTE5Mzc4LDYgKzE5Mzg1LDcgQEAKIAkJCQk5MzkyMjYy RDEwMzIxMDdCMDA2RTdENUQgLyogSlNIVE1MQ2FudmFzRWxlbWVudEN1c3RvbS5jcHAgaW4gU291 cmNlcyAqLywKIAkJCQk5MzkyMjYyRjEwMzIxMDg0MDA2RTdENUQgLyogSlNDU1NSdWxlTGlzdEN1 c3RvbS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCNUMxMTIzQjEwMkI2QzQ2MDAwOTY1NzggLyog U1FMVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAgaW4gU291cmNlcyAqLywKKwkJCQkwMDE0NjBB RDEwM0M4QTJFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07 CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwIGIvV2ViQ29y ZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi42YTZlZjdmCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFj Y2Vzc0VudHJ5LmNwcApAQCAtMCwwICsxLDc0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5 IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMu ICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3Ig dGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2Fy ZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJ UyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKKworI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKK09yaWdpbkFjY2Vzc0VudHJ5OjpPcmlnaW5B Y2Nlc3NFbnRyeShjb25zdCBTdHJpbmcmIHByb3RvY29sLCBjb25zdCBTdHJpbmcmIGhvc3QsIFN1 YmRvbWFpblNldHRpbmcgc3ViZG9tYWluU2V0dGluZykgOiBtX3Byb3RvY29sKHByb3RvY29sKSwg bV9ob3N0KGhvc3QpLCBtX2FsbG93U3ViZG9tYWlucyhzdWJkb21haW5TZXR0aW5nKSB7CisgICAg QVNTRVJUKHByb3RvY29sID09ICJodHRwIiB8fCBwcm90b2NvbCA9PSAiaHR0cHMiKTsKKyAgICBB U1NFUlQoc3ViZG9tYWluU2V0dGluZyA9PSBBbGxvd1N1YmRvbWFpbnMgfHwgc3ViZG9tYWluU2V0 dGluZyA9PSBEaXNhbGxvd1N1YmRvbWFpbnMpOworCisgICAgLy8gQXNzdW1lIHRoYXQgYW55IGhv c3QgdGhhdCBlbmRzIHdpdGggYSBkaWdpdCBpcyB0cnlpbmcgdG8gYmUgYW4gSVAgYWRkcmVzcy4K KyAgICBVQ2hhciBsYXN0ID0gbV9ob3N0W21faG9zdC5sZW5ndGgoKSAtIDFdOworICAgIG1faG9z dElzSVBBZGRyZXNzID0gbGFzdCA+PSAnMCcgJiYgbGFzdCA8PSAnOSc7Cit9CisKK2Jvb2wgT3Jp Z2luQWNjZXNzRW50cnk6Om1hdGNoZXNPcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIG9yaWdp bikKK3sKKyAgICBpZiAobV9wcm90b2NvbCAhPSBvcmlnaW4ucHJvdG9jb2woKSkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIAorICAgIC8vIFNwZWNpYWwgY2FzZTogSW5jbHVkZSBzdWJkb21h aW5zIGFuZCBlbXB0eSBob3N0IG1lYW5zICJhbGwgaG9zdHMsIGluY2x1ZGluZyBpcCBhZGRyZXNz ZXMiLgorICAgIGlmIChtX2FsbG93U3ViZG9tYWlucyA9PSBBbGxvd1N1YmRvbWFpbnMgJiYgbV9o b3N0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gRXhhY3Qg bWF0Y2guCisgICAgaWYgKG1faG9zdCA9PSBvcmlnaW4uaG9zdCgpKQorICAgICAgICByZXR1cm4g dHJ1ZTsKKyAgICAKKyAgICAvLyBPdGhlcndpc2Ugd2UgY2FuIG9ubHkgbWF0Y2ggaWYgd2UncmUg bWF0Y2hpbmcgc3ViZG9tYWlucy4KKyAgICBpZiAobV9hbGxvd1N1YmRvbWFpbnMgPT0gRGlzYWxs b3dTdWJkb21haW5zKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAgLy8gRG9uJ3Qg dHJ5IHRvIGRvIHN1YmRvbWFpbiBtYXRjaGluZyBvbiBJUCBhZGRyZXNzZXMuCisgICAgaWYgKG1f aG9zdElzSVBBZGRyZXNzKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAgLy8gTWF0 Y2ggc3ViZG9tYWlucy4KKyAgICAvLyBGSVhNRTogVGhpcyBoYXNuJ3QgYWN0dWFsbHkgYmVlbiB0 ZXN0ZWQgYXMgSSBjYW4ndCBmaWd1cmUgb3V0IGEgd2F5IHRvIHRlc3QgaXQgd2l0aCB0aGUgbGF5 b3V0IHRlc3Qgc3lzdGVtLgorICAgIGlmIChvcmlnaW4uaG9zdCgpLmxlbmd0aCgpID4gbV9ob3N0 Lmxlbmd0aCgpICYmIG9yaWdpbi5ob3N0KClbb3JpZ2luLmhvc3QoKS5sZW5ndGgoKSAtIG1faG9z dC5sZW5ndGgoKSAtIDFdID09ICcuJyAmJiBvcmlnaW4uaG9zdCgpLmVuZHNXaXRoKG1faG9zdCwg ZmFsc2UpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAKKyAgICByZXR1cm4gZmFsc2U7Cit9 CisgICAgCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2Uv T3JpZ2luQWNjZXNzRW50cnkuaCBiL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI3MjcyZTIKLS0tIC9kZXYvbnVsbAor KysgYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuaApAQCAtMCwwICsxLDU4IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAg UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1 dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1 dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAor ICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4g cGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFO RCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAor ICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg T1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aWZuZGVmIENyb3NzT3JpZ2luQWNjZXNzX2gKKyNkZWZpbmUgQ3Jvc3NPcmlnaW5BY2Nlc3NfaAor CisjaW5jbHVkZSAiQ1N0cmluZy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFNl Y3VyaXR5T3JpZ2luOworCitjbGFzcyBPcmlnaW5BY2Nlc3NFbnRyeSB7CitwdWJsaWM6CisgICAg ZW51bSBTdWJkb21haW5TZXR0aW5nIHsKKyAgICAgICAgQWxsb3dTdWJkb21haW5zLAorICAgICAg ICBEaXNhbGxvd1N1YmRvbWFpbnMKKyAgICB9OworCisgICAgT3JpZ2luQWNjZXNzRW50cnkoY29u c3QgU3RyaW5nJiBwcm90b2NvbCwgY29uc3QgU3RyaW5nJiBob3N0LCBTdWJkb21haW5TZXR0aW5n IHN1YmRvbWFpblNldHRpbmcpOworICAgIGJvb2wgbWF0Y2hlc09yaWdpbihjb25zdCBTZWN1cml0 eU9yaWdpbiYgb3JpZ2luKTsKKyAgICAKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1fcHJvdG9jb2w7 CisgICAgU3RyaW5nIG1faG9zdDsKKyAgICBTdWJkb21haW5TZXR0aW5nIG1fYWxsb3dTdWJkb21h aW5zOworICAgIGJvb2wgbV9ob3N0SXNJUEFkZHJlc3M7CisgICAgCit9OworCit9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDcm9zc09yaWdpbkFjY2Vzc19oCmRpZmYgLS1naXQg YS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5 T3JpZ2luLmNwcAppbmRleCA4Mjc0ZTBlLi42NjkxZjMzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvU2VjdXJpdHlPcmlnaW4uY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5j cHAKQEAgLTMxLDExICszMSwyMSBAQAogCiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUg IkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKICNpbmNsdWRl ICJLVVJMLmgiCiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKK3R5cGVkZWYgVmVjdG9yPE9yaWdpbkFjY2Vzc0VudHJ5PiBPcmlnaW5BY2Nlc3NX aGl0ZUxpc3Q7Cit0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Qq PiBPcmlnaW5BY2Nlc3NNYXA7CisKK3N0YXRpYyBPcmlnaW5BY2Nlc3NNYXAmIG9yaWdpbkFjY2Vz c01hcCgpCit7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChPcmlnaW5BY2Nlc3NNYXAsIG9yaWdp bkFjY2Vzc01hcCwgKCkpOworICAgIHJldHVybiBvcmlnaW5BY2Nlc3NNYXA7Cit9CisKIHN0YXRp YyBVUkxTY2hlbWVzTWFwJiBsb2NhbFNjaGVtZXMoKQogewogICAgIERFRklORV9TVEFUSUNfTE9D QUwoVVJMU2NoZW1lc01hcCwgbG9jYWxTY2hlbWVzLCAoKSk7CkBAIC0xOTgsNyArMjA4LDE3IEBA IGJvb2wgU2VjdXJpdHlPcmlnaW46OmNhblJlcXVlc3QoY29uc3QgS1VSTCYgdXJsKSBjb25zdAog CiAgICAgLy8gV2UgY2FsbCBpc1NhbWVTY2hlbWVIb3N0UG9ydCBoZXJlIGluc3RlYWQgb2YgY2Fu QWNjZXNzIGJlY2F1c2Ugd2Ugd2FudAogICAgIC8vIHRvIGlnbm9yZSBkb2N1bWVudC5kb21haW4g ZWZmZWN0cy4KLSAgICByZXR1cm4gaXNTYW1lU2NoZW1lSG9zdFBvcnQodGFyZ2V0T3JpZ2luLmdl dCgpKTsKKyAgICBpZiAoaXNTYW1lU2NoZW1lSG9zdFBvcnQodGFyZ2V0T3JpZ2luLmdldCgpKSkK KyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAoT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBs aXN0ID0gb3JpZ2luQWNjZXNzTWFwKCkuZ2V0KHRvU3RyaW5nKCkpKSB7CisgICAgICAgIGZvciAo c2l6ZV90IGkgPSAwOyBpIDwgbGlzdC0+c2l6ZSgpOyArK2kpIHsKKyAgICAgICAgICAgIGlmIChs aXN0LT5hdChpKS5tYXRjaGVzT3JpZ2luKCp0YXJnZXRPcmlnaW4pKQorICAgICAgICAgICAgICAg IHJldHVybiB0cnVlOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOwogfQog CiB2b2lkIFNlY3VyaXR5T3JpZ2luOjpncmFudExvYWRMb2NhbFJlc291cmNlcygpCkBAIC00MTQs NCArNDM0LDMyIEBAIGJvb2wgU2VjdXJpdHlPcmlnaW46OnNob3VsZFRyZWF0VVJMU2NoZW1lQXNO b0FjY2Vzcyhjb25zdCBTdHJpbmcmIHNjaGVtZSkKICAgICByZXR1cm4gbm9BY2Nlc3NTY2hlbWVz KCkuY29udGFpbnMoc2NoZW1lKTsKIH0KIAorLy8gc3RhdGljCit2b2lkIFNlY3VyaXR5T3JpZ2lu Ojp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2VP cmlnaW4sIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgU3RyaW5nJiBk ZXN0aW5hdGlvbkRvbWFpbnMsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNvdXJjZU9yaWdpbi5pc0Vt cHR5KCkpOworCisgICAgU3RyaW5nIHNvdXJjZVN0cmluZyA9IHNvdXJjZU9yaWdpbi50b1N0cmlu ZygpOworICAgIE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9yaWdpbkFjY2Vzc01hcCgp LmdldChzb3VyY2VTdHJpbmcpOworICAgIGlmICghbGlzdCkgeworICAgICAgICBsaXN0ID0gbmV3 IE9yaWdpbkFjY2Vzc1doaXRlTGlzdCgpOworICAgICAgICBvcmlnaW5BY2Nlc3NNYXAoKS5zZXQo c291cmNlU3RyaW5nLCBsaXN0KTsKKyAgICB9CisgICAgbGlzdC0+YXBwZW5kKE9yaWdpbkFjY2Vz c0VudHJ5KGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9uRG9tYWlucywgYWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnMgPyBPcmlnaW5BY2Nlc3NFbnRyeTo6QWxsb3dTdWJkb21haW5zIDog T3JpZ2luQWNjZXNzRW50cnk6OkRpc2FsbG93U3ViZG9tYWlucykpOworfQorCisvLyBzdGF0aWMK K3ZvaWQgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpCit7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBPcmlnaW5BY2Nlc3NNYXAmIG1hcCA9IG9y aWdpbkFjY2Vzc01hcCgpOworICAgIGZvciAoT3JpZ2luQWNjZXNzTWFwOjppdGVyYXRvciBpdGVy ID0gbWFwLmJlZ2luKCk7IGl0ZXIgIT0gbWFwLmVuZCgpOyArK2l0ZXIpIHsKKyAgICAgICAgT3Jp Z2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0ID0gaXRlci0+c2Vjb25kOworICAgICAgICBkZWxldGUg bGlzdDsKKyAgICB9CisKKyAgICBtYXAuY2xlYXIoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9XZWJDb3Jl L3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAppbmRleCAzMzVlZDI4Li5jYzJhY2RkIDEwMDY0NAotLS0g YS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uaApAQCAtMTQxLDYgKzE0MSw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAg ICAgc3RhdGljIHZvaWQgcmVnaXN0ZXJVUkxTY2hlbWVBc05vQWNjZXNzKGNvbnN0IFN0cmluZyYp OwogICAgICAgICBzdGF0aWMgYm9vbCBzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29u c3QgU3RyaW5nJik7CiAKKyAgICAgICAgc3RhdGljIHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJvbU9y aWdpbihjb25zdCBTZWN1cml0eU9yaWdpbiYgc291cmNlT3JpZ2luLCBjb25zdCBTdHJpbmcmIGRl c3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Eb21haW5zLCBib29s IGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKKyAgICAgICAgc3RhdGljIHZvaWQgcmVzZXRP cmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CisKICAgICBwcml2YXRlOgogICAgICAgICBleHBsaWNp dCBTZWN1cml0eU9yaWdpbihjb25zdCBLVVJMJik7CiAgICAgICAgIGV4cGxpY2l0IFNlY3VyaXR5 T3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luKik7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0No YW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDZmNjY1MmUuLmI4ODdmZmMgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTUgQEAKKzIwMDktMDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEg d2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxh ciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIgYWNjZXNzLgorCisgICAgICAgICogd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwOgorICAgICAgICAod2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3Rv X29yaWdpbik6IEFkZCBBUEkgdG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMu CisgICAgICAgICh3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9saXN0cyk6IERpdHRv LgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6IERpdHRvLgorCiAyMDA5LTA4LTE1 ICBaYW4gRG9iZXJzZWsgIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgWGFuIExvcGV6LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCA3NTVi NGQzLi40YjNjNjVjIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMzcsNiAr MzcsNyBAQAogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlQ2xpZW50LmgiCiAjaW5jbHVkZSAiUmVz b3VyY2VIYW5kbGVJbnRlcm5hbC5oIgogI2luY2x1ZGUgPHJ1bnRpbWUvSW5pdGlhbGl6ZVRocmVh ZGluZy5oPgorI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAKICNpZiBFTkFCTEUoREFUQUJB U0UpCiAjaW5jbHVkZSAiRGF0YWJhc2VUcmFja2VyLmgiCkBAIC0xNzgsMyArMTc5LDEzIEBAIHZv aWQgd2Via2l0X2luaXQoKQogICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBz bmlmZmVyKTsKICAgICBnX29iamVjdF91bnJlZihzbmlmZmVyKTsKIH0KKwordm9pZCB3ZWJraXRf d2hpdGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKGNvbnN0IGdjaGFyKiBzb3VyY2VPcmlnaW4sIGNv bnN0IGdjaGFyKiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25I b3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQoreworICAgIFNlY3VyaXR5T3Jp Z2luOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0 cmluZyhzb3VyY2VPcmlnaW4pLCBkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhvc3Qs IGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30KKwordm9pZCB3ZWJraXRfcmVzZXRfb3Jp Z2luX2FjY2Vzc193aGl0ZV9saXN0cygpCit7CisgICAgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3Jp Z2luQWNjZXNzV2hpdGVMaXN0cygpOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4 IDBjM2ZiZDMuLjQ1ZGU2MTIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTI1MCw2 ICsyNTAsMTIgQEAgZXh0ZXJuICJDIiB7CiAKICAgICBXRUJLSVRfQVBJIHZvaWQKICAgICB3ZWJr aXRfYXBwbGljYXRpb25fY2FjaGVfc2V0X21heGltdW1fc2l6ZSh1bnNpZ25lZCBsb25nIGxvbmcg c2l6ZSk7CisgICAgCisgICAgV0VCS0lUIEFQSSB2b2lkCisgICAgd2Via2l0X3doaXRlX2xpc3Rf YWNjZXNzX3RvX29yaWdpbihjb25zdCBnY2hhciogc291cmNlT3JpZ2luLCBjb25zdCBnY2hhciog ZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBh bGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgCisgICAgV0VCS0lUIEFQSSB2b2lkCisg ICAgd2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKIH0KIAogI2VuZGlm CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9n CmluZGV4IGU0YzFhYjEuLmFhOGJhMTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9n CisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDktMDgtMTkg IEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bworICAg ICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIg YWNjZXNzLgorCisgICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOiBBZGQgU1BJIHRvIG1hbmlw dWxhdGUgb3JpZ2luIGFjY2VzcyB3aGl0ZWxpc3RzLgorICAgICAgICAoK1tXZWJWaWV3IF93aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOmRlc3RpbmF0aW9uUHJvdG9jb2w6ZGVzdGluYXRpb25Ib3N0 OmFsbG93RGVzdGluYXRpb25TdWJkb21haW5zOl0pOiBEaXR0by4KKyAgICAgICAgKCtbV2ViVmll dyBfcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzXSk6IERpdHRvLgorICAgICAgICAqIFdlYlZp ZXcvV2ViVmlld1ByaXZhdGUuaDogRGl0dG8uCisKIDIwMDktMDgtMTcgIERhcmluIEFkbGVyICA8 ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCmRpZmYg LS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmll dy9XZWJWaWV3Lm1tCmluZGV4IDNhM2NiNTkuLmJkNjM3OTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1t CkBAIC0yMDkyLDYgKzIwOTIsMTUgQEAgc3RhdGljIGlubGluZSBJTVAgZ2V0TWV0aG9kKGlkIG8s IFNFTCBzKQogICAgIHJldHVybiBfcHJpdmF0ZSA/IF9wcml2YXRlLT5pbnNlcnRpb25QYXN0ZWJv YXJkIDogbmlsOwogfQogCisrICh2b2lkKV93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOihOU1N0 cmluZyopc291cmNlT3JpZ2luIGRlc3RpbmF0aW9uUHJvdG9jb2w6KE5TU3RyaW5nKilkZXN0aW5h dGlvblByb3RvY29sIGRlc3RpbmF0aW9uSG9zdDooTlNTdHJpbmcqKWRlc3RpbmF0aW9uSG9zdCBh bGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczooQk9PTClhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlu czsKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigqU2Vj dXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcoc291cmNlT3JpZ2luKSwgZGVzdGluYXRpb25Q cm90b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7Cit9 CisKKysodm9pZClfcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzCit7CisgICAgU2VjdXJpdHlP cmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworfQogCiAtICh2b2lkKV91cGRh dGVBY3RpdmVTdGF0ZQogewpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQ cml2YXRlLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaAppbmRleCAzNjJi MmU2Li4xMjhhYTkxIDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZh dGUuaAorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaApAQCAtNDQzLDYg KzQ0MywxNSBAQCBDb3VsZCBiZSB3b3J0aCBhZGRpbmcgdG8gdGhlIEFQSS4KIC8vIFdoaWNoIHBh c3RlYm9hcmQgdGV4dCBpcyBjb21pbmcgZnJvbSBpbiBlZGl0aW5nIGRlbGVnYXRlIG1ldGhvZHMg c3VjaCBhcyBzaG91bGRJbnNlcnROb2RlLgogLSAoTlNQYXN0ZWJvYXJkICopX2luc2VydGlvblBh c3RlYm9hcmQ7CiAKKy8vIFdoaXRlbGlzdHMgYWNjZXNzIGZyb20gYW4gb3JpZ2luIChzb3VyY2VP cmlnaW4pIHRvIGEgc2V0IG9mIG9uZSBvciBtb3JlIG9yaWdpbnMgZGVzY3JpYmVkIGJ5IHRoZSBw YXJhbWV0ZXJzOgorLy8gLSBkZXN0aW5hdGlvblByb3RvY29sOiBUaGUgcHJvdG9jb2wgdG8gZ3Jh bnQgYWNjZXNzIHRvLgorLy8gLSBkZXN0aW5hdGlvbkhvc3Q6IFRoZSBob3N0IHRvIGdyYW50IGFj Y2VzcyB0by4KKy8vIC0gYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnM6IElmIGhvc3QgaXMgYSBk b21haW4sIHNldHRpbmcgdGhpcyB0byBZRVMgd2lsbCB3aGl0ZWxpc3QgaG9zdCBhbmQgYWxsIGl0 cyBzdWJkb21haW5zLCByZWN1cnNpdmVseS4KKysgKHZvaWQpX3doaXRlTGlzdEFjY2Vzc0Zyb21P cmlnaW46KE5TU3RyaW5nKilzb3VyY2VPcmlnaW4gZGVzdGluYXRpb25Qcm90b2NvbDooTlNTdHJp bmcqKWRlc3RpbmF0aW9uUHJvdG9jb2wgZGVzdGluYXRpb25Ib3N0OihOU1N0cmluZyopZGVzdGlu YXRpb25Ib3N0IGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zOihCT09MKWFsbG93RGVzdGluYXRp b25TdWJkb21haW5zOworCisvLyBSZW1vdmVzIGFsbCB3aGl0ZSBsaXN0IGVudHJpZXMgY3JlYXRl ZCB3aXRoIF93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luLgorKyAodm9pZClfcmVzZXRPcmlnaW5B Y2Nlc3NXaGl0ZUxpc3RzOworCiBAZW5kCiAKIEBpbnRlcmZhY2UgV2ViVmlldyAoV2ViVmlld1By aW50aW5nUHJpdmF0ZSkKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3Jp Z2luLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcAppbmRleCBiMzAw NWMyLi5mY2U5YTk5IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdp bi5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCkBAIC0yMzUs MyArMjM1LDEyIEBAIFFTdHJpbmdMaXN0IFFXZWJTZWN1cml0eU9yaWdpbjo6bG9jYWxTY2hlbWVz KCkKICAgICByZXR1cm4gbGlzdDsKIH0KIAordm9pZCBRV2ViU2VjdXJpdHlPcmlnaW46OndoaXRl TGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgUVN0cmluZyYgc291cmNlT3JpZ2luLCBjb25zdCBR U3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlvbkhv c3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAgU2VjdXJpdHlPcmln aW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oc291cmNlT3JpZ2luLCBkZXN0aW5hdGlvblBy b3RvY29sLCBkZXN0aW5hdGlvbkhvc3QsIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30K Kwordm9pZCBRV2ViU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygp Cit7CisgICAgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOwor fQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaCBiL1dlYktp dC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmgKaW5kZXggMTZmOGJjMS4uMDU1NmI4OSAxMDA2 NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaAorKysgYi9XZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCkBAIC00MCw2ICs0MCw4IEBAIHB1YmxpYzoKICAg ICBzdGF0aWMgdm9pZCBhZGRMb2NhbFNjaGVtZShjb25zdCBRU3RyaW5nJiBzY2hlbWUpOwogICAg IHN0YXRpYyB2b2lkIHJlbW92ZUxvY2FsU2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVtZSk7CiAg ICAgc3RhdGljIFFTdHJpbmdMaXN0IGxvY2FsU2NoZW1lcygpOworICAgIHN0YXRpYyB2b2lkIHdo aXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgUVN0cmluZyYgc291cmNlT3JpZ2luLCBjb25z dCBRU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlv bkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworICAgIHN0YXRpYyB2b2lk IGNsZWFyT3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOwogCiAgICAgflFXZWJTZWN1cml0eU9yaWdp bigpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5n ZUxvZwppbmRleCA1Y2E4YzFhLi41YmJiOWMwIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wOC0x OSAgQWFyb24gQm9vZG1hbiAgPGFhQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjQ4NTM6IFByb3ZpZGUgYSB3YXkgZm9yIFdlYktpdCBjbGllbnRzIHRvCisg ICAgICAgIHNwZWNpZnkgYSBtb3JlIGdyYW51bGFyIHBvbGljeSBmb3IgY3Jvc3Mtb3JpZ2luIFhI UiBhY2Nlc3MuCisKKyAgICAgICAgKiBBcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcDogQWRkIEFQ SSB0byBtYW5pcHVsYXRlIG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAgKFFXZWJT ZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAg ICAoUVdlYlNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMpOiBEaXR0 by4KKyAgICAgICAgKiBBcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmg6IERpdHRvLgorCiAyMDA5LTA4 LTE3ICBEYXJpbiBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBUcnkgdG8gZml4 IFF0IGJ1aWxkIGFnYWluLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IGQ3ZjFlODMuLmYyY2MwOTIgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSw0NiBAQAorMjAwOS0wOC0xOSAgQWFyb24gQm9vZG1hbiAgPGFhQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ4NTM6IFByb3ZpZGUgYSB3YXkgZm9yIFdl YktpdCBjbGllbnRzIHRvCisgICAgICAgIHNwZWNpZnkgYSBtb3JlIGdyYW51bGFyIHBvbGljeSBm b3IgY3Jvc3Mtb3JpZ2luIFhIUiBhY2Nlc3MuCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5jcHA6IEV4cG9zZSB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu KCkgdG8gbGF5b3V0IHRlc3RzLgorICAgICAgICAod2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbkNh bGxiYWNrKTogRGl0dG8uCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVu Y3Rpb25zKTogRGl0dG8uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaDogRGl0dG8uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RD b250cm9sbGVyR3RrLmNwcDogRGl0dG8uCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4pOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06IERpdHRvLgorICAgICAgICAoTGF5b3V0 VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9qc29iamVjdHMuY3BwOiBEaXR0by4KKyAgICAgICAgKExh eW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0dG8uCisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDog U3R1YiBvdXQgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigpLgorICAgICAgICAoTGF5b3V0VGVz dENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwOiBSZXNldCBvcmlnaW4gYWNj ZXNzIGxpc3RzIGJlZm9yZSBlYWNoIHRlc3QuCisgICAgICAgIChyZXNldFdlYlZpZXdUb0NvbnNp c3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcpOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW06IERpdHRvLgorICAgICAgICAocmVzZXRXZWJWaWV3VG9D b25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKTogRGl0dG8uCisgICAgICAgICogRHVtcFJlbmRl clRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OkR1 bXBSZW5kZXJUcmVlOjpyZXNldFRvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZyk6IERpdHRv LgorCisyMDA5LTA4LTE4ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0 IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBj cm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcDogQWRkIHBsdW1iaW5nIHRvIGJlIGFibGUgdG8gbWFuaXB1bGF0 ZQorICAgICAgICBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMgZnJvbSBsYXlvdXQgdGVzdHMuCisg ICAgICAgICh3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbkNhbGxiYWNrKTogRGl0dG8uCisgICAgICAg IChyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNDYWxsYmFjayk6IERpdHRvLgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucyk6IERpdHRvLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6IERpdHRvLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbTogRGl0dG8uCisg ICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4pOiBE aXR0by4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpyZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHMpOiBEaXR0by4KKwogMjAwOS0wOC0xNyAgU2hpbmljaGlybyBIYW1hamkgIDxoYW1h amlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CmluZGV4IGY4NjQwZmEuLjcwNDA5MTcgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTg3NCw2ICs4NzQsMjQgQEAgc3Rh dGljIEpTVmFsdWVSZWYgd2FpdEZvclBvbGljeURlbGVnYXRlQ2FsbGJhY2soSlNDb250ZXh0UmVm IGNvbnRleHQsIEpTT2JqZWN0UmUKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29u dGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIHdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW5D YWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYsIEpTT2JqZWN0UmVmIHRo aXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50 c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgIT0g NCkKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisgICAg SlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IHNvdXJjZU9yaWdpbihBZG9wdCwgSlNWYWx1ZVRvU3Ry aW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCgh KmV4Y2VwdGlvbik7CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGRlc3RpbmF0aW9uUHJv dG9jb2woQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzFdLCBl eGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworICAgIEpTUmV0YWluUHRyPEpT U3RyaW5nUmVmPiBkZXN0aW5hdGlvbkhvc3QoQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29u dGV4dCwgYXJndW1lbnRzWzJdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24p OworICAgIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMgPSBKU1ZhbHVlVG9Cb29sZWFu KGNvbnRleHQsIGFyZ3VtZW50c1szXSk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29u dHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQ cml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT53aGl0ZUxpc3RBY2Nlc3NGcm9t T3JpZ2luKHNvdXJjZU9yaWdpbi5nZXQoKSwgZGVzdGluYXRpb25Qcm90b2NvbC5nZXQoKSwgZGVz dGluYXRpb25Ib3N0LmdldCgpLCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgcmV0 dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiAvLyBTdGF0aWMgVmFsdWVz CiAKIHN0YXRpYyBKU1ZhbHVlUmVmIGdldEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYg Y29udGV4dCwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1l LCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCkBAIC0xMDE0LDYgKzEwMzIsNyBAQCBKU1N0YXRpY0Z1 bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAg eyAid2FpdEZvclBvbGljeURlbGVnYXRlIiwgd2FpdEZvclBvbGljeURlbGVnYXRlQ2FsbGJhY2ss IGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnRE ZWxldGUgfSwKICAgICAgICAgeyAid2FpdFVudGlsRG9uZSIsIHdhaXRVbnRpbERvbmVDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJ3aW5kb3dDb3VudCIsIHdpbmRvd0NvdW50Q2FsbGJhY2ss IGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnRE ZWxldGUgfSwKKyAgICAgICAgeyAid2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbiIsIHdoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW5DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7IDAsIDAsIDAgfQog ICAgIH07CiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oCmluZGV4IDhhZWJlZDQuLmQ3YmEzNWMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaApAQCAtMTc4LDcgKzE3OCw5IEBA IHB1YmxpYzoKICAgICBib29sIHBhdXNlQW5pbWF0aW9uQXRUaW1lT25FbGVtZW50V2l0aElkKEpT U3RyaW5nUmVmIGFuaW1hdGlvbk5hbWUsIGRvdWJsZSB0aW1lLCBKU1N0cmluZ1JlZiBlbGVtZW50 SWQpOwogICAgIGJvb2wgcGF1c2VUcmFuc2l0aW9uQXRUaW1lT25FbGVtZW50V2l0aElkKEpTU3Ry aW5nUmVmIHByb3BlcnR5TmFtZSwgZG91YmxlIHRpbWUsIEpTU3RyaW5nUmVmIGVsZW1lbnRJZCk7 CiAgICAgdW5zaWduZWQgbnVtYmVyT2ZBY3RpdmVBbmltYXRpb25zKCkgY29uc3Q7Ci0gICAgCisK KyAgICB2b2lkIHdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNlT3Jp Z2luLCBKU1N0cmluZ1JlZiBkZXN0aW5hdGlvblByb3RvY29sLCBKU1N0cmluZ1JlZiBkZXN0aW5h dGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworCiBwcml2YXRlOgog ICAgIGJvb2wgbV9kdW1wQXNUZXh0OwogICAgIGJvb2wgbV9kdW1wQXNQREY7CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCA0ZjMw NDllLi40MmRmNWUwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsv RHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9E dW1wUmVuZGVyVHJlZS5jcHAKQEAgLTYyLDYgKzYyLDcgQEAgZXh0ZXJuIHZvaWQgd2Via2l0X3dl Yl9zZXR0aW5nc19hZGRfZXh0cmFfcGx1Z2luX2RpcmVjdG9yeShXZWJLaXRXZWJWaWV3KiB2aWV3 LAogZXh0ZXJuIGdjaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX2dldF9yZXNwb25zZV9taW1lX3R5cGUo V2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIGV4dGVybiB2b2lkIHdlYmtpdF93ZWJfZnJhbWVfY2xl YXJfbWFpbl9mcmFtZV9uYW1lKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiBleHRlcm4gdm9pZCB3 ZWJraXRfd2ViX3ZpZXdfc2V0X2dyb3VwX25hbWUoV2ViS2l0V2ViVmlldyogdmlldywgY29uc3Qg Z2NoYXIqIGdyb3VwTmFtZSk7CitleHRlcm4gdm9pZCB3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vz c193aGl0ZV9saXN0cygpOwogfQogCiB2b2xhdGlsZSBib29sIGRvbmU7CkBAIC0yODAsNiArMjgx LDggQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0 aW5nKCkKIAogICAgIFdlYktpdFdlYkluc3BlY3RvciogaW5zcGVjdG9yID0gd2Via2l0X3dlYl92 aWV3X2dldF9pbnNwZWN0b3Iod2ViVmlldyk7CiAgICAgZ19vYmplY3Rfc2V0KEdfT0JKRUNUKGlu c3BlY3RvciksICJqYXZhc2NyaXB0LXByb2ZpbGluZy1lbmFibGVkIiwgRkFMU0UsIE5VTEwpOwor CisgICAgd2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKIH0KIAogdm9p ZCBkdW1wKCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlv dXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsv TGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCmluZGV4IGYwM2NjODAuLjJiYTUxZWEgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxl ckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RD b250cm9sbGVyR3RrLmNwcApAQCAtNDgsNiArNDgsNyBAQCBib29sIHdlYmtpdF93ZWJfZnJhbWVf cGF1c2VfYW5pbWF0aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIG5hbWUs CiBib29sIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2VfdHJhbnNpdGlvbihXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGNvbnN0IGdjaGFyKiBuYW1lLCBkb3VibGUgdGltZSwgY29uc3QgZ2NoYXIqIGVsZW1l bnQpOwogdW5zaWduZWQgaW50IHdlYmtpdF93ZWJfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9hbmlt YXRpb25zKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiB2b2lkIHdlYmtpdF9hcHBsaWNhdGlvbl9j YWNoZV9zZXRfbWF4aW11bV9zaXplKHVuc2lnbmVkIGxvbmcgbG9uZyBzaXplKTsKK3ZvaWQgd2Vi a2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29yaWdpbihjb25zdCBnY2hhciogc291cmNlT3JpZ2lu LCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0 aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CiB9CiAKIExheW91dFRl c3RDb250cm9sbGVyOjp+TGF5b3V0VGVzdENvbnRyb2xsZXIoKQpAQCAtMTYzLDYgKzE2NCwxNCBA QCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogICAg IHNldFdhaXRUb0R1bXAodHJ1ZSk7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Ondo aXRlTGlzdEFjY2Vzc1RvT3JpZ2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdS ZWYgcHJvdG9jb2wsIEpTU3RyaW5nUmVmIGhvc3QsIGJvb2wgaW5jbHVkZVN1YmRvbWFpbnMpCit7 CisgICAgZ2NoYXIqIHNvdXJjZU9yaWdpbkdDaGFyID0gSlNTdHJpbmdDb3B5VVRGOENTdHJpbmco c291cmNlT3JpZ2luKTsKKyAgICBnY2hhciogcHJvdG9jb2xHQ2hhciA9IEpTU3RyaW5nQ29weVVU RjhDU3RyaW5nKHByb3RvY29sKTsKKyAgICBnY2hhciogaG9zdEdDaGFyID0gSlNTdHJpbmdDb3B5 VVRGOENTdHJpbmcoaG9zdCk7CisgICAgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29yaWdp bihzb3VyY2VPcmlnaW5HQ2hhciwgcHJvdG9jb2xHQ2hhciwgaG9zdEdDaGFyLCBpbmNsdWRlU3Vi ZG9tYWlucyk7Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldE1haW5GcmFtZUlz Rmlyc3RSZXNwb25kZXIoYm9vbCBmbGFnKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5t bSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRl eCAwYWNmZjc3Li44MDU1NzIyIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC0xMDgyLDYgKzEwODIsNyBAQCBzdGF0aWMgdm9pZCBy ZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogICAgIFtbW21haW5G cmFtZSB3ZWJWaWV3XSBpbnNwZWN0b3JdIHNldEphdmFTY3JpcHRQcm9maWxpbmdFbmFibGVkOk5P XTsKIAogICAgIFtXZWJWaWV3IF9zZXRVc2VzVGVzdE1vZGVGb2N1c1JpbmdDb2xvcjpZRVNdOwor ICAgIFtXZWJWaWV3IF9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNdOwogfQogCiBzdGF0aWMg dm9pZCBydW5UZXN0KGNvbnN0IHN0cmluZyYgdGVzdFBhdGhPclVSTCkKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbSBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5t bQppbmRleCBhMDkzZGZkLi5lNDBkYzViIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCkBAIC00MzcsMyAr NDM3LDE0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndhaXRGb3JQb2xpY3lEZWxlZ2F0 ZSgpCiAgICAgW3BvbGljeURlbGVnYXRlIHNldENvbnRyb2xsZXJUb05vdGlmeURvbmU6dGhpc107 CiAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gc2V0UG9saWN5RGVsZWdhdGU6cG9saWN5RGVsZWdh dGVdOwogfQorCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9t T3JpZ2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Q cm90b2NvbCwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRp b25TdWJkb21haW5zKQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gc291cmNlT3JpZ2lu Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgc291 cmNlT3JpZ2luKSk7CisgICAgTlNTdHJpbmcgKnNvdXJjZU9yaWdpbk5TID0gKE5TU3RyaW5nICop c291cmNlT3JpZ2luQ0YuZ2V0KCk7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBwcm90b2Nv bENGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGRl c3RpbmF0aW9uUHJvdG9jb2wpKTsKKyAgICBOU1N0cmluZyAqZGVzdGluYXRpb25Qcm90b2NvbE5T ID0gKE5TU3RyaW5nICopcHJvdG9jb2xDRi5nZXQoKTsKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdS ZWY+IGhvc3RDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBkZXN0aW5hdGlvbkhvc3QpKTsKKyAgICBOU1N0cmluZyAqZGVzdGluYXRpb25Ib3N0TlMg PSAoTlNTdHJpbmcgKilob3N0Q0YuZ2V0KCk7CisgICAgW1dlYlZpZXcgX3doaXRlTGlzdEFjY2Vz c0Zyb21PcmlnaW46c291cmNlT3JpZ2luTlMgZGVzdGluYXRpb25Qcm90b2NvbDpkZXN0aW5hdGlv blByb3RvY29sTlMgZGVzdGluYXRpb25Ib3N0OmRlc3RpbmF0aW9uSG9zdE5TIGFsbG93RGVzdGlu YXRpb25TdWJkb21haW5zOmFsbG93RGVzdGluYXRpb25TdWJkb21haW5zXTsKK30KZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCAxNjdh NGM1Li41ZTMwOWY0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9E dW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVt cFJlbmRlclRyZWUuY3BwCkBAIC0yMTgsNiArMjE4LDcgQEAgdm9pZCBEdW1wUmVuZGVyVHJlZTo6 cmVzZXRUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogICAgIC8vV29ya1F1ZXVlOjpz aGFyZWQoKS0+c2V0RnJvemVuKGZhbHNlKTsKIAogICAgIG1fY29udHJvbGxlci0+cmVzZXQoKTsK KyAgICBRV2ViU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOwog fQogCiB2b2lkIER1bXBSZW5kZXJUcmVlOjpvcGVuKGNvbnN0IFFVcmwmIGF1cmwpCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9qc29iamVjdHMuY3BwIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNwcAppbmRleCBjOWU3Yjg0Li40YmVm M2I5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9qc29iamVjdHMu Y3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHAKQEAg LTMzNyw2ICszMzcsMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6Y2xlYXJBbGxEYXRh YmFzZXMoKQogICAgIFFXZWJEYXRhYmFzZTo6cmVtb3ZlQWxsRGF0YWJhc2VzKCk7CiB9CiAKK3Zv aWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3Qg UVN0cmluZyYgc291cmNlT3JpZ2luLCBjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29s LCBjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1 YmRvbWFpbnMpCit7CisgICAgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21Pcmln aW4oc291cmNlT3JpZ2luLCBkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhvc3QsIGFs bG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30KKwogRXZlbnRTZW5kZXI6OkV2ZW50U2VuZGVy KFFXZWJQYWdlICpwYXJlbnQpCiAgICAgOiBRT2JqZWN0KHBhcmVudCkKIHsKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5j cHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCmluZGV4IGVjZDA4NmUuLmRlZDYwYmQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKKysrIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcApAQCAt Nzk3LDMgKzc5Nyw4IEBAIHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjpudW1iZXJPZkFj dGl2ZUFuaW1hdGlvbnMoKSBjb25zdAogCiAgICAgcmV0dXJuIG51bWJlcjsKIH0KKwordm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihKU1N0cmluZ1Jl ZiBzb3VyY2VPcmlnaW4sIEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIEpTU3RyaW5n UmVmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sK KyAgICBwcmludGYoIkxheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luIG5vdCBpbXBsZW1lbnRlZFxuIik7Cit9Cg== 35161 2009-08-19 17:21:51 -0700 2009-08-19 17:39:03 -0700 Now with even more code! patch.txt text/plain 52151 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjYTQyYjU3Li41Njg1ZjMyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTggIFNoaW5pY2hpcm8gSGFtYWpp ICA8aGFtYWppQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRl bC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTJiYTQyZgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1hbGwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTEgQEAKK1Rlc3RzIHRoZSBzcGVjaWFs IGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLgorCitUZXN0aW5nOiBodHRwOi8vbG9j YWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNT OiBQQVNTCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4w LjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzog UEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291 cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5odG1s IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLWFsbC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUwNzg1ZTEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L29yaWdpbi13aGl0ZWxpc3RpbmctYWxsLmh0bWwKQEAgLTAsMCArMSw1NiBAQAorPHA+VGVzdHMg dGhlIHNwZWNpYWwgY2FzZSBvZiB3aGl0ZWxpc3RpbmcgYWxsIG9yaWdpbnMuPC9wPgorCis8cHJl IGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRU ZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCJodHRwOi8vMTI3LjAuMC4x OjgwMDAiLCAiaHR0cCIsICIiLCB0cnVlKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIiIsIHRy dWUpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3REb21haW4oKQoreworICAgIHZhciB1cmwg PSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IjsKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEg PSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7 CisgICAgdHJ5IHsKKyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygiUEFTUzog IiArIHJlcS5yZXNwb25zZVRleHQpOworICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAgICAgbG9nKCJG QUlMOiAiICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5 bmMpIik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdF VCIsIHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBs b2coIlBBU1M6ICIgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAgICAgdGVzdElQQWRkcmVzcygp OworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKCJG QUlMOiAiICsgcmVxLnN0YXR1cyk7CisgICAgICAgIHRlc3RJUEFkZHJlc3MoKTsKKyAgICB9Owor ICAgIHJlcS5zZW5kKG51bGwpOworfQorCitmdW5jdGlvbiB0ZXN0SVBBZGRyZXNzKCkKK3sKKyAg ICB2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiaWZyYW1lIik7CisgICAgZG9j dW1lbnQuYm9keS5hcHBlbmRDaGlsZChpZnJhbWUpOworICAgIGlmcmFtZS5zcmMgPSAiaHR0cDov L2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9vcmlnaW4td2hpdGVsaXN0 aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKKyAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcigi bWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICAgICAgaWYgKGUuZGF0YSA9PSAiRE9ORSIpCisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIGVs c2UKKyAgICAgICAgICAgIGxvZyhlLmRhdGEpOworICAgIH0sIGZhbHNlKTsKK30KKwordGVzdERv bWFpbigpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2gtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi5iOTkxNmEzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDExIEBACitUZXN0cyB0aGUgYmVoYXZpb3Igb2Ygd2hpdGVsaXN0aW5n IG9yaWdpbnMgdXNpbmcgZXhhY3QgbWF0Y2hpbmcuCisKK1Rlc3Rpbmc6IGh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3luYykKK1BBU1M6IFBB U1MKK1Rlc3Rpbmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJj ZXMvZ2V0LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCitUZXN0aW5nOiBodHRwOi8vbG9DQUxob3N0 OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNTOiBQQVNT CitUZXN0aW5nOiBodHRwOi8vbG9DQUxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2gu aHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRl bGlzdGluZy1leGFjdC1tYXRjaC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmIzNWU5ZGUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbApAQCAtMCww ICsxLDYwIEBACis8cD5UZXN0cyB0aGUgYmVoYXZpb3Igb2Ygd2hpdGVsaXN0aW5nIG9yaWdpbnMg dXNpbmcgZXhhY3QgbWF0Y2hpbmcuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxz Y3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29u dHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RB Y2Nlc3NGcm9tT3JpZ2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cCIsICJsb2NhbGhv c3QiLCBmYWxzZSk7CisKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5v ZGUobWVzc2FnZSArICdcbicpKTsKK30KKworZnVuY3Rpb24gdGVzdCh1cmwsIGV4cGVjdFN1Y2Nl c3MpCit7CisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIg cmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFs c2UpOworICAgIHRyeSB7CisgICAgICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coKGV4 cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOwor ICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIg OiAiUEFTUzogIikgKyBlKTsKKyAgICB9CisKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAi IChhc3luYykiKTsKKyAgICByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3Bl bigiR0VUIiwgdXJsLCB0cnVlKTsKKyAgICByZXEub25sb2FkID0gZnVuY3Rpb24oKSB7CisgICAg ICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQQVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3Bv bnNlVGV4dCk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEub25lcnJvciA9 IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQ QVNTOiAiKSArIHJlcS5zdGF0dXMpOworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAg cmVxLnNlbmQobnVsbCk7Cit9CisKK3ZhciB0ZXN0cyA9IFsKKyAgICBbImh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdLAorICAgIFsi aHR0cDovL2xvQ0FMaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0Iiwg dHJ1ZV0KKyAgICAvLyBGSVhNRTogSXMgaXQgcG9zc2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2lu ZyB0ZXN0cz8KKyAgICAvLyBbImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMS94bWxodHRwcmVxdWVzdC9y ZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNlXSwKKyAgICAvLyBbImh0dHA6Ly9mb28ubG9jYWxob3N0 OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0sCisgICAgLy8g WyJodHRwczovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IiwgZmFsc2VdCitdOworCit2YXIgY3VycmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVz dCgpCit7CisgICAgaWYgKGN1cnJlbnRUZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0 LmFwcGx5KG51bGwsIHRlc3RzW2N1cnJlbnRUZXN0KytdKTsKKyAgICBlbHNlCisgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKK30KKworbmV4dFRlc3QoKTsKKzwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9v cmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTMzYzRhOAotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitUZXN0cyB0aGF0 IG9yaWdpbiB3aGl0ZWxpc3RpbmcgZm9yIGh0dHBzIGRvZXMgbm90IG1hdGNoIGh0dHAgVVJMcy4K KworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNl cy9nZXQudHh0IChzeW5jKQorUEFTUzogRXJyb3I6IE5FVFdPUktfRVJSOiBYTUxIdHRwUmVxdWVz dCBFeGNlcHRpb24gMTAxCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJl cXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogMAorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aHR0cHMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1odHRwcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjEwZTYwNmUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMuaHRtbApAQCAtMCwwICsxLDU3 IEBACis8cD5UZXN0cyB0aGF0IG9yaWdpbiB3aGl0ZWxpc3RpbmcgZm9yIGh0dHBzIGRvZXMgbm90 IG1hdGNoIGh0dHAgVVJMcy48L3A+CisKKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlw dD4KK2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RDb250cm9s bGVyLndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFjY2Vz c0Zyb21PcmlnaW4oImh0dHA6Ly8xMjcuMC4wLjE6ODAwMCIsICJodHRwcyIsICJsb2NhbGhvc3Qi LCBmYWxzZSk7CisKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUo bWVzc2FnZSArICdcbicpKTsKK30KKworZnVuY3Rpb24gdGVzdCh1cmwsIGV4cGVjdFN1Y2Nlc3Mp Cit7CisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIgcmVx ID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFsc2Up OworICAgIHRyeSB7CisgICAgICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coKGV4cGVj dFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOworICAg IH0gY2F0Y2ggKGUpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAi UEFTUzogIikgKyBlKTsKKyAgICB9CisKKyAgICBsb2coIlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChh c3luYykiKTsKKyAgICByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICByZXEub3Blbigi R0VUIiwgdXJsLCB0cnVlKTsKKyAgICByZXEub25sb2FkID0gZnVuY3Rpb24oKSB7CisgICAgICAg IGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQQVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNl VGV4dCk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEub25lcnJvciA9IGZ1 bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNT OiAiKSArIHJlcS5zdGF0dXMpOworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVx LnNlbmQobnVsbCk7Cit9CisKK3ZhciB0ZXN0cyA9IFsKKyAgICBbImh0dHA6Ly9sb2NhbGhvc3Q6 ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNlXQorICAgIC8vIEZJ WE1FOiBJcyBpdCBwb3NzaWJsZSB0byBzZXR1cCB0aGUgZm9sbG93aW5nIHRlc3RzPworICAgIC8v IFsiaHR0cHM6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4 dCIsIHRydWVdCitdOworCit2YXIgY3VycmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVz dCgpCit7CisgICAgaWYgKGN1cnJlbnRUZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0 LmFwcGx5KG51bGwsIHRlc3RzW2N1cnJlbnRUZXN0KytdKTsKKyAgICBlbHNlCisgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKK30KKworbmV4dFRlc3QoKTsKKzwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9v cmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVz c2VzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMDk5 NDc0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy1leHBlY3RlZC50eHQKQEAgLTAs MCArMSw3IEBACitUZXN0cyBvcmlnaW4gd2hpdGVsaXN0aW5nIHdpdGggSVAgYWRkcmVzc2VzLgor CitUZXN0aW5nOiBodHRwOi8vMTI3LjAuMC4xOjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2dldC50eHQgKHN5bmMpCitQQVNTOiBQQVNTCitUZXN0aW5nOiBodHRwOi8vMTI3LjAuMC4xOjgw MDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUwor CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2RlNjgzMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1h ZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK1Nw ZWNpZnlpbmcgdGhhdCBhbiBJUCBhZGRyZXNzIHNob3VsZCBtYXRjaCBzdWJkb21haW5zIGRvZXNu J3QgbWFrZSBzZW5zZS4gVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgaXQgZG9lc24ndCBkbyBhbnl0 aGluZy4KKworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChzeW5jKQorRkFJTDogRXJyb3I6IE5FVFdPUktfRVJSOiBYTUxIdHRw UmVxdWVzdCBFeGNlcHRpb24gMTAxCitUZXN0aW5nOiBodHRwOi8vMTI3LjAuMC4xOjgwMDAveG1s aHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKGFzeW5jKQorRkFJTDogMAorCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13 aXRoLXN1YmRvbWFpbnMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44 NTBkMTYyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRw cmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMu aHRtbApAQCAtMCwwICsxLDIyIEBACis8cD5TcGVjaWZ5aW5nIHRoYXQgYW4gSVAgYWRkcmVzcyBz aG91bGQgbWF0Y2ggc3ViZG9tYWlucyBkb2Vzbid0IG1ha2Ugc2Vuc2UuIFRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGl0IGRvZXNuJ3QgZG8gYW55dGhpbmcuPC9wPgorPHByZSBpZD0iY29uc29sZSI+ PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5 b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIu d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigiaHR0cDovL2xvY2FsaG9zdDo4MDAwIiwgImh0dHAi LCAiKi4wLjAuMSIsIHRydWUpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0 ZVRleHROb2RlKG1lc3NhZ2UgKyAnXG4nKSk7Cit9CisKK3ZhciBpZnJhbWUgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KCJpZnJhbWUiKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaWZyYW1l KTsKK2lmcmFtZS5zcmMgPSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKK3dpbmRv dy5hZGRFdmVudExpc3RlbmVyKCJtZXNzYWdlIiwgZnVuY3Rpb24oZSkgeworICAgIGlmIChlLmRh dGEgPT0gIkRPTkUiKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7 CisgICAgZWxzZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0Pgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmEzYTNhZjcKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaXAtYWRkcmVzc2VzLmh0bWwKQEAgLTAsMCArMSwyMiBAQAorPHA+VGVzdHMgb3JpZ2luIHdo aXRlbGlzdGluZyB3aXRoIElQIGFkZHJlc3Nlcy48L3A+Cis8cHJlIGlkPSJjb25zb2xlIj48L3By ZT4KKzxzY3JpcHQ+CitsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRU ZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiaHR0cCIsICIx MjcuMC4wLjEiLCBmYWxzZSk7CisKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRl VGV4dE5vZGUobWVzc2FnZSArICdcbicpKTsKK30KKwordmFyIGlmcmFtZSA9IGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoImlmcmFtZSIpOworZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChpZnJhbWUp OworaWZyYW1lLnNyYyA9ICJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzcy10ZXN0Lmh0bWwiOword2luZG93 LmFkZEV2ZW50TGlzdGVuZXIoIm1lc3NhZ2UiLCBmdW5jdGlvbihlKSB7CisgICAgaWYgKGUuZGF0 YSA9PSAiRE9ORSIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsK KyAgICBlbHNlCisgICAgICAgIGxvZyhlLmRhdGEpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13 aGl0ZWxpc3Rpbmctc3ViZG9tYWlucy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmctc3ViZG9tYWlucy1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2U2MmU0ZQotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK1Rl c3RzIG9yaWdpbiB3aGl0ZWxpc3Rpbmcgc3ViZG9tYWluIGJlaGF2aW9yLgorCitUZXN0aW5nOiBo dHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5 bmMpCitQQVNTOiBQQVNTCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJl cXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKGFzeW5jKQorUEFTUzogUEFTUworCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctc3ViZG9tYWlucy5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42MTYxMGU0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMu aHRtbApAQCAtMCwwICsxLDU5IEBACis8cD5UZXN0cyBvcmlnaW4gd2hpdGVsaXN0aW5nIHN1YmRv bWFpbiBiZWhhdmlvci48L3A+CisKKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgorPHNjcmlwdD4K K2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RDb250cm9sbGVy LndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW4oImh0dHA6Ly8xMjcuMC4wLjE6ODAwMCIsICJodHRwIiwgImxvY2FsaG9zdCIsIHRy dWUpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQorewor ICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5l dyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAg ICB0cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNj ZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNh dGNoIChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6 ICIpICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMp Iik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIs IHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2co KGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQp OworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlv bigpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikg KyByZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5k KG51bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8vIEZJWE1FOiBJ cyBpdCBwb3NzaWJsZSB0byBzZXR1cCB0aGUgZm9sbG93aW5nIHRlc3RzPworICAgIC8vIFsiaHR0 cDovL2Zvby5sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIs IHRydWVdCisgICAgLy8gWyJodHRwOi8vYmFyLmZvby5sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVx dWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisgICAgLy8gWyJodHRwOi8vZm9vbG9jYWxo b3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KK107CisK K3ZhciBjdXJyZW50VGVzdCA9IDA7CisKK2Z1bmN0aW9uIG5leHRUZXN0KCkKK3sKKyAgICBpZiAo Y3VycmVudFRlc3QgPCB0ZXN0cy5sZW5ndGgpCisgICAgICAgIHRlc3QuYXBwbHkobnVsbCwgdGVz dHNbY3VycmVudFRlc3QrK10pOworICAgIGVsc2UKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOworfQorCituZXh0VGVzdCgpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L3dpbi9Ta2lwcGVkCmluZGV4IDdhMTYyZjMuLjUyODY5ZjAgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9T a2lwcGVkCkBAIC02NDAsMyArNjQwLDExIEBAIG1lZGlhL3ZpZGVvLXBsYXllZC1jb2xsYXBzZS5o dG1sCiAjIFRoZXNlIHR3byBjcmFzaCBmcm9tIHRoZSBzYW1lIHJlZ3Jlc3Npb24uCiBtZWRpYS91 bnN1cHBvcnRlZC1ydHNwLmh0bWwKIG1lZGlhL3ZpZGVvLXNvdXJjZS1lcnJvci5odG1sCisKKyMg TWlzc2luZyBMYXlvdXRUZXN0Q29udHJvbGxlciBpbXBsZW1lbnRhdGlvbgoraHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5odG1sCitodHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbAoraHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKK2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRt bAoraHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJl c3Nlcy13aXRoLXN1YmRvbWFpbnMuaHRtbAoraHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmln aW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMuaHRtbApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFu Z2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1MTc1MDg5Li40ODBjMjc0IDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDMzIEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2Vi S2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZv ciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICBUZXN0czogaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5odG1sCisgICAgICAgICAgICAg ICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctZXhhY3QtbWF0 Y2guaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5z Lmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94 bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMuaHRtbAorCisgICAg ICAgICogV2ViQ29yZS5iYXNlLmV4cDogRXhwb3J0IG1ldGhvZHMgdG8gbWFuaXB1bGF0ZSBvcmln aW4gYWNjZXNzIHdoaXRlbGlzdHMgdG8gZW5hYmxlCisgICAgICAgIHRlc3RpbmcgdmlhIGxheW91 dCB0ZXN0cy4KKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6IEFk ZCBPcmlnaW5BY2Nlc3NFbnRyeS4qCisgICAgICAgICogR05VbWFrZWZpbGUuYW06IERpdHRvLgor ICAgICAgICAqIFdlYkNvcmUuZ3lwaTogRGl0dG8uCisgICAgICAgICogV2ViQ29yZS5wcm86IERp dHRvLgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qOiBEaXR0by4KKyAg ICAgICAgKiBXZWJDb3JlU291cmNlcy5ibGs6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6b3Jp Z2luQWNjZXNzTWFwKTogSW1wbGVtZW50IG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAg ICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0KTogRGl0dG8uCisgICAgICAg IChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERp dHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNz V2hpdGVMaXN0cyk6IERpdHRvLgorICAgICAgICAqIHBhZ2UvU2VjdXJpdHlPcmlnaW4uaDogRGl0 dG8uCisgICAgICAgICogcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oOiBEaXR0by4KKyAgICAgICAg KiBwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcDogRGl0dG8uCisKIDIwMDktMDgtMTggIEtlbnQg VGFtdXJhICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVyaWMg U2VpZGVsLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05V bWFrZWZpbGUuYW0KaW5kZXggZTIyNDBmNy4uZmY3ODk5YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9H TlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xMzA0LDYgKzEz MDQsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuaCBc CiAJV2ViQ29yZS9wYWdlL05hdmlnYXRvckJhc2UuY3BwIFwKIAlXZWJDb3JlL3BhZ2UvTmF2aWdh dG9yQmFzZS5oIFwKKwlXZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuaCBcCisJV2ViQ29y ZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcCBcCiAJV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIFwK IAlXZWJDb3JlL3BhZ2UvUGFnZS5oIFwKIAlXZWJDb3JlL3BhZ2UvUGFnZUdyb3VwLmNwcCBcCmRp ZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAgYi9XZWJDb3JlL1dlYkNvcmUuYmFz ZS5leHAKaW5kZXggMmU3NzNlNi4uN2IzMzZjZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3Jl LmJhc2UuZXhwCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cApAQCAtMzEzLDYgKzMxMyw5 IEBAIF9fWk43V2ViQ29yZTE0UmVzb3VyY2VMb2FkZXIxNGNhbmNlbGxlZEVycm9yRXYKIF9fWk43 V2ViQ29yZTE0UmVzb3VyY2VMb2FkZXIxOXNldFNob3VsZEJ1ZmZlckRhdGFFYgogX19aTjdXZWJD b3JlMTRTZWN1cml0eU9yaWdpbjI0cmVnaXN0ZXJVUkxTY2hlbWVBc0xvY2FsRVJLTlNfNlN0cmlu Z0UKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFCitfX1pO N1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luMTZjcmVhdGVGcm9tU3RyaW5nRVJLTlNfNlN0cmluZ0UK K19fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4yN3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0 c0V2CitfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luMjV3aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luRVJLUzBfUktOU182U3RyaW5nRVM1X2IKIF9fWk43V2ViQ29yZTE1QXJjaGl2ZVJlc291cmNl NmNyZWF0ZUVOM1dURjEwUGFzc1JlZlB0cklOU18xMlNoYXJlZEJ1ZmZlckVFRVJLTlNfNEtVUkxF UktOU182U3RyaW5nRVNBX1NBX1JLTlNfMTZSZXNvdXJjZVJlc3BvbnNlRQogX19aTjdXZWJDb3Jl MTVCYWNrRm9yd2FyZExpc3QxMHJlbW92ZUl0ZW1FUE5TXzExSGlzdG9yeUl0ZW1FCiBfX1pON1dl YkNvcmUxNUJhY2tGb3J3YXJkTGlzdDEwc2V0RW5hYmxlZEViCmRpZmYgLS1naXQgYS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDFkN2ZhNmMuLjIwZWY0 YTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29y ZS5neXBpCkBAIC0xNjUyLDYgKzE2NTIsOCBAQAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9y LmgnLAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9yQmFzZS5jcHAnLAogICAgICAgICAgICAg J3BhZ2UvTmF2aWdhdG9yQmFzZS5oJywKKyAgICAgICAgICAgICdwYWdlL09yaWdpbkFjY2Vzc0Vu dHJ5LmNwcCcsCisgICAgICAgICAgICAncGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oJywKICAgICAg ICAgICAgICdwYWdlL1BhZ2UuY3BwJywKICAgICAgICAgICAgICdwYWdlL1BhZ2UuaCcsCiAgICAg ICAgICAgICAncGFnZS9QYWdlR3JvdXAuY3BwJywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29y ZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IDVlZWFkYjcuLmNiYjBlNmEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAt MTEwOCw2ICsxMTA4LDcgQEAgU09VUkNFUyArPSBcCiAgICAgcGFnZS9IaXN0b3J5LmNwcCBcCiAg ICAgcGFnZS9Mb2NhdGlvbi5jcHAgXAogICAgIHBhZ2UvTW91c2VFdmVudFdpdGhIaXRUZXN0UmVz dWx0cy5jcHAgXAorICAgIHBhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwIFwKICAgICBwYWdlL1Bh Z2UuY3BwIFwKICAgICBwYWdlL1BhZ2VHcm91cC5jcHAgXAogICAgIHBhZ2UvUGFnZUdyb3VwTG9h ZERlZmVycmVyLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCA5 ZDA4YjU2Li44ZjhmOWNkIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAg LTE2OTg5LDYgKzE2OTg5LDE0IEBACiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KKwkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHBhZ2VcT3JpZ2luQWNjZXNzRW50cnkuY3BwIg0KKwkJCQk+DQor CQkJPC9GaWxlPg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccGFnZVxPcmlnaW5B Y2Nlc3NFbnRyeS5oIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0 aXZlUGF0aD0iLi5ccGFnZVxQYWdlLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1n aXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDkxN2JlZTkuLmNmZTM3YWUg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisr KyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMSw2ICsy MSw4IEBACiAvKiBFbmQgUEJYQWdncmVnYXRlVGFyZ2V0IHNlY3Rpb24gKi8KIAogLyogQmVnaW4g UEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KKwkJMDAxNDYwQUQxMDNDOEEyRTAwMEIyMERCIC8qIE9y aWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDAwMTQ2MEFCMTAzQzhBMkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5j cHAgKi87IH07CisJCTAwMTQ2MEFFMTAzQzhBMkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRy eS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDAxNDYw QUMxMDNDOEEyRTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmggKi87IH07CiAJCTA2MDI3 Q0FEMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250ZXh0TWVudUl0ZW0uaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDA2MDI3Q0FDMEIxQ0JGQzAwMDg4NEIyRCAv KiBDb250ZXh0TWVudUl0ZW0uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRl LCApOyB9OyB9OwogCQkwNjAyN0NCMzBCMUNDMDNEMDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVt TWFjLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDYw MjdDQjIwQjFDQzAzRDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbU1hYy5tbSAqLzsgfTsKIAkJ MDYyMjg3ODQwQjREQjMyMjAwMEMzNERGIC8qIEZvY3VzRGlyZWN0aW9uLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwNjIyODc4MzBCNERCMzIyMDAwQzM0 REYgLyogRm9jdXNEaXJlY3Rpb24uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OwpAQCAtNTAwNSw2ICs1MDA3LDggQEAKIC8qIEVuZCBQQlhDb3B5RmlsZXNC dWlsZFBoYXNlIHNlY3Rpb24gKi8KIAogLyogQmVnaW4gUEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9u ICovCisJCTAwMTQ2MEFCMTAzQzhBMkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTAwMTQ2MEFDMTAzQzhBMkUwMDBCMjBE QiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBPcmlnaW5BY2Nlc3NFbnRyeS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwNjAy N0NBQzBCMUNCRkMwMDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVtLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBDb250ZXh0TWVudUl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJMDYwMjdDQjIwQjFDQzAzRDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbU1h Yy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBDb250ZXh0TWVu dUl0ZW1NYWMubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTA2MjI4NzgzMEI0REIz MjIwMDBDMzRERiAvKiBGb2N1c0RpcmVjdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gRm9jdXNEaXJlY3Rpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAg LTEwNjc5LDYgKzEwNjgzLDggQEAKIAkJCQlBOUM2RTY1RDBENzQ2Njk0MDA2NDQyRTkgLyogTmF2 aWdhdG9yLmlkbCAqLywKIAkJCQlFMTI3MTlDOTBFRUVDMjEzMDBGNjEyMTMgLyogTmF2aWdhdG9y QmFzZS5jcHAgKi8sCiAJCQkJRTEyNzE5QzYwRUVFQzE2ODAwRjYxMjEzIC8qIE5hdmlnYXRvckJh c2UuaCAqLywKKwkJCQkwMDE0NjBBQjEwM0M4QTJFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50 cnkuY3BwICovLAorCQkJCTAwMTQ2MEFDMTAzQzhBMkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NF bnRyeS5oICovLAogCQkJCTY1RkVBODY4MDk4MzNBREUwMEJFRDRBQiAvKiBQYWdlLmNwcCAqLywK IAkJCQk2NUEyMTQ2NzA5N0EzMjkxMDBCOTA1MEEgLyogUGFnZS5oICovLAogCQkJCTkzMDJCMEJD MEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwICovLApAQCAtMTczMTIsNiArMTczMTgs NyBAQAogCQkJCTQxNkUyOUE2MTAyRkE5NjIwMDdGQzE0RSAvKiBXb3JrZXJSZXBvcnRpbmdQcm94 eS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQjVDMTEyM0MxMDJCNkM0NjAwMDk2NTc4IC8qIFNRTFRy YW5zYWN0aW9uQ29vcmRpbmF0b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCUQ4QjYxNTJGMTAzMjQ5 NTEwMEM4NTU0QSAvKiBDb29raWUuaCBpbiBIZWFkZXJzICovLAorCQkJCTAwMTQ2MEFFMTAzQzhB MkUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwog CQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0xOTM3 OCw2ICsxOTM4NSw3IEBACiAJCQkJOTM5MjI2MkQxMDMyMTA3QjAwNkU3RDVEIC8qIEpTSFRNTENh bnZhc0VsZW1lbnRDdXN0b20uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJOTM5MjI2MkYxMDMyMTA4 NDAwNkU3RDVEIC8qIEpTQ1NTUnVsZUxpc3RDdXN0b20uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ QjVDMTEyM0IxMDJCNkM0NjAwMDk2NTc4IC8qIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3Bw IGluIFNvdXJjZXMgKi8sCisJCQkJMDAxNDYwQUQxMDNDOEEyRTAwMEIyMERCIC8qIE9yaWdpbkFj Y2Vzc0VudHJ5LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3lt ZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3Jl U291cmNlcy5ia2wgYi9XZWJDb3JlL1dlYkNvcmVTb3VyY2VzLmJrbAppbmRleCBhNDBjMmIxLi5m MWRjYTM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmVTb3VyY2VzLmJrbAorKysgYi9XZWJD b3JlL1dlYkNvcmVTb3VyY2VzLmJrbApAQCAtNzY2LDYgKzc2Niw3IEBAIFRoaXMgZmlsZSBjb250 YWlucyB0aGUgbGlzdCBvZiBmaWxlcyBuZWVkZWQgdG8gYnVpbGQgV2ViQ29yZS4KICAgICAgICAg cGFnZS9Nb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzLmNwcAogICAgICAgICBwYWdlL05hdmln YXRvci5jcHAKICAgICAgICAgcGFnZS9OYXZpZ2F0b3JCYXNlLmNwcAorICAgICAgICBwYWdlL09y aWdpbkFjY2Vzc0VudHJ5LmNwcAogICAgICAgICBwYWdlL1BhZ2UuY3BwCiAgICAgICAgIHBhZ2Uv UGFnZUdyb3VwLmNwcAogICAgICAgICBwYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5jcHAgYi9XZWJDb3JlL3Bh Z2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmMwZTkyZmUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNz RW50cnkuY3BwCkBAIC0wLDAgKzEsODAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5l aXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUg bmFtZXMgb2YKKyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdp dGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBB TkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJ TUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJM RSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwor ICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJDVHlwZS5oIgorI2luY2x1ZGUgIk9yaWdpbkFjY2Vzc0VudHJ5LmgiCisKKyNpbmNsdWRlICJT ZWN1cml0eU9yaWdpbi5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCitPcmlnaW5BY2Nl c3NFbnRyeTo6T3JpZ2luQWNjZXNzRW50cnkoY29uc3QgU3RyaW5nJiBwcm90b2NvbCwgY29uc3Qg U3RyaW5nJiBob3N0LCBTdWJkb21haW5TZXR0aW5nIHN1YmRvbWFpblNldHRpbmcpCisgICAgOiBt X3Byb3RvY29sKHByb3RvY29sLmxvd2VyKCkpCisgICAgLCBtX2hvc3QoaG9zdC5sb3dlcigpKQor ICAgICwgbV9hbGxvd1N1YmRvbWFpbnMoc3ViZG9tYWluU2V0dGluZykKK3sKKyAgICBBU1NFUlQo bV9wcm90b2NvbCA9PSAiaHR0cCIgfHwgbV9wcm90b2NvbCA9PSAiaHR0cHMiKTsKKyAgICBBU1NF UlQoc3ViZG9tYWluU2V0dGluZyA9PSBBbGxvd1N1YmRvbWFpbnMgfHwgc3ViZG9tYWluU2V0dGlu ZyA9PSBEaXNhbGxvd1N1YmRvbWFpbnMpOworCisgICAgLy8gQXNzdW1lIHRoYXQgYW55IGhvc3Qg dGhhdCBlbmRzIHdpdGggYSBkaWdpdCBpcyB0cnlpbmcgdG8gYmUgYW4gSVAgYWRkcmVzcy4KKyAg ICBtX2hvc3RJc0lQQWRkcmVzcyA9ICFtX2hvc3QuaXNFbXB0eSgpICYmIGlzQVNDSUlEaWdpdCht X2hvc3RbbV9ob3N0Lmxlbmd0aCgpIC0gMV0pOworfQorCitib29sIE9yaWdpbkFjY2Vzc0VudHJ5 OjptYXRjaGVzT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBvcmlnaW4pIGNvbnN0Cit7Cisg ICAgQVNTRVJUKG9yaWdpbi5ob3N0KCkgPT0gb3JpZ2luLmhvc3QoKS5sb3dlcigpKTsKKyAgICBB U1NFUlQob3JpZ2luLnByb3RvY29sKCkgPT0gb3JpZ2luLnByb3RvY29sKCkubG93ZXIoKSk7CisK KyAgICBpZiAobV9wcm90b2NvbCAhPSBvcmlnaW4ucHJvdG9jb2woKSkKKyAgICAgICAgcmV0dXJu IGZhbHNlOworICAgIAorICAgIC8vIFNwZWNpYWwgY2FzZTogSW5jbHVkZSBzdWJkb21haW5zIGFu ZCBlbXB0eSBob3N0IG1lYW5zICJhbGwgaG9zdHMsIGluY2x1ZGluZyBpcCBhZGRyZXNzZXMiLgor ICAgIGlmIChtX2FsbG93U3ViZG9tYWlucyA9PSBBbGxvd1N1YmRvbWFpbnMgJiYgbV9ob3N0Lmlz RW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gRXhhY3QgbWF0Y2gu CisgICAgaWYgKG1faG9zdCA9PSBvcmlnaW4uaG9zdCgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICAKKyAgICAvLyBPdGhlcndpc2Ugd2UgY2FuIG9ubHkgbWF0Y2ggaWYgd2UncmUgbWF0Y2hp bmcgc3ViZG9tYWlucy4KKyAgICBpZiAobV9hbGxvd1N1YmRvbWFpbnMgPT0gRGlzYWxsb3dTdWJk b21haW5zKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAgLy8gRG9uJ3QgdHJ5IHRv IGRvIHN1YmRvbWFpbiBtYXRjaGluZyBvbiBJUCBhZGRyZXNzZXMuCisgICAgaWYgKG1faG9zdElz SVBBZGRyZXNzKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAgLy8gTWF0Y2ggc3Vi ZG9tYWlucy4KKyAgICBpZiAob3JpZ2luLmhvc3QoKS5sZW5ndGgoKSA+IG1faG9zdC5sZW5ndGgo KSAmJiBvcmlnaW4uaG9zdCgpW29yaWdpbi5ob3N0KCkubGVuZ3RoKCkgLSBtX2hvc3QubGVuZ3Ro KCkgLSAxXSA9PSAnLicgJiYgb3JpZ2luLmhvc3QoKS5lbmRzV2l0aChtX2hvc3QpKQorICAgICAg ICByZXR1cm4gdHJ1ZTsKKyAgICAKKyAgICByZXR1cm4gZmFsc2U7Cit9CisgICAgCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50 cnkuaCBiL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmM4NzdiOGQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3Bh Z2UvT3JpZ2luQWNjZXNzRW50cnkuaApAQCAtMCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBw bGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVU T1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIENyb3NzT3Jp Z2luQWNjZXNzX2gKKyNkZWZpbmUgQ3Jvc3NPcmlnaW5BY2Nlc3NfaAorCisjaW5jbHVkZSAiUGxh dGZvcm1TdHJpbmcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTZWN1cml0eU9y aWdpbjsKKworY2xhc3MgT3JpZ2luQWNjZXNzRW50cnkgeworcHVibGljOgorICAgIGVudW0gU3Vi ZG9tYWluU2V0dGluZyB7CisgICAgICAgIEFsbG93U3ViZG9tYWlucywKKyAgICAgICAgRGlzYWxs b3dTdWJkb21haW5zCisgICAgfTsKKworICAgIE9yaWdpbkFjY2Vzc0VudHJ5KGNvbnN0IFN0cmlu ZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9zdCwgU3ViZG9tYWluU2V0dGluZyk7CisgICAg Ym9vbCBtYXRjaGVzT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJikgY29uc3Q7CisgICAgCitw cml2YXRlOgorICAgIFN0cmluZyBtX3Byb3RvY29sOworICAgIFN0cmluZyBtX2hvc3Q7CisgICAg U3ViZG9tYWluU2V0dGluZyBtX2FsbG93U3ViZG9tYWluczsKKyAgICBib29sIG1faG9zdElzSVBB ZGRyZXNzOworICAgIAorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8g Q3Jvc3NPcmlnaW5BY2Nlc3NfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3Jp Z2luLmNwcCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKaW5kZXggODI3NGUwZS4u ZDViNjllNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAorKysg Yi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCkBAIC0zMSwxMSArMzEsMjEgQEAKIAog I2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUg Ik9yaWdpbkFjY2Vzc0VudHJ5LmgiCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgPHd0Zi9T dGRMaWJFeHRyYXMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit0eXBlZGVmIFZlY3RvcjxP cmlnaW5BY2Nlc3NFbnRyeT4gT3JpZ2luQWNjZXNzV2hpdGVMaXN0OwordHlwZWRlZiBIYXNoTWFw PFN0cmluZywgT3JpZ2luQWNjZXNzV2hpdGVMaXN0Kj4gT3JpZ2luQWNjZXNzTWFwOworCitzdGF0 aWMgT3JpZ2luQWNjZXNzTWFwJiBvcmlnaW5BY2Nlc3NNYXAoKQoreworICAgIERFRklORV9TVEFU SUNfTE9DQUwoT3JpZ2luQWNjZXNzTWFwLCBvcmlnaW5BY2Nlc3NNYXAsICgpKTsKKyAgICByZXR1 cm4gb3JpZ2luQWNjZXNzTWFwOworfQorCiBzdGF0aWMgVVJMU2NoZW1lc01hcCYgbG9jYWxTY2hl bWVzKCkKIHsKICAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFVSTFNjaGVtZXNNYXAsIGxvY2FsU2No ZW1lcywgKCkpOwpAQCAtMTk4LDcgKzIwOCwxNyBAQCBib29sIFNlY3VyaXR5T3JpZ2luOjpjYW5S ZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCkgY29uc3QKIAogICAgIC8vIFdlIGNhbGwgaXNTYW1lU2No ZW1lSG9zdFBvcnQgaGVyZSBpbnN0ZWFkIG9mIGNhbkFjY2VzcyBiZWNhdXNlIHdlIHdhbnQKICAg ICAvLyB0byBpZ25vcmUgZG9jdW1lbnQuZG9tYWluIGVmZmVjdHMuCi0gICAgcmV0dXJuIGlzU2Ft ZVNjaGVtZUhvc3RQb3J0KHRhcmdldE9yaWdpbi5nZXQoKSk7CisgICAgaWYgKGlzU2FtZVNjaGVt ZUhvc3RQb3J0KHRhcmdldE9yaWdpbi5nZXQoKSkpCisgICAgICAgIHJldHVybiB0cnVlOworCisg ICAgaWYgKE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9yaWdpbkFjY2Vzc01hcCgpLmdl dCh0b1N0cmluZygpKSkgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGxpc3QtPnNp emUoKTsgKytpKSB7CisgICAgICAgICAgICBpZiAobGlzdC0+YXQoaSkubWF0Y2hlc09yaWdpbigq dGFyZ2V0T3JpZ2luKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQor ICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKIH0KIAogdm9pZCBTZWN1cml0eU9yaWdpbjo6Z3Jh bnRMb2FkTG9jYWxSZXNvdXJjZXMoKQpAQCAtNDE0LDQgKzQzNCwyNiBAQCBib29sIFNlY3VyaXR5 T3JpZ2luOjpzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29uc3QgU3RyaW5nJiBzY2hl bWUpCiAgICAgcmV0dXJuIG5vQWNjZXNzU2NoZW1lcygpLmNvbnRhaW5zKHNjaGVtZSk7CiB9CiAK K3ZvaWQgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgU2Vj dXJpdHlPcmlnaW4mIHNvdXJjZU9yaWdpbiwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblByb3Rv Y29sLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9uRG9tYWlucywgYm9vbCBhbGxvd0Rlc3RpbmF0 aW9uU3ViZG9tYWlucykKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VS VCghc291cmNlT3JpZ2luLmlzRW1wdHkoKSk7CisKKyAgICBTdHJpbmcgc291cmNlU3RyaW5nID0g c291cmNlT3JpZ2luLnRvU3RyaW5nKCk7CisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0 ID0gb3JpZ2luQWNjZXNzTWFwKCkuZ2V0KHNvdXJjZVN0cmluZyk7CisgICAgaWYgKCFsaXN0KSB7 CisgICAgICAgIGxpc3QgPSBuZXcgT3JpZ2luQWNjZXNzV2hpdGVMaXN0OworICAgICAgICBvcmln aW5BY2Nlc3NNYXAoKS5zZXQoc291cmNlU3RyaW5nLCBsaXN0KTsKKyAgICB9CisgICAgbGlzdC0+ YXBwZW5kKE9yaWdpbkFjY2Vzc0VudHJ5KGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9u RG9tYWlucywgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMgPyBPcmlnaW5BY2Nlc3NFbnRyeTo6 QWxsb3dTdWJkb21haW5zIDogT3JpZ2luQWNjZXNzRW50cnk6OkRpc2FsbG93U3ViZG9tYWlucykp OworfQorCit2b2lkIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMo KQoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgT3JpZ2luQWNjZXNzTWFwJiBt YXAgPSBvcmlnaW5BY2Nlc3NNYXAoKTsKKyAgICBkZWxldGVBbGxWYWx1ZXMobWFwKTsKKyAgICBt YXAuY2xlYXIoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmggYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4u aAppbmRleCAzMzVlZDI4Li5jYzJhY2RkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJp dHlPcmlnaW4uaAorKysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaApAQCAtMTQxLDYg KzE0MSw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RhdGljIHZvaWQgcmVnaXN0 ZXJVUkxTY2hlbWVBc05vQWNjZXNzKGNvbnN0IFN0cmluZyYpOwogICAgICAgICBzdGF0aWMgYm9v bCBzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29uc3QgU3RyaW5nJik7CiAKKyAgICAg ICAgc3RhdGljIHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBTZWN1cml0eU9y aWdpbiYgc291cmNlT3JpZ2luLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNv bnN0IFN0cmluZyYgZGVzdGluYXRpb25Eb21haW5zLCBib29sIGFsbG93RGVzdGluYXRpb25TdWJk b21haW5zKTsKKyAgICAgICAgc3RhdGljIHZvaWQgcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Rz KCk7CisKICAgICBwcml2YXRlOgogICAgICAgICBleHBsaWNpdCBTZWN1cml0eU9yaWdpbihjb25z dCBLVVJMJik7CiAgICAgICAgIGV4cGxpY2l0IFNlY3VyaXR5T3JpZ2luKGNvbnN0IFNlY3VyaXR5 T3JpZ2luKik7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsv Q2hhbmdlTG9nCmluZGV4IDZmNjY1MmUuLmI4ODdmZmMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv Q2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIw MDktMDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50 cyB0bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9y aWdpbiBYSFIgYWNjZXNzLgorCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwOgor ICAgICAgICAod2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29yaWdpbik6IEFkZCBBUEkgdG8g bWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMuCisgICAgICAgICh3ZWJraXRfcmVz ZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9saXN0cyk6IERpdHRvLgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRwcml2YXRlLmg6IERpdHRvLgorCiAyMDA5LTA4LTE1ICBaYW4gRG9iZXJzZWsgIDx6YW5k b2JlcnNla0BnbWFpbC5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6LgpkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCA3NTViNGQzLi40YjNjNjVjIDEwMDY0NAot LS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlJl c291cmNlSGFuZGxlQ2xpZW50LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5o IgogI2luY2x1ZGUgPHJ1bnRpbWUvSW5pdGlhbGl6ZVRocmVhZGluZy5oPgorI2luY2x1ZGUgIlNl Y3VyaXR5T3JpZ2luLmgiCiAKICNpZiBFTkFCTEUoREFUQUJBU0UpCiAjaW5jbHVkZSAiRGF0YWJh c2VUcmFja2VyLmgiCkBAIC0xNzgsMyArMTc5LDEzIEBAIHZvaWQgd2Via2l0X2luaXQoKQogICAg IHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBzbmlmZmVyKTsKICAgICBnX29iamVj dF91bnJlZihzbmlmZmVyKTsKIH0KKwordm9pZCB3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9f b3JpZ2luKGNvbnN0IGdjaGFyKiBzb3VyY2VPcmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlv blByb3RvY29sLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGlu YXRpb25TdWJkb21haW5zKQoreworICAgIFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NU b09yaWdpbihTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhzb3VyY2VPcmlnaW4pLCBk ZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhvc3QsIGFsbG93RGVzdGluYXRpb25TdWJk b21haW5zKTsKK30KKwordm9pZCB3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9saXN0 cygpCit7CisgICAgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygp OworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDBjM2ZiZDMuLjQ1ZGU2MTIgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTI1MCw2ICsyNTAsMTIgQEAgZXh0ZXJuICJD IiB7CiAKICAgICBXRUJLSVRfQVBJIHZvaWQKICAgICB3ZWJraXRfYXBwbGljYXRpb25fY2FjaGVf c2V0X21heGltdW1fc2l6ZSh1bnNpZ25lZCBsb25nIGxvbmcgc2l6ZSk7CisgICAgCisgICAgV0VC S0lUIEFQSSB2b2lkCisgICAgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29yaWdpbihjb25z dCBnY2hhciogc291cmNlT3JpZ2luLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Qcm90b2NvbCwg Y29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9t YWlucyk7CisgICAgCisgICAgV0VCS0lUIEFQSSB2b2lkCisgICAgd2Via2l0X3Jlc2V0X29yaWdp bl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQv bWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IGU0YzFhYjEuLmFhOGJh MTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9tYWMvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDktMDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92 aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBn cmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIgYWNjZXNzLgorCisgICAgICAgICog V2ViVmlldy9XZWJWaWV3Lm1tOiBBZGQgU1BJIHRvIG1hbmlwdWxhdGUgb3JpZ2luIGFjY2VzcyB3 aGl0ZWxpc3RzLgorICAgICAgICAoK1tXZWJWaWV3IF93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu OmRlc3RpbmF0aW9uUHJvdG9jb2w6ZGVzdGluYXRpb25Ib3N0OmFsbG93RGVzdGluYXRpb25TdWJk b21haW5zOl0pOiBEaXR0by4KKyAgICAgICAgKCtbV2ViVmlldyBfcmVzZXRPcmlnaW5BY2Nlc3NX aGl0ZUxpc3RzXSk6IERpdHRvLgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlld1ByaXZhdGUuaDog RGl0dG8uCisKIDIwMDktMDgtMTcgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dl YlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCmluZGV4IDNh M2NiNTkuLmYxNmIyNzUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1t CisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0yMDkyLDYgKzIwOTIsMTUg QEAgc3RhdGljIGlubGluZSBJTVAgZ2V0TWV0aG9kKGlkIG8sIFNFTCBzKQogICAgIHJldHVybiBf cHJpdmF0ZSA/IF9wcml2YXRlLT5pbnNlcnRpb25QYXN0ZWJvYXJkIDogbmlsOwogfQogCisrICh2 b2lkKV93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOihOU1N0cmluZyAqKXNvdXJjZU9yaWdpbiBk ZXN0aW5hdGlvblByb3RvY29sOihOU1N0cmluZyAqKWRlc3RpbmF0aW9uUHJvdG9jb2wgZGVzdGlu YXRpb25Ib3N0OihOU1N0cmluZyAqKWRlc3RpbmF0aW9uSG9zdCBhbGxvd0Rlc3RpbmF0aW9uU3Vi ZG9tYWluczooQk9PTClhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucworeworICAgIFNlY3VyaXR5 T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCpTZWN1cml0eU9yaWdpbjo6Y3JlYXRl RnJvbVN0cmluZyhzb3VyY2VPcmlnaW4pLCBkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlv bkhvc3QsIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30KKworKyh2b2lkKV9yZXNldE9y aWdpbkFjY2Vzc1doaXRlTGlzdHMKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5B Y2Nlc3NXaGl0ZUxpc3RzKCk7Cit9CiAKIC0gKHZvaWQpX3VwZGF0ZUFjdGl2ZVN0YXRlCiB7CmRp ZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaCBiL1dlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCmluZGV4IDM2MmIyZTYuLjZjNDcyZDYgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCisrKyBiL1dlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCkBAIC00NDMsNiArNDQzLDE1IEBAIENvdWxkIGJl IHdvcnRoIGFkZGluZyB0byB0aGUgQVBJLgogLy8gV2hpY2ggcGFzdGVib2FyZCB0ZXh0IGlzIGNv bWluZyBmcm9tIGluIGVkaXRpbmcgZGVsZWdhdGUgbWV0aG9kcyBzdWNoIGFzIHNob3VsZEluc2Vy dE5vZGUuCiAtIChOU1Bhc3RlYm9hcmQgKilfaW5zZXJ0aW9uUGFzdGVib2FyZDsKIAorLy8gV2hp dGVsaXN0cyBhY2Nlc3MgZnJvbSBhbiBvcmlnaW4gKHNvdXJjZU9yaWdpbikgdG8gYSBzZXQgb2Yg b25lIG9yIG1vcmUgb3JpZ2lucyBkZXNjcmliZWQgYnkgdGhlIHBhcmFtZXRlcnM6CisvLyAtIGRl c3RpbmF0aW9uUHJvdG9jb2w6IFRoZSBwcm90b2NvbCB0byBncmFudCBhY2Nlc3MgdG8uCisvLyAt IGRlc3RpbmF0aW9uSG9zdDogVGhlIGhvc3QgdG8gZ3JhbnQgYWNjZXNzIHRvLgorLy8gLSBhbGxv d0Rlc3RpbmF0aW9uU3ViZG9tYWluczogSWYgaG9zdCBpcyBhIGRvbWFpbiwgc2V0dGluZyB0aGlz IHRvIFlFUyB3aWxsIHdoaXRlbGlzdCBob3N0IGFuZCBhbGwgaXRzIHN1YmRvbWFpbnMsIHJlY3Vy c2l2ZWx5LgorKyAodm9pZClfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbjooTlNTdHJpbmcgKilz b3VyY2VPcmlnaW4gZGVzdGluYXRpb25Qcm90b2NvbDooTlNTdHJpbmcgKilkZXN0aW5hdGlvblBy b3RvY29sIGRlc3RpbmF0aW9uSG9zdDooTlNTdHJpbmcgKilkZXN0aW5hdGlvbkhvc3QgYWxsb3dE ZXN0aW5hdGlvblN1YmRvbWFpbnM6KEJPT0wpYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnM7CisK Ky8vIFJlbW92ZXMgYWxsIHdoaXRlIGxpc3QgZW50cmllcyBjcmVhdGVkIHdpdGggX3doaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4uCisrICh2b2lkKV9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHM7 CisKIEBlbmQKIAogQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpbnRpbmdQcml2YXRlKQpk aWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwIGIvV2ViS2l0 L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCmluZGV4IGIzMDA1YzIuLmZjZTlhOTkgMTAw NjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcAorKysgYi9XZWJL aXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKQEAgLTIzNSwzICsyMzUsMTIgQEAgUVN0 cmluZ0xpc3QgUVdlYlNlY3VyaXR5T3JpZ2luOjpsb2NhbFNjaGVtZXMoKQogICAgIHJldHVybiBs aXN0OwogfQogCit2b2lkIFFXZWJTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9y aWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0 aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rl c3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0 aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworfQorCit2b2lkIFFXZWJTZWN1 cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCkKK3sKKyAgICBTZWN1cml0 eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7Cit9CmRpZmYgLS1naXQgYS9X ZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2Vj dXJpdHlvcmlnaW4uaAppbmRleCAxNmY4YmMxLi4wNTU2Yjg5IDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3Vy aXR5b3JpZ2luLmgKQEAgLTQwLDYgKzQwLDggQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIGFk ZExvY2FsU2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVtZSk7CiAgICAgc3RhdGljIHZvaWQgcmVt b3ZlTG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYgc2NoZW1lKTsKICAgICBzdGF0aWMgUVN0cmlu Z0xpc3QgbG9jYWxTY2hlbWVzKCk7CisgICAgc3RhdGljIHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJv bU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJpbmcmIGRlc3Rp bmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxv d0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgc3RhdGljIHZvaWQgY2xlYXJPcmlnaW5BY2Nl c3NXaGl0ZUxpc3RzKCk7CiAKICAgICB+UVdlYlNlY3VyaXR5T3JpZ2luKCk7CiAKZGlmZiAtLWdp dCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDVjYThj MWEuLjViYmI5YzAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0 L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFu ICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1 MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBh IG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAg ICAgICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwOiBBZGQgQVBJIHRvIG1hbmlwdWxhdGUg b3JpZ2luIGFjY2VzcyB3aGl0ZWxpc3RzLgorICAgICAgICAoUVdlYlNlY3VyaXR5T3JpZ2luOjp3 aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0dG8uCisgICAgICAgIChRV2ViU2VjdXJpdHlP cmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cyk6IERpdHRvLgorICAgICAgICAqIEFw aS9xd2Vic2VjdXJpdHlvcmlnaW4uaDogRGl0dG8uCisKIDIwMDktMDgtMTcgIERhcmluIEFkbGVy ICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFRyeSB0byBmaXggUXQgYnVpbGQgYWdhaW4u CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VM b2cKaW5kZXggZDdmMWU4My4uZWUyYjFiYSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdl TG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDA5LTA4 LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8K KyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4g WEhSIGFjY2Vzcy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmNwcDogRXhwb3NlIHdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKSB0byBsYXlvdXQgdGVz dHMuCisgICAgICAgICh3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luQ2FsbGJhY2spOiBEaXR0by4K KyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOiBEaXR0by4K KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOiBEaXR0by4K KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3Bw OiBEaXR0by4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NU b09yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0 Q29udHJvbGxlck1hYy5tbTogRGl0dG8uCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJU cmVlL3F0L2pzb2JqZWN0cy5jcHA6IERpdHRvLgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwOiBTdHViIG91dCB3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKCkuCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hp dGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVl L2d0ay9EdW1wUmVuZGVyVHJlZS5jcHA6IFJlc2V0IG9yaWdpbiBhY2Nlc3MgbGlzdHMgYmVmb3Jl IGVhY2ggdGVzdC4KKyAgICAgICAgKHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZyk6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVy VHJlZS5tbTogRGl0dG8uCisgICAgICAgIChyZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJl Zm9yZVRlc3RpbmcpOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVu ZGVyVHJlZS5jcHA6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6RHVtcFJlbmRlclRyZWU6OnJl c2V0VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKTogRGl0dG8uCisKIDIwMDktMDgtMTcg IFNoaW5pY2hpcm8gSGFtYWppICA8aGFtYWppQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZp ZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCBmODY0MGZhLi43MDQwOTE3IDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAK KysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CkBAIC04NzQsNiArODc0LDI0IEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHdhaXRGb3JQb2xpY3lEZWxl Z2F0ZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlCiAgICAgcmV0dXJu IEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiB3 aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpT T2JqZWN0UmVmLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwg Y29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQorewor ICAgIGlmIChhcmd1bWVudENvdW50ICE9IDQpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVu ZGVmaW5lZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBzb3VyY2VP cmlnaW4oQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBl eGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworICAgIEpTUmV0YWluUHRyPEpT U3RyaW5nUmVmPiBkZXN0aW5hdGlvblByb3RvY29sKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5 KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0 aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gZGVzdGluYXRpb25Ib3N0KEFkb3B0 LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1syXSwgZXhjZXB0aW9uKSk7 CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBib29sIGFsbG93RGVzdGluYXRpb25TdWJk b21haW5zID0gSlNWYWx1ZVRvQm9vbGVhbihjb250ZXh0LCBhcmd1bWVudHNbM10pOworCisgICAg TGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRUZXN0 Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJv bGxlci0+d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihzb3VyY2VPcmlnaW4uZ2V0KCksIGRlc3Rp bmF0aW9uUHJvdG9jb2wuZ2V0KCksIGRlc3RpbmF0aW9uSG9zdC5nZXQoKSwgYWxsb3dEZXN0aW5h dGlvblN1YmRvbWFpbnMpOworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0 KTsKK30KKwogLy8gU3RhdGljIFZhbHVlcwogCiBzdGF0aWMgSlNWYWx1ZVJlZiBnZXRHbG9iYWxG bGFnQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIHRoaXNPYmplY3Qs IEpTU3RyaW5nUmVmIHByb3BlcnR5TmFtZSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQpAQCAtMTAx NCw2ICsxMDMyLDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0 YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgIndhaXRGb3JQb2xpY3lEZWxlZ2F0ZSIsIHdhaXRG b3JQb2xpY3lEZWxlZ2F0ZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIndhaXRVbnRpbERv bmUiLCB3YWl0VW50aWxEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAid2luZG93Q291 bnQiLCB3aW5kb3dDb3VudENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAgIHsgIndoaXRlTGlzdEFj Y2Vzc0Zyb21PcmlnaW4iLCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luQ2FsbGJhY2ssIGtKU1By b3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUg fSwKICAgICAgICAgeyAwLCAwLCAwIH0KICAgICB9OwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCA4YWViZWQ0Li5kN2JhMzVj IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmgKQEAgLTE3OCw3ICsxNzgsOSBAQCBwdWJsaWM6CiAgICAgYm9vbCBwYXVzZUFuaW1hdGlv bkF0VGltZU9uRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBhbmltYXRpb25OYW1lLCBkb3VibGUg dGltZSwgSlNTdHJpbmdSZWYgZWxlbWVudElkKTsKICAgICBib29sIHBhdXNlVHJhbnNpdGlvbkF0 VGltZU9uRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBwcm9wZXJ0eU5hbWUsIGRvdWJsZSB0aW1l LCBKU1N0cmluZ1JlZiBlbGVtZW50SWQpOwogICAgIHVuc2lnbmVkIG51bWJlck9mQWN0aXZlQW5p bWF0aW9ucygpIGNvbnN0OwotICAgIAorCisgICAgdm9pZCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Qcm90 b2NvbCwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25T dWJkb21haW5zKTsKKwogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFzVGV4dDsKICAgICBib29s IG1fZHVtcEFzUERGOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3Rr L0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1w UmVuZGVyVHJlZS5jcHAKaW5kZXggNGYzMDQ5ZS4uNDJkZjVlMCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC02Miw2ICs2Miw3 IEBAIGV4dGVybiB2b2lkIHdlYmtpdF93ZWJfc2V0dGluZ3NfYWRkX2V4dHJhX3BsdWdpbl9kaXJl Y3RvcnkoV2ViS2l0V2ViVmlldyogdmlldywKIGV4dGVybiBnY2hhciogd2Via2l0X3dlYl9mcmFt ZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiBleHRlcm4g dm9pZCB3ZWJraXRfd2ViX2ZyYW1lX2NsZWFyX21haW5fZnJhbWVfbmFtZShXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogZXh0ZXJuIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldF9ncm91cF9uYW1lKFdl YktpdFdlYlZpZXcqIHZpZXcsIGNvbnN0IGdjaGFyKiBncm91cE5hbWUpOworZXh0ZXJuIHZvaWQg d2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKIH0KIAogdm9sYXRpbGUg Ym9vbCBkb25lOwpAQCAtMjgwLDYgKzI4MSw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1Rv Q29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAKICAgICBXZWJLaXRXZWJJbnNwZWN0b3Iq IGluc3BlY3RvciA9IHdlYmtpdF93ZWJfdmlld19nZXRfaW5zcGVjdG9yKHdlYlZpZXcpOwogICAg IGdfb2JqZWN0X3NldChHX09CSkVDVChpbnNwZWN0b3IpLCAiamF2YXNjcmlwdC1wcm9maWxpbmct ZW5hYmxlZCIsIEZBTFNFLCBOVUxMKTsKKworICAgIHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNz X3doaXRlX2xpc3RzKCk7CiB9CiAKIHZvaWQgZHVtcCgpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAppbmRl eCBmMDNjYzgwLi4yYmE1MWVhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKQEAgLTQ4LDYgKzQ4LDcg QEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGNvbnN0IGdjaGFyKiBuYW1lLAogYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3Ry YW5zaXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogbmFtZSwgZG91Ymxl IHRpbWUsIGNvbnN0IGdjaGFyKiBlbGVtZW50KTsKIHVuc2lnbmVkIGludCB3ZWJraXRfd2ViX2Zy YW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwog dm9pZCB3ZWJraXRfYXBwbGljYXRpb25fY2FjaGVfc2V0X21heGltdW1fc2l6ZSh1bnNpZ25lZCBs b25nIGxvbmcgc2l6ZSk7Cit2b2lkIHdlYmtpdF93aGl0ZV9saXN0X2FjY2Vzc190b19vcmlnaW4o Y29uc3QgZ2NoYXIqIHNvdXJjZU9yaWdpbiwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uUHJvdG9j b2wsIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1 YmRvbWFpbnMpOwogfQogCiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6fkxheW91dFRlc3RDb250cm9s bGVyKCkKQEAgLTE2Myw2ICsxNjQsMTQgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2Fp dEZvclBvbGljeURlbGVnYXRlKCkKICAgICBzZXRXYWl0VG9EdW1wKHRydWUpOwogfQogCit2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihKU1N0cmluZ1Jl ZiBzb3VyY2VPcmlnaW4sIEpTU3RyaW5nUmVmIHByb3RvY29sLCBKU1N0cmluZ1JlZiBob3N0LCBi b29sIGluY2x1ZGVTdWJkb21haW5zKQoreworICAgIGdjaGFyKiBzb3VyY2VPcmlnaW5HQ2hhciA9 IEpTU3RyaW5nQ29weVVURjhDU3RyaW5nKHNvdXJjZU9yaWdpbik7CisgICAgZ2NoYXIqIHByb3Rv Y29sR0NoYXIgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhwcm90b2NvbCk7CisgICAgZ2NoYXIq IGhvc3RHQ2hhciA9IEpTU3RyaW5nQ29weVVURjhDU3RyaW5nKGhvc3QpOworICAgIHdlYmtpdF93 aGl0ZV9saXN0X2FjY2Vzc190b19vcmlnaW4oc291cmNlT3JpZ2luR0NoYXIsIHByb3RvY29sR0No YXIsIGhvc3RHQ2hhciwgaW5jbHVkZVN1YmRvbWFpbnMpOworfQorCiB2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpzZXRNYWluRnJhbWVJc0ZpcnN0UmVzcG9uZGVyKGJvb2wgZmxhZykKIHsKICAg ICAvLyBGSVhNRTogaW1wbGVtZW50CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvRHVtcFJlbmRlclRyZWUubW0KaW5kZXggMGFjZmY3Ny4uODA1NTcyMiAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtMTA4Miw2 ICsxMDgyLDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZv cmVUZXN0aW5nKCkKICAgICBbW1ttYWluRnJhbWUgd2ViVmlld10gaW5zcGVjdG9yXSBzZXRKYXZh U2NyaXB0UHJvZmlsaW5nRW5hYmxlZDpOT107CiAKICAgICBbV2ViVmlldyBfc2V0VXNlc1Rlc3RN b2RlRm9jdXNSaW5nQ29sb3I6WUVTXTsKKyAgICBbV2ViVmlldyBfcmVzZXRPcmlnaW5BY2Nlc3NX aGl0ZUxpc3RzXTsKIH0KIAogc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBzdHJpbmcmIHRlc3RQ YXRoT3JVUkwpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv TGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggYTA5M2RmZC4uZTQwZGM1YiAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29u dHJvbGxlck1hYy5tbQpAQCAtNDM3LDMgKzQzNywxNCBAQCB2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogICAgIFtwb2xpY3lEZWxlZ2F0ZSBzZXRDb250 cm9sbGVyVG9Ob3RpZnlEb25lOnRoaXNdOwogICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIHNldFBv bGljeURlbGVnYXRlOnBvbGljeURlbGVnYXRlXTsKIH0KKwordm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihKU1N0cmluZ1JlZiBzb3VyY2VPcmlnaW4s IEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9u SG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBSZXRhaW5QdHI8 Q0ZTdHJpbmdSZWY+IHNvdXJjZU9yaWdpbkNGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5n KGtDRkFsbG9jYXRvckRlZmF1bHQsIHNvdXJjZU9yaWdpbikpOworICAgIE5TU3RyaW5nICpzb3Vy Y2VPcmlnaW5OUyA9IChOU1N0cmluZyAqKXNvdXJjZU9yaWdpbkNGLmdldCgpOworICAgIFJldGFp blB0cjxDRlN0cmluZ1JlZj4gcHJvdG9jb2xDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmlu ZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBkZXN0aW5hdGlvblByb3RvY29sKSk7CisgICAgTlNTdHJp bmcgKmRlc3RpbmF0aW9uUHJvdG9jb2xOUyA9IChOU1N0cmluZyAqKXByb3RvY29sQ0YuZ2V0KCk7 CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBob3N0Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5 Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgZGVzdGluYXRpb25Ib3N0KSk7CisgICAgTlNT dHJpbmcgKmRlc3RpbmF0aW9uSG9zdE5TID0gKE5TU3RyaW5nICopaG9zdENGLmdldCgpOworICAg IFtXZWJWaWV3IF93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOnNvdXJjZU9yaWdpbk5TIGRlc3Rp bmF0aW9uUHJvdG9jb2w6ZGVzdGluYXRpb25Qcm90b2NvbE5TIGRlc3RpbmF0aW9uSG9zdDpkZXN0 aW5hdGlvbkhvc3ROUyBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczphbGxvd0Rlc3RpbmF0aW9u U3ViZG9tYWluc107Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9x dC9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9EdW1w UmVuZGVyVHJlZS5jcHAKaW5kZXggMTY3YTRjNS4uNWUzMDlmNCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtMjE4LDYgKzIxOCw3 IEBAIHZvaWQgRHVtcFJlbmRlclRyZWU6OnJlc2V0VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0 aW5nKCkKICAgICAvL1dvcmtRdWV1ZTo6c2hhcmVkKCktPnNldEZyb3plbihmYWxzZSk7CiAKICAg ICBtX2NvbnRyb2xsZXItPnJlc2V0KCk7CisgICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpyZXNldE9y aWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZTo6b3Blbihj b25zdCBRVXJsJiBhdXJsKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv cXQvanNvYmplY3RzLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2JqZWN0 cy5jcHAKaW5kZXggYzllN2I4NC4uNGJlZjNiOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9xdC9qc29iamVjdHMuY3BwCkBAIC0zMzcsNiArMzM3LDExIEBAIHZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OmNsZWFyQWxsRGF0YWJhc2VzKCkKICAgICBRV2ViRGF0YWJhc2U6OnJlbW92 ZUFsbERhdGFiYXNlcygpOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcmIHNvdXJjZU9yaWdpbiwgY29uc3QgUVN0 cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgUVN0cmluZyYgZGVzdGluYXRpb25Ib3N0 LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQoreworICAgIFNlY3VyaXR5T3JpZ2lu Ojp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKHNvdXJjZU9yaWdpbiwgZGVzdGluYXRpb25Qcm90 b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7Cit9CisK IEV2ZW50U2VuZGVyOjpFdmVudFNlbmRlcihRV2ViUGFnZSAqcGFyZW50KQogICAgIDogUU9iamVj dChwYXJlbnQpCiB7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv d2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAppbmRleCBlY2QwODZlLi5kZWQ2MGJkIDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRy b2xsZXJXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRU ZXN0Q29udHJvbGxlcldpbi5jcHAKQEAgLTc5NywzICs3OTcsOCBAQCB1bnNpZ25lZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6bnVtYmVyT2ZBY3RpdmVBbmltYXRpb25zKCkgY29uc3QKIAogICAgIHJl dHVybiBudW1iZXI7CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFj Y2Vzc0Zyb21PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNlT3JpZ2luLCBKU1N0cmluZ1JlZiBkZXN0 aW5hdGlvblByb3RvY29sLCBKU1N0cmluZ1JlZiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dE ZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAgcHJpbnRmKCJMYXlvdXRUZXN0Q29udHJvbGxl cjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbiBub3QgaW1wbGVtZW50ZWRcbiIpOworfQo= 35166 2009-08-19 17:39:03 -0700 2009-08-19 18:20:47 -0700 rebase patch to HEAD patch.txt text/plain 52040 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlZGE4Nzc4Li4xYjkyMWUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTkgIFJ5b3N1a2UgTml3YSAgPHJu aXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctYWxsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEyYmE0MmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctYWxs LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDExIEBACitUZXN0cyB0aGUgc3BlY2lhbCBjYXNlIG9m IHdoaXRlbGlzdGluZyBhbGwgb3JpZ2lucy4KKworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4 MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUwor VGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9n ZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAw MC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3luYykKK1BBU1M6IFBBU1MKK1Rl c3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0 LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMDc4NWUxCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC5odG1sCkBAIC0wLDAgKzEsNTYgQEAKKzxwPlRlc3RzIHRoZSBzcGVj aWFsIGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLjwvcD4KKworPHByZSBpZD0iY29u c29sZSI+PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OworbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwg Imh0dHAiLCAiIiwgdHJ1ZSk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NG cm9tT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiaHR0cCIsICIiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0RG9tYWluKCkKK3sKKyAgICB2YXIgdXJsID0gImh0dHA6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCI7CisgICAg bG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIgcmVxID0gbmV3IFhN TEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFsc2UpOworICAgIHRy eSB7CisgICAgICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coIlBBU1M6ICIgKyByZXEu cmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNoIChlKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IGUpOworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOwor ICAgIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmws IHRydWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKCJQQVNT OiAiICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgICAgIHRlc3RJUEFkZHJlc3MoKTsKKyAgICB9 OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IHJlcS5zdGF0dXMpOworICAgICAgICB0ZXN0SVBBZGRyZXNzKCk7CisgICAgfTsKKyAgICByZXEu c2VuZChudWxsKTsKK30KKworZnVuY3Rpb24gdGVzdElQQWRkcmVzcygpCit7CisgICAgdmFyIGlm cmFtZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImlmcmFtZSIpOworICAgIGRvY3VtZW50LmJv ZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKKyAgICBpZnJhbWUuc3JjID0gImh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1h ZGRyZXNzLXRlc3QuaHRtbCI7CisgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoIm1lc3NhZ2Ui LCBmdW5jdGlvbihlKSB7CisgICAgICAgIGlmIChlLmRhdGEgPT0gIkRPTkUiKQorICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICBlbHNlCisgICAg ICAgICAgICBsb2coZS5kYXRhKTsKKyAgICB9LCBmYWxzZSk7Cit9CisKK3Rlc3REb21haW4oKTsK Kzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFj dC1tYXRjaC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u Yjk5MTZhMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwxMSBAQAorVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5z IHVzaW5nIGV4YWN0IG1hdGNoaW5nLgorCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNTOiBQQVNTCitUZXN0 aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50 eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUworVGVzdGlu ZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct ZXhhY3QtbWF0Y2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMzVl OWRlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwKQEAgLTAsMCArMSw2MCBA QAorPHA+VGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5zIHVzaW5nIGV4 YWN0IG1hdGNoaW5nLjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0Pgor bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIu d2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNzRnJv bU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHAiLCAibG9jYWxob3N0IiwgZmFs c2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQorewor ICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5l dyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAg ICB0cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNj ZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNh dGNoIChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6 ICIpICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMp Iik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIs IHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2co KGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQp OworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlv bigpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikg KyByZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5k KG51bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXSwKKyAgICBbImh0dHA6Ly9s b0NBTGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisg ICAgLy8gRklYTUU6IElzIGl0IHBvc3NpYmxlIHRvIHNldHVwIHRoZSBmb2xsb3dpbmcgdGVzdHM/ CisgICAgLy8gWyJodHRwOi8vbG9jYWxob3N0OjgwMDEveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2dldC50eHQiLCBmYWxzZV0sCisgICAgLy8gWyJodHRwOi8vZm9vLmxvY2FsaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdLAorICAgIC8vIFsiaHR0cHM6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUzM2M0YTgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgdGhhdCBvcmlnaW4g d2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBodHRwIFVSTHMuCisKK1Rlc3Rp bmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4 dCAoc3luYykKK1BBU1M6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3QgRXhjZXB0 aW9uIDEwMQorVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaHR0cHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMGU2 MDZlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKQEAgLTAsMCArMSw1NyBAQAorPHA+ VGVzdHMgdGhhdCBvcmlnaW4gd2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBo dHRwIFVSTHMuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0 VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cHMiLCAibG9jYWxob3N0IiwgZmFsc2Up OworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2Ug KyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQoreworICAg IGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBY TUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0 cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNz ID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNo IChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIp ICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMpIik7 CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVy bCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4 cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOwor ICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigp IHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyBy ZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5kKG51 bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1s aHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KKyAgICAvLyBGSVhNRTogSXMg aXQgcG9zc2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHBz Oi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDA5OTQ3NAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBA QAorVGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyB3aXRoIElQIGFkZHJlc3Nlcy4KKworVGVzdGlu ZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0 dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVs aXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmNkZTY4MzIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LXdpdGgtc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitTcGVjaWZ5aW5n IHRoYXQgYW4gSVAgYWRkcmVzcyBzaG91bGQgbWF0Y2ggc3ViZG9tYWlucyBkb2Vzbid0IG1ha2Ug c2Vuc2UuIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGl0IGRvZXNuJ3QgZG8gYW55dGhpbmcuCisK K1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv Z2V0LnR4dCAoc3luYykKK0ZBSUw6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3Qg RXhjZXB0aW9uIDEwMQorVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1 ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK0ZBSUw6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlw LWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJk b21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODUwZDE2Mgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSwyMiBAQAorPHA+U3BlY2lmeWluZyB0aGF0IGFuIElQIGFkZHJlc3Mgc2hvdWxkIG1h dGNoIHN1YmRvbWFpbnMgZG9lc24ndCBtYWtlIHNlbnNlLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhh dCBpdCBkb2Vzbid0IGRvIGFueXRoaW5nLjwvcD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgor PHNjcmlwdD4KK2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RD b250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIiouMC4w LjEiLCB0cnVlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9k ZShtZXNzYWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgiaWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJh bWUuc3JjID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZl bnRMaXN0ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJE T05FIikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIGVs c2UKKyAgICAgICAgbG9nKGUuZGF0YSk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1pcC1hZGRyZXNzZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5hM2EzYWY3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy5odG1sCkBAIC0wLDAgKzEsMjIgQEAKKzxwPlRlc3RzIG9yaWdpbiB3aGl0ZWxpc3Rp bmcgd2l0aCBJUCBhZGRyZXNzZXMuPC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2Ny aXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbigiaHR0cDovL2xvY2FsaG9zdDo4MDAwIiwgImh0dHAiLCAiMTI3LjAuMC4x IiwgZmFsc2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2Rl KG1lc3NhZ2UgKyAnXG4nKSk7Cit9CisKK3ZhciBpZnJhbWUgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJpZnJhbWUiKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKK2lmcmFt ZS5zcmMgPSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9v cmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKK3dpbmRvdy5hZGRFdmVu dExpc3RlbmVyKCJtZXNzYWdlIiwgZnVuY3Rpb24oZSkgeworICAgIGlmIChlLmRhdGEgPT0gIkRP TkUiKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZWxz ZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlNjJlNGUKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3Rpbmctc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitUZXN0cyBvcmln aW4gd2hpdGVsaXN0aW5nIHN1YmRvbWFpbiBiZWhhdmlvci4KKworVGVzdGluZzogaHR0cDovL2xv Y2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFT UzogUEFTUworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uNjE2MTBlNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSw1OSBAQAorPHA+VGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyBzdWJkb21haW4gYmVo YXZpb3IuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50 aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu KCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cCIsICJsb2NhbGhvc3QiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0KHVybCwgZXhwZWN0U3VjY2VzcykKK3sKKyAgICBsb2co IlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEgPSBuZXcgWE1MSHR0 cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7CisgICAgdHJ5IHsK KyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQ QVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgfSBjYXRjaCAoZSkg eworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNTOiAiKSArIGUp OworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOworICAg IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIHRy dWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKChleHBlY3RT dWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAg ICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7Cisg ICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsgcmVxLnN0 YXR1cyk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEuc2VuZChudWxsKTsK K30KKwordmFyIHRlc3RzID0gWworICAgIFsiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHBy ZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAvLyBGSVhNRTogSXMgaXQgcG9z c2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHA6Ly9mb28u bG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQor ICAgIC8vIFsiaHR0cDovL2Jhci5mb28ubG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8vIFsiaHR0cDovL2Zvb2xvY2FsaG9zdDo4MDAw L3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdCitdOworCit2YXIgY3Vy cmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVzdCgpCit7CisgICAgaWYgKGN1cnJlbnRU ZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0LmFwcGx5KG51bGwsIHRlc3RzW2N1cnJl bnRUZXN0KytdKTsKKyAgICBlbHNlCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlm eURvbmUoKTsKK30KKworbmV4dFRlc3QoKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tp cHBlZAppbmRleCA4MTM3NDMxLi5hOTA0NTE3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93aW4vU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZApA QCAtNjM2LDMgKzYzNiwxMiBAQCBtZWRpYS92aWRlby1zb3VyY2UtZXJyb3IuaHRtbAogCiAjIDxo dHRwOi8vd2Via2l0Lm9yZy9iLzI4NDY3PgogaHR0cC90ZXN0cy9sb2FkaW5nL3ByZWxvYWQtaW1n LXRlc3QuaHRtbAorCisjIE1pc3NpbmcgTGF5b3V0VGVzdENvbnRyb2xsZXIgaW1wbGVtZW50YXRp b24KK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRt bAoraHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1h dGNoLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy5odG1sCitodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRl bGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKK2h0dHAvdGVzdHMveG1s aHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKKwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjNmVlMDAw Li4xZDZmZjIzIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDMzIEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFA Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJv dmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUg Z3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICBU ZXN0czogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5o dG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKKyAgICAgICAgICAgICAg IGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbAorICAgICAgICAg ICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDogRXhwb3J0IG1ldGhvZHMg dG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMgdG8gZW5hYmxlCisgICAgICAg IHRlc3RpbmcgdmlhIGxheW91dCB0ZXN0cy4KKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2o6IEFkZCBPcmlnaW5BY2Nlc3NFbnRyeS4qCisgICAgICAgICogR05VbWFr ZWZpbGUuYW06IERpdHRvLgorICAgICAgICAqIFdlYkNvcmUuZ3lwaTogRGl0dG8uCisgICAgICAg ICogV2ViQ29yZS5wcm86IERpdHRvLgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUu dmNwcm9qOiBEaXR0by4KKyAgICAgICAgKiBXZWJDb3JlU291cmNlcy5ibGs6IERpdHRvLgorICAg ICAgICAoV2ViQ29yZTo6b3JpZ2luQWNjZXNzTWFwKTogSW1wbGVtZW50IG9yaWdpbiBhY2Nlc3Mg d2hpdGVsaXN0cy4KKyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0 KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46 OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cyk6IERpdHRvLgorICAgICAgICAqIHBhZ2UvU2Vj dXJpdHlPcmlnaW4uaDogRGl0dG8uCisgICAgICAgICogcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5o OiBEaXR0by4KKyAgICAgICAgKiBwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcDogRGl0dG8uCisK IDIwMDktMDgtMTkgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBEYXZpZCBIeWF0dCBhbmQgRGFuIEJlcm5zdGVpbi4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4 IGM0M2U2ZjguLjQ5YWI2NWUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysr IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTMwMCw2ICsxMzAwLDggQEAgd2ViY29yZV9z b3VyY2VzICs9IFwKIAlXZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmggXAogCVdlYkNvcmUvcGFnZS9O YXZpZ2F0b3JCYXNlLmNwcCBcCiAJV2ViQ29yZS9wYWdlL05hdmlnYXRvckJhc2UuaCBcCisJV2Vi Q29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmggXAorCVdlYkNvcmUvcGFnZS9PcmlnaW5BY2Nl c3NFbnRyeS5jcHAgXAogCVdlYkNvcmUvcGFnZS9QYWdlLmNwcCBcCiAJV2ViQ29yZS9wYWdlL1Bh Z2UuaCBcCiAJV2ViQ29yZS9wYWdlL1BhZ2VHcm91cC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9XZWJDb3JlLmJhc2UuZXhwIGIvV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCmluZGV4IGNmYmIy M2MuLjFkYzhiMDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAorKysgYi9X ZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKQEAgLTMxNCw2ICszMTQsOSBAQCBfX1pON1dlYkNvcmUx NFJlc291cmNlTG9hZGVyMTRjYW5jZWxsZWRFcnJvckV2CiBfX1pON1dlYkNvcmUxNFJlc291cmNl TG9hZGVyMTlzZXRTaG91bGRCdWZmZXJEYXRhRWIKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmln aW4yNHJlZ2lzdGVyVVJMU2NoZW1lQXNMb2NhbEVSS05TXzZTdHJpbmdFCiBfX1pON1dlYkNvcmUx NFNlY3VyaXR5T3JpZ2luNmNyZWF0ZUVSS05TXzRLVVJMRQorX19aTjdXZWJDb3JlMTRTZWN1cml0 eU9yaWdpbjE2Y3JlYXRlRnJvbVN0cmluZ0VSS05TXzZTdHJpbmdFCitfX1pON1dlYkNvcmUxNFNl Y3VyaXR5T3JpZ2luMjdyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHNFdgorX19aTjdXZWJDb3Jl MTRTZWN1cml0eU9yaWdpbjI1d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbkVSS1MwX1JLTlNfNlN0 cmluZ0VTNV9iCiBfX1pON1dlYkNvcmUxNUFyY2hpdmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBh c3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVSS05TXzRLVVJMRVJLTlNfNlN0cmluZ0VTQV9T QV9SS05TXzE2UmVzb3VyY2VSZXNwb25zZUUKIF9fWk43V2ViQ29yZTE1QmFja0ZvcndhcmRMaXN0 MTByZW1vdmVJdGVtRVBOU18xMUhpc3RvcnlJdGVtRQogX19aTjdXZWJDb3JlMTVCYWNrRm9yd2Fy ZExpc3QxMHNldEVuYWJsZWRFYgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA2NTExMGUyLi43YzI2YTQ2IDEwMDY0NAotLS0gYS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTY2MSw2 ICsxNjYxLDggQEAKICAgICAgICAgICAgICdwYWdlL05hdmlnYXRvci5oJywKICAgICAgICAgICAg ICdwYWdlL05hdmlnYXRvckJhc2UuY3BwJywKICAgICAgICAgICAgICdwYWdlL05hdmlnYXRvckJh c2UuaCcsCisgICAgICAgICAgICAncGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5jcHAnLAorICAgICAg ICAgICAgJ3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuaCcsCiAgICAgICAgICAgICAncGFnZS9QYWdl LmNwcCcsCiAgICAgICAgICAgICAncGFnZS9QYWdlLmgnLAogICAgICAgICAgICAgJ3BhZ2UvUGFn ZUdyb3VwLmNwcCcsCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9X ZWJDb3JlLnBybwppbmRleCBhOGQ4OTRhLi5hYmE0MzgxIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dl YkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTExMDgsNiArMTEwOCw3IEBA IFNPVVJDRVMgKz0gXAogICAgIHBhZ2UvSGlzdG9yeS5jcHAgXAogICAgIHBhZ2UvTG9jYXRpb24u Y3BwIFwKICAgICBwYWdlL01vdXNlRXZlbnRXaXRoSGl0VGVzdFJlc3VsdHMuY3BwIFwKKyAgICBw YWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcCBcCiAgICAgcGFnZS9QYWdlLmNwcCBcCiAgICAgcGFn ZS9QYWdlR3JvdXAuY3BwIFwKICAgICBwYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAgXApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1dlYkNv cmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXggMGE1YzMyYy4uOWRlMjEzMyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9X ZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0xNjk0MSw2ICsxNjk0MSwx NCBAQAogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIu LlxwYWdlXE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8 RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHBhZ2VcT3JpZ2luQWNjZXNzRW50cnkuaCINCisJ CQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHBhZ2Vc UGFnZS5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagppbmRleCBjN2M3MzY1Li44YjM0NWE1IDEwMDY0NAotLS0gYS9XZWJD b3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMjEsNiArMjEsOCBAQAogLyogRW5kIFBC WEFnZ3JlZ2F0ZVRhcmdldCBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEJ1aWxkRmlsZSBzZWN0 aW9uICovCisJCTAwMTQ2MjhBMTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwMDE0NjI4 ODEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwICovOyB9OworCQkwMDE0 NjI4QjEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMTQ2Mjg5MTAzQ0QxREUwMDBCMjBE QiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovOyB9OwogCQkwNjAyN0NBRDBCMUNCRkMwMDA4ODRC MkQgLyogQ29udGV4dE1lbnVJdGVtLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSAwNjAyN0NBQzBCMUNCRkMwMDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVt LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJMDYw MjdDQjMwQjFDQzAzRDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbU1hYy5tbSBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDA2MDI3Q0IyMEIxQ0MwM0QwMDg4 NEIyRCAvKiBDb250ZXh0TWVudUl0ZW1NYWMubW0gKi87IH07CiAJCTA2MjI4Nzg0MEI0REIzMjIw MDBDMzRERiAvKiBGb2N1c0RpcmVjdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gMDYyMjg3ODMwQjREQjMyMjAwMEMzNERGIC8qIEZvY3VzRGlyZWN0 aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAg LTUwMDYsNiArNTAwOCw4IEBACiAvKiBFbmQgUEJYQ29weUZpbGVzQnVpbGRQaGFzZSBzZWN0aW9u ICovCiAKIC8qIEJlZ2luIFBCWEZpbGVSZWZlcmVuY2Ugc2VjdGlvbiAqLworCQkwMDE0NjI4ODEw M0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gT3JpZ2luQWNjZXNzRW50cnkuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQkwMDE0NjI4OTEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNz RW50cnkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gT3JpZ2luQWNjZXNzRW50 cnkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDYwMjdDQUMwQjFDQkZDMDAwODg0 QjJEIC8qIENvbnRleHRNZW51SXRlbS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gQ29udGV4dE1lbnVJdGVtLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTA2MDI3 Q0IyMEIxQ0MwM0QwMDg4NEIyRCAvKiBDb250ZXh0TWVudUl0ZW1NYWMubW0gKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gQ29udGV4dE1lbnVJdGVtTWFjLm1tOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwNjIyODc4MzBCNERCMzIyMDAwQzM0REYgLyogRm9j dXNEaXJlY3Rpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZvY3VzRGly ZWN0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMDY4MSw2ICsxMDY4NSw4 IEBACiAJCQkJQTlDNkU2NUQwRDc0NjY5NDAwNjQ0MkU5IC8qIE5hdmlnYXRvci5pZGwgKi8sCiAJ CQkJRTEyNzE5QzkwRUVFQzIxMzAwRjYxMjEzIC8qIE5hdmlnYXRvckJhc2UuY3BwICovLAogCQkJ CUUxMjcxOUM2MEVFRUMxNjgwMEY2MTIxMyAvKiBOYXZpZ2F0b3JCYXNlLmggKi8sCisJCQkJMDAx NDYyODgxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCAqLywKKwkJCQkw MDE0NjI4OTEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuaCAqLywKIAkJCQk2 NUZFQTg2ODA5ODMzQURFMDBCRUQ0QUIgLyogUGFnZS5jcHAgKi8sCiAJCQkJNjVBMjE0NjcwOTdB MzI5MTAwQjkwNTBBIC8qIFBhZ2UuaCAqLywKIAkJCQk5MzAyQjBCQzBENzlGODI5MDBDN0VFODMg LyogUGFnZUdyb3VwLmNwcCAqLywKQEAgLTE3MzE2LDYgKzE3MzIyLDcgQEAKIAkJCQlCNUMxMTIz QzEwMkI2QzQ2MDAwOTY1NzggLyogU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIGluIEhlYWRl cnMgKi8sCiAJCQkJRDhCNjE1MkYxMDMyNDk1MTAwQzg1NTRBIC8qIENvb2tpZS5oIGluIEhlYWRl cnMgKi8sCiAJCQkJQkNGQTkzMDgxMDMzMzE5MzAwN0IyNUQxIC8qIFJlbmRlck92ZXJmbG93Lmgg aW4gSGVhZGVycyAqLywKKwkJCQkwMDE0NjI4QjEwM0NEMURFMDAwQjIwREIgLyogT3JpZ2luQWNj ZXNzRW50cnkuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50 UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMTkzODIsNiArMTkzODksNyBAQAogCQkJCTkz OTIyNjJEMTAzMjEwN0IwMDZFN0Q1RCAvKiBKU0hUTUxDYW52YXNFbGVtZW50Q3VzdG9tLmNwcCBp biBTb3VyY2VzICovLAogCQkJCTkzOTIyNjJGMTAzMjEwODQwMDZFN0Q1RCAvKiBKU0NTU1J1bGVM aXN0Q3VzdG9tLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUI1QzExMjNCMTAyQjZDNDYwMDA5NjU3 OCAvKiBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTAw MTQ2MjhBMTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgaW4gU291cmNl cyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsK IAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZVNvdXJjZXMuYmtsIGIvV2ViQ29yZS9X ZWJDb3JlU291cmNlcy5ia2wKaW5kZXggYTQwYzJiMS4uZjFkY2EzOSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9XZWJDb3JlU291cmNlcy5ia2wKKysrIGIvV2ViQ29yZS9XZWJDb3JlU291cmNlcy5ia2wK QEAgLTc2Niw2ICs3NjYsNyBAQCBUaGlzIGZpbGUgY29udGFpbnMgdGhlIGxpc3Qgb2YgZmlsZXMg bmVlZGVkIHRvIGJ1aWxkIFdlYkNvcmUuCiAgICAgICAgIHBhZ2UvTW91c2VFdmVudFdpdGhIaXRU ZXN0UmVzdWx0cy5jcHAKICAgICAgICAgcGFnZS9OYXZpZ2F0b3IuY3BwCiAgICAgICAgIHBhZ2Uv TmF2aWdhdG9yQmFzZS5jcHAKKyAgICAgICAgcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5jcHAKICAg ICAgICAgcGFnZS9QYWdlLmNwcAogICAgICAgICBwYWdlL1BhZ2VHcm91cC5jcHAKICAgICAgICAg cGFnZS9QYWdlR3JvdXBMb2FkRGVmZXJyZXIuY3BwCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2Uv T3JpZ2luQWNjZXNzRW50cnkuY3BwIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNw cApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMGU5MmZlCi0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcApAQCAtMCwwICsxLDgw IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisg KiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxl IENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAor ICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQ1R5cGUuaCIKKyNpbmNsdWRlICJP cmlnaW5BY2Nlc3NFbnRyeS5oIgorCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworICAgIAorT3JpZ2luQWNjZXNzRW50cnk6Ok9yaWdpbkFjY2Vzc0Vu dHJ5KGNvbnN0IFN0cmluZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9zdCwgU3ViZG9tYWlu U2V0dGluZyBzdWJkb21haW5TZXR0aW5nKQorICAgIDogbV9wcm90b2NvbChwcm90b2NvbC5sb3dl cigpKQorICAgICwgbV9ob3N0KGhvc3QubG93ZXIoKSkKKyAgICAsIG1fYWxsb3dTdWJkb21haW5z KHN1YmRvbWFpblNldHRpbmcpCit7CisgICAgQVNTRVJUKG1fcHJvdG9jb2wgPT0gImh0dHAiIHx8 IG1fcHJvdG9jb2wgPT0gImh0dHBzIik7CisgICAgQVNTRVJUKHN1YmRvbWFpblNldHRpbmcgPT0g QWxsb3dTdWJkb21haW5zIHx8IHN1YmRvbWFpblNldHRpbmcgPT0gRGlzYWxsb3dTdWJkb21haW5z KTsKKworICAgIC8vIEFzc3VtZSB0aGF0IGFueSBob3N0IHRoYXQgZW5kcyB3aXRoIGEgZGlnaXQg aXMgdHJ5aW5nIHRvIGJlIGFuIElQIGFkZHJlc3MuCisgICAgbV9ob3N0SXNJUEFkZHJlc3MgPSAh bV9ob3N0LmlzRW1wdHkoKSAmJiBpc0FTQ0lJRGlnaXQobV9ob3N0W21faG9zdC5sZW5ndGgoKSAt IDFdKTsKK30KKworYm9vbCBPcmlnaW5BY2Nlc3NFbnRyeTo6bWF0Y2hlc09yaWdpbihjb25zdCBT ZWN1cml0eU9yaWdpbiYgb3JpZ2luKSBjb25zdAoreworICAgIEFTU0VSVChvcmlnaW4uaG9zdCgp ID09IG9yaWdpbi5ob3N0KCkubG93ZXIoKSk7CisgICAgQVNTRVJUKG9yaWdpbi5wcm90b2NvbCgp ID09IG9yaWdpbi5wcm90b2NvbCgpLmxvd2VyKCkpOworCisgICAgaWYgKG1fcHJvdG9jb2wgIT0g b3JpZ2luLnByb3RvY29sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAKKyAgICAvLyBT cGVjaWFsIGNhc2U6IEluY2x1ZGUgc3ViZG9tYWlucyBhbmQgZW1wdHkgaG9zdCBtZWFucyAiYWxs IGhvc3RzLCBpbmNsdWRpbmcgaXAgYWRkcmVzc2VzIi4KKyAgICBpZiAobV9hbGxvd1N1YmRvbWFp bnMgPT0gQWxsb3dTdWJkb21haW5zICYmIG1faG9zdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVy biB0cnVlOworICAgIAorICAgIC8vIEV4YWN0IG1hdGNoLgorICAgIGlmIChtX2hvc3QgPT0gb3Jp Z2luLmhvc3QoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gT3RoZXJ3aXNl IHdlIGNhbiBvbmx5IG1hdGNoIGlmIHdlJ3JlIG1hdGNoaW5nIHN1YmRvbWFpbnMuCisgICAgaWYg KG1fYWxsb3dTdWJkb21haW5zID09IERpc2FsbG93U3ViZG9tYWlucykKKyAgICAgICAgcmV0dXJu IGZhbHNlOworICAgIAorICAgIC8vIERvbid0IHRyeSB0byBkbyBzdWJkb21haW4gbWF0Y2hpbmcg b24gSVAgYWRkcmVzc2VzLgorICAgIGlmIChtX2hvc3RJc0lQQWRkcmVzcykKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIAorICAgIC8vIE1hdGNoIHN1YmRvbWFpbnMuCisgICAgaWYgKG9yaWdp bi5ob3N0KCkubGVuZ3RoKCkgPiBtX2hvc3QubGVuZ3RoKCkgJiYgb3JpZ2luLmhvc3QoKVtvcmln aW4uaG9zdCgpLmxlbmd0aCgpIC0gbV9ob3N0Lmxlbmd0aCgpIC0gMV0gPT0gJy4nICYmIG9yaWdp bi5ob3N0KCkuZW5kc1dpdGgobV9ob3N0KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisg ICAgcmV0dXJuIGZhbHNlOworfQorICAgIAorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmggYi9XZWJDb3JlL3BhZ2UvT3Jp Z2luQWNjZXNzRW50cnkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jODc3 YjhkCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgK QEAgLTAsMCArMSw1OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAzLiAgTmVpdGhlciB0aGUg bmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgor ICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3Rl IHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBmcm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAq IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkK KyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9G IFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAq IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBDcm9zc09yaWdpbkFjY2Vzc19oCisjZGVmaW5lIENy b3NzT3JpZ2luQWNjZXNzX2gKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworY2xhc3MgU2VjdXJpdHlPcmlnaW47CisKK2NsYXNzIE9yaWdpbkFj Y2Vzc0VudHJ5IHsKK3B1YmxpYzoKKyAgICBlbnVtIFN1YmRvbWFpblNldHRpbmcgeworICAgICAg ICBBbGxvd1N1YmRvbWFpbnMsCisgICAgICAgIERpc2FsbG93U3ViZG9tYWlucworICAgIH07CisK KyAgICBPcmlnaW5BY2Nlc3NFbnRyeShjb25zdCBTdHJpbmcmIHByb3RvY29sLCBjb25zdCBTdHJp bmcmIGhvc3QsIFN1YmRvbWFpblNldHRpbmcpOworICAgIGJvb2wgbWF0Y2hlc09yaWdpbihjb25z dCBTZWN1cml0eU9yaWdpbiYpIGNvbnN0OworICAgIAorcHJpdmF0ZToKKyAgICBTdHJpbmcgbV9w cm90b2NvbDsKKyAgICBTdHJpbmcgbV9ob3N0OworICAgIFN1YmRvbWFpblNldHRpbmcgbV9hbGxv d1N1YmRvbWFpbnM7CisgICAgYm9vbCBtX2hvc3RJc0lQQWRkcmVzczsKKyAgICAKK307CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENyb3NzT3JpZ2luQWNjZXNzX2gKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAgYi9XZWJDb3JlL3BhZ2Uv U2VjdXJpdHlPcmlnaW4uY3BwCmluZGV4IDgyNzRlMGUuLmQ1YjY5ZTQgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5 T3JpZ2luLmNwcApAQCAtMzEsMTEgKzMxLDIxIEBACiAKICNpbmNsdWRlICJDU3RyaW5nLmgiCiAj aW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJPcmlnaW5BY2Nlc3NFbnRyeS5oIgog I2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAordHlwZWRlZiBWZWN0b3I8T3JpZ2luQWNjZXNzRW50cnk+IE9yaWdp bkFjY2Vzc1doaXRlTGlzdDsKK3R5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIE9yaWdpbkFjY2Vzc1do aXRlTGlzdCo+IE9yaWdpbkFjY2Vzc01hcDsKKworc3RhdGljIE9yaWdpbkFjY2Vzc01hcCYgb3Jp Z2luQWNjZXNzTWFwKCkKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKE9yaWdpbkFjY2Vzc01h cCwgb3JpZ2luQWNjZXNzTWFwLCAoKSk7CisgICAgcmV0dXJuIG9yaWdpbkFjY2Vzc01hcDsKK30K Kwogc3RhdGljIFVSTFNjaGVtZXNNYXAmIGxvY2FsU2NoZW1lcygpCiB7CiAgICAgREVGSU5FX1NU QVRJQ19MT0NBTChVUkxTY2hlbWVzTWFwLCBsb2NhbFNjaGVtZXMsICgpKTsKQEAgLTE5OCw3ICsy MDgsMTcgQEAgYm9vbCBTZWN1cml0eU9yaWdpbjo6Y2FuUmVxdWVzdChjb25zdCBLVVJMJiB1cmwp IGNvbnN0CiAKICAgICAvLyBXZSBjYWxsIGlzU2FtZVNjaGVtZUhvc3RQb3J0IGhlcmUgaW5zdGVh ZCBvZiBjYW5BY2Nlc3MgYmVjYXVzZSB3ZSB3YW50CiAgICAgLy8gdG8gaWdub3JlIGRvY3VtZW50 LmRvbWFpbiBlZmZlY3RzLgotICAgIHJldHVybiBpc1NhbWVTY2hlbWVIb3N0UG9ydCh0YXJnZXRP cmlnaW4uZ2V0KCkpOworICAgIGlmIChpc1NhbWVTY2hlbWVIb3N0UG9ydCh0YXJnZXRPcmlnaW4u Z2V0KCkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChPcmlnaW5BY2Nlc3NXaGl0 ZUxpc3QqIGxpc3QgPSBvcmlnaW5BY2Nlc3NNYXAoKS5nZXQodG9TdHJpbmcoKSkpIHsKKyAgICAg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBsaXN0LT5zaXplKCk7ICsraSkgeworICAgICAgICAg ICAgaWYgKGxpc3QtPmF0KGkpLm1hdGNoZXNPcmlnaW4oKnRhcmdldE9yaWdpbikpCisgICAgICAg ICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gZmFs c2U7CiB9CiAKIHZvaWQgU2VjdXJpdHlPcmlnaW46OmdyYW50TG9hZExvY2FsUmVzb3VyY2VzKCkK QEAgLTQxNCw0ICs0MzQsMjYgQEAgYm9vbCBTZWN1cml0eU9yaWdpbjo6c2hvdWxkVHJlYXRVUkxT Y2hlbWVBc05vQWNjZXNzKGNvbnN0IFN0cmluZyYgc2NoZW1lKQogICAgIHJldHVybiBub0FjY2Vz c1NjaGVtZXMoKS5jb250YWlucyhzY2hlbWUpOwogfQogCit2b2lkIFNlY3VyaXR5T3JpZ2luOjp3 aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2VPcmln aW4sIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgU3RyaW5nJiBkZXN0 aW5hdGlvbkRvbWFpbnMsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAg QVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoIXNvdXJjZU9yaWdpbi5pc0VtcHR5 KCkpOworCisgICAgU3RyaW5nIHNvdXJjZVN0cmluZyA9IHNvdXJjZU9yaWdpbi50b1N0cmluZygp OworICAgIE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9yaWdpbkFjY2Vzc01hcCgpLmdl dChzb3VyY2VTdHJpbmcpOworICAgIGlmICghbGlzdCkgeworICAgICAgICBsaXN0ID0gbmV3IE9y aWdpbkFjY2Vzc1doaXRlTGlzdDsKKyAgICAgICAgb3JpZ2luQWNjZXNzTWFwKCkuc2V0KHNvdXJj ZVN0cmluZywgbGlzdCk7CisgICAgfQorICAgIGxpc3QtPmFwcGVuZChPcmlnaW5BY2Nlc3NFbnRy eShkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkRvbWFpbnMsIGFsbG93RGVzdGluYXRp b25TdWJkb21haW5zID8gT3JpZ2luQWNjZXNzRW50cnk6OkFsbG93U3ViZG9tYWlucyA6IE9yaWdp bkFjY2Vzc0VudHJ5OjpEaXNhbGxvd1N1YmRvbWFpbnMpKTsKK30KKwordm9pZCBTZWN1cml0eU9y aWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCkKK3sKKyAgICBBU1NFUlQoaXNNYWlu VGhyZWFkKCkpOworICAgIE9yaWdpbkFjY2Vzc01hcCYgbWFwID0gb3JpZ2luQWNjZXNzTWFwKCk7 CisgICAgZGVsZXRlQWxsVmFsdWVzKG1hcCk7CisgICAgbWFwLmNsZWFyKCk7Cit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdp bi5oIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKaW5kZXggMzM1ZWQyOC4uY2MyYWNk ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29y ZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgKQEAgLTE0MSw2ICsxNDEsOSBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIHN0YXRpYyB2b2lkIHJlZ2lzdGVyVVJMU2NoZW1lQXNOb0FjY2Vzcyhj b25zdCBTdHJpbmcmKTsKICAgICAgICAgc3RhdGljIGJvb2wgc2hvdWxkVHJlYXRVUkxTY2hlbWVB c05vQWNjZXNzKGNvbnN0IFN0cmluZyYpOwogCisgICAgICAgIHN0YXRpYyB2b2lkIHdoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIHNvdXJjZU9yaWdpbiwgY29u c3QgU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9u RG9tYWlucywgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgICAgIHN0YXRp YyB2b2lkIHJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworCiAgICAgcHJpdmF0ZToKICAg ICAgICAgZXhwbGljaXQgU2VjdXJpdHlPcmlnaW4oY29uc3QgS1VSTCYpOwogICAgICAgICBleHBs aWNpdCBTZWN1cml0eU9yaWdpbihjb25zdCBTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA0ZmExYWI2 Li4yNDQ3MzdlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQv Z3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFu ICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1 MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBh IG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAg ICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKyAgICAgICAgKHdlYmtpdF93aGl0ZV9s aXN0X2FjY2Vzc190b19vcmlnaW4pOiBBZGQgQVBJIHRvIG1hbmlwdWxhdGUgb3JpZ2luIGFjY2Vz cyB3aGl0ZWxpc3RzLgorICAgICAgICAod2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVf bGlzdHMpOiBEaXR0by4KKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOiBEaXR0by4K KwogMjAwOS0wOC0xOCAgWGFuIExvcGV6ICA8eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAg UnViYmVyLXN0YW1wZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcAppbmRleCA3NTViNGQzLi40YjNjNjVjIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlQ2xpZW50 LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oIgogI2luY2x1ZGUgPHJ1bnRp bWUvSW5pdGlhbGl6ZVRocmVhZGluZy5oPgorI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAK ICNpZiBFTkFCTEUoREFUQUJBU0UpCiAjaW5jbHVkZSAiRGF0YWJhc2VUcmFja2VyLmgiCkBAIC0x NzgsMyArMTc5LDEzIEBAIHZvaWQgd2Via2l0X2luaXQoKQogICAgIHNvdXBfc2Vzc2lvbl9hZGRf ZmVhdHVyZShzZXNzaW9uLCBzbmlmZmVyKTsKICAgICBnX29iamVjdF91bnJlZihzbmlmZmVyKTsK IH0KKwordm9pZCB3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKGNvbnN0IGdjaGFy KiBzb3VyY2VPcmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBn Y2hhciogZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQor eworICAgIFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihTZWN1cml0eU9y aWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhzb3VyY2VPcmlnaW4pLCBkZXN0aW5hdGlvblByb3RvY29s LCBkZXN0aW5hdGlvbkhvc3QsIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30KKwordm9p ZCB3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9saXN0cygpCit7CisgICAgU2VjdXJp dHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworfQpkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oCmluZGV4IGRlODEyMjIuLmNmODlmNzEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmgKQEAgLTI1Myw2ICsyNTMsMTIgQEAgZXh0ZXJuICJDIiB7CiAKICAgICBXRUJLSVRf QVBJIHVuc2lnbmVkIGludAogICAgIHdlYmtpdF93b3JrZXJfdGhyZWFkX2NvdW50KCk7CisgICAg CisgICAgV0VCS0lUIEFQSSB2b2lkCisgICAgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29y aWdpbihjb25zdCBnY2hhciogc291cmNlT3JpZ2luLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Q cm90b2NvbCwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0 aW9uU3ViZG9tYWlucyk7CisgICAgCisgICAgV0VCS0lUIEFQSSB2b2lkCisgICAgd2Via2l0X3Jl c2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQg YS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDUzMzVl ZmIuLjA4ZjQ1MzkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktp dC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDktMDgtMTkgIEFhcm9uIEJvb2Rt YW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0 ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bworICAgICAgICBzcGVjaWZ5 IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIgYWNjZXNzLgorCisg ICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOiBBZGQgU1BJIHRvIG1hbmlwdWxhdGUgb3JpZ2lu IGFjY2VzcyB3aGl0ZWxpc3RzLgorICAgICAgICAoK1tXZWJWaWV3IF93aGl0ZUxpc3RBY2Nlc3NG cm9tT3JpZ2luOmRlc3RpbmF0aW9uUHJvdG9jb2w6ZGVzdGluYXRpb25Ib3N0OmFsbG93RGVzdGlu YXRpb25TdWJkb21haW5zOl0pOiBEaXR0by4KKyAgICAgICAgKCtbV2ViVmlldyBfcmVzZXRPcmln aW5BY2Nlc3NXaGl0ZUxpc3RzXSk6IERpdHRvLgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlld1By aXZhdGUuaDogRGl0dG8uCisKIDIwMDktMDgtMTggIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2Nh QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGVsZSBQZXRlcnNvbi4KZGlmZiAt LWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlZpZXcubW0KaW5kZXggM2EzY2I1OS4uZjE2YjI3NSAxMDA2NDQKLS0tIGEvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXcubW0KKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0K QEAgLTIwOTIsNiArMjA5MiwxNSBAQCBzdGF0aWMgaW5saW5lIElNUCBnZXRNZXRob2QoaWQgbywg U0VMIHMpCiAgICAgcmV0dXJuIF9wcml2YXRlID8gX3ByaXZhdGUtPmluc2VydGlvblBhc3RlYm9h cmQgOiBuaWw7CiB9CiAKKysgKHZvaWQpX3doaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW46KE5TU3Ry aW5nICopc291cmNlT3JpZ2luIGRlc3RpbmF0aW9uUHJvdG9jb2w6KE5TU3RyaW5nICopZGVzdGlu YXRpb25Qcm90b2NvbCBkZXN0aW5hdGlvbkhvc3Q6KE5TU3RyaW5nICopZGVzdGluYXRpb25Ib3N0 IGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zOihCT09MKWFsbG93RGVzdGluYXRpb25TdWJkb21h aW5zCit7CisgICAgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKlNl Y3VyaXR5T3JpZ2luOjpjcmVhdGVGcm9tU3RyaW5nKHNvdXJjZU9yaWdpbiksIGRlc3RpbmF0aW9u UHJvdG9jb2wsIGRlc3RpbmF0aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOwor fQorCisrKHZvaWQpX3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cworeworICAgIFNlY3VyaXR5 T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK30KIAogLSAodm9pZClfdXBk YXRlQWN0aXZlU3RhdGUKIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 UHJpdmF0ZS5oIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKaW5kZXggMzYy YjJlNi4uNmM0NzJkNiAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2 YXRlLmgKKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKQEAgLTQ0Myw2 ICs0NDMsMTUgQEAgQ291bGQgYmUgd29ydGggYWRkaW5nIHRvIHRoZSBBUEkuCiAvLyBXaGljaCBw YXN0ZWJvYXJkIHRleHQgaXMgY29taW5nIGZyb20gaW4gZWRpdGluZyBkZWxlZ2F0ZSBtZXRob2Rz IHN1Y2ggYXMgc2hvdWxkSW5zZXJ0Tm9kZS4KIC0gKE5TUGFzdGVib2FyZCAqKV9pbnNlcnRpb25Q YXN0ZWJvYXJkOwogCisvLyBXaGl0ZWxpc3RzIGFjY2VzcyBmcm9tIGFuIG9yaWdpbiAoc291cmNl T3JpZ2luKSB0byBhIHNldCBvZiBvbmUgb3IgbW9yZSBvcmlnaW5zIGRlc2NyaWJlZCBieSB0aGUg cGFyYW1ldGVyczoKKy8vIC0gZGVzdGluYXRpb25Qcm90b2NvbDogVGhlIHByb3RvY29sIHRvIGdy YW50IGFjY2VzcyB0by4KKy8vIC0gZGVzdGluYXRpb25Ib3N0OiBUaGUgaG9zdCB0byBncmFudCBh Y2Nlc3MgdG8uCisvLyAtIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zOiBJZiBob3N0IGlzIGEg ZG9tYWluLCBzZXR0aW5nIHRoaXMgdG8gWUVTIHdpbGwgd2hpdGVsaXN0IGhvc3QgYW5kIGFsbCBp dHMgc3ViZG9tYWlucywgcmVjdXJzaXZlbHkuCisrICh2b2lkKV93aGl0ZUxpc3RBY2Nlc3NGcm9t T3JpZ2luOihOU1N0cmluZyAqKXNvdXJjZU9yaWdpbiBkZXN0aW5hdGlvblByb3RvY29sOihOU1N0 cmluZyAqKWRlc3RpbmF0aW9uUHJvdG9jb2wgZGVzdGluYXRpb25Ib3N0OihOU1N0cmluZyAqKWRl c3RpbmF0aW9uSG9zdCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczooQk9PTClhbGxvd0Rlc3Rp bmF0aW9uU3ViZG9tYWluczsKKworLy8gUmVtb3ZlcyBhbGwgd2hpdGUgbGlzdCBlbnRyaWVzIGNy ZWF0ZWQgd2l0aCBfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbi4KKysgKHZvaWQpX3Jlc2V0T3Jp Z2luQWNjZXNzV2hpdGVMaXN0czsKKwogQGVuZAogCiBAaW50ZXJmYWNlIFdlYlZpZXcgKFdlYlZp ZXdQcmludGluZ1ByaXZhdGUpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0 eW9yaWdpbi5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKaW5kZXgg YjMwMDVjMi4uZmNlOWE5OSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlv cmlnaW4uY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcApAQCAt MjM1LDMgKzIzNSwxMiBAQCBRU3RyaW5nTGlzdCBRV2ViU2VjdXJpdHlPcmlnaW46OmxvY2FsU2No ZW1lcygpCiAgICAgcmV0dXJuIGxpc3Q7CiB9CiAKK3ZvaWQgUVdlYlNlY3VyaXR5T3JpZ2luOjp3 aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcmIHNvdXJjZU9yaWdpbiwgY29u c3QgUVN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgUVN0cmluZyYgZGVzdGluYXRp b25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQoreworICAgIFNlY3VyaXR5 T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKHNvdXJjZU9yaWdpbiwgZGVzdGluYXRp b25Qcm90b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7 Cit9CisKK3ZvaWQgUVdlYlNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlz dHMoKQoreworICAgIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMo KTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmggYi9X ZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCmluZGV4IDE2ZjhiYzEuLjA1NTZiODkg MTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmgKKysrIGIvV2Vi S2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaApAQCAtNDAsNiArNDAsOCBAQCBwdWJsaWM6 CiAgICAgc3RhdGljIHZvaWQgYWRkTG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYgc2NoZW1lKTsK ICAgICBzdGF0aWMgdm9pZCByZW1vdmVMb2NhbFNjaGVtZShjb25zdCBRU3RyaW5nJiBzY2hlbWUp OwogICAgIHN0YXRpYyBRU3RyaW5nTGlzdCBsb2NhbFNjaGVtZXMoKTsKKyAgICBzdGF0aWMgdm9p ZCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcmIHNvdXJjZU9yaWdpbiwg Y29uc3QgUVN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgUVN0cmluZyYgZGVzdGlu YXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKKyAgICBzdGF0aWMg dm9pZCBjbGVhck9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKIAogICAgIH5RV2ViU2VjdXJpdHlP cmlnaW4oKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9D aGFuZ2VMb2cKaW5kZXggYzUxNDdlZC4uMGFmNDRhMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0No YW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDkt MDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0 bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdp biBYSFIgYWNjZXNzLgorCisgICAgICAgICogQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHA6IEFk ZCBBUEkgdG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMuCisgICAgICAgIChR V2ViU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAg ICAgICAgKFFXZWJTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKTog RGl0dG8uCisgICAgICAgICogQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oOiBEaXR0by4KKwogMjAw OS0wOC0xOCAgTWFya3VzIEdvZXR6IDxNYXJrdXMuR29ldHpAbm9raWEuY29tPgogCiAgICAgICAg IFJldml3ZWQgYnkgQXJpeWEgSGlkYXlhdC4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5n ZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCAwZjk5MjMwLi4zNTc2YmU2IDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjkgQEAKKzIwMDktMDgtMTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEg d2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bworICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxh ciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBYSFIgYWNjZXNzLgorCisgICAgICAgICogRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOiBFeHBvc2Ugd2hpdGVMaXN0QWNjZXNz RnJvbU9yaWdpbigpIHRvIGxheW91dCB0ZXN0cy4KKyAgICAgICAgKHdoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW5DYWxsYmFjayk6IERpdHRvLgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnN0YXRpY0Z1bmN0aW9ucyk6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmg6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9M YXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHA6IERpdHRvLgorICAgICAgICAoTGF5b3V0VGVzdENv bnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc1RvT3JpZ2luKTogRGl0dG8uCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOiBEaXR0by4KKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0 dG8uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNwcDogRGl0dG8uCisg ICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6 IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxl cldpbi5jcHA6IFN0dWIgb3V0IHdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKS4KKyAgICAgICAg KExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0dG8u CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcDogUmVzZXQg b3JpZ2luIGFjY2VzcyBsaXN0cyBiZWZvcmUgZWFjaCB0ZXN0LgorICAgICAgICAocmVzZXRXZWJW aWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKTogRGl0dG8uCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOiBEaXR0by4KKyAgICAgICAgKHJlc2V0 V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZyk6IERpdHRvLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcDogRGl0dG8uCisgICAgICAgIChX ZWJDb3JlOjpEdW1wUmVuZGVyVHJlZTo6cmVzZXRUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3Rp bmcpOiBEaXR0by4KKwogMjAwOS0wOC0xOSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAyYjA3MGFkLi4y YWNlN2RjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuY3BwCkBAIC04NzQsNiArODc0LDI0IEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHdh aXRGb3JQb2xpY3lEZWxlZ2F0ZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVj dFJlCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0 aWMgSlNWYWx1ZVJlZiB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3Qg YXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiog ZXhjZXB0aW9uKQoreworICAgIGlmIChhcmd1bWVudENvdW50ICE9IDQpCisgICAgICAgIHJldHVy biBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBzb3VyY2VPcmlnaW4oQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwg YXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworICAg IEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBkZXN0aW5hdGlvblByb3RvY29sKEFkb3B0LCBKU1Zh bHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwgZXhjZXB0aW9uKSk7CisgICAg QVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gZGVzdGlu YXRpb25Ib3N0KEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sy XSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBib29sIGFsbG93 RGVzdGluYXRpb25TdWJkb21haW5zID0gSlNWYWx1ZVRvQm9vbGVhbihjb250ZXh0LCBhcmd1bWVu dHNbM10pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBzdGF0aWNf Y2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0 KSk7CisgICAgY29udHJvbGxlci0+d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihzb3VyY2VPcmln aW4uZ2V0KCksIGRlc3RpbmF0aW9uUHJvdG9jb2wuZ2V0KCksIGRlc3RpbmF0aW9uSG9zdC5nZXQo KSwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVu ZGVmaW5lZChjb250ZXh0KTsKK30KKwogLy8gU3RhdGljIFZhbHVlcwogCiBzdGF0aWMgSlNWYWx1 ZVJlZiBnZXRHbG9iYWxGbGFnQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0 UmVmIHRoaXNPYmplY3QsIEpTU3RyaW5nUmVmIHByb3BlcnR5TmFtZSwgSlNWYWx1ZVJlZiogZXhj ZXB0aW9uKQpAQCAtMTAyMSw2ICsxMDM5LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVz dENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgIndhaXRGb3JQb2xpY3lE ZWxlZ2F0ZSIsIHdhaXRGb3JQb2xpY3lEZWxlZ2F0ZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgIndhaXRVbnRpbERvbmUiLCB3YWl0VW50aWxEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAid2luZG93Q291bnQiLCB3aW5kb3dDb3VudENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAg IHsgIndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4iLCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAwLCAwLCAwIH0KICAgICB9OwogCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCBj N2I0OGU4Li44MDA5MTRlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTE3OSw3ICsxNzksOSBAQCBwdWJsaWM6CiAgICAgYm9v bCBwYXVzZUFuaW1hdGlvbkF0VGltZU9uRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBhbmltYXRp b25OYW1lLCBkb3VibGUgdGltZSwgSlNTdHJpbmdSZWYgZWxlbWVudElkKTsKICAgICBib29sIHBh dXNlVHJhbnNpdGlvbkF0VGltZU9uRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBwcm9wZXJ0eU5h bWUsIGRvdWJsZSB0aW1lLCBKU1N0cmluZ1JlZiBlbGVtZW50SWQpOwogICAgIHVuc2lnbmVkIG51 bWJlck9mQWN0aXZlQW5pbWF0aW9ucygpIGNvbnN0OwotICAgIAorCisgICAgdm9pZCB3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdSZWYg ZGVzdGluYXRpb25Qcm90b2NvbCwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFs bG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKKwogcHJpdmF0ZToKICAgICBib29sIG1fZHVtcEFz VGV4dDsKICAgICBib29sIG1fZHVtcEFzUERGOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggNzQ1MGNmYi4uYWIwZTVmMCAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNw cAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3Bw CkBAIC02Miw2ICs2Miw3IEBAIGV4dGVybiB2b2lkIHdlYmtpdF93ZWJfc2V0dGluZ3NfYWRkX2V4 dHJhX3BsdWdpbl9kaXJlY3RvcnkoV2ViS2l0V2ViVmlldyogdmlldywKIGV4dGVybiBnY2hhciog d2Via2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1lKiBm cmFtZSk7CiBleHRlcm4gdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX2NsZWFyX21haW5fZnJhbWVfbmFt ZShXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogZXh0ZXJuIHZvaWQgd2Via2l0X3dlYl92aWV3X3Nl dF9ncm91cF9uYW1lKFdlYktpdFdlYlZpZXcqIHZpZXcsIGNvbnN0IGdjaGFyKiBncm91cE5hbWUp OworZXh0ZXJuIHZvaWQgd2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKTsK IH0KIAogdm9sYXRpbGUgYm9vbCBkb25lOwpAQCAtMjgwLDYgKzI4MSw4IEBAIHN0YXRpYyB2b2lk IHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAKICAgICBXZWJL aXRXZWJJbnNwZWN0b3IqIGluc3BlY3RvciA9IHdlYmtpdF93ZWJfdmlld19nZXRfaW5zcGVjdG9y KHdlYlZpZXcpOwogICAgIGdfb2JqZWN0X3NldChHX09CSkVDVChpbnNwZWN0b3IpLCAiamF2YXNj cmlwdC1wcm9maWxpbmctZW5hYmxlZCIsIEZBTFNFLCBOVUxMKTsKKworICAgIHdlYmtpdF9yZXNl dF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3RzKCk7CiB9CiAKIHZvaWQgZHVtcCgpCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJH dGsuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9s bGVyR3RrLmNwcAppbmRleCAzODhmYmVkLi40YTk5NTFkIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAK QEAgLTQ5LDYgKzQ5LDcgQEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3RyYW5zaXRpb24o V2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogbmFtZSwKIHVuc2lnbmVkIGludCB3 ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogdm9pZCB3ZWJraXRfYXBwbGljYXRpb25fY2FjaGVfc2V0X21heGltdW1fc2l6 ZSh1bnNpZ25lZCBsb25nIGxvbmcgc2l6ZSk7CiB1bnNpZ25lZCBpbnQgd2Via2l0X3dvcmtlcl90 aHJlYWRfY291bnQodm9pZCk7Cit2b2lkIHdlYmtpdF93aGl0ZV9saXN0X2FjY2Vzc190b19vcmln aW4oY29uc3QgZ2NoYXIqIHNvdXJjZU9yaWdpbiwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uUHJv dG9jb2wsIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlv blN1YmRvbWFpbnMpOwogfQogCiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6fkxheW91dFRlc3RDb250 cm9sbGVyKCkKQEAgLTE2OSw2ICsxNzAsMTQgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2FpdEZvclBvbGljeURlbGVnYXRlKCkKICAgICBzZXRXYWl0VG9EdW1wKHRydWUpOwogfQogCit2 b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbihKU1N0cmlu Z1JlZiBzb3VyY2VPcmlnaW4sIEpTU3RyaW5nUmVmIHByb3RvY29sLCBKU1N0cmluZ1JlZiBob3N0 LCBib29sIGluY2x1ZGVTdWJkb21haW5zKQoreworICAgIGdjaGFyKiBzb3VyY2VPcmlnaW5HQ2hh ciA9IEpTU3RyaW5nQ29weVVURjhDU3RyaW5nKHNvdXJjZU9yaWdpbik7CisgICAgZ2NoYXIqIHBy b3RvY29sR0NoYXIgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhwcm90b2NvbCk7CisgICAgZ2No YXIqIGhvc3RHQ2hhciA9IEpTU3RyaW5nQ29weVVURjhDU3RyaW5nKGhvc3QpOworICAgIHdlYmtp dF93aGl0ZV9saXN0X2FjY2Vzc190b19vcmlnaW4oc291cmNlT3JpZ2luR0NoYXIsIHByb3RvY29s R0NoYXIsIGhvc3RHQ2hhciwgaW5jbHVkZVN1YmRvbWFpbnMpOworfQorCiB2b2lkIExheW91dFRl c3RDb250cm9sbGVyOjpzZXRNYWluRnJhbWVJc0ZpcnN0UmVzcG9uZGVyKGJvb2wgZmxhZykKIHsK ICAgICAvLyBGSVhNRTogaW1wbGVtZW50CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KaW5kZXggMGFjZmY3Ny4uODA1NTcyMiAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtMTA4 Miw2ICsxMDgyLDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVC ZWZvcmVUZXN0aW5nKCkKICAgICBbW1ttYWluRnJhbWUgd2ViVmlld10gaW5zcGVjdG9yXSBzZXRK YXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZDpOT107CiAKICAgICBbV2ViVmlldyBfc2V0VXNlc1Rl c3RNb2RlRm9jdXNSaW5nQ29sb3I6WUVTXTsKKyAgICBbV2ViVmlldyBfcmVzZXRPcmlnaW5BY2Nl c3NXaGl0ZUxpc3RzXTsKIH0KIAogc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBzdHJpbmcmIHRl c3RQYXRoT3JVUkwpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv TGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggZDMxY2Q4ZC4uYjM5Y2Y0NyAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9s bGVyTWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0 Q29udHJvbGxlck1hYy5tbQpAQCAtNDQzLDMgKzQ0MywxNCBAQCB2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogICAgIFtwb2xpY3lEZWxlZ2F0ZSBzZXRD b250cm9sbGVyVG9Ob3RpZnlEb25lOnRoaXNdOwogICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIHNl dFBvbGljeURlbGVnYXRlOnBvbGljeURlbGVnYXRlXTsKIH0KKwordm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihKU1N0cmluZ1JlZiBzb3VyY2VPcmln aW4sIEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIEpTU3RyaW5nUmVmIGRlc3RpbmF0 aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBSZXRhaW5Q dHI8Q0ZTdHJpbmdSZWY+IHNvdXJjZU9yaWdpbkNGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3Ry aW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIHNvdXJjZU9yaWdpbikpOworICAgIE5TU3RyaW5nICpz b3VyY2VPcmlnaW5OUyA9IChOU1N0cmluZyAqKXNvdXJjZU9yaWdpbkNGLmdldCgpOworICAgIFJl dGFpblB0cjxDRlN0cmluZ1JlZj4gcHJvdG9jb2xDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0 cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBkZXN0aW5hdGlvblByb3RvY29sKSk7CisgICAgTlNT dHJpbmcgKmRlc3RpbmF0aW9uUHJvdG9jb2xOUyA9IChOU1N0cmluZyAqKXByb3RvY29sQ0YuZ2V0 KCk7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBob3N0Q0YoQWRvcHRDRiwgSlNTdHJpbmdD b3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgZGVzdGluYXRpb25Ib3N0KSk7CisgICAg TlNTdHJpbmcgKmRlc3RpbmF0aW9uSG9zdE5TID0gKE5TU3RyaW5nICopaG9zdENGLmdldCgpOwor ICAgIFtXZWJWaWV3IF93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOnNvdXJjZU9yaWdpbk5TIGRl c3RpbmF0aW9uUHJvdG9jb2w6ZGVzdGluYXRpb25Qcm90b2NvbE5TIGRlc3RpbmF0aW9uSG9zdDpk ZXN0aW5hdGlvbkhvc3ROUyBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczphbGxvd0Rlc3RpbmF0 aW9uU3ViZG9tYWluc107Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9E dW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggMTY3YTRjNS4uNWUzMDlmNCAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtMjE4LDYgKzIx OCw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWU6OnJlc2V0VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVU ZXN0aW5nKCkKICAgICAvL1dvcmtRdWV1ZTo6c2hhcmVkKCktPnNldEZyb3plbihmYWxzZSk7CiAK ICAgICBtX2NvbnRyb2xsZXItPnJlc2V0KCk7CisgICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpyZXNl dE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZTo6b3Bl bihjb25zdCBRVXJsJiBhdXJsKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvcXQvanNvYmplY3RzLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2Jq ZWN0cy5jcHAKaW5kZXggYzllN2I4NC4uNGJlZjNiOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9xdC9qc29iamVjdHMuY3BwCkBAIC0zMzcsNiArMzM3LDExIEBAIHZvaWQgTGF5b3V0 VGVzdENvbnRyb2xsZXI6OmNsZWFyQWxsRGF0YWJhc2VzKCkKICAgICBRV2ViRGF0YWJhc2U6OnJl bW92ZUFsbERhdGFiYXNlcygpOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcmIHNvdXJjZU9yaWdpbiwgY29uc3Qg UVN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgUVN0cmluZyYgZGVzdGluYXRpb25I b3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQoreworICAgIFNlY3VyaXR5T3Jp Z2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKHNvdXJjZU9yaWdpbiwgZGVzdGluYXRpb25Q cm90b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7Cit9 CisKIEV2ZW50U2VuZGVyOjpFdmVudFNlbmRlcihRV2ViUGFnZSAqcGFyZW50KQogICAgIDogUU9i amVjdChwYXJlbnQpCiB7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93 aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAppbmRleCA1NzQzNDRmLi4zODNiMDA2 IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENv bnRyb2xsZXJXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlv dXRUZXN0Q29udHJvbGxlcldpbi5jcHAKQEAgLTgxNiwzICs4MTYsOCBAQCB1bnNpZ25lZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6bnVtYmVyT2ZBY3RpdmVBbmltYXRpb25zKCkgY29uc3QKIAogICAg IHJldHVybiBudW1iZXI7CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNlT3JpZ2luLCBKU1N0cmluZ1JlZiBk ZXN0aW5hdGlvblByb3RvY29sLCBKU1N0cmluZ1JlZiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxs b3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAgcHJpbnRmKCJMYXlvdXRUZXN0Q29udHJv bGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbiBub3QgaW1wbGVtZW50ZWRcbiIpOworfQo= 35172 2009-08-19 18:20:47 -0700 2009-08-19 20:16:43 -0700 New patch patch.txt text/plain 52416 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlZGE4Nzc4Li4xYjkyMWUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTkgIFJ5b3N1a2UgTml3YSAgPHJu aXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctYWxsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEyYmE0MmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctYWxs LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDExIEBACitUZXN0cyB0aGUgc3BlY2lhbCBjYXNlIG9m IHdoaXRlbGlzdGluZyBhbGwgb3JpZ2lucy4KKworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4 MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUwor VGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9n ZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAw MC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3luYykKK1BBU1M6IFBBU1MKK1Rl c3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0 LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMDc4NWUxCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC5odG1sCkBAIC0wLDAgKzEsNTYgQEAKKzxwPlRlc3RzIHRoZSBzcGVj aWFsIGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLjwvcD4KKworPHByZSBpZD0iY29u c29sZSI+PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OworbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwg Imh0dHAiLCAiIiwgdHJ1ZSk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NG cm9tT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiaHR0cCIsICIiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0RG9tYWluKCkKK3sKKyAgICB2YXIgdXJsID0gImh0dHA6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCI7CisgICAg bG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIgcmVxID0gbmV3IFhN TEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFsc2UpOworICAgIHRy eSB7CisgICAgICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coIlBBU1M6ICIgKyByZXEu cmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNoIChlKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IGUpOworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOwor ICAgIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmws IHRydWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKCJQQVNT OiAiICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgICAgIHRlc3RJUEFkZHJlc3MoKTsKKyAgICB9 OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IHJlcS5zdGF0dXMpOworICAgICAgICB0ZXN0SVBBZGRyZXNzKCk7CisgICAgfTsKKyAgICByZXEu c2VuZChudWxsKTsKK30KKworZnVuY3Rpb24gdGVzdElQQWRkcmVzcygpCit7CisgICAgdmFyIGlm cmFtZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImlmcmFtZSIpOworICAgIGRvY3VtZW50LmJv ZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKKyAgICBpZnJhbWUuc3JjID0gImh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1h ZGRyZXNzLXRlc3QuaHRtbCI7CisgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoIm1lc3NhZ2Ui LCBmdW5jdGlvbihlKSB7CisgICAgICAgIGlmIChlLmRhdGEgPT0gIkRPTkUiKQorICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICBlbHNlCisgICAg ICAgICAgICBsb2coZS5kYXRhKTsKKyAgICB9LCBmYWxzZSk7Cit9CisKK3Rlc3REb21haW4oKTsK Kzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFj dC1tYXRjaC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u Yjk5MTZhMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwxMSBAQAorVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5z IHVzaW5nIGV4YWN0IG1hdGNoaW5nLgorCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNTOiBQQVNTCitUZXN0 aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50 eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUworVGVzdGlu ZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct ZXhhY3QtbWF0Y2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMzVl OWRlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwKQEAgLTAsMCArMSw2MCBA QAorPHA+VGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5zIHVzaW5nIGV4 YWN0IG1hdGNoaW5nLjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0Pgor bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIu d2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNzRnJv bU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHAiLCAibG9jYWxob3N0IiwgZmFs c2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQorewor ICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5l dyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAg ICB0cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNj ZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNh dGNoIChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6 ICIpICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMp Iik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIs IHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2co KGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQp OworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlv bigpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikg KyByZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5k KG51bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXSwKKyAgICBbImh0dHA6Ly9s b0NBTGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisg ICAgLy8gRklYTUU6IElzIGl0IHBvc3NpYmxlIHRvIHNldHVwIHRoZSBmb2xsb3dpbmcgdGVzdHM/ CisgICAgLy8gWyJodHRwOi8vbG9jYWxob3N0OjgwMDEveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2dldC50eHQiLCBmYWxzZV0sCisgICAgLy8gWyJodHRwOi8vZm9vLmxvY2FsaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdLAorICAgIC8vIFsiaHR0cHM6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUzM2M0YTgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgdGhhdCBvcmlnaW4g d2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBodHRwIFVSTHMuCisKK1Rlc3Rp bmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4 dCAoc3luYykKK1BBU1M6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3QgRXhjZXB0 aW9uIDEwMQorVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaHR0cHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMGU2 MDZlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKQEAgLTAsMCArMSw1NyBAQAorPHA+ VGVzdHMgdGhhdCBvcmlnaW4gd2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBo dHRwIFVSTHMuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0 VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cHMiLCAibG9jYWxob3N0IiwgZmFsc2Up OworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2Ug KyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQoreworICAg IGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBY TUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0 cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNz ID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNo IChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIp ICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMpIik7 CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVy bCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4 cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOwor ICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigp IHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyBy ZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5kKG51 bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1s aHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KKyAgICAvLyBGSVhNRTogSXMg aXQgcG9zc2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHBz Oi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDA5OTQ3NAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBA QAorVGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyB3aXRoIElQIGFkZHJlc3Nlcy4KKworVGVzdGlu ZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0 dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVs aXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmNkZTY4MzIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LXdpdGgtc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitTcGVjaWZ5aW5n IHRoYXQgYW4gSVAgYWRkcmVzcyBzaG91bGQgbWF0Y2ggc3ViZG9tYWlucyBkb2Vzbid0IG1ha2Ug c2Vuc2UuIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGl0IGRvZXNuJ3QgZG8gYW55dGhpbmcuCisK K1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv Z2V0LnR4dCAoc3luYykKK0ZBSUw6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3Qg RXhjZXB0aW9uIDEwMQorVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1 ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK0ZBSUw6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlw LWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJk b21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODUwZDE2Mgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSwyMiBAQAorPHA+U3BlY2lmeWluZyB0aGF0IGFuIElQIGFkZHJlc3Mgc2hvdWxkIG1h dGNoIHN1YmRvbWFpbnMgZG9lc24ndCBtYWtlIHNlbnNlLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhh dCBpdCBkb2Vzbid0IGRvIGFueXRoaW5nLjwvcD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgor PHNjcmlwdD4KK2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RD b250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIiouMC4w LjEiLCB0cnVlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9k ZShtZXNzYWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgiaWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJh bWUuc3JjID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZl bnRMaXN0ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJE T05FIikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIGVs c2UKKyAgICAgICAgbG9nKGUuZGF0YSk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1pcC1hZGRyZXNzZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5hM2EzYWY3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy5odG1sCkBAIC0wLDAgKzEsMjIgQEAKKzxwPlRlc3RzIG9yaWdpbiB3aGl0ZWxpc3Rp bmcgd2l0aCBJUCBhZGRyZXNzZXMuPC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2Ny aXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbigiaHR0cDovL2xvY2FsaG9zdDo4MDAwIiwgImh0dHAiLCAiMTI3LjAuMC4x IiwgZmFsc2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2Rl KG1lc3NhZ2UgKyAnXG4nKSk7Cit9CisKK3ZhciBpZnJhbWUgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJpZnJhbWUiKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKK2lmcmFt ZS5zcmMgPSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9v cmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKK3dpbmRvdy5hZGRFdmVu dExpc3RlbmVyKCJtZXNzYWdlIiwgZnVuY3Rpb24oZSkgeworICAgIGlmIChlLmRhdGEgPT0gIkRP TkUiKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZWxz ZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlNjJlNGUKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3Rpbmctc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitUZXN0cyBvcmln aW4gd2hpdGVsaXN0aW5nIHN1YmRvbWFpbiBiZWhhdmlvci4KKworVGVzdGluZzogaHR0cDovL2xv Y2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFT UzogUEFTUworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uNjE2MTBlNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSw1OSBAQAorPHA+VGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyBzdWJkb21haW4gYmVo YXZpb3IuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50 aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu KCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cCIsICJsb2NhbGhvc3QiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0KHVybCwgZXhwZWN0U3VjY2VzcykKK3sKKyAgICBsb2co IlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEgPSBuZXcgWE1MSHR0 cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7CisgICAgdHJ5IHsK KyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQ QVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgfSBjYXRjaCAoZSkg eworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNTOiAiKSArIGUp OworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOworICAg IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIHRy dWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKChleHBlY3RT dWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAg ICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7Cisg ICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsgcmVxLnN0 YXR1cyk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEuc2VuZChudWxsKTsK K30KKwordmFyIHRlc3RzID0gWworICAgIFsiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHBy ZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAvLyBGSVhNRTogSXMgaXQgcG9z c2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHA6Ly9mb28u bG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQor ICAgIC8vIFsiaHR0cDovL2Jhci5mb28ubG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8vIFsiaHR0cDovL2Zvb2xvY2FsaG9zdDo4MDAw L3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdCitdOworCit2YXIgY3Vy cmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVzdCgpCit7CisgICAgaWYgKGN1cnJlbnRU ZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0LmFwcGx5KG51bGwsIHRlc3RzW2N1cnJl bnRUZXN0KytdKTsKKyAgICBlbHNlCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlm eURvbmUoKTsKK30KKworbmV4dFRlc3QoKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tp cHBlZAppbmRleCA4MTM3NDMxLi5hOTA0NTE3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93aW4vU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZApA QCAtNjM2LDMgKzYzNiwxMiBAQCBtZWRpYS92aWRlby1zb3VyY2UtZXJyb3IuaHRtbAogCiAjIDxo dHRwOi8vd2Via2l0Lm9yZy9iLzI4NDY3PgogaHR0cC90ZXN0cy9sb2FkaW5nL3ByZWxvYWQtaW1n LXRlc3QuaHRtbAorCisjIE1pc3NpbmcgTGF5b3V0VGVzdENvbnRyb2xsZXIgaW1wbGVtZW50YXRp b24KK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRt bAoraHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1h dGNoLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy5odG1sCitodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRl bGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKK2h0dHAvdGVzdHMveG1s aHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKKwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjNmVlMDAw Li4zYmVhNGE5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFA Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJv dmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUg Z3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICBU ZXN0czogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5o dG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKKyAgICAgICAgICAgICAg IGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbAorICAgICAgICAg ICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDogRXhwb3J0IG1ldGhvZHMg dG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMgdG8gZW5hYmxlCisgICAgICAg IHRlc3RpbmcgdmlhIGxheW91dCB0ZXN0cy4KKworICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajogQWRkIE9yaWdpbkFjY2Vzc0VudHJ5LioKKyAgICAgICAgKiBHTlVt YWtlZmlsZS5hbTogRGl0dG8uCisgICAgICAgICogV2ViQ29yZS5neXBpOiBEaXR0by4KKyAgICAg ICAgKiBXZWJDb3JlLnBybzogRGl0dG8uCisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29y ZS52Y3Byb2o6IERpdHRvLgorICAgICAgICAqIFdlYkNvcmVTb3VyY2VzLmJsazogRGl0dG8uCisK KyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6IEltcGxlbWVudCBvcmlnaW4gYWNjZXNz IHdoaXRlbGlzdHMuCisgICAgICAgIChXZWJDb3JlOjpvcmlnaW5BY2Nlc3NNYXApOiBTdGF0aWMg Z2V0dGVyIGZvciBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luOjpjYW5SZXF1ZXN0KTogTW9kaWZ5IHJlcXVlc3QgY2hlY2tpbmcgbG9naWMgdG8gY2hl Y2sgd2hpdGVsaXN0cy4KKyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKTogQWRkIGFuIGVudHJ5IHRvIGEgd2hpdGVsaXN0LgorICAgICAg ICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cyk6 IENsZWFyIGFsbCB0aGUgd2hpdGVsaXN0cy4KKworICAgICAgICAqIHBhZ2UvT3JpZ2luQWNjZXNz RW50cnkuaDogQWRkZWQuIEFuIGVudHJ5IGluIGFuIG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0Lgor ICAgICAgICAqIHBhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwOiBEaXR0by4KKwogMjAwOS0wOC0x OSAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IERhdmlkIEh5YXR0IGFuZCBEYW4gQmVybnN0ZWluLgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggYzQzZTZmOC4u MzJlZDAzZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3Jl L0dOVW1ha2VmaWxlLmFtCkBAIC0xMzAwLDYgKzEzMDAsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0g XAogCVdlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuaCBcCiAJV2ViQ29yZS9wYWdlL05hdmlnYXRvckJh c2UuY3BwIFwKIAlXZWJDb3JlL3BhZ2UvTmF2aWdhdG9yQmFzZS5oIFwKKwlXZWJDb3JlL3BhZ2Uv T3JpZ2luQWNjZXNzRW50cnkuY3BwIFwKKwlXZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnku aCBcCiAJV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIFwKIAlXZWJDb3JlL3BhZ2UvUGFnZS5oIFwKIAlX ZWJDb3JlL3BhZ2UvUGFnZUdyb3VwLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUu YmFzZS5leHAgYi9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKaW5kZXggY2ZiYjIzYy4uOTBmZjM3 NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS5iYXNlLmV4cApAQCAtMzEyLDggKzMxMiwxMSBAQCBfX1pON1dlYkNvcmUxNFJlc291cmNl SGFuZGxlMTJyZWxlYXNlUHJveHlFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTIwZm9y Y2VDb250ZW50U25pZmZpbmdFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUxvYWRlcjE0Y2FuY2Vs bGVkRXJyb3JFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUxvYWRlcjE5c2V0U2hvdWxkQnVmZmVy RGF0YUViCi1fX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luMjRyZWdpc3RlclVSTFNjaGVtZUFz TG9jYWxFUktOU182U3RyaW5nRQogX19aTjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjZjcmVhdGVF UktOU180S1VSTEUKK19fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4xNmNyZWF0ZUZyb21TdHJp bmdFUktOU182U3RyaW5nRQorX19aTjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjI0cmVnaXN0ZXJV UkxTY2hlbWVBc0xvY2FsRVJLTlNfNlN0cmluZ0UKK19fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmln aW4yNXdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW5FUktTMF9SS05TXzZTdHJpbmdFUzVfYgorX19a TjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjI3cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzRXYK IF9fWk43V2ViQ29yZTE1QXJjaGl2ZVJlc291cmNlNmNyZWF0ZUVOM1dURjEwUGFzc1JlZlB0cklO U18xMlNoYXJlZEJ1ZmZlckVFRVJLTlNfNEtVUkxFUktOU182U3RyaW5nRVNBX1NBX1JLTlNfMTZS ZXNvdXJjZVJlc3BvbnNlRQogX19aTjdXZWJDb3JlMTVCYWNrRm9yd2FyZExpc3QxMHJlbW92ZUl0 ZW1FUE5TXzExSGlzdG9yeUl0ZW1FCiBfX1pON1dlYkNvcmUxNUJhY2tGb3J3YXJkTGlzdDEwc2V0 RW5hYmxlZEViCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2Vi Q29yZS5neXBpCmluZGV4IDY1MTEwZTIuLjdjMjZhNDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2Vi Q29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xNjYxLDYgKzE2NjEsOCBA QAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9yLmgnLAogICAgICAgICAgICAgJ3BhZ2UvTmF2 aWdhdG9yQmFzZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9yQmFzZS5oJywKKyAg ICAgICAgICAgICdwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcCcsCisgICAgICAgICAgICAncGFn ZS9PcmlnaW5BY2Nlc3NFbnRyeS5oJywKICAgICAgICAgICAgICdwYWdlL1BhZ2UuY3BwJywKICAg ICAgICAgICAgICdwYWdlL1BhZ2UuaCcsCiAgICAgICAgICAgICAncGFnZS9QYWdlR3JvdXAuY3Bw JywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJv CmluZGV4IGE4ZDg5NGEuLmFiYTQzODEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8K KysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMTEwOCw2ICsxMTA4LDcgQEAgU09VUkNFUyAr PSBcCiAgICAgcGFnZS9IaXN0b3J5LmNwcCBcCiAgICAgcGFnZS9Mb2NhdGlvbi5jcHAgXAogICAg IHBhZ2UvTW91c2VFdmVudFdpdGhIaXRUZXN0UmVzdWx0cy5jcHAgXAorICAgIHBhZ2UvT3JpZ2lu QWNjZXNzRW50cnkuY3BwIFwKICAgICBwYWdlL1BhZ2UuY3BwIFwKICAgICBwYWdlL1BhZ2VHcm91 cC5jcHAgXAogICAgIHBhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcCBcCmRpZmYgLS1naXQg YS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29yZS9XZWJDb3Jl LnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCAwYTVjMzJjLi45ZGUyMTMzIDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTE2OTQxLDYgKzE2OTQxLDE0IEBACiAJCQkJ Pg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHBhZ2VcT3Jp Z2luQWNjZXNzRW50cnkuY3BwIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQorCQkJ CVJlbGF0aXZlUGF0aD0iLi5ccGFnZVxPcmlnaW5BY2Nlc3NFbnRyeS5oIg0KKwkJCQk+DQorCQkJ PC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccGFnZVxQYWdlLmNwcCIN CiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IGM3YzczNjUuLjhiMzQ1YTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMSw2ICsyMSw4IEBACiAvKiBFbmQgUEJYQWdncmVnYXRl VGFyZ2V0IHNlY3Rpb24gKi8KIAogLyogQmVnaW4gUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KKwkJ MDAxNDYyOEExMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMTQ2Mjg4MTAzQ0QxREUw MDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi87IH07CisJCTAwMTQ2MjhCMTAzQ0Qx REUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDAxNDYyODkxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdp bkFjY2Vzc0VudHJ5LmggKi87IH07CiAJCTA2MDI3Q0FEMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250 ZXh0TWVudUl0ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDA2MDI3Q0FDMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250ZXh0TWVudUl0ZW0uaCAqLzsgc2V0 dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQkwNjAyN0NCMzBCMUND MDNEMDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVtTWFjLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDYwMjdDQjIwQjFDQzAzRDAwODg0QjJEIC8qIENv bnRleHRNZW51SXRlbU1hYy5tbSAqLzsgfTsKIAkJMDYyMjg3ODQwQjREQjMyMjAwMEMzNERGIC8q IEZvY3VzRGlyZWN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSAwNjIyODc4MzBCNERCMzIyMDAwQzM0REYgLyogRm9jdXNEaXJlY3Rpb24uaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtNTAwNiw2ICs1 MDA4LDggQEAKIC8qIEVuZCBQQlhDb3B5RmlsZXNCdWlsZFBoYXNlIHNlY3Rpb24gKi8KIAogLyog QmVnaW4gUEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9uICovCisJCTAwMTQ2Mjg4MTAzQ0QxREUwMDBC MjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCTAwMTQ2Mjg5MTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwNjAyN0NBQzBCMUNCRkMwMDA4ODRCMkQgLyogQ29u dGV4dE1lbnVJdGVtLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb250ZXh0 TWVudUl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDYwMjdDQjIwQjFDQzAz RDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbU1hYy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5vYmpjcHA7IHBhdGggPSBDb250ZXh0TWVudUl0ZW1NYWMubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTA2MjI4NzgzMEI0REIzMjIwMDBDMzRERiAvKiBGb2N1c0RpcmVjdGlv bi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRm9jdXNEaXJlY3Rpb24uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEwNjgxLDYgKzEwNjg1LDggQEAKIAkJCQlB OUM2RTY1RDBENzQ2Njk0MDA2NDQyRTkgLyogTmF2aWdhdG9yLmlkbCAqLywKIAkJCQlFMTI3MTlD OTBFRUVDMjEzMDBGNjEyMTMgLyogTmF2aWdhdG9yQmFzZS5jcHAgKi8sCiAJCQkJRTEyNzE5QzYw RUVFQzE2ODAwRjYxMjEzIC8qIE5hdmlnYXRvckJhc2UuaCAqLywKKwkJCQkwMDE0NjI4ODEwM0NE MURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwICovLAorCQkJCTAwMTQ2Mjg5MTAz Q0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovLAogCQkJCTY1RkVBODY4MDk4 MzNBREUwMEJFRDRBQiAvKiBQYWdlLmNwcCAqLywKIAkJCQk2NUEyMTQ2NzA5N0EzMjkxMDBCOTA1 MEEgLyogUGFnZS5oICovLAogCQkJCTkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3Jv dXAuY3BwICovLApAQCAtMTczMTYsNiArMTczMjIsNyBAQAogCQkJCUI1QzExMjNDMTAyQjZDNDYw MDA5NjU3OCAvKiBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmggaW4gSGVhZGVycyAqLywKIAkJ CQlEOEI2MTUyRjEwMzI0OTUxMDBDODU1NEEgLyogQ29va2llLmggaW4gSGVhZGVycyAqLywKIAkJ CQlCQ0ZBOTMwODEwMzMzMTkzMDA3QjI1RDEgLyogUmVuZGVyT3ZlcmZsb3cuaCBpbiBIZWFkZXJz ICovLAorCQkJCTAwMTQ2MjhCMTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5o IGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vz c2luZyA9IDA7CiAJCX07CkBAIC0xOTM4Miw2ICsxOTM4OSw3IEBACiAJCQkJOTM5MjI2MkQxMDMy MTA3QjAwNkU3RDVEIC8qIEpTSFRNTENhbnZhc0VsZW1lbnRDdXN0b20uY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJOTM5MjI2MkYxMDMyMTA4NDAwNkU3RDVEIC8qIEpTQ1NTUnVsZUxpc3RDdXN0b20u Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQjVDMTEyM0IxMDJCNkM0NjAwMDk2NTc4IC8qIFNRTFRy YW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJMDAxNDYyOEExMDND RDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3VyY2VzICovLAogCQkJ KTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlU291cmNlcy5ia2wgYi9XZWJDb3JlL1dlYkNvcmVTb3Vy Y2VzLmJrbAppbmRleCBhNDBjMmIxLi5mMWRjYTM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNv cmVTb3VyY2VzLmJrbAorKysgYi9XZWJDb3JlL1dlYkNvcmVTb3VyY2VzLmJrbApAQCAtNzY2LDYg Kzc2Niw3IEBAIFRoaXMgZmlsZSBjb250YWlucyB0aGUgbGlzdCBvZiBmaWxlcyBuZWVkZWQgdG8g YnVpbGQgV2ViQ29yZS4KICAgICAgICAgcGFnZS9Nb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRz LmNwcAogICAgICAgICBwYWdlL05hdmlnYXRvci5jcHAKICAgICAgICAgcGFnZS9OYXZpZ2F0b3JC YXNlLmNwcAorICAgICAgICBwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcAogICAgICAgICBwYWdl L1BhZ2UuY3BwCiAgICAgICAgIHBhZ2UvUGFnZUdyb3VwLmNwcAogICAgICAgICBwYWdlL1BhZ2VH cm91cExvYWREZWZlcnJlci5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nl c3NFbnRyeS5jcHAgYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM2YjhkMmYKLS0tIC9kZXYvbnVsbAorKysgYi9X ZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwCkBAIC0wLDAgKzEsODIgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlz dHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKKworI2luY2x1ZGUg IkNUeXBlLmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKworbmFtZXNwYWNlIFdlYkNv cmUgeworICAgIAorT3JpZ2luQWNjZXNzRW50cnk6Ok9yaWdpbkFjY2Vzc0VudHJ5KGNvbnN0IFN0 cmluZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9zdCwgU3ViZG9tYWluU2V0dGluZyBzdWJk b21haW5TZXR0aW5nKQorICAgIDogbV9wcm90b2NvbChwcm90b2NvbC5sb3dlcigpKQorICAgICwg bV9ob3N0KGhvc3QubG93ZXIoKSkKKyAgICAsIG1fYWxsb3dTdWJkb21haW5zKHN1YmRvbWFpblNl dHRpbmcpCit7CisgICAgQVNTRVJUKG1fcHJvdG9jb2wgPT0gImh0dHAiIHx8IG1fcHJvdG9jb2wg PT0gImh0dHBzIik7CisgICAgQVNTRVJUKHN1YmRvbWFpblNldHRpbmcgPT0gQWxsb3dTdWJkb21h aW5zIHx8IHN1YmRvbWFpblNldHRpbmcgPT0gRGlzYWxsb3dTdWJkb21haW5zKTsKKworICAgIC8v IEFzc3VtZSB0aGF0IGFueSBob3N0IHRoYXQgZW5kcyB3aXRoIGEgZGlnaXQgaXMgdHJ5aW5nIHRv IGJlIGFuIElQIGFkZHJlc3MuCisgICAgbV9ob3N0SXNJUEFkZHJlc3MgPSAhbV9ob3N0LmlzRW1w dHkoKSAmJiBpc0FTQ0lJRGlnaXQobV9ob3N0W21faG9zdC5sZW5ndGgoKSAtIDFdKTsKK30KKwor Ym9vbCBPcmlnaW5BY2Nlc3NFbnRyeTo6bWF0Y2hlc09yaWdpbihjb25zdCBTZWN1cml0eU9yaWdp biYgb3JpZ2luKSBjb25zdAoreworICAgIEFTU0VSVChvcmlnaW4uaG9zdCgpID09IG9yaWdpbi5o b3N0KCkubG93ZXIoKSk7CisgICAgQVNTRVJUKG9yaWdpbi5wcm90b2NvbCgpID09IG9yaWdpbi5w cm90b2NvbCgpLmxvd2VyKCkpOworCisgICAgaWYgKG1fcHJvdG9jb2wgIT0gb3JpZ2luLnByb3Rv Y29sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAKKyAgICAvLyBTcGVjaWFsIGNhc2U6 IEluY2x1ZGUgc3ViZG9tYWlucyBhbmQgZW1wdHkgaG9zdCBtZWFucyAiYWxsIGhvc3RzLCBpbmNs dWRpbmcgaXAgYWRkcmVzc2VzIi4KKyAgICBpZiAobV9hbGxvd1N1YmRvbWFpbnMgPT0gQWxsb3dT dWJkb21haW5zICYmIG1faG9zdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAg IAorICAgIC8vIEV4YWN0IG1hdGNoLgorICAgIGlmIChtX2hvc3QgPT0gb3JpZ2luLmhvc3QoKSkK KyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gT3RoZXJ3aXNlIHdlIGNhbiBvbmx5 IG1hdGNoIGlmIHdlJ3JlIG1hdGNoaW5nIHN1YmRvbWFpbnMuCisgICAgaWYgKG1fYWxsb3dTdWJk b21haW5zID09IERpc2FsbG93U3ViZG9tYWlucykKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IAorICAgIC8vIERvbid0IHRyeSB0byBkbyBzdWJkb21haW4gbWF0Y2hpbmcgb24gSVAgYWRkcmVz c2VzLgorICAgIGlmIChtX2hvc3RJc0lQQWRkcmVzcykKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIAorICAgIC8vIE1hdGNoIHN1YmRvbWFpbnMuCisgICAgaWYgKG9yaWdpbi5ob3N0KCkubGVu Z3RoKCkgPiBtX2hvc3QubGVuZ3RoKCkgJiYgb3JpZ2luLmhvc3QoKVtvcmlnaW4uaG9zdCgpLmxl bmd0aCgpIC0gbV9ob3N0Lmxlbmd0aCgpIC0gMV0gPT0gJy4nICYmIG9yaWdpbi5ob3N0KCkuZW5k c1dpdGgobV9ob3N0KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgcmV0dXJuIGZh bHNlOworfQorICAgIAorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmggYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50 cnkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMzk5MGY4Ci0tLSAvZGV2 L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKQEAgLTAsMCArMSw2 MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoK KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBp biB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2ds ZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0 d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09O VFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAor ICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpZm5kZWYgQ3Jvc3NPcmlnaW5BY2Nlc3NfaAorI2RlZmluZSBDcm9zc09yaWdpbkFjY2Vz c19oCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKK2NsYXNzIFNlY3VyaXR5T3JpZ2luOworCitjbGFzcyBPcmlnaW5BY2Nlc3NFbnRyeSB7Citw dWJsaWM6CisgICAgZW51bSBTdWJkb21haW5TZXR0aW5nIHsKKyAgICAgICAgQWxsb3dTdWJkb21h aW5zLAorICAgICAgICBEaXNhbGxvd1N1YmRvbWFpbnMKKyAgICB9OworCisgICAgT3JpZ2luQWNj ZXNzRW50cnkoY29uc3QgU3RyaW5nJiBwcm90b2NvbCwgY29uc3QgU3RyaW5nJiBob3N0LCBTdWJk b21haW5TZXR0aW5nKTsKKyAgICBib29sIG1hdGNoZXNPcmlnaW4oY29uc3QgU2VjdXJpdHlPcmln aW4mKSBjb25zdDsKKyAgICAKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1fcHJvdG9jb2w7CisgICAg U3RyaW5nIG1faG9zdDsKKyAgICBTdWJkb21haW5TZXR0aW5nIG1fYWxsb3dTdWJkb21haW5zOwor ICAgIGJvb2wgbV9ob3N0SXNJUEFkZHJlc3M7CisgICAgCit9OworCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBDcm9zc09yaWdpbkFjY2Vzc19oCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2lu LmNwcAppbmRleCA4Mjc0ZTBlLi4zM2VkZTAwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2Vj dXJpdHlPcmlnaW4uY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKQEAg LTMyLDEwICszMiwyMCBAQAogI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJGcmFtZUxv YWRlci5oIgogI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlICJPcmlnaW5BY2Nlc3NFbnRyeS5o IgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewog Cit0eXBlZGVmIFZlY3RvcjxPcmlnaW5BY2Nlc3NFbnRyeT4gT3JpZ2luQWNjZXNzV2hpdGVMaXN0 OwordHlwZWRlZiBIYXNoTWFwPFN0cmluZywgT3JpZ2luQWNjZXNzV2hpdGVMaXN0Kj4gT3JpZ2lu QWNjZXNzTWFwOworCitzdGF0aWMgT3JpZ2luQWNjZXNzTWFwJiBvcmlnaW5BY2Nlc3NNYXAoKQor eworICAgIERFRklORV9TVEFUSUNfTE9DQUwoT3JpZ2luQWNjZXNzTWFwLCBvcmlnaW5BY2Nlc3NN YXAsICgpKTsKKyAgICByZXR1cm4gb3JpZ2luQWNjZXNzTWFwOworfQorCiBzdGF0aWMgVVJMU2No ZW1lc01hcCYgbG9jYWxTY2hlbWVzKCkKIHsKICAgICBERUZJTkVfU1RBVElDX0xPQ0FMKFVSTFNj aGVtZXNNYXAsIGxvY2FsU2NoZW1lcywgKCkpOwpAQCAtMTk4LDcgKzIwOCwxNyBAQCBib29sIFNl Y3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCkgY29uc3QKIAogICAgIC8v IFdlIGNhbGwgaXNTYW1lU2NoZW1lSG9zdFBvcnQgaGVyZSBpbnN0ZWFkIG9mIGNhbkFjY2VzcyBi ZWNhdXNlIHdlIHdhbnQKICAgICAvLyB0byBpZ25vcmUgZG9jdW1lbnQuZG9tYWluIGVmZmVjdHMu Ci0gICAgcmV0dXJuIGlzU2FtZVNjaGVtZUhvc3RQb3J0KHRhcmdldE9yaWdpbi5nZXQoKSk7Cisg ICAgaWYgKGlzU2FtZVNjaGVtZUhvc3RQb3J0KHRhcmdldE9yaWdpbi5nZXQoKSkpCisgICAgICAg IHJldHVybiB0cnVlOworCisgICAgaWYgKE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9y aWdpbkFjY2Vzc01hcCgpLmdldCh0b1N0cmluZygpKSkgeworICAgICAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IGxpc3QtPnNpemUoKTsgKytpKSB7CisgICAgICAgICAgICBpZiAobGlzdC0+YXQo aSkubWF0Y2hlc09yaWdpbigqdGFyZ2V0T3JpZ2luKSkKKyAgICAgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKIH0KIAogdm9pZCBT ZWN1cml0eU9yaWdpbjo6Z3JhbnRMb2FkTG9jYWxSZXNvdXJjZXMoKQpAQCAtNDE0LDQgKzQzNCwy OCBAQCBib29sIFNlY3VyaXR5T3JpZ2luOjpzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3Mo Y29uc3QgU3RyaW5nJiBzY2hlbWUpCiAgICAgcmV0dXJuIG5vQWNjZXNzU2NoZW1lcygpLmNvbnRh aW5zKHNjaGVtZSk7CiB9CiAKK3ZvaWQgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIHNvdXJjZU9yaWdpbiwgY29uc3QgU3RyaW5n JiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9uRG9tYWlucywg Ym9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkpOworICAgIEFTU0VSVCghc291cmNlT3JpZ2luLmlzRW1wdHkoKSk7CisgICAgaWYgKHNv dXJjZU9yaWdpbi5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFN0cmluZyBzb3Vy Y2VTdHJpbmcgPSBzb3VyY2VPcmlnaW4udG9TdHJpbmcoKTsKKyAgICBPcmlnaW5BY2Nlc3NXaGl0 ZUxpc3QqIGxpc3QgPSBvcmlnaW5BY2Nlc3NNYXAoKS5nZXQoc291cmNlU3RyaW5nKTsKKyAgICBp ZiAoIWxpc3QpIHsKKyAgICAgICAgbGlzdCA9IG5ldyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Q7Cisg ICAgICAgIG9yaWdpbkFjY2Vzc01hcCgpLnNldChzb3VyY2VTdHJpbmcsIGxpc3QpOworICAgIH0K KyAgICBsaXN0LT5hcHBlbmQoT3JpZ2luQWNjZXNzRW50cnkoZGVzdGluYXRpb25Qcm90b2NvbCwg ZGVzdGluYXRpb25Eb21haW5zLCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyA/IE9yaWdpbkFj Y2Vzc0VudHJ5OjpBbGxvd1N1YmRvbWFpbnMgOiBPcmlnaW5BY2Nlc3NFbnRyeTo6RGlzYWxsb3dT dWJkb21haW5zKSk7Cit9CisKK3ZvaWQgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNz V2hpdGVMaXN0cygpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBPcmlnaW5B Y2Nlc3NNYXAmIG1hcCA9IG9yaWdpbkFjY2Vzc01hcCgpOworICAgIGRlbGV0ZUFsbFZhbHVlcyht YXApOworICAgIG1hcC5jbGVhcigpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1 cml0eU9yaWdpbi5oCmluZGV4IDMzNWVkMjguLmNjMmFjZGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGFnZS9TZWN1cml0eU9yaWdpbi5oCisrKyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5o CkBAIC0xNDEsNiArMTQxLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBzdGF0aWMg dm9pZCByZWdpc3RlclVSTFNjaGVtZUFzTm9BY2Nlc3MoY29uc3QgU3RyaW5nJik7CiAgICAgICAg IHN0YXRpYyBib29sIHNob3VsZFRyZWF0VVJMU2NoZW1lQXNOb0FjY2Vzcyhjb25zdCBTdHJpbmcm KTsKIAorICAgICAgICBzdGF0aWMgdm9pZCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0 IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Q cm90b2NvbCwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvbkRvbWFpbnMsIGJvb2wgYWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnMpOworICAgICAgICBzdGF0aWMgdm9pZCByZXNldE9yaWdpbkFjY2Vz c1doaXRlTGlzdHMoKTsKKwogICAgIHByaXZhdGU6CiAgICAgICAgIGV4cGxpY2l0IFNlY3VyaXR5 T3JpZ2luKGNvbnN0IEtVUkwmKTsKICAgICAgICAgZXhwbGljaXQgU2VjdXJpdHlPcmlnaW4oY29u c3QgU2VjdXJpdHlPcmlnaW4qKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIv V2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggNGZhMWFiNi4uMjQ0NzM3ZSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNSBAQAorMjAwOS0wOC0xOSAgQWFyb24gQm9vZG1hbiAgPGFhQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ4NTM6IFByb3ZpZGUgYSB3YXkgZm9yIFdl YktpdCBjbGllbnRzIHRvCisgICAgICAgIHNwZWNpZnkgYSBtb3JlIGdyYW51bGFyIHBvbGljeSBm b3IgY3Jvc3Mtb3JpZ2luIFhIUiBhY2Nlc3MuCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJp dmF0ZS5jcHA6CisgICAgICAgICh3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKTog QWRkIEFQSSB0byBtYW5pcHVsYXRlIG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAg KHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3RzKTogRGl0dG8uCisgICAgICAg ICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDogRGl0dG8uCisKIDIwMDktMDgtMTggIFhhbiBMb3Bl eiAgPHhsb3BlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEhvbGdl ciBGcmV5dGhlci4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu Y3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKaW5kZXggNzU1YjRkMy4u NGIzYzY1YyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKQEAgLTM3LDYgKzM3LDcg QEAKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZUNsaWVudC5oIgogI2luY2x1ZGUgIlJlc291cmNl SGFuZGxlSW50ZXJuYWwuaCIKICNpbmNsdWRlIDxydW50aW1lL0luaXRpYWxpemVUaHJlYWRpbmcu aD4KKyNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQog I2luY2x1ZGUgIkRhdGFiYXNlVHJhY2tlci5oIgpAQCAtMTc4LDMgKzE3OSwxMyBAQCB2b2lkIHdl YmtpdF9pbml0KCkKICAgICBzb3VwX3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgc25pZmZl cik7CiAgICAgZ19vYmplY3RfdW5yZWYoc25pZmZlcik7CiB9CisKK3ZvaWQgd2Via2l0X3doaXRl X2xpc3RfYWNjZXNzX3RvX29yaWdpbihjb25zdCBnY2hhciogc291cmNlT3JpZ2luLCBjb25zdCBn Y2hhciogZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uSG9zdCwg Ym9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6 d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4oU2VjdXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmco c291cmNlT3JpZ2luKSwgZGVzdGluYXRpb25Qcm90b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxv d0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7Cit9CisKK3ZvaWQgd2Via2l0X3Jlc2V0X29yaWdpbl9h Y2Nlc3Nfd2hpdGVfbGlzdHMoKQoreworICAgIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFj Y2Vzc1doaXRlTGlzdHMoKTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCBkZTgx MjIyLi5jZjg5ZjcxIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC0yNTMsNiArMjUz LDEyIEBAIGV4dGVybiAiQyIgewogCiAgICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3 ZWJraXRfd29ya2VyX3RocmVhZF9jb3VudCgpOworICAgIAorICAgIFdFQktJVCBBUEkgdm9pZAor ICAgIHdlYmtpdF93aGl0ZV9saXN0X2FjY2Vzc190b19vcmlnaW4oY29uc3QgZ2NoYXIqIHNvdXJj ZU9yaWdpbiwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IGdjaGFyKiBk ZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworICAgIAor ICAgIFdFQktJVCBBUEkgdm9pZAorICAgIHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNzX3doaXRl X2xpc3RzKCk7CiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cg Yi9XZWJLaXQvbWFjL0NoYW5nZUxvZwppbmRleCA1MzM1ZWZiLi4wOGY0NTM5IDEwMDY0NAotLS0g YS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9XZWJLaXQvbWFjL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE1IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3Ig V2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5 IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICAqIFdlYlZpZXcvV2ViVmll dy5tbTogQWRkIFNQSSB0byBtYW5pcHVsYXRlIG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAg ICAgICAgKCtbV2ViVmlldyBfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbjpkZXN0aW5hdGlvblBy b3RvY29sOmRlc3RpbmF0aW9uSG9zdDphbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczpdKTogRGl0 dG8uCisgICAgICAgICgrW1dlYlZpZXcgX3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0c10pOiBE aXR0by4KKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXdQcml2YXRlLmg6IERpdHRvLgorCiAyMDA5 LTA4LTE4ICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQWRlbGUgUGV0ZXJzb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCmluZGV4IDNhM2Ni NTkuLmYxNmIyNzUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCisr KyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0yMDkyLDYgKzIwOTIsMTUgQEAg c3RhdGljIGlubGluZSBJTVAgZ2V0TWV0aG9kKGlkIG8sIFNFTCBzKQogICAgIHJldHVybiBfcHJp dmF0ZSA/IF9wcml2YXRlLT5pbnNlcnRpb25QYXN0ZWJvYXJkIDogbmlsOwogfQogCisrICh2b2lk KV93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOihOU1N0cmluZyAqKXNvdXJjZU9yaWdpbiBkZXN0 aW5hdGlvblByb3RvY29sOihOU1N0cmluZyAqKWRlc3RpbmF0aW9uUHJvdG9jb2wgZGVzdGluYXRp b25Ib3N0OihOU1N0cmluZyAqKWRlc3RpbmF0aW9uSG9zdCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9t YWluczooQk9PTClhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucworeworICAgIFNlY3VyaXR5T3Jp Z2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJv bVN0cmluZyhzb3VyY2VPcmlnaW4pLCBkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhv c3QsIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK30KKworKyh2b2lkKV9yZXNldE9yaWdp bkFjY2Vzc1doaXRlTGlzdHMKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nl c3NXaGl0ZUxpc3RzKCk7Cit9CiAKIC0gKHZvaWQpX3VwZGF0ZUFjdGl2ZVN0YXRlCiB7CmRpZmYg LS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaCBiL1dlYktpdC9tYWMv V2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCmluZGV4IDM2MmIyZTYuLjZjNDcyZDYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCisrKyBiL1dlYktpdC9tYWMv V2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCkBAIC00NDMsNiArNDQzLDE1IEBAIENvdWxkIGJlIHdv cnRoIGFkZGluZyB0byB0aGUgQVBJLgogLy8gV2hpY2ggcGFzdGVib2FyZCB0ZXh0IGlzIGNvbWlu ZyBmcm9tIGluIGVkaXRpbmcgZGVsZWdhdGUgbWV0aG9kcyBzdWNoIGFzIHNob3VsZEluc2VydE5v ZGUuCiAtIChOU1Bhc3RlYm9hcmQgKilfaW5zZXJ0aW9uUGFzdGVib2FyZDsKIAorLy8gV2hpdGVs aXN0cyBhY2Nlc3MgZnJvbSBhbiBvcmlnaW4gKHNvdXJjZU9yaWdpbikgdG8gYSBzZXQgb2Ygb25l IG9yIG1vcmUgb3JpZ2lucyBkZXNjcmliZWQgYnkgdGhlIHBhcmFtZXRlcnM6CisvLyAtIGRlc3Rp bmF0aW9uUHJvdG9jb2w6IFRoZSBwcm90b2NvbCB0byBncmFudCBhY2Nlc3MgdG8uCisvLyAtIGRl c3RpbmF0aW9uSG9zdDogVGhlIGhvc3QgdG8gZ3JhbnQgYWNjZXNzIHRvLgorLy8gLSBhbGxvd0Rl c3RpbmF0aW9uU3ViZG9tYWluczogSWYgaG9zdCBpcyBhIGRvbWFpbiwgc2V0dGluZyB0aGlzIHRv IFlFUyB3aWxsIHdoaXRlbGlzdCBob3N0IGFuZCBhbGwgaXRzIHN1YmRvbWFpbnMsIHJlY3Vyc2l2 ZWx5LgorKyAodm9pZClfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbjooTlNTdHJpbmcgKilzb3Vy Y2VPcmlnaW4gZGVzdGluYXRpb25Qcm90b2NvbDooTlNTdHJpbmcgKilkZXN0aW5hdGlvblByb3Rv Y29sIGRlc3RpbmF0aW9uSG9zdDooTlNTdHJpbmcgKilkZXN0aW5hdGlvbkhvc3QgYWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnM6KEJPT0wpYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnM7CisKKy8v IFJlbW92ZXMgYWxsIHdoaXRlIGxpc3QgZW50cmllcyBjcmVhdGVkIHdpdGggX3doaXRlTGlzdEFj Y2Vzc0Zyb21PcmlnaW4uCisrICh2b2lkKV9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHM7CisK IEBlbmQKIAogQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpbnRpbmdQcml2YXRlKQpkaWZm IC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwIGIvV2ViS2l0L3F0 L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCmluZGV4IGIzMDA1YzIuLmZjZTlhOTkgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcAorKysgYi9XZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKQEAgLTIzNSwzICsyMzUsMTIgQEAgUVN0cmlu Z0xpc3QgUVdlYlNlY3VyaXR5T3JpZ2luOjpsb2NhbFNjaGVtZXMoKQogICAgIHJldHVybiBsaXN0 OwogfQogCit2b2lkIFFXZWJTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdp bihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9u UHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3Rp bmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNz RnJvbU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9u SG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworfQorCit2b2lkIFFXZWJTZWN1cml0 eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCkKK3sKKyAgICBTZWN1cml0eU9y aWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7Cit9CmRpZmYgLS1naXQgYS9XZWJL aXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJp dHlvcmlnaW4uaAppbmRleCAxNmY4YmMxLi4wNTU2Yjg5IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQv QXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5 b3JpZ2luLmgKQEAgLTQwLDYgKzQwLDggQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIGFkZExv Y2FsU2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVtZSk7CiAgICAgc3RhdGljIHZvaWQgcmVtb3Zl TG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYgc2NoZW1lKTsKICAgICBzdGF0aWMgUVN0cmluZ0xp c3QgbG9jYWxTY2hlbWVzKCk7CisgICAgc3RhdGljIHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJvbU9y aWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0 aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rl c3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgc3RhdGljIHZvaWQgY2xlYXJPcmlnaW5BY2Nlc3NX aGl0ZUxpc3RzKCk7CiAKICAgICB+UVdlYlNlY3VyaXR5T3JpZ2luKCk7CiAKZGlmZiAtLWdpdCBh L1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IGM1MTQ3ZWQu LjBhZjQ0YTAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0 L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8 YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1Mzog UHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1v cmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAg ICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwOiBBZGQgQVBJIHRvIG1hbmlwdWxhdGUgb3Jp Z2luIGFjY2VzcyB3aGl0ZWxpc3RzLgorICAgICAgICAoUVdlYlNlY3VyaXR5T3JpZ2luOjp3aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0dG8uCisgICAgICAgIChRV2ViU2VjdXJpdHlPcmln aW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cyk6IERpdHRvLgorICAgICAgICAqIEFwaS9x d2Vic2VjdXJpdHlvcmlnaW4uaDogRGl0dG8uCisKIDIwMDktMDgtMTggIE1hcmt1cyBHb2V0eiA8 TWFya3VzLkdvZXR6QG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpd2VkIGJ5IEFyaXlhIEhpZGF5 YXQuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFu Z2VMb2cKaW5kZXggMGY5OTIzMC4uMzU3NmJlNiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hh bmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDA5 LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMg dG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmln aW4gWEhSIGFjY2Vzcy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcDogRXhwb3NlIHdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKSB0byBsYXlvdXQg dGVzdHMuCisgICAgICAgICh3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luQ2FsbGJhY2spOiBEaXR0 by4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOiBEaXR0 by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOiBEaXR0 by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsu Y3BwOiBEaXR0by4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nl c3NUb09yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRU ZXN0Q29udHJvbGxlck1hYy5tbTogRGl0dG8uCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxl cjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5k ZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHA6IERpdHRvLgorICAgICAgICAoTGF5b3V0VGVzdENvbnRy b2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4pOiBEaXR0by4KKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwOiBTdHViIG91dCB3aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCkuCisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJU cmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHA6IFJlc2V0IG9yaWdpbiBhY2Nlc3MgbGlzdHMgYmVm b3JlIGVhY2ggdGVzdC4KKyAgICAgICAgKHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVm b3JlVGVzdGluZyk6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVu ZGVyVHJlZS5tbTogRGl0dG8uCisgICAgICAgIChyZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0 ZUJlZm9yZVRlc3RpbmcpOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9EdW1w UmVuZGVyVHJlZS5jcHA6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6RHVtcFJlbmRlclRyZWU6 OnJlc2V0VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKTogRGl0dG8uCisKIDIwMDktMDgt MTkgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5jcHAKaW5kZXggMmIwNzBhZC4uMmFjZTdkYyAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcApAQCAtODc0 LDYgKzg3NCwyNCBAQCBzdGF0aWMgSlNWYWx1ZVJlZiB3YWl0Rm9yUG9saWN5RGVsZWdhdGVDYWxs YmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZQogICAgIHJldHVybiBKU1ZhbHVl TWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgd2hpdGVMaXN0 QWNjZXNzRnJvbU9yaWdpbkNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJl ZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpT VmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAo YXJndW1lbnRDb3VudCAhPSA0KQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQo Y29udGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gc291cmNlT3JpZ2luKEFk b3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9u KSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1Jl Zj4gZGVzdGluYXRpb25Qcm90b2NvbChBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0 LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7Cisg ICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGRlc3RpbmF0aW9uSG9zdChBZG9wdCwgSlNWYWx1 ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMl0sIGV4Y2VwdGlvbikpOworICAgIEFT U0VSVCghKmV4Y2VwdGlvbik7CisgICAgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyA9 IEpTVmFsdWVUb0Jvb2xlYW4oY29udGV4dCwgYXJndW1lbnRzWzNdKTsKKworICAgIExheW91dFRl c3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gc3RhdGljX2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xs ZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVjdCkpOworICAgIGNvbnRyb2xsZXItPndo aXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oc291cmNlT3JpZ2luLmdldCgpLCBkZXN0aW5hdGlvblBy b3RvY29sLmdldCgpLCBkZXN0aW5hdGlvbkhvc3QuZ2V0KCksIGFsbG93RGVzdGluYXRpb25TdWJk b21haW5zKTsKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisK IC8vIFN0YXRpYyBWYWx1ZXMKIAogc3RhdGljIEpTVmFsdWVSZWYgZ2V0R2xvYmFsRmxhZ0NhbGxi YWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBKU1N0cmlu Z1JlZiBwcm9wZXJ0eU5hbWUsIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKQEAgLTEwMjEsNiArMTAz OSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5j dGlvbnMoKQogICAgICAgICB7ICJ3YWl0Rm9yUG9saWN5RGVsZWdhdGUiLCB3YWl0Rm9yUG9saWN5 RGVsZWdhdGVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3Bl cnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJ3YWl0VW50aWxEb25lIiwgd2Fp dFVudGlsRG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIndpbmRvd0NvdW50Iiwgd2lu ZG93Q291bnRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3Bl cnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJ3aGl0ZUxpc3RBY2Nlc3NGcm9t T3JpZ2luIiwgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgMCwgMCwgMCB9CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggYzdiNDhlOC4uODAwOTE0ZSAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBA IC0xNzksNyArMTc5LDkgQEAgcHVibGljOgogICAgIGJvb2wgcGF1c2VBbmltYXRpb25BdFRpbWVP bkVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgYW5pbWF0aW9uTmFtZSwgZG91YmxlIHRpbWUsIEpT U3RyaW5nUmVmIGVsZW1lbnRJZCk7CiAgICAgYm9vbCBwYXVzZVRyYW5zaXRpb25BdFRpbWVPbkVs ZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBkb3VibGUgdGltZSwgSlNTdHJp bmdSZWYgZWxlbWVudElkKTsKICAgICB1bnNpZ25lZCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMo KSBjb25zdDsKLSAgICAKKworICAgIHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihKU1N0 cmluZ1JlZiBzb3VyY2VPcmlnaW4sIEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIEpT U3RyaW5nUmVmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlu cyk7CisKIHByaXZhdGU6CiAgICAgYm9vbCBtX2R1bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBB c1BERjsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVu ZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRy ZWUuY3BwCmluZGV4IDc0NTBjZmIuLmFiMGU1ZjAgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtNjIsNiArNjIsNyBAQCBleHRl cm4gdm9pZCB3ZWJraXRfd2ViX3NldHRpbmdzX2FkZF9leHRyYV9wbHVnaW5fZGlyZWN0b3J5KFdl YktpdFdlYlZpZXcqIHZpZXcsCiBleHRlcm4gZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3Jl c3BvbnNlX21pbWVfdHlwZShXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogZXh0ZXJuIHZvaWQgd2Vi a2l0X3dlYl9mcmFtZV9jbGVhcl9tYWluX2ZyYW1lX25hbWUoV2ViS2l0V2ViRnJhbWUqIGZyYW1l KTsKIGV4dGVybiB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfZ3JvdXBfbmFtZShXZWJLaXRXZWJW aWV3KiB2aWV3LCBjb25zdCBnY2hhciogZ3JvdXBOYW1lKTsKK2V4dGVybiB2b2lkIHdlYmtpdF9y ZXNldF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3RzKCk7CiB9CiAKIHZvbGF0aWxlIGJvb2wgZG9u ZTsKQEAgLTI4MCw2ICsyODEsOCBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3Rl bnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogCiAgICAgV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0 b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJWaWV3KTsKICAgICBnX29iamVj dF9zZXQoR19PQkpFQ1QoaW5zcGVjdG9yKSwgImphdmFzY3JpcHQtcHJvZmlsaW5nLWVuYWJsZWQi LCBGQUxTRSwgTlVMTCk7CisKKyAgICB3ZWJraXRfcmVzZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9s aXN0cygpOwogfQogCiB2b2lkIGR1bXAoKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5kZXggMzg4ZmJl ZC4uNGE5OTUxZCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xh eW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCkBAIC00OSw2ICs0OSw3IEBAIGJvb2wg d2Via2l0X3dlYl9mcmFtZV9wYXVzZV90cmFuc2l0aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwg Y29uc3QgZ2NoYXIqIG5hbWUsCiB1bnNpZ25lZCBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1iZXJf b2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIHZvaWQgd2Via2l0 X2FwcGxpY2F0aW9uX2NhY2hlX3NldF9tYXhpbXVtX3NpemUodW5zaWduZWQgbG9uZyBsb25nIHNp emUpOwogdW5zaWduZWQgaW50IHdlYmtpdF93b3JrZXJfdGhyZWFkX2NvdW50KHZvaWQpOwordm9p ZCB3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKGNvbnN0IGdjaGFyKiBzb3VyY2VP cmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBnY2hhciogZGVz dGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKIH0KIAogTGF5 b3V0VGVzdENvbnRyb2xsZXI6On5MYXlvdXRUZXN0Q29udHJvbGxlcigpCkBAIC0xNjksNiArMTcw LDE0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndhaXRGb3JQb2xpY3lEZWxlZ2F0ZSgp CiAgICAgc2V0V2FpdFRvRHVtcCh0cnVlKTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNlT3JpZ2luLCBKU1N0 cmluZ1JlZiBwcm90b2NvbCwgSlNTdHJpbmdSZWYgaG9zdCwgYm9vbCBpbmNsdWRlU3ViZG9tYWlu cykKK3sKKyAgICBnY2hhciogc291cmNlT3JpZ2luR0NoYXIgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0 cmluZyhzb3VyY2VPcmlnaW4pOworICAgIGdjaGFyKiBwcm90b2NvbEdDaGFyID0gSlNTdHJpbmdD b3B5VVRGOENTdHJpbmcocHJvdG9jb2wpOworICAgIGdjaGFyKiBob3N0R0NoYXIgPSBKU1N0cmlu Z0NvcHlVVEY4Q1N0cmluZyhob3N0KTsKKyAgICB3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9f b3JpZ2luKHNvdXJjZU9yaWdpbkdDaGFyLCBwcm90b2NvbEdDaGFyLCBob3N0R0NoYXIsIGluY2x1 ZGVTdWJkb21haW5zKTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0TWFpbkZy YW1lSXNGaXJzdFJlc3BvbmRlcihib29sIGZsYWcpCiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVu dApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJU cmVlLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1t CmluZGV4IDBhY2ZmNzcuLjgwNTU3MjIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAgLTEwODIsNiArMTA4Miw3IEBAIHN0YXRpYyB2 b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAgICAgW1tb bWFpbkZyYW1lIHdlYlZpZXddIGluc3BlY3Rvcl0gc2V0SmF2YVNjcmlwdFByb2ZpbGluZ0VuYWJs ZWQ6Tk9dOwogCiAgICAgW1dlYlZpZXcgX3NldFVzZXNUZXN0TW9kZUZvY3VzUmluZ0NvbG9yOllF U107CisgICAgW1dlYlZpZXcgX3Jlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0c107CiB9CiAKIHN0 YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5nJiB0ZXN0UGF0aE9yVVJMKQpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFj Lm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tCmluZGV4IGQzMWNkOGQuLmIzOWNmNDcgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTQ0 MywzICs0NDMsMTQgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2FpdEZvclBvbGljeURl bGVnYXRlKCkKICAgICBbcG9saWN5RGVsZWdhdGUgc2V0Q29udHJvbGxlclRvTm90aWZ5RG9uZTp0 aGlzXTsKICAgICBbW21haW5GcmFtZSB3ZWJWaWV3XSBzZXRQb2xpY3lEZWxlZ2F0ZTpwb2xpY3lE ZWxlZ2F0ZV07CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vz c0Zyb21PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNlT3JpZ2luLCBKU1N0cmluZ1JlZiBkZXN0aW5h dGlvblByb3RvY29sLCBKU1N0cmluZ1JlZiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBzb3VyY2VP cmlnaW5DRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0 LCBzb3VyY2VPcmlnaW4pKTsKKyAgICBOU1N0cmluZyAqc291cmNlT3JpZ2luTlMgPSAoTlNTdHJp bmcgKilzb3VyY2VPcmlnaW5DRi5nZXQoKTsKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHBy b3RvY29sQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVs dCwgZGVzdGluYXRpb25Qcm90b2NvbCkpOworICAgIE5TU3RyaW5nICpkZXN0aW5hdGlvblByb3Rv Y29sTlMgPSAoTlNTdHJpbmcgKilwcm90b2NvbENGLmdldCgpOworICAgIFJldGFpblB0cjxDRlN0 cmluZ1JlZj4gaG9zdENGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRv ckRlZmF1bHQsIGRlc3RpbmF0aW9uSG9zdCkpOworICAgIE5TU3RyaW5nICpkZXN0aW5hdGlvbkhv c3ROUyA9IChOU1N0cmluZyAqKWhvc3RDRi5nZXQoKTsKKyAgICBbV2ViVmlldyBfd2hpdGVMaXN0 QWNjZXNzRnJvbU9yaWdpbjpzb3VyY2VPcmlnaW5OUyBkZXN0aW5hdGlvblByb3RvY29sOmRlc3Rp bmF0aW9uUHJvdG9jb2xOUyBkZXN0aW5hdGlvbkhvc3Q6ZGVzdGluYXRpb25Ib3N0TlMgYWxsb3dE ZXN0aW5hdGlvblN1YmRvbWFpbnM6YWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnNdOworfQpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3Bw IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4 IDE2N2E0YzUuLjVlMzA5ZjQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3F0L0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9x dC9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTIxOCw2ICsyMTgsNyBAQCB2b2lkIER1bXBSZW5kZXJU cmVlOjpyZXNldFRvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAgICAgLy9Xb3JrUXVl dWU6OnNoYXJlZCgpLT5zZXRGcm96ZW4oZmFsc2UpOwogCiAgICAgbV9jb250cm9sbGVyLT5yZXNl dCgpOworICAgIFFXZWJTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Rz KCk7CiB9CiAKIHZvaWQgRHVtcFJlbmRlclRyZWU6Om9wZW4oY29uc3QgUVVybCYgYXVybCkKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHAgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9qc29iamVjdHMuY3BwCmluZGV4IGM5ZTdiODQu LjRiZWYzYjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2Jq ZWN0cy5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNw cApAQCAtMzM3LDYgKzMzNywxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpjbGVhckFs bERhdGFiYXNlcygpCiAgICAgUVdlYkRhdGFiYXNlOjpyZW1vdmVBbGxEYXRhYmFzZXMoKTsKIH0K IAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihj b25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJv dG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0 aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJv bU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9uSG9z dCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworfQorCiBFdmVudFNlbmRlcjo6RXZlbnRT ZW5kZXIoUVdlYlBhZ2UgKnBhcmVudCkKICAgICA6IFFPYmplY3QocGFyZW50KQogewpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVy V2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJv bGxlcldpbi5jcHAKaW5kZXggNTc0MzQ0Zi4uMzgzYjAwNiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3Bw CkBAIC04MTYsMyArODE2LDggQEAgdW5zaWduZWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om51bWJl ck9mQWN0aXZlQW5pbWF0aW9ucygpIGNvbnN0CiAKICAgICByZXR1cm4gbnVtYmVyOwogfQorCit2 b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKEpTU3Ry aW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Qcm90b2NvbCwgSlNT dHJpbmdSZWYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5z KQoreworICAgIHByaW50ZigiTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW4gbm90IGltcGxlbWVudGVkXG4iKTsKK30K 35181 2009-08-19 20:16:43 -0700 2009-08-19 21:24:10 -0700 New patch patch.txt text/plain 52557 aa ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlZGE4Nzc4Li4xYjkyMWUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDgt MTkgIEFhcm9uIEJvb2RtYW4gIDxhYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI0ODUzOiBQcm92aWRlIGEgd2F5IGZvciBXZWJLaXQgY2xpZW50cyB0bwor ICAgICAgICBzcGVjaWZ5IGEgbW9yZSBncmFudWxhciBwb2xpY3kgZm9yIGNyb3NzLW9yaWdpbiBY SFIgYWNjZXNzLgorCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4 YWN0LW1hdGNoLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1odHRwcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBo dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdp bi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2VzLXdpdGgtc3ViZG9tYWlucy5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5n LXN1YmRvbWFpbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDgtMTkgIFJ5b3N1a2UgTml3YSAgPHJu aXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctYWxsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEyYmE0MmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctYWxs LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDExIEBACitUZXN0cyB0aGUgc3BlY2lhbCBjYXNlIG9m IHdoaXRlbGlzdGluZyBhbGwgb3JpZ2lucy4KKworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4 MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUwor VGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9n ZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKK1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAw MC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCAoc3luYykKK1BBU1M6IFBBU1MKK1Rl c3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0 LnR4dCAoYXN5bmMpCitQQVNTOiBQQVNTCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMDc4NWUxCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4t d2hpdGVsaXN0aW5nLWFsbC5odG1sCkBAIC0wLDAgKzEsNTYgQEAKKzxwPlRlc3RzIHRoZSBzcGVj aWFsIGNhc2Ugb2Ygd2hpdGVsaXN0aW5nIGFsbCBvcmlnaW5zLjwvcD4KKworPHByZSBpZD0iY29u c29sZSI+PC9wcmU+Cis8c2NyaXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OworbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwg Imh0dHAiLCAiIiwgdHJ1ZSk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NG cm9tT3JpZ2luKCJodHRwOi8vbG9jYWxob3N0OjgwMDAiLCAiaHR0cCIsICIiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0RG9tYWluKCkKK3sKKyAgICB2YXIgdXJsID0gImh0dHA6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCI7CisgICAg bG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoc3luYykiKTsKKyAgICB2YXIgcmVxID0gbmV3IFhN TEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgZmFsc2UpOworICAgIHRy eSB7CisgICAgICAgIHJlcS5zZW5kKG51bGwpOworICAgICAgICBsb2coIlBBU1M6ICIgKyByZXEu cmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNoIChlKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IGUpOworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOwor ICAgIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmws IHRydWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKCJQQVNT OiAiICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgICAgIHRlc3RJUEFkZHJlc3MoKTsKKyAgICB9 OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGxvZygiRkFJTDogIiAr IHJlcS5zdGF0dXMpOworICAgICAgICB0ZXN0SVBBZGRyZXNzKCk7CisgICAgfTsKKyAgICByZXEu c2VuZChudWxsKTsKK30KKworZnVuY3Rpb24gdGVzdElQQWRkcmVzcygpCit7CisgICAgdmFyIGlm cmFtZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImlmcmFtZSIpOworICAgIGRvY3VtZW50LmJv ZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKKyAgICBpZnJhbWUuc3JjID0gImh0dHA6Ly9sb2NhbGhv c3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1h ZGRyZXNzLXRlc3QuaHRtbCI7CisgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoIm1lc3NhZ2Ui LCBmdW5jdGlvbihlKSB7CisgICAgICAgIGlmIChlLmRhdGEgPT0gIkRPTkUiKQorICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICBlbHNlCisgICAg ICAgICAgICBsb2coZS5kYXRhKTsKKyAgICB9LCBmYWxzZSk7Cit9CisKK3Rlc3REb21haW4oKTsK Kzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFj dC1tYXRjaC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u Yjk5MTZhMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1leGFjdC1tYXRjaC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwxMSBAQAorVGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5z IHVzaW5nIGV4YWN0IG1hdGNoaW5nLgorCitUZXN0aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQgKHN5bmMpCitQQVNTOiBQQVNTCitUZXN0 aW5nOiBodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50 eHQgKGFzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFTUzogUEFTUworVGVzdGlu ZzogaHR0cDovL2xvQ0FMaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct ZXhhY3QtbWF0Y2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMzVl OWRlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1hdGNoLmh0bWwKQEAgLTAsMCArMSw2MCBA QAorPHA+VGVzdHMgdGhlIGJlaGF2aW9yIG9mIHdoaXRlbGlzdGluZyBvcmlnaW5zIHVzaW5nIGV4 YWN0IG1hdGNoaW5nLjwvcD4KKworPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0Pgor bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIu d2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNjZXNzRnJv bU9yaWdpbigiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImh0dHAiLCAibG9jYWxob3N0IiwgZmFs c2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3Nh Z2UgKyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQorewor ICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5l dyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAg ICB0cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNj ZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNh dGNoIChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6 ICIpICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMp Iik7CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIs IHVybCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2co KGV4cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQp OworICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlv bigpIHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikg KyByZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5k KG51bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAv eG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXSwKKyAgICBbImh0dHA6Ly9s b0NBTGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIHRydWVdCisg ICAgLy8gRklYTUU6IElzIGl0IHBvc3NpYmxlIHRvIHNldHVwIHRoZSBmb2xsb3dpbmcgdGVzdHM/ CisgICAgLy8gWyJodHRwOi8vbG9jYWxob3N0OjgwMDEveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2dldC50eHQiLCBmYWxzZV0sCisgICAgLy8gWyJodHRwOi8vZm9vLmxvY2FsaG9zdDo4MDAwL3ht bGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdLAorICAgIC8vIFsiaHR0cHM6 Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4dCIsIGZhbHNl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3ht bGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaHR0cHMtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUzM2M0YTgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rp bmctaHR0cHMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGVzdHMgdGhhdCBvcmlnaW4g d2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBodHRwIFVSTHMuCisKK1Rlc3Rp bmc6IGh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvZ2V0LnR4 dCAoc3luYykKK1BBU1M6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3QgRXhjZXB0 aW9uIDEwMQorVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0 bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3RpbmctaHR0cHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMGU2 MDZlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKQEAgLTAsMCArMSw1NyBAQAorPHA+ VGVzdHMgdGhhdCBvcmlnaW4gd2hpdGVsaXN0aW5nIGZvciBodHRwcyBkb2VzIG5vdCBtYXRjaCBo dHRwIFVSTHMuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0 VW50aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3Jp Z2luKCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cHMiLCAibG9jYWxob3N0IiwgZmFsc2Up OworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2Ug KyAnXG4nKSk7Cit9CisKK2Z1bmN0aW9uIHRlc3QodXJsLCBleHBlY3RTdWNjZXNzKQoreworICAg IGxvZygiVGVzdGluZzogIiArIHVybCArICIgKHN5bmMpIik7CisgICAgdmFyIHJlcSA9IG5ldyBY TUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIGZhbHNlKTsKKyAgICB0 cnkgeworICAgICAgICByZXEuc2VuZChudWxsKTsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNz ID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICB9IGNhdGNo IChlKSB7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIp ICsgZSk7CisgICAgfQorCisgICAgbG9nKCJUZXN0aW5nOiAiICsgdXJsICsgIiAoYXN5bmMpIik7 CisgICAgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVy bCwgdHJ1ZSk7CisgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICBsb2coKGV4 cGVjdFN1Y2Nlc3MgPyAiUEFTUzogIiA6ICJGQUlMOiAiKSArIHJlcS5yZXNwb25zZVRleHQpOwor ICAgICAgICBuZXh0VGVzdCgpOworICAgIH07CisgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlvbigp IHsKKyAgICAgICAgbG9nKChleHBlY3RTdWNjZXNzID8gIkZBSUw6ICIgOiAiUEFTUzogIikgKyBy ZXEuc3RhdHVzKTsKKyAgICAgICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5zZW5kKG51 bGwpOworfQorCit2YXIgdGVzdHMgPSBbCisgICAgWyJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1s aHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCBmYWxzZV0KKyAgICAvLyBGSVhNRTogSXMg aXQgcG9zc2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHBz Oi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVl XQorXTsKKwordmFyIGN1cnJlbnRUZXN0ID0gMDsKKworZnVuY3Rpb24gbmV4dFRlc3QoKQorewor ICAgIGlmIChjdXJyZW50VGVzdCA8IHRlc3RzLmxlbmd0aCkKKyAgICAgICAgdGVzdC5hcHBseShu dWxsLCB0ZXN0c1tjdXJyZW50VGVzdCsrXSk7CisgICAgZWxzZQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cit9CisKK25leHRUZXN0KCk7Cis8L3NjcmlwdD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdo aXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3Nlcy1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDA5OTQ3NAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3Jp Z2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBA QAorVGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyB3aXRoIElQIGFkZHJlc3Nlcy4KKworVGVzdGlu ZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0 IChzeW5jKQorUEFTUzogUEFTUworVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0 dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVs aXN0aW5nLWlwLWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmNkZTY4MzIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3RpbmctaXAtYWRkcmVzc2Vz LXdpdGgtc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitTcGVjaWZ5aW5n IHRoYXQgYW4gSVAgYWRkcmVzcyBzaG91bGQgbWF0Y2ggc3ViZG9tYWlucyBkb2Vzbid0IG1ha2Ug c2Vuc2UuIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGl0IGRvZXNuJ3QgZG8gYW55dGhpbmcuCisK K1Rlc3Rpbmc6IGh0dHA6Ly8xMjcuMC4wLjE6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv Z2V0LnR4dCAoc3luYykKK0ZBSUw6IEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3Qg RXhjZXB0aW9uIDEwMQorVGVzdGluZzogaHR0cDovLzEyNy4wLjAuMTo4MDAwL3htbGh0dHByZXF1 ZXN0L3Jlc291cmNlcy9nZXQudHh0IChhc3luYykKK0ZBSUw6IDAKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlw LWFkZHJlc3Nlcy13aXRoLXN1YmRvbWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv eG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJk b21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODUwZDE2Mgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSwyMiBAQAorPHA+U3BlY2lmeWluZyB0aGF0IGFuIElQIGFkZHJlc3Mgc2hvdWxkIG1h dGNoIHN1YmRvbWFpbnMgZG9lc24ndCBtYWtlIHNlbnNlLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhh dCBpdCBkb2Vzbid0IGRvIGFueXRoaW5nLjwvcD4KKzxwcmUgaWQ9ImNvbnNvbGUiPjwvcHJlPgor PHNjcmlwdD4KK2xheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK2xheW91dFRlc3RD b250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK2xheW91dFRlc3RDb250cm9sbGVyLndoaXRlTGlz dEFjY2Vzc0Zyb21PcmlnaW4oImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMCIsICJodHRwIiwgIiouMC4w LjEiLCB0cnVlKTsKKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9k ZShtZXNzYWdlICsgJ1xuJykpOworfQorCit2YXIgaWZyYW1lID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgiaWZyYW1lIik7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGlmcmFtZSk7CitpZnJh bWUuc3JjID0gImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv b3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzLXRlc3QuaHRtbCI7Cit3aW5kb3cuYWRkRXZl bnRMaXN0ZW5lcigibWVzc2FnZSIsIGZ1bmN0aW9uKGUpIHsKKyAgICBpZiAoZS5kYXRhID09ICJE T05FIikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIGVs c2UKKyAgICAgICAgbG9nKGUuZGF0YSk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlz dGluZy1pcC1hZGRyZXNzZXMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5hM2EzYWY3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWlwLWFk ZHJlc3Nlcy5odG1sCkBAIC0wLDAgKzEsMjIgQEAKKzxwPlRlc3RzIG9yaWdpbiB3aGl0ZWxpc3Rp bmcgd2l0aCBJUCBhZGRyZXNzZXMuPC9wPgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2Ny aXB0PgorbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworbGF5b3V0VGVzdENvbnRyb2xsZXIud2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbigiaHR0cDovL2xvY2FsaG9zdDo4MDAwIiwgImh0dHAiLCAiMTI3LjAuMC4x IiwgZmFsc2UpOworCitmdW5jdGlvbiBsb2cobWVzc2FnZSkKK3sKKyAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnY29uc29sZScpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2Rl KG1lc3NhZ2UgKyAnXG4nKSk7Cit9CisKK3ZhciBpZnJhbWUgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJpZnJhbWUiKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaWZyYW1lKTsKK2lmcmFt ZS5zcmMgPSAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9v cmlnaW4td2hpdGVsaXN0aW5nLWlwLWFkZHJlc3MtdGVzdC5odG1sIjsKK3dpbmRvdy5hZGRFdmVu dExpc3RlbmVyKCJtZXNzYWdlIiwgZnVuY3Rpb24oZSkgeworICAgIGlmIChlLmRhdGEgPT0gIkRP TkUiKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZWxz ZQorICAgICAgICBsb2coZS5kYXRhKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0 aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRvbWFpbnMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlNjJlNGUKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxp c3Rpbmctc3ViZG9tYWlucy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitUZXN0cyBvcmln aW4gd2hpdGVsaXN0aW5nIHN1YmRvbWFpbiBiZWhhdmlvci4KKworVGVzdGluZzogaHR0cDovL2xv Y2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IChzeW5jKQorUEFT UzogUEFTUworVGVzdGluZzogaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jl c291cmNlcy9nZXQudHh0IChhc3luYykKK1BBU1M6IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2lu LXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uNjE2MTBlNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKQEAg LTAsMCArMSw1OSBAQAorPHA+VGVzdHMgb3JpZ2luIHdoaXRlbGlzdGluZyBzdWJkb21haW4gYmVo YXZpb3IuPC9wPgorCis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+CitsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50 aWxEb25lKCk7CitsYXlvdXRUZXN0Q29udHJvbGxlci53aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu KCJodHRwOi8vMTI3LjAuMC4xOjgwMDAiLCAiaHR0cCIsICJsb2NhbGhvc3QiLCB0cnVlKTsKKwor ZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nv bnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtZXNzYWdlICsgJ1xu JykpOworfQorCitmdW5jdGlvbiB0ZXN0KHVybCwgZXhwZWN0U3VjY2VzcykKK3sKKyAgICBsb2co IlRlc3Rpbmc6ICIgKyB1cmwgKyAiIChzeW5jKSIpOworICAgIHZhciByZXEgPSBuZXcgWE1MSHR0 cFJlcXVlc3QoKTsKKyAgICByZXEub3BlbigiR0VUIiwgdXJsLCBmYWxzZSk7CisgICAgdHJ5IHsK KyAgICAgICAgcmVxLnNlbmQobnVsbCk7CisgICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJQ QVNTOiAiIDogIkZBSUw6ICIpICsgcmVxLnJlc3BvbnNlVGV4dCk7CisgICAgfSBjYXRjaCAoZSkg eworICAgICAgICBsb2coKGV4cGVjdFN1Y2Nlc3MgPyAiRkFJTDogIiA6ICJQQVNTOiAiKSArIGUp OworICAgIH0KKworICAgIGxvZygiVGVzdGluZzogIiArIHVybCArICIgKGFzeW5jKSIpOworICAg IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgIHJlcS5vcGVuKCJHRVQiLCB1cmwsIHRy dWUpOworICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgbG9nKChleHBlY3RT dWNjZXNzID8gIlBBU1M6ICIgOiAiRkFJTDogIikgKyByZXEucmVzcG9uc2VUZXh0KTsKKyAgICAg ICAgbmV4dFRlc3QoKTsKKyAgICB9OworICAgIHJlcS5vbmVycm9yID0gZnVuY3Rpb24oKSB7Cisg ICAgICAgIGxvZygoZXhwZWN0U3VjY2VzcyA/ICJGQUlMOiAiIDogIlBBU1M6ICIpICsgcmVxLnN0 YXR1cyk7CisgICAgICAgIG5leHRUZXN0KCk7CisgICAgfTsKKyAgICByZXEuc2VuZChudWxsKTsK K30KKwordmFyIHRlc3RzID0gWworICAgIFsiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHBy ZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgdHJ1ZV0KKyAgICAvLyBGSVhNRTogSXMgaXQgcG9z c2libGUgdG8gc2V0dXAgdGhlIGZvbGxvd2luZyB0ZXN0cz8KKyAgICAvLyBbImh0dHA6Ly9mb28u bG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2VzL2dldC50eHQiLCB0cnVlXQor ICAgIC8vIFsiaHR0cDovL2Jhci5mb28ubG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVz b3VyY2VzL2dldC50eHQiLCB0cnVlXQorICAgIC8vIFsiaHR0cDovL2Zvb2xvY2FsaG9zdDo4MDAw L3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9nZXQudHh0IiwgZmFsc2VdCitdOworCit2YXIgY3Vy cmVudFRlc3QgPSAwOworCitmdW5jdGlvbiBuZXh0VGVzdCgpCit7CisgICAgaWYgKGN1cnJlbnRU ZXN0IDwgdGVzdHMubGVuZ3RoKQorICAgICAgICB0ZXN0LmFwcGx5KG51bGwsIHRlc3RzW2N1cnJl bnRUZXN0KytdKTsKKyAgICBlbHNlCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlm eURvbmUoKTsKK30KKworbmV4dFRlc3QoKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tp cHBlZAppbmRleCA4MTM3NDMxLi5hOTA0NTE3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93aW4vU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZApA QCAtNjM2LDMgKzYzNiwxMiBAQCBtZWRpYS92aWRlby1zb3VyY2UtZXJyb3IuaHRtbAogCiAjIDxo dHRwOi8vd2Via2l0Lm9yZy9iLzI4NDY3PgogaHR0cC90ZXN0cy9sb2FkaW5nL3ByZWxvYWQtaW1n LXRlc3QuaHRtbAorCisjIE1pc3NpbmcgTGF5b3V0VGVzdENvbnRyb2xsZXIgaW1wbGVtZW50YXRp b24KK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1hbGwuaHRt bAoraHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWV4YWN0LW1h dGNoLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1o dHRwcy5odG1sCitodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0ZWxpc3Rpbmct aXAtYWRkcmVzc2VzLmh0bWwKK2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRl bGlzdGluZy1pcC1hZGRyZXNzZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKK2h0dHAvdGVzdHMveG1s aHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1zdWJkb21haW5zLmh0bWwKKwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjNmVlMDAw Li4zYmVhNGE5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0No YW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFA Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJv dmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUg Z3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICBU ZXN0czogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWFsbC5o dG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L29yaWdpbi13aGl0 ZWxpc3RpbmctZXhhY3QtbWF0Y2guaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy94bWxo dHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLWh0dHBzLmh0bWwKKyAgICAgICAgICAgICAg IGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNz ZXMtd2l0aC1zdWJkb21haW5zLmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMveG1saHR0 cHJlcXVlc3Qvb3JpZ2luLXdoaXRlbGlzdGluZy1pcC1hZGRyZXNzZXMuaHRtbAorICAgICAgICAg ICAgICAgaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9vcmlnaW4td2hpdGVsaXN0aW5nLXN1YmRv bWFpbnMuaHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDogRXhwb3J0IG1ldGhvZHMg dG8gbWFuaXB1bGF0ZSBvcmlnaW4gYWNjZXNzIHdoaXRlbGlzdHMgdG8gZW5hYmxlCisgICAgICAg IHRlc3RpbmcgdmlhIGxheW91dCB0ZXN0cy4KKworICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajogQWRkIE9yaWdpbkFjY2Vzc0VudHJ5LioKKyAgICAgICAgKiBHTlVt YWtlZmlsZS5hbTogRGl0dG8uCisgICAgICAgICogV2ViQ29yZS5neXBpOiBEaXR0by4KKyAgICAg ICAgKiBXZWJDb3JlLnBybzogRGl0dG8uCisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29y ZS52Y3Byb2o6IERpdHRvLgorICAgICAgICAqIFdlYkNvcmVTb3VyY2VzLmJsazogRGl0dG8uCisK KyAgICAgICAgKiBwYWdlL1NlY3VyaXR5T3JpZ2luLmg6IEltcGxlbWVudCBvcmlnaW4gYWNjZXNz IHdoaXRlbGlzdHMuCisgICAgICAgIChXZWJDb3JlOjpvcmlnaW5BY2Nlc3NNYXApOiBTdGF0aWMg Z2V0dGVyIGZvciBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luOjpjYW5SZXF1ZXN0KTogTW9kaWZ5IHJlcXVlc3QgY2hlY2tpbmcgbG9naWMgdG8gY2hl Y2sgd2hpdGVsaXN0cy4KKyAgICAgICAgKFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKTogQWRkIGFuIGVudHJ5IHRvIGEgd2hpdGVsaXN0LgorICAgICAg ICAoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cyk6 IENsZWFyIGFsbCB0aGUgd2hpdGVsaXN0cy4KKworICAgICAgICAqIHBhZ2UvT3JpZ2luQWNjZXNz RW50cnkuaDogQWRkZWQuIEFuIGVudHJ5IGluIGFuIG9yaWdpbiBhY2Nlc3Mgd2hpdGVsaXN0Lgor ICAgICAgICAqIHBhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwOiBEaXR0by4KKwogMjAwOS0wOC0x OSAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IERhdmlkIEh5YXR0IGFuZCBEYW4gQmVybnN0ZWluLgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggYzQzZTZmOC4u MzJlZDAzZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3Jl L0dOVW1ha2VmaWxlLmFtCkBAIC0xMzAwLDYgKzEzMDAsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0g XAogCVdlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuaCBcCiAJV2ViQ29yZS9wYWdlL05hdmlnYXRvckJh c2UuY3BwIFwKIAlXZWJDb3JlL3BhZ2UvTmF2aWdhdG9yQmFzZS5oIFwKKwlXZWJDb3JlL3BhZ2Uv T3JpZ2luQWNjZXNzRW50cnkuY3BwIFwKKwlXZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnku aCBcCiAJV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIFwKIAlXZWJDb3JlL3BhZ2UvUGFnZS5oIFwKIAlX ZWJDb3JlL3BhZ2UvUGFnZUdyb3VwLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUu YmFzZS5leHAgYi9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKaW5kZXggY2ZiYjIzYy4uOTBmZjM3 NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS5iYXNlLmV4cApAQCAtMzEyLDggKzMxMiwxMSBAQCBfX1pON1dlYkNvcmUxNFJlc291cmNl SGFuZGxlMTJyZWxlYXNlUHJveHlFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUhhbmRsZTIwZm9y Y2VDb250ZW50U25pZmZpbmdFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUxvYWRlcjE0Y2FuY2Vs bGVkRXJyb3JFdgogX19aTjdXZWJDb3JlMTRSZXNvdXJjZUxvYWRlcjE5c2V0U2hvdWxkQnVmZmVy RGF0YUViCi1fX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luMjRyZWdpc3RlclVSTFNjaGVtZUFz TG9jYWxFUktOU182U3RyaW5nRQogX19aTjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjZjcmVhdGVF UktOU180S1VSTEUKK19fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4xNmNyZWF0ZUZyb21TdHJp bmdFUktOU182U3RyaW5nRQorX19aTjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjI0cmVnaXN0ZXJV UkxTY2hlbWVBc0xvY2FsRVJLTlNfNlN0cmluZ0UKK19fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmln aW4yNXdoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW5FUktTMF9SS05TXzZTdHJpbmdFUzVfYgorX19a TjdXZWJDb3JlMTRTZWN1cml0eU9yaWdpbjI3cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzRXYK IF9fWk43V2ViQ29yZTE1QXJjaGl2ZVJlc291cmNlNmNyZWF0ZUVOM1dURjEwUGFzc1JlZlB0cklO U18xMlNoYXJlZEJ1ZmZlckVFRVJLTlNfNEtVUkxFUktOU182U3RyaW5nRVNBX1NBX1JLTlNfMTZS ZXNvdXJjZVJlc3BvbnNlRQogX19aTjdXZWJDb3JlMTVCYWNrRm9yd2FyZExpc3QxMHJlbW92ZUl0 ZW1FUE5TXzExSGlzdG9yeUl0ZW1FCiBfX1pON1dlYkNvcmUxNUJhY2tGb3J3YXJkTGlzdDEwc2V0 RW5hYmxlZEViCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2Vi Q29yZS5neXBpCmluZGV4IDY1MTEwZTIuLjdjMjZhNDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2Vi Q29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xNjYxLDYgKzE2NjEsOCBA QAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9yLmgnLAogICAgICAgICAgICAgJ3BhZ2UvTmF2 aWdhdG9yQmFzZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvTmF2aWdhdG9yQmFzZS5oJywKKyAg ICAgICAgICAgICdwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcCcsCisgICAgICAgICAgICAncGFn ZS9PcmlnaW5BY2Nlc3NFbnRyeS5oJywKICAgICAgICAgICAgICdwYWdlL1BhZ2UuY3BwJywKICAg ICAgICAgICAgICdwYWdlL1BhZ2UuaCcsCiAgICAgICAgICAgICAncGFnZS9QYWdlR3JvdXAuY3Bw JywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJv CmluZGV4IGE4ZDg5NGEuLmFiYTQzODEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8K KysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMTEwOCw2ICsxMTA4LDcgQEAgU09VUkNFUyAr PSBcCiAgICAgcGFnZS9IaXN0b3J5LmNwcCBcCiAgICAgcGFnZS9Mb2NhdGlvbi5jcHAgXAogICAg IHBhZ2UvTW91c2VFdmVudFdpdGhIaXRUZXN0UmVzdWx0cy5jcHAgXAorICAgIHBhZ2UvT3JpZ2lu QWNjZXNzRW50cnkuY3BwIFwKICAgICBwYWdlL1BhZ2UuY3BwIFwKICAgICBwYWdlL1BhZ2VHcm91 cC5jcHAgXAogICAgIHBhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcCBcCmRpZmYgLS1naXQg YS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29yZS9XZWJDb3Jl LnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCAwYTVjMzJjLi45ZGUyMTMzIDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTE2OTQxLDYgKzE2OTQxLDE0IEBACiAJCQkJ Pg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHBhZ2VcT3Jp Z2luQWNjZXNzRW50cnkuY3BwIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQorCQkJ CVJlbGF0aXZlUGF0aD0iLi5ccGFnZVxPcmlnaW5BY2Nlc3NFbnRyeS5oIg0KKwkJCQk+DQorCQkJ PC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccGFnZVxQYWdlLmNwcCIN CiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IGM3YzczNjUuLjhiMzQ1YTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMSw2ICsyMSw4IEBACiAvKiBFbmQgUEJYQWdncmVnYXRl VGFyZ2V0IHNlY3Rpb24gKi8KIAogLyogQmVnaW4gUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KKwkJ MDAxNDYyOEExMDNDRDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDAwMTQ2Mjg4MTAzQ0QxREUw MDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi87IH07CisJCTAwMTQ2MjhCMTAzQ0Qx REUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDAxNDYyODkxMDNDRDFERTAwMEIyMERCIC8qIE9yaWdp bkFjY2Vzc0VudHJ5LmggKi87IH07CiAJCTA2MDI3Q0FEMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250 ZXh0TWVudUl0ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDA2MDI3Q0FDMEIxQ0JGQzAwMDg4NEIyRCAvKiBDb250ZXh0TWVudUl0ZW0uaCAqLzsgc2V0 dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQkwNjAyN0NCMzBCMUND MDNEMDA4ODRCMkQgLyogQ29udGV4dE1lbnVJdGVtTWFjLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMDYwMjdDQjIwQjFDQzAzRDAwODg0QjJEIC8qIENv bnRleHRNZW51SXRlbU1hYy5tbSAqLzsgfTsKIAkJMDYyMjg3ODQwQjREQjMyMjAwMEMzNERGIC8q IEZvY3VzRGlyZWN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSAwNjIyODc4MzBCNERCMzIyMDAwQzM0REYgLyogRm9jdXNEaXJlY3Rpb24uaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtNTAwNiw2ICs1 MDA4LDggQEAKIC8qIEVuZCBQQlhDb3B5RmlsZXNCdWlsZFBoYXNlIHNlY3Rpb24gKi8KIAogLyog QmVnaW4gUEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9uICovCisJCTAwMTQ2Mjg4MTAzQ0QxREUwMDBC MjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCTAwMTQ2Mjg5MTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPcmlnaW5BY2Nlc3NFbnRyeS5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwNjAyN0NBQzBCMUNCRkMwMDA4ODRCMkQgLyogQ29u dGV4dE1lbnVJdGVtLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb250ZXh0 TWVudUl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMDYwMjdDQjIwQjFDQzAz RDAwODg0QjJEIC8qIENvbnRleHRNZW51SXRlbU1hYy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5vYmpjcHA7IHBhdGggPSBDb250ZXh0TWVudUl0ZW1NYWMubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTA2MjI4NzgzMEI0REIzMjIwMDBDMzRERiAvKiBGb2N1c0RpcmVjdGlv bi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRm9jdXNEaXJlY3Rpb24uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEwNjgxLDYgKzEwNjg1LDggQEAKIAkJCQlB OUM2RTY1RDBENzQ2Njk0MDA2NDQyRTkgLyogTmF2aWdhdG9yLmlkbCAqLywKIAkJCQlFMTI3MTlD OTBFRUVDMjEzMDBGNjEyMTMgLyogTmF2aWdhdG9yQmFzZS5jcHAgKi8sCiAJCQkJRTEyNzE5QzYw RUVFQzE2ODAwRjYxMjEzIC8qIE5hdmlnYXRvckJhc2UuaCAqLywKKwkJCQkwMDE0NjI4ODEwM0NE MURFMDAwQjIwREIgLyogT3JpZ2luQWNjZXNzRW50cnkuY3BwICovLAorCQkJCTAwMTQ2Mjg5MTAz Q0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5oICovLAogCQkJCTY1RkVBODY4MDk4 MzNBREUwMEJFRDRBQiAvKiBQYWdlLmNwcCAqLywKIAkJCQk2NUEyMTQ2NzA5N0EzMjkxMDBCOTA1 MEEgLyogUGFnZS5oICovLAogCQkJCTkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3Jv dXAuY3BwICovLApAQCAtMTczMTYsNiArMTczMjIsNyBAQAogCQkJCUI1QzExMjNDMTAyQjZDNDYw MDA5NjU3OCAvKiBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmggaW4gSGVhZGVycyAqLywKIAkJ CQlEOEI2MTUyRjEwMzI0OTUxMDBDODU1NEEgLyogQ29va2llLmggaW4gSGVhZGVycyAqLywKIAkJ CQlCQ0ZBOTMwODEwMzMzMTkzMDA3QjI1RDEgLyogUmVuZGVyT3ZlcmZsb3cuaCBpbiBIZWFkZXJz ICovLAorCQkJCTAwMTQ2MjhCMTAzQ0QxREUwMDBCMjBEQiAvKiBPcmlnaW5BY2Nlc3NFbnRyeS5o IGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vz c2luZyA9IDA7CiAJCX07CkBAIC0xOTM4Miw2ICsxOTM4OSw3IEBACiAJCQkJOTM5MjI2MkQxMDMy MTA3QjAwNkU3RDVEIC8qIEpTSFRNTENhbnZhc0VsZW1lbnRDdXN0b20uY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJOTM5MjI2MkYxMDMyMTA4NDAwNkU3RDVEIC8qIEpTQ1NTUnVsZUxpc3RDdXN0b20u Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQjVDMTEyM0IxMDJCNkM0NjAwMDk2NTc4IC8qIFNRTFRy YW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJMDAxNDYyOEExMDND RDFERTAwMEIyMERCIC8qIE9yaWdpbkFjY2Vzc0VudHJ5LmNwcCBpbiBTb3VyY2VzICovLAogCQkJ KTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlU291cmNlcy5ia2wgYi9XZWJDb3JlL1dlYkNvcmVTb3Vy Y2VzLmJrbAppbmRleCBhNDBjMmIxLi5mMWRjYTM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNv cmVTb3VyY2VzLmJrbAorKysgYi9XZWJDb3JlL1dlYkNvcmVTb3VyY2VzLmJrbApAQCAtNzY2LDYg Kzc2Niw3IEBAIFRoaXMgZmlsZSBjb250YWlucyB0aGUgbGlzdCBvZiBmaWxlcyBuZWVkZWQgdG8g YnVpbGQgV2ViQ29yZS4KICAgICAgICAgcGFnZS9Nb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRz LmNwcAogICAgICAgICBwYWdlL05hdmlnYXRvci5jcHAKICAgICAgICAgcGFnZS9OYXZpZ2F0b3JC YXNlLmNwcAorICAgICAgICBwYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmNwcAogICAgICAgICBwYWdl L1BhZ2UuY3BwCiAgICAgICAgIHBhZ2UvUGFnZUdyb3VwLmNwcAogICAgICAgICBwYWdlL1BhZ2VH cm91cExvYWREZWZlcnJlci5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nl c3NFbnRyeS5jcHAgYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmViMDhhMTcKLS0tIC9kZXYvbnVsbAorKysgYi9X ZWJDb3JlL3BhZ2UvT3JpZ2luQWNjZXNzRW50cnkuY3BwCkBAIC0wLDAgKzEsODIgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlz dHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKKworI2luY2x1ZGUg IkNUeXBlLmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKworbmFtZXNwYWNlIFdlYkNv cmUgeworICAgIAorT3JpZ2luQWNjZXNzRW50cnk6Ok9yaWdpbkFjY2Vzc0VudHJ5KGNvbnN0IFN0 cmluZyYgcHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgaG9zdCwgU3ViZG9tYWluU2V0dGluZyBzdWJk b21haW5TZXR0aW5nKQorICAgIDogbV9wcm90b2NvbChwcm90b2NvbC5sb3dlcigpKQorICAgICwg bV9ob3N0KGhvc3QubG93ZXIoKSkKKyAgICAsIG1fc3ViZG9tYWluU2V0dGluZ3Moc3ViZG9tYWlu U2V0dGluZykKK3sKKyAgICBBU1NFUlQobV9wcm90b2NvbCA9PSAiaHR0cCIgfHwgbV9wcm90b2Nv bCA9PSAiaHR0cHMiKTsKKyAgICBBU1NFUlQoc3ViZG9tYWluU2V0dGluZyA9PSBBbGxvd1N1YmRv bWFpbnMgfHwgc3ViZG9tYWluU2V0dGluZyA9PSBEaXNhbGxvd1N1YmRvbWFpbnMpOworCisgICAg Ly8gQXNzdW1lIHRoYXQgYW55IGhvc3QgdGhhdCBlbmRzIHdpdGggYSBkaWdpdCBpcyB0cnlpbmcg dG8gYmUgYW4gSVAgYWRkcmVzcy4KKyAgICBtX2hvc3RJc0lQQWRkcmVzcyA9ICFtX2hvc3QuaXNF bXB0eSgpICYmIGlzQVNDSUlEaWdpdChtX2hvc3RbbV9ob3N0Lmxlbmd0aCgpIC0gMV0pOworfQor Citib29sIE9yaWdpbkFjY2Vzc0VudHJ5OjptYXRjaGVzT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3Jp Z2luJiBvcmlnaW4pIGNvbnN0Cit7CisgICAgQVNTRVJUKG9yaWdpbi5ob3N0KCkgPT0gb3JpZ2lu Lmhvc3QoKS5sb3dlcigpKTsKKyAgICBBU1NFUlQob3JpZ2luLnByb3RvY29sKCkgPT0gb3JpZ2lu LnByb3RvY29sKCkubG93ZXIoKSk7CisKKyAgICBpZiAobV9wcm90b2NvbCAhPSBvcmlnaW4ucHJv dG9jb2woKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIAorICAgIC8vIFNwZWNpYWwgY2Fz ZTogSW5jbHVkZSBzdWJkb21haW5zIGFuZCBlbXB0eSBob3N0IG1lYW5zICJhbGwgaG9zdHMsIGlu Y2x1ZGluZyBpcCBhZGRyZXNzZXMiLgorICAgIGlmIChtX3N1YmRvbWFpblNldHRpbmdzID09IEFs bG93U3ViZG9tYWlucyAmJiBtX2hvc3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICAKKyAgICAvLyBFeGFjdCBtYXRjaC4KKyAgICBpZiAobV9ob3N0ID09IG9yaWdpbi5ob3N0 KCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIAorICAgIC8vIE90aGVyd2lzZSB3ZSBjYW4g b25seSBtYXRjaCBpZiB3ZSdyZSBtYXRjaGluZyBzdWJkb21haW5zLgorICAgIGlmIChtX3N1YmRv bWFpblNldHRpbmdzID09IERpc2FsbG93U3ViZG9tYWlucykKKyAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIAorICAgIC8vIERvbid0IHRyeSB0byBkbyBzdWJkb21haW4gbWF0Y2hpbmcgb24gSVAg YWRkcmVzc2VzLgorICAgIGlmIChtX2hvc3RJc0lQQWRkcmVzcykKKyAgICAgICAgcmV0dXJuIGZh bHNlOworICAgIAorICAgIC8vIE1hdGNoIHN1YmRvbWFpbnMuCisgICAgaWYgKG9yaWdpbi5ob3N0 KCkubGVuZ3RoKCkgPiBtX2hvc3QubGVuZ3RoKCkgJiYgb3JpZ2luLmhvc3QoKVtvcmlnaW4uaG9z dCgpLmxlbmd0aCgpIC0gbV9ob3N0Lmxlbmd0aCgpIC0gMV0gPT0gJy4nICYmIG9yaWdpbi5ob3N0 KCkuZW5kc1dpdGgobV9ob3N0KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgcmV0 dXJuIGZhbHNlOworfQorICAgIAorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmggYi9XZWJDb3JlL3BhZ2UvT3JpZ2luQWNj ZXNzRW50cnkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NjdkNzVmCi0t LSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKQEAgLTAs MCArMSw2MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgQ3Jvc3NPcmlnaW5BY2Nlc3NfaAorI2RlZmluZSBDcm9zc09yaWdp bkFjY2Vzc19oCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorCituYW1lc3BhY2UgV2Vi Q29yZSB7CisKK2NsYXNzIFNlY3VyaXR5T3JpZ2luOworCitjbGFzcyBPcmlnaW5BY2Nlc3NFbnRy eSB7CitwdWJsaWM6CisgICAgZW51bSBTdWJkb21haW5TZXR0aW5nIHsKKyAgICAgICAgQWxsb3dT dWJkb21haW5zLAorICAgICAgICBEaXNhbGxvd1N1YmRvbWFpbnMKKyAgICB9OworCisgICAgLy8g SWYgaG9zdCBpcyBlbXB0eSBzdHJpbmcgYW5kIFN1YmRvbWFpblNldHRpbmcgaXMgQWxsb3dTdWJk b21haW5zLCB0aGUgZW50cnkgd2lsbCBtYXRjaCBhbGwgZG9tYWlucyBpbiB0aGUgc3BlY2lmaWVk IHByb3RvY29sLgorICAgIE9yaWdpbkFjY2Vzc0VudHJ5KGNvbnN0IFN0cmluZyYgcHJvdG9jb2ws IGNvbnN0IFN0cmluZyYgaG9zdCwgU3ViZG9tYWluU2V0dGluZyk7CisgICAgYm9vbCBtYXRjaGVz T3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJikgY29uc3Q7CisgICAgCitwcml2YXRlOgorICAg IFN0cmluZyBtX3Byb3RvY29sOworICAgIFN0cmluZyBtX2hvc3Q7CisgICAgU3ViZG9tYWluU2V0 dGluZyBtX3N1YmRvbWFpblNldHRpbmdzOworICAgIGJvb2wgbV9ob3N0SXNJUEFkZHJlc3M7Cisg ICAgCit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDcm9zc09yaWdp bkFjY2Vzc19oCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwIGIv V2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAppbmRleCA4Mjc0ZTBlLi4zM2VkZTAwIDEw MDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCisrKyBiL1dlYkNvcmUv cGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKQEAgLTMyLDEwICszMiwyMCBAQAogI2luY2x1ZGUgIkNT dHJpbmcuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgogI2luY2x1ZGUgIktVUkwuaCIKKyNp bmNsdWRlICJPcmlnaW5BY2Nlc3NFbnRyeS5oIgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMu aD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit0eXBlZGVmIFZlY3RvcjxPcmlnaW5BY2Nlc3NF bnRyeT4gT3JpZ2luQWNjZXNzV2hpdGVMaXN0OwordHlwZWRlZiBIYXNoTWFwPFN0cmluZywgT3Jp Z2luQWNjZXNzV2hpdGVMaXN0Kj4gT3JpZ2luQWNjZXNzTWFwOworCitzdGF0aWMgT3JpZ2luQWNj ZXNzTWFwJiBvcmlnaW5BY2Nlc3NNYXAoKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoT3Jp Z2luQWNjZXNzTWFwLCBvcmlnaW5BY2Nlc3NNYXAsICgpKTsKKyAgICByZXR1cm4gb3JpZ2luQWNj ZXNzTWFwOworfQorCiBzdGF0aWMgVVJMU2NoZW1lc01hcCYgbG9jYWxTY2hlbWVzKCkKIHsKICAg ICBERUZJTkVfU1RBVElDX0xPQ0FMKFVSTFNjaGVtZXNNYXAsIGxvY2FsU2NoZW1lcywgKCkpOwpA QCAtMTk4LDcgKzIwOCwxNyBAQCBib29sIFNlY3VyaXR5T3JpZ2luOjpjYW5SZXF1ZXN0KGNvbnN0 IEtVUkwmIHVybCkgY29uc3QKIAogICAgIC8vIFdlIGNhbGwgaXNTYW1lU2NoZW1lSG9zdFBvcnQg aGVyZSBpbnN0ZWFkIG9mIGNhbkFjY2VzcyBiZWNhdXNlIHdlIHdhbnQKICAgICAvLyB0byBpZ25v cmUgZG9jdW1lbnQuZG9tYWluIGVmZmVjdHMuCi0gICAgcmV0dXJuIGlzU2FtZVNjaGVtZUhvc3RQ b3J0KHRhcmdldE9yaWdpbi5nZXQoKSk7CisgICAgaWYgKGlzU2FtZVNjaGVtZUhvc3RQb3J0KHRh cmdldE9yaWdpbi5nZXQoKSkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgaWYgKE9yaWdp bkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IG9yaWdpbkFjY2Vzc01hcCgpLmdldCh0b1N0cmluZygp KSkgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGxpc3QtPnNpemUoKTsgKytpKSB7 CisgICAgICAgICAgICBpZiAobGlzdC0+YXQoaSkubWF0Y2hlc09yaWdpbigqdGFyZ2V0T3JpZ2lu KSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgIH0KKworICAg IHJldHVybiBmYWxzZTsKIH0KIAogdm9pZCBTZWN1cml0eU9yaWdpbjo6Z3JhbnRMb2FkTG9jYWxS ZXNvdXJjZXMoKQpAQCAtNDE0LDQgKzQzNCwyOCBAQCBib29sIFNlY3VyaXR5T3JpZ2luOjpzaG91 bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29uc3QgU3RyaW5nJiBzY2hlbWUpCiAgICAgcmV0 dXJuIG5vQWNjZXNzU2NoZW1lcygpLmNvbnRhaW5zKHNjaGVtZSk7CiB9CiAKK3ZvaWQgU2VjdXJp dHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4m IHNvdXJjZU9yaWdpbiwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBT dHJpbmcmIGRlc3RpbmF0aW9uRG9tYWlucywgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlu cykKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVCghc291cmNlT3Jp Z2luLmlzRW1wdHkoKSk7CisgICAgaWYgKHNvdXJjZU9yaWdpbi5pc0VtcHR5KCkpCisgICAgICAg IHJldHVybjsKKworICAgIFN0cmluZyBzb3VyY2VTdHJpbmcgPSBzb3VyY2VPcmlnaW4udG9TdHJp bmcoKTsKKyAgICBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3QqIGxpc3QgPSBvcmlnaW5BY2Nlc3NNYXAo KS5nZXQoc291cmNlU3RyaW5nKTsKKyAgICBpZiAoIWxpc3QpIHsKKyAgICAgICAgbGlzdCA9IG5l dyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Q7CisgICAgICAgIG9yaWdpbkFjY2Vzc01hcCgpLnNldChz b3VyY2VTdHJpbmcsIGxpc3QpOworICAgIH0KKyAgICBsaXN0LT5hcHBlbmQoT3JpZ2luQWNjZXNz RW50cnkoZGVzdGluYXRpb25Qcm90b2NvbCwgZGVzdGluYXRpb25Eb21haW5zLCBhbGxvd0Rlc3Rp bmF0aW9uU3ViZG9tYWlucyA/IE9yaWdpbkFjY2Vzc0VudHJ5OjpBbGxvd1N1YmRvbWFpbnMgOiBP cmlnaW5BY2Nlc3NFbnRyeTo6RGlzYWxsb3dTdWJkb21haW5zKSk7Cit9CisKK3ZvaWQgU2VjdXJp dHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpCit7CisgICAgQVNTRVJUKGlz TWFpblRocmVhZCgpKTsKKyAgICBPcmlnaW5BY2Nlc3NNYXAmIG1hcCA9IG9yaWdpbkFjY2Vzc01h cCgpOworICAgIGRlbGV0ZUFsbFZhbHVlcyhtYXApOworICAgIG1hcC5jbGVhcigpOworfQorCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlP cmlnaW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDMzNWVkMjguLmNj MmFjZGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCisrKyBiL1dl YkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0xNDEsNiArMTQxLDkgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICBzdGF0aWMgdm9pZCByZWdpc3RlclVSTFNjaGVtZUFzTm9BY2Nl c3MoY29uc3QgU3RyaW5nJik7CiAgICAgICAgIHN0YXRpYyBib29sIHNob3VsZFRyZWF0VVJMU2No ZW1lQXNOb0FjY2Vzcyhjb25zdCBTdHJpbmcmKTsKIAorICAgICAgICBzdGF0aWMgdm9pZCB3aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2VPcmlnaW4s IGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3QgU3RyaW5nJiBkZXN0aW5h dGlvbkRvbWFpbnMsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworICAgICAgICBz dGF0aWMgdm9pZCByZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKKwogICAgIHByaXZhdGU6 CiAgICAgICAgIGV4cGxpY2l0IFNlY3VyaXR5T3JpZ2luKGNvbnN0IEtVUkwmKTsKICAgICAgICAg ZXhwbGljaXQgU2VjdXJpdHlPcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4qKTsKZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggNGZh MWFiNi4uMjQ0NzM3ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wOC0xOSAgQWFyb24gQm9v ZG1hbiAgPGFhQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjQ4NTM6IFByb3ZpZGUgYSB3YXkgZm9yIFdlYktpdCBjbGllbnRzIHRvCisgICAgICAgIHNwZWNp ZnkgYSBtb3JlIGdyYW51bGFyIHBvbGljeSBmb3IgY3Jvc3Mtb3JpZ2luIFhIUiBhY2Nlc3MuCisK KyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHA6CisgICAgICAgICh3ZWJraXRfd2hp dGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKTogQWRkIEFQSSB0byBtYW5pcHVsYXRlIG9yaWdpbiBh Y2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAgKHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNzX3do aXRlX2xpc3RzKTogRGl0dG8uCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDogRGl0 dG8uCisKIDIwMDktMDgtMTggIFhhbiBMb3BleiAgPHhsb3BlekBpZ2FsaWEuY29tPgogCiAgICAg ICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEhvbGdlciBGcmV5dGhlci4KZGlmZiAtLWdpdCBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAKaW5kZXggNzU1YjRkMy4uNGIzYzY1YyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZUNs aWVudC5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlSW50ZXJuYWwuaCIKICNpbmNsdWRlIDxy dW50aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuaD4KKyNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5o IgogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQogI2luY2x1ZGUgIkRhdGFiYXNlVHJhY2tlci5oIgpA QCAtMTc4LDMgKzE3OSwxMyBAQCB2b2lkIHdlYmtpdF9pbml0KCkKICAgICBzb3VwX3Nlc3Npb25f YWRkX2ZlYXR1cmUoc2Vzc2lvbiwgc25pZmZlcik7CiAgICAgZ19vYmplY3RfdW5yZWYoc25pZmZl cik7CiB9CisKK3ZvaWQgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX3RvX29yaWdpbihjb25zdCBn Y2hhciogc291cmNlT3JpZ2luLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Qcm90b2NvbCwgY29u c3QgZ2NoYXIqIGRlc3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlu cykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4oU2VjdXJp dHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcoc291cmNlT3JpZ2luKSwgZGVzdGluYXRpb25Qcm90 b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7Cit9CisK K3ZvaWQgd2Via2l0X3Jlc2V0X29yaWdpbl9hY2Nlc3Nfd2hpdGVfbGlzdHMoKQoreworICAgIFNl Y3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsKK30KZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuaAppbmRleCBkZTgxMjIyLi5jZjg5ZjcxIDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oCkBAIC0yNTMsNiArMjUzLDEyIEBAIGV4dGVybiAiQyIgewogCiAgICAgV0VC S0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3ZWJraXRfd29ya2VyX3RocmVhZF9jb3VudCgpOwor ICAgIAorICAgIFdFQktJVCBBUEkgdm9pZAorICAgIHdlYmtpdF93aGl0ZV9saXN0X2FjY2Vzc190 b19vcmlnaW4oY29uc3QgZ2NoYXIqIHNvdXJjZU9yaWdpbiwgY29uc3QgZ2NoYXIqIGRlc3RpbmF0 aW9uUHJvdG9jb2wsIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnMpOworICAgIAorICAgIFdFQktJVCBBUEkgdm9pZAorICAgIHdlYmtp dF9yZXNldF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3RzKCk7CiB9CiAKICNlbmRpZgpkaWZmIC0t Z2l0IGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cgYi9XZWJLaXQvbWFjL0NoYW5nZUxvZwppbmRleCA1 MzM1ZWZiLi4wOGY0NTM5IDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9X ZWJLaXQvbWFjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA4LTE5ICBBYXJvbiBC b29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3Bl Y2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4K KworICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5tbTogQWRkIFNQSSB0byBtYW5pcHVsYXRlIG9y aWdpbiBhY2Nlc3Mgd2hpdGVsaXN0cy4KKyAgICAgICAgKCtbV2ViVmlldyBfd2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbjpkZXN0aW5hdGlvblByb3RvY29sOmRlc3RpbmF0aW9uSG9zdDphbGxvd0Rl c3RpbmF0aW9uU3ViZG9tYWluczpdKTogRGl0dG8uCisgICAgICAgICgrW1dlYlZpZXcgX3Jlc2V0 T3JpZ2luQWNjZXNzV2hpdGVMaXN0c10pOiBEaXR0by4KKyAgICAgICAgKiBXZWJWaWV3L1dlYlZp ZXdQcml2YXRlLmg6IERpdHRvLgorCiAyMDA5LTA4LTE4ICBBbmRlcnMgQ2FybHNzb24gIDxhbmRl cnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRlbGUgUGV0ZXJzb24uCmRp ZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3Lm1tCmluZGV4IDNhM2NiNTkuLmYxNmIyNzUgMTAwNjQ0Ci0tLSBhL1dlYktp dC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 Lm1tCkBAIC0yMDkyLDYgKzIwOTIsMTUgQEAgc3RhdGljIGlubGluZSBJTVAgZ2V0TWV0aG9kKGlk IG8sIFNFTCBzKQogICAgIHJldHVybiBfcHJpdmF0ZSA/IF9wcml2YXRlLT5pbnNlcnRpb25QYXN0 ZWJvYXJkIDogbmlsOwogfQogCisrICh2b2lkKV93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luOihO U1N0cmluZyAqKXNvdXJjZU9yaWdpbiBkZXN0aW5hdGlvblByb3RvY29sOihOU1N0cmluZyAqKWRl c3RpbmF0aW9uUHJvdG9jb2wgZGVzdGluYXRpb25Ib3N0OihOU1N0cmluZyAqKWRlc3RpbmF0aW9u SG9zdCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczooQk9PTClhbGxvd0Rlc3RpbmF0aW9uU3Vi ZG9tYWlucworeworICAgIFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2lu KCpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhzb3VyY2VPcmlnaW4pLCBkZXN0aW5h dGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhvc3QsIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5z KTsKK30KKworKyh2b2lkKV9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMKK3sKKyAgICBTZWN1 cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7Cit9CiAKIC0gKHZvaWQp X3VwZGF0ZUFjdGl2ZVN0YXRlCiB7CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2Vi Vmlld1ByaXZhdGUuaCBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCmluZGV4 IDM2MmIyZTYuLjZjNDcyZDYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 UHJpdmF0ZS5oCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCkBAIC00 NDMsNiArNDQzLDE1IEBAIENvdWxkIGJlIHdvcnRoIGFkZGluZyB0byB0aGUgQVBJLgogLy8gV2hp Y2ggcGFzdGVib2FyZCB0ZXh0IGlzIGNvbWluZyBmcm9tIGluIGVkaXRpbmcgZGVsZWdhdGUgbWV0 aG9kcyBzdWNoIGFzIHNob3VsZEluc2VydE5vZGUuCiAtIChOU1Bhc3RlYm9hcmQgKilfaW5zZXJ0 aW9uUGFzdGVib2FyZDsKIAorLy8gV2hpdGVsaXN0cyBhY2Nlc3MgZnJvbSBhbiBvcmlnaW4gKHNv dXJjZU9yaWdpbikgdG8gYSBzZXQgb2Ygb25lIG9yIG1vcmUgb3JpZ2lucyBkZXNjcmliZWQgYnkg dGhlIHBhcmFtZXRlcnM6CisvLyAtIGRlc3RpbmF0aW9uUHJvdG9jb2w6IFRoZSBwcm90b2NvbCB0 byBncmFudCBhY2Nlc3MgdG8uCisvLyAtIGRlc3RpbmF0aW9uSG9zdDogVGhlIGhvc3QgdG8gZ3Jh bnQgYWNjZXNzIHRvLgorLy8gLSBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWluczogSWYgaG9zdCBp cyBhIGRvbWFpbiwgc2V0dGluZyB0aGlzIHRvIFlFUyB3aWxsIHdoaXRlbGlzdCBob3N0IGFuZCBh bGwgaXRzIHN1YmRvbWFpbnMsIHJlY3Vyc2l2ZWx5LgorKyAodm9pZClfd2hpdGVMaXN0QWNjZXNz RnJvbU9yaWdpbjooTlNTdHJpbmcgKilzb3VyY2VPcmlnaW4gZGVzdGluYXRpb25Qcm90b2NvbDoo TlNTdHJpbmcgKilkZXN0aW5hdGlvblByb3RvY29sIGRlc3RpbmF0aW9uSG9zdDooTlNTdHJpbmcg KilkZXN0aW5hdGlvbkhvc3QgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnM6KEJPT0wpYWxsb3dE ZXN0aW5hdGlvblN1YmRvbWFpbnM7CisKKy8vIFJlbW92ZXMgYWxsIHdoaXRlIGxpc3QgZW50cmll cyBjcmVhdGVkIHdpdGggX3doaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4uCisrICh2b2lkKV9yZXNl dE9yaWdpbkFjY2Vzc1doaXRlTGlzdHM7CisKIEBlbmQKIAogQGludGVyZmFjZSBXZWJWaWV3IChX ZWJWaWV3UHJpbnRpbmdQcml2YXRlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2Vj dXJpdHlvcmlnaW4uY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCmlu ZGV4IGIzMDA1YzIuLmZjZTlhOTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnNlY3Vy aXR5b3JpZ2luLmNwcAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAK QEAgLTIzNSwzICsyMzUsMTIgQEAgUVN0cmluZ0xpc3QgUVdlYlNlY3VyaXR5T3JpZ2luOjpsb2Nh bFNjaGVtZXMoKQogICAgIHJldHVybiBsaXN0OwogfQogCit2b2lkIFFXZWJTZWN1cml0eU9yaWdp bjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4s IGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3Rp bmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1 cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3Rp bmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFp bnMpOworfQorCit2b2lkIFFXZWJTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0 ZUxpc3RzKCkKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxp c3RzKCk7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5o IGIvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaAppbmRleCAxNmY4YmMxLi4wNTU2 Yjg5IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCisrKyBi L1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmgKQEAgLTQwLDYgKzQwLDggQEAgcHVi bGljOgogICAgIHN0YXRpYyB2b2lkIGFkZExvY2FsU2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVt ZSk7CiAgICAgc3RhdGljIHZvaWQgcmVtb3ZlTG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYgc2No ZW1lKTsKICAgICBzdGF0aWMgUVN0cmluZ0xpc3QgbG9jYWxTY2hlbWVzKCk7CisgICAgc3RhdGlj IHZvaWQgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmln aW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRl c3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisgICAgc3Rh dGljIHZvaWQgY2xlYXJPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CiAKICAgICB+UVdlYlNlY3Vy aXR5T3JpZ2luKCk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQv cXQvQ2hhbmdlTG9nCmluZGV4IGM1MTQ3ZWQuLjBhZjQ0YTAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9x dC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisy MDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlkZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVu dHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3JhbnVsYXIgcG9saWN5IGZvciBjcm9zcy1v cmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3Bw OiBBZGQgQVBJIHRvIG1hbmlwdWxhdGUgb3JpZ2luIGFjY2VzcyB3aGl0ZWxpc3RzLgorICAgICAg ICAoUVdlYlNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKTogRGl0dG8u CisgICAgICAgIChRV2ViU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2luQWNjZXNzV2hpdGVMaXN0 cyk6IERpdHRvLgorICAgICAgICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaDogRGl0dG8uCisK IDIwMDktMDgtMTggIE1hcmt1cyBHb2V0eiA8TWFya3VzLkdvZXR6QG5va2lhLmNvbT4KIAogICAg ICAgICBSZXZpd2VkIGJ5IEFyaXlhIEhpZGF5YXQuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9D aGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggMGY5OTIzMC4uMzU3NmJlNiAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDA5LTA4LTE5ICBBYXJvbiBCb29kbWFuICA8YWFAY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg1MzogUHJvdmlk ZSBhIHdheSBmb3IgV2ViS2l0IGNsaWVudHMgdG8KKyAgICAgICAgc3BlY2lmeSBhIG1vcmUgZ3Jh bnVsYXIgcG9saWN5IGZvciBjcm9zcy1vcmlnaW4gWEhSIGFjY2Vzcy4KKworICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDogRXhwb3NlIHdoaXRlTGlzdEFj Y2Vzc0Zyb21PcmlnaW4oKSB0byBsYXlvdXQgdGVzdHMuCisgICAgICAgICh3aGl0ZUxpc3RBY2Nl c3NGcm9tT3JpZ2luQ2FsbGJhY2spOiBEaXR0by4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9s bGVyOjpzdGF0aWNGdW5jdGlvbnMpOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5oOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9n dGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwOiBEaXR0by4KKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NUb09yaWdpbik6IERpdHRvLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbTogRGl0dG8uCisg ICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6 IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHA6IERpdHRv LgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21Pcmln aW4pOiBEaXR0by4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRy b2xsZXJXaW4uY3BwOiBTdHViIG91dCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKCkuCisgICAg ICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6IERp dHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHA6IFJl c2V0IG9yaWdpbiBhY2Nlc3MgbGlzdHMgYmVmb3JlIGVhY2ggdGVzdC4KKyAgICAgICAgKHJlc2V0 V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZyk6IERpdHRvLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbTogRGl0dG8uCisgICAgICAgIChy ZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcpOiBEaXR0by4KKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHA6IERpdHRvLgorICAgICAg ICAoV2ViQ29yZTo6RHVtcFJlbmRlclRyZWU6OnJlc2V0VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVU ZXN0aW5nKTogRGl0dG8uCisKIDIwMDktMDgtMTkgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggMmIwNzBh ZC4uMmFjZTdkYyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcApAQCAtODc0LDYgKzg3NCwyNCBAQCBzdGF0aWMgSlNWYWx1ZVJl ZiB3YWl0Rm9yUG9saWN5RGVsZWdhdGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNP YmplY3RSZQogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAor c3RhdGljIEpTVmFsdWVSZWYgd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbkNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRDb3VudCAhPSA0KQorICAgICAgICBy ZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxK U1N0cmluZ1JlZj4gc291cmNlT3JpZ2luKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRl eHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsK KyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gZGVzdGluYXRpb25Qcm90b2NvbChBZG9wdCwg SlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOwor ICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGRl c3RpbmF0aW9uSG9zdChBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVu dHNbMl0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgYm9vbCBh bGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyA9IEpTVmFsdWVUb0Jvb2xlYW4oY29udGV4dCwgYXJn dW1lbnRzWzNdKTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gc3Rh dGljX2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09i amVjdCkpOworICAgIGNvbnRyb2xsZXItPndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oc291cmNl T3JpZ2luLmdldCgpLCBkZXN0aW5hdGlvblByb3RvY29sLmdldCgpLCBkZXN0aW5hdGlvbkhvc3Qu Z2V0KCksIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKKyAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIC8vIFN0YXRpYyBWYWx1ZXMKIAogc3RhdGljIEpT VmFsdWVSZWYgZ2V0R2xvYmFsRmxhZ0NhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09i amVjdFJlZiB0aGlzT2JqZWN0LCBKU1N0cmluZ1JlZiBwcm9wZXJ0eU5hbWUsIEpTVmFsdWVSZWYq IGV4Y2VwdGlvbikKQEAgLTEwMjEsNiArMTAzOSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91 dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJ3YWl0Rm9yUG9s aWN5RGVsZWdhdGUiLCB3YWl0Rm9yUG9saWN5RGVsZWdhdGVDYWxsYmFjaywga0pTUHJvcGVydHlB dHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAg ICAgICB7ICJ3YWl0VW50aWxEb25lIiwgd2FpdFVudGlsRG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgIndpbmRvd0NvdW50Iiwgd2luZG93Q291bnRDYWxsYmFjaywga0pTUHJvcGVydHlB dHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAg ICAgICB7ICJ3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luIiwgd2hpdGVMaXN0QWNjZXNzRnJvbU9y aWdpbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlB dHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgMCwgMCwgMCB9CiAgICAgfTsKIApkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5k ZXggYzdiNDhlOC4uODAwOTE0ZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBAIC0xNzksNyArMTc5LDkgQEAgcHVibGljOgogICAg IGJvb2wgcGF1c2VBbmltYXRpb25BdFRpbWVPbkVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgYW5p bWF0aW9uTmFtZSwgZG91YmxlIHRpbWUsIEpTU3RyaW5nUmVmIGVsZW1lbnRJZCk7CiAgICAgYm9v bCBwYXVzZVRyYW5zaXRpb25BdFRpbWVPbkVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgcHJvcGVy dHlOYW1lLCBkb3VibGUgdGltZSwgSlNTdHJpbmdSZWYgZWxlbWVudElkKTsKICAgICB1bnNpZ25l ZCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMoKSBjb25zdDsKLSAgICAKKworICAgIHZvaWQgd2hp dGVMaXN0QWNjZXNzRnJvbU9yaWdpbihKU1N0cmluZ1JlZiBzb3VyY2VPcmlnaW4sIEpTU3RyaW5n UmVmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIEpTU3RyaW5nUmVmIGRlc3RpbmF0aW9uSG9zdCwgYm9v bCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CisKIHByaXZhdGU6CiAgICAgYm9vbCBtX2R1 bXBBc1RleHQ7CiAgICAgYm9vbCBtX2R1bXBBc1BERjsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IDc0NTBjZmIuLmFiMGU1ZjAg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJl ZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVl LmNwcApAQCAtNjIsNiArNjIsNyBAQCBleHRlcm4gdm9pZCB3ZWJraXRfd2ViX3NldHRpbmdzX2Fk ZF9leHRyYV9wbHVnaW5fZGlyZWN0b3J5KFdlYktpdFdlYlZpZXcqIHZpZXcsCiBleHRlcm4gZ2No YXIqIHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3Jlc3BvbnNlX21pbWVfdHlwZShXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogZXh0ZXJuIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9jbGVhcl9tYWluX2ZyYW1l X25hbWUoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIGV4dGVybiB2b2lkIHdlYmtpdF93ZWJfdmll d19zZXRfZ3JvdXBfbmFtZShXZWJLaXRXZWJWaWV3KiB2aWV3LCBjb25zdCBnY2hhciogZ3JvdXBO YW1lKTsKK2V4dGVybiB2b2lkIHdlYmtpdF9yZXNldF9vcmlnaW5fYWNjZXNzX3doaXRlX2xpc3Rz KCk7CiB9CiAKIHZvbGF0aWxlIGJvb2wgZG9uZTsKQEAgLTI4MCw2ICsyODEsOCBAQCBzdGF0aWMg dm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogCiAgICAg V2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3Bl Y3Rvcih3ZWJWaWV3KTsKICAgICBnX29iamVjdF9zZXQoR19PQkpFQ1QoaW5zcGVjdG9yKSwgImph dmFzY3JpcHQtcHJvZmlsaW5nLWVuYWJsZWQiLCBGQUxTRSwgTlVMTCk7CisKKyAgICB3ZWJraXRf cmVzZXRfb3JpZ2luX2FjY2Vzc193aGl0ZV9saXN0cygpOwogfQogCiB2b2lkIGR1bXAoKQpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9s bGVyR3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29u dHJvbGxlckd0ay5jcHAKaW5kZXggMzg4ZmJlZC4uNGE5OTUxZCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAorKysg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsu Y3BwCkBAIC00OSw2ICs0OSw3IEBAIGJvb2wgd2Via2l0X3dlYl9mcmFtZV9wYXVzZV90cmFuc2l0 aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIG5hbWUsCiB1bnNpZ25lZCBp bnQgd2Via2l0X3dlYl9mcmFtZV9udW1iZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2Vi RnJhbWUqIGZyYW1lKTsKIHZvaWQgd2Via2l0X2FwcGxpY2F0aW9uX2NhY2hlX3NldF9tYXhpbXVt X3NpemUodW5zaWduZWQgbG9uZyBsb25nIHNpemUpOwogdW5zaWduZWQgaW50IHdlYmtpdF93b3Jr ZXJfdGhyZWFkX2NvdW50KHZvaWQpOwordm9pZCB3ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9f b3JpZ2luKGNvbnN0IGdjaGFyKiBzb3VyY2VPcmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlv blByb3RvY29sLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGlu YXRpb25TdWJkb21haW5zKTsKIH0KIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6On5MYXlvdXRUZXN0 Q29udHJvbGxlcigpCkBAIC0xNjksNiArMTcwLDE0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xs ZXI6OndhaXRGb3JQb2xpY3lEZWxlZ2F0ZSgpCiAgICAgc2V0V2FpdFRvRHVtcCh0cnVlKTsKIH0K IAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzVG9PcmlnaW4oSlNT dHJpbmdSZWYgc291cmNlT3JpZ2luLCBKU1N0cmluZ1JlZiBwcm90b2NvbCwgSlNTdHJpbmdSZWYg aG9zdCwgYm9vbCBpbmNsdWRlU3ViZG9tYWlucykKK3sKKyAgICBnY2hhciogc291cmNlT3JpZ2lu R0NoYXIgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhzb3VyY2VPcmlnaW4pOworICAgIGdjaGFy KiBwcm90b2NvbEdDaGFyID0gSlNTdHJpbmdDb3B5VVRGOENTdHJpbmcocHJvdG9jb2wpOworICAg IGdjaGFyKiBob3N0R0NoYXIgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhob3N0KTsKKyAgICB3 ZWJraXRfd2hpdGVfbGlzdF9hY2Nlc3NfdG9fb3JpZ2luKHNvdXJjZU9yaWdpbkdDaGFyLCBwcm90 b2NvbEdDaGFyLCBob3N0R0NoYXIsIGluY2x1ZGVTdWJkb21haW5zKTsKK30KKwogdm9pZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6c2V0TWFpbkZyYW1lSXNGaXJzdFJlc3BvbmRlcihib29sIGZsYWcp CiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCmluZGV4IDBhY2ZmNzcuLjgwNTU3MjIgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAg LTEwODIsNiArMTA4Miw3IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0 YXRlQmVmb3JlVGVzdGluZygpCiAgICAgW1tbbWFpbkZyYW1lIHdlYlZpZXddIGluc3BlY3Rvcl0g c2V0SmF2YVNjcmlwdFByb2ZpbGluZ0VuYWJsZWQ6Tk9dOwogCiAgICAgW1dlYlZpZXcgX3NldFVz ZXNUZXN0TW9kZUZvY3VzUmluZ0NvbG9yOllFU107CisgICAgW1dlYlZpZXcgX3Jlc2V0T3JpZ2lu QWNjZXNzV2hpdGVMaXN0c107CiB9CiAKIHN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5n JiB0ZXN0UGF0aE9yVVJMKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGQzMWNkOGQuLmIzOWNmNDcg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29u dHJvbGxlck1hYy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0 VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTQ0MywzICs0NDMsMTQgQEAgdm9pZCBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6d2FpdEZvclBvbGljeURlbGVnYXRlKCkKICAgICBbcG9saWN5RGVsZWdhdGUg c2V0Q29udHJvbGxlclRvTm90aWZ5RG9uZTp0aGlzXTsKICAgICBbW21haW5GcmFtZSB3ZWJWaWV3 XSBzZXRQb2xpY3lEZWxlZ2F0ZTpwb2xpY3lEZWxlZ2F0ZV07CiB9CisKK3ZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oSlNTdHJpbmdSZWYgc291cmNl T3JpZ2luLCBKU1N0cmluZ1JlZiBkZXN0aW5hdGlvblByb3RvY29sLCBKU1N0cmluZ1JlZiBkZXN0 aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpCit7CisgICAgUmV0 YWluUHRyPENGU3RyaW5nUmVmPiBzb3VyY2VPcmlnaW5DRihBZG9wdENGLCBKU1N0cmluZ0NvcHlD RlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBzb3VyY2VPcmlnaW4pKTsKKyAgICBOU1N0cmlu ZyAqc291cmNlT3JpZ2luTlMgPSAoTlNTdHJpbmcgKilzb3VyY2VPcmlnaW5DRi5nZXQoKTsKKyAg ICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHByb3RvY29sQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5 Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgZGVzdGluYXRpb25Qcm90b2NvbCkpOworICAg IE5TU3RyaW5nICpkZXN0aW5hdGlvblByb3RvY29sTlMgPSAoTlNTdHJpbmcgKilwcm90b2NvbENG LmdldCgpOworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gaG9zdENGKEFkb3B0Q0YsIEpTU3Ry aW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGRlc3RpbmF0aW9uSG9zdCkpOwor ICAgIE5TU3RyaW5nICpkZXN0aW5hdGlvbkhvc3ROUyA9IChOU1N0cmluZyAqKWhvc3RDRi5nZXQo KTsKKyAgICBbV2ViVmlldyBfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbjpzb3VyY2VPcmlnaW5O UyBkZXN0aW5hdGlvblByb3RvY29sOmRlc3RpbmF0aW9uUHJvdG9jb2xOUyBkZXN0aW5hdGlvbkhv c3Q6ZGVzdGluYXRpb25Ib3N0TlMgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnM6YWxsb3dEZXN0 aW5hdGlvblN1YmRvbWFpbnNdOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvcXQvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv cXQvRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IDE2N2E0YzUuLjVlMzA5ZjQgMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTIxOCw2 ICsyMTgsNyBAQCB2b2lkIER1bXBSZW5kZXJUcmVlOjpyZXNldFRvQ29uc2lzdGVudFN0YXRlQmVm b3JlVGVzdGluZygpCiAgICAgLy9Xb3JrUXVldWU6OnNoYXJlZCgpLT5zZXRGcm96ZW4oZmFsc2Up OwogCiAgICAgbV9jb250cm9sbGVyLT5yZXNldCgpOworICAgIFFXZWJTZWN1cml0eU9yaWdpbjo6 cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CiB9CiAKIHZvaWQgRHVtcFJlbmRlclRyZWU6 Om9wZW4oY29uc3QgUVVybCYgYXVybCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9q c29iamVjdHMuY3BwCmluZGV4IGM5ZTdiODQuLjRiZWYzYjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3F0L2pzb2JqZWN0cy5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvcXQvanNvYmplY3RzLmNwcApAQCAtMzM3LDYgKzMzNywxMSBAQCB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpjbGVhckFsbERhdGFiYXNlcygpCiAgICAgUVdlYkRhdGFiYXNl OjpyZW1vdmVBbGxEYXRhYmFzZXMoKTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNv bnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0 aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKK3sKKyAgICBTZWN1cml0 eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3RpbmF0 aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMp OworfQorCiBFdmVudFNlbmRlcjo6RXZlbnRTZW5kZXIoUVdlYlBhZ2UgKnBhcmVudCkKICAgICA6 IFFPYmplY3QocGFyZW50KQogewpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggNTc0MzQ0Zi4uMzgz YjAwNiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRl c3RDb250cm9sbGVyV2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCkBAIC04MTYsMyArODE2LDggQEAgdW5zaWduZWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6Om51bWJlck9mQWN0aXZlQW5pbWF0aW9ucygpIGNvbnN0CiAK ICAgICByZXR1cm4gbnVtYmVyOwogfQorCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3aGl0 ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKEpTU3RyaW5nUmVmIHNvdXJjZU9yaWdpbiwgSlNTdHJpbmdS ZWYgZGVzdGluYXRpb25Qcm90b2NvbCwgSlNTdHJpbmdSZWYgZGVzdGluYXRpb25Ib3N0LCBib29s IGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKQoreworICAgIHByaW50ZigiTGF5b3V0VGVzdENv bnRyb2xsZXI6OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4gbm90IGltcGxlbWVudGVkXG4iKTsK K30K