17998 2008-03-21 18:31:10 -0700 When a resource is cached locally, WebKit should follow RFC 2616 "Specific end-to-end revalidation" instead of "Unspecified end-to-end revalidation" 2018-03-21 03:50:58 -0700 1 1 1 Unclassified WebKit Page Loading 525.x (Safari 3.1) Mac (Intel) OS X 10.5 NEW InRadar P2 Major --- 49246 1 mark.hughes koivisto aestes akwb alex ap beidson cdumez darin ddkilzer emacemac7 japhet kieran koivisto mihnea mnot mrowe oldest_to_newest 74719 0 mark.hughes 2008-03-21 18:31:10 -0700 Overview: --------- After much research, WebKit seems to ignore Expire / ETag headers in a response, either for static or dynamic content. Using Apache's mod_expires as a basis point, WebKit/Safari seems unable to understand server-side caching headers, and caching accordingly. Ultimately, this is bad on its face, but especially bad for low bandwidth, high latency, and/or resource-limited situations, such as dial-up users or the iPhone. Steps to Reproduce: ------------------- 1) Using Mac OS X builtin web sharing, configure my userdir.conf file (under 10.5/Intel) shell> sudo vi /etc/apache2/users/mhughes.conf <Directory "/Users/mhughes/Sites"> Options Indexes MultiViews AllowOverride None Order allow,deny Allow from all ExpiresActive On ExpiresDefault "access plus 7 days" </Directory> 2) Restart Apache shell> sudo apachectl graceful --or-- "System Preferences" > "Sharing" > Uncheck "Web Sharing" > Wait a few seconds for it to shutdown > Re-check "Web Sharing" ** Confirm the restart by opening http://localhost/~mhughes/ - you should see "Your website here" and such. 3) Confirm Expires and ETag are being sent properly by the webserver (Apache 2.2). Open your terminal window and issue the following command: shell> curl -i --head http://localhost/~mhughes/images/macosxlogo.gif Result should look similar to below: [antbox:~] mhughes% curl -i --head http://localhost/~mhughes/images/macosxlogo.gif HTTP/1.1 200 OK Date: Sat, 22 Mar 2008 00:12:40 GMT Server: Apache/2.2.6 (Unix) mod_ssl/2.2.6 OpenSSL/0.9.7l DAV/2 PHP/5.2.4 Last-Modified: Sat, 03 Nov 2007 20:12:50 GMT ETag: "52b87-b0d-43e0be8509480" Accept-Ranges: bytes Content-Length: 2829 Cache-Control: max-age=604800 Expires: Sat, 29 Mar 2008 00:12:40 GMT Content-Type: image/gif ** Note the ETag, Cache-Control, and Expires headers being returned. 3) Open Terminal.app and run the following: shell> sudo tail -n 0 -f /var/log/apache2/access_log | grep macosxlogo ## The -n 0 will ensure no unwelcome previous access lines 4) Open Safari to http://localhost/~mhughes/ 5) Return to your terminal window. Results should look similar to below: ::1 - - [21/Mar/2008:17:06:40 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 ** Request return with a 200 response code. This is fine. 6) Return to Safari and reload the page. 7) Return to your terminal window. Results should look similar to below: ::1 - - [21/Mar/2008:17:06:48 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 ** Request still have a 200 response code, not 304 (Not Modified) as expected. Expected Results: ----------------- All static content should have, upon subsequent load, been cached via the numerous caching headers. Actual Results: --------------- All content, regardless of cache headers from the server, is re-requested and retransferred from the server. This causes much more bandwidth to be used, which should also increase local resource usage and cache churning. Products affected: ------------------ Safari Version 3.1 (5525.13) 10.5 / Intel Safari Version 3.0.4 (523.15) WinXP SP2 WebKit r31114 10.5 / Intel Additional Builds and Platforms: -------------------------------- Other major browsers, by comparison, perform as expected (below are the Apache logs for relevant browsers) Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12 <---- Running on 10.5.2 / Intel First request: 127.0.0.1 - - [21/Mar/2008:17:13:58 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 Second request: 127.0.0.1 - - [21/Mar/2008:17:14:04 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 304 - Opera/9.24 (Macintosh; Intel Mac OS X; U; en) <---- Running on 10.5.2 / Intel First request: 127.0.0.1 - - [21/Mar/2008:17:18:15 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 Second request: 127.0.0.1 - - [21/Mar/2008:17:18:31 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 304 - Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en; rv:1.8.1.14pre) Gecko/20080321 Camino/1.6b3pre (like Firefox/2.0.0.14pre) <---- (Camino nightly) Running on 10.5.2 / Intel First request: 127.0.0.1 - - [21/Mar/2008:17:20:04 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 Second request: 127.0.0.1 - - [21/Mar/2008:17:20:08 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 304 - Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1) <---- Running on WinXP SP2 First request: 10.50.3.140 - - [21/Mar/2008:17:24:53 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 Second request: 10.50.3.140 - - [21/Mar/2008:17:25:05 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 304 - Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1) <---- Running on WinXP SP2 First request: 10.50.3.140 - - [21/Mar/2008:17:28:47 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 200 2829 Second request: 10.50.3.140 - - [21/Mar/2008:17:28:49 -0700] "GET /~mhughes/images/macosxlogo.gif HTTP/1.1" 304 - Additional information: ----------------------- I am not familiar with the core of the engine enough to point blame, but I did notice that even with returning: ... Last-Modified: Sat, 03 Nov 2007 20:12:50 GMT ETag: "52b87-b0d-43e0be8509480" ... Cache-Control: max-age=604800 Expires: Sat, 29 Mar 2008 00:12:40 GMT ... The subsequent request(s) from WebKit/Safari will show (by using the web inspector to dump headers): >>> request headers >>> Cache-Control max-age=0 Referer http://localhost/~mhughes/ User-Agent Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_2; en-us) AppleWebKit/526.1+ (KHTML, like Gecko) Version/3.0.4 Safari/523.15 <<< request headers <<< >>> response headers >>> Accept-Ranges bytes Cache-Control max-age=604800 Connection Keep-Alive Content-Length 2829 Content-Type image/gif Date Sat, 22 Mar 2008 00:33:41 GMT Etag "52b87-b0d-43e0be8509480" Expires Sat, 29 Mar 2008 00:33:41 GMT Keep-Alive timeout=5, max=98 Last-Modified Sat, 03 Nov 2007 20:12:50 GMT Server Apache/2.2.6 (Unix) mod_ssl/2.2.6 OpenSSL/0.9.7l DAV/2 PHP/5.2.4 <<< response headers <<< Of note is that no matter how many cache cleans or reloads, the request always seems to contain: Cache-Control max-age=0 A good example to test with: ---------------------------- * http://www.apple.com/startpage/ Clear cache > Open Inspector > Load Page. *** According to network panel, all of the resources total ~770KB. Reload page leaving inspector open. *** Same transfer of data. A sampling of the requests show all as pulling max-age=0 and retransferring. Note: As a point of comparison, repeat the same thing in FireFox with FireBug installed. On reload, ONLY the HTML page is reloaded from the network. All other pages trust their cached copies, even though they do confirm with the server that their copies are good. 74724 1 mrowe 2008-03-21 19:13:46 -0700 Please try a similar experiment but instead of hitting Reload, simply load the page again by hitting Enter in the address bar. 74819 2 mark.hughes 2008-03-22 15:02:20 -0700 (In reply to comment #1) > Please try a similar experiment but instead of hitting Reload, simply load the > page again by hitting Enter in the address bar. On resubmission, or by following a link to that page, the cache is wholly respected and there is not even a request to validate the content to confirm the page's status - there is no network activity whatsoever. This is great, and even more "aggressive" than other browsers. However, why during a reload are the linked resources themselves not trusted? I could see a reload causing the contents of the "primary" URL to be forceably reloaded/reverifed (Cache-Control: max-age=0), but if that page references resources in the cache already, wouldn't it be more sensible/efficient to let the cache work the same way as if you had reentered the URL? In this case, with Expires/Cache-control: max-age=>0 (freshness) and ETag (validator) returned in the initial response, sending the If-None-Match / If-Modified-Since headers would make the utmost sense. In short, even if reload becomes a condition for the browser to forceably revalidate all of the resources involved, shouldn't the proper outcome of described scenario be a stream of 304s from the server in the ideal situation? 74821 3 mrowe 2008-03-22 15:08:23 -0700 See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.4>: What you describe for the current behaviour is termed "Unspecified end-to-end revalidation". What you describe for the preferred behaviour is termed "Specific end-to-end revalidation". The paragraph preceding the definitions suggests that specific end-to-end revalidation should be used when a local cached copy of the resource is available, which would appear to be in agreement the approach you suggest. I suspect that the current behaviour that WebKit uses is determined by the CFNetwork stack it uses for HTTP rather than in WebKit itself. 74822 4 mrowe 2008-03-22 15:09:02 -0700 I think the bug should be retitled to reflect the specific problem you mentioned. At the moment it's too general and doesn't accurately describe the situation. 74833 5 mark.hughes 2008-03-22 15:55:49 -0700 Renamed per your suggestion. You are certainly correct in this, as the file is in the cache already, and therefore not a total unknown. 74925 6 mrowe 2008-03-23 21:44:42 -0700 <rdar://problem/5815252> 74939 7 ap 2008-03-23 23:18:16 -0700 > Note: As a point of comparison, repeat the same thing in FireFox with FireBug > installed. On reload, ONLY the HTML page is reloaded from the network. In general, Safari reloading behavior should be compared to what other browsers do on Shift-reload - since we only have on flavor of reload, it has to be the more thorough one. 74973 8 mark.hughes 2008-03-24 09:02:24 -0700 > > Note: As a point of comparison, repeat the same thing in FireFox with FireBug > > installed. On reload, ONLY the HTML page is reloaded from the network. > > In general, Safari reloading behavior should be compared to what other browsers > do on Shift-reload - since we only have on flavor of reload, it has to be the > more thorough one. All due respect to the many engineers who have spent their time working on this project, but that doesn't sound like a proper implementation of the mechanism. Most all browsers seem to implement "Specific end to end" on reload, as referenced earlier. That WebKit would forcibly ignore the cache on reload seems counterintuitive, and unfriendly to the types of issues I list above - low bandwidth, high latency, or resource-limited devices - the first two I have spent much time in, and I am made to shy away from WebKit/Safari when I do. That said, what is the rationale for wholesale reloading on "reload?" 74978 9 ap 2008-03-24 09:22:31 -0700 Please note that my personal opinion is that we should have both reload and shift-reload. But in the absence of the latter, it appears obvious that reload should fulfill the primary purpose of reloading - which is to guarantee freshness of content, regardless of proxy misconfiguration, time zone changes, software bugs and other issues that may necessitate full reload. Saving bandwidth is a very important consideration, but a secondary one. Just as an example, in the past I've personally experienced a situation where I couldn't reload stale content that was stuck in a proxy from within Safari - I had to open the same page in Firefox and use shift-reload; only after that, Safari would display updated content. 74985 10 koivisto 2008-03-24 10:10:03 -0700 It is not acceptable to make user experience worse for every user to deal with exteremely rare caching problems. Supporting shift-reload is probably the right way to deal with those cases. 74989 11 mark.hughes 2008-03-24 10:19:20 -0700 > Please note that my personal opinion is that we should have both reload and > shift-reload. But in the absence of the latter, it appears obvious that reload > should fulfill the primary purpose of reloading - which is to guarantee > freshness of content, regardless of proxy misconfiguration, time zone changes, > software bugs and other issues that may necessitate full reload. Saving > bandwidth is a very important consideration, but a secondary one. So what would the process be to have both options available? Clearly, it's not a situation where the ideal is one or the other, but in fact both. I would also think that there could be a client-side preference to force super-reload when connected to a known bad proxy, or in general (for web dev testing for instance), or to be OS X Network Locaton specific (so that you could say to always err on the side of trust on a cellular WiFi network). I'd like to dig in further to the codebase and see if I could perhaps contribute this. Does anyone know if the work would be in WebKit, WebCore, CFNetwork, or is it not community changeable? > Just as an example, in the past I've personally experienced a situation where I > couldn't reload stale content that was stuck in a proxy from within Safari - I > had to open the same page in Firefox and use shift-reload; only after that, > Safari would display updated content. As both are just browsers, I believe it would then be advisable to research if there are any differences between WebKit SuperReload'ing and FF's SuperReload'ing. If FF can force an upstream to re-cache, and WebKit cannot, that seems like WebKit needs additional headers/something to force upstreams to re-cache/re-validate content. 75015 12 ap 2008-03-24 15:26:21 -0700 (In reply to comment #11) > Does anyone know if the work would be in WebKit, WebCore, > CFNetwork, or is it not community changeable? Depending on what the UI will be, this may be WebKit or Safari. Web Inspector is in open source WebKit, while Safari UI is closed source. Some supporting changes in lower level frameworks might be necessary, too. > As both are just browsers, I believe it would then be advisable to research if > there are any differences between WebKit SuperReload'ing and FF's > SuperReload'ing. This was a while ago, I believe Safari's behavior has changed, and using Firefox to reset proxy wouldn't have been necessary now. 75084 13 ap 2008-03-25 01:08:07 -0700 (In reply to comment #12) > This was a while ago, I believe Safari's behavior has changed, and using > Firefox to reset proxy wouldn't have been necessary now. Actually, I take my words back - this part hasn't changed, see bug 7414 comment 6 (the plain reload results mentioned there are obsolete). 88788 14 22872 koivisto 2008-08-18 18:09:59 -0700 Created attachment 22872 implement Specific end-to-end revalidation for WebCore memory cache putting this up for comments 88794 15 22874 koivisto 2008-08-18 20:44:44 -0700 Created attachment 22874 updated patch Fixes based on comments by Mark. Added code that includes "Cache-Control: max-age=0" in reload case (which is not enabled for now) required for correct "Unspecified end-to-end revalidation" . 89214 16 22874 darin 2008-08-24 15:32:07 -0700 Comment on attachment 22874 updated patch This looks great. I have a few questions about it. How can we test this? I assume you did some testing already, but I'm curious how we can prevent changes from causing regressions in this area. I'm also thinking that the division of labor between WebCore and the underlying loader library is getting weaker. Some of the code here should probably be using functions from ResourceHandle; maybe the constant "304" could be coming from there for example and also the "can revalidate". 195 if (resource->resourceToRevalidate()) 196 return; I don't like the way this if statement reads. It's in a function named revalidateResource it says "if there is a resource to revalidate, just return". This shows that the names aren't quite right. I think I understand the case where this would be true, but I'm not sure. Maybe this is a resource that already represents a revalidation? Maybe we need a comment explaining this a little more? 201 String url = resource->url(),; The comma here looks like a syntax error. It seems that we wouldn't be able to compile this. Also might be more efficient to use const& here. 282 // Equivalent of deref() for all clients 283 m_clients.clear(); 284 285 unsigned moveCount = clientsToMove.size(); 286 for (unsigned n = 0; n < moveCount; ++n) 287 m_resourceToRevalidate->addClient(clientsToMove[n]); Does this create a window where the clients could go away altogether or something along those lines? Normally doing a deref before a reref is incorrect. Maybe it's OK since it's not literally deref(). Also, it's possible your use of "deref()" here is out of date, since Hyatt renamed the functions here in the cache since they weren't quite ref/deref. 292 return !m_loading && (!m_response.httpHeaderField("Last-Modified").isEmpty() || !m_response.httpHeaderField("ETag").isEmpty()); This assumes that ETag is implemented. It's not implemented in current versions of CFNetwork! 48 void setResource(CachedResource* res) { We put the braces on a separate line. And maybe a function like this shouldn't be inline. The general rule is that we want to inline functions that are completely trivial, like a single assignment, or ones where there's a clear performance win. But not others. 57 CachedResourceHandleBase& operator=(const CachedResourceHandleBase&) { return *this; } Do we want this function to be defined at all? Who needs to call it? 245 String lastModified = resourceToRevalidate->response().httpHeaderField("Last-Modified"); 246 String eTag = resourceToRevalidate->response().httpHeaderField("ETag"); These can be more efficient if they use const& so they don't have to ref/deref the string. I'm going to say review- because of that comma (at least) and because there seem to be enough questions that at least one might cause you to change the patch. 89215 17 mrowe 2008-08-24 15:42:48 -0700 (In reply to comment #16) > (From update of attachment 22874 [edit]) > > 292 return !m_loading && > (!m_response.httpHeaderField("Last-Modified").isEmpty() || > !m_response.httpHeaderField("ETag").isEmpty()); > > This assumes that ETag is implemented. It's not implemented in current versions > of CFNetwork! The revalidation is handled entirely in WebCore, with Loader::Host::servePendingRequests adding the If-None-Match header if the original response had an ETag header. This should allow us to use ETags to revalidate from the memory cache even when using a network library that does not support revalidation via ETags. 89222 18 koivisto 2008-08-24 17:20:45 -0700 (In reply to comment #16) > (From update of attachment 22874 [edit]) > This looks great. I have a few questions about it. > > How can we test this? I assume you did some testing already, but I'm curious > how we can prevent changes from causing regressions in this area. I'm also > thinking that the division of labor between WebCore and the underlying loader > library is getting weaker. I don't have good story for that. I have been running versions of this patch in regular use over a few months but that obviously that obviously does not catch that much. Automated HTTP tests that give code coverage should be possible but good coverage of real world scenarios (involving potentially broken servers, caches, etc) is very difficult. This is true for all our networking code. I don't think division of labor is getting weaker. That overall idea is to treat networking library cache and WebCore cache as two separate levels in HTTP cache hierarchy. The specification is written in multiple cache levels in mind and the interaction between levels is well defined. This allows us to implement functionality (like ETag, below) without caring if it is implemented in other levels. For example if the CFNetwork level includes a cache validator to a request for an item in its own cache we never see the resulting 304 response in WebCore level. It gets transparently turned into 200 response. We only get 304 responses for requests that include a validator from the WebCore level. > Some of the code here should probably be using functions from ResourceHandle; > maybe the constant "304" could be coming from there for example and also the > "can revalidate". > > 195 if (resource->resourceToRevalidate()) > 196 return; > > I don't like the way this if statement reads. It's in a function named > revalidateResource it says "if there is a resource to revalidate, just return". > This shows that the names aren't quite right. I think I understand the case > where this would be true, but I'm not sure. Maybe this is a resource that > already represents a revalidation? Maybe we need a comment explaining this a > little more? I don't like the name either. I changed it a few times and this was the best I came up with. The questions here is along the lines of "Is this a resource that represents a request that includes cache validator for an existing resource". > > 201 String url = resource->url(),; > > The comma here looks like a syntax error. It seems that we wouldn't be able to > compile this. Also might be more efficient to use const& here. Good catch. Suprisingly it compiles fine, as does int a,; No idea if this is a compiler bug or if it is legal C++. > > 282 // Equivalent of deref() for all clients > 283 m_clients.clear(); > 284 > 285 unsigned moveCount = clientsToMove.size(); > 286 for (unsigned n = 0; n < moveCount; ++n) > 287 m_resourceToRevalidate->addClient(clientsToMove[n]); > > Does this create a window where the clients could go away altogether or > something along those lines? Normally doing a deref before a reref is > incorrect. Maybe it's OK since it's not literally deref(). Also, it's possible > your use of "deref()" here is out of date, since Hyatt renamed the functions > here in the cache since they weren't quite ref/deref. Yeah, deref() comment is pre-rename. CachedResources have weird destruction rules that involve multiple conditions (CachedResources::canDelete()), and this patch adds more (for resources in process of being revalidated) so just removing clients don't kill the objects. > > 292 return !m_loading && > (!m_response.httpHeaderField("Last-Modified").isEmpty() || > !m_response.httpHeaderField("ETag").isEmpty()); > > This assumes that ETag is implemented. It's not implemented in current versions > of CFNetwork! The implementation is entirely self contained in WebCore. We can validate WebCore cache with ETag validators even if CFNetwork can not do it with its cache. > > 48 void setResource(CachedResource* res) { > > We put the braces on a separate line. And maybe a function like this shouldn't > be inline. The general rule is that we want to inline functions that are > completely trivial, like a single assignment, or ones where there's a clear > performance win. But not others. Ok. > 57 CachedResourceHandleBase& operator=(const > CachedResourceHandleBase&) { return *this; } > > Do we want this function to be defined at all? Who needs to call it? I made it private to ensure that no one is invoking the default version. The handle went though various iterations, that helped to catch bugs at least in some form. > > 245 String lastModified = > resourceToRevalidate->response().httpHeaderField("Last-Modified"); > 246 String eTag = > resourceToRevalidate->response().httpHeaderField("ETag"); > > These can be more efficient if they use const& so they don't have to ref/deref > the string. > > I'm going to say review- because of that comma (at least) and because there > seem to be enough questions that at least one might cause you to change the > patch. Thanks for the review! 89320 19 22987 koivisto 2008-08-25 15:16:18 -0700 Created attachment 22987 more updates Fixes based on review comments, cleanups - added CachedResource::mustRevalidate(CachePolicy) that takes "Cache-Control: no-cache" and "CacheControl: must-revalidate" into account - added CachedResource::isCacheValidator() - renamed CachedResource::canBeRevalidated() to canUseCacheValidator() - added CachedResourceHandle.cpp - sorted headers - random cosmetic fixes 89786 20 22987 darin 2008-08-30 19:14:07 -0700 Comment on attachment 22987 more updates Sorry, I can't remember which of these are repeating something I already asked. 213 CachedScript *cs = pendingScripts.first().get(); Would be nice to move the star when you're tweaking this line of code. 225 int delta = static_cast<int>(resource->size()); Does this really require an explicit cast? 103 void revalidationSucceeded(CachedResource* revalidatingResource, const ResourceResponse& response); 104 void revalidationFailed(CachedResource* revalidatingResource); Seems that you don't need the argument names here. 111 return (difftime(now, m_expirationDate) >= 0); Extra parentheses on this line. 88 void checkDelete(); Not a great name. This names it sound like we check deletion, which doesn't make a lot of logical sense. A better name might be deleteIfPossible() or deleteIfNotInCache(). Those are less elegant than checkDelete, but at least a little easier to understand. There's probably an even better name. 301 return !cacheControl.isEmpty() && (cacheControl.contains("no-cache") || (isExpired() && cacheControl.contains("must-revalidate"))); 302 return isExpired() || cacheControl.contains("no-cache"); I think we'd want the case-ignoring version of contains, right? Also, is a substring match really the correct way to read this field? That seems a little sloppy to me. What's the correct algorithm? 134 void setResponse(const ResourceResponse& response); 188 void setResourceToRevalidate(CachedResource* resource); Should omit the argument names in these cases. 31 void CachedResourceHandleBase::setResource(CachedResource* resource) { Brace goes on a separate line. 39 operator bool() const { return get(); } We normally don't use operator bool. I think it would be best to imitate the technique used in our smart pointers such as RefPtr instead. 42 CachedResourceHandleBase() : m_resource(0) {} We use a space in these parentheses. 46 void setResource(CachedResource* res); Should omit the argument names in these cases. None of these are serious concerns, so I'll say review+. 90251 21 koivisto 2008-09-05 02:32:04 -0700 Sending WebCore/ChangeLog Sending WebCore/WebCore.pro Sending WebCore/WebCore.vcproj/WebCore.vcproj Sending WebCore/WebCore.xcodeproj/project.pbxproj Sending WebCore/css/CSSFontFaceSource.h Sending WebCore/css/CSSImportRule.h Sending WebCore/dom/Clipboard.h Sending WebCore/dom/ProcessingInstruction.h Sending WebCore/dom/ScriptElement.h Sending WebCore/dom/XMLTokenizer.cpp Sending WebCore/dom/XMLTokenizer.h Sending WebCore/html/HTMLImageLoader.cpp Sending WebCore/html/HTMLImageLoader.h Sending WebCore/html/HTMLLinkElement.h Sending WebCore/html/HTMLTokenizer.cpp Sending WebCore/html/HTMLTokenizer.h Sending WebCore/loader/Cache.cpp Sending WebCore/loader/Cache.h Sending WebCore/loader/CachedResource.cpp Sending WebCore/loader/CachedResource.h Adding WebCore/loader/CachedResourceHandle.cpp Adding WebCore/loader/CachedResourceHandle.h Sending WebCore/loader/DocLoader.cpp Sending WebCore/loader/UserStyleSheetLoader.h Sending WebCore/loader/loader.cpp Sending WebCore/page/EventHandler.cpp Sending WebCore/rendering/RenderImage.cpp Sending WebCore/rendering/RenderImage.h Sending WebCore/rendering/style/RenderStyle.h Sending WebCore/rendering/style/StyleCachedImage.h Sending WebCore/svg/SVGFEImageElement.h Sending WebCore/svg/graphics/filters/SVGFEImage.h Sending WebCore/xml/XSLImportRule.h Transmitting file data ................................. Committed revision 36109. 90252 22 koivisto 2008-09-05 02:33:45 -0700 > Also, is a substring match really the correct way to read this field? That > seems a little sloppy to me. What's the correct algorithm? I added a FIXME. It should really be tokenized but substring match works in practice (and some http code i have seen does the same thing). 90253 23 koivisto 2008-09-05 02:34:28 -0700 Leaving this open for followup patch to enable it for reloading case. 94322 24 22987 eric 2008-10-06 18:25:34 -0700 Comment on attachment 22987 more updates Clearing review flag since this has landed. 98276 25 25045 koivisto 2008-11-11 02:51:58 -0800 Created attachment 25045 WebCore patch for enabling revalidation on reload 98277 26 25046 koivisto 2008-11-11 02:54:29 -0800 Created attachment 25046 WebKit patch for enabling revalidation on reload This also contains hack that allows WebKit running in shipping Safari to use shift-reload to force end-to-end reload. 98348 27 25055 koivisto 2008-11-11 14:30:23 -0800 Created attachment 25055 updated WebCore patch Some small updates - set request cache policy in addExtraFieldsToRequest() - some more text in ChangeLog 98668 28 mrowe 2008-11-13 15:48:13 -0800 *** Bug 13892 has been marked as a duplicate of this bug. *** 99988 29 akwb 2008-11-24 10:42:46 -0800 Does this bug need to be accepted as a bug (instead of having the status NEW) in order to get reviewed? 100005 30 darin 2008-11-24 11:49:19 -0800 (In reply to comment #29) > Does this bug need to be accepted as a bug (instead of having the status NEW) > in order to get reviewed? No. "NEW" just means that the assignee hasn't accepted. It's more the status of the assignee than the status of the bug. We don't use it much on the WebKit project. 100016 31 akwb 2008-11-24 12:41:01 -0800 So currently the bug is assigned to "Nobody". Should it be assigned to the person in charge of this area of the Webkit engine so that it can be moved along? I'm quite keen to see these patches get reviewed as this bug very much affects my daily usage of Webkit. 100024 32 darin 2008-11-24 12:55:36 -0800 (In reply to comment #31) > So currently the bug is assigned to "Nobody". Should it be assigned to the > person in charge of this area of the Webkit engine so that it can be moved > along? I'm quite keen to see these patches get reviewed as this bug very much > affects my daily usage of Webkit. This patch is in the review queue. There are about 50 others in the queue too. Assignment of the bug won't affect how soon it's reviewed. 100054 33 25046 darin 2008-11-24 13:51:30 -0800 Comment on attachment 25046 WebKit patch for enabling revalidation on reload > + // FIXME: This is a hack to make shift-reload work on shipping Safari. Remove when Safari has this functionality. > + if ([[[NSBundle mainBundle] bundleIdentifier] isEqualToString:@"com.apple.Safari"]) Normally we would do a linked-on-or-after check to make this back off automatically when the new Safari ships. 100055 34 25046 darin 2008-11-24 13:51:30 -0800 Comment on attachment 25046 WebKit patch for enabling revalidation on reload > + // FIXME: This is a hack to make shift-reload work on shipping Safari. Remove when Safari has this functionality. > + if ([[[NSBundle mainBundle] bundleIdentifier] isEqualToString:@"com.apple.Safari"]) Normally we would do a linked-on-or-after check to make this back off automatically when the new Safari ships. 100057 35 25055 darin 2008-11-24 13:56:12 -0800 Comment on attachment 25055 updated WebCore patch > + CachePolicy cachePolicy = this->cachePolicy(); > + if (cachePolicy == CachePolicyVerify || cachePolicy == CachePolicyCache) { > + CachedResource* existing = cache()->resourceForURL(fullURL.string()); > + if (existing && !existing->isPreloaded() && existing->mustRevalidate(cachePolicy)) { > + cache()->revalidateResource(existing, this); > + m_reloadedURLs.add(fullURL.string()); > + } > + return; > + } > + if (cachePolicy == CachePolicyReload || cachePolicy == CachePolicyRevalidate) { > + CachedResource* existing = cache()->resourceForURL(fullURL.string()); > + if (existing && !existing->isPreloaded()) { > + if (cachePolicy == CachePolicyReload) > + cache()->remove(existing); > + else > + cache()->revalidateResource(existing, this); > + m_reloadedURLs.add(fullURL.string()); > + } > } The above looks like it should be a switch statement. > - ScheduledRedirection(double redirectDelay, const String& redirectURL, bool redirectLockHistory, bool userGesture) > + ScheduledRedirection(double redirectDelay, const String& redirectURL, bool redirectLockHistory, bool userGesture, bool refresh) It's a little confusing to have both the term "reload" and the term "refresh" used. > + ResourceRequest request(url, referrer, refresh ? ReloadIgnoringCacheData : UseProtocolCachePolicy); Two spaces here after the comma. > - scheduleRedirection(new ScheduledRedirection(delay, url, delay <= 1, false)); > + scheduleRedirection(new ScheduledRedirection(delay, url, delay <= 1, false, false)); Yuck, I hate booleans. We should really use enums instead so we can see what "false" means. > + // FIXME: We don't have a mechanism to revalidate the main resource without reloadin at the moment. Typo here. Need a "g" on the end of "reloading". > - void changeLocation(const String& url, const String& referrer, bool lockHistory = true, bool userGesture = false); > - void changeLocation(const KURL&, const String& referrer, bool lockHistory = true, bool userGesture = false); > + void changeLocation(const String& url, const String& referrer, bool lockHistory = true, bool userGesture = false, bool refresh = false); > + void changeLocation(const KURL&, const String& referrer, bool lockHistory = true, bool userGesture = false, bool refresh = false); You added the "= false" default here, but you also added the false boolean explicitly to some call sites. I think you should omit it at the call sites. r=me 102559 36 koivisto 2008-12-15 07:14:08 -0800 > The above looks like it should be a switch statement. Fixed. > It's a little confusing to have both the term "reload" and the term "refresh" > used. The confusing terminology predates this patch. At least some instances of "refresh" refer to meta refresh header. Cleaning this up left as future exercise. > > + ResourceRequest request(url, referrer, refresh ? ReloadIgnoringCacheData : UseProtocolCachePolicy); > > Two spaces here after the comma. Fixed. > Yuck, I hate booleans. We should really use enums instead so we can see what > "false" means. Agreed. Still keeping this bit of refactoring out from this patch. > Typo here. Need a "g" on the end of "reloading". Fixed. > You added the "= false" default here, but you also added the false boolean > explicitly to some call sites. I think you should omit it at the call sites. Fixed. Also did some slight additional refactoring which probably does not need review. 102560 37 koivisto 2008-12-15 07:30:49 -0800 Sending WebCore/ChangeLog Sending WebCore/WebCore.base.exp Sending WebCore/loader/CachePolicy.h Sending WebCore/loader/DocLoader.cpp Sending WebCore/loader/DocLoader.h Sending WebCore/loader/DocumentLoader.cpp Sending WebCore/loader/FrameLoader.cpp Sending WebCore/loader/FrameLoader.h Sending WebCore/loader/FrameLoaderTypes.h Sending WebCore/loader/NavigationAction.cpp Sending WebCore/loader/SubresourceLoader.cpp Sending WebCore/loader/loader.cpp Transmitting file data ............ Committed revision 39304. 102561 38 koivisto 2008-12-15 07:32:02 -0800 Sending WebKit/mac/ChangeLog Sending WebKit/mac/WebView/WebFrame.h Sending WebKit/mac/WebView/WebFrame.mm Sending WebKit/mac/WebView/WebFramePrivate.h Sending WebKit/mac/WebView/WebView.h Sending WebKit/mac/WebView/WebView.mm Transmitting file data ...... Committed revision 39305. 102563 39 koivisto 2008-12-15 07:33:48 -0800 > Normally we would do a linked-on-or-after check to make this back off > automatically when the new Safari ships. I will add this bit later. 102564 40 koivisto 2008-12-15 07:34:31 -0800 This bug still remain unresolved for the top level resources. 105448 41 25046 mrowe 2009-01-12 23:36:55 -0800 Comment on attachment 25046 WebKit patch for enabling revalidation on reload Clearing review flag as this was landed. 105449 42 25055 mrowe 2009-01-12 23:37:11 -0800 Comment on attachment 25055 updated WebCore patch Clearing review flag as this was landed. 115545 43 akwb 2009-03-27 08:46:25 -0700 Perhaps this is bad bugzilla-etiquette but can someone review these patches please? They were added to this bug 3.5 months ago now. If I had the skill I would but I don't so I'm afraid I need to ask. Thank you. 115551 44 mrowe 2009-03-27 09:07:57 -0700 None of the patches attached to this bug are waiting for review. The relevant ones have already been landed, as my two previous comments indicate. 115553 45 akwb 2009-03-27 09:10:35 -0700 Mark, thanks. So we're awaiting further patches from Antti in order to be able to mark this bug as resolved? 176941 46 ddkilzer 2010-01-04 16:44:48 -0800 (In reply to comment #45) > Mark, thanks. So we're awaiting further patches from Antti in order to be able > to mark this bug as resolved? Correct. Antti? :) 300278 47 alex 2010-10-27 09:23:59 -0700 Just to be clear: are you planning to send If-None-Match/If-Modified-Since headers with a regular reload request in WebKit? At the moment WebKit browsers do not do this, while FF and IE do. FF and IE can then benefit from 304 Not Modified responses from the server with no body content and it would be great if WebKit could receive those too, especially in situations where end users are hammering their reload button in order to get content they're expecting to be published in the immediate future. 300315 48 ap 2010-10-27 10:09:12 -0700 Just to avoid confusion, this is only about top level resources. Subresources do get their conditional headers on reload, and we also have shift-reload now (there is no Cmd+Shift+R, but you can shift-click the reload button). The top level resource being different is still a bug that needs to be fixed. 306703 49 koivisto 2010-11-09 04:28:32 -0800 I filed bug 49246 specifically for the main resource in the memory cache. 820170 50 alex 2013-01-30 06:51:45 -0800 Is this any closer to being fixed for main resources now that Nate Chapin landed all the changes for main resources and the memory cache in: Bug 49246 - Main resource should be cached in the memory cache Bug 105667 - Enable reuse of cached main resources 878063 51 beidson 2013-04-18 13:47:45 -0700 We assumed that once we cached main resources, main resources would get this for free. Well, we cache main resources now and - as pointed out in 114738 - we haven't gotten it for free. We can finish this up now. 878068 52 beidson 2013-04-18 13:53:31 -0700 *** Bug 114738 has been marked as a duplicate of this bug. *** 1135288 53 alex 2015-10-21 11:09:33 -0700 Hi all. Though there was some initial debate about this 7 years ago, the most recent comments here suggest there isn't any controversy today. Especially based on comments 48 and 51. Are any WebKit developers actively interested in pursuing this? 22872 2008-08-18 18:09:59 -0700 2008-08-18 20:44:44 -0700 implement Specific end-to-end revalidation for WebCore memory cache 304-10.patch text/plain 47099 koivisto SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTgyOSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsOTIgQEAKKzIwMDgtMDgtMTggIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICAKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3OTk4CisgICAg ICAgIFdoZW4gYSByZXNvdXJjZSBpcyBjYWNoZWQgbG9jYWxseSwgV2ViS2l0IHNob3VsZCBmb2xs b3cgUkZDIDI2MTYgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBpbnN0ZWFkIG9m ICJVbnNwZWNpZmllZCBlbmQtdG8tZW5kIHJldmFsaWRhdGlvbiIKKworICAgICAgICBJbXBsZW1l bnQgSFRUUCAxLjEgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBmb3IgV2ViQ29y ZSBtZW1vcnkgY2FjaGUuIFRoaXMgcGF0Y2ggZG9lcworICAgICAgICBub3QgeWV0IGVuYWJsZSBp dCBmb3IgdGhlIGJpZ2dlc3QgdXNlIGNhc2UsIHJlbG9kaW5nLiBIb3dldmVyIGl0IGlzIGdvb2Qg Zm9yIGdlbmVyYWwgYnJvd3NpbmcgYXMKKyAgICAgICAgd2VsbC4gRG9pbmcgdGhpcyBpbiBXZWJD b3JlIGxldmVsIGFzIG9wcG9zZWQgdG8gcmVseWluZyBvbiBkaXNrIGNhY2hlIGhhcyBiaWcgYmVu ZWZpdCB0aGF0CisgICAgICAgIHdlIGF2b2lkIHJlLWRlY29kaW5nIHJlc291cmNlcywgZXNwZWNp YWxseSBpbWFnZXMuCisgICAgICAgIAorICAgICAgICBUaGUgYXBwcm9hY2ggZm9yIHJldmFsaWRh dGlvbiBpcyB0byBraWNrIHRoZSBvcmlnaW5hbCByZXNvdXJjZSBvdXQgZnJvbSB0aGUgbWVtb3J5 IGNhY2hlCisgICAgICAgIGFuZCBjcmVhdGUgYSBuZXcgQ2FjaGVkUmVzb3VyY2UgdGhhdCByZXBy ZXNlbnRzIHRoZSByZXZhbGlkYXRpb24gcmVxdWVzdC4gSW4gY2FzZQorICAgICAgICB3ZSBnZXQg MzA0IGJhY2sgZm9yIHRoZSByZXF1ZXN0IHdlIHB1dCB0aGUgb3JpZ2luYWwgcmVzb3VyY2UgYmFj ayB0byB0aGUgY2FjaGUsIHVwZGF0ZSAKKyAgICAgICAgaXRzIGV4cGlyYXRpb24gZGF0ZSBhbmQg c3dpdGNoIHRoZSBjbGllbnRzIHJlZ2lzdGVyZWQgdG8gcmV2YWxpZGF0aW9uIHJlc291cmNlIHRv IGJlCisgICAgICAgIGNsaWVudHMgb2YgdGhlIG9yaWdpbmFsIHJlc291cmNlLgorICAgICAgICAK KyAgICAgICAgQWxsIGhlYXAgYWxsb2NhdGVkIENhY2hlZEltYWdlIHBvaW50ZXJzIG5vdyB1c2Ug Q2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IChhbmQgc28gb24pIGluc3RlYWQuCisg ICAgICAgIFRoaXMgYWxsb3dzIHVwZGF0aW5nIHRoZSBoYW5kbGVzIHRvIHBvaW50IHRvIHRoZSBv cmlnaW5hbCByZXNvdXJjZSB3aGVuIHRoZSByZXZhbGlkYXRpb24gc3VjY2VlZHMuIEl0CisgICAg ICAgIGFsc28gYWN0cyBhcyByZWZjb3VudGluZyBzbWFydCBwb2ludGVyLgorCisgICAgICAgICog V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGNzcy9DU1NGb250 RmFjZVNvdXJjZS5oOgorICAgICAgICAqIGNzcy9DU1NJbXBvcnRSdWxlLmg6CisgICAgICAgICog ZG9tL0NsaXBib2FyZC5oOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkOjpkcmFnSW1hZ2Up OgorICAgICAgICAqIGRvbS9Qcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaDoKKyAgICAgICAgKiBkb20v U2NyaXB0RWxlbWVudC5oOgorICAgICAgICAqIGRvbS9YTUxUb2tlbml6ZXIuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6WE1MVG9rZW5pemVyOjppc1dhaXRpbmdGb3JTY3JpcHRzKToKKyAgICAgICAg KiBkb20vWE1MVG9rZW5pemVyLmg6CisgICAgICAgICogaHRtbC9IVE1MSW1hZ2VMb2FkZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SFRNTEltYWdlTG9hZGVyOjpzZXRJbWFnZSk6CisgICAgICAg IChXZWJDb3JlOjpIVE1MSW1hZ2VMb2FkZXI6OnVwZGF0ZUZyb21FbGVtZW50KToKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxJbWFnZUxvYWRlcjo6bm90aWZ5RmluaXNoZWQpOgorICAgICAgICAqIGh0 bWwvSFRNTEltYWdlTG9hZGVyLmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW1hZ2VMb2FkZXI6 OmltYWdlKToKKyAgICAgICAgKiBodG1sL0hUTUxMaW5rRWxlbWVudC5oOgorICAgICAgICAqIGh0 bWwvSFRNTFRva2VuaXplci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVG9rZW5pemVyOjpy ZXNldCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVG9rZW5pemVyOjpzY3JpcHRIYW5kbGVyKToK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxUb2tlbml6ZXI6Om5vdGlmeUZpbmlzaGVkKToKKyAgICAg ICAgKiBodG1sL0hUTUxUb2tlbml6ZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvQ2FjaGUuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6Q2FjaGU6OnJldmFsaWRhdGVSZXNvdXJjZSk6CisgICAgICAgIChX ZWJDb3JlOjpDYWNoZTo6cmV2YWxpZGF0aW9uU3VjY2VlZGVkKToKKyAgICAgICAgKFdlYkNvcmU6 OkNhY2hlOjpyZXZhbGlkYXRpb25GYWlsZWQpOgorICAgICAgICAqIGxvYWRlci9DYWNoZS5oOgor ICAgICAgICAqIGxvYWRlci9DYWNoZWRSZXNvdXJjZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpD YWNoZWRSZXNvdXJjZTo6Q2FjaGVkUmVzb3VyY2UpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVk UmVzb3VyY2U6On5DYWNoZWRSZXNvdXJjZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNv dXJjZTo6aXNFeHBpcmVkKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpzZXRS ZXNwb25zZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6Y2hlY2tEZWxldGUp OgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OnNldFJlc291cmNlVG9SZXZhbGlk YXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpjbGVhclJlc291cmNlVG9S ZXZhbGlkYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpzd2l0Y2hDbGll bnRzVG9SZXZhbGlkYXRlZFJlc291cmNlKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291 cmNlOjpjYW5CZVJldmFsaWRhdGVkKToKKyAgICAgICAgKiBsb2FkZXIvQ2FjaGVkUmVzb3VyY2Uu aDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpjYW5EZWxldGUpOgorICAgICAg ICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OnJlZ2lzdGVySGFuZGxlKToKKyAgICAgICAgKFdl YkNvcmU6OkNhY2hlZFJlc291cmNlOjp1bnJlZ2lzdGVySGFuZGxlKToKKyAgICAgICAgKFdlYkNv cmU6OkNhY2hlZFJlc291cmNlOjpyZXNvdXJjZVRvUmV2YWxpZGF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpDYWNoZWRSZXNvdXJjZTo6c2V0RXhwaXJhdGlvbkRhdGUpOgorICAgICAgICAqIGxvYWRl ci9Eb2NMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jTG9hZGVyOjpjaGVja0ZvclJl bG9hZCk6CisgICAgICAgICogbG9hZGVyL2xvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpM b2FkZXI6Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKToKKyAgICAgICAgKFdlYkNvcmU6Okxv YWRlcjo6SG9zdDo6ZGlkRmluaXNoTG9hZGluZyk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6 Okhvc3Q6OmRpZEZhaWwpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpkaWRSZWNl aXZlUmVzcG9uc2UpOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpkaWRSZWNlaXZl RGF0YSk6CisgICAgICAgICogbG9hZGVyL21hYy9Vc2VyU3R5bGVTaGVldExvYWRlci5oOgorICAg ICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFu ZGxlcjo6c2VsZWN0Q3Vyc29yKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVySW1hZ2UuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OnNldENhY2hlZEltYWdlKToKKyAgICAg ICAgKFdlYkNvcmU6OlJlbmRlckltYWdlOjppbWFnZUNoYW5nZWQpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJJbWFnZS5oOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OmNhY2hl ZEltYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckltYWdlOjppbWFnZVB0cik6CisgICAg ICAgICogcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmg6CisgICAgICAgIChXZWJDb3JlOjpT dHlsZUNhY2hlZEltYWdlOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlN0eWxlQ2FjaGVkSW1h Z2U6OmNhY2hlZEltYWdlKToKKyAgICAgICAgKiBzdmcvU1ZHRkVJbWFnZUVsZW1lbnQuaDoKKyAg ICAgICAgKiBzdmcvZ3JhcGhpY3MvZmlsdGVycy9TVkdGRUltYWdlLmg6CisgICAgICAgICogeG1s L1hTTEltcG9ydFJ1bGUuaDoKKwogMjAwOC0wOC0xOCAgTWF4aW1lIEJyaXR0byAgPGJyaXR0b0Bh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRlbGUuCkluZGV4OiBXZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJD b3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAt NDA1MSw2ICs0MDUxLDcgQEAKIAkJRTQ0NjE0M0MwQ0Q2ODlDQzAwRkFEQTc1IC8qIEpTSFRNTFNv dXJjZUVsZW1lbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEU0QjQyMzcyMENCRkI2RTAwMEFGMkVDRSAvKiBKU0hUTUxTb3VyY2VFbGVtZW50LmggKi87 IH07CiAJCUU0NDYxNDUxMENENjhBMzUwMEZBREE3NSAvKiBSZW5kZXJWaWRlby5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEI0MUUzMzBDQkZCNjA5 MDBBRjJFQ0UgLyogUmVuZGVyVmlkZW8uY3BwICovOyB9OwogCQlFNDQ2MTQ1MjBDRDY4QTM1MDBG QURBNzUgLyogUmVuZGVyVmlkZW8uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEU0QjQxRTM0MENCRkI2MDkwMEFGMkVDRSAvKiBSZW5kZXJWaWRlby5oICov OyB9OworCQlFNDcyMDUzQjBFNUEwNTNBMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3VyY2VIYW5kbGUu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU0NzIwNTNB MEU1QTA1M0EwMDA2QkI0RCAvKiBDYWNoZWRSZXNvdXJjZUhhbmRsZS5oICovOyBzZXR0aW5ncyA9 IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUU0OTYyNkMyMEQ4MEQ5NDgwMEUz NDA1QyAvKiBQcmVsb2FkU2Nhbm5lci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBFNEQ0QUJFMDBENzU0MkYwMDBGOTY4NjkgLyogUHJlbG9hZFNjYW5u ZXIuY3BwICovOyB9OwogCQlFNDk2MjZDMzBEODBEOTQ5MDBFMzQwNUMgLyogUHJlbG9hZFNjYW5u ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU0RDRB QkUxMEQ3NTQyRjEwMEY5Njg2OSAvKiBQcmVsb2FkU2Nhbm5lci5oICovOyB9OwogCQlFNEFGQ0ZB NTBEQUYyOUEzMDBGNUY1NUMgLyogVW5pdEJlemllci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRTRBRkNGQTQwREFGMjlBMzAwRjVGNTVDIC8qIFVuaXRC ZXppZXIuaCAqLzsgfTsKQEAgLTg0NTIsNiArODQ1Myw3IEBACiAJCUU0NDYxNDExMENENjgyNjkw MEZBREE3NSAvKiBKU01lZGlhRXJyb3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gSlNNZWRpYUVycm9yLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUU0NDYxNDEy MENENjgyNjkwMEZBREE3NSAvKiBKU1RpbWVSYW5nZXMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gSlNUaW1lUmFuZ2VzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJRTQ0NjE0MTMwQ0Q2ODI2OTAwRkFEQTc1IC8qIEpTVGltZVJhbmdlcy5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU1RpbWVSYW5nZXMuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJRTQ3MjA1M0EwRTVBMDUzQTAwMDZCQjREIC8qIENhY2hlZFJlc291 cmNlSGFuZGxlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENhY2hlZFJlc291 cmNlSGFuZGxlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUU0QUZDRkE0MERBRjI5 QTMwMEY1RjU1QyAvKiBVbml0QmV6aWVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IFVuaXRCZXppZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRTRBRkQwMDUw REFGMzM1NDAwRjVGNTVDIC8qIFNNSUxUaW1lLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IFNNSUxUaW1lLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RTRBRkQwMDYwREFGMzM1NDAwRjVGNTVDIC8qIFNNSUxUaW1lLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IFNNSUxUaW1lLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBA IC0xMjU5Myw2ICsxMjU5NSw3IEBACiAJCQkJQkNCMTZDMEQwOTc5QzNCRDAwNDY3NzQxIC8qIENh Y2hlZFhCTERvY3VtZW50LmggKi8sCiAJCQkJQkNCMTZDMEUwOTc5QzNCRDAwNDY3NzQxIC8qIENh Y2hlZFhTTFN0eWxlU2hlZXQuY3BwICovLAogCQkJCUJDQjE2QzBGMDk3OUMzQkQwMDQ2Nzc0MSAv KiBDYWNoZWRYU0xTdHlsZVNoZWV0LmggKi8sCisJCQkJRTQ3MjA1M0EwRTVBMDUzQTAwMDZCQjRE IC8qIENhY2hlZFJlc291cmNlSGFuZGxlLmggKi8sCiAJCQkJRjU4Nzg2NDkwMkRFM0E5QTAxRUE0 MTIyIC8qIENhY2hlUG9saWN5LmggKi8sCiAJCQkJQkNCMTZDMTAwOTc5QzNCRDAwNDY3NzQxIC8q IERvY0xvYWRlci5jcHAgKi8sCiAJCQkJQkNCMTZDMTEwOTc5QzNCRDAwNDY3NzQxIC8qIERvY0xv YWRlci5oICovLApAQCAtMTU0MDIsNiArMTU0MDUsNyBAQAogCQkJCTMxQzBGRjRFMEU0Q0VGREQw MDdENkZFNSAvKiBET01XZWJLaXRUcmFuc2l0aW9uRXZlbnRJbnRlcm5hbC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJMDhBNDg0NzgwRTUyNzJDNTAwQzNGRTc2IC8qIFNjcmlwdEVsZW1lbnQuaCBpbiBI ZWFkZXJzICovLAogCQkJCUE4RkE2RTVEMEU0Q0ZERUQwMEQ1Q0Y0OSAvKiBQYXR0ZXJuLmggaW4g SGVhZGVycyAqLywKKwkJCQlFNDcyMDUzQjBFNUEwNTNBMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3Vy Y2VIYW5kbGUuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50 UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogV2ViQ29yZS9jc3MvQ1NTRm9udEZhY2VT b3VyY2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Nzcy9DU1NGb250RmFjZVNvdXJjZS5oCShy ZXZpc2lvbiAzNTgxOSkKKysrIFdlYkNvcmUvY3NzL0NTU0ZvbnRGYWNlU291cmNlLmgJKHdvcmtp bmcgY29weSkKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkF0b21pY1N0cmluZy5oIgog I2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3Vy Y2VIYW5kbGUuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiAjaWYgRU5BQkxFKFNWR19G T05UUykKQEAgLTY3LDcgKzY4LDcgQEAgcHVibGljOgogCiBwcml2YXRlOgogICAgIEF0b21pY1N0 cmluZyBtX3N0cmluZzsgLy8gVVJJIGZvciByZW1vdGUsIGJ1aWx0LWluIGZvbnQgbmFtZSBmb3Ig bG9jYWwuCi0gICAgQ2FjaGVkRm9udCogbV9mb250OyAvLyBGb3IgcmVtb3RlIGZvbnRzLCBhIHBv aW50ZXIgdG8gb3VyIGNhY2hlZCByZXNvdXJjZS4KKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxD YWNoZWRGb250PiBtX2ZvbnQ7IC8vIEZvciByZW1vdGUgZm9udHMsIGEgcG9pbnRlciB0byBvdXIg Y2FjaGVkIHJlc291cmNlLgogICAgIENTU0ZvbnRGYWNlKiBtX2ZhY2U7IC8vIE91ciBvd25pbmcg Zm9udCBmYWNlLgogICAgIEhhc2hNYXA8dW5zaWduZWQsIFNpbXBsZUZvbnREYXRhKj4gbV9mb250 RGF0YVRhYmxlOyAvLyBUaGUgaGFzaCBrZXkgaXMgY29tcG9zZWQgb2Ygc2l6ZSBzeW50aGV0aWMg c3R5bGVzLgogCkluZGV4OiBXZWJDb3JlL2Nzcy9DU1NJbXBvcnRSdWxlLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9jc3MvQ1NTSW1wb3J0UnVsZS5oCShyZXZpc2lvbiAzNTgxOSkKKysrIFdlYkNv cmUvY3NzL0NTU0ltcG9ydFJ1bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMjIsNiArMjIsNyBAQAog I2lmbmRlZiBDU1NJbXBvcnRSdWxlX2gKICNkZWZpbmUgQ1NTSW1wb3J0UnVsZV9oCiAKKyNpbmNs dWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIkNTU1J1bGUuaCIKICNpbmNs dWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgogI2luY2x1ZGUgIk1lZGlhTGlzdC5oIgpAQCAt NjUsNyArNjYsNyBAQCBwcml2YXRlOgogICAgIFN0cmluZyBtX3N0ckhyZWY7CiAgICAgUmVmUHRy PE1lZGlhTGlzdD4gbV9sc3RNZWRpYTsKICAgICBSZWZQdHI8Q1NTU3R5bGVTaGVldD4gbV9zdHls ZVNoZWV0OwotICAgIENhY2hlZENTU1N0eWxlU2hlZXQqIG1fY2FjaGVkU2hlZXQ7CisgICAgQ2Fj aGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkQ1NTU3R5bGVTaGVldD4gbV9jYWNoZWRTaGVldDsKICAg ICBib29sIG1fbG9hZGluZzsKIH07CiAKSW5kZXg6IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCShyZXZpc2lvbiAzNTgxOSkKKysr IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNCw2ICsyNCw3IEBA CiAjaWZuZGVmIENsaXBib2FyZF9oCiAjZGVmaW5lIENsaXBib2FyZF9oCiAKKyNpbmNsdWRlICJD YWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIkNsaXBib2FyZEFjY2Vzc1BvbGljeS5o IgogI2luY2x1ZGUgIkRyYWdBY3Rpb25zLmgiCiAjaW5jbHVkZSAiRHJhZ0ltYWdlLmgiCkBAIC01 NCw3ICs1NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBIYXNoU2V0 PFN0cmluZz4gdHlwZXMoKSBjb25zdCA9IDA7CiAgICAgCiAgICAgICAgIEludFBvaW50IGRyYWdM b2NhdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fZHJhZ0xvYzsgfQotICAgICAgICBDYWNoZWRJbWFn ZSogZHJhZ0ltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9kcmFnSW1hZ2U7IH0KKyAgICAgICAgQ2Fj aGVkSW1hZ2UqIGRyYWdJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIG1fZHJhZ0ltYWdlLmdldCgpOyB9 CiAgICAgICAgIHZpcnR1YWwgdm9pZCBzZXREcmFnSW1hZ2UoQ2FjaGVkSW1hZ2UqLCBjb25zdCBJ bnRQb2ludCYpID0gMDsKICAgICAgICAgTm9kZSogZHJhZ0ltYWdlRWxlbWVudCgpIHsgcmV0dXJu IG1fZHJhZ0ltYWdlRWxlbWVudC5nZXQoKTsgfQogICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0RHJh Z0ltYWdlRWxlbWVudChOb2RlKiwgY29uc3QgSW50UG9pbnQmKSA9IDA7CkBAIC05MCw3ICs5MSw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBwcm90ZWN0ZWQ6CiAgICAgICAgIGJvb2wgbV9m b3JEcmFnZ2luZzsKICAgICAgICAgSW50UG9pbnQgbV9kcmFnTG9jOwotICAgICAgICBDYWNoZWRJ bWFnZSogbV9kcmFnSW1hZ2U7CisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZElt YWdlPiBtX2RyYWdJbWFnZTsKICAgICAgICAgUmVmUHRyPE5vZGU+IG1fZHJhZ0ltYWdlRWxlbWVu dDsKICAgICB9OwogCkluZGV4OiBXZWJDb3JlL2RvbS9Qcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Qcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaAkocmV2aXNp b24gMzU4MTkpCisrKyBXZWJDb3JlL2RvbS9Qcm9jZXNzaW5nSW5zdHJ1Y3Rpb24uaAkod29ya2lu ZyBjb3B5KQpAQCAtMjUsNiArMjUsNyBAQAogI2RlZmluZSBQcm9jZXNzaW5nSW5zdHJ1Y3Rpb25f aAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIKKyNpbmNsdWRlICJDYWNoZWRS ZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIkNvbnRhaW5lck5vZGUuaCIKIAogbmFtZXNwYWNl IFdlYkNvcmUgewpAQCAtODQsNyArODUsNyBAQCBwcml2YXRlOgogICAgIFN0cmluZyBtX2xvY2Fs SHJlZjsKICAgICBTdHJpbmcgbV90aXRsZTsKICAgICBTdHJpbmcgbV9tZWRpYTsKLSAgICBDYWNo ZWRSZXNvdXJjZSogbV9jYWNoZWRTaGVldDsKKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNo ZWRSZXNvdXJjZT4gbV9jYWNoZWRTaGVldDsKICAgICBSZWZQdHI8U3R5bGVTaGVldD4gbV9zaGVl dDsKICAgICBib29sIG1fbG9hZGluZzsKICAgICBib29sIG1fYWx0ZXJuYXRlOwpJbmRleDogV2Vi Q29yZS9kb20vU2NyaXB0RWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL1Njcmlw dEVsZW1lbnQuaAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3JlL2RvbS9TY3JpcHRFbGVtZW50 LmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDYgKzIyLDcgQEAKICNkZWZpbmUgU2NyaXB0RWxlbWVu dF9oCiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hl ZFJlc291cmNlSGFuZGxlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtODAsNyArODEs NyBAQCBwcml2YXRlOgogcHJpdmF0ZToKICAgICBTY3JpcHRFbGVtZW50KiBtX3NjcmlwdEVsZW1l bnQ7CiAgICAgRWxlbWVudCogbV9lbGVtZW50OwotICAgIENhY2hlZFNjcmlwdCogbV9jYWNoZWRT Y3JpcHQ7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkU2NyaXB0PiBtX2NhY2hlZFNj cmlwdDsKICAgICBib29sIG1fY3JlYXRlZEJ5UGFyc2VyOwogICAgIGJvb2wgbV9ldmFsdWF0ZWQ7 CiB9OwpJbmRleDogV2ViQ29yZS9kb20vWE1MVG9rZW5pemVyLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL2RvbS9YTUxUb2tlbml6ZXIuY3BwCShyZXZpc2lvbiAzNTgxOSkKKysrIFdlYkNvcmUv ZG9tL1hNTFRva2VuaXplci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1NDAsNyArMTU0MCw3IEBA IHZvaWQgWE1MVG9rZW5pemVyOjpub3RpZnlGaW5pc2hlZChDYWNoZWQKIAogYm9vbCBYTUxUb2tl bml6ZXI6OmlzV2FpdGluZ0ZvclNjcmlwdHMoKSBjb25zdAogewotICAgIHJldHVybiBtX3BlbmRp bmdTY3JpcHQgIT0gMDsKKyAgICByZXR1cm4gbV9wZW5kaW5nU2NyaXB0OwogfQogCiAjaWYgRU5B QkxFKFhTTFQpCkluZGV4OiBXZWJDb3JlL2RvbS9YTUxUb2tlbml6ZXIuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL2RvbS9YTUxUb2tlbml6ZXIuaAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3Jl L2RvbS9YTUxUb2tlbml6ZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjUsNiArMjUsNyBAQAogI2Rl ZmluZSBYTUxUb2tlbml6ZXJfaAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIK KyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNlZ21lbnRlZFN0 cmluZy5oIgogI2luY2x1ZGUgIlN0cmluZ0hhc2guaCIKICNpbmNsdWRlICJUb2tlbml6ZXIuaCIK QEAgLTE1NCw3ICsxNTUsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGludCBtX2xh c3RFcnJvckNvbHVtbjsKICAgICAgICAgU3RyaW5nIG1fZXJyb3JNZXNzYWdlczsKIAotICAgICAg ICBDYWNoZWRTY3JpcHQqIG1fcGVuZGluZ1NjcmlwdDsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VI YW5kbGU8Q2FjaGVkU2NyaXB0PiBtX3BlbmRpbmdTY3JpcHQ7CiAgICAgICAgIFJlZlB0cjxFbGVt ZW50PiBtX3NjcmlwdEVsZW1lbnQ7CiAgICAgICAgIGludCBtX3NjcmlwdFN0YXJ0TGluZTsKIApJ bmRleDogV2ViQ29yZS9odG1sL0hUTUxJbWFnZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9odG1sL0hUTUxJbWFnZUxvYWRlci5jcHAJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29y ZS9odG1sL0hUTUxJbWFnZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU3LDcgKzU3LDcg QEAgSFRNTEltYWdlTG9hZGVyOjp+SFRNTEltYWdlTG9hZGVyKCkKIAogdm9pZCBIVE1MSW1hZ2VM b2FkZXI6OnNldEltYWdlKENhY2hlZEltYWdlICpuZXdJbWFnZSkKIHsKLSAgICBDYWNoZWRJbWFn ZSAqb2xkSW1hZ2UgPSBtX2ltYWdlOworICAgIENhY2hlZEltYWdlICpvbGRJbWFnZSA9IG1faW1h Z2UuZ2V0KCk7CiAgICAgaWYgKG5ld0ltYWdlICE9IG9sZEltYWdlKSB7CiAgICAgICAgIHNldExv YWRpbmdJbWFnZShuZXdJbWFnZSk7CiAgICAgICAgIG1fZmlyZWRMb2FkID0gdHJ1ZTsKQEAgLTEw Nyw3ICsxMDcsNyBAQCB2b2lkIEhUTUxJbWFnZUxvYWRlcjo6dXBkYXRlRnJvbUVsZW1lbnQoCiAg ICAgICAgICAgICBuZXdJbWFnZSA9IGRvYy0+ZG9jTG9hZGVyKCktPnJlcXVlc3RJbWFnZShwYXJz ZVVSTChhdHRyKSk7CiAgICAgfQogICAgIAotICAgIENhY2hlZEltYWdlICpvbGRJbWFnZSA9IG1f aW1hZ2U7CisgICAgQ2FjaGVkSW1hZ2UgKm9sZEltYWdlID0gbV9pbWFnZS5nZXQoKTsKICAgICBp ZiAobmV3SW1hZ2UgIT0gb2xkSW1hZ2UpIHsKICNpZmRlZiBJTlNUUlVNRU5UX0xBWU9VVF9TQ0hF RFVMSU5HCiAgICAgICAgIGlmICghZG9jLT5vd25lckVsZW1lbnQoKSAmJiBuZXdJbWFnZSkKQEAg LTE0NSw3ICsxNDUsNyBAQCB2b2lkIEhUTUxJbWFnZUxvYWRlcjo6bm90aWZ5RmluaXNoZWQoQ2Fj CiAjZW5kaWYKICAgICBpZiAoUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW0tPnJlbmRlcmVy KCkpCiAgICAgICAgIGlmIChyZW5kZXJlci0+aXNJbWFnZSgpKQotICAgICAgICAgICAgc3RhdGlj X2Nhc3Q8UmVuZGVySW1hZ2UqPihyZW5kZXJlciktPnNldENhY2hlZEltYWdlKG1faW1hZ2UpOwor ICAgICAgICAgICAgc3RhdGljX2Nhc3Q8UmVuZGVySW1hZ2UqPihyZW5kZXJlciktPnNldENhY2hl ZEltYWdlKG1faW1hZ2UuZ2V0KCkpOwogICAgICAgICAgICAgCiAgICAgaWYgKGltYWdlLT5lcnJv ck9jY3VycmVkKCkgJiYgZWxlbS0+aGFzVGFnTmFtZShvYmplY3RUYWcpKQogICAgICAgICBzdGF0 aWNfY2FzdDxIVE1MT2JqZWN0RWxlbWVudCo+KGVsZW0pLT5yZW5kZXJGYWxsYmFja0NvbnRlbnQo KTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VMb2FkZXIuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmgJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29y ZS9odG1sL0hUTUxJbWFnZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw2ICsyNiw3IEBA CiAjZGVmaW5lIEhUTUxJbWFnZUxvYWRlcl9oCiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNs aWVudC5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtNDMsNyArNDQsNyBAQCBwdWJsaWM6CiAgICAgRWxlbWVudCogZWxlbWVu dCgpIGNvbnN0IHsgcmV0dXJuIG1fZWxlbWVudDsgfQogICAgIGJvb2wgaW1hZ2VDb21wbGV0ZSgp IGNvbnN0IHsgcmV0dXJuIG1faW1hZ2VDb21wbGV0ZTsgfQogCi0gICAgQ2FjaGVkSW1hZ2UqIGlt YWdlKCkgY29uc3QgeyByZXR1cm4gbV9pbWFnZTsgfQorICAgIENhY2hlZEltYWdlKiBpbWFnZSgp IGNvbnN0IHsgcmV0dXJuIG1faW1hZ2UuZ2V0KCk7IH0KICAgICB2b2lkIHNldEltYWdlKENhY2hl ZEltYWdlKik7CiAKICAgICB2b2lkIHNldExvYWRNYW51YWxseShib29sIGxvYWRNYW51YWxseSkg eyBtX2xvYWRNYW51YWxseSA9IGxvYWRNYW51YWxseTsgfQpAQCAtNTksNyArNjAsNyBAQCBwcm90 ZWN0ZWQ6CiAKIHByaXZhdGU6CiAgICAgRWxlbWVudCogbV9lbGVtZW50OwotICAgIENhY2hlZElt YWdlKiBtX2ltYWdlOworICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZEltYWdlPiBtX2lt YWdlOwogICAgIGJvb2wgbV9maXJlZExvYWQgOiAxOwogICAgIGJvb2wgbV9pbWFnZUNvbXBsZXRl IDogMTsKICAgICBib29sIG1fbG9hZE1hbnVhbGx5IDogMTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9I VE1MTGlua0VsZW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTExpbmtFbGVt ZW50LmgJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29yZS9odG1sL0hUTUxMaW5rRWxlbWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC0yMyw2ICsyMyw3IEBACiAjaWZuZGVmIEhUTUxMaW5rRWxlbWVu dF9oCiAjZGVmaW5lIEhUTUxMaW5rRWxlbWVudF9oCiAKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJj ZUhhbmRsZS5oIgogI2luY2x1ZGUgIkNTU1N0eWxlU2hlZXQuaCIKICNpbmNsdWRlICJDYWNoZWRS ZXNvdXJjZUNsaWVudC5oIgogI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCkBAIC0xMDAsNyArMTAx LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBmaW5pc2hQYXJzaW5nQ2hpbGRyZW4oKTsK IAogcHJvdGVjdGVkOgotICAgIENhY2hlZENTU1N0eWxlU2hlZXQqIG1fY2FjaGVkU2hlZXQ7Cisg ICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkQ1NTU3R5bGVTaGVldD4gbV9jYWNoZWRTaGVl dDsKICAgICBSZWZQdHI8Q1NTU3R5bGVTaGVldD4gbV9zaGVldDsKICAgICBTdHJpbmcgbV91cmw7 CiAgICAgU3RyaW5nIG1fdHlwZTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MVG9rZW5pemVyLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTFRva2VuaXplci5jcHAJKHJldmlzaW9u IDM1ODE5KQorKysgV2ViQ29yZS9odG1sL0hUTUxUb2tlbml6ZXIuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0yMTAsOSArMjEwLDEwIEBAIHZvaWQgSFRNTFRva2VuaXplcjo6cmVzZXQoKQogICAgIEFT U0VSVChtX2V4ZWN1dGluZ1NjcmlwdCA9PSAwKTsKIAogICAgIHdoaWxlICghcGVuZGluZ1Njcmlw dHMuaXNFbXB0eSgpKSB7Ci0gICAgICBDYWNoZWRTY3JpcHQgKmNzID0gcGVuZGluZ1NjcmlwdHMu ZGVxdWV1ZSgpOwotICAgICAgQVNTRVJUKGNhY2hlKCktPmRpc2FibGVkKCkgfHwgY3MtPmFjY2Vz c0NvdW50KCkgPiAwKTsKLSAgICAgIGNzLT5yZW1vdmVDbGllbnQodGhpcyk7CisgICAgICAgIENh Y2hlZFNjcmlwdCAqY3MgPSBwZW5kaW5nU2NyaXB0cy5maXJzdCgpLmdldCgpOworICAgICAgICBw ZW5kaW5nU2NyaXB0cy5yZW1vdmVGaXJzdCgpOworICAgICAgICBBU1NFUlQoY2FjaGUoKS0+ZGlz YWJsZWQoKSB8fCBjcy0+YWNjZXNzQ291bnQoKSA+IDApOworICAgICAgICBjcy0+cmVtb3ZlQ2xp ZW50KHRoaXMpOwogICAgIH0KICAgICAKICAgICBmYXN0RnJlZShidWZmZXIpOwpAQCAtNDMwLDcg KzQzMSw3IEBAIEhUTUxUb2tlbml6ZXI6OlN0YXRlIEhUTUxUb2tlbml6ZXI6OnNjcmkKICAgICAg ICAgICAgICAgICAvLyBUaGUgcGFyc2VyIG1pZ2h0IGhhdmUgYmVlbiBzdG9wcGVkIGJ5IGZvciBl eGFtcGxlIGEgd2luZG93LmNsb3NlIGNhbGwgaW4gYW4gZWFybGllciBzY3JpcHQuCiAgICAgICAg ICAgICAgICAgLy8gSWYgc28sIHdlIGRvbid0IHdhbnQgdG8gbG9hZCBzY3JpcHRzLgogICAgICAg ICAgICAgICAgIGlmICghbV9wYXJzZXJTdG9wcGVkICYmIChjcyA9IG1fZG9jLT5kb2NMb2FkZXIo KS0+cmVxdWVzdFNjcmlwdChzY3JpcHRTcmMsIHNjcmlwdFNyY0NoYXJzZXQpKSkKLSAgICAgICAg ICAgICAgICAgICAgcGVuZGluZ1NjcmlwdHMuZW5xdWV1ZShjcyk7CisgICAgICAgICAgICAgICAg ICAgIHBlbmRpbmdTY3JpcHRzLmFwcGVuZChjcyk7CiAgICAgICAgICAgICAgICAgZWxzZQogICAg ICAgICAgICAgICAgICAgICBzY3JpcHROb2RlID0gMDsKICAgICAgICAgICAgIH0gZWxzZQpAQCAt MTk4MCw4ICsxOTgxLDkgQEAgdm9pZCBIVE1MVG9rZW5pemVyOjpub3RpZnlGaW5pc2hlZChDYWNo ZQogICAgICAgICByZXR1cm47CiAKICAgICBib29sIGZpbmlzaGVkID0gZmFsc2U7Ci0gICAgd2hp bGUgKCFmaW5pc2hlZCAmJiBwZW5kaW5nU2NyaXB0cy5oZWFkKCktPmlzTG9hZGVkKCkpIHsKLSAg ICAgICAgQ2FjaGVkU2NyaXB0KiBjcyA9IHBlbmRpbmdTY3JpcHRzLmRlcXVldWUoKTsKKyAgICB3 aGlsZSAoIWZpbmlzaGVkICYmIHBlbmRpbmdTY3JpcHRzLmZpcnN0KCktPmlzTG9hZGVkKCkpIHsK KyAgICAgICAgQ2FjaGVkU2NyaXB0KiBjcyA9IHBlbmRpbmdTY3JpcHRzLmZpcnN0KCkuZ2V0KCk7 CisgICAgICAgIHBlbmRpbmdTY3JpcHRzLnJlbW92ZUZpcnN0KCk7CiAgICAgICAgIEFTU0VSVChj YWNoZSgpLT5kaXNhYmxlZCgpIHx8IGNzLT5hY2Nlc3NDb3VudCgpID4gMCk7CiAKICAgICAgICAg U3RyaW5nIHNjcmlwdFNvdXJjZSA9IGNzLT5zY3JpcHQoKTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9I VE1MVG9rZW5pemVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxUb2tlbml6ZXIu aAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3JlL2h0bWwvSFRNTFRva2VuaXplci5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0yNCwxMiArMjQsMTMgQEAKICNpZm5kZWYgSFRNTFRva2VuaXplcl9oCiAj ZGVmaW5lIEhUTUxUb2tlbml6ZXJfaAogCi0jaW5jbHVkZSAiRGVwcmVjYXRlZFB0clF1ZXVlLmgi CisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJOYW1lZE1hcHBl ZEF0dHJNYXAuaCIKICNpbmNsdWRlICJTZWdtZW50ZWRTdHJpbmcuaCIKICNpbmNsdWRlICJUaW1l ci5oIgogI2luY2x1ZGUgIlRva2VuaXplci5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xp ZW50LmgiCisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgog I2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KIApAQCAtMzczLDcgKzM3NCw3IEBAIHByaXZhdGU6CiAg ICAgLy8gdHJ1ZSBpZiB3ZSBhcmUgZXhlY3V0aW5nIGEgc2NyaXB0IHdoaWxlIHBhcnNpbmcgYSBk b2N1bWVudC4gVGhpcyBjYXVzZXMgdGhlIHBhcnNpbmcgb2YKICAgICAvLyB0aGUgb3V0cHV0IG9m IHRoZSBzY3JpcHQgdG8gYmUgcG9zdHBvbmVkIHVudGlsIGFmdGVyIHRoZSBzY3JpcHQgaGFzIGZp bmlzaGVkIGV4ZWN1dGluZwogICAgIGludCBtX2V4ZWN1dGluZ1NjcmlwdDsKLSAgICBEZXByZWNh dGVkUHRyUXVldWU8Q2FjaGVkU2NyaXB0PiBwZW5kaW5nU2NyaXB0czsKKyAgICBEZXF1ZTxDYWNo ZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRTY3JpcHQ+ID4gcGVuZGluZ1NjcmlwdHM7CiAgICAgUmVm UHRyPE5vZGU+IHNjcmlwdE5vZGU7CiAKICAgICBib29sIG1fcmVxdWVzdGluZ1NjcmlwdDsKSW5k ZXg6IFdlYkNvcmUvbG9hZGVyL0NhY2hlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRl ci9DYWNoZS5jcHAJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29yZS9sb2FkZXIvQ2FjaGUuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xODcsNiArMTg3LDU3IEBAIENhY2hlZENTU1N0eWxlU2hlZXQq IENhY2hlOjpyZXF1ZXN0VXNlckMKIAogICAgIHJldHVybiB1c2VyU2hlZXQ7CiB9CisgICAgCit2 b2lkIENhY2hlOjpyZXZhbGlkYXRlUmVzb3VyY2UoQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlLCBE b2NMb2FkZXIqIGRvY0xvYWRlcikKK3sKKyAgICBBU1NFUlQocmVzb3VyY2UpOworICAgIEFTU0VS VCghZGlzYWJsZWQoKSk7CisgICAgaWYgKHJlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgp KQorICAgICAgICByZXR1cm47CisgICAgaWYgKCFyZXNvdXJjZS0+Y2FuQmVSZXZhbGlkYXRlZCgp KSB7CisgICAgICAgIHJlbW92ZShyZXNvdXJjZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9Cisg ICAgU3RyaW5nIHVybCA9IHJlc291cmNlLT51cmwoKSw7CisgICAgQ2FjaGVkUmVzb3VyY2UqIG5l d1Jlc291cmNlID0gY3JlYXRlUmVzb3VyY2UocmVzb3VyY2UtPnR5cGUoKSwgS1VSTCh1cmwpLCBy ZXNvdXJjZS0+ZW5jb2RpbmcoKSk7CisgICAgbmV3UmVzb3VyY2UtPnNldFJlc291cmNlVG9SZXZh bGlkYXRlKHJlc291cmNlKTsKKyAgICByZW1vdmUocmVzb3VyY2UpOworICAgIG1fcmVzb3VyY2Vz LnNldCh1cmwsIG5ld1Jlc291cmNlKTsKKyAgICBuZXdSZXNvdXJjZS0+c2V0SW5DYWNoZSh0cnVl KTsKKyAgICByZXNvdXJjZUFjY2Vzc2VkKG5ld1Jlc291cmNlKTsKKyAgICBuZXdSZXNvdXJjZS0+ bG9hZChkb2NMb2FkZXIpOworfQorICAgIAordm9pZCBDYWNoZTo6cmV2YWxpZGF0aW9uU3VjY2Vl ZGVkKENhY2hlZFJlc291cmNlKiByZXZhbGlkYXRpbmdSZXNvdXJjZSwgdGltZV90IG5ld0V4cGly YXRpb25EYXRlKQoreworICAgIENhY2hlZFJlc291cmNlKiByZXNvdXJjZSA9IHJldmFsaWRhdGlu Z1Jlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworICAgIEFTU0VSVChyZXNvdXJjZSk7 CisgICAgQVNTRVJUKCFyZXNvdXJjZS0+aW5DYWNoZSgpKTsKKyAgICBBU1NFUlQocmVzb3VyY2Ut PmlzTG9hZGVkKCkpOworICAgIAorICAgIHJlbW92ZShyZXZhbGlkYXRpbmdSZXNvdXJjZSk7CisK KyAgICBBU1NFUlQoIW1fcmVzb3VyY2VzLmdldChyZXNvdXJjZS0+dXJsKCkpKTsKKyAgICBtX3Jl c291cmNlcy5zZXQocmVzb3VyY2UtPnVybCgpLCByZXNvdXJjZSk7CisgICAgcmVzb3VyY2UtPnNl dEluQ2FjaGUodHJ1ZSk7CisgICAgcmVzb3VyY2UtPnNldEV4cGlyYXRpb25EYXRlKG5ld0V4cGly YXRpb25EYXRlKTsKKyAgICBpbnNlcnRJbkxSVUxpc3QocmVzb3VyY2UpOworICAgIGludCBkZWx0 YSA9IHN0YXRpY19jYXN0PGludD4ocmVzb3VyY2UtPnNpemUoKSk7CisgICAgaWYgKHJlc291cmNl LT5kZWNvZGVkU2l6ZSgpICYmIHJlc291cmNlLT5yZWZlcmVuY2VkKCkpCisgICAgICAgIGluc2Vy dEluTGl2ZURlY29kZWRSZXNvdXJjZXNMaXN0KHJlc291cmNlKTsKKyAgICBpZiAoZGVsdGEpCisg ICAgICAgIGFkanVzdFNpemUocmVzb3VyY2UtPnJlZmVyZW5jZWQoKSwgZGVsdGEpOworICAgIAor ICAgIHJldmFsaWRhdGluZ1Jlc291cmNlLT5zd2l0Y2hDbGllbnRzVG9SZXZhbGlkYXRlZFJlc291 cmNlKCk7CisgICAgLy8gdGhpcyBkZWxldGVzIHRoZSByZXZhbGlkYXRpbmcgcmVzb3VyY2UKKyAg ICByZXZhbGlkYXRpbmdSZXNvdXJjZS0+Y2xlYXJSZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworfQor Cit2b2lkIENhY2hlOjpyZXZhbGlkYXRpb25GYWlsZWQoQ2FjaGVkUmVzb3VyY2UqIHJldmFsaWRh dGluZ1Jlc291cmNlKQoreworICAgIEFTU0VSVChyZXZhbGlkYXRpbmdSZXNvdXJjZS0+cmVzb3Vy Y2VUb1JldmFsaWRhdGUoKSk7CisgICAgcmV2YWxpZGF0aW5nUmVzb3VyY2UtPmNsZWFyUmVzb3Vy Y2VUb1JldmFsaWRhdGUoKTsKK30KIAogQ2FjaGVkUmVzb3VyY2UqIENhY2hlOjpyZXNvdXJjZUZv clVSTChjb25zdCBTdHJpbmcmIHVybCkKIHsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0NhY2hlLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvQ2FjaGUuaAkocmV2aXNpb24gMzU4MTkpCisr KyBXZWJDb3JlL2xvYWRlci9DYWNoZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0zLDcgKzMsNyBAQAog CiAgICAgQ29weXJpZ2h0IChDKSAxOTk4IExhcnMgS25vbGwgKGtub2xsQG1waS1oZC5tcGcuZGUp CiAgICAgQ29weXJpZ2h0IChDKSAyMDAxIERpcmsgTXVlbGxlciA8bXVlbGxlckBrZGUub3JnPgot ICAgIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiwgMjAwNyBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3 LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KIAogICAgIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAgICBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YwpAQCAtOTksNiArOTksMTAgQEAgcHVibGljOgogCiAgICAgQ2FjaGVkQ1NTU3R5bGVTaGVldCog cmVxdWVzdFVzZXJDU1NTdHlsZVNoZWV0KERvY0xvYWRlciosIGNvbnN0IFN0cmluZyYgdXJsLCBj b25zdCBTdHJpbmcmIGNoYXJzZXQpOwogICAgIAorICAgIHZvaWQgcmV2YWxpZGF0ZVJlc291cmNl KENhY2hlZFJlc291cmNlKiwgRG9jTG9hZGVyKik7CisgICAgdm9pZCByZXZhbGlkYXRpb25TdWNj ZWVkZWQoQ2FjaGVkUmVzb3VyY2UqIHJldmFsaWRhdGluZ1Jlc291cmNlLCB0aW1lX3QgbmV3RXhw aXJhdGlvbkRhdGUpOworICAgIHZvaWQgcmV2YWxpZGF0aW9uRmFpbGVkKENhY2hlZFJlc291cmNl KiByZXZhbGlkYXRpbmdSZXNvdXJjZSk7CisgICAgCiAgICAgLy8gU2V0cyB0aGUgY2FjaGUncyBt ZW1vcnkgY2FwYWNpdGllcywgaW4gYnl0ZXMuIFRoZXNlIHdpbGwgaG9sZCBvbmx5IGFwcHJveGlt YXRlbHksIAogICAgIC8vIHNpbmNlIHRoZSBkZWNvZGVkIGNvc3Qgb2YgcmVzb3VyY2VzIGxpa2Ug c2NyaXB0cyBhbmQgc3R5bGVzaGVldHMgaXMgbm90IGtub3duLgogICAgIC8vICAtIG1pbkRlYWRC eXRlczogVGhlIG1heGltdW0gbnVtYmVyIG9mIGJ5dGVzIHRoYXQgZGVhZCByZXNvdXJjZXMgc2hv dWxkIGNvbnN1bWUgd2hlbiB0aGUgY2FjaGUgaXMgdW5kZXIgcHJlc3N1cmUuCkluZGV4OiBXZWJD b3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2Fk ZXIvQ2FjaGVkUmVzb3VyY2UuY3BwCShyZXZpc2lvbiAzNTgxOSkKKysrIFdlYkNvcmUvbG9hZGVy L0NhY2hlZFJlc291cmNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjUsNiArMjUsNyBAQAogI2lu Y2x1ZGUgIkNhY2hlZFJlc291cmNlLmgiCiAKICNpbmNsdWRlICJDYWNoZS5oIgorI2luY2x1ZGUg IkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiRG9jTG9hZGVyLmgiCiAjaW5jbHVk ZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgpAQCAtNDUsNiArNDYsMTAgQEAg Q2FjaGVkUmVzb3VyY2U6OkNhY2hlZFJlc291cmNlKGNvbnN0IFN0cgogICAgICwgbV9pbkNhY2hl KGZhbHNlKQogICAgICwgbV9sb2FkaW5nKGZhbHNlKQogICAgICwgbV9kb2NMb2FkZXIoMCkKKyAg ICAsIG1faGFuZGxlQ291bnQoMCkKKyAgICAsIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUoMCkKKyAg ICAsIG1faXNCZWluZ1JldmFsaWRhdGVkKGZhbHNlKQorICAgICwgbV9leHBpcmF0aW9uRGF0ZSgw KQogewogICAgIG1fdHlwZSA9IHR5cGU7CiAgICAgbV9zdGF0dXMgPSBQZW5kaW5nOwpAQCAtNzYs NyArODEsMTIgQEAgQ2FjaGVkUmVzb3VyY2U6On5DYWNoZWRSZXNvdXJjZSgpCiAjaWZuZGVmIE5E RUJVRwogICAgIG1fZGVsZXRlZCA9IHRydWU7CiAjZW5kaWYKKworICAgIEFTU0VSVChjYWNoZSgp LT5yZXNvdXJjZUZvclVSTCh1cmwoKSkgIT0gdGhpcyk7CiAgICAgCisgICAgaWYgKG1fcmVzb3Vy Y2VUb1JldmFsaWRhdGUpCisgICAgICAgIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPm1faXNCZWlu Z1JldmFsaWRhdGVkID0gZmFsc2U7ICAgIAorICAgCiAgICAgaWYgKG1fZG9jTG9hZGVyKQogICAg ICAgICBtX2RvY0xvYWRlci0+cmVtb3ZlQ2FjaGVkUmVzb3VyY2UodGhpcyk7CiB9CkBAIC05NSwx MiArMTA1LDE4IEBAIHZvaWQgQ2FjaGVkUmVzb3VyY2U6OmZpbmlzaCgpCiAKIGJvb2wgQ2FjaGVk UmVzb3VyY2U6OmlzRXhwaXJlZCgpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX3Jlc3BvbnNlLmV4cGly YXRpb25EYXRlKCkpCisgICAgaWYgKCFtX2V4cGlyYXRpb25EYXRlKQogICAgICAgICByZXR1cm4g ZmFsc2U7CiAgICAgdGltZV90IG5vdyA9IHRpbWUoMCk7Ci0gICAgcmV0dXJuIChkaWZmdGltZShu b3csIG1fcmVzcG9uc2UuZXhwaXJhdGlvbkRhdGUoKSkgPj0gMCk7CisgICAgcmV0dXJuIChkaWZm dGltZShub3csIG1fZXhwaXJhdGlvbkRhdGUpID49IDApOwogfQotCisgIAordm9pZCBDYWNoZWRS ZXNvdXJjZTo6c2V0UmVzcG9uc2UoY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVzcG9uc2UpCit7 CisgICAgbV9yZXNwb25zZSA9IHJlc3BvbnNlOworICAgIG1fZXhwaXJhdGlvbkRhdGUgPSByZXNw b25zZS5leHBpcmF0aW9uRGF0ZSgpOworfQorICAgIAogdm9pZCBDYWNoZWRSZXNvdXJjZTo6c2V0 UmVxdWVzdChSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGlmIChyZXF1ZXN0ICYmICFtX3JlcXVl c3QpCkBAIC0xMzksNiArMTU1LDEyIEBAIHZvaWQgQ2FjaGVkUmVzb3VyY2U6OnJlbW92ZUNsaWVu dChDYWNoZWQKICAgICB9CiB9CiAKK3ZvaWQgQ2FjaGVkUmVzb3VyY2U6OmNoZWNrRGVsZXRlKCkK K3sKKyAgICBpZiAoY2FuRGVsZXRlKCkgJiYgIWluQ2FjaGUoKSkKKyAgICAgICAgZGVsZXRlIHRo aXM7Cit9CisgICAgCiB2b2lkIENhY2hlZFJlc291cmNlOjpzZXREZWNvZGVkU2l6ZSh1bnNpZ25l ZCBzaXplKQogewogICAgIGlmIChzaXplID09IG1fZGVjb2RlZFNpemUpCkBAIC0yMDgsNSArMjMw LDY2IEBAIHZvaWQgQ2FjaGVkUmVzb3VyY2U6OmRpZEFjY2Vzc0RlY29kZWREYXQKICAgICAgICAg Y2FjaGUoKS0+cHJ1bmUoKTsKICAgICB9CiB9CisgICAgCit2b2lkIENhY2hlZFJlc291cmNlOjpz ZXRSZXNvdXJjZVRvUmV2YWxpZGF0ZShDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UpIAoreyAKKyAg ICBBU1NFUlQocmVzb3VyY2UpOworICAgIEFTU0VSVCghbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSk7 CisgICAgQVNTRVJUKHJlc291cmNlICE9IHRoaXMpOworICAgIEFTU0VSVCghcmVzb3VyY2UtPm1f aXNCZWluZ1JldmFsaWRhdGVkKTsKKyAgICBBU1NFUlQobV9oYW5kbGVzVG9SZXZhbGlkYXRlLmlz RW1wdHkoKSk7CisgICAgQVNTRVJUKHJlc291cmNlLT50eXBlKCkgPT0gdHlwZSgpKTsKKyAgICBy ZXNvdXJjZS0+bV9pc0JlaW5nUmV2YWxpZGF0ZWQgPSB0cnVlOworICAgIG1fcmVzb3VyY2VUb1Jl dmFsaWRhdGUgPSByZXNvdXJjZTsKK30KKwordm9pZCBDYWNoZWRSZXNvdXJjZTo6Y2xlYXJSZXNv dXJjZVRvUmV2YWxpZGF0ZSgpIAoreyAKKyAgICBBU1NFUlQobV9yZXNvdXJjZVRvUmV2YWxpZGF0 ZSk7CisgICAgQVNTRVJUKG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPm1faXNCZWluZ1JldmFsaWRh dGVkKTsKKyAgICBtX3Jlc291cmNlVG9SZXZhbGlkYXRlLT5tX2lzQmVpbmdSZXZhbGlkYXRlZCA9 IGZhbHNlOworICAgIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPmNoZWNrRGVsZXRlKCk7CisgICAg bV9oYW5kbGVzVG9SZXZhbGlkYXRlLmNsZWFyKCk7CisgICAgbV9yZXNvdXJjZVRvUmV2YWxpZGF0 ZSA9IDA7CisgICAgY2hlY2tEZWxldGUoKTsKK30KKyAgICAKK3ZvaWQgQ2FjaGVkUmVzb3VyY2U6 OnN3aXRjaENsaWVudHNUb1JldmFsaWRhdGVkUmVzb3VyY2UoKQoreworICAgIEFTU0VSVChtX3Jl c291cmNlVG9SZXZhbGlkYXRlKTsKKyAgICBBU1NFUlQoIWluQ2FjaGUoKSk7CisKKyAgICBIYXNo U2V0PENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSo+OjppdGVyYXRvciBlbmQgPSBtX2hhbmRsZXNU b1JldmFsaWRhdGUuZW5kKCk7CisgICAgZm9yIChIYXNoU2V0PENhY2hlZFJlc291cmNlSGFuZGxl QmFzZSo+OjppdGVyYXRvciBpdCA9IG1faGFuZGxlc1RvUmV2YWxpZGF0ZS5iZWdpbigpOyBpdCAh PSBlbmQ7ICsraXQpIHsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKiBoYW5kbGUg PSAqaXQ7CisgICAgICAgIGhhbmRsZS0+bV9yZXNvdXJjZSA9IG1fcmVzb3VyY2VUb1JldmFsaWRh dGU7CisgICAgICAgIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlZ2lzdGVySGFuZGxlKGhhbmRs ZSk7CisgICAgICAgIC0tbV9oYW5kbGVDb3VudDsKKyAgICB9CisgICAgQVNTRVJUKCFtX2hhbmRs ZUNvdW50KTsKKyAgICBtX2hhbmRsZXNUb1JldmFsaWRhdGUuY2xlYXIoKTsKKworICAgIFZlY3Rv cjxDYWNoZWRSZXNvdXJjZUNsaWVudCo+IGNsaWVudHNUb01vdmU7CisgICAgSGFzaENvdW50ZWRT ZXQ8Q2FjaGVkUmVzb3VyY2VDbGllbnQqPjo6aXRlcmF0b3IgZW5kMiA9IG1fY2xpZW50cy5lbmQo KTsKKyAgICBmb3IgKEhhc2hDb3VudGVkU2V0PENhY2hlZFJlc291cmNlQ2xpZW50Kj46Oml0ZXJh dG9yIGl0ID0gbV9jbGllbnRzLmJlZ2luKCk7IGl0ICE9IGVuZDI7ICsraXQpIHsKKyAgICAgICAg Q2FjaGVkUmVzb3VyY2VDbGllbnQqIGNsaWVudCA9IGl0LT5maXJzdDsKKyAgICAgICAgdW5zaWdu ZWQgY291bnQgPSBpdC0+c2Vjb25kOworICAgICAgICB3aGlsZSAoY291bnQpIHsKKyAgICAgICAg ICAgIGNsaWVudHNUb01vdmUuYXBwZW5kKGNsaWVudCk7CisgICAgICAgICAgICAtLWNvdW50Owor ICAgICAgICB9CisgICAgfQorICAgIC8vIEVxdWl2YWxlbnQgb2YgZGVyZWYoKSBmb3IgYWxsIGNs aWVudHMKKyAgICBtX2NsaWVudHMuY2xlYXIoKTsKKyAgICAKKyAgICB1bnNpZ25lZCBtb3ZlQ291 bnQgPSBjbGllbnRzVG9Nb3ZlLnNpemUoKTsKKyAgICBmb3IgKHVuc2lnbmVkIG4gPSAwOyBuIDwg bW92ZUNvdW50OyArK24pCisgICAgICAgIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPmFkZENsaWVu dChjbGllbnRzVG9Nb3ZlW25dKTsKK30KKyAgICAKK2Jvb2wgQ2FjaGVkUmVzb3VyY2U6OmNhbkJl UmV2YWxpZGF0ZWQoKSBjb25zdAoreworICAgIHJldHVybiAhbV9sb2FkaW5nICYmICghbV9yZXNw b25zZS5odHRwSGVhZGVyRmllbGQoIkxhc3QtTW9kaWZpZWQiKS5pc0VtcHR5KCkgfHwgIW1fcmVz cG9uc2UuaHR0cEhlYWRlckZpZWxkKCJFVGFnIikuaXNFbXB0eSgpKTsKK30KIAogfQpJbmRleDog V2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xv YWRlci9DYWNoZWRSZXNvdXJjZS5oCShyZXZpc2lvbiAzNTgxOSkKKysrIFdlYkNvcmUvbG9hZGVy L0NhY2hlZFJlc291cmNlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNs dWRlICJSZXNvdXJjZVJlc3BvbnNlLmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCiAjaW5j bHVkZSA8d3RmL0hhc2hDb3VudGVkU2V0Lmg+CisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNp bmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAjaW5jbHVkZSA8dGltZS5oPgogCkBAIC0zNCw3ICszNSw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2FjaGU7CiBjbGFzcyBDYWNoZWRSZXNv dXJjZUNsaWVudDsKLWNsYXNzIENhY2hlSGFuZGxlQmFzZTsKK2NsYXNzIENhY2hlZFJlc291cmNl SGFuZGxlQmFzZTsKIGNsYXNzIERvY0xvYWRlcjsKIGNsYXNzIFJlcXVlc3Q7CiAKQEAgLTgzLDYg Kzg0LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhZGRDbGllbnQoQ2FjaGVkUmVzb3Vy Y2VDbGllbnQqKTsKICAgICB2b2lkIHJlbW92ZUNsaWVudChDYWNoZWRSZXNvdXJjZUNsaWVudCop OwogICAgIGJvb2wgcmVmZXJlbmNlZCgpIGNvbnN0IHsgcmV0dXJuICFtX2NsaWVudHMuaXNFbXB0 eSgpOyB9CisgICAgdm9pZCBjaGVja0RlbGV0ZSgpOwogCiAgICAgZW51bSBQcmVsb2FkUmVzdWx0 IHsKICAgICAgICAgUHJlbG9hZE5vdFJlZmVyZW5jZWQsCkBAIC0xMjgsMTAgKzEzMCwxMCBAQCBw dWJsaWM6CiAKICAgICBTaGFyZWRCdWZmZXIqIGRhdGEoKSBjb25zdCB7IHJldHVybiBtX2RhdGEu Z2V0KCk7IH0KIAotICAgIHZvaWQgc2V0UmVzcG9uc2UoY29uc3QgUmVzb3VyY2VSZXNwb25zZSYg cmVzcG9uc2UpIHsgbV9yZXNwb25zZSA9IHJlc3BvbnNlOyB9CisgICAgdm9pZCBzZXRSZXNwb25z ZShjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSk7CiAgICAgY29uc3QgUmVzb3VyY2VS ZXNwb25zZSYgcmVzcG9uc2UoKSBjb25zdCB7IHJldHVybiBtX3Jlc3BvbnNlOyB9CiAgICAgCi0g ICAgYm9vbCBjYW5EZWxldGUoKSBjb25zdCB7IHJldHVybiAhcmVmZXJlbmNlZCgpICYmICFtX3Jl cXVlc3QgJiYgIW1fcHJlbG9hZENvdW50OyB9CisgICAgYm9vbCBjYW5EZWxldGUoKSBjb25zdCB7 IHJldHVybiAhcmVmZXJlbmNlZCgpICYmICFtX3JlcXVlc3QgJiYgIW1fcHJlbG9hZENvdW50ICYm ICFtX2hhbmRsZUNvdW50ICYmICFtX3Jlc291cmNlVG9SZXZhbGlkYXRlICYmICFtX2lzQmVpbmdS ZXZhbGlkYXRlZDsgfQogCiAgICAgYm9vbCBpc0V4cGlyZWQoKSBjb25zdDsKIApAQCAtMTUzLDYg KzE1NSwxMiBAQCBwdWJsaWM6CiAgICAgdm9pZCBpbmNyZWFzZVByZWxvYWRDb3VudCgpIHsgKytt X3ByZWxvYWRDb3VudDsgfQogICAgIHZvaWQgZGVjcmVhc2VQcmVsb2FkQ291bnQoKSB7IEFTU0VS VChtX3ByZWxvYWRDb3VudCk7IC0tbV9wcmVsb2FkQ291bnQ7IH0KICAgICAKKyAgICB2b2lkIHJl Z2lzdGVySGFuZGxlKENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSogaCkgeyArK21faGFuZGxlQ291 bnQ7IGlmIChtX3Jlc291cmNlVG9SZXZhbGlkYXRlKSBtX2hhbmRsZXNUb1JldmFsaWRhdGUuYWRk KGgpOyB9CisgICAgdm9pZCB1bnJlZ2lzdGVySGFuZGxlKENhY2hlZFJlc291cmNlSGFuZGxlQmFz ZSogaCkgeyAtLW1faGFuZGxlQ291bnQ7IGlmIChtX3Jlc291cmNlVG9SZXZhbGlkYXRlKSBtX2hh bmRsZXNUb1JldmFsaWRhdGUucmVtb3ZlKGgpOyBjaGVja0RlbGV0ZSgpOyB9CisgICAgCisgICAg Ym9vbCBjYW5CZVJldmFsaWRhdGVkKCkgY29uc3Q7CisgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291 cmNlVG9SZXZhbGlkYXRlKCkgY29uc3QgeyByZXR1cm4gbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZTsg fQorICAgIAogcHJvdGVjdGVkOgogICAgIHZvaWQgc2V0RW5jb2RlZFNpemUodW5zaWduZWQpOwog ICAgIHZvaWQgc2V0RGVjb2RlZFNpemUodW5zaWduZWQpOwpAQCAtMTczLDYgKzE4MSwxMiBAQCBw cm90ZWN0ZWQ6CiAgICAgYm9vbCBtX2Vycm9yT2NjdXJyZWQ7CiAKIHByaXZhdGU6CisgICAgLy8g VGhlc2UgYXJlIGNhbGxlZCBieSB0aGUgZnJpZW5kbHkgQ2FjaGUgb25seQorICAgIHZvaWQgc2V0 UmVzb3VyY2VUb1JldmFsaWRhdGUoQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlKTsKKyAgICB2b2lk IHN3aXRjaENsaWVudHNUb1JldmFsaWRhdGVkUmVzb3VyY2UoKTsKKyAgICB2b2lkIGNsZWFyUmVz b3VyY2VUb1JldmFsaWRhdGUoKTsKKyAgICB2b2lkIHNldEV4cGlyYXRpb25EYXRlKHRpbWVfdCBl eHBpcmF0aW9uRGF0ZSkgeyBtX2V4cGlyYXRpb25EYXRlID0gZXhwaXJhdGlvbkRhdGU7ICB9CisK ICAgICB1bnNpZ25lZCBtX2VuY29kZWRTaXplOwogICAgIHVuc2lnbmVkIG1fZGVjb2RlZFNpemU7 CiAgICAgdW5zaWduZWQgbV9hY2Nlc3NDb3VudDsKQEAgLTIwMiw2ICsyMTYsMTggQEAgcHJpdmF0 ZToKICAgICBDYWNoZWRSZXNvdXJjZSogbV9wcmV2SW5MaXZlUmVzb3VyY2VzTGlzdDsKIAogICAg IERvY0xvYWRlciogbV9kb2NMb2FkZXI7IC8vIG9ubHkgbm9uLTAgZm9yIHJlc291cmNlcyB0aGF0 IGFyZSBub3QgaW4gdGhlIGNhY2hlCisgICAgCisgICAgdW5zaWduZWQgbV9oYW5kbGVDb3VudDsK KyAgICAvLyBJZiB0aGlzIGZpZWxkIGlzIG5vbi1udWxsIHdlIGFyZSB1c2luZyB0aGUgcmVzb3Vy Y2UgYXMgYSBwcm94eSBmb3IgY2hlY2tpbmcgd2hldGhlciBhbiBleGlzdGluZyByZXNvdXJjZSBp cyBzdGlsbCB1cCB0byBkYXRlCisgICAgLy8gdXNpbmcgSFRUUCBJZi1tb2RpZmllZC1zaW5jZS9J Zi1ub25lLWV4aXN0cyBoZWFkZXJzLiBJZiB0aGUgcmVzcG9uc2UgaXMgMzA0IGFsbCBjbGllbnRz IG9mIHRoaXMgcmVzb3VyY2UgYXJlIG1vdmVkCisgICAgLy8gdG8gdG8gYmUgY2xpZW50cyBvZiBt X3Jlc291cmNlVG9SZXZhbGlkYXRlIGFuZCB0aGUgcmVzb3VyY2UgaXMgZGVsZXRlZC4gSWYgbm90 LCB0aGUgZmllbGQgaXMgemVyb2VkIGFuZCB0aGlzCisgICAgLy8gcmVzb3VyY2VzIGJlY29tZXMg bm9ybWFsIHJlc291cmNlIGxvYWQuCisgICAgQ2FjaGVkUmVzb3VyY2UqIG1fcmVzb3VyY2VUb1Jl dmFsaWRhdGU7CisgICAgYm9vbCBtX2lzQmVpbmdSZXZhbGlkYXRlZDsKKyAgICAvLyBUaGVzZSBo YW5kbGVzIHdpbGwgbmVlZCB0byBiZSB1cGRhdGVkIHRvIHBvaW50IHRvIHRoZSBtX3Jlc291cmNl VG9SZXZhbGlkYXRlIGluIGNhc2Ugd2UgZ2V0IDMwNCByZXNwb25zZS4KKyAgICBIYXNoU2V0PENh Y2hlZFJlc291cmNlSGFuZGxlQmFzZSo+IG1faGFuZGxlc1RvUmV2YWxpZGF0ZTsKKyAgICAKKyAg ICB0aW1lX3QgbV9leHBpcmF0aW9uRGF0ZTsKIH07CiAKIH0KSW5kZXg6IFdlYkNvcmUvbG9hZGVy L0NhY2hlZFJlc291cmNlSGFuZGxlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvQ2Fj aGVkUmVzb3VyY2VIYW5kbGUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvbG9hZGVyL0NhY2hl ZFJlc291cmNlSGFuZGxlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsOTcgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2lmbmRlZiBDYWNoZWRSZXNv dXJjZUhhbmRsZV9oCisjZGVmaW5lIENhY2hlZFJlc291cmNlSGFuZGxlX2gKKworI2luY2x1ZGUg IkNhY2hlZFJlc291cmNlLmgiCisjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0 Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisgICAgY2xhc3MgQ2FjaGVkUmVz b3VyY2VIYW5kbGVCYXNlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIH5DYWNoZWRSZXNvdXJjZUhh bmRsZUJhc2UoKSB7IGlmIChtX3Jlc291cmNlKSBtX3Jlc291cmNlLT51bnJlZ2lzdGVySGFuZGxl KHRoaXMpOyB9CisgICAgICAgIENhY2hlZFJlc291cmNlKiBnZXQoKSBjb25zdCB7IHJldHVybiBt X3Jlc291cmNlOyB9CisgICAgICAgIAorICAgICAgICBib29sIG9wZXJhdG9yISgpIGNvbnN0IHsg cmV0dXJuICFnZXQoKTsgfQorICAgICAgICBvcGVyYXRvciBib29sKCkgY29uc3QgeyByZXR1cm4g Z2V0KCk7IH0KKworICAgIHByb3RlY3RlZDoKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGVC YXNlKCkgOiBtX3Jlc291cmNlKDApIHt9CisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlQmFz ZShDYWNoZWRSZXNvdXJjZSogcmVzKSB7IG1fcmVzb3VyY2UgPSByZXM7IGlmIChtX3Jlc291cmNl KSBtX3Jlc291cmNlLT5yZWdpc3RlckhhbmRsZSh0aGlzKTsgfQorICAgICAgICBDYWNoZWRSZXNv dXJjZUhhbmRsZUJhc2UoY29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlJiBvKSA6IG1fcmVz b3VyY2Uoby5tX3Jlc291cmNlKSB7IGlmIChtX3Jlc291cmNlKSBtX3Jlc291cmNlLT5yZWdpc3Rl ckhhbmRsZSh0aGlzKTsgfQorCisgICAgICAgIHZvaWQgc2V0UmVzb3VyY2UoQ2FjaGVkUmVzb3Vy Y2UqIHJlcykgeworICAgICAgICAgICAgaWYgKG1fcmVzb3VyY2UpCisgICAgICAgICAgICAgICAg bV9yZXNvdXJjZS0+dW5yZWdpc3RlckhhbmRsZSh0aGlzKTsKKyAgICAgICAgICAgIG1fcmVzb3Vy Y2UgPSByZXM7CisgICAgICAgICAgICBpZiAobV9yZXNvdXJjZSkKKyAgICAgICAgICAgICAgICBt X3Jlc291cmNlLT5yZWdpc3RlckhhbmRsZSh0aGlzKTsKKyAgICAgICAgfQorICAgICAgICAKKyAg ICBwcml2YXRlOgorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UmIG9wZXJhdG9yPShj b25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UmKSB7IHJldHVybiAqdGhpczsgfSAKKyAgICAg ICAgCisgICAgICAgIGZyaWVuZCBjbGFzcyBDYWNoZWRSZXNvdXJjZTsKKworICAgICAgICBDYWNo ZWRSZXNvdXJjZSogbV9yZXNvdXJjZTsKKyAgICB9OworICAgICAgICAKKyAgICB0ZW1wbGF0ZSA8 Y2xhc3MgUj4gY2xhc3MgQ2FjaGVkUmVzb3VyY2VIYW5kbGUgOiBwdWJsaWMgQ2FjaGVkUmVzb3Vy Y2VIYW5kbGVCYXNlIHsKKyAgICBwdWJsaWM6IAorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRs ZSgpIHt9CisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlKFIqIHJlcykgOiBDYWNoZWRSZXNv dXJjZUhhbmRsZUJhc2UocmVzKSB7fQorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZShjb25z dCBDYWNoZWRSZXNvdXJjZUhhbmRsZTxSPiYgbykgOiBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2Uo bykge30KKworICAgICAgICBSKiBnZXQoKSBjb25zdCB7IHJldHVybiByZWludGVycHJldF9jYXN0 PFIqPihDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2U6OmdldCgpKTsgfQorICAgICAgICBSKiBvcGVy YXRvci0+KCkgY29uc3QgeyByZXR1cm4gZ2V0KCk7IH0KKyAgICAgICAgICAgICAgIAorICAgICAg ICBDYWNoZWRSZXNvdXJjZUhhbmRsZSYgb3BlcmF0b3I9KFIqIHJlcykgeyBzZXRSZXNvdXJjZShy ZXMpOyByZXR1cm4gKnRoaXM7IH0gCisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlJiBvcGVy YXRvcj0oY29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGUmIG8pIHsgc2V0UmVzb3VyY2Uoby5nZXQo KSk7IHJldHVybiAqdGhpczsgfQorICAgICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQ2FjaGVk UmVzb3VyY2VIYW5kbGVCYXNlJiBvKSBjb25zdCB7IHJldHVybiBnZXQoKSA9PSBvLmdldCgpOyB9 CisgICAgICAgIGJvb2wgb3BlcmF0b3IhPShjb25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2Um IG8pIGNvbnN0IHsgcmV0dXJuIGdldCgpICE9IG8uZ2V0KCk7IH0KKyAgICB9OworICAgIAorICAg IHRlbXBsYXRlIDxjbGFzcyBSLCBjbGFzcyBSUj4gYm9vbCBvcGVyYXRvcj09KGNvbnN0IENhY2hl ZFJlc291cmNlSGFuZGxlPFI+JiBoLCBjb25zdCBSUiogcmVzKSAKKyAgICB7IAorICAgICAgICBy ZXR1cm4gaC5nZXQoKSA9PSByZXM7IAorICAgIH0KKyAgICB0ZW1wbGF0ZSA8Y2xhc3MgUiwgY2xh c3MgUlI+IGJvb2wgb3BlcmF0b3I9PShjb25zdCBSUiogcmVzLCBjb25zdCBDYWNoZWRSZXNvdXJj ZUhhbmRsZTxSPiYgaCkgCisgICAgeyAKKyAgICAgICAgcmV0dXJuIGguZ2V0KCkgPT0gcmVzOyAK KyAgICB9CisgICAgdGVtcGxhdGUgPGNsYXNzIFIsIGNsYXNzIFJSPiBib29sIG9wZXJhdG9yIT0o Y29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Uj4mIGgsIGNvbnN0IFJSKiByZXMpIAorICAgIHsg CisgICAgICAgIHJldHVybiBoLmdldCgpICE9IHJlczsgCisgICAgfQorICAgIHRlbXBsYXRlIDxj bGFzcyBSLCBjbGFzcyBSUj4gYm9vbCBvcGVyYXRvciE9KGNvbnN0IFJSKiByZXMsIGNvbnN0IENh Y2hlZFJlc291cmNlSGFuZGxlPFI+JiBoKSAKKyAgICB7IAorICAgICAgICByZXR1cm4gaC5nZXQo KSAhPSByZXM7IAorICAgIH0KK30KKworI2VuZGlmCkluZGV4OiBXZWJDb3JlL2xvYWRlci9Eb2NM b2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5jcHAJKHJl dmlzaW9uIDM1ODE5KQorKysgV2ViQ29yZS9sb2FkZXIvRG9jTG9hZGVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtODQsMTQgKzg0LDE1IEBAIHZvaWQgRG9jTG9hZGVyOjpjaGVja0ZvclJlbG9hZChj b25zdCBLVVIKICAgICAgICBpZiAoIW1fcmVsb2FkZWRVUkxzLmNvbnRhaW5zKGZ1bGxVUkwuc3Ry aW5nKCkpKSB7CiAgICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIGV4aXN0aW5nID0gY2FjaGUoKS0+ cmVzb3VyY2VGb3JVUkwoZnVsbFVSTC5zdHJpbmcoKSk7CiAgICAgICAgICAgaWYgKGV4aXN0aW5n ICYmIGV4aXN0aW5nLT5pc0V4cGlyZWQoKSAmJiAhZXhpc3RpbmctPmlzUHJlbG9hZGVkKCkpIHsK LSAgICAgICAgICAgICBjYWNoZSgpLT5yZW1vdmUoZXhpc3RpbmcpOwotICAgICAgICAgICAgIG1f cmVsb2FkZWRVUkxzLmFkZChmdWxsVVJMLnN0cmluZygpKTsKKyAgICAgICAgICAgICAgY2FjaGUo KS0+cmV2YWxpZGF0ZVJlc291cmNlKGV4aXN0aW5nLCB0aGlzKTsKKyAgICAgICAgICAgICAgbV9y ZWxvYWRlZFVSTHMuYWRkKGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAgIH0KICAgICAgICB9 CiAgICAgfSBlbHNlIGlmICgobV9jYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeVJlbG9hZCkgfHwg KG1fY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lSZWZyZXNoKSkgewogICAgICAgIGlmICghbV9y ZWxvYWRlZFVSTHMuY29udGFpbnMoZnVsbFVSTC5zdHJpbmcoKSkpIHsKICAgICAgICAgICAgQ2Fj aGVkUmVzb3VyY2UqIGV4aXN0aW5nID0gY2FjaGUoKS0+cmVzb3VyY2VGb3JVUkwoZnVsbFVSTC5z dHJpbmcoKSk7CiAgICAgICAgICAgIGlmIChleGlzdGluZyAmJiAhZXhpc3RpbmctPmlzUHJlbG9h ZGVkKCkpIHsKKyAgICAgICAgICAgICAgIC8vIEZJWE1FOiBVc2UgcmV2YWxpZGF0ZVJlc291cmNl KCkgdG8gaW1wbGVtZW50IEhUVFAgMS4xICJTcGVjaWZpYyBlbmQtdG8tZW5kIHJldmFsaWRhdGlv biIgZm9yIHJlZ3VsYXIgcmVsb2FkaW5nCiAgICAgICAgICAgICAgICBjYWNoZSgpLT5yZW1vdmUo ZXhpc3RpbmcpOwogICAgICAgICAgICAgICAgbV9yZWxvYWRlZFVSTHMuYWRkKGZ1bGxVUkwuc3Ry aW5nKCkpOwogICAgICAgICAgICB9CkluZGV4OiBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAJKHJldmlzaW9uIDM1ODE5KQor KysgV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjE4LDExICsy MTgsMTIgQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKAogICAgIHdo aWxlICghcmVxdWVzdHNQZW5kaW5nLmlzRW1wdHkoKSkgeyAgICAgICAgCiAgICAgICAgIFJlcXVl c3QqIHJlcXVlc3QgPSByZXF1ZXN0c1BlbmRpbmcuZmlyc3QoKTsKICAgICAgICAgRG9jTG9hZGVy KiBkb2NMb2FkZXIgPSByZXF1ZXN0LT5kb2NMb2FkZXIoKTsKKyAgICAgICAgQ2FjaGVkUmVzb3Vy Y2UqIHJlc291cmNlVG9SZXZhbGlkYXRlID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKS0+cmVz b3VyY2VUb1JldmFsaWRhdGUoKTsKICAgICAgICAgLy8gSWYgdGhlIGRvY3VtZW50IGlzIGZ1bGx5 IHBhcnNlZCBhbmQgdGhlcmUgYXJlIG5vIHBlbmRpbmcgc3R5bGVzaGVldHMgdGhlcmUgd29uJ3Qg YmUgYW55IG1vcmUgCiAgICAgICAgIC8vIHJlc291cmNlcyB0aGF0IHdlIHdvdWxkIHdhbnQgdG8g cHVzaCB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlLiBKdXN0IGhhbmQgb2ZmIHRoZSByZW1haW5p bmcgcmVzb3VyY2VzCiAgICAgICAgIC8vIHRvIHRoZSBuZXR3b3JraW5nIGxheWVyLgogICAgICAg ICBib29sIHBhcnNlZEFuZFN0eWxlc2hlZXRzS25vd24gPSAhZG9jTG9hZGVyLT5kb2MoKS0+cGFy c2luZygpICYmIGRvY0xvYWRlci0+ZG9jKCktPmhhdmVTdHlsZXNoZWV0c0xvYWRlZCgpOwotICAg ICAgICBpZiAoIXBhcnNlZEFuZFN0eWxlc2hlZXRzS25vd24gJiYgbV9yZXF1ZXN0c0xvYWRpbmcu c2l6ZSgpID49IG1fbWF4UmVxdWVzdHNJbkZsaWdodCkgeworICAgICAgICBpZiAoIXBhcnNlZEFu ZFN0eWxlc2hlZXRzS25vd24gJiYgIXJlc291cmNlVG9SZXZhbGlkYXRlICYmIG1fcmVxdWVzdHNM b2FkaW5nLnNpemUoKSA+PSBtX21heFJlcXVlc3RzSW5GbGlnaHQpIHsKICAgICAgICAgICAgIHNl cnZlTG93ZXJQcmlvcml0eSA9IGZhbHNlOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9 CkBAIC0yMzcsNiArMjM4LDE3IEBAIHZvaWQgTG9hZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1 ZXN0cygKICAgICAgICAgaWYgKChyZWZlcnJlci5wcm90b2NvbElzKCJodHRwIikgfHwgcmVmZXJy ZXIucHJvdG9jb2xJcygiaHR0cHMiKSkgJiYgcmVmZXJyZXIucGF0aCgpLmlzRW1wdHkoKSkKICAg ICAgICAgICAgIHJlZmVycmVyLnNldFBhdGgoIi8iKTsKICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0 LnNldEhUVFBSZWZlcnJlcihyZWZlcnJlci5zdHJpbmcoKSk7CisgICAgICAgIAorICAgICAgICBp ZiAocmVzb3VyY2VUb1JldmFsaWRhdGUpIHsKKyAgICAgICAgICAgIEFTU0VSVChyZXNvdXJjZVRv UmV2YWxpZGF0ZS0+Y2FuQmVSZXZhbGlkYXRlZCgpKTsKKyAgICAgICAgICAgIEFTU0VSVChyZXNv dXJjZVRvUmV2YWxpZGF0ZS0+aXNMb2FkZWQoKSk7CisgICAgICAgICAgICBTdHJpbmcgbGFzdE1v ZGlmaWVkID0gcmVzb3VyY2VUb1JldmFsaWRhdGUtPnJlc3BvbnNlKCkuaHR0cEhlYWRlckZpZWxk KCJMYXN0LU1vZGlmaWVkIik7CisgICAgICAgICAgICBTdHJpbmcgZVRhZyA9IHJlc291cmNlVG9S ZXZhbGlkYXRlLT5yZXNwb25zZSgpLmh0dHBIZWFkZXJGaWVsZCgiRVRhZyIpOworICAgICAgICAg ICAgaWYgKCFsYXN0TW9kaWZpZWQuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgIHJlc291cmNl UmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIklmLU1vZGlmaWVkLVNpbmNlIiwgbGFzdE1vZGlm aWVkKTsKKyAgICAgICAgICAgIGlmICghZVRhZy5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAg cmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiSWYtTm9uZS1NYXRjaCIsIGVUYWcp OworICAgICAgICB9CiAKICAgICAgICAgUmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBsb2FkZXIg PSBTdWJyZXNvdXJjZUxvYWRlcjo6Y3JlYXRlKGRvY0xvYWRlci0+ZG9jKCktPmZyYW1lKCksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzLCByZXNvdXJjZVJlcXVlc3QsIHJlcXVlc3QtPnNob3VsZFNraXBDYW5M b2FkQ2hlY2soKSwgcmVxdWVzdC0+c2VuZFJlc291cmNlTG9hZENhbGxiYWNrcygpKTsKQEAgLTI2 OSw2ICsyODEsNyBAQCB2b2lkIExvYWRlcjo6SG9zdDo6ZGlkRmluaXNoTG9hZGluZyhTdWJyCiAg ICAgICAgIGRvY0xvYWRlci0+ZGVjcmVtZW50UmVxdWVzdENvdW50KCk7CiAKICAgICBDYWNoZWRS ZXNvdXJjZSogcmVzb3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOworICAgIEFTU0VS VCghcmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlkYXRlKCkpOwogCiAgICAgLy8gSWYgd2UgZ290 IGEgNHh4IHJlc3BvbnNlLCB3ZSdyZSBwcmV0ZW5kaW5nIHRvIGhhdmUgcmVjZWl2ZWQgYSBuZXR3 b3JrCiAgICAgLy8gZXJyb3IsIHNvIHdlIGNhbid0IHNlbmQgdGhlIHN1Y2Nlc3NmdWwgZGF0YSgp IGFuZCBmaW5pc2goKSBjYWxsYmFja3MuCkBAIC0zMTEsNiArMzI0LDkgQEAgdm9pZCBMb2FkZXI6 Okhvc3Q6OmRpZEZhaWwoU3VicmVzb3VyY2VMbwogICAgICAgICBkb2NMb2FkZXItPmRlY3JlbWVu dFJlcXVlc3RDb3VudCgpOwogCiAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlID0gcmVxdWVz dC0+Y2FjaGVkUmVzb3VyY2UoKTsKKyAgICAKKyAgICBpZiAocmVzb3VyY2UtPnJlc291cmNlVG9S ZXZhbGlkYXRlKCkpCisgICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGlvbkZhaWxlZChyZXNvdXJj ZSk7CiAKICAgICBpZiAoIWNhbmNlbGxlZCkgewogICAgICAgICBkb2NMb2FkZXItPnNldExvYWRJ blByb2dyZXNzKHRydWUpOwpAQCAtMzQwLDcgKzM1NiwyNyBAQCB2b2lkIExvYWRlcjo6SG9zdDo6 ZGlkUmVjZWl2ZVJlc3BvbnNlKFN1CiAgICAgLy8gQVNTRVJUKHJlcXVlc3QpOwogICAgIGlmICgh cmVxdWVzdCkKICAgICAgICAgcmV0dXJuOwotICAgIHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCkt PnNldFJlc3BvbnNlKHJlc3BvbnNlKTsKKyAgICAKKyAgICBDYWNoZWRSZXNvdXJjZSogcmVzb3Vy Y2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOworICAgIAorICAgIGlmIChyZXNvdXJjZS0+ cmVzb3VyY2VUb1JldmFsaWRhdGUoKSkgeworICAgICAgICBpZiAocmVzcG9uc2UuaHR0cFN0YXR1 c0NvZGUoKSA9PSAzMDQpIHsKKyAgICAgICAgICAgIC8vIDMwNCBOb3QgbW9kaWZpZWQgLyBVc2Ug bG9jYWwgY29weQorICAgICAgICAgICAgbV9yZXF1ZXN0c0xvYWRpbmcucmVtb3ZlKGxvYWRlcik7 CisgICAgICAgICAgICByZXF1ZXN0LT5kb2NMb2FkZXIoKS0+ZGVjcmVtZW50UmVxdWVzdENvdW50 KCk7CisKKyAgICAgICAgICAgIC8vIEV4aXN0aW5nIHJlc291cmNlIGlzIG9rLCBqdXN0IHVzZSBp dCB1cGRhdGluZyBleHBpcmF0aW9uIHRpbWUuCisgICAgICAgICAgICBjYWNoZSgpLT5yZXZhbGlk YXRpb25TdWNjZWVkZWQocmVzb3VyY2UsIHJlc3BvbnNlLmV4cGlyYXRpb25EYXRlKCkpOworICAg ICAgICAgICAgZGVsZXRlIHJlcXVlc3Q7CisKKyAgICAgICAgICAgIHNlcnZlUGVuZGluZ1JlcXVl c3RzKCk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0gCisgICAgICAgIC8vIERpZCBu b3QgZ2V0IDMwNCByZXNwb25zZSwgY29udGludWUgYXMgYSByZWd1bGFyIHJlc291cmNlIGxvYWQu CisgICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGlvbkZhaWxlZChyZXNvdXJjZSk7CisgICAgfQor ICAgIAorICAgIHJlc291cmNlLT5zZXRSZXNwb25zZShyZXNwb25zZSk7CiAgICAgCiAgICAgU3Ry aW5nIGVuY29kaW5nID0gcmVzcG9uc2UudGV4dEVuY29kaW5nTmFtZSgpOwogICAgIGlmICghZW5j b2RpbmcuaXNOdWxsKCkpCkBAIC0zNzEsNiArNDA3LDggQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OmRp ZFJlY2VpdmVEYXRhKFN1YnJlcwogICAgICAgICByZXR1cm47CiAKICAgICBDYWNoZWRSZXNvdXJj ZSogcmVzb3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOyAgICAKKyAgICBBU1NFUlQo IXJlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKTsKKyAgICAKICAgICBpZiAocmVzb3Vy Y2UtPmVycm9yT2NjdXJyZWQoKSkKICAgICAgICAgcmV0dXJuOwogICAgIApJbmRleDogV2ViQ29y ZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9hZGVyLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9hZGVyLmgJKHJldmlzaW9uIDM1ODE5KQorKysg V2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9hZGVyLmgJKHdvcmtpbmcgY29weSkK QEAgLTMwLDYgKzMwLDcgQEAKICNkZWZpbmUgVXNlclN0eWxlU2hlZXRMb2FkZXJfaAogCiAjaW5j bHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhh bmRsZS5oIgogCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKIApAQCAtNDgsNyArNDksNyBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBzZXRDU1NTdHlsZVNoZWV0KGNv bnN0IFN0cmluZyYgVVJMLCBjb25zdCBTdHJpbmcmIGNoYXJzZXQsIGNvbnN0IENhY2hlZENTU1N0 eWxlU2hlZXQqIHNoZWV0KTsKIAogICAgICAgICBSZWZQdHI8RG9jdW1lbnQ+IG1fZG9jdW1lbnQ7 Ci0gICAgICAgIENhY2hlZENTU1N0eWxlU2hlZXQqIG1fY2FjaGVkU2hlZXQ7CisgICAgICAgIENh Y2hlZFJlc291cmNlSGFuZGxlPENhY2hlZENTU1N0eWxlU2hlZXQ+IG1fY2FjaGVkU2hlZXQ7CiAg ICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50 SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJ KHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTgwOSw3ICs4MDksNyBAQCBDdXJzb3IgRXZlbnRIYW5kbGVyOjpzZWxlY3RD dXJzb3IoY29uc3QgCiAgICAgaWYgKHN0eWxlICYmIHN0eWxlLT5jdXJzb3JzKCkpIHsKICAgICAg ICAgY29uc3QgQ3Vyc29yTGlzdCogY3Vyc29ycyA9IHN0eWxlLT5jdXJzb3JzKCk7CiAgICAgICAg IGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBjdXJzb3JzLT5zaXplKCk7ICsraSkgewotICAgICAg ICAgICAgQ2FjaGVkSW1hZ2UqIGNpbWFnZSA9ICgqY3Vyc29ycylbaV0uY3Vyc29ySW1hZ2U7Cisg ICAgICAgICAgICBDYWNoZWRJbWFnZSogY2ltYWdlID0gKCpjdXJzb3JzKVtpXS5jdXJzb3JJbWFn ZS5nZXQoKTsKICAgICAgICAgICAgIEludFBvaW50IGhvdFNwb3QgPSAoKmN1cnNvcnMpW2ldLmhv dFNwb3Q7CiAgICAgICAgICAgICBpZiAoIWNpbWFnZSkKICAgICAgICAgICAgICAgICBjb250aW51 ZTsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckltYWdlLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbWFnZS5jcHAJKHJldmlzaW9uIDM1ODE5KQorKysg V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW1hZ2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTYs NyArMTk2LDcgQEAgdm9pZCBSZW5kZXJJbWFnZTo6c2V0Q2FjaGVkSW1hZ2UoQ2FjaGVkSQogICAg IGlmIChtX2NhY2hlZEltYWdlKSB7CiAgICAgICAgIG1fY2FjaGVkSW1hZ2UtPmFkZENsaWVudCh0 aGlzKTsKICAgICAgICAgaWYgKG1fY2FjaGVkSW1hZ2UtPmVycm9yT2NjdXJyZWQoKSkKLSAgICAg ICAgICAgIGltYWdlQ2hhbmdlZChtX2NhY2hlZEltYWdlKTsKKyAgICAgICAgICAgIGltYWdlQ2hh bmdlZChtX2NhY2hlZEltYWdlLmdldCgpKTsKICAgICB9CiB9CiAKQEAgLTI1OSw3ICsyNTksNyBA QCB2b2lkIFJlbmRlckltYWdlOjppbWFnZUNoYW5nZWQoV3JhcHBlZEltCiAKICAgICAvLyBTZXQg aW1hZ2UgZGltZW5zaW9ucywgdGFraW5nIGludG8gYWNjb3VudCB0aGUgc2l6ZSBvZiB0aGUgYWx0 IHRleHQuCiAgICAgaWYgKGVycm9yT2NjdXJyZWQoKSkKLSAgICAgICAgaW1hZ2VTaXplQ2hhbmdl ZCA9IHNldEltYWdlU2l6ZUZvckFsdFRleHQobV9jYWNoZWRJbWFnZSk7CisgICAgICAgIGltYWdl U2l6ZUNoYW5nZWQgPSBzZXRJbWFnZVNpemVGb3JBbHRUZXh0KG1fY2FjaGVkSW1hZ2UuZ2V0KCkp OwogICAgIAogICAgIGJvb2wgc2hvdWxkUmVwYWludCA9IHRydWU7CiAKSW5kZXg6IFdlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckltYWdlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVySW1hZ2UuaAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJJbWFnZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw2ICsyNiw3IEBACiAjZGVmaW5lIFJlbmRl ckltYWdlX2gKIAogI2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVz b3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJSZW5kZXJSZXBsYWNlZC5oIgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CkBAIC01Myw3ICs1NCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHVwZGF0ZUFsdFRl eHQoKTsKIAogICAgIHZvaWQgc2V0Q2FjaGVkSW1hZ2UoQ2FjaGVkSW1hZ2UqKTsKLSAgICBDYWNo ZWRJbWFnZSogY2FjaGVkSW1hZ2UoKSBjb25zdCB7IHJldHVybiBtX2NhY2hlZEltYWdlOyB9Cisg ICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFn ZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCBib29sIG5vZGVBdFBvaW50KGNvbnN0IEhpdFRlc3RS ZXF1ZXN0JiwgSGl0VGVzdFJlc3VsdCYsIGludCB4LCBpbnQgeSwgaW50IHR4LCBpbnQgdHksIEhp dFRlc3RBY3Rpb24pOwogCkBAIC03OCw3ICs3OSw3IEBAIHByb3RlY3RlZDoKICAgICB2aXJ0dWFs IGJvb2wgaW1hZ2VIYXNSZWxhdGl2ZVdpZHRoKCkgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFn ZSA/IG1fY2FjaGVkSW1hZ2UtPmltYWdlSGFzUmVsYXRpdmVXaWR0aCgpIDogZmFsc2U7IH0KICAg ICB2aXJ0dWFsIGJvb2wgaW1hZ2VIYXNSZWxhdGl2ZUhlaWdodCgpIGNvbnN0IHsgcmV0dXJuIG1f Y2FjaGVkSW1hZ2UgPyBtX2NhY2hlZEltYWdlLT5pbWFnZUhhc1JlbGF0aXZlSGVpZ2h0KCkgOiBm YWxzZTsgfQogICAgIHZpcnR1YWwgSW50U2l6ZSBpbWFnZVNpemUoZmxvYXQgbXVsdGlwbGllcikg Y29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZSA/IG1fY2FjaGVkSW1hZ2UtPmltYWdlU2l6ZSht dWx0aXBsaWVyKSA6IEludFNpemUoKTsgfQotICAgIHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGlt YWdlUHRyKCkgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZTsgfQorICAgIHZpcnR1YWwgV3Jh cHBlZEltYWdlUHRyIGltYWdlUHRyKCkgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZS5nZXQo KTsgfQogCiAgICAgdmlydHVhbCB2b2lkIGludHJpbnNpY1NpemVDaGFuZ2VkKCkgeyBpbWFnZUNo YW5nZWQoaW1hZ2VQdHIoKSk7IH0KIApAQCAtOTEsNyArOTIsNyBAQCBwcml2YXRlOgogCiBwcm90 ZWN0ZWQ6CiAgICAgLy8gVGhlIGltYWdlIHdlIGFyZSByZW5kZXJpbmcuCi0gICAgQ2FjaGVkSW1h Z2UqIG1fY2FjaGVkSW1hZ2U7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+ IG1fY2FjaGVkSW1hZ2U7CiAKICAgICAvLyBUZXh0IHRvIGRpc3BsYXkgYXMgbG9uZyBhcyB0aGUg aW1hZ2UgaXNuJ3QgYXZhaWxhYmxlLgogICAgIFN0cmluZyBtX2FsdFRleHQ7CkluZGV4OiBXZWJD b3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHlsZS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmgJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29y ZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiAr MzUsOCBAQAogICovCiAKICNpbmNsdWRlICJBZmZpbmVUcmFuc2Zvcm0uaCIKKyNpbmNsdWRlICJD YWNoZWRJbWFnZS5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVk ZSAiQ1NTSGVscGVyLmgiCiAjaW5jbHVkZSAiQ1NTSW1hZ2VHZW5lcmF0b3JWYWx1ZS5oIgogI2lu Y2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCkBAIC0xNjQsMTMgKzE2NiwxMyBAQCBjbGFzcyBT dHlsZUNhY2hlZEltYWdlIDogcHVibGljIFN0eWxlSW1hCiB7CiBwdWJsaWM6CiAgICAgc3RhdGlj IFBhc3NSZWZQdHI8U3R5bGVDYWNoZWRJbWFnZT4gY3JlYXRlKENhY2hlZEltYWdlKiBpbWFnZSkg eyByZXR1cm4gYWRvcHRSZWYobmV3IFN0eWxlQ2FjaGVkSW1hZ2UoaW1hZ2UpKTsgfQotICAgIHZp cnR1YWwgV3JhcHBlZEltYWdlUHRyIGRhdGEoKSBjb25zdCB7IHJldHVybiBtX2ltYWdlOyB9Cisg ICAgdmlydHVhbCBXcmFwcGVkSW1hZ2VQdHIgZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1faW1hZ2Uu Z2V0KCk7IH0KIAogICAgIHZpcnR1YWwgYm9vbCBpc0NhY2hlZEltYWdlKCkgY29uc3QgeyByZXR1 cm4gdHJ1ZTsgfQogICAgIAogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxDU1NWYWx1ZT4gY3NzVmFs dWUoKTsKICAgICAKLSAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UoKSBjb25zdCB7IHJldHVy biBtX2ltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlKCkgY29uc3QgeyByZXR1 cm4gbV9pbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCBib29sIGNhblJlbmRlcihmbG9hdCBt dWx0aXBsaWVyKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNMb2FkZWQoKSBjb25zdDsKQEAg LTE5MCw3ICsxOTIsNyBAQCBwcml2YXRlOgogICAgIHsKICAgICB9CiAgICAgCi0gICAgQ2FjaGVk SW1hZ2UqIG1faW1hZ2U7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1f aW1hZ2U7CiB9OwogCiBjbGFzcyBTdHlsZUdlbmVyYXRlZEltYWdlIDogcHVibGljIFN0eWxlSW1h Z2UKQEAgLTE1OTcsNyArMTU5OSw3IEBAIHN0cnVjdCBDdXJzb3JEYXRhIHsKICAgICBib29sIG9w ZXJhdG9yIT0oY29uc3QgQ3Vyc29yRGF0YSYgbykgY29uc3QgeyByZXR1cm4gISgqdGhpcyA9PSBv KTsgfQogCiAgICAgSW50UG9pbnQgaG90U3BvdDsgLy8gZm9yIENTUzMgc3VwcG9ydAotICAgIENh Y2hlZEltYWdlKiBjdXJzb3JJbWFnZTsgLy8gd2VhayBwb2ludGVyLCB0aGUgQ1NTVmFsdWVJbWFn ZSB0YWtlcyBjYXJlIG9mIGRlbGV0aW5nIGN1cnNvckltYWdlCisgICAgQ2FjaGVkUmVzb3VyY2VI YW5kbGU8Q2FjaGVkSW1hZ2U+IGN1cnNvckltYWdlOwogfTsKIAogY2xhc3MgQ3Vyc29yTGlzdCA6 IHB1YmxpYyBSZWZDb3VudGVkPEN1cnNvckxpc3Q+IHsKSW5kZXg6IFdlYkNvcmUvc3ZnL1NWR0ZF SW1hZ2VFbGVtZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHRkVJbWFnZUVsZW1l bnQuaAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3JlL3N2Zy9TVkdGRUltYWdlRWxlbWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC0yNCw2ICsyNCw3IEBACiAjZGVmaW5lIFNWR0ZFSW1hZ2VFbGVt ZW50X2gKIAogI2lmIEVOQUJMRShTVkcpICYmIEVOQUJMRShTVkdfRklMVEVSUykKKyNpbmNsdWRl ICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNWR0ZpbHRlclByaW1pdGl2ZVN0 YW5kYXJkQXR0cmlidXRlcy5oIgogI2luY2x1ZGUgIlNWR1VSSVJlZmVyZW5jZS5oIgogI2luY2x1 ZGUgIlNWR0xhbmdTcGFjZS5oIgpAQCAtNTUsNyArNTYsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgcHJpdmF0ZToKICAgICAgICAgQU5JTUFURURfUFJPUEVSVFlfREVDTEFSQVRJT05TKFNW R0ZFSW1hZ2VFbGVtZW50LCBTVkdOYW1lczo6ZmVJbWFnZVRhZ1N0cmluZywgU1ZHTmFtZXM6OnBy ZXNlcnZlQXNwZWN0UmF0aW9BdHRyU3RyaW5nLCBTVkdQcmVzZXJ2ZUFzcGVjdFJhdGlvLCBQcmVz ZXJ2ZUFzcGVjdFJhdGlvLCBwcmVzZXJ2ZUFzcGVjdFJhdGlvKQogCi0gICAgICAgIENhY2hlZElt YWdlKiBtX2NhY2hlZEltYWdlOworICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRJ bWFnZT4gbV9jYWNoZWRJbWFnZTsKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8RkVJbWFnZT4gbV9m aWx0ZXJFZmZlY3Q7CiAgICAgfTsKIApJbmRleDogV2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmlsdGVy cy9TVkdGRUltYWdlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmlsdGVy cy9TVkdGRUltYWdlLmgJKHJldmlzaW9uIDM1ODE5KQorKysgV2ViQ29yZS9zdmcvZ3JhcGhpY3Mv ZmlsdGVycy9TVkdGRUltYWdlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI1LDYgKzI1LDcgQEAKICNp ZiBFTkFCTEUoU1ZHKSAmJiBFTkFCTEUoU1ZHX0ZJTFRFUlMpCiAjaW5jbHVkZSAiQ2FjaGVkSW1h Z2UuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hl ZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiRmlsdGVyRWZmZWN0LmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKQEAgLTQ3LDcgKzQ4LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHBy aXZhdGU6CiAgICAgICAgIEZFSW1hZ2UoQ2FjaGVkSW1hZ2UqKTsKIAotICAgICAgICBDYWNoZWRJ bWFnZSogbV9jYWNoZWRJbWFnZTsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVk SW1hZ2U+IG1fY2FjaGVkSW1hZ2U7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJ bmRleDogV2ViQ29yZS94bWwvWFNMSW1wb3J0UnVsZS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv eG1sL1hTTEltcG9ydFJ1bGUuaAkocmV2aXNpb24gMzU4MTkpCisrKyBXZWJDb3JlL3htbC9YU0xJ bXBvcnRSdWxlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNpZiBFTkFCTEUo WFNMVCkKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2Fj aGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJTdHlsZUJhc2UuaCIKICNpbmNsdWRlICJY U0xTdHlsZVNoZWV0LmgiCiAKQEAgLTYwLDcgKzYxLDcgQEAgcHJpdmF0ZToKICAgICAKICAgICBT dHJpbmcgbV9zdHJIcmVmOwogICAgIFJlZlB0cjxYU0xTdHlsZVNoZWV0PiBtX3N0eWxlU2hlZXQ7 Ci0gICAgQ2FjaGVkWFNMU3R5bGVTaGVldCogbV9jYWNoZWRTaGVldDsKKyAgICBDYWNoZWRSZXNv dXJjZUhhbmRsZTxDYWNoZWRYU0xTdHlsZVNoZWV0PiBtX2NhY2hlZFNoZWV0OwogICAgIGJvb2wg bV9sb2FkaW5nOwogfTsKIAo= 22874 2008-08-18 20:44:44 -0700 2008-08-25 15:16:18 -0700 updated patch 304-12.patch text/plain 47639 koivisto SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTgwNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsOTUgQEAKKzIwMDgtMDgtMTggIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICAKKyAg ICAgICAgTW9zdCBvZiB0aGUgaW1wbGVtZW50YXRpb24gZm9yIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNzk5OAorICAgICAgICBXaGVuIGEgcmVzb3VyY2UgaXMgY2Fj aGVkIGxvY2FsbHksIFdlYktpdCBzaG91bGQgZm9sbG93IFJGQyAyNjE2ICJTcGVjaWZpYyBlbmQt dG8tZW5kIHJldmFsaWRhdGlvbiIgaW5zdGVhZCBvZiAiVW5zcGVjaWZpZWQgZW5kLXRvLWVuZCBy ZXZhbGlkYXRpb24iCisKKyAgICAgICAgSW1wbGVtZW50IEhUVFAgMS4xICJTcGVjaWZpYyBlbmQt dG8tZW5kIHJldmFsaWRhdGlvbiIgZm9yIFdlYkNvcmUgbWVtb3J5IGNhY2hlLiBUaGlzIHBhdGNo IGRvZXMKKyAgICAgICAgbm90IHlldCBlbmFibGUgaXQgZm9yIHRoZSBiaWdnZXN0IHVzZSBjYXNl LCByZWxvYWRpbmcuIEhvd2V2ZXIgaXQgaXMgZ29vZCBmb3IgZ2VuZXJhbCBicm93c2luZyBhcwor ICAgICAgICB3ZWxsLiBEb2luZyB0aGlzIGluIFdlYkNvcmUgbGV2ZWwgYXMgb3Bwb3NlZCB0byBy ZWx5aW5nIG9uIGRpc2sgY2FjaGUgaGFzIGJpZyBiZW5lZml0IHRoYXQKKyAgICAgICAgd2UgYXZv aWQgcmUtZGVjb2RpbmcgcmVzb3VyY2VzLCBlc3BlY2lhbGx5IGltYWdlcy4gCisgICAgICAgIAor ICAgICAgICBUbyBiZSBleGFjdCB0aGUgZW5hYmxlZCBjYXNlIGlzIG5vdCBhY3R1YWxseSB0aGUg IlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBzaW5jZSBpdCBkb2VzIG5vdCBpbmNs dWRlCisgICAgICAgIENhY2hlQ29udHJvbDogbWF4LWFnZT0wIGhlYWRlci4gVGhhdCB3b3VsZCBi ZSBhZGRlZCBpbiByZWxvYWQgY2FzZS4KKyAgICAgICAgCisgICAgICAgIFRoZSBhcHByb2FjaCBm b3IgcmV2YWxpZGF0aW9uIGlzIHRvIGtpY2sgdGhlIG9yaWdpbmFsIHJlc291cmNlIG91dCBmcm9t IHRoZSBtZW1vcnkgY2FjaGUKKyAgICAgICAgYW5kIGNyZWF0ZSBhIG5ldyBDYWNoZWRSZXNvdXJj ZSB0aGF0IHJlcHJlc2VudHMgdGhlIHJldmFsaWRhdGlvbiByZXF1ZXN0LiBJbiBjYXNlCisgICAg ICAgIHdlIGdldCAzMDQgYmFjayBmb3IgdGhlIHJlcXVlc3Qgd2UgcHV0IHRoZSBvcmlnaW5hbCBy ZXNvdXJjZSBiYWNrIHRvIHRoZSBjYWNoZSwgdXBkYXRlIAorICAgICAgICBpdHMgZXhwaXJhdGlv biBkYXRlIGFuZCBzd2l0Y2ggdGhlIGNsaWVudHMgcmVnaXN0ZXJlZCB0byByZXZhbGlkYXRpb24g cmVzb3VyY2UgdG8gYmUKKyAgICAgICAgY2xpZW50cyBvZiB0aGUgb3JpZ2luYWwgcmVzb3VyY2Uu CisgICAgICAgIAorICAgICAgICBBbGwgaGVhcCBhbGxvY2F0ZWQgQ2FjaGVkSW1hZ2UgcG9pbnRl cnMgbm93IHVzZSBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRJbWFnZT4gKGFuZCBzbyBvbikg aW5zdGVhZC4KKyAgICAgICAgVGhpcyBhbGxvd3MgdXBkYXRpbmcgdGhlIGhhbmRsZXMgdG8gcG9p bnQgdG8gdGhlIG9yaWdpbmFsIHJlc291cmNlIHdoZW4gdGhlIHJldmFsaWRhdGlvbiBzdWNjZWVk cy4gSXQKKyAgICAgICAgYWxzbyBhY3RzIGFzIHJlZmNvdW50aW5nIHNtYXJ0IHBvaW50ZXIuCisK KyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICog Y3NzL0NTU0ZvbnRGYWNlU291cmNlLmg6CisgICAgICAgICogY3NzL0NTU0ltcG9ydFJ1bGUuaDoK KyAgICAgICAgKiBkb20vQ2xpcGJvYXJkLmg6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmQ6 OmRyYWdJbWFnZSk6CisgICAgICAgICogZG9tL1Byb2Nlc3NpbmdJbnN0cnVjdGlvbi5oOgorICAg ICAgICAqIGRvbS9TY3JpcHRFbGVtZW50Lmg6CisgICAgICAgICogZG9tL1hNTFRva2VuaXplci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxUb2tlbml6ZXI6OmlzV2FpdGluZ0ZvclNjcmlwdHMp OgorICAgICAgICAqIGRvbS9YTUxUb2tlbml6ZXIuaDoKKyAgICAgICAgKiBodG1sL0hUTUxJbWFn ZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW1hZ2VMb2FkZXI6OnNldEltYWdl KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbWFnZUxvYWRlcjo6dXBkYXRlRnJvbUVsZW1lbnQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTEltYWdlTG9hZGVyOjpub3RpZnlGaW5pc2hlZCk6Cisg ICAgICAgICogaHRtbC9IVE1MSW1hZ2VMb2FkZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJ bWFnZUxvYWRlcjo6aW1hZ2UpOgorICAgICAgICAqIGh0bWwvSFRNTExpbmtFbGVtZW50Lmg6Cisg ICAgICAgICogaHRtbC9IVE1MVG9rZW5pemVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxU b2tlbml6ZXI6OnJlc2V0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxUb2tlbml6ZXI6OnNjcmlw dEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRva2VuaXplcjo6bm90aWZ5RmluaXNo ZWQpOgorICAgICAgICAqIGh0bWwvSFRNTFRva2VuaXplci5oOgorICAgICAgICAqIGxvYWRlci9D YWNoZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZTo6cmV2YWxpZGF0ZVJlc291cmNlKToK KyAgICAgICAgKFdlYkNvcmU6OkNhY2hlOjpyZXZhbGlkYXRpb25TdWNjZWVkZWQpOgorICAgICAg ICAoV2ViQ29yZTo6Q2FjaGU6OnJldmFsaWRhdGlvbkZhaWxlZCk6CisgICAgICAgICogbG9hZGVy L0NhY2hlLmg6CisgICAgICAgICogbG9hZGVyL0NhY2hlZFJlc291cmNlLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpDYWNoZWRSZXNvdXJjZSk6CisgICAgICAgIChXZWJD b3JlOjpDYWNoZWRSZXNvdXJjZTo6fkNhY2hlZFJlc291cmNlKToKKyAgICAgICAgKFdlYkNvcmU6 OkNhY2hlZFJlc291cmNlOjppc0V4cGlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVz b3VyY2U6OnNldFJlc3BvbnNlKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpj aGVja0RlbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6c2V0UmVzb3Vy Y2VUb1JldmFsaWRhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OmNsZWFy UmVzb3VyY2VUb1JldmFsaWRhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6 OnN3aXRjaENsaWVudHNUb1JldmFsaWRhdGVkUmVzb3VyY2UpOgorICAgICAgICAoV2ViQ29yZTo6 Q2FjaGVkUmVzb3VyY2U6OmNhbkJlUmV2YWxpZGF0ZWQpOgorICAgICAgICAqIGxvYWRlci9DYWNo ZWRSZXNvdXJjZS5oOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OmNhbkRlbGV0 ZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6cmVnaXN0ZXJIYW5kbGUpOgor ICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OnVucmVnaXN0ZXJIYW5kbGUpOgorICAg ICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OnJlc291cmNlVG9SZXZhbGlkYXRlKToKKyAg ICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpzZXRFeHBpcmF0aW9uRGF0ZSk6CisgICAg ICAgICogbG9hZGVyL0RvY0xvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2NMb2FkZXI6 OmNoZWNrRm9yUmVsb2FkKToKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkxvYWRlcjo6SG9zdDo6c2VydmVQZW5kaW5nUmVxdWVzdHMpOgorICAgICAgICAo V2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpkaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdlYkNv cmU6OkxvYWRlcjo6SG9zdDo6ZGlkRmFpbCk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhv c3Q6OmRpZFJlY2VpdmVSZXNwb25zZSk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhvc3Q6 OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKiBsb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9h ZGVyLmg6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RXZlbnRIYW5kbGVyOjpzZWxlY3RDdXJzb3IpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJJbWFnZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbWFnZTo6c2V0Q2FjaGVkSW1h Z2UpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OmltYWdlQ2hhbmdlZCk6CisgICAg ICAgICogcmVuZGVyaW5nL1JlbmRlckltYWdlLmg6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJ bWFnZTo6Y2FjaGVkSW1hZ2UpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OmltYWdl UHRyKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuaDoKKyAgICAgICAg KFdlYkNvcmU6OlN0eWxlQ2FjaGVkSW1hZ2U6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U3R5 bGVDYWNoZWRJbWFnZTo6Y2FjaGVkSW1hZ2UpOgorICAgICAgICAqIHN2Zy9TVkdGRUltYWdlRWxl bWVudC5oOgorICAgICAgICAqIHN2Zy9ncmFwaGljcy9maWx0ZXJzL1NWR0ZFSW1hZ2UuaDoKKyAg ICAgICAgKiB4bWwvWFNMSW1wb3J0UnVsZS5oOgorCiAyMDA4LTA4LTE1ICBNYXJrIFJvd2UgIDxt cm93ZUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5k ZXg6IFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAz NTgwNikKKysrIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3Jr aW5nIGNvcHkpCkBAIC00MDUxLDYgKzQwNTEsNyBAQAogCQlFNDQ2MTQzQzBDRDY4OUNDMDBGQURB NzUgLyogSlNIVE1MU291cmNlRWxlbWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRTRCNDIzNzIwQ0JGQjZFMDAwQUYyRUNFIC8qIEpTSFRNTFNvdXJj ZUVsZW1lbnQuaCAqLzsgfTsKIAkJRTQ0NjE0NTEwQ0Q2OEEzNTAwRkFEQTc1IC8qIFJlbmRlclZp ZGVvLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU0 QjQxRTMzMENCRkI2MDkwMEFGMkVDRSAvKiBSZW5kZXJWaWRlby5jcHAgKi87IH07CiAJCUU0NDYx NDUyMENENjhBMzUwMEZBREE3NSAvKiBSZW5kZXJWaWRlby5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRTRCNDFFMzQwQ0JGQjYwOTAwQUYyRUNFIC8qIFJl bmRlclZpZGVvLmggKi87IH07CisJCUU0NzIwNTNCMEU1QTA1M0EwMDA2QkI0RCAvKiBDYWNoZWRS ZXNvdXJjZUhhbmRsZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRTQ3MjA1M0EwRTVBMDUzQTAwMDZCQjREIC8qIENhY2hlZFJlc291cmNlSGFuZGxlLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRTQ5NjI2 QzIwRDgwRDk0ODAwRTM0MDVDIC8qIFByZWxvYWRTY2FubmVyLmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU0RDRBQkUwMEQ3NTQyRjAwMEY5Njg2OSAv KiBQcmVsb2FkU2Nhbm5lci5jcHAgKi87IH07CiAJCUU0OTYyNkMzMEQ4MEQ5NDkwMEUzNDA1QyAv KiBQcmVsb2FkU2Nhbm5lci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gRTRENEFCRTEwRDc1NDJGMTAwRjk2ODY5IC8qIFByZWxvYWRTY2FubmVyLmggKi87 IH07CiAJCUU0QUZDRkE1MERBRjI5QTMwMEY1RjU1QyAvKiBVbml0QmV6aWVyLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEFGQ0ZBNDBEQUYyOUEzMDBG NUY1NUMgLyogVW5pdEJlemllci5oICovOyB9OwpAQCAtODQ1Miw2ICs4NDUzLDcgQEAKIAkJRTQ0 NjE0MTEwQ0Q2ODI2OTAwRkFEQTc1IC8qIEpTTWVkaWFFcnJvci5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBKU01lZGlhRXJyb3IuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRTQ0NjE0MTIwQ0Q2ODI2OTAwRkFEQTc1IC8qIEpTVGltZVJhbmdlcy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU1RpbWVSYW5nZXMuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQlFNDQ2MTQxMzBDRDY4MjY5MDBGQURBNzUgLyogSlNUaW1l UmFuZ2VzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTVGltZVJhbmdlcy5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlFNDcyMDUzQTBFNUEwNTNBMDAwNkJCNEQg LyogQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RTRBRkNGQTQwREFGMjlBMzAwRjVGNTVDIC8qIFVuaXRCZXppZXIuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gVW5pdEJlemllci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlFNEFGRDAwNTBEQUYzMzU0MDBGNUY1NUMgLyogU01JTFRpbWUuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU01JTFRpbWUuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlFNEFGRDAwNjBEQUYzMzU0MDBGNUY1NUMgLyogU01JTFRpbWUuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU01JTFRpbWUuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKQEAgLTEyNTkzLDYgKzEyNTk1LDcgQEAKIAkJCQlCQ0IxNkMwRDA5NzlDM0JE MDA0Njc3NDEgLyogQ2FjaGVkWEJMRG9jdW1lbnQuaCAqLywKIAkJCQlCQ0IxNkMwRTA5NzlDM0JE MDA0Njc3NDEgLyogQ2FjaGVkWFNMU3R5bGVTaGVldC5jcHAgKi8sCiAJCQkJQkNCMTZDMEYwOTc5 QzNCRDAwNDY3NzQxIC8qIENhY2hlZFhTTFN0eWxlU2hlZXQuaCAqLywKKwkJCQlFNDcyMDUzQTBF NUEwNTNBMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCAqLywKIAkJCQlGNTg3ODY0 OTAyREUzQTlBMDFFQTQxMjIgLyogQ2FjaGVQb2xpY3kuaCAqLywKIAkJCQlCQ0IxNkMxMDA5NzlD M0JEMDA0Njc3NDEgLyogRG9jTG9hZGVyLmNwcCAqLywKIAkJCQlCQ0IxNkMxMTA5NzlDM0JEMDA0 Njc3NDEgLyogRG9jTG9hZGVyLmggKi8sCkBAIC0xNTQwMiw2ICsxNTQwNSw3IEBACiAJCQkJMzFD MEZGNEUwRTRDRUZERDAwN0Q2RkU1IC8qIERPTVdlYktpdFRyYW5zaXRpb25FdmVudEludGVybmFs LmggaW4gSGVhZGVycyAqLywKIAkJCQkwOEE0ODQ3ODBFNTI3MkM1MDBDM0ZFNzYgLyogU2NyaXB0 RWxlbWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQThGQTZFNUQwRTRDRkRFRDAwRDVDRjQ5IC8q IFBhdHRlcm4uaCBpbiBIZWFkZXJzICovLAorCQkJCUU0NzIwNTNCMEU1QTA1M0EwMDA2QkI0RCAv KiBDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25s eUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkluZGV4OiBXZWJDb3JlL2Nz cy9DU1NGb250RmFjZVNvdXJjZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvY3NzL0NTU0ZvbnRG YWNlU291cmNlLmgJKHJldmlzaW9uIDM1ODA2KQorKysgV2ViQ29yZS9jc3MvQ1NTRm9udEZhY2VT b3VyY2UuaAkod29ya2luZyBjb3B5KQpAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQXRv bWljU3RyaW5nLmgiCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIKKyNpbmNsdWRl ICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAKICNp ZiBFTkFCTEUoU1ZHX0ZPTlRTKQpAQCAtNjcsNyArNjgsNyBAQCBwdWJsaWM6CiAKIHByaXZhdGU6 CiAgICAgQXRvbWljU3RyaW5nIG1fc3RyaW5nOyAvLyBVUkkgZm9yIHJlbW90ZSwgYnVpbHQtaW4g Zm9udCBuYW1lIGZvciBsb2NhbC4KLSAgICBDYWNoZWRGb250KiBtX2ZvbnQ7IC8vIEZvciByZW1v dGUgZm9udHMsIGEgcG9pbnRlciB0byBvdXIgY2FjaGVkIHJlc291cmNlLgorICAgIENhY2hlZFJl c291cmNlSGFuZGxlPENhY2hlZEZvbnQ+IG1fZm9udDsgLy8gRm9yIHJlbW90ZSBmb250cywgYSBw b2ludGVyIHRvIG91ciBjYWNoZWQgcmVzb3VyY2UuCiAgICAgQ1NTRm9udEZhY2UqIG1fZmFjZTsg Ly8gT3VyIG93bmluZyBmb250IGZhY2UuCiAgICAgSGFzaE1hcDx1bnNpZ25lZCwgU2ltcGxlRm9u dERhdGEqPiBtX2ZvbnREYXRhVGFibGU7IC8vIFRoZSBoYXNoIGtleSBpcyBjb21wb3NlZCBvZiBz aXplIHN5bnRoZXRpYyBzdHlsZXMuCiAKSW5kZXg6IFdlYkNvcmUvY3NzL0NTU0ltcG9ydFJ1bGUu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Nzcy9DU1NJbXBvcnRSdWxlLmgJKHJldmlzaW9uIDM1 ODA2KQorKysgV2ViQ29yZS9jc3MvQ1NTSW1wb3J0UnVsZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0y Miw2ICsyMiw3IEBACiAjaWZuZGVmIENTU0ltcG9ydFJ1bGVfaAogI2RlZmluZSBDU1NJbXBvcnRS dWxlX2gKIAorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ1NT UnVsZS5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCiAjaW5jbHVkZSAiTWVk aWFMaXN0LmgiCkBAIC02NSw3ICs2Niw3IEBAIHByaXZhdGU6CiAgICAgU3RyaW5nIG1fc3RySHJl ZjsKICAgICBSZWZQdHI8TWVkaWFMaXN0PiBtX2xzdE1lZGlhOwogICAgIFJlZlB0cjxDU1NTdHls ZVNoZWV0PiBtX3N0eWxlU2hlZXQ7Ci0gICAgQ2FjaGVkQ1NTU3R5bGVTaGVldCogbV9jYWNoZWRT aGVldDsKKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRDU1NTdHlsZVNoZWV0PiBtX2Nh Y2hlZFNoZWV0OwogICAgIGJvb2wgbV9sb2FkaW5nOwogfTsKIApJbmRleDogV2ViQ29yZS9kb20v Q2xpcGJvYXJkLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgJKHJldmlz aW9uIDM1ODA2KQorKysgV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgJKHdvcmtpbmcgY29weSkKQEAg LTI0LDYgKzI0LDcgQEAKICNpZm5kZWYgQ2xpcGJvYXJkX2gKICNkZWZpbmUgQ2xpcGJvYXJkX2gK IAorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ2xpcGJvYXJk QWNjZXNzUG9saWN5LmgiCiAjaW5jbHVkZSAiRHJhZ0FjdGlvbnMuaCIKICNpbmNsdWRlICJEcmFn SW1hZ2UuaCIKQEAgLTU0LDcgKzU1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2 aXJ0dWFsIEhhc2hTZXQ8U3RyaW5nPiB0eXBlcygpIGNvbnN0ID0gMDsKICAgICAKICAgICAgICAg SW50UG9pbnQgZHJhZ0xvY2F0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9kcmFnTG9jOyB9Ci0gICAg ICAgIENhY2hlZEltYWdlKiBkcmFnSW1hZ2UoKSBjb25zdCB7IHJldHVybiBtX2RyYWdJbWFnZTsg fQorICAgICAgICBDYWNoZWRJbWFnZSogZHJhZ0ltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9kcmFn SW1hZ2UuZ2V0KCk7IH0KICAgICAgICAgdmlydHVhbCB2b2lkIHNldERyYWdJbWFnZShDYWNoZWRJ bWFnZSosIGNvbnN0IEludFBvaW50JikgPSAwOwogICAgICAgICBOb2RlKiBkcmFnSW1hZ2VFbGVt ZW50KCkgeyByZXR1cm4gbV9kcmFnSW1hZ2VFbGVtZW50LmdldCgpOyB9CiAgICAgICAgIHZpcnR1 YWwgdm9pZCBzZXREcmFnSW1hZ2VFbGVtZW50KE5vZGUqLCBjb25zdCBJbnRQb2ludCYpID0gMDsK QEAgLTkwLDcgKzkxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHByb3RlY3RlZDoKICAg ICAgICAgYm9vbCBtX2ZvckRyYWdnaW5nOwogICAgICAgICBJbnRQb2ludCBtX2RyYWdMb2M7Ci0g ICAgICAgIENhY2hlZEltYWdlKiBtX2RyYWdJbWFnZTsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VI YW5kbGU8Q2FjaGVkSW1hZ2U+IG1fZHJhZ0ltYWdlOwogICAgICAgICBSZWZQdHI8Tm9kZT4gbV9k cmFnSW1hZ2VFbGVtZW50OwogICAgIH07CiAKSW5kZXg6IFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJ bnN0cnVjdGlvbi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJbnN0cnVj dGlvbi5oCShyZXZpc2lvbiAzNTgwNikKKysrIFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJbnN0cnVj dGlvbi5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2ICsyNSw3IEBACiAjZGVmaW5lIFByb2Nlc3Np bmdJbnN0cnVjdGlvbl9oCiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2lu Y2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ29udGFpbmVyTm9kZS5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC04NCw3ICs4NSw3IEBAIHByaXZhdGU6CiAgICAg U3RyaW5nIG1fbG9jYWxIcmVmOwogICAgIFN0cmluZyBtX3RpdGxlOwogICAgIFN0cmluZyBtX21l ZGlhOwotICAgIENhY2hlZFJlc291cmNlKiBtX2NhY2hlZFNoZWV0OworICAgIENhY2hlZFJlc291 cmNlSGFuZGxlPENhY2hlZFJlc291cmNlPiBtX2NhY2hlZFNoZWV0OwogICAgIFJlZlB0cjxTdHls ZVNoZWV0PiBtX3NoZWV0OwogICAgIGJvb2wgbV9sb2FkaW5nOwogICAgIGJvb2wgbV9hbHRlcm5h dGU7CkluZGV4OiBXZWJDb3JlL2RvbS9TY3JpcHRFbGVtZW50LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9kb20vU2NyaXB0RWxlbWVudC5oCShyZXZpc2lvbiAzNTgwNikKKysrIFdlYkNvcmUvZG9t L1NjcmlwdEVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMjIsNiArMjIsNyBAQAogI2RlZmlu ZSBTY3JpcHRFbGVtZW50X2gKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisj aW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog CkBAIC04MCw3ICs4MSw3IEBAIHByaXZhdGU6CiBwcml2YXRlOgogICAgIFNjcmlwdEVsZW1lbnQq IG1fc2NyaXB0RWxlbWVudDsKICAgICBFbGVtZW50KiBtX2VsZW1lbnQ7Ci0gICAgQ2FjaGVkU2Ny aXB0KiBtX2NhY2hlZFNjcmlwdDsKKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRTY3Jp cHQ+IG1fY2FjaGVkU2NyaXB0OwogICAgIGJvb2wgbV9jcmVhdGVkQnlQYXJzZXI7CiAgICAgYm9v bCBtX2V2YWx1YXRlZDsKIH07CkluZGV4OiBXZWJDb3JlL2RvbS9YTUxUb2tlbml6ZXIuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5jcHAJKHJldmlzaW9uIDM1ODA2 KQorKysgV2ViQ29yZS9kb20vWE1MVG9rZW5pemVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTU0 MCw3ICsxNTQwLDcgQEAgdm9pZCBYTUxUb2tlbml6ZXI6Om5vdGlmeUZpbmlzaGVkKENhY2hlZAog CiBib29sIFhNTFRva2VuaXplcjo6aXNXYWl0aW5nRm9yU2NyaXB0cygpIGNvbnN0CiB7Ci0gICAg cmV0dXJuIG1fcGVuZGluZ1NjcmlwdCAhPSAwOworICAgIHJldHVybiBtX3BlbmRpbmdTY3JpcHQ7 CiB9CiAKICNpZiBFTkFCTEUoWFNMVCkKSW5kZXg6IFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5oCShyZXZpc2lvbiAzNTgw NikKKysrIFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2 ICsyNSw3IEBACiAjZGVmaW5lIFhNTFRva2VuaXplcl9oCiAKICNpbmNsdWRlICJDYWNoZWRSZXNv dXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVk ZSAiU2VnbWVudGVkU3RyaW5nLmgiCiAjaW5jbHVkZSAiU3RyaW5nSGFzaC5oIgogI2luY2x1ZGUg IlRva2VuaXplci5oIgpAQCAtMTU0LDcgKzE1NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgaW50IG1fbGFzdEVycm9yQ29sdW1uOwogICAgICAgICBTdHJpbmcgbV9lcnJvck1lc3Nh Z2VzOwogCi0gICAgICAgIENhY2hlZFNjcmlwdCogbV9wZW5kaW5nU2NyaXB0OworICAgICAgICBD YWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRTY3JpcHQ+IG1fcGVuZGluZ1NjcmlwdDsKICAgICAg ICAgUmVmUHRyPEVsZW1lbnQ+IG1fc2NyaXB0RWxlbWVudDsKICAgICAgICAgaW50IG1fc2NyaXB0 U3RhcnRMaW5lOwogCkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmNwcAkocmV2aXNpb24gMzU4 MDYpCisrKyBXZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpA QCAtNTcsNyArNTcsNyBAQCBIVE1MSW1hZ2VMb2FkZXI6On5IVE1MSW1hZ2VMb2FkZXIoKQogCiB2 b2lkIEhUTUxJbWFnZUxvYWRlcjo6c2V0SW1hZ2UoQ2FjaGVkSW1hZ2UgKm5ld0ltYWdlKQogewot ICAgIENhY2hlZEltYWdlICpvbGRJbWFnZSA9IG1faW1hZ2U7CisgICAgQ2FjaGVkSW1hZ2UgKm9s ZEltYWdlID0gbV9pbWFnZS5nZXQoKTsKICAgICBpZiAobmV3SW1hZ2UgIT0gb2xkSW1hZ2UpIHsK ICAgICAgICAgc2V0TG9hZGluZ0ltYWdlKG5ld0ltYWdlKTsKICAgICAgICAgbV9maXJlZExvYWQg PSB0cnVlOwpAQCAtMTA3LDcgKzEwNyw3IEBAIHZvaWQgSFRNTEltYWdlTG9hZGVyOjp1cGRhdGVG cm9tRWxlbWVudCgKICAgICAgICAgICAgIG5ld0ltYWdlID0gZG9jLT5kb2NMb2FkZXIoKS0+cmVx dWVzdEltYWdlKHBhcnNlVVJMKGF0dHIpKTsKICAgICB9CiAgICAgCi0gICAgQ2FjaGVkSW1hZ2Ug Km9sZEltYWdlID0gbV9pbWFnZTsKKyAgICBDYWNoZWRJbWFnZSAqb2xkSW1hZ2UgPSBtX2ltYWdl LmdldCgpOwogICAgIGlmIChuZXdJbWFnZSAhPSBvbGRJbWFnZSkgewogI2lmZGVmIElOU1RSVU1F TlRfTEFZT1VUX1NDSEVEVUxJTkcKICAgICAgICAgaWYgKCFkb2MtPm93bmVyRWxlbWVudCgpICYm IG5ld0ltYWdlKQpAQCAtMTQ1LDcgKzE0NSw3IEBAIHZvaWQgSFRNTEltYWdlTG9hZGVyOjpub3Rp ZnlGaW5pc2hlZChDYWMKICNlbmRpZgogICAgIGlmIChSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0g ZWxlbS0+cmVuZGVyZXIoKSkKICAgICAgICAgaWYgKHJlbmRlcmVyLT5pc0ltYWdlKCkpCi0gICAg ICAgICAgICBzdGF0aWNfY2FzdDxSZW5kZXJJbWFnZSo+KHJlbmRlcmVyKS0+c2V0Q2FjaGVkSW1h Z2UobV9pbWFnZSk7CisgICAgICAgICAgICBzdGF0aWNfY2FzdDxSZW5kZXJJbWFnZSo+KHJlbmRl cmVyKS0+c2V0Q2FjaGVkSW1hZ2UobV9pbWFnZS5nZXQoKSk7CiAgICAgICAgICAgICAKICAgICBp ZiAoaW1hZ2UtPmVycm9yT2NjdXJyZWQoKSAmJiBlbGVtLT5oYXNUYWdOYW1lKG9iamVjdFRhZykp CiAgICAgICAgIHN0YXRpY19jYXN0PEhUTUxPYmplY3RFbGVtZW50Kj4oZWxlbSktPnJlbmRlckZh bGxiYWNrQ29udGVudCgpOwpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxJbWFnZUxvYWRlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VMb2FkZXIuaAkocmV2aXNpb24gMzU4 MDYpCisrKyBXZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmgJKHdvcmtpbmcgY29weSkKQEAg LTI2LDYgKzI2LDcgQEAKICNkZWZpbmUgSFRNTEltYWdlTG9hZGVyX2gKIAogI2luY2x1ZGUgIkNh Y2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC00Myw3ICs0NCw3IEBAIHB1YmxpYzoKICAgICBF bGVtZW50KiBlbGVtZW50KCkgY29uc3QgeyByZXR1cm4gbV9lbGVtZW50OyB9CiAgICAgYm9vbCBp bWFnZUNvbXBsZXRlKCkgY29uc3QgeyByZXR1cm4gbV9pbWFnZUNvbXBsZXRlOyB9CiAKLSAgICBD YWNoZWRJbWFnZSogaW1hZ2UoKSBjb25zdCB7IHJldHVybiBtX2ltYWdlOyB9CisgICAgQ2FjaGVk SW1hZ2UqIGltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9pbWFnZS5nZXQoKTsgfQogICAgIHZvaWQg c2V0SW1hZ2UoQ2FjaGVkSW1hZ2UqKTsKIAogICAgIHZvaWQgc2V0TG9hZE1hbnVhbGx5KGJvb2wg bG9hZE1hbnVhbGx5KSB7IG1fbG9hZE1hbnVhbGx5ID0gbG9hZE1hbnVhbGx5OyB9CkBAIC01OSw3 ICs2MCw3IEBAIHByb3RlY3RlZDoKIAogcHJpdmF0ZToKICAgICBFbGVtZW50KiBtX2VsZW1lbnQ7 Ci0gICAgQ2FjaGVkSW1hZ2UqIG1faW1hZ2U7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2Fj aGVkSW1hZ2U+IG1faW1hZ2U7CiAgICAgYm9vbCBtX2ZpcmVkTG9hZCA6IDE7CiAgICAgYm9vbCBt X2ltYWdlQ29tcGxldGUgOiAxOwogICAgIGJvb2wgbV9sb2FkTWFudWFsbHkgOiAxOwpJbmRleDog V2ViQ29yZS9odG1sL0hUTUxMaW5rRWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRt bC9IVE1MTGlua0VsZW1lbnQuaAkocmV2aXNpb24gMzU4MDYpCisrKyBXZWJDb3JlL2h0bWwvSFRN TExpbmtFbGVtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTIzLDYgKzIzLDcgQEAKICNpZm5kZWYg SFRNTExpbmtFbGVtZW50X2gKICNkZWZpbmUgSFRNTExpbmtFbGVtZW50X2gKIAorI2luY2x1ZGUg IkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ1NTU3R5bGVTaGVldC5oIgogI2lu Y2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCiAjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIK QEAgLTEwMCw3ICsxMDEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGZpbmlzaFBhcnNp bmdDaGlsZHJlbigpOwogCiBwcm90ZWN0ZWQ6Ci0gICAgQ2FjaGVkQ1NTU3R5bGVTaGVldCogbV9j YWNoZWRTaGVldDsKKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRDU1NTdHlsZVNoZWV0 PiBtX2NhY2hlZFNoZWV0OwogICAgIFJlZlB0cjxDU1NTdHlsZVNoZWV0PiBtX3NoZWV0OwogICAg IFN0cmluZyBtX3VybDsKICAgICBTdHJpbmcgbV90eXBlOwpJbmRleDogV2ViQ29yZS9odG1sL0hU TUxUb2tlbml6ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MVG9rZW5pemVy LmNwcAkocmV2aXNpb24gMzU4MDYpCisrKyBXZWJDb3JlL2h0bWwvSFRNTFRva2VuaXplci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTIxMCw5ICsyMTAsMTAgQEAgdm9pZCBIVE1MVG9rZW5pemVyOjpy ZXNldCgpCiAgICAgQVNTRVJUKG1fZXhlY3V0aW5nU2NyaXB0ID09IDApOwogCiAgICAgd2hpbGUg KCFwZW5kaW5nU2NyaXB0cy5pc0VtcHR5KCkpIHsKLSAgICAgIENhY2hlZFNjcmlwdCAqY3MgPSBw ZW5kaW5nU2NyaXB0cy5kZXF1ZXVlKCk7Ci0gICAgICBBU1NFUlQoY2FjaGUoKS0+ZGlzYWJsZWQo KSB8fCBjcy0+YWNjZXNzQ291bnQoKSA+IDApOwotICAgICAgY3MtPnJlbW92ZUNsaWVudCh0aGlz KTsKKyAgICAgICAgQ2FjaGVkU2NyaXB0ICpjcyA9IHBlbmRpbmdTY3JpcHRzLmZpcnN0KCkuZ2V0 KCk7CisgICAgICAgIHBlbmRpbmdTY3JpcHRzLnJlbW92ZUZpcnN0KCk7CisgICAgICAgIEFTU0VS VChjYWNoZSgpLT5kaXNhYmxlZCgpIHx8IGNzLT5hY2Nlc3NDb3VudCgpID4gMCk7CisgICAgICAg IGNzLT5yZW1vdmVDbGllbnQodGhpcyk7CiAgICAgfQogICAgIAogICAgIGZhc3RGcmVlKGJ1ZmZl cik7CkBAIC00MzAsNyArNDMxLDcgQEAgSFRNTFRva2VuaXplcjo6U3RhdGUgSFRNTFRva2VuaXpl cjo6c2NyaQogICAgICAgICAgICAgICAgIC8vIFRoZSBwYXJzZXIgbWlnaHQgaGF2ZSBiZWVuIHN0 b3BwZWQgYnkgZm9yIGV4YW1wbGUgYSB3aW5kb3cuY2xvc2UgY2FsbCBpbiBhbiBlYXJsaWVyIHNj cmlwdC4KICAgICAgICAgICAgICAgICAvLyBJZiBzbywgd2UgZG9uJ3Qgd2FudCB0byBsb2FkIHNj cmlwdHMuCiAgICAgICAgICAgICAgICAgaWYgKCFtX3BhcnNlclN0b3BwZWQgJiYgKGNzID0gbV9k b2MtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNjcmlwdFNyYywgc2NyaXB0U3JjQ2hhcnNl dCkpKQotICAgICAgICAgICAgICAgICAgICBwZW5kaW5nU2NyaXB0cy5lbnF1ZXVlKGNzKTsKKyAg ICAgICAgICAgICAgICAgICAgcGVuZGluZ1NjcmlwdHMuYXBwZW5kKGNzKTsKICAgICAgICAgICAg ICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgIHNjcmlwdE5vZGUgPSAwOwogICAgICAgICAg ICAgfSBlbHNlCkBAIC0xOTgwLDggKzE5ODEsOSBAQCB2b2lkIEhUTUxUb2tlbml6ZXI6Om5vdGlm eUZpbmlzaGVkKENhY2hlCiAgICAgICAgIHJldHVybjsKIAogICAgIGJvb2wgZmluaXNoZWQgPSBm YWxzZTsKLSAgICB3aGlsZSAoIWZpbmlzaGVkICYmIHBlbmRpbmdTY3JpcHRzLmhlYWQoKS0+aXNM b2FkZWQoKSkgewotICAgICAgICBDYWNoZWRTY3JpcHQqIGNzID0gcGVuZGluZ1NjcmlwdHMuZGVx dWV1ZSgpOworICAgIHdoaWxlICghZmluaXNoZWQgJiYgcGVuZGluZ1NjcmlwdHMuZmlyc3QoKS0+ aXNMb2FkZWQoKSkgeworICAgICAgICBDYWNoZWRTY3JpcHQqIGNzID0gcGVuZGluZ1NjcmlwdHMu Zmlyc3QoKS5nZXQoKTsKKyAgICAgICAgcGVuZGluZ1NjcmlwdHMucmVtb3ZlRmlyc3QoKTsKICAg ICAgICAgQVNTRVJUKGNhY2hlKCktPmRpc2FibGVkKCkgfHwgY3MtPmFjY2Vzc0NvdW50KCkgPiAw KTsKIAogICAgICAgICBTdHJpbmcgc2NyaXB0U291cmNlID0gY3MtPnNjcmlwdCgpOwpJbmRleDog V2ViQ29yZS9odG1sL0hUTUxUb2tlbml6ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwv SFRNTFRva2VuaXplci5oCShyZXZpc2lvbiAzNTgwNikKKysrIFdlYkNvcmUvaHRtbC9IVE1MVG9r ZW5pemVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTI0LDEyICsyNCwxMyBAQAogI2lmbmRlZiBIVE1M VG9rZW5pemVyX2gKICNkZWZpbmUgSFRNTFRva2VuaXplcl9oCiAKLSNpbmNsdWRlICJEZXByZWNh dGVkUHRyUXVldWUuaCIKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1 ZGUgIk5hbWVkTWFwcGVkQXR0ck1hcC5oIgogI2luY2x1ZGUgIlNlZ21lbnRlZFN0cmluZy5oIgog I2luY2x1ZGUgIlRpbWVyLmgiCiAjaW5jbHVkZSAiVG9rZW5pemVyLmgiCiAjaW5jbHVkZSAiQ2Fj aGVkUmVzb3VyY2VDbGllbnQuaCIKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgogCkBAIC0zNzMsNyArMzc0LDcg QEAgcHJpdmF0ZToKICAgICAvLyB0cnVlIGlmIHdlIGFyZSBleGVjdXRpbmcgYSBzY3JpcHQgd2hp bGUgcGFyc2luZyBhIGRvY3VtZW50LiBUaGlzIGNhdXNlcyB0aGUgcGFyc2luZyBvZgogICAgIC8v IHRoZSBvdXRwdXQgb2YgdGhlIHNjcmlwdCB0byBiZSBwb3N0cG9uZWQgdW50aWwgYWZ0ZXIgdGhl IHNjcmlwdCBoYXMgZmluaXNoZWQgZXhlY3V0aW5nCiAgICAgaW50IG1fZXhlY3V0aW5nU2NyaXB0 OwotICAgIERlcHJlY2F0ZWRQdHJRdWV1ZTxDYWNoZWRTY3JpcHQ+IHBlbmRpbmdTY3JpcHRzOwor ICAgIERlcXVlPENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZFNjcmlwdD4gPiBwZW5kaW5nU2Ny aXB0czsKICAgICBSZWZQdHI8Tm9kZT4gc2NyaXB0Tm9kZTsKIAogICAgIGJvb2wgbV9yZXF1ZXN0 aW5nU2NyaXB0OwpJbmRleDogV2ViQ29yZS9sb2FkZXIvQ2FjaGUuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvbG9hZGVyL0NhY2hlLmNwcAkocmV2aXNpb24gMzU4MDYpCisrKyBXZWJDb3JlL2xv YWRlci9DYWNoZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE4Nyw2ICsxODcsNTcgQEAgQ2FjaGVk Q1NTU3R5bGVTaGVldCogQ2FjaGU6OnJlcXVlc3RVc2VyQwogCiAgICAgcmV0dXJuIHVzZXJTaGVl dDsKIH0KKyAgICAKK3ZvaWQgQ2FjaGU6OnJldmFsaWRhdGVSZXNvdXJjZShDYWNoZWRSZXNvdXJj ZSogcmVzb3VyY2UsIERvY0xvYWRlciogZG9jTG9hZGVyKQoreworICAgIEFTU0VSVChyZXNvdXJj ZSk7CisgICAgQVNTRVJUKCFkaXNhYmxlZCgpKTsKKyAgICBpZiAocmVzb3VyY2UtPnJlc291cmNl VG9SZXZhbGlkYXRlKCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAoIXJlc291cmNlLT5jYW5C ZVJldmFsaWRhdGVkKCkpIHsKKyAgICAgICAgcmVtb3ZlKHJlc291cmNlKTsKKyAgICAgICAgcmV0 dXJuOworICAgIH0KKyAgICBTdHJpbmcgdXJsID0gcmVzb3VyY2UtPnVybCgpLDsKKyAgICBDYWNo ZWRSZXNvdXJjZSogbmV3UmVzb3VyY2UgPSBjcmVhdGVSZXNvdXJjZShyZXNvdXJjZS0+dHlwZSgp LCBLVVJMKHVybCksIHJlc291cmNlLT5lbmNvZGluZygpKTsKKyAgICBuZXdSZXNvdXJjZS0+c2V0 UmVzb3VyY2VUb1JldmFsaWRhdGUocmVzb3VyY2UpOworICAgIHJlbW92ZShyZXNvdXJjZSk7Cisg ICAgbV9yZXNvdXJjZXMuc2V0KHVybCwgbmV3UmVzb3VyY2UpOworICAgIG5ld1Jlc291cmNlLT5z ZXRJbkNhY2hlKHRydWUpOworICAgIHJlc291cmNlQWNjZXNzZWQobmV3UmVzb3VyY2UpOworICAg IG5ld1Jlc291cmNlLT5sb2FkKGRvY0xvYWRlcik7Cit9CisgICAgCit2b2lkIENhY2hlOjpyZXZh bGlkYXRpb25TdWNjZWVkZWQoQ2FjaGVkUmVzb3VyY2UqIHJldmFsaWRhdGluZ1Jlc291cmNlLCB0 aW1lX3QgbmV3RXhwaXJhdGlvbkRhdGUpCit7CisgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNl ID0gcmV2YWxpZGF0aW5nUmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlkYXRlKCk7CisgICAgQVNT RVJUKHJlc291cmNlKTsKKyAgICBBU1NFUlQoIXJlc291cmNlLT5pbkNhY2hlKCkpOworICAgIEFT U0VSVChyZXNvdXJjZS0+aXNMb2FkZWQoKSk7CisgICAgCisgICAgcmVtb3ZlKHJldmFsaWRhdGlu Z1Jlc291cmNlKTsKKworICAgIEFTU0VSVCghbV9yZXNvdXJjZXMuZ2V0KHJlc291cmNlLT51cmwo KSkpOworICAgIG1fcmVzb3VyY2VzLnNldChyZXNvdXJjZS0+dXJsKCksIHJlc291cmNlKTsKKyAg ICByZXNvdXJjZS0+c2V0SW5DYWNoZSh0cnVlKTsKKyAgICByZXNvdXJjZS0+c2V0RXhwaXJhdGlv bkRhdGUobmV3RXhwaXJhdGlvbkRhdGUpOworICAgIGluc2VydEluTFJVTGlzdChyZXNvdXJjZSk7 CisgICAgaW50IGRlbHRhID0gc3RhdGljX2Nhc3Q8aW50PihyZXNvdXJjZS0+c2l6ZSgpKTsKKyAg ICBpZiAocmVzb3VyY2UtPmRlY29kZWRTaXplKCkgJiYgcmVzb3VyY2UtPnJlZmVyZW5jZWQoKSkK KyAgICAgICAgaW5zZXJ0SW5MaXZlRGVjb2RlZFJlc291cmNlc0xpc3QocmVzb3VyY2UpOworICAg IGlmIChkZWx0YSkKKyAgICAgICAgYWRqdXN0U2l6ZShyZXNvdXJjZS0+cmVmZXJlbmNlZCgpLCBk ZWx0YSk7CisgICAgCisgICAgcmV2YWxpZGF0aW5nUmVzb3VyY2UtPnN3aXRjaENsaWVudHNUb1Jl dmFsaWRhdGVkUmVzb3VyY2UoKTsKKyAgICAvLyB0aGlzIGRlbGV0ZXMgdGhlIHJldmFsaWRhdGlu ZyByZXNvdXJjZQorICAgIHJldmFsaWRhdGluZ1Jlc291cmNlLT5jbGVhclJlc291cmNlVG9SZXZh bGlkYXRlKCk7Cit9CisKK3ZvaWQgQ2FjaGU6OnJldmFsaWRhdGlvbkZhaWxlZChDYWNoZWRSZXNv dXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2UpCit7CisgICAgQVNTRVJUKHJldmFsaWRhdGluZ1Jl c291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKTsKKyAgICByZXZhbGlkYXRpbmdSZXNvdXJj ZS0+Y2xlYXJSZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworfQogCiBDYWNoZWRSZXNvdXJjZSogQ2Fj aGU6OnJlc291cmNlRm9yVVJMKGNvbnN0IFN0cmluZyYgdXJsKQogewpJbmRleDogV2ViQ29yZS9s b2FkZXIvQ2FjaGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9DYWNoZS5oCShyZXZp c2lvbiAzNTgwNikKKysrIFdlYkNvcmUvbG9hZGVyL0NhY2hlLmgJKHdvcmtpbmcgY29weSkKQEAg LTMsNyArMyw3IEBACiAKICAgICBDb3B5cmlnaHQgKEMpIDE5OTggTGFycyBLbm9sbCAoa25vbGxA bXBpLWhkLm1wZy5kZSkKICAgICBDb3B5cmlnaHQgKEMpIDIwMDEgRGlyayBNdWVsbGVyIDxtdWVs bGVyQGtkZS5vcmc+Ci0gICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAgICBDb3B5cmlnaHQgKEMpIDIwMDQsIDIw MDUsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogCiAg ICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgogICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6CiAKICAgICBDYWNoZWRD U1NTdHlsZVNoZWV0KiByZXF1ZXN0VXNlckNTU1N0eWxlU2hlZXQoRG9jTG9hZGVyKiwgY29uc3Qg U3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgY2hhcnNldCk7CiAgICAgCisgICAgdm9pZCByZXZh bGlkYXRlUmVzb3VyY2UoQ2FjaGVkUmVzb3VyY2UqLCBEb2NMb2FkZXIqKTsKKyAgICB2b2lkIHJl dmFsaWRhdGlvblN1Y2NlZWRlZChDYWNoZWRSZXNvdXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2Us IHRpbWVfdCBuZXdFeHBpcmF0aW9uRGF0ZSk7CisgICAgdm9pZCByZXZhbGlkYXRpb25GYWlsZWQo Q2FjaGVkUmVzb3VyY2UqIHJldmFsaWRhdGluZ1Jlc291cmNlKTsKKyAgICAKICAgICAvLyBTZXRz IHRoZSBjYWNoZSdzIG1lbW9yeSBjYXBhY2l0aWVzLCBpbiBieXRlcy4gVGhlc2Ugd2lsbCBob2xk IG9ubHkgYXBwcm94aW1hdGVseSwgCiAgICAgLy8gc2luY2UgdGhlIGRlY29kZWQgY29zdCBvZiBy ZXNvdXJjZXMgbGlrZSBzY3JpcHRzIGFuZCBzdHlsZXNoZWV0cyBpcyBub3Qga25vd24uCiAgICAg Ly8gIC0gbWluRGVhZEJ5dGVzOiBUaGUgbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMgdGhhdCBkZWFk IHJlc291cmNlcyBzaG91bGQgY29uc3VtZSB3aGVuIHRoZSBjYWNoZSBpcyB1bmRlciBwcmVzc3Vy ZS4KSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0NhY2hlZFJlc291cmNlLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZS5jcHAJKHJldmlzaW9uIDM1ODA2KQorKysg V2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2 ICsyNSw3IEBACiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2UuaCIKIAogI2luY2x1ZGUgIkNhY2hl LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJEb2NMb2Fk ZXIuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCkBAIC00 NSw2ICs0NiwxMCBAQCBDYWNoZWRSZXNvdXJjZTo6Q2FjaGVkUmVzb3VyY2UoY29uc3QgU3RyCiAg ICAgLCBtX2luQ2FjaGUoZmFsc2UpCiAgICAgLCBtX2xvYWRpbmcoZmFsc2UpCiAgICAgLCBtX2Rv Y0xvYWRlcigwKQorICAgICwgbV9oYW5kbGVDb3VudCgwKQorICAgICwgbV9yZXNvdXJjZVRvUmV2 YWxpZGF0ZSgwKQorICAgICwgbV9pc0JlaW5nUmV2YWxpZGF0ZWQoZmFsc2UpCisgICAgLCBtX2V4 cGlyYXRpb25EYXRlKDApCiB7CiAgICAgbV90eXBlID0gdHlwZTsKICAgICBtX3N0YXR1cyA9IFBl bmRpbmc7CkBAIC03Niw3ICs4MSwxMiBAQCBDYWNoZWRSZXNvdXJjZTo6fkNhY2hlZFJlc291cmNl KCkKICNpZm5kZWYgTkRFQlVHCiAgICAgbV9kZWxldGVkID0gdHJ1ZTsKICNlbmRpZgorCisgICAg QVNTRVJUKGNhY2hlKCktPnJlc291cmNlRm9yVVJMKHVybCgpKSAhPSB0aGlzKTsKICAgICAKKyAg ICBpZiAobV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSkKKyAgICAgICAgbV9yZXNvdXJjZVRvUmV2YWxp ZGF0ZS0+bV9pc0JlaW5nUmV2YWxpZGF0ZWQgPSBmYWxzZTsgICAgCisgICAKICAgICBpZiAobV9k b2NMb2FkZXIpCiAgICAgICAgIG1fZG9jTG9hZGVyLT5yZW1vdmVDYWNoZWRSZXNvdXJjZSh0aGlz KTsKIH0KQEAgLTk1LDEyICsxMDUsMTggQEAgdm9pZCBDYWNoZWRSZXNvdXJjZTo6ZmluaXNoKCkK IAogYm9vbCBDYWNoZWRSZXNvdXJjZTo6aXNFeHBpcmVkKCkgY29uc3QKIHsKLSAgICBpZiAoIW1f cmVzcG9uc2UuZXhwaXJhdGlvbkRhdGUoKSkKKyAgICBpZiAoIW1fZXhwaXJhdGlvbkRhdGUpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKICAgICB0aW1lX3Qgbm93ID0gdGltZSgwKTsKLSAgICByZXR1 cm4gKGRpZmZ0aW1lKG5vdywgbV9yZXNwb25zZS5leHBpcmF0aW9uRGF0ZSgpKSA+PSAwKTsKKyAg ICByZXR1cm4gKGRpZmZ0aW1lKG5vdywgbV9leHBpcmF0aW9uRGF0ZSkgPj0gMCk7CiB9Ci0KKyAg Cit2b2lkIENhY2hlZFJlc291cmNlOjpzZXRSZXNwb25zZShjb25zdCBSZXNvdXJjZVJlc3BvbnNl JiByZXNwb25zZSkKK3sKKyAgICBtX3Jlc3BvbnNlID0gcmVzcG9uc2U7CisgICAgbV9leHBpcmF0 aW9uRGF0ZSA9IHJlc3BvbnNlLmV4cGlyYXRpb25EYXRlKCk7Cit9CisgICAgCiB2b2lkIENhY2hl ZFJlc291cmNlOjpzZXRSZXF1ZXN0KFJlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAgaWYgKHJlcXVl c3QgJiYgIW1fcmVxdWVzdCkKQEAgLTEzOSw2ICsxNTUsMTIgQEAgdm9pZCBDYWNoZWRSZXNvdXJj ZTo6cmVtb3ZlQ2xpZW50KENhY2hlZAogICAgIH0KIH0KIAordm9pZCBDYWNoZWRSZXNvdXJjZTo6 Y2hlY2tEZWxldGUoKQoreworICAgIGlmIChjYW5EZWxldGUoKSAmJiAhaW5DYWNoZSgpKQorICAg ICAgICBkZWxldGUgdGhpczsKK30KKyAgICAKIHZvaWQgQ2FjaGVkUmVzb3VyY2U6OnNldERlY29k ZWRTaXplKHVuc2lnbmVkIHNpemUpCiB7CiAgICAgaWYgKHNpemUgPT0gbV9kZWNvZGVkU2l6ZSkK QEAgLTIwOCw1ICsyMzAsNjYgQEAgdm9pZCBDYWNoZWRSZXNvdXJjZTo6ZGlkQWNjZXNzRGVjb2Rl ZERhdAogICAgICAgICBjYWNoZSgpLT5wcnVuZSgpOwogICAgIH0KIH0KKyAgICAKK3ZvaWQgQ2Fj aGVkUmVzb3VyY2U6OnNldFJlc291cmNlVG9SZXZhbGlkYXRlKENhY2hlZFJlc291cmNlKiByZXNv dXJjZSkgCit7IAorICAgIEFTU0VSVChyZXNvdXJjZSk7CisgICAgQVNTRVJUKCFtX3Jlc291cmNl VG9SZXZhbGlkYXRlKTsKKyAgICBBU1NFUlQocmVzb3VyY2UgIT0gdGhpcyk7CisgICAgQVNTRVJU KCFyZXNvdXJjZS0+bV9pc0JlaW5nUmV2YWxpZGF0ZWQpOworICAgIEFTU0VSVChtX2hhbmRsZXNU b1JldmFsaWRhdGUuaXNFbXB0eSgpKTsKKyAgICBBU1NFUlQocmVzb3VyY2UtPnR5cGUoKSA9PSB0 eXBlKCkpOworICAgIHJlc291cmNlLT5tX2lzQmVpbmdSZXZhbGlkYXRlZCA9IHRydWU7CisgICAg bV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJlc291cmNlOworfQorCit2b2lkIENhY2hlZFJlc291 cmNlOjpjbGVhclJlc291cmNlVG9SZXZhbGlkYXRlKCkgCit7IAorICAgIEFTU0VSVChtX3Jlc291 cmNlVG9SZXZhbGlkYXRlKTsKKyAgICBBU1NFUlQobV9yZXNvdXJjZVRvUmV2YWxpZGF0ZS0+bV9p c0JlaW5nUmV2YWxpZGF0ZWQpOworICAgIG1fcmVzb3VyY2VUb1JldmFsaWRhdGUtPm1faXNCZWlu Z1JldmFsaWRhdGVkID0gZmFsc2U7CisgICAgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZS0+Y2hlY2tE ZWxldGUoKTsKKyAgICBtX2hhbmRsZXNUb1JldmFsaWRhdGUuY2xlYXIoKTsKKyAgICBtX3Jlc291 cmNlVG9SZXZhbGlkYXRlID0gMDsKKyAgICBjaGVja0RlbGV0ZSgpOworfQorICAgIAordm9pZCBD YWNoZWRSZXNvdXJjZTo6c3dpdGNoQ2xpZW50c1RvUmV2YWxpZGF0ZWRSZXNvdXJjZSgpCit7Cisg ICAgQVNTRVJUKG1fcmVzb3VyY2VUb1JldmFsaWRhdGUpOworICAgIEFTU0VSVCghaW5DYWNoZSgp KTsKKworICAgIEhhc2hTZXQ8Q2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKj46Oml0ZXJhdG9yIGVu ZCA9IG1faGFuZGxlc1RvUmV2YWxpZGF0ZS5lbmQoKTsKKyAgICBmb3IgKEhhc2hTZXQ8Q2FjaGVk UmVzb3VyY2VIYW5kbGVCYXNlKj46Oml0ZXJhdG9yIGl0ID0gbV9oYW5kbGVzVG9SZXZhbGlkYXRl LmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkgeworICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRs ZUJhc2UqIGhhbmRsZSA9ICppdDsKKyAgICAgICAgaGFuZGxlLT5tX3Jlc291cmNlID0gbV9yZXNv dXJjZVRvUmV2YWxpZGF0ZTsKKyAgICAgICAgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVnaXN0 ZXJIYW5kbGUoaGFuZGxlKTsKKyAgICAgICAgLS1tX2hhbmRsZUNvdW50OworICAgIH0KKyAgICBB U1NFUlQoIW1faGFuZGxlQ291bnQpOworICAgIG1faGFuZGxlc1RvUmV2YWxpZGF0ZS5jbGVhcigp OworCisgICAgVmVjdG9yPENhY2hlZFJlc291cmNlQ2xpZW50Kj4gY2xpZW50c1RvTW92ZTsKKyAg ICBIYXNoQ291bnRlZFNldDxDYWNoZWRSZXNvdXJjZUNsaWVudCo+OjppdGVyYXRvciBlbmQyID0g bV9jbGllbnRzLmVuZCgpOworICAgIGZvciAoSGFzaENvdW50ZWRTZXQ8Q2FjaGVkUmVzb3VyY2VD bGllbnQqPjo6aXRlcmF0b3IgaXQgPSBtX2NsaWVudHMuYmVnaW4oKTsgaXQgIT0gZW5kMjsgKytp dCkgeworICAgICAgICBDYWNoZWRSZXNvdXJjZUNsaWVudCogY2xpZW50ID0gaXQtPmZpcnN0Owor ICAgICAgICB1bnNpZ25lZCBjb3VudCA9IGl0LT5zZWNvbmQ7CisgICAgICAgIHdoaWxlIChjb3Vu dCkgeworICAgICAgICAgICAgY2xpZW50c1RvTW92ZS5hcHBlbmQoY2xpZW50KTsKKyAgICAgICAg ICAgIC0tY291bnQ7CisgICAgICAgIH0KKyAgICB9CisgICAgLy8gRXF1aXZhbGVudCBvZiBkZXJl ZigpIGZvciBhbGwgY2xpZW50cworICAgIG1fY2xpZW50cy5jbGVhcigpOworICAgIAorICAgIHVu c2lnbmVkIG1vdmVDb3VudCA9IGNsaWVudHNUb01vdmUuc2l6ZSgpOworICAgIGZvciAodW5zaWdu ZWQgbiA9IDA7IG4gPCBtb3ZlQ291bnQ7ICsrbikKKyAgICAgICAgbV9yZXNvdXJjZVRvUmV2YWxp ZGF0ZS0+YWRkQ2xpZW50KGNsaWVudHNUb01vdmVbbl0pOworfQorICAgIAorYm9vbCBDYWNoZWRS ZXNvdXJjZTo6Y2FuQmVSZXZhbGlkYXRlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX2xvYWRp bmcgJiYgKCFtX3Jlc3BvbnNlLmh0dHBIZWFkZXJGaWVsZCgiTGFzdC1Nb2RpZmllZCIpLmlzRW1w dHkoKSB8fCAhbV9yZXNwb25zZS5odHRwSGVhZGVyRmllbGQoIkVUYWciKS5pc0VtcHR5KCkpOwor fQogCiB9CkluZGV4OiBXZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvbG9hZGVyL0NhY2hlZFJlc291cmNlLmgJKHJldmlzaW9uIDM1ODA2KQorKysg V2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2UuaAkod29ya2luZyBjb3B5KQpAQCAtMjcsNiAr MjcsNyBAQAogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJTaGFyZWRC dWZmZXIuaCIKICNpbmNsdWRlIDx3dGYvSGFzaENvdW50ZWRTZXQuaD4KKyNpbmNsdWRlIDx3dGYv SGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KICNpbmNsdWRlIDx0aW1lLmg+CiAK QEAgLTM0LDcgKzM1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBDYWNoZTsKIGNs YXNzIENhY2hlZFJlc291cmNlQ2xpZW50OwotY2xhc3MgQ2FjaGVIYW5kbGVCYXNlOworY2xhc3Mg Q2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlOwogY2xhc3MgRG9jTG9hZGVyOwogY2xhc3MgUmVxdWVz dDsKIApAQCAtODMsNiArODQsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZENsaWVu dChDYWNoZWRSZXNvdXJjZUNsaWVudCopOwogICAgIHZvaWQgcmVtb3ZlQ2xpZW50KENhY2hlZFJl c291cmNlQ2xpZW50Kik7CiAgICAgYm9vbCByZWZlcmVuY2VkKCkgY29uc3QgeyByZXR1cm4gIW1f Y2xpZW50cy5pc0VtcHR5KCk7IH0KKyAgICB2b2lkIGNoZWNrRGVsZXRlKCk7CiAKICAgICBlbnVt IFByZWxvYWRSZXN1bHQgewogICAgICAgICBQcmVsb2FkTm90UmVmZXJlbmNlZCwKQEAgLTEyOCwx MCArMTMwLDEwIEBAIHB1YmxpYzoKIAogICAgIFNoYXJlZEJ1ZmZlciogZGF0YSgpIGNvbnN0IHsg cmV0dXJuIG1fZGF0YS5nZXQoKTsgfQogCi0gICAgdm9pZCBzZXRSZXNwb25zZShjb25zdCBSZXNv dXJjZVJlc3BvbnNlJiByZXNwb25zZSkgeyBtX3Jlc3BvbnNlID0gcmVzcG9uc2U7IH0KKyAgICB2 b2lkIHNldFJlc3BvbnNlKGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlKTsKICAgICBj b25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSgpIGNvbnN0IHsgcmV0dXJuIG1fcmVzcG9u c2U7IH0KICAgICAKLSAgICBib29sIGNhbkRlbGV0ZSgpIGNvbnN0IHsgcmV0dXJuICFyZWZlcmVu Y2VkKCkgJiYgIW1fcmVxdWVzdCAmJiAhbV9wcmVsb2FkQ291bnQ7IH0KKyAgICBib29sIGNhbkRl bGV0ZSgpIGNvbnN0IHsgcmV0dXJuICFyZWZlcmVuY2VkKCkgJiYgIW1fcmVxdWVzdCAmJiAhbV9w cmVsb2FkQ291bnQgJiYgIW1faGFuZGxlQ291bnQgJiYgIW1fcmVzb3VyY2VUb1JldmFsaWRhdGUg JiYgIW1faXNCZWluZ1JldmFsaWRhdGVkOyB9CiAKICAgICBib29sIGlzRXhwaXJlZCgpIGNvbnN0 OwogCkBAIC0xNTMsNiArMTU1LDEyIEBAIHB1YmxpYzoKICAgICB2b2lkIGluY3JlYXNlUHJlbG9h ZENvdW50KCkgeyArK21fcHJlbG9hZENvdW50OyB9CiAgICAgdm9pZCBkZWNyZWFzZVByZWxvYWRD b3VudCgpIHsgQVNTRVJUKG1fcHJlbG9hZENvdW50KTsgLS1tX3ByZWxvYWRDb3VudDsgfQogICAg IAorICAgIHZvaWQgcmVnaXN0ZXJIYW5kbGUoQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKiBoKSB7 ICsrbV9oYW5kbGVDb3VudDsgaWYgKG1fcmVzb3VyY2VUb1JldmFsaWRhdGUpIG1faGFuZGxlc1Rv UmV2YWxpZGF0ZS5hZGQoaCk7IH0KKyAgICB2b2lkIHVucmVnaXN0ZXJIYW5kbGUoQ2FjaGVkUmVz b3VyY2VIYW5kbGVCYXNlKiBoKSB7IC0tbV9oYW5kbGVDb3VudDsgaWYgKG1fcmVzb3VyY2VUb1Jl dmFsaWRhdGUpIG1faGFuZGxlc1RvUmV2YWxpZGF0ZS5yZW1vdmUoaCk7IGNoZWNrRGVsZXRlKCk7 IH0KKyAgICAKKyAgICBib29sIGNhbkJlUmV2YWxpZGF0ZWQoKSBjb25zdDsKKyAgICBDYWNoZWRS ZXNvdXJjZSogcmVzb3VyY2VUb1JldmFsaWRhdGUoKSBjb25zdCB7IHJldHVybiBtX3Jlc291cmNl VG9SZXZhbGlkYXRlOyB9CisgICAgCiBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBzZXRFbmNvZGVkU2l6 ZSh1bnNpZ25lZCk7CiAgICAgdm9pZCBzZXREZWNvZGVkU2l6ZSh1bnNpZ25lZCk7CkBAIC0xNzMs NiArMTgxLDEyIEBAIHByb3RlY3RlZDoKICAgICBib29sIG1fZXJyb3JPY2N1cnJlZDsKIAogcHJp dmF0ZToKKyAgICAvLyBUaGVzZSBhcmUgY2FsbGVkIGJ5IHRoZSBmcmllbmRseSBDYWNoZSBvbmx5 CisgICAgdm9pZCBzZXRSZXNvdXJjZVRvUmV2YWxpZGF0ZShDYWNoZWRSZXNvdXJjZSogcmVzb3Vy Y2UpOworICAgIHZvaWQgc3dpdGNoQ2xpZW50c1RvUmV2YWxpZGF0ZWRSZXNvdXJjZSgpOworICAg IHZvaWQgY2xlYXJSZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworICAgIHZvaWQgc2V0RXhwaXJhdGlv bkRhdGUodGltZV90IGV4cGlyYXRpb25EYXRlKSB7IG1fZXhwaXJhdGlvbkRhdGUgPSBleHBpcmF0 aW9uRGF0ZTsgIH0KKwogICAgIHVuc2lnbmVkIG1fZW5jb2RlZFNpemU7CiAgICAgdW5zaWduZWQg bV9kZWNvZGVkU2l6ZTsKICAgICB1bnNpZ25lZCBtX2FjY2Vzc0NvdW50OwpAQCAtMjAyLDYgKzIx NiwxOCBAQCBwcml2YXRlOgogICAgIENhY2hlZFJlc291cmNlKiBtX3ByZXZJbkxpdmVSZXNvdXJj ZXNMaXN0OwogCiAgICAgRG9jTG9hZGVyKiBtX2RvY0xvYWRlcjsgLy8gb25seSBub24tMCBmb3Ig cmVzb3VyY2VzIHRoYXQgYXJlIG5vdCBpbiB0aGUgY2FjaGUKKyAgICAKKyAgICB1bnNpZ25lZCBt X2hhbmRsZUNvdW50OworICAgIC8vIElmIHRoaXMgZmllbGQgaXMgbm9uLW51bGwgd2UgYXJlIHVz aW5nIHRoZSByZXNvdXJjZSBhcyBhIHByb3h5IGZvciBjaGVja2luZyB3aGV0aGVyIGFuIGV4aXN0 aW5nIHJlc291cmNlIGlzIHN0aWxsIHVwIHRvIGRhdGUKKyAgICAvLyB1c2luZyBIVFRQIElmLU1v ZGlmaWVkLVNpbmNlL0lmLU5vbmUtTWF0Y2ggaGVhZGVycy4gSWYgdGhlIHJlc3BvbnNlIGlzIDMw NCBhbGwgY2xpZW50cyBvZiB0aGlzIHJlc291cmNlIGFyZSBtb3ZlZAorICAgIC8vIHRvIHRvIGJl IGNsaWVudHMgb2YgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSBhbmQgdGhlIHJlc291cmNlIGlzIGRl bGV0ZWQuIElmIG5vdCwgdGhlIGZpZWxkIGlzIHplcm9lZCBhbmQgdGhpcworICAgIC8vIHJlc291 cmNlcyBiZWNvbWVzIG5vcm1hbCByZXNvdXJjZSBsb2FkLgorICAgIENhY2hlZFJlc291cmNlKiBt X3Jlc291cmNlVG9SZXZhbGlkYXRlOworICAgIGJvb2wgbV9pc0JlaW5nUmV2YWxpZGF0ZWQ7Cisg ICAgLy8gVGhlc2UgaGFuZGxlcyB3aWxsIG5lZWQgdG8gYmUgdXBkYXRlZCB0byBwb2ludCB0byB0 aGUgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSBpbiBjYXNlIHdlIGdldCAzMDQgcmVzcG9uc2UuCisg ICAgSGFzaFNldDxDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UqPiBtX2hhbmRsZXNUb1JldmFsaWRh dGU7CisgICAgCisgICAgdGltZV90IG1fZXhwaXJhdGlvbkRhdGU7CiB9OwogCiB9CkluZGV4OiBX ZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZUhhbmRsZS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvbG9hZGVyL0NhY2hlZFJlc291cmNlSGFuZGxlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L2xvYWRlci9DYWNoZWRSZXNvdXJjZUhhbmRsZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDk3 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4IEFwcGxlIEluYy4gQWxsIFJpZ2h0cyBSZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEu IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICog ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisg KiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpZm5k ZWYgQ2FjaGVkUmVzb3VyY2VIYW5kbGVfaAorI2RlZmluZSBDYWNoZWRSZXNvdXJjZUhhbmRsZV9o CisKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZS5oIgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4K KyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworICAgIGNs YXNzIENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSB7CisgICAgcHVibGljOgorICAgICAgICB+Q2Fj aGVkUmVzb3VyY2VIYW5kbGVCYXNlKCkgeyBpZiAobV9yZXNvdXJjZSkgbV9yZXNvdXJjZS0+dW5y ZWdpc3RlckhhbmRsZSh0aGlzKTsgfQorICAgICAgICBDYWNoZWRSZXNvdXJjZSogZ2V0KCkgY29u c3QgeyByZXR1cm4gbV9yZXNvdXJjZTsgfQorICAgICAgICAKKyAgICAgICAgYm9vbCBvcGVyYXRv ciEoKSBjb25zdCB7IHJldHVybiAhZ2V0KCk7IH0KKyAgICAgICAgb3BlcmF0b3IgYm9vbCgpIGNv bnN0IHsgcmV0dXJuIGdldCgpOyB9CisKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIENhY2hlZFJl c291cmNlSGFuZGxlQmFzZSgpIDogbV9yZXNvdXJjZSgwKSB7fQorICAgICAgICBDYWNoZWRSZXNv dXJjZUhhbmRsZUJhc2UoQ2FjaGVkUmVzb3VyY2UqIHJlcykgeyBtX3Jlc291cmNlID0gcmVzOyBp ZiAobV9yZXNvdXJjZSkgbV9yZXNvdXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7IH0KKyAgICAg ICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxlQmFz ZSYgbykgOiBtX3Jlc291cmNlKG8ubV9yZXNvdXJjZSkgeyBpZiAobV9yZXNvdXJjZSkgbV9yZXNv dXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7IH0KKworICAgICAgICB2b2lkIHNldFJlc291cmNl KENhY2hlZFJlc291cmNlKiByZXMpIHsKKyAgICAgICAgICAgIGlmIChtX3Jlc291cmNlKQorICAg ICAgICAgICAgICAgIG1fcmVzb3VyY2UtPnVucmVnaXN0ZXJIYW5kbGUodGhpcyk7CisgICAgICAg ICAgICBtX3Jlc291cmNlID0gcmVzOworICAgICAgICAgICAgaWYgKG1fcmVzb3VyY2UpCisgICAg ICAgICAgICAgICAgbV9yZXNvdXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7CisgICAgICAgIH0K KyAgICAgICAgCisgICAgcHJpdmF0ZToKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNl JiBvcGVyYXRvcj0oY29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlJikgeyByZXR1cm4gKnRo aXM7IH0gCisgICAgICAgIAorICAgICAgICBmcmllbmQgY2xhc3MgQ2FjaGVkUmVzb3VyY2U7CisK KyAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIG1fcmVzb3VyY2U7CisgICAgfTsKKyAgICAgICAgCisg ICAgdGVtcGxhdGUgPGNsYXNzIFI+IGNsYXNzIENhY2hlZFJlc291cmNlSGFuZGxlIDogcHVibGlj IENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSB7CisgICAgcHVibGljOiAKKyAgICAgICAgQ2FjaGVk UmVzb3VyY2VIYW5kbGUoKSB7fQorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZShSKiByZXMp IDogQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKHJlcykge30KKyAgICAgICAgQ2FjaGVkUmVzb3Vy Y2VIYW5kbGUoY29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Uj4mIG8pIDogQ2FjaGVkUmVzb3Vy Y2VIYW5kbGVCYXNlKG8pIHt9CisKKyAgICAgICAgUiogZ2V0KCkgY29uc3QgeyByZXR1cm4gcmVp bnRlcnByZXRfY2FzdDxSKj4oQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlOjpnZXQoKSk7IH0KKyAg ICAgICAgUiogb3BlcmF0b3ItPigpIGNvbnN0IHsgcmV0dXJuIGdldCgpOyB9CisgICAgICAgICAg ICAgICAKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGUmIG9wZXJhdG9yPShSKiByZXMpIHsg c2V0UmVzb3VyY2UocmVzKTsgcmV0dXJuICp0aGlzOyB9IAorICAgICAgICBDYWNoZWRSZXNvdXJj ZUhhbmRsZSYgb3BlcmF0b3I9KGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxlJiBvKSB7IHNldFJl c291cmNlKG8uZ2V0KCkpOyByZXR1cm4gKnRoaXM7IH0KKyAgICAgICAgYm9vbCBvcGVyYXRvcj09 KGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSYgbykgY29uc3QgeyByZXR1cm4gZ2V0KCkg PT0gby5nZXQoKTsgfQorICAgICAgICBib29sIG9wZXJhdG9yIT0oY29uc3QgQ2FjaGVkUmVzb3Vy Y2VIYW5kbGVCYXNlJiBvKSBjb25zdCB7IHJldHVybiBnZXQoKSAhPSBvLmdldCgpOyB9CisgICAg fTsKKyAgICAKKyAgICB0ZW1wbGF0ZSA8Y2xhc3MgUiwgY2xhc3MgUlI+IGJvb2wgb3BlcmF0b3I9 PShjb25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZTxSPiYgaCwgY29uc3QgUlIqIHJlcykgCisgICAg eyAKKyAgICAgICAgcmV0dXJuIGguZ2V0KCkgPT0gcmVzOyAKKyAgICB9CisgICAgdGVtcGxhdGUg PGNsYXNzIFIsIGNsYXNzIFJSPiBib29sIG9wZXJhdG9yPT0oY29uc3QgUlIqIHJlcywgY29uc3Qg Q2FjaGVkUmVzb3VyY2VIYW5kbGU8Uj4mIGgpIAorICAgIHsgCisgICAgICAgIHJldHVybiBoLmdl dCgpID09IHJlczsgCisgICAgfQorICAgIHRlbXBsYXRlIDxjbGFzcyBSLCBjbGFzcyBSUj4gYm9v bCBvcGVyYXRvciE9KGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxlPFI+JiBoLCBjb25zdCBSUiog cmVzKSAKKyAgICB7IAorICAgICAgICByZXR1cm4gaC5nZXQoKSAhPSByZXM7IAorICAgIH0KKyAg ICB0ZW1wbGF0ZSA8Y2xhc3MgUiwgY2xhc3MgUlI+IGJvb2wgb3BlcmF0b3IhPShjb25zdCBSUiog cmVzLCBjb25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZTxSPiYgaCkgCisgICAgeyAKKyAgICAgICAg cmV0dXJuIGguZ2V0KCkgIT0gcmVzOyAKKyAgICB9Cit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29y ZS9sb2FkZXIvRG9jTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9Eb2NM b2FkZXIuY3BwCShyZXZpc2lvbiAzNTgwNikKKysrIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTg0LDE0ICs4NCwxNSBAQCB2b2lkIERvY0xvYWRlcjo6Y2hl Y2tGb3JSZWxvYWQoY29uc3QgS1VSCiAgICAgICAgaWYgKCFtX3JlbG9hZGVkVVJMcy5jb250YWlu cyhmdWxsVVJMLnN0cmluZygpKSkgewogICAgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGlu ZyA9IGNhY2hlKCktPnJlc291cmNlRm9yVVJMKGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAg IGlmIChleGlzdGluZyAmJiBleGlzdGluZy0+aXNFeHBpcmVkKCkgJiYgIWV4aXN0aW5nLT5pc1By ZWxvYWRlZCgpKSB7Ci0gICAgICAgICAgICAgY2FjaGUoKS0+cmVtb3ZlKGV4aXN0aW5nKTsKLSAg ICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5hZGQoZnVsbFVSTC5zdHJpbmcoKSk7CisgICAgICAg ICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGVSZXNvdXJjZShleGlzdGluZywgdGhpcyk7CisgICAg ICAgICAgICAgIG1fcmVsb2FkZWRVUkxzLmFkZChmdWxsVVJMLnN0cmluZygpKTsKICAgICAgICAg ICB9CiAgICAgICAgfQogICAgIH0gZWxzZSBpZiAoKG1fY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xp Y3lSZWxvYWQpIHx8IChtX2NhY2hlUG9saWN5ID09IENhY2hlUG9saWN5UmVmcmVzaCkpIHsKICAg ICAgICBpZiAoIW1fcmVsb2FkZWRVUkxzLmNvbnRhaW5zKGZ1bGxVUkwuc3RyaW5nKCkpKSB7CiAg ICAgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGluZyA9IGNhY2hlKCktPnJlc291cmNlRm9y VVJMKGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAgICBpZiAoZXhpc3RpbmcgJiYgIWV4aXN0 aW5nLT5pc1ByZWxvYWRlZCgpKSB7CisgICAgICAgICAgICAgICAvLyBGSVhNRTogVXNlIHJldmFs aWRhdGVSZXNvdXJjZSgpIHRvIGltcGxlbWVudCBIVFRQIDEuMSAiU3BlY2lmaWMgZW5kLXRvLWVu ZCByZXZhbGlkYXRpb24iIGZvciByZWd1bGFyIHJlbG9hZGluZwogICAgICAgICAgICAgICAgY2Fj aGUoKS0+cmVtb3ZlKGV4aXN0aW5nKTsKICAgICAgICAgICAgICAgIG1fcmVsb2FkZWRVUkxzLmFk ZChmdWxsVVJMLnN0cmluZygpKTsKICAgICAgICAgICAgfQpJbmRleDogV2ViQ29yZS9sb2FkZXIv bG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCShyZXZp c2lvbiAzNTgwNikKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTIxOCwxMSArMjE4LDEyIEBAIHZvaWQgTG9hZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1 ZXN0cygKICAgICB3aGlsZSAoIXJlcXVlc3RzUGVuZGluZy5pc0VtcHR5KCkpIHsgICAgICAgIAog ICAgICAgICBSZXF1ZXN0KiByZXF1ZXN0ID0gcmVxdWVzdHNQZW5kaW5nLmZpcnN0KCk7CiAgICAg ICAgIERvY0xvYWRlciogZG9jTG9hZGVyID0gcmVxdWVzdC0+ZG9jTG9hZGVyKCk7CisgICAgICAg IENhY2hlZFJlc291cmNlKiByZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJlcXVlc3QtPmNhY2hlZFJl c291cmNlKCktPnJlc291cmNlVG9SZXZhbGlkYXRlKCk7CiAgICAgICAgIC8vIElmIHRoZSBkb2N1 bWVudCBpcyBmdWxseSBwYXJzZWQgYW5kIHRoZXJlIGFyZSBubyBwZW5kaW5nIHN0eWxlc2hlZXRz IHRoZXJlIHdvbid0IGJlIGFueSBtb3JlIAogICAgICAgICAvLyByZXNvdXJjZXMgdGhhdCB3ZSB3 b3VsZCB3YW50IHRvIHB1c2ggdG8gdGhlIGZyb250IG9mIHRoZSBxdWV1ZS4gSnVzdCBoYW5kIG9m ZiB0aGUgcmVtYWluaW5nIHJlc291cmNlcwogICAgICAgICAvLyB0byB0aGUgbmV0d29ya2luZyBs YXllci4KICAgICAgICAgYm9vbCBwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duID0gIWRvY0xvYWRl ci0+ZG9jKCktPnBhcnNpbmcoKSAmJiBkb2NMb2FkZXItPmRvYygpLT5oYXZlU3R5bGVzaGVldHNM b2FkZWQoKTsKLSAgICAgICAgaWYgKCFwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duICYmIG1fcmVx dWVzdHNMb2FkaW5nLnNpemUoKSA+PSBtX21heFJlcXVlc3RzSW5GbGlnaHQpIHsKKyAgICAgICAg aWYgKCFwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duICYmICFyZXNvdXJjZVRvUmV2YWxpZGF0ZSAm JiBtX3JlcXVlc3RzTG9hZGluZy5zaXplKCkgPj0gbV9tYXhSZXF1ZXN0c0luRmxpZ2h0KSB7CiAg ICAgICAgICAgICBzZXJ2ZUxvd2VyUHJpb3JpdHkgPSBmYWxzZTsKICAgICAgICAgICAgIHJldHVy bjsKICAgICAgICAgfQpAQCAtMjM3LDYgKzIzOCwyMSBAQCB2b2lkIExvYWRlcjo6SG9zdDo6c2Vy dmVQZW5kaW5nUmVxdWVzdHMoCiAgICAgICAgIGlmICgocmVmZXJyZXIucHJvdG9jb2xJcygiaHR0 cCIpIHx8IHJlZmVycmVyLnByb3RvY29sSXMoImh0dHBzIikpICYmIHJlZmVycmVyLnBhdGgoKS5p c0VtcHR5KCkpCiAgICAgICAgICAgICByZWZlcnJlci5zZXRQYXRoKCIvIik7CiAgICAgICAgIHJl c291cmNlUmVxdWVzdC5zZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIuc3RyaW5nKCkpOworICAgICAg ICAKKyAgICAgICAgaWYgKHJlc291cmNlVG9SZXZhbGlkYXRlKSB7CisgICAgICAgICAgICBBU1NF UlQocmVzb3VyY2VUb1JldmFsaWRhdGUtPmNhbkJlUmV2YWxpZGF0ZWQoKSk7CisgICAgICAgICAg ICBBU1NFUlQocmVzb3VyY2VUb1JldmFsaWRhdGUtPmlzTG9hZGVkKCkpOworICAgICAgICAgICAg U3RyaW5nIGxhc3RNb2RpZmllZCA9IHJlc291cmNlVG9SZXZhbGlkYXRlLT5yZXNwb25zZSgpLmh0 dHBIZWFkZXJGaWVsZCgiTGFzdC1Nb2RpZmllZCIpOworICAgICAgICAgICAgU3RyaW5nIGVUYWcg PSByZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVzcG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkVUYWci KTsKKyAgICAgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlzRW1wdHkoKSB8fCAhZVRhZy5pc0Vt cHR5KCkpIHsKKyAgICAgICAgICAgICAgICBpZiAoZG9jTG9hZGVyLT5jYWNoZVBvbGljeSgpID09 IENhY2hlUG9saWN5UmVsb2FkIHx8IGRvY0xvYWRlci0+Y2FjaGVQb2xpY3koKSA9PSBDYWNoZVBv bGljeVJlZnJlc2gpCisgICAgICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQ SGVhZGVyRmllbGQoIkNhY2hlLUNvbnRyb2wiLCAibWF4LWFnZT0wIik7CisgICAgICAgICAgICAg ICAgaWYgKCFsYXN0TW9kaWZpZWQuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgICAgICByZXNv dXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJJZi1Nb2RpZmllZC1TaW5jZSIsIGxhc3RN b2RpZmllZCk7CisgICAgICAgICAgICAgICAgaWYgKCFlVGFnLmlzRW1wdHkoKSkKKyAgICAgICAg ICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiSWYtTm9uZS1N YXRjaCIsIGVUYWcpOworICAgICAgICAgICAgfQorICAgICAgICB9CiAKICAgICAgICAgUmVmUHRy PFN1YnJlc291cmNlTG9hZGVyPiBsb2FkZXIgPSBTdWJyZXNvdXJjZUxvYWRlcjo6Y3JlYXRlKGRv Y0xvYWRlci0+ZG9jKCktPmZyYW1lKCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzLCByZXNvdXJjZVJlcXVl c3QsIHJlcXVlc3QtPnNob3VsZFNraXBDYW5Mb2FkQ2hlY2soKSwgcmVxdWVzdC0+c2VuZFJlc291 cmNlTG9hZENhbGxiYWNrcygpKTsKQEAgLTI2OSw2ICsyODUsNyBAQCB2b2lkIExvYWRlcjo6SG9z dDo6ZGlkRmluaXNoTG9hZGluZyhTdWJyCiAgICAgICAgIGRvY0xvYWRlci0+ZGVjcmVtZW50UmVx dWVzdENvdW50KCk7CiAKICAgICBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UgPSByZXF1ZXN0LT5j YWNoZWRSZXNvdXJjZSgpOworICAgIEFTU0VSVCghcmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlk YXRlKCkpOwogCiAgICAgLy8gSWYgd2UgZ290IGEgNHh4IHJlc3BvbnNlLCB3ZSdyZSBwcmV0ZW5k aW5nIHRvIGhhdmUgcmVjZWl2ZWQgYSBuZXR3b3JrCiAgICAgLy8gZXJyb3IsIHNvIHdlIGNhbid0 IHNlbmQgdGhlIHN1Y2Nlc3NmdWwgZGF0YSgpIGFuZCBmaW5pc2goKSBjYWxsYmFja3MuCkBAIC0z MTEsNiArMzI4LDkgQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZEZhaWwoU3VicmVzb3VyY2VMbwog ICAgICAgICBkb2NMb2FkZXItPmRlY3JlbWVudFJlcXVlc3RDb3VudCgpOwogCiAgICAgQ2FjaGVk UmVzb3VyY2UqIHJlc291cmNlID0gcmVxdWVzdC0+Y2FjaGVkUmVzb3VyY2UoKTsKKyAgICAKKyAg ICBpZiAocmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlkYXRlKCkpCisgICAgICAgIGNhY2hlKCkt PnJldmFsaWRhdGlvbkZhaWxlZChyZXNvdXJjZSk7CiAKICAgICBpZiAoIWNhbmNlbGxlZCkgewog ICAgICAgICBkb2NMb2FkZXItPnNldExvYWRJblByb2dyZXNzKHRydWUpOwpAQCAtMzQwLDcgKzM2 MCwyNyBAQCB2b2lkIExvYWRlcjo6SG9zdDo6ZGlkUmVjZWl2ZVJlc3BvbnNlKFN1CiAgICAgLy8g QVNTRVJUKHJlcXVlc3QpOwogICAgIGlmICghcmVxdWVzdCkKICAgICAgICAgcmV0dXJuOwotICAg IHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnNldFJlc3BvbnNlKHJlc3BvbnNlKTsKKyAgICAK KyAgICBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgp OworICAgIAorICAgIGlmIChyZXNvdXJjZS0+cmVzb3VyY2VUb1JldmFsaWRhdGUoKSkgeworICAg ICAgICBpZiAocmVzcG9uc2UuaHR0cFN0YXR1c0NvZGUoKSA9PSAzMDQpIHsKKyAgICAgICAgICAg IC8vIDMwNCBOb3QgbW9kaWZpZWQgLyBVc2UgbG9jYWwgY29weQorICAgICAgICAgICAgbV9yZXF1 ZXN0c0xvYWRpbmcucmVtb3ZlKGxvYWRlcik7CisgICAgICAgICAgICByZXF1ZXN0LT5kb2NMb2Fk ZXIoKS0+ZGVjcmVtZW50UmVxdWVzdENvdW50KCk7CisKKyAgICAgICAgICAgIC8vIEV4aXN0aW5n IHJlc291cmNlIGlzIG9rLCBqdXN0IHVzZSBpdCB1cGRhdGluZyBleHBpcmF0aW9uIHRpbWUuCisg ICAgICAgICAgICBjYWNoZSgpLT5yZXZhbGlkYXRpb25TdWNjZWVkZWQocmVzb3VyY2UsIHJlc3Bv bnNlLmV4cGlyYXRpb25EYXRlKCkpOworICAgICAgICAgICAgZGVsZXRlIHJlcXVlc3Q7CisKKyAg ICAgICAgICAgIHNlcnZlUGVuZGluZ1JlcXVlc3RzKCk7CisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIH0gCisgICAgICAgIC8vIERpZCBub3QgZ2V0IDMwNCByZXNwb25zZSwgY29udGludWUg YXMgYSByZWd1bGFyIHJlc291cmNlIGxvYWQuCisgICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGlv bkZhaWxlZChyZXNvdXJjZSk7CisgICAgfQorICAgIAorICAgIHJlc291cmNlLT5zZXRSZXNwb25z ZShyZXNwb25zZSk7CiAgICAgCiAgICAgU3RyaW5nIGVuY29kaW5nID0gcmVzcG9uc2UudGV4dEVu Y29kaW5nTmFtZSgpOwogICAgIGlmICghZW5jb2RpbmcuaXNOdWxsKCkpCkBAIC0zNzEsNiArNDEx LDggQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OmRpZFJlY2VpdmVEYXRhKFN1YnJlcwogICAgICAgICBy ZXR1cm47CiAKICAgICBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRS ZXNvdXJjZSgpOyAgICAKKyAgICBBU1NFUlQoIXJlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0 ZSgpKTsKKyAgICAKICAgICBpZiAocmVzb3VyY2UtPmVycm9yT2NjdXJyZWQoKSkKICAgICAgICAg cmV0dXJuOwogICAgIApJbmRleDogV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9h ZGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9h ZGVyLmgJKHJldmlzaW9uIDM1ODA2KQorKysgV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNo ZWV0TG9hZGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDYgKzMwLDcgQEAKICNkZWZpbmUgVXNl clN0eWxlU2hlZXRMb2FkZXJfaAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIK KyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogCiAjaW5jbHVkZSAiRG9jdW1lbnQu aCIKIApAQCAtNDgsNyArNDksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1 YWwgdm9pZCBzZXRDU1NTdHlsZVNoZWV0KGNvbnN0IFN0cmluZyYgVVJMLCBjb25zdCBTdHJpbmcm IGNoYXJzZXQsIGNvbnN0IENhY2hlZENTU1N0eWxlU2hlZXQqIHNoZWV0KTsKIAogICAgICAgICBS ZWZQdHI8RG9jdW1lbnQ+IG1fZG9jdW1lbnQ7Ci0gICAgICAgIENhY2hlZENTU1N0eWxlU2hlZXQq IG1fY2FjaGVkU2hlZXQ7CisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZENTU1N0 eWxlU2hlZXQ+IG1fY2FjaGVkU2hlZXQ7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDM1ODA2KQorKysgV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTgwOSw3ICs4MDksNyBAQCBD dXJzb3IgRXZlbnRIYW5kbGVyOjpzZWxlY3RDdXJzb3IoY29uc3QgCiAgICAgaWYgKHN0eWxlICYm IHN0eWxlLT5jdXJzb3JzKCkpIHsKICAgICAgICAgY29uc3QgQ3Vyc29yTGlzdCogY3Vyc29ycyA9 IHN0eWxlLT5jdXJzb3JzKCk7CiAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBjdXJz b3JzLT5zaXplKCk7ICsraSkgewotICAgICAgICAgICAgQ2FjaGVkSW1hZ2UqIGNpbWFnZSA9ICgq Y3Vyc29ycylbaV0uY3Vyc29ySW1hZ2U7CisgICAgICAgICAgICBDYWNoZWRJbWFnZSogY2ltYWdl ID0gKCpjdXJzb3JzKVtpXS5jdXJzb3JJbWFnZS5nZXQoKTsKICAgICAgICAgICAgIEludFBvaW50 IGhvdFNwb3QgPSAoKmN1cnNvcnMpW2ldLmhvdFNwb3Q7CiAgICAgICAgICAgICBpZiAoIWNpbWFn ZSkKICAgICAgICAgICAgICAgICBjb250aW51ZTsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckltYWdlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbWFn ZS5jcHAJKHJldmlzaW9uIDM1ODA2KQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW1hZ2Uu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTYsNyArMTk2LDcgQEAgdm9pZCBSZW5kZXJJbWFnZTo6 c2V0Q2FjaGVkSW1hZ2UoQ2FjaGVkSQogICAgIGlmIChtX2NhY2hlZEltYWdlKSB7CiAgICAgICAg IG1fY2FjaGVkSW1hZ2UtPmFkZENsaWVudCh0aGlzKTsKICAgICAgICAgaWYgKG1fY2FjaGVkSW1h Z2UtPmVycm9yT2NjdXJyZWQoKSkKLSAgICAgICAgICAgIGltYWdlQ2hhbmdlZChtX2NhY2hlZElt YWdlKTsKKyAgICAgICAgICAgIGltYWdlQ2hhbmdlZChtX2NhY2hlZEltYWdlLmdldCgpKTsKICAg ICB9CiB9CiAKQEAgLTI1OSw3ICsyNTksNyBAQCB2b2lkIFJlbmRlckltYWdlOjppbWFnZUNoYW5n ZWQoV3JhcHBlZEltCiAKICAgICAvLyBTZXQgaW1hZ2UgZGltZW5zaW9ucywgdGFraW5nIGludG8g YWNjb3VudCB0aGUgc2l6ZSBvZiB0aGUgYWx0IHRleHQuCiAgICAgaWYgKGVycm9yT2NjdXJyZWQo KSkKLSAgICAgICAgaW1hZ2VTaXplQ2hhbmdlZCA9IHNldEltYWdlU2l6ZUZvckFsdFRleHQobV9j YWNoZWRJbWFnZSk7CisgICAgICAgIGltYWdlU2l6ZUNoYW5nZWQgPSBzZXRJbWFnZVNpemVGb3JB bHRUZXh0KG1fY2FjaGVkSW1hZ2UuZ2V0KCkpOwogICAgIAogICAgIGJvb2wgc2hvdWxkUmVwYWlu dCA9IHRydWU7CiAKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckltYWdlLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW1hZ2UuaAkocmV2aXNpb24gMzU4MDYp CisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbWFnZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0y Niw2ICsyNiw3IEBACiAjZGVmaW5lIFJlbmRlckltYWdlX2gKIAogI2luY2x1ZGUgIkNhY2hlZElt YWdlLmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJSZW5k ZXJSZXBsYWNlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC01Myw3ICs1NCw3IEBAIHB1 YmxpYzoKICAgICB2b2lkIHVwZGF0ZUFsdFRleHQoKTsKIAogICAgIHZvaWQgc2V0Q2FjaGVkSW1h Z2UoQ2FjaGVkSW1hZ2UqKTsKLSAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UoKSBjb25zdCB7 IHJldHVybiBtX2NhY2hlZEltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlKCkg Y29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCBib29s IG5vZGVBdFBvaW50KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiwgSGl0VGVzdFJlc3VsdCYsIGludCB4 LCBpbnQgeSwgaW50IHR4LCBpbnQgdHksIEhpdFRlc3RBY3Rpb24pOwogCkBAIC03OCw3ICs3OSw3 IEBAIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGJvb2wgaW1hZ2VIYXNSZWxhdGl2ZVdpZHRoKCkg Y29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZSA/IG1fY2FjaGVkSW1hZ2UtPmltYWdlSGFzUmVs YXRpdmVXaWR0aCgpIDogZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgaW1hZ2VIYXNSZWxhdGl2 ZUhlaWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fY2FjaGVkSW1hZ2UgPyBtX2NhY2hlZEltYWdlLT5p bWFnZUhhc1JlbGF0aXZlSGVpZ2h0KCkgOiBmYWxzZTsgfQogICAgIHZpcnR1YWwgSW50U2l6ZSBp bWFnZVNpemUoZmxvYXQgbXVsdGlwbGllcikgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZSA/ IG1fY2FjaGVkSW1hZ2UtPmltYWdlU2l6ZShtdWx0aXBsaWVyKSA6IEludFNpemUoKTsgfQotICAg IHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGltYWdlUHRyKCkgY29uc3QgeyByZXR1cm4gbV9jYWNo ZWRJbWFnZTsgfQorICAgIHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGltYWdlUHRyKCkgY29uc3Qg eyByZXR1cm4gbV9jYWNoZWRJbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCB2b2lkIGludHJp bnNpY1NpemVDaGFuZ2VkKCkgeyBpbWFnZUNoYW5nZWQoaW1hZ2VQdHIoKSk7IH0KIApAQCAtOTEs NyArOTIsNyBAQCBwcml2YXRlOgogCiBwcm90ZWN0ZWQ6CiAgICAgLy8gVGhlIGltYWdlIHdlIGFy ZSByZW5kZXJpbmcuCi0gICAgQ2FjaGVkSW1hZ2UqIG1fY2FjaGVkSW1hZ2U7CisgICAgQ2FjaGVk UmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1fY2FjaGVkSW1hZ2U7CiAKICAgICAvLyBUZXh0 IHRvIGRpc3BsYXkgYXMgbG9uZyBhcyB0aGUgaW1hZ2UgaXNuJ3QgYXZhaWxhYmxlLgogICAgIFN0 cmluZyBtX2FsdFRleHQ7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHls ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmgJ KHJldmlzaW9uIDM1ODA2KQorKysgV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUu aAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsOCBAQAogICovCiAKICNpbmNsdWRlICJBZmZp bmVUcmFuc2Zvcm0uaCIKKyNpbmNsdWRlICJDYWNoZWRJbWFnZS5oIgorI2luY2x1ZGUgIkNhY2hl ZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ1NTSGVscGVyLmgiCiAjaW5jbHVkZSAiQ1NT SW1hZ2VHZW5lcmF0b3JWYWx1ZS5oIgogI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCkBA IC0xNjQsMTMgKzE2NiwxMyBAQCBjbGFzcyBTdHlsZUNhY2hlZEltYWdlIDogcHVibGljIFN0eWxl SW1hCiB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U3R5bGVDYWNoZWRJbWFnZT4g Y3JlYXRlKENhY2hlZEltYWdlKiBpbWFnZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFN0eWxlQ2Fj aGVkSW1hZ2UoaW1hZ2UpKTsgfQotICAgIHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGRhdGEoKSBj b25zdCB7IHJldHVybiBtX2ltYWdlOyB9CisgICAgdmlydHVhbCBXcmFwcGVkSW1hZ2VQdHIgZGF0 YSgpIGNvbnN0IHsgcmV0dXJuIG1faW1hZ2UuZ2V0KCk7IH0KIAogICAgIHZpcnR1YWwgYm9vbCBp c0NhY2hlZEltYWdlKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQogICAgIAogICAgIHZpcnR1YWwg UGFzc1JlZlB0cjxDU1NWYWx1ZT4gY3NzVmFsdWUoKTsKICAgICAKLSAgICBDYWNoZWRJbWFnZSog Y2FjaGVkSW1hZ2UoKSBjb25zdCB7IHJldHVybiBtX2ltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2Uq IGNhY2hlZEltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9pbWFnZS5nZXQoKTsgfQogCiAgICAgdmly dHVhbCBib29sIGNhblJlbmRlcihmbG9hdCBtdWx0aXBsaWVyKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgaXNMb2FkZWQoKSBjb25zdDsKQEAgLTE5MCw3ICsxOTIsNyBAQCBwcml2YXRlOgogICAg IHsKICAgICB9CiAgICAgCi0gICAgQ2FjaGVkSW1hZ2UqIG1faW1hZ2U7CisgICAgQ2FjaGVkUmVz b3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1faW1hZ2U7CiB9OwogCiBjbGFzcyBTdHlsZUdlbmVy YXRlZEltYWdlIDogcHVibGljIFN0eWxlSW1hZ2UKQEAgLTE1OTcsNyArMTU5OSw3IEBAIHN0cnVj dCBDdXJzb3JEYXRhIHsKICAgICBib29sIG9wZXJhdG9yIT0oY29uc3QgQ3Vyc29yRGF0YSYgbykg Y29uc3QgeyByZXR1cm4gISgqdGhpcyA9PSBvKTsgfQogCiAgICAgSW50UG9pbnQgaG90U3BvdDsg Ly8gZm9yIENTUzMgc3VwcG9ydAotICAgIENhY2hlZEltYWdlKiBjdXJzb3JJbWFnZTsgLy8gd2Vh ayBwb2ludGVyLCB0aGUgQ1NTVmFsdWVJbWFnZSB0YWtlcyBjYXJlIG9mIGRlbGV0aW5nIGN1cnNv ckltYWdlCisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IGN1cnNvckltYWdl OwogfTsKIAogY2xhc3MgQ3Vyc29yTGlzdCA6IHB1YmxpYyBSZWZDb3VudGVkPEN1cnNvckxpc3Q+ IHsKSW5kZXg6IFdlYkNvcmUvc3ZnL1NWR0ZFSW1hZ2VFbGVtZW50LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9zdmcvU1ZHRkVJbWFnZUVsZW1lbnQuaAkocmV2aXNpb24gMzU4MDYpCisrKyBXZWJD b3JlL3N2Zy9TVkdGRUltYWdlRWxlbWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNCw2ICsyNCw3 IEBACiAjZGVmaW5lIFNWR0ZFSW1hZ2VFbGVtZW50X2gKIAogI2lmIEVOQUJMRShTVkcpICYmIEVO QUJMRShTVkdfRklMVEVSUykKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2lu Y2x1ZGUgIlNWR0ZpbHRlclByaW1pdGl2ZVN0YW5kYXJkQXR0cmlidXRlcy5oIgogI2luY2x1ZGUg IlNWR1VSSVJlZmVyZW5jZS5oIgogI2luY2x1ZGUgIlNWR0xhbmdTcGFjZS5oIgpAQCAtNTUsNyAr NTYsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgQU5JTUFU RURfUFJPUEVSVFlfREVDTEFSQVRJT05TKFNWR0ZFSW1hZ2VFbGVtZW50LCBTVkdOYW1lczo6ZmVJ bWFnZVRhZ1N0cmluZywgU1ZHTmFtZXM6OnByZXNlcnZlQXNwZWN0UmF0aW9BdHRyU3RyaW5nLCBT VkdQcmVzZXJ2ZUFzcGVjdFJhdGlvLCBQcmVzZXJ2ZUFzcGVjdFJhdGlvLCBwcmVzZXJ2ZUFzcGVj dFJhdGlvKQogCi0gICAgICAgIENhY2hlZEltYWdlKiBtX2NhY2hlZEltYWdlOworICAgICAgICBD YWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRJbWFnZT4gbV9jYWNoZWRJbWFnZTsKICAgICAgICAg bXV0YWJsZSBSZWZQdHI8RkVJbWFnZT4gbV9maWx0ZXJFZmZlY3Q7CiAgICAgfTsKIApJbmRleDog V2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmlsdGVycy9TVkdGRUltYWdlLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmlsdGVycy9TVkdGRUltYWdlLmgJKHJldmlzaW9uIDM1ODA2 KQorKysgV2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmlsdGVycy9TVkdGRUltYWdlLmgJKHdvcmtpbmcg Y29weSkKQEAgLTI1LDYgKzI1LDcgQEAKICNpZiBFTkFCTEUoU1ZHKSAmJiBFTkFCTEUoU1ZHX0ZJ TFRFUlMpCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJj ZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAi RmlsdGVyRWZmZWN0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQ3LDcgKzQ4LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHByaXZhdGU6CiAgICAgICAgIEZFSW1hZ2UoQ2FjaGVk SW1hZ2UqKTsKIAotICAgICAgICBDYWNoZWRJbWFnZSogbV9jYWNoZWRJbWFnZTsKKyAgICAgICAg Q2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1fY2FjaGVkSW1hZ2U7CiAgICAgfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS94bWwvWFNMSW1wb3J0UnVs ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUveG1sL1hTTEltcG9ydFJ1bGUuaAkocmV2aXNpb24g MzU4MDYpCisrKyBXZWJDb3JlL3htbC9YU0xJbXBvcnRSdWxlLmgJKHdvcmtpbmcgY29weSkKQEAg LTI2LDYgKzI2LDcgQEAKICNpZiBFTkFCTEUoWFNMVCkKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291 cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRl ICJTdHlsZUJhc2UuaCIKICNpbmNsdWRlICJYU0xTdHlsZVNoZWV0LmgiCiAKQEAgLTYwLDcgKzYx LDcgQEAgcHJpdmF0ZToKICAgICAKICAgICBTdHJpbmcgbV9zdHJIcmVmOwogICAgIFJlZlB0cjxY U0xTdHlsZVNoZWV0PiBtX3N0eWxlU2hlZXQ7Ci0gICAgQ2FjaGVkWFNMU3R5bGVTaGVldCogbV9j YWNoZWRTaGVldDsKKyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRYU0xTdHlsZVNoZWV0 PiBtX2NhY2hlZFNoZWV0OwogICAgIGJvb2wgbV9sb2FkaW5nOwogfTsKIAo= 22987 2008-08-25 15:16:18 -0700 2010-06-10 20:06:09 -0700 more updates 304-13.patch text/plain 52574 koivisto SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTE0IEBACisyMDA4LTA4LTI1ICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBN b3N0IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBmb3IgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE3OTk4CisgICAgICAgIFdoZW4gYSByZXNvdXJjZSBpcyBjYWNoZWQgbG9j YWxseSwgV2ViS2l0IHNob3VsZCBmb2xsb3cgUkZDIDI2MTYgIlNwZWNpZmljIGVuZC10by1lbmQg cmV2YWxpZGF0aW9uIiBpbnN0ZWFkIG9mICJVbnNwZWNpZmllZCBlbmQtdG8tZW5kIHJldmFsaWRh dGlvbiIKKworICAgICAgICBJbXBsZW1lbnQgSFRUUCAxLjEgIlNwZWNpZmljIGVuZC10by1lbmQg cmV2YWxpZGF0aW9uIiBmb3IgV2ViQ29yZSBtZW1vcnkgY2FjaGUuIFRoaXMgcGF0Y2ggZG9lcwor ICAgICAgICBub3QgeWV0IGVuYWJsZSBpdCBmb3IgdGhlIGJpZ2dlc3QgdXNlIGNhc2UsIHJlbG9h ZGluZy4gSG93ZXZlciBpdCBpcyBnb29kIGZvciBnZW5lcmFsIGJyb3dzaW5nIGFzCisgICAgICAg IHdlbGwuIERvaW5nIHRoaXMgaW4gV2ViQ29yZSBsZXZlbCBhcyBvcHBvc2VkIHRvIHJlbHlpbmcg b24gZGlzayBjYWNoZSBoYXMgYmlnIGJlbmVmaXQgdGhhdAorICAgICAgICB3ZSBhdm9pZCByZS1k ZWNvZGluZyByZXNvdXJjZXMsIGVzcGVjaWFsbHkgaW1hZ2VzLiAKKyAgICAgICAgCisgICAgICAg IFRvIGJlIGV4YWN0IHRoZSBlbmFibGVkIGNhc2UgaXMgbm90IGFjdHVhbGx5IHRoZSAiU3BlY2lm aWMgZW5kLXRvLWVuZCByZXZhbGlkYXRpb24iIHNpbmNlIGl0IGRvZXMgbm90IGluY2x1ZGUKKyAg ICAgICAgQ2FjaGVDb250cm9sOiBtYXgtYWdlPTAgaGVhZGVyLiBUaGF0IHdvdWxkIGJlIGFkZGVk IGluIHJlbG9hZCBjYXNlLgorICAgICAgICAKKyAgICAgICAgVGhlIGFwcHJvYWNoIGZvciByZXZh bGlkYXRpb24gaXMgdG8ga2ljayB0aGUgb3JpZ2luYWwgcmVzb3VyY2Ugb3V0IGZyb20gdGhlIG1l bW9yeSBjYWNoZQorICAgICAgICBhbmQgY3JlYXRlIGEgbmV3IENhY2hlZFJlc291cmNlIHRoYXQg cmVwcmVzZW50cyB0aGUgcmV2YWxpZGF0aW9uIHJlcXVlc3QuIEluIGNhc2UKKyAgICAgICAgd2Ug Z2V0IDMwNCBiYWNrIGZvciB0aGUgcmVxdWVzdCB3ZSBwdXQgdGhlIG9yaWdpbmFsIHJlc291cmNl IGJhY2sgdG8gdGhlIGNhY2hlLCB1cGRhdGUgCisgICAgICAgIGl0cyBleHBpcmF0aW9uIGRhdGUg YW5kIHN3aXRjaCB0aGUgY2xpZW50cyByZWdpc3RlcmVkIHRvIHJldmFsaWRhdGlvbiByZXNvdXJj ZSB0byBiZQorICAgICAgICBjbGllbnRzIG9mIHRoZSBvcmlnaW5hbCByZXNvdXJjZS4KKyAgICAg ICAgCisgICAgICAgIEFsbCBoZWFwIGFsbG9jYXRlZCBDYWNoZWRJbWFnZSBwb2ludGVycyBub3cg dXNlIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZEltYWdlPiAoYW5kIHNvIG9uKSBpbnN0ZWFk LgorICAgICAgICBUaGlzIGFsbG93cyB1cGRhdGluZyB0aGUgaGFuZGxlcyB0byBwb2ludCB0byB0 aGUgb3JpZ2luYWwgcmVzb3VyY2Ugd2hlbiB0aGUgcmV2YWxpZGF0aW9uIHN1Y2NlZWRzLiBJdAor ICAgICAgICBhbHNvIGFjdHMgYXMgcmVmY291bnRpbmcgc21hcnQgcG9pbnRlci4KKworICAgICAg ICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBjc3MvQ1NT Rm9udEZhY2VTb3VyY2UuaDoKKyAgICAgICAgKiBjc3MvQ1NTSW1wb3J0UnVsZS5oOgorICAgICAg ICAqIGRvbS9DbGlwYm9hcmQuaDoKKyAgICAgICAgKFdlYkNvcmU6OkNsaXBib2FyZDo6ZHJhZ0lt YWdlKToKKyAgICAgICAgKiBkb20vUHJvY2Vzc2luZ0luc3RydWN0aW9uLmg6CisgICAgICAgICog ZG9tL1NjcmlwdEVsZW1lbnQuaDoKKyAgICAgICAgKiBkb20vWE1MVG9rZW5pemVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlhNTFRva2VuaXplcjo6aXNXYWl0aW5nRm9yU2NyaXB0cyk6CisgICAg ICAgICogZG9tL1hNTFRva2VuaXplci5oOgorICAgICAgICAqIGh0bWwvSFRNTEltYWdlTG9hZGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbWFnZUxvYWRlcjo6c2V0SW1hZ2UpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTEltYWdlTG9hZGVyOjp1cGRhdGVGcm9tRWxlbWVudCk6CisgICAg ICAgIChXZWJDb3JlOjpIVE1MSW1hZ2VMb2FkZXI6Om5vdGlmeUZpbmlzaGVkKToKKyAgICAgICAg KiBodG1sL0hUTUxJbWFnZUxvYWRlci5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEltYWdlTG9h ZGVyOjppbWFnZSk6CisgICAgICAgICogaHRtbC9IVE1MTGlua0VsZW1lbnQuaDoKKyAgICAgICAg KiBodG1sL0hUTUxUb2tlbml6ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRva2VuaXpl cjo6cmVzZXQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRva2VuaXplcjo6c2NyaXB0SGFuZGxl cik6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVG9rZW5pemVyOjpub3RpZnlGaW5pc2hlZCk6Cisg ICAgICAgICogaHRtbC9IVE1MVG9rZW5pemVyLmg6CisgICAgICAgICogbG9hZGVyL0NhY2hlLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlOjpyZXZhbGlkYXRlUmVzb3VyY2UpOgorICAgICAg ICAoV2ViQ29yZTo6Q2FjaGU6OnJldmFsaWRhdGlvblN1Y2NlZWRlZCk6CisgICAgICAgIChXZWJD b3JlOjpDYWNoZTo6cmV2YWxpZGF0aW9uRmFpbGVkKToKKyAgICAgICAgKiBsb2FkZXIvQ2FjaGUu aDoKKyAgICAgICAgKiBsb2FkZXIvQ2FjaGVkUmVzb3VyY2UuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6Q2FjaGVkUmVzb3VyY2U6OkNhY2hlZFJlc291cmNlKToKKyAgICAgICAgKFdlYkNvcmU6OkNh Y2hlZFJlc291cmNlOjp+Q2FjaGVkUmVzb3VyY2UpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVk UmVzb3VyY2U6OmlzRXhwaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6 c2V0UmVzcG9uc2UpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OmNoZWNrRGVs ZXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpzZXRSZXNvdXJjZVRvUmV2 YWxpZGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6Y2xlYXJSZXNvdXJj ZVRvUmV2YWxpZGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZTo6c3dpdGNo Q2xpZW50c1RvUmV2YWxpZGF0ZWRSZXNvdXJjZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRS ZXNvdXJjZTo6Y2FuVXNlQ2FjaGVWYWxpZGF0b3IpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVk UmVzb3VyY2U6Om11c3RSZXZhbGlkYXRlKToKKyAgICAgICAgKiBsb2FkZXIvQ2FjaGVkUmVzb3Vy Y2UuaDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjpjYW5EZWxldGUpOgorICAg ICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2U6OnJlZ2lzdGVySGFuZGxlKToKKyAgICAgICAg KFdlYkNvcmU6OkNhY2hlZFJlc291cmNlOjp1bnJlZ2lzdGVySGFuZGxlKToKKyAgICAgICAgKFdl YkNvcmU6OkNhY2hlZFJlc291cmNlOjppc0NhY2hlVmFsaWRhdG9yKToKKyAgICAgICAgKFdlYkNv cmU6OkNhY2hlZFJlc291cmNlOjpyZXNvdXJjZVRvUmV2YWxpZGF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpDYWNoZWRSZXNvdXJjZTo6c2V0RXhwaXJhdGlvbkRhdGUpOgorICAgICAgICAqIGxvYWRl ci9DYWNoZWRSZXNvdXJjZUhhbmRsZS5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6Q2Fj aGVkUmVzb3VyY2VIYW5kbGVCYXNlOjpzZXRSZXNvdXJjZSk6CisgICAgICAgICogbG9hZGVyL0Nh Y2hlZFJlc291cmNlSGFuZGxlLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVz b3VyY2VIYW5kbGVCYXNlOjp+Q2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKToKKyAgICAgICAgKFdl YkNvcmU6OkNhY2hlZFJlc291cmNlSGFuZGxlQmFzZTo6Z2V0KToKKyAgICAgICAgKFdlYkNvcmU6 OkNhY2hlZFJlc291cmNlSGFuZGxlQmFzZTo6b3BlcmF0b3IhKToKKyAgICAgICAgKFdlYkNvcmU6 OkNhY2hlZFJlc291cmNlSGFuZGxlQmFzZTo6b3BlcmF0b3IgYm9vbCk6CisgICAgICAgIChXZWJD b3JlOjpDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2U6OkNhY2hlZFJlc291cmNlSGFuZGxlQmFzZSk6 CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2U6Om9wZXJhdG9yPSk6 CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZUhhbmRsZTo6Q2FjaGVkUmVzb3VyY2VI YW5kbGUpOgorICAgICAgICAoV2ViQ29yZTo6Q2FjaGVkUmVzb3VyY2VIYW5kbGU6OmdldCk6Cisg ICAgICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZUhhbmRsZTo6b3BlcmF0b3ItPik6CisgICAg ICAgIChXZWJDb3JlOjpDYWNoZWRSZXNvdXJjZUhhbmRsZTo6b3BlcmF0b3I9KToKKyAgICAgICAg KFdlYkNvcmU6OkNhY2hlZFJlc291cmNlSGFuZGxlOjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdl YkNvcmU6OkNhY2hlZFJlc291cmNlSGFuZGxlOjpvcGVyYXRvciE9KToKKyAgICAgICAgKFdlYkNv cmU6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3IhPSk6CisgICAgICAg ICogbG9hZGVyL0RvY0xvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2NMb2FkZXI6OmNo ZWNrRm9yUmVsb2FkKToKKyAgICAgICAgKiBsb2FkZXIvbG9hZGVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkxvYWRlcjo6SG9zdDo6c2VydmVQZW5kaW5nUmVxdWVzdHMpOgorICAgICAgICAoV2Vi Q29yZTo6TG9hZGVyOjpIb3N0OjpkaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdlYkNvcmU6 OkxvYWRlcjo6SG9zdDo6ZGlkRmFpbCk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhvc3Q6 OmRpZFJlY2VpdmVSZXNwb25zZSk6CisgICAgICAgIChXZWJDb3JlOjpMb2FkZXI6Okhvc3Q6OmRp ZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKiBsb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9hZGVy Lmg6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RXZlbnRIYW5kbGVyOjpzZWxlY3RDdXJzb3IpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJJ bWFnZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbWFnZTo6c2V0Q2FjaGVkSW1hZ2Up OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OmltYWdlQ2hhbmdlZCk6CisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckltYWdlLmg6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbWFn ZTo6Y2FjaGVkSW1hZ2UpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW1hZ2U6OmltYWdlUHRy KToKKyAgICAgICAgKiByZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuaDoKKyAgICAgICAgKFdl YkNvcmU6OlN0eWxlQ2FjaGVkSW1hZ2U6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U3R5bGVD YWNoZWRJbWFnZTo6Y2FjaGVkSW1hZ2UpOgorICAgICAgICAqIHN2Zy9TVkdGRUltYWdlRWxlbWVu dC5oOgorICAgICAgICAqIHN2Zy9ncmFwaGljcy9maWx0ZXJzL1NWR0ZFSW1hZ2UuaDoKKyAgICAg ICAgKiB4bWwvWFNMSW1wb3J0UnVsZS5oOgorCiAyMDA4LTA4LTI1ICBBbnR0aSBLb2l2aXN0byAg PGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4gQmVybnN0ZWluLgpJ bmRleDogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9u IDM1OTIxKQorKysgV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdv cmtpbmcgY29weSkKQEAgLTQwNjEsNiArNDA2MSw4IEBACiAJCUU0NDYxNDNDMENENjg5Q0MwMEZB REE3NSAvKiBKU0hUTUxTb3VyY2VFbGVtZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBFNEI0MjM3MjBDQkZCNkUwMDBBRjJFQ0UgLyogSlNIVE1MU291 cmNlRWxlbWVudC5oICovOyB9OwogCQlFNDQ2MTQ1MTBDRDY4QTM1MDBGQURBNzUgLyogUmVuZGVy VmlkZW8uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g RTRCNDFFMzMwQ0JGQjYwOTAwQUYyRUNFIC8qIFJlbmRlclZpZGVvLmNwcCAqLzsgfTsKIAkJRTQ0 NjE0NTIwQ0Q2OEEzNTAwRkFEQTc1IC8qIFJlbmRlclZpZGVvLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEI0MUUzNDBDQkZCNjA5MDBBRjJFQ0UgLyog UmVuZGVyVmlkZW8uaCAqLzsgfTsKKwkJRTQ3MjA1M0IwRTVBMDUzQTAwMDZCQjREIC8qIENhY2hl ZFJlc291cmNlSGFuZGxlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBFNDcyMDUzQTBFNUEwNTNBMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3VyY2VIYW5kbGUu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlFNDcy MDhBNTBFNjMyRDFCMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3VyY2VIYW5kbGUuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRTQ3MjA4QTQwRTYzMkQxQjAw MDZCQjREIC8qIENhY2hlZFJlc291cmNlSGFuZGxlLmNwcCAqLzsgfTsKIAkJRTQ5NjI2QzIwRDgw RDk0ODAwRTM0MDVDIC8qIFByZWxvYWRTY2FubmVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU0RDRBQkUwMEQ3NTQyRjAwMEY5Njg2OSAvKiBQcmVs b2FkU2Nhbm5lci5jcHAgKi87IH07CiAJCUU0OTYyNkMzMEQ4MEQ5NDkwMEUzNDA1QyAvKiBQcmVs b2FkU2Nhbm5lci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRTRENEFCRTEwRDc1NDJGMTAwRjk2ODY5IC8qIFByZWxvYWRTY2FubmVyLmggKi87IH07CiAJ CUU0QUZDRkE1MERBRjI5QTMwMEY1RjU1QyAvKiBVbml0QmV6aWVyLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEFGQ0ZBNDBEQUYyOUEzMDBGNUY1NUMg LyogVW5pdEJlemllci5oICovOyB9OwpAQCAtODQ3Miw2ICs4NDc0LDggQEAKIAkJRTQ0NjE0MTEw Q0Q2ODI2OTAwRkFEQTc1IC8qIEpTTWVkaWFFcnJvci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBKU01lZGlhRXJyb3IuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RTQ0NjE0MTIwQ0Q2ODI2OTAwRkFEQTc1IC8qIEpTVGltZVJhbmdlcy5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU1RpbWVSYW5nZXMuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQlFNDQ2MTQxMzBDRDY4MjY5MDBGQURBNzUgLyogSlNUaW1lUmFuZ2Vz LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTVGltZVJhbmdlcy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQlFNDcyMDUzQTBFNUEwNTNBMDAwNkJCNEQgLyogQ2Fj aGVkUmVzb3VyY2VIYW5kbGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ2Fj aGVkUmVzb3VyY2VIYW5kbGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRTQ3MjA4 QTQwRTYzMkQxQjAwMDZCQjREIC8qIENhY2hlZFJlc291cmNlSGFuZGxlLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENhY2hlZFJlc291cmNlSGFuZGxlLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRTRBRkNGQTQwREFGMjlBMzAwRjVGNTVDIC8qIFVu aXRCZXppZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVW5pdEJlemllci5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFNEFGRDAwNTBEQUYzMzU0MDBGNUY1NUMg LyogU01JTFRpbWUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU01J TFRpbWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFNEFGRDAwNjBEQUYzMzU0 MDBGNUY1NUMgLyogU01JTFRpbWUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g U01JTFRpbWUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEyNjIzLDYgKzEyNjI3 LDcgQEAKIAkJCQlCQ0IxNkMwRDA5NzlDM0JEMDA0Njc3NDEgLyogQ2FjaGVkWEJMRG9jdW1lbnQu aCAqLywKIAkJCQlCQ0IxNkMwRTA5NzlDM0JEMDA0Njc3NDEgLyogQ2FjaGVkWFNMU3R5bGVTaGVl dC5jcHAgKi8sCiAJCQkJQkNCMTZDMEYwOTc5QzNCRDAwNDY3NzQxIC8qIENhY2hlZFhTTFN0eWxl U2hlZXQuaCAqLywKKwkJCQlFNDcyMDUzQTBFNUEwNTNBMDAwNkJCNEQgLyogQ2FjaGVkUmVzb3Vy Y2VIYW5kbGUuaCAqLywKIAkJCQlGNTg3ODY0OTAyREUzQTlBMDFFQTQxMjIgLyogQ2FjaGVQb2xp Y3kuaCAqLywKIAkJCQlCQ0IxNkMxMDA5NzlDM0JEMDA0Njc3NDEgLyogRG9jTG9hZGVyLmNwcCAq LywKIAkJCQlCQ0IxNkMxMTA5NzlDM0JEMDA0Njc3NDEgLyogRG9jTG9hZGVyLmggKi8sCkBAIC0x MjY2OCw2ICsxMjY3Myw3IEBACiAJCQkJMUE2OTM4MDAwQTExMTAwQTAwQzEyN0ZFIC8qIFRleHRE b2N1bWVudC5oICovLAogCQkJCUY1MjNEMjc4MDJERTQzRDcwMTg2MzVDQSAvKiBUZXh0UmVzb3Vy Y2VEZWNvZGVyLmNwcCAqLywKIAkJCQlGNTIzRDI3OTAyREU0M0Q3MDE4NjM1Q0EgLyogVGV4dFJl c291cmNlRGVjb2Rlci5oICovLAorCQkJCUU0NzIwOEE0MEU2MzJEMUIwMDA2QkI0RCAvKiBDYWNo ZWRSZXNvdXJjZUhhbmRsZS5jcHAgKi8sCiAJCQkpOwogCQkJcGF0aCA9IGxvYWRlcjsKIAkJCXNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBAIC0xNTQzNyw2ICsxNTQ0Myw3IEBACiAJCQkJMjlBQUM1 MUYwRTUzOTYzQjAwOEY5QjNCIC8qIEFjY2Vzc2liaWxpdHlUYWJsZUhlYWRlckNvbnRhaW5lci5o IGluIEhlYWRlcnMgKi8sCiAJCQkJMDhBNDg0NzgwRTUyNzJDNTAwQzNGRTc2IC8qIFNjcmlwdEVs ZW1lbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4RkE2RTVEMEU0Q0ZERUQwMEQ1Q0Y0OSAvKiBQ YXR0ZXJuLmggaW4gSGVhZGVycyAqLywKKwkJCQlFNDcyMDUzQjBFNUEwNTNBMDAwNkJCNEQgLyog Q2FjaGVkUmVzb3VyY2VIYW5kbGUuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMTcyMjgsNiArMTcyMzUs NyBAQAogCQkJCTA4QTQ4NDc3MEU1MjcyQzUwMEMzRkU3NiAvKiBTY3JpcHRFbGVtZW50LmNwcCBp biBTb3VyY2VzICovLAogCQkJCUE4RkE2RTVFMEU0Q0ZERUQwMEQ1Q0Y0OSAvKiBQYXR0ZXJuLmNw cCBpbiBTb3VyY2VzICovLAogCQkJCUE4MEEzOEZFMEU1MENDODIwMEEyNUVCQyAvKiBQYXR0ZXJu Q0cuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRTQ3MjA4QTUwRTYzMkQxQjAwMDZCQjREIC8qIENh Y2hlZFJlc291cmNlSGFuZGxlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogV2ViQ29yZS9jc3Mv Q1NTRm9udEZhY2VTb3VyY2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Nzcy9DU1NGb250RmFj ZVNvdXJjZS5oCShyZXZpc2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvY3NzL0NTU0ZvbnRGYWNlU291 cmNlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkF0b21p Y1N0cmluZy5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAi Q2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiAjaWYg RU5BQkxFKFNWR19GT05UUykKQEAgLTY3LDcgKzY4LDcgQEAgcHVibGljOgogCiBwcml2YXRlOgog ICAgIEF0b21pY1N0cmluZyBtX3N0cmluZzsgLy8gVVJJIGZvciByZW1vdGUsIGJ1aWx0LWluIGZv bnQgbmFtZSBmb3IgbG9jYWwuCi0gICAgQ2FjaGVkRm9udCogbV9mb250OyAvLyBGb3IgcmVtb3Rl IGZvbnRzLCBhIHBvaW50ZXIgdG8gb3VyIGNhY2hlZCByZXNvdXJjZS4KKyAgICBDYWNoZWRSZXNv dXJjZUhhbmRsZTxDYWNoZWRGb250PiBtX2ZvbnQ7IC8vIEZvciByZW1vdGUgZm9udHMsIGEgcG9p bnRlciB0byBvdXIgY2FjaGVkIHJlc291cmNlLgogICAgIENTU0ZvbnRGYWNlKiBtX2ZhY2U7IC8v IE91ciBvd25pbmcgZm9udCBmYWNlLgogICAgIEhhc2hNYXA8dW5zaWduZWQsIFNpbXBsZUZvbnRE YXRhKj4gbV9mb250RGF0YVRhYmxlOyAvLyBUaGUgaGFzaCBrZXkgaXMgY29tcG9zZWQgb2Ygc2l6 ZSBzeW50aGV0aWMgc3R5bGVzLgogCkluZGV4OiBXZWJDb3JlL2Nzcy9DU1NJbXBvcnRSdWxlLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9jc3MvQ1NTSW1wb3J0UnVsZS5oCShyZXZpc2lvbiAzNTky MSkKKysrIFdlYkNvcmUvY3NzL0NTU0ltcG9ydFJ1bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMjQs NiArMjQsNyBAQAogCiAjaW5jbHVkZSAiQ1NTUnVsZS5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291 cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRl ICJNZWRpYUxpc3QuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgogCkBAIC02NSw3ICs2 Niw3IEBAIHByaXZhdGU6CiAgICAgU3RyaW5nIG1fc3RySHJlZjsKICAgICBSZWZQdHI8TWVkaWFM aXN0PiBtX2xzdE1lZGlhOwogICAgIFJlZlB0cjxDU1NTdHlsZVNoZWV0PiBtX3N0eWxlU2hlZXQ7 Ci0gICAgQ2FjaGVkQ1NTU3R5bGVTaGVldCogbV9jYWNoZWRTaGVldDsKKyAgICBDYWNoZWRSZXNv dXJjZUhhbmRsZTxDYWNoZWRDU1NTdHlsZVNoZWV0PiBtX2NhY2hlZFNoZWV0OwogICAgIGJvb2wg bV9sb2FkaW5nOwogfTsKIApJbmRleDogV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29y ZS9kb20vQ2xpcGJvYXJkLmgJKHdvcmtpbmcgY29weSkKQEAgLTI0LDYgKzI0LDcgQEAKICNpZm5k ZWYgQ2xpcGJvYXJkX2gKICNkZWZpbmUgQ2xpcGJvYXJkX2gKIAorI2luY2x1ZGUgIkNhY2hlZFJl c291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiQ2xpcGJvYXJkQWNjZXNzUG9saWN5LmgiCiAjaW5j bHVkZSAiRHJhZ0FjdGlvbnMuaCIKICNpbmNsdWRlICJEcmFnSW1hZ2UuaCIKQEAgLTU0LDcgKzU1 LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIEhhc2hTZXQ8U3RyaW5n PiB0eXBlcygpIGNvbnN0ID0gMDsKICAgICAKICAgICAgICAgSW50UG9pbnQgZHJhZ0xvY2F0aW9u KCkgY29uc3QgeyByZXR1cm4gbV9kcmFnTG9jOyB9Ci0gICAgICAgIENhY2hlZEltYWdlKiBkcmFn SW1hZ2UoKSBjb25zdCB7IHJldHVybiBtX2RyYWdJbWFnZTsgfQorICAgICAgICBDYWNoZWRJbWFn ZSogZHJhZ0ltYWdlKCkgY29uc3QgeyByZXR1cm4gbV9kcmFnSW1hZ2UuZ2V0KCk7IH0KICAgICAg ICAgdmlydHVhbCB2b2lkIHNldERyYWdJbWFnZShDYWNoZWRJbWFnZSosIGNvbnN0IEludFBvaW50 JikgPSAwOwogICAgICAgICBOb2RlKiBkcmFnSW1hZ2VFbGVtZW50KCkgeyByZXR1cm4gbV9kcmFn SW1hZ2VFbGVtZW50LmdldCgpOyB9CiAgICAgICAgIHZpcnR1YWwgdm9pZCBzZXREcmFnSW1hZ2VF bGVtZW50KE5vZGUqLCBjb25zdCBJbnRQb2ludCYpID0gMDsKQEAgLTkwLDcgKzkxLDcgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgIHByb3RlY3RlZDoKICAgICAgICAgYm9vbCBtX2ZvckRyYWdn aW5nOwogICAgICAgICBJbnRQb2ludCBtX2RyYWdMb2M7Ci0gICAgICAgIENhY2hlZEltYWdlKiBt X2RyYWdJbWFnZTsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1f ZHJhZ0ltYWdlOwogICAgICAgICBSZWZQdHI8Tm9kZT4gbV9kcmFnSW1hZ2VFbGVtZW50OwogICAg IH07CiAKSW5kZXg6IFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJbnN0cnVjdGlvbi5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJbnN0cnVjdGlvbi5oCShyZXZpc2lvbiAzNTky MSkKKysrIFdlYkNvcmUvZG9tL1Byb2Nlc3NpbmdJbnN0cnVjdGlvbi5oCSh3b3JraW5nIGNvcHkp CkBAIC0yNSw2ICsyNSw3IEBACiAjZGVmaW5lIFByb2Nlc3NpbmdJbnN0cnVjdGlvbl9oCiAKICNp bmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNl SGFuZGxlLmgiCiAjaW5jbHVkZSAiQ29udGFpbmVyTm9kZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CkBAIC04NCw3ICs4NSw3IEBAIHByaXZhdGU6CiAgICAgU3RyaW5nIG1fbG9jYWxIcmVmOwog ICAgIFN0cmluZyBtX3RpdGxlOwogICAgIFN0cmluZyBtX21lZGlhOwotICAgIENhY2hlZFJlc291 cmNlKiBtX2NhY2hlZFNoZWV0OworICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZFJlc291 cmNlPiBtX2NhY2hlZFNoZWV0OwogICAgIFJlZlB0cjxTdHlsZVNoZWV0PiBtX3NoZWV0OwogICAg IGJvb2wgbV9sb2FkaW5nOwogICAgIGJvb2wgbV9hbHRlcm5hdGU7CkluZGV4OiBXZWJDb3JlL2Rv bS9TY3JpcHRFbGVtZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vU2NyaXB0RWxlbWVu dC5oCShyZXZpc2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvZG9tL1NjcmlwdEVsZW1lbnQuaAkod29y a2luZyBjb3B5KQpAQCAtMjIsNiArMjIsNyBAQAogI2RlZmluZSBTY3JpcHRFbGVtZW50X2gKIAog I2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3Vy Y2VIYW5kbGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC04MCw3ICs4MSw3IEBAIHBy aXZhdGU6CiBwcml2YXRlOgogICAgIFNjcmlwdEVsZW1lbnQqIG1fc2NyaXB0RWxlbWVudDsKICAg ICBFbGVtZW50KiBtX2VsZW1lbnQ7Ci0gICAgQ2FjaGVkU2NyaXB0KiBtX2NhY2hlZFNjcmlwdDsK KyAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRTY3JpcHQ+IG1fY2FjaGVkU2NyaXB0Owog ICAgIGJvb2wgbV9jcmVhdGVkQnlQYXJzZXI7CiAgICAgYm9vbCBtX2V2YWx1YXRlZDsKIH07Cklu ZGV4OiBXZWJDb3JlL2RvbS9YTUxUb2tlbml6ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv ZG9tL1hNTFRva2VuaXplci5jcHAJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9kb20vWE1M VG9rZW5pemVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTU0MCw3ICsxNTQwLDcgQEAgdm9pZCBY TUxUb2tlbml6ZXI6Om5vdGlmeUZpbmlzaGVkKENhY2hlZAogCiBib29sIFhNTFRva2VuaXplcjo6 aXNXYWl0aW5nRm9yU2NyaXB0cygpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1fcGVuZGluZ1Njcmlw dCAhPSAwOworICAgIHJldHVybiBtX3BlbmRpbmdTY3JpcHQ7CiB9CiAKICNpZiBFTkFCTEUoWFNM VCkKSW5kZXg6IFdlYkNvcmUvZG9tL1hNTFRva2VuaXplci5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvZG9tL1hNTFRva2VuaXplci5oCShyZXZpc2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvZG9tL1hN TFRva2VuaXplci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2ICsyNSw3IEBACiAjZGVmaW5lIFhN TFRva2VuaXplcl9oCiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1 ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2VnbWVudGVkU3RyaW5nLmgi CiAjaW5jbHVkZSAiU3RyaW5nSGFzaC5oIgogI2luY2x1ZGUgIlRva2VuaXplci5oIgpAQCAtMTU0 LDcgKzE1NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgaW50IG1fbGFzdEVycm9y Q29sdW1uOwogICAgICAgICBTdHJpbmcgbV9lcnJvck1lc3NhZ2VzOwogCi0gICAgICAgIENhY2hl ZFNjcmlwdCogbV9wZW5kaW5nU2NyaXB0OworICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxD YWNoZWRTY3JpcHQ+IG1fcGVuZGluZ1NjcmlwdDsKICAgICAgICAgUmVmUHRyPEVsZW1lbnQ+IG1f c2NyaXB0RWxlbWVudDsKICAgICAgICAgaW50IG1fc2NyaXB0U3RhcnRMaW5lOwogCkluZGV4OiBX ZWJDb3JlL2h0bWwvSFRNTEltYWdlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0 bWwvSFRNTEltYWdlTG9hZGVyLmNwcAkocmV2aXNpb24gMzU5MjEpCisrKyBXZWJDb3JlL2h0bWwv SFRNTEltYWdlTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTcsNyArNTcsNyBAQCBIVE1M SW1hZ2VMb2FkZXI6On5IVE1MSW1hZ2VMb2FkZXIoKQogCiB2b2lkIEhUTUxJbWFnZUxvYWRlcjo6 c2V0SW1hZ2UoQ2FjaGVkSW1hZ2UgKm5ld0ltYWdlKQogewotICAgIENhY2hlZEltYWdlICpvbGRJ bWFnZSA9IG1faW1hZ2U7CisgICAgQ2FjaGVkSW1hZ2UgKm9sZEltYWdlID0gbV9pbWFnZS5nZXQo KTsKICAgICBpZiAobmV3SW1hZ2UgIT0gb2xkSW1hZ2UpIHsKICAgICAgICAgc2V0TG9hZGluZ0lt YWdlKG5ld0ltYWdlKTsKICAgICAgICAgbV9maXJlZExvYWQgPSB0cnVlOwpAQCAtMTA3LDcgKzEw Nyw3IEBAIHZvaWQgSFRNTEltYWdlTG9hZGVyOjp1cGRhdGVGcm9tRWxlbWVudCgKICAgICAgICAg ICAgIG5ld0ltYWdlID0gZG9jLT5kb2NMb2FkZXIoKS0+cmVxdWVzdEltYWdlKHBhcnNlVVJMKGF0 dHIpKTsKICAgICB9CiAgICAgCi0gICAgQ2FjaGVkSW1hZ2UgKm9sZEltYWdlID0gbV9pbWFnZTsK KyAgICBDYWNoZWRJbWFnZSAqb2xkSW1hZ2UgPSBtX2ltYWdlLmdldCgpOwogICAgIGlmIChuZXdJ bWFnZSAhPSBvbGRJbWFnZSkgewogI2lmZGVmIElOU1RSVU1FTlRfTEFZT1VUX1NDSEVEVUxJTkcK ICAgICAgICAgaWYgKCFkb2MtPm93bmVyRWxlbWVudCgpICYmIG5ld0ltYWdlKQpAQCAtMTQ1LDcg KzE0NSw3IEBAIHZvaWQgSFRNTEltYWdlTG9hZGVyOjpub3RpZnlGaW5pc2hlZChDYWMKICNlbmRp ZgogICAgIGlmIChSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gZWxlbS0+cmVuZGVyZXIoKSkKICAg ICAgICAgaWYgKHJlbmRlcmVyLT5pc0ltYWdlKCkpCi0gICAgICAgICAgICBzdGF0aWNfY2FzdDxS ZW5kZXJJbWFnZSo+KHJlbmRlcmVyKS0+c2V0Q2FjaGVkSW1hZ2UobV9pbWFnZSk7CisgICAgICAg ICAgICBzdGF0aWNfY2FzdDxSZW5kZXJJbWFnZSo+KHJlbmRlcmVyKS0+c2V0Q2FjaGVkSW1hZ2Uo bV9pbWFnZS5nZXQoKSk7CiAgICAgICAgICAgICAKICAgICBpZiAoaW1hZ2UtPmVycm9yT2NjdXJy ZWQoKSAmJiBlbGVtLT5oYXNUYWdOYW1lKG9iamVjdFRhZykpCiAgICAgICAgIHN0YXRpY19jYXN0 PEhUTUxPYmplY3RFbGVtZW50Kj4oZWxlbSktPnJlbmRlckZhbGxiYWNrQ29udGVudCgpOwpJbmRl eDogV2ViQ29yZS9odG1sL0hUTUxJbWFnZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv aHRtbC9IVE1MSW1hZ2VMb2FkZXIuaAkocmV2aXNpb24gMzU5MjEpCisrKyBXZWJDb3JlL2h0bWwv SFRNTEltYWdlTG9hZGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNkZWZp bmUgSFRNTEltYWdlTG9hZGVyX2gKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50Lmgi CisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCkBAIC00Myw3ICs0NCw3IEBAIHB1YmxpYzoKICAgICBFbGVtZW50KiBlbGVtZW50KCkgY29u c3QgeyByZXR1cm4gbV9lbGVtZW50OyB9CiAgICAgYm9vbCBpbWFnZUNvbXBsZXRlKCkgY29uc3Qg eyByZXR1cm4gbV9pbWFnZUNvbXBsZXRlOyB9CiAKLSAgICBDYWNoZWRJbWFnZSogaW1hZ2UoKSBj b25zdCB7IHJldHVybiBtX2ltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2UqIGltYWdlKCkgY29uc3Qg eyByZXR1cm4gbV9pbWFnZS5nZXQoKTsgfQogICAgIHZvaWQgc2V0SW1hZ2UoQ2FjaGVkSW1hZ2Uq KTsKIAogICAgIHZvaWQgc2V0TG9hZE1hbnVhbGx5KGJvb2wgbG9hZE1hbnVhbGx5KSB7IG1fbG9h ZE1hbnVhbGx5ID0gbG9hZE1hbnVhbGx5OyB9CkBAIC01OSw3ICs2MCw3IEBAIHByb3RlY3RlZDoK IAogcHJpdmF0ZToKICAgICBFbGVtZW50KiBtX2VsZW1lbnQ7Ci0gICAgQ2FjaGVkSW1hZ2UqIG1f aW1hZ2U7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1faW1hZ2U7CiAg ICAgYm9vbCBtX2ZpcmVkTG9hZCA6IDE7CiAgICAgYm9vbCBtX2ltYWdlQ29tcGxldGUgOiAxOwog ICAgIGJvb2wgbV9sb2FkTWFudWFsbHkgOiAxOwpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxMaW5r RWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MTGlua0VsZW1lbnQuaAko cmV2aXNpb24gMzU5MjEpCisrKyBXZWJDb3JlL2h0bWwvSFRNTExpbmtFbGVtZW50LmgJKHdvcmtp bmcgY29weSkKQEAgLTI1LDYgKzI1LDcgQEAKIAogI2luY2x1ZGUgIkNTU1N0eWxlU2hlZXQuaCIK ICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291 cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtMTAwLDcgKzEwMSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZmluaXNo UGFyc2luZ0NoaWxkcmVuKCk7CiAKIHByb3RlY3RlZDoKLSAgICBDYWNoZWRDU1NTdHlsZVNoZWV0 KiBtX2NhY2hlZFNoZWV0OworICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZENTU1N0eWxl U2hlZXQ+IG1fY2FjaGVkU2hlZXQ7CiAgICAgUmVmUHRyPENTU1N0eWxlU2hlZXQ+IG1fc2hlZXQ7 CiAgICAgU3RyaW5nIG1fdXJsOwogICAgIFN0cmluZyBtX3R5cGU7CkluZGV4OiBXZWJDb3JlL2h0 bWwvSFRNTFRva2VuaXplci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxUb2tl bml6ZXIuY3BwCShyZXZpc2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvaHRtbC9IVE1MVG9rZW5pemVy LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjEwLDkgKzIxMCwxMCBAQCB2b2lkIEhUTUxUb2tlbml6 ZXI6OnJlc2V0KCkKICAgICBBU1NFUlQobV9leGVjdXRpbmdTY3JpcHQgPT0gMCk7CiAKICAgICB3 aGlsZSAoIXBlbmRpbmdTY3JpcHRzLmlzRW1wdHkoKSkgewotICAgICAgQ2FjaGVkU2NyaXB0ICpj cyA9IHBlbmRpbmdTY3JpcHRzLmRlcXVldWUoKTsKLSAgICAgIEFTU0VSVChjYWNoZSgpLT5kaXNh YmxlZCgpIHx8IGNzLT5hY2Nlc3NDb3VudCgpID4gMCk7Ci0gICAgICBjcy0+cmVtb3ZlQ2xpZW50 KHRoaXMpOworICAgICAgICBDYWNoZWRTY3JpcHQgKmNzID0gcGVuZGluZ1NjcmlwdHMuZmlyc3Qo KS5nZXQoKTsKKyAgICAgICAgcGVuZGluZ1NjcmlwdHMucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAg QVNTRVJUKGNhY2hlKCktPmRpc2FibGVkKCkgfHwgY3MtPmFjY2Vzc0NvdW50KCkgPiAwKTsKKyAg ICAgICAgY3MtPnJlbW92ZUNsaWVudCh0aGlzKTsKICAgICB9CiAgICAgCiAgICAgZmFzdEZyZWUo YnVmZmVyKTsKQEAgLTQzMCw3ICs0MzEsNyBAQCBIVE1MVG9rZW5pemVyOjpTdGF0ZSBIVE1MVG9r ZW5pemVyOjpzY3JpCiAgICAgICAgICAgICAgICAgLy8gVGhlIHBhcnNlciBtaWdodCBoYXZlIGJl ZW4gc3RvcHBlZCBieSBmb3IgZXhhbXBsZSBhIHdpbmRvdy5jbG9zZSBjYWxsIGluIGFuIGVhcmxp ZXIgc2NyaXB0LgogICAgICAgICAgICAgICAgIC8vIElmIHNvLCB3ZSBkb24ndCB3YW50IHRvIGxv YWQgc2NyaXB0cy4KICAgICAgICAgICAgICAgICBpZiAoIW1fcGFyc2VyU3RvcHBlZCAmJiAoY3Mg PSBtX2RvYy0+ZG9jTG9hZGVyKCktPnJlcXVlc3RTY3JpcHQoc2NyaXB0U3JjLCBzY3JpcHRTcmND aGFyc2V0KSkpCi0gICAgICAgICAgICAgICAgICAgIHBlbmRpbmdTY3JpcHRzLmVucXVldWUoY3Mp OworICAgICAgICAgICAgICAgICAgICBwZW5kaW5nU2NyaXB0cy5hcHBlbmQoY3MpOwogICAgICAg ICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgc2NyaXB0Tm9kZSA9IDA7CiAgICAg ICAgICAgICB9IGVsc2UKQEAgLTE5ODAsOCArMTk4MSw5IEBAIHZvaWQgSFRNTFRva2VuaXplcjo6 bm90aWZ5RmluaXNoZWQoQ2FjaGUKICAgICAgICAgcmV0dXJuOwogCiAgICAgYm9vbCBmaW5pc2hl ZCA9IGZhbHNlOwotICAgIHdoaWxlICghZmluaXNoZWQgJiYgcGVuZGluZ1NjcmlwdHMuaGVhZCgp LT5pc0xvYWRlZCgpKSB7Ci0gICAgICAgIENhY2hlZFNjcmlwdCogY3MgPSBwZW5kaW5nU2NyaXB0 cy5kZXF1ZXVlKCk7CisgICAgd2hpbGUgKCFmaW5pc2hlZCAmJiBwZW5kaW5nU2NyaXB0cy5maXJz dCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgIENhY2hlZFNjcmlwdCogY3MgPSBwZW5kaW5nU2Ny aXB0cy5maXJzdCgpLmdldCgpOworICAgICAgICBwZW5kaW5nU2NyaXB0cy5yZW1vdmVGaXJzdCgp OwogICAgICAgICBBU1NFUlQoY2FjaGUoKS0+ZGlzYWJsZWQoKSB8fCBjcy0+YWNjZXNzQ291bnQo KSA+IDApOwogCiAgICAgICAgIFN0cmluZyBzY3JpcHRTb3VyY2UgPSBjcy0+c2NyaXB0KCk7Cklu ZGV4OiBXZWJDb3JlL2h0bWwvSFRNTFRva2VuaXplci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv aHRtbC9IVE1MVG9rZW5pemVyLmgJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9odG1sL0hU TUxUb2tlbml6ZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjQsMTQgKzI0LDE1IEBACiAjaWZuZGVm IEhUTUxUb2tlbml6ZXJfaAogI2RlZmluZSBIVE1MVG9rZW5pemVyX2gKIAotI2luY2x1ZGUgIkRl cHJlY2F0ZWRQdHJRdWV1ZS5oIgorI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisj aW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJOYW1lZE1hcHBlZEF0 dHJNYXAuaCIKICNpbmNsdWRlICJTZWdtZW50ZWRTdHJpbmcuaCIKICNpbmNsdWRlICJUaW1lci5o IgogI2luY2x1ZGUgIlRva2VuaXplci5oIgotI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50 LmgiCi0jaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2lu Y2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIApAQCAtMzczLDcgKzM3NCw3IEBAIHByaXZhdGU6CiAgICAgLy8gdHJ1ZSBp ZiB3ZSBhcmUgZXhlY3V0aW5nIGEgc2NyaXB0IHdoaWxlIHBhcnNpbmcgYSBkb2N1bWVudC4gVGhp cyBjYXVzZXMgdGhlIHBhcnNpbmcgb2YKICAgICAvLyB0aGUgb3V0cHV0IG9mIHRoZSBzY3JpcHQg dG8gYmUgcG9zdHBvbmVkIHVudGlsIGFmdGVyIHRoZSBzY3JpcHQgaGFzIGZpbmlzaGVkIGV4ZWN1 dGluZwogICAgIGludCBtX2V4ZWN1dGluZ1NjcmlwdDsKLSAgICBEZXByZWNhdGVkUHRyUXVldWU8 Q2FjaGVkU2NyaXB0PiBwZW5kaW5nU2NyaXB0czsKKyAgICBEZXF1ZTxDYWNoZWRSZXNvdXJjZUhh bmRsZTxDYWNoZWRTY3JpcHQ+ID4gcGVuZGluZ1NjcmlwdHM7CiAgICAgUmVmUHRyPE5vZGU+IHNj cmlwdE5vZGU7CiAKICAgICBib29sIG1fcmVxdWVzdGluZ1NjcmlwdDsKSW5kZXg6IFdlYkNvcmUv bG9hZGVyL0NhY2hlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9DYWNoZS5jcHAJ KHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9sb2FkZXIvQ2FjaGUuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xODcsNiArMTg3LDU3IEBAIENhY2hlZENTU1N0eWxlU2hlZXQqIENhY2hlOjpyZXF1 ZXN0VXNlckMKIAogICAgIHJldHVybiB1c2VyU2hlZXQ7CiB9CisgICAgCit2b2lkIENhY2hlOjpy ZXZhbGlkYXRlUmVzb3VyY2UoQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlLCBEb2NMb2FkZXIqIGRv Y0xvYWRlcikKK3sKKyAgICBBU1NFUlQocmVzb3VyY2UpOworICAgIEFTU0VSVCghZGlzYWJsZWQo KSk7CisgICAgaWYgKHJlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKQorICAgICAgICBy ZXR1cm47CisgICAgaWYgKCFyZXNvdXJjZS0+Y2FuVXNlQ2FjaGVWYWxpZGF0b3IoKSkgeworICAg ICAgICByZW1vdmUocmVzb3VyY2UpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGNvbnN0 IFN0cmluZyYgdXJsID0gcmVzb3VyY2UtPnVybCgpOworICAgIENhY2hlZFJlc291cmNlKiBuZXdS ZXNvdXJjZSA9IGNyZWF0ZVJlc291cmNlKHJlc291cmNlLT50eXBlKCksIEtVUkwodXJsKSwgcmVz b3VyY2UtPmVuY29kaW5nKCkpOworICAgIG5ld1Jlc291cmNlLT5zZXRSZXNvdXJjZVRvUmV2YWxp ZGF0ZShyZXNvdXJjZSk7CisgICAgcmVtb3ZlKHJlc291cmNlKTsKKyAgICBtX3Jlc291cmNlcy5z ZXQodXJsLCBuZXdSZXNvdXJjZSk7CisgICAgbmV3UmVzb3VyY2UtPnNldEluQ2FjaGUodHJ1ZSk7 CisgICAgcmVzb3VyY2VBY2Nlc3NlZChuZXdSZXNvdXJjZSk7CisgICAgbmV3UmVzb3VyY2UtPmxv YWQoZG9jTG9hZGVyKTsKK30KKyAgICAKK3ZvaWQgQ2FjaGU6OnJldmFsaWRhdGlvblN1Y2NlZWRl ZChDYWNoZWRSZXNvdXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2UsIGNvbnN0IFJlc291cmNlUmVz cG9uc2UmIHJlc3BvbnNlKQoreworICAgIENhY2hlZFJlc291cmNlKiByZXNvdXJjZSA9IHJldmFs aWRhdGluZ1Jlc291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworICAgIEFTU0VSVChyZXNv dXJjZSk7CisgICAgQVNTRVJUKCFyZXNvdXJjZS0+aW5DYWNoZSgpKTsKKyAgICBBU1NFUlQocmVz b3VyY2UtPmlzTG9hZGVkKCkpOworICAgIAorICAgIHJlbW92ZShyZXZhbGlkYXRpbmdSZXNvdXJj ZSk7CisKKyAgICBBU1NFUlQoIW1fcmVzb3VyY2VzLmdldChyZXNvdXJjZS0+dXJsKCkpKTsKKyAg ICBtX3Jlc291cmNlcy5zZXQocmVzb3VyY2UtPnVybCgpLCByZXNvdXJjZSk7CisgICAgcmVzb3Vy Y2UtPnNldEluQ2FjaGUodHJ1ZSk7CisgICAgcmVzb3VyY2UtPnNldEV4cGlyYXRpb25EYXRlKHJl c3BvbnNlLmV4cGlyYXRpb25EYXRlKCkpOworICAgIGluc2VydEluTFJVTGlzdChyZXNvdXJjZSk7 CisgICAgaW50IGRlbHRhID0gc3RhdGljX2Nhc3Q8aW50PihyZXNvdXJjZS0+c2l6ZSgpKTsKKyAg ICBpZiAocmVzb3VyY2UtPmRlY29kZWRTaXplKCkgJiYgcmVzb3VyY2UtPmhhc0NsaWVudHMoKSkK KyAgICAgICAgaW5zZXJ0SW5MaXZlRGVjb2RlZFJlc291cmNlc0xpc3QocmVzb3VyY2UpOworICAg IGlmIChkZWx0YSkKKyAgICAgICAgYWRqdXN0U2l6ZShyZXNvdXJjZS0+aGFzQ2xpZW50cygpLCBk ZWx0YSk7CisgICAgCisgICAgcmV2YWxpZGF0aW5nUmVzb3VyY2UtPnN3aXRjaENsaWVudHNUb1Jl dmFsaWRhdGVkUmVzb3VyY2UoKTsKKyAgICAvLyB0aGlzIGRlbGV0ZXMgdGhlIHJldmFsaWRhdGlu ZyByZXNvdXJjZQorICAgIHJldmFsaWRhdGluZ1Jlc291cmNlLT5jbGVhclJlc291cmNlVG9SZXZh bGlkYXRlKCk7Cit9CisKK3ZvaWQgQ2FjaGU6OnJldmFsaWRhdGlvbkZhaWxlZChDYWNoZWRSZXNv dXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2UpCit7CisgICAgQVNTRVJUKHJldmFsaWRhdGluZ1Jl c291cmNlLT5yZXNvdXJjZVRvUmV2YWxpZGF0ZSgpKTsKKyAgICByZXZhbGlkYXRpbmdSZXNvdXJj ZS0+Y2xlYXJSZXNvdXJjZVRvUmV2YWxpZGF0ZSgpOworfQogCiBDYWNoZWRSZXNvdXJjZSogQ2Fj aGU6OnJlc291cmNlRm9yVVJMKGNvbnN0IFN0cmluZyYgdXJsKQogewpJbmRleDogV2ViQ29yZS9s b2FkZXIvQ2FjaGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9DYWNoZS5oCShyZXZp c2lvbiAzNTkyMSkKKysrIFdlYkNvcmUvbG9hZGVyL0NhY2hlLmgJKHdvcmtpbmcgY29weSkKQEAg LTMsNyArMyw3IEBACiAKICAgICBDb3B5cmlnaHQgKEMpIDE5OTggTGFycyBLbm9sbCAoa25vbGxA bXBpLWhkLm1wZy5kZSkKICAgICBDb3B5cmlnaHQgKEMpIDIwMDEgRGlyayBNdWVsbGVyIDxtdWVs bGVyQGtkZS5vcmc+Ci0gICAgQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2LCAyMDA3IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAgICBDb3B5cmlnaHQgKEMpIDIwMDQsIDIw MDUsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogCiAg ICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgogICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCkBAIC05OSw2ICs5OSwxMCBAQCBwdWJsaWM6CiAKICAgICBDYWNoZWRD U1NTdHlsZVNoZWV0KiByZXF1ZXN0VXNlckNTU1N0eWxlU2hlZXQoRG9jTG9hZGVyKiwgY29uc3Qg U3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgY2hhcnNldCk7CiAgICAgCisgICAgdm9pZCByZXZh bGlkYXRlUmVzb3VyY2UoQ2FjaGVkUmVzb3VyY2UqLCBEb2NMb2FkZXIqKTsKKyAgICB2b2lkIHJl dmFsaWRhdGlvblN1Y2NlZWRlZChDYWNoZWRSZXNvdXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2Us IGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlKTsKKyAgICB2b2lkIHJldmFsaWRhdGlv bkZhaWxlZChDYWNoZWRSZXNvdXJjZSogcmV2YWxpZGF0aW5nUmVzb3VyY2UpOworICAgIAogICAg IC8vIFNldHMgdGhlIGNhY2hlJ3MgbWVtb3J5IGNhcGFjaXRpZXMsIGluIGJ5dGVzLiBUaGVzZSB3 aWxsIGhvbGQgb25seSBhcHByb3hpbWF0ZWx5LCAKICAgICAvLyBzaW5jZSB0aGUgZGVjb2RlZCBj b3N0IG9mIHJlc291cmNlcyBsaWtlIHNjcmlwdHMgYW5kIHN0eWxlc2hlZXRzIGlzIG5vdCBrbm93 bi4KICAgICAvLyAgLSBtaW5EZWFkQnl0ZXM6IFRoZSBtYXhpbXVtIG51bWJlciBvZiBieXRlcyB0 aGF0IGRlYWQgcmVzb3VyY2VzIHNob3VsZCBjb25zdW1lIHdoZW4gdGhlIGNhY2hlIGlzIHVuZGVy IHByZXNzdXJlLgpJbmRleDogV2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2UuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0NhY2hlZFJlc291cmNlLmNwcAkocmV2aXNpb24gMzU5 MjEpCisrKyBXZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZS5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZS5oIgogCiAjaW5jbHVk ZSAiQ2FjaGUuaCIKKyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUg IkRvY0xvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXIu aCIKQEAgLTQ1LDYgKzQ2LDEwIEBAIENhY2hlZFJlc291cmNlOjpDYWNoZWRSZXNvdXJjZShjb25z dCBTdHIKICAgICAsIG1faW5DYWNoZShmYWxzZSkKICAgICAsIG1fbG9hZGluZyhmYWxzZSkKICAg ICAsIG1fZG9jTG9hZGVyKDApCisgICAgLCBtX2hhbmRsZUNvdW50KDApCisgICAgLCBtX3Jlc291 cmNlVG9SZXZhbGlkYXRlKDApCisgICAgLCBtX2lzQmVpbmdSZXZhbGlkYXRlZChmYWxzZSkKKyAg ICAsIG1fZXhwaXJhdGlvbkRhdGUoMCkKIHsKICAgICBtX3R5cGUgPSB0eXBlOwogICAgIG1fc3Rh dHVzID0gUGVuZGluZzsKQEAgLTc2LDcgKzgxLDEyIEBAIENhY2hlZFJlc291cmNlOjp+Q2FjaGVk UmVzb3VyY2UoKQogI2lmbmRlZiBOREVCVUcKICAgICBtX2RlbGV0ZWQgPSB0cnVlOwogI2VuZGlm CisKKyAgICBBU1NFUlQoY2FjaGUoKS0+cmVzb3VyY2VGb3JVUkwodXJsKCkpICE9IHRoaXMpOwog ICAgIAorICAgIGlmIChtX3Jlc291cmNlVG9SZXZhbGlkYXRlKQorICAgICAgICBtX3Jlc291cmNl VG9SZXZhbGlkYXRlLT5tX2lzQmVpbmdSZXZhbGlkYXRlZCA9IGZhbHNlOyAgICAKKyAgIAogICAg IGlmIChtX2RvY0xvYWRlcikKICAgICAgICAgbV9kb2NMb2FkZXItPnJlbW92ZUNhY2hlZFJlc291 cmNlKHRoaXMpOwogfQpAQCAtOTUsMTIgKzEwNSwxOCBAQCB2b2lkIENhY2hlZFJlc291cmNlOjpm aW5pc2goKQogCiBib29sIENhY2hlZFJlc291cmNlOjppc0V4cGlyZWQoKSBjb25zdAogewotICAg IGlmICghbV9yZXNwb25zZS5leHBpcmF0aW9uRGF0ZSgpKQorICAgIGlmICghbV9leHBpcmF0aW9u RGF0ZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIHRpbWVfdCBub3cgPSB0aW1lKDApOwot ICAgIHJldHVybiAoZGlmZnRpbWUobm93LCBtX3Jlc3BvbnNlLmV4cGlyYXRpb25EYXRlKCkpID49 IDApOworICAgIHJldHVybiAoZGlmZnRpbWUobm93LCBtX2V4cGlyYXRpb25EYXRlKSA+PSAwKTsK IH0KLQorICAKK3ZvaWQgQ2FjaGVkUmVzb3VyY2U6OnNldFJlc3BvbnNlKGNvbnN0IFJlc291cmNl UmVzcG9uc2UmIHJlc3BvbnNlKQoreworICAgIG1fcmVzcG9uc2UgPSByZXNwb25zZTsKKyAgICBt X2V4cGlyYXRpb25EYXRlID0gcmVzcG9uc2UuZXhwaXJhdGlvbkRhdGUoKTsKK30KKyAgICAKIHZv aWQgQ2FjaGVkUmVzb3VyY2U6OnNldFJlcXVlc3QoUmVxdWVzdCogcmVxdWVzdCkKIHsKICAgICBp ZiAocmVxdWVzdCAmJiAhbV9yZXF1ZXN0KQpAQCAtMTM5LDYgKzE1NSwxMiBAQCB2b2lkIENhY2hl ZFJlc291cmNlOjpyZW1vdmVDbGllbnQoQ2FjaGVkCiAgICAgfQogfQogCit2b2lkIENhY2hlZFJl c291cmNlOjpjaGVja0RlbGV0ZSgpCit7CisgICAgaWYgKGNhbkRlbGV0ZSgpICYmICFpbkNhY2hl KCkpCisgICAgICAgIGRlbGV0ZSB0aGlzOworfQorICAgIAogdm9pZCBDYWNoZWRSZXNvdXJjZTo6 c2V0RGVjb2RlZFNpemUodW5zaWduZWQgc2l6ZSkKIHsKICAgICBpZiAoc2l6ZSA9PSBtX2RlY29k ZWRTaXplKQpAQCAtMjA4LDUgKzIzMCw3NiBAQCB2b2lkIENhY2hlZFJlc291cmNlOjpkaWRBY2Nl c3NEZWNvZGVkRGF0CiAgICAgICAgIGNhY2hlKCktPnBydW5lKCk7CiAgICAgfQogfQorICAgIAor dm9pZCBDYWNoZWRSZXNvdXJjZTo6c2V0UmVzb3VyY2VUb1JldmFsaWRhdGUoQ2FjaGVkUmVzb3Vy Y2UqIHJlc291cmNlKSAKK3sgCisgICAgQVNTRVJUKHJlc291cmNlKTsKKyAgICBBU1NFUlQoIW1f cmVzb3VyY2VUb1JldmFsaWRhdGUpOworICAgIEFTU0VSVChyZXNvdXJjZSAhPSB0aGlzKTsKKyAg ICBBU1NFUlQoIXJlc291cmNlLT5tX2lzQmVpbmdSZXZhbGlkYXRlZCk7CisgICAgQVNTRVJUKG1f aGFuZGxlc1RvUmV2YWxpZGF0ZS5pc0VtcHR5KCkpOworICAgIEFTU0VSVChyZXNvdXJjZS0+dHlw ZSgpID09IHR5cGUoKSk7CisgICAgcmVzb3VyY2UtPm1faXNCZWluZ1JldmFsaWRhdGVkID0gdHJ1 ZTsKKyAgICBtX3Jlc291cmNlVG9SZXZhbGlkYXRlID0gcmVzb3VyY2U7Cit9CisKK3ZvaWQgQ2Fj aGVkUmVzb3VyY2U6OmNsZWFyUmVzb3VyY2VUb1JldmFsaWRhdGUoKSAKK3sgCisgICAgQVNTRVJU KG1fcmVzb3VyY2VUb1JldmFsaWRhdGUpOworICAgIEFTU0VSVChtX3Jlc291cmNlVG9SZXZhbGlk YXRlLT5tX2lzQmVpbmdSZXZhbGlkYXRlZCk7CisgICAgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZS0+ bV9pc0JlaW5nUmV2YWxpZGF0ZWQgPSBmYWxzZTsKKyAgICBtX3Jlc291cmNlVG9SZXZhbGlkYXRl LT5jaGVja0RlbGV0ZSgpOworICAgIG1faGFuZGxlc1RvUmV2YWxpZGF0ZS5jbGVhcigpOworICAg IG1fcmVzb3VyY2VUb1JldmFsaWRhdGUgPSAwOworICAgIGNoZWNrRGVsZXRlKCk7Cit9CisgICAg Cit2b2lkIENhY2hlZFJlc291cmNlOjpzd2l0Y2hDbGllbnRzVG9SZXZhbGlkYXRlZFJlc291cmNl KCkKK3sKKyAgICBBU1NFUlQobV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSk7CisgICAgQVNTRVJUKCFp bkNhY2hlKCkpOworCisgICAgSGFzaFNldDxDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UqPjo6aXRl cmF0b3IgZW5kID0gbV9oYW5kbGVzVG9SZXZhbGlkYXRlLmVuZCgpOworICAgIGZvciAoSGFzaFNl dDxDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UqPjo6aXRlcmF0b3IgaXQgPSBtX2hhbmRsZXNUb1Jl dmFsaWRhdGUuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIENhY2hlZFJlc291 cmNlSGFuZGxlQmFzZSogaGFuZGxlID0gKml0OworICAgICAgICBoYW5kbGUtPm1fcmVzb3VyY2Ug PSBtX3Jlc291cmNlVG9SZXZhbGlkYXRlOworICAgICAgICBtX3Jlc291cmNlVG9SZXZhbGlkYXRl LT5yZWdpc3RlckhhbmRsZShoYW5kbGUpOworICAgICAgICAtLW1faGFuZGxlQ291bnQ7CisgICAg fQorICAgIEFTU0VSVCghbV9oYW5kbGVDb3VudCk7CisgICAgbV9oYW5kbGVzVG9SZXZhbGlkYXRl LmNsZWFyKCk7CisKKyAgICBWZWN0b3I8Q2FjaGVkUmVzb3VyY2VDbGllbnQqPiBjbGllbnRzVG9N b3ZlOworICAgIEhhc2hDb3VudGVkU2V0PENhY2hlZFJlc291cmNlQ2xpZW50Kj46Oml0ZXJhdG9y IGVuZDIgPSBtX2NsaWVudHMuZW5kKCk7CisgICAgZm9yIChIYXNoQ291bnRlZFNldDxDYWNoZWRS ZXNvdXJjZUNsaWVudCo+OjppdGVyYXRvciBpdCA9IG1fY2xpZW50cy5iZWdpbigpOyBpdCAhPSBl bmQyOyArK2l0KSB7CisgICAgICAgIENhY2hlZFJlc291cmNlQ2xpZW50KiBjbGllbnQgPSBpdC0+ Zmlyc3Q7CisgICAgICAgIHVuc2lnbmVkIGNvdW50ID0gaXQtPnNlY29uZDsKKyAgICAgICAgd2hp bGUgKGNvdW50KSB7CisgICAgICAgICAgICBjbGllbnRzVG9Nb3ZlLmFwcGVuZChjbGllbnQpOwor ICAgICAgICAgICAgLS1jb3VudDsKKyAgICAgICAgfQorICAgIH0KKyAgICAvLyBFcXVpdmFsZW50 IG9mIGNhbGxpbmcgcmVtb3ZlQ2xpZW50KCkgZm9yIGFsbCBjbGllbnRzCisgICAgbV9jbGllbnRz LmNsZWFyKCk7CisgICAgCisgICAgdW5zaWduZWQgbW92ZUNvdW50ID0gY2xpZW50c1RvTW92ZS5z aXplKCk7CisgICAgZm9yICh1bnNpZ25lZCBuID0gMDsgbiA8IG1vdmVDb3VudDsgKytuKQorICAg ICAgICBtX3Jlc291cmNlVG9SZXZhbGlkYXRlLT5hZGRDbGllbnQoY2xpZW50c1RvTW92ZVtuXSk7 Cit9CisgICAgCitib29sIENhY2hlZFJlc291cmNlOjpjYW5Vc2VDYWNoZVZhbGlkYXRvcigpIGNv bnN0Cit7CisgICAgcmV0dXJuICFtX2xvYWRpbmcgJiYgKCFtX3Jlc3BvbnNlLmh0dHBIZWFkZXJG aWVsZCgiTGFzdC1Nb2RpZmllZCIpLmlzRW1wdHkoKSB8fCAhbV9yZXNwb25zZS5odHRwSGVhZGVy RmllbGQoIkVUYWciKS5pc0VtcHR5KCkpOworfQorICAgIAorYm9vbCBDYWNoZWRSZXNvdXJjZTo6 bXVzdFJldmFsaWRhdGUoQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3kpIGNvbnN0Cit7CisgICAgaWYg KG1fbG9hZGluZykKKyAgICAgICAgcmV0dXJuIGZhbHNlOyAgICAKKyAgICBTdHJpbmcgY2FjaGVD b250cm9sID0gbV9yZXNwb25zZS5odHRwSGVhZGVyRmllbGQoIkNhY2hlLUNvbnRyb2wiKTsKKyAg ICBpZiAoY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lDYWNoZSkKKyAgICAgICAgcmV0dXJuICFj YWNoZUNvbnRyb2wuaXNFbXB0eSgpICYmIChjYWNoZUNvbnRyb2wuY29udGFpbnMoIm5vLWNhY2hl IikgfHwgKGlzRXhwaXJlZCgpICYmIGNhY2hlQ29udHJvbC5jb250YWlucygibXVzdC1yZXZhbGlk YXRlIikpKTsKKyAgICByZXR1cm4gaXNFeHBpcmVkKCkgfHwgY2FjaGVDb250cm9sLmNvbnRhaW5z KCJuby1jYWNoZSIpOworfQogCiB9CkluZGV4OiBXZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJj ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0NhY2hlZFJlc291cmNlLmgJKHJldmlz aW9uIDM1OTIxKQorKysgV2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2UuaAkod29ya2luZyBj b3B5KQpAQCAtMjMsMTAgKzIzLDEyIEBACiAjaWZuZGVmIENhY2hlZFJlc291cmNlX2gKICNkZWZp bmUgQ2FjaGVkUmVzb3VyY2VfaAogCisjaW5jbHVkZSAiQ2FjaGVQb2xpY3kuaCIKICNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNs dWRlICJTaGFyZWRCdWZmZXIuaCIKICNpbmNsdWRlIDx3dGYvSGFzaENvdW50ZWRTZXQuaD4KKyNp bmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KICNpbmNsdWRl IDx0aW1lLmg+CiAKQEAgLTM0LDcgKzM2LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFz cyBDYWNoZTsKIGNsYXNzIENhY2hlZFJlc291cmNlQ2xpZW50OwotY2xhc3MgQ2FjaGVIYW5kbGVC YXNlOworY2xhc3MgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlOwogY2xhc3MgRG9jTG9hZGVyOwog Y2xhc3MgUmVxdWVzdDsKIApAQCAtODMsNiArODUsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIGFkZENsaWVudChDYWNoZWRSZXNvdXJjZUNsaWVudCopOwogICAgIHZvaWQgcmVtb3ZlQ2xp ZW50KENhY2hlZFJlc291cmNlQ2xpZW50Kik7CiAgICAgYm9vbCBoYXNDbGllbnRzKCkgY29uc3Qg eyByZXR1cm4gIW1fY2xpZW50cy5pc0VtcHR5KCk7IH0KKyAgICB2b2lkIGNoZWNrRGVsZXRlKCk7 CiAKICAgICBlbnVtIFByZWxvYWRSZXN1bHQgewogICAgICAgICBQcmVsb2FkTm90UmVmZXJlbmNl ZCwKQEAgLTEyOCwxMCArMTMxLDEwIEBAIHB1YmxpYzoKIAogICAgIFNoYXJlZEJ1ZmZlciogZGF0 YSgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YS5nZXQoKTsgfQogCi0gICAgdm9pZCBzZXRSZXNwb25z ZShjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSkgeyBtX3Jlc3BvbnNlID0gcmVzcG9u c2U7IH0KKyAgICB2b2lkIHNldFJlc3BvbnNlKGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIHJlc3Bv bnNlKTsKICAgICBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSgpIGNvbnN0IHsgcmV0 dXJuIG1fcmVzcG9uc2U7IH0KLSAgICAKLSAgICBib29sIGNhbkRlbGV0ZSgpIGNvbnN0IHsgcmV0 dXJuICFoYXNDbGllbnRzKCkgJiYgIW1fcmVxdWVzdCAmJiAhbV9wcmVsb2FkQ291bnQ7IH0KKwor ICAgIGJvb2wgY2FuRGVsZXRlKCkgY29uc3QgeyByZXR1cm4gIWhhc0NsaWVudHMoKSAmJiAhbV9y ZXF1ZXN0ICYmICFtX3ByZWxvYWRDb3VudCAmJiAhbV9oYW5kbGVDb3VudCAmJiAhbV9yZXNvdXJj ZVRvUmV2YWxpZGF0ZSAmJiAhbV9pc0JlaW5nUmV2YWxpZGF0ZWQ7IH0KIAogICAgIGJvb2wgaXNF eHBpcmVkKCkgY29uc3Q7CiAKQEAgLTE1Myw2ICsxNTYsMTQgQEAgcHVibGljOgogICAgIHZvaWQg aW5jcmVhc2VQcmVsb2FkQ291bnQoKSB7ICsrbV9wcmVsb2FkQ291bnQ7IH0KICAgICB2b2lkIGRl Y3JlYXNlUHJlbG9hZENvdW50KCkgeyBBU1NFUlQobV9wcmVsb2FkQ291bnQpOyAtLW1fcHJlbG9h ZENvdW50OyB9CiAgICAgCisgICAgdm9pZCByZWdpc3RlckhhbmRsZShDYWNoZWRSZXNvdXJjZUhh bmRsZUJhc2UqIGgpIHsgKyttX2hhbmRsZUNvdW50OyBpZiAobV9yZXNvdXJjZVRvUmV2YWxpZGF0 ZSkgbV9oYW5kbGVzVG9SZXZhbGlkYXRlLmFkZChoKTsgfQorICAgIHZvaWQgdW5yZWdpc3Rlckhh bmRsZShDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UqIGgpIHsgLS1tX2hhbmRsZUNvdW50OyBpZiAo bV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSkgbV9oYW5kbGVzVG9SZXZhbGlkYXRlLnJlbW92ZShoKTsg Y2hlY2tEZWxldGUoKTsgfQorICAgIAorICAgIGJvb2wgY2FuVXNlQ2FjaGVWYWxpZGF0b3IoKSBj b25zdDsKKyAgICBib29sIG11c3RSZXZhbGlkYXRlKENhY2hlUG9saWN5KSBjb25zdDsKKyAgICBi b29sIGlzQ2FjaGVWYWxpZGF0b3IoKSBjb25zdCB7IHJldHVybiBtX3Jlc291cmNlVG9SZXZhbGlk YXRlOyB9CisgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlVG9SZXZhbGlkYXRlKCkgY29uc3Qg eyByZXR1cm4gbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZTsgfQorICAgIAogcHJvdGVjdGVkOgogICAg IHZvaWQgc2V0RW5jb2RlZFNpemUodW5zaWduZWQpOwogICAgIHZvaWQgc2V0RGVjb2RlZFNpemUo dW5zaWduZWQpOwpAQCAtMTczLDYgKzE4NCwxMiBAQCBwcm90ZWN0ZWQ6CiAgICAgYm9vbCBtX2Vy cm9yT2NjdXJyZWQ7CiAKIHByaXZhdGU6CisgICAgLy8gVGhlc2UgYXJlIGNhbGxlZCBieSB0aGUg ZnJpZW5kbHkgQ2FjaGUgb25seQorICAgIHZvaWQgc2V0UmVzb3VyY2VUb1JldmFsaWRhdGUoQ2Fj aGVkUmVzb3VyY2UqIHJlc291cmNlKTsKKyAgICB2b2lkIHN3aXRjaENsaWVudHNUb1JldmFsaWRh dGVkUmVzb3VyY2UoKTsKKyAgICB2b2lkIGNsZWFyUmVzb3VyY2VUb1JldmFsaWRhdGUoKTsKKyAg ICB2b2lkIHNldEV4cGlyYXRpb25EYXRlKHRpbWVfdCBleHBpcmF0aW9uRGF0ZSkgeyBtX2V4cGly YXRpb25EYXRlID0gZXhwaXJhdGlvbkRhdGU7IH0KKwogICAgIHVuc2lnbmVkIG1fZW5jb2RlZFNp emU7CiAgICAgdW5zaWduZWQgbV9kZWNvZGVkU2l6ZTsKICAgICB1bnNpZ25lZCBtX2FjY2Vzc0Nv dW50OwpAQCAtMjAyLDYgKzIxOSwxOCBAQCBwcml2YXRlOgogICAgIENhY2hlZFJlc291cmNlKiBt X3ByZXZJbkxpdmVSZXNvdXJjZXNMaXN0OwogCiAgICAgRG9jTG9hZGVyKiBtX2RvY0xvYWRlcjsg Ly8gb25seSBub24tMCBmb3IgcmVzb3VyY2VzIHRoYXQgYXJlIG5vdCBpbiB0aGUgY2FjaGUKKyAg ICAKKyAgICB1bnNpZ25lZCBtX2hhbmRsZUNvdW50OworICAgIC8vIElmIHRoaXMgZmllbGQgaXMg bm9uLW51bGwgd2UgYXJlIHVzaW5nIHRoZSByZXNvdXJjZSBhcyBhIHByb3h5IGZvciBjaGVja2lu ZyB3aGV0aGVyIGFuIGV4aXN0aW5nIHJlc291cmNlIGlzIHN0aWxsIHVwIHRvIGRhdGUKKyAgICAv LyB1c2luZyBIVFRQIElmLU1vZGlmaWVkLVNpbmNlL0lmLU5vbmUtTWF0Y2ggaGVhZGVycy4gSWYg dGhlIHJlc3BvbnNlIGlzIDMwNCBhbGwgY2xpZW50cyBvZiB0aGlzIHJlc291cmNlIGFyZSBtb3Zl ZAorICAgIC8vIHRvIHRvIGJlIGNsaWVudHMgb2YgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSBhbmQg dGhlIHJlc291cmNlIGlzIGRlbGV0ZWQuIElmIG5vdCwgdGhlIGZpZWxkIGlzIHplcm9lZCBhbmQg dGhpcworICAgIC8vIHJlc291cmNlcyBiZWNvbWVzIG5vcm1hbCByZXNvdXJjZSBsb2FkLgorICAg IENhY2hlZFJlc291cmNlKiBtX3Jlc291cmNlVG9SZXZhbGlkYXRlOworICAgIGJvb2wgbV9pc0Jl aW5nUmV2YWxpZGF0ZWQ7CisgICAgLy8gVGhlc2UgaGFuZGxlcyB3aWxsIG5lZWQgdG8gYmUgdXBk YXRlZCB0byBwb2ludCB0byB0aGUgbV9yZXNvdXJjZVRvUmV2YWxpZGF0ZSBpbiBjYXNlIHdlIGdl dCAzMDQgcmVzcG9uc2UuCisgICAgSGFzaFNldDxDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UqPiBt X2hhbmRsZXNUb1JldmFsaWRhdGU7CisgICAgCisgICAgdGltZV90IG1fZXhwaXJhdGlvbkRhdGU7 CiB9OwogCiB9CkluZGV4OiBXZWJDb3JlL2xvYWRlci9DYWNoZWRSZXNvdXJjZUhhbmRsZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2VIYW5kbGUuY3BwCShy ZXZpc2lvbiAwKQorKysgV2ViQ29yZS9sb2FkZXIvQ2FjaGVkUmVzb3VyY2VIYW5kbGUuY3BwCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4IEFw cGxlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVO VCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAq IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuIAorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJDYWNoZWRS ZXNvdXJjZUhhbmRsZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgQ2FjaGVkUmVz b3VyY2VIYW5kbGVCYXNlOjpzZXRSZXNvdXJjZShDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UpIHsK KyAgICBpZiAocmVzb3VyY2UgPT0gbV9yZXNvdXJjZSkKKyAgICAgICAgcmV0dXJuOworICAgIGlm IChtX3Jlc291cmNlKQorICAgICAgICBtX3Jlc291cmNlLT51bnJlZ2lzdGVySGFuZGxlKHRoaXMp OworICAgIG1fcmVzb3VyY2UgPSByZXNvdXJjZTsKKyAgICBpZiAobV9yZXNvdXJjZSkKKyAgICAg ICAgbV9yZXNvdXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7Cit9CisKK30KSW5kZXg6IFdlYkNv cmUvbG9hZGVyL0NhY2hlZFJlc291cmNlSGFuZGxlLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9s b2FkZXIvQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvbG9h ZGVyL0NhY2hlZFJlc291cmNlSGFuZGxlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsODkgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5D LiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisg KiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2lmbmRlZiBD YWNoZWRSZXNvdXJjZUhhbmRsZV9oCisjZGVmaW5lIENhY2hlZFJlc291cmNlSGFuZGxlX2gKKwor I2luY2x1ZGUgIkNhY2hlZFJlc291cmNlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworICAg IGNsYXNzIENhY2hlZFJlc291cmNlSGFuZGxlQmFzZSB7CisgICAgcHVibGljOgorICAgICAgICB+ Q2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKCkgeyBpZiAobV9yZXNvdXJjZSkgbV9yZXNvdXJjZS0+ dW5yZWdpc3RlckhhbmRsZSh0aGlzKTsgfQorICAgICAgICBDYWNoZWRSZXNvdXJjZSogZ2V0KCkg Y29uc3QgeyByZXR1cm4gbV9yZXNvdXJjZTsgfQorICAgICAgICAKKyAgICAgICAgYm9vbCBvcGVy YXRvciEoKSBjb25zdCB7IHJldHVybiAhZ2V0KCk7IH0KKyAgICAgICAgb3BlcmF0b3IgYm9vbCgp IGNvbnN0IHsgcmV0dXJuIGdldCgpOyB9CisKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIENhY2hl ZFJlc291cmNlSGFuZGxlQmFzZSgpIDogbV9yZXNvdXJjZSgwKSB7fQorICAgICAgICBDYWNoZWRS ZXNvdXJjZUhhbmRsZUJhc2UoQ2FjaGVkUmVzb3VyY2UqIHJlcykgeyBtX3Jlc291cmNlID0gcmVz OyBpZiAobV9yZXNvdXJjZSkgbV9yZXNvdXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7IH0KKyAg ICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlKGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxl QmFzZSYgbykgOiBtX3Jlc291cmNlKG8ubV9yZXNvdXJjZSkgeyBpZiAobV9yZXNvdXJjZSkgbV9y ZXNvdXJjZS0+cmVnaXN0ZXJIYW5kbGUodGhpcyk7IH0KKworICAgICAgICB2b2lkIHNldFJlc291 cmNlKENhY2hlZFJlc291cmNlKiByZXMpOworICAgICAgICAKKyAgICBwcml2YXRlOgorICAgICAg ICBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UmIG9wZXJhdG9yPShjb25zdCBDYWNoZWRSZXNvdXJj ZUhhbmRsZUJhc2UmKSB7IHJldHVybiAqdGhpczsgfSAKKyAgICAgICAgCisgICAgICAgIGZyaWVu ZCBjbGFzcyBDYWNoZWRSZXNvdXJjZTsKKworICAgICAgICBDYWNoZWRSZXNvdXJjZSogbV9yZXNv dXJjZTsKKyAgICB9OworICAgICAgICAKKyAgICB0ZW1wbGF0ZSA8Y2xhc3MgUj4gY2xhc3MgQ2Fj aGVkUmVzb3VyY2VIYW5kbGUgOiBwdWJsaWMgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNlIHsKKyAg ICBwdWJsaWM6IAorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZSgpIHt9CisgICAgICAgIENh Y2hlZFJlc291cmNlSGFuZGxlKFIqIHJlcykgOiBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UocmVz KSB7fQorICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZShjb25zdCBDYWNoZWRSZXNvdXJjZUhh bmRsZTxSPiYgbykgOiBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2Uobykge30KKworICAgICAgICBS KiBnZXQoKSBjb25zdCB7IHJldHVybiByZWludGVycHJldF9jYXN0PFIqPihDYWNoZWRSZXNvdXJj ZUhhbmRsZUJhc2U6OmdldCgpKTsgfQorICAgICAgICBSKiBvcGVyYXRvci0+KCkgY29uc3QgeyBy ZXR1cm4gZ2V0KCk7IH0KKyAgICAgICAgICAgICAgIAorICAgICAgICBDYWNoZWRSZXNvdXJjZUhh bmRsZSYgb3BlcmF0b3I9KFIqIHJlcykgeyBzZXRSZXNvdXJjZShyZXMpOyByZXR1cm4gKnRoaXM7 IH0gCisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlJiBvcGVyYXRvcj0oY29uc3QgQ2FjaGVk UmVzb3VyY2VIYW5kbGUmIG8pIHsgc2V0UmVzb3VyY2Uoby5nZXQoKSk7IHJldHVybiAqdGhpczsg fQorICAgICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgQ2FjaGVkUmVzb3VyY2VIYW5kbGVCYXNl JiBvKSBjb25zdCB7IHJldHVybiBnZXQoKSA9PSBvLmdldCgpOyB9CisgICAgICAgIGJvb2wgb3Bl cmF0b3IhPShjb25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZUJhc2UmIG8pIGNvbnN0IHsgcmV0dXJu IGdldCgpICE9IG8uZ2V0KCk7IH0KKyAgICB9OworICAgIAorICAgIHRlbXBsYXRlIDxjbGFzcyBS LCBjbGFzcyBSUj4gYm9vbCBvcGVyYXRvcj09KGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxlPFI+ JiBoLCBjb25zdCBSUiogcmVzKSAKKyAgICB7IAorICAgICAgICByZXR1cm4gaC5nZXQoKSA9PSBy ZXM7IAorICAgIH0KKyAgICB0ZW1wbGF0ZSA8Y2xhc3MgUiwgY2xhc3MgUlI+IGJvb2wgb3BlcmF0 b3I9PShjb25zdCBSUiogcmVzLCBjb25zdCBDYWNoZWRSZXNvdXJjZUhhbmRsZTxSPiYgaCkgCisg ICAgeyAKKyAgICAgICAgcmV0dXJuIGguZ2V0KCkgPT0gcmVzOyAKKyAgICB9CisgICAgdGVtcGxh dGUgPGNsYXNzIFIsIGNsYXNzIFJSPiBib29sIG9wZXJhdG9yIT0oY29uc3QgQ2FjaGVkUmVzb3Vy Y2VIYW5kbGU8Uj4mIGgsIGNvbnN0IFJSKiByZXMpIAorICAgIHsgCisgICAgICAgIHJldHVybiBo LmdldCgpICE9IHJlczsgCisgICAgfQorICAgIHRlbXBsYXRlIDxjbGFzcyBSLCBjbGFzcyBSUj4g Ym9vbCBvcGVyYXRvciE9KGNvbnN0IFJSKiByZXMsIGNvbnN0IENhY2hlZFJlc291cmNlSGFuZGxl PFI+JiBoKSAKKyAgICB7IAorICAgICAgICByZXR1cm4gaC5nZXQoKSAhPSByZXM7IAorICAgIH0K K30KKworI2VuZGlmCkluZGV4OiBXZWJDb3JlL2xvYWRlci9Eb2NMb2FkZXIuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5jcHAJKHJldmlzaW9uIDM1OTIxKQorKysg V2ViQ29yZS9sb2FkZXIvRG9jTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtODAsMTggKzgw LDE5IEBAIHZvaWQgRG9jTG9hZGVyOjpjaGVja0ZvclJlbG9hZChjb25zdCBLVVIKICAgICBpZiAo ZnVsbFVSTC5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmIChtX2NhY2hlUG9s aWN5ID09IENhY2hlUG9saWN5VmVyaWZ5KSB7CisgICAgaWYgKG1fY2FjaGVQb2xpY3kgPT0gQ2Fj aGVQb2xpY3lWZXJpZnkgfHwgbV9jYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeUNhY2hlKSB7CiAg ICAgICAgaWYgKCFtX3JlbG9hZGVkVVJMcy5jb250YWlucyhmdWxsVVJMLnN0cmluZygpKSkgewog ICAgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGluZyA9IGNhY2hlKCktPnJlc291cmNlRm9y VVJMKGZ1bGxVUkwuc3RyaW5nKCkpOwotICAgICAgICAgIGlmIChleGlzdGluZyAmJiBleGlzdGlu Zy0+aXNFeHBpcmVkKCkgJiYgIWV4aXN0aW5nLT5pc1ByZWxvYWRlZCgpKSB7Ci0gICAgICAgICAg ICAgY2FjaGUoKS0+cmVtb3ZlKGV4aXN0aW5nKTsKLSAgICAgICAgICAgICBtX3JlbG9hZGVkVVJM cy5hZGQoZnVsbFVSTC5zdHJpbmcoKSk7CisgICAgICAgICAgaWYgKGV4aXN0aW5nICYmICFleGlz dGluZy0+aXNQcmVsb2FkZWQoKSAmJiBleGlzdGluZy0+bXVzdFJldmFsaWRhdGUobV9jYWNoZVBv bGljeSkpIHsKKyAgICAgICAgICAgICAgY2FjaGUoKS0+cmV2YWxpZGF0ZVJlc291cmNlKGV4aXN0 aW5nLCB0aGlzKTsKKyAgICAgICAgICAgICAgbV9yZWxvYWRlZFVSTHMuYWRkKGZ1bGxVUkwuc3Ry aW5nKCkpOwogICAgICAgICAgIH0KICAgICAgICB9CiAgICAgfSBlbHNlIGlmICgobV9jYWNoZVBv bGljeSA9PSBDYWNoZVBvbGljeVJlbG9hZCkgfHwgKG1fY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xp Y3lSZWZyZXNoKSkgewogICAgICAgIGlmICghbV9yZWxvYWRlZFVSTHMuY29udGFpbnMoZnVsbFVS TC5zdHJpbmcoKSkpIHsKICAgICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIGV4aXN0aW5nID0gY2Fj aGUoKS0+cmVzb3VyY2VGb3JVUkwoZnVsbFVSTC5zdHJpbmcoKSk7CiAgICAgICAgICAgIGlmIChl eGlzdGluZyAmJiAhZXhpc3RpbmctPmlzUHJlbG9hZGVkKCkpIHsKKyAgICAgICAgICAgICAgIC8v IEZJWE1FOiBVc2UgcmV2YWxpZGF0ZVJlc291cmNlKCkgdG8gaW1wbGVtZW50IEhUVFAgMS4xICJT cGVjaWZpYyBlbmQtdG8tZW5kIHJldmFsaWRhdGlvbiIgZm9yIHJlZ3VsYXIgcmVsb2FkaW5nCiAg ICAgICAgICAgICAgICBjYWNoZSgpLT5yZW1vdmUoZXhpc3RpbmcpOwogICAgICAgICAgICAgICAg bV9yZWxvYWRlZFVSTHMuYWRkKGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAgICB9CkluZGV4 OiBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVy L2xvYWRlci5jcHAJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMjE4LDExICsyMTgsMTIgQEAgdm9pZCBMb2FkZXI6Okhvc3Q6 OnNlcnZlUGVuZGluZ1JlcXVlc3RzKAogICAgIHdoaWxlICghcmVxdWVzdHNQZW5kaW5nLmlzRW1w dHkoKSkgeyAgICAgICAgCiAgICAgICAgIFJlcXVlc3QqIHJlcXVlc3QgPSByZXF1ZXN0c1BlbmRp bmcuZmlyc3QoKTsKICAgICAgICAgRG9jTG9hZGVyKiBkb2NMb2FkZXIgPSByZXF1ZXN0LT5kb2NM b2FkZXIoKTsKKyAgICAgICAgYm9vbCByZXNvdXJjZUlzQ2FjaGVWYWxpZGF0b3IgPSByZXF1ZXN0 LT5jYWNoZWRSZXNvdXJjZSgpLT5pc0NhY2hlVmFsaWRhdG9yKCk7CiAgICAgICAgIC8vIElmIHRo ZSBkb2N1bWVudCBpcyBmdWxseSBwYXJzZWQgYW5kIHRoZXJlIGFyZSBubyBwZW5kaW5nIHN0eWxl c2hlZXRzIHRoZXJlIHdvbid0IGJlIGFueSBtb3JlIAogICAgICAgICAvLyByZXNvdXJjZXMgdGhh dCB3ZSB3b3VsZCB3YW50IHRvIHB1c2ggdG8gdGhlIGZyb250IG9mIHRoZSBxdWV1ZS4gSnVzdCBo YW5kIG9mZiB0aGUgcmVtYWluaW5nIHJlc291cmNlcwogICAgICAgICAvLyB0byB0aGUgbmV0d29y a2luZyBsYXllci4KICAgICAgICAgYm9vbCBwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duID0gIWRv Y0xvYWRlci0+ZG9jKCktPnBhcnNpbmcoKSAmJiBkb2NMb2FkZXItPmRvYygpLT5oYXZlU3R5bGVz aGVldHNMb2FkZWQoKTsKLSAgICAgICAgaWYgKCFwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duICYm IG1fcmVxdWVzdHNMb2FkaW5nLnNpemUoKSA+PSBtX21heFJlcXVlc3RzSW5GbGlnaHQpIHsKKyAg ICAgICAgaWYgKCFwYXJzZWRBbmRTdHlsZXNoZWV0c0tub3duICYmICFyZXNvdXJjZUlzQ2FjaGVW YWxpZGF0b3IgJiYgbV9yZXF1ZXN0c0xvYWRpbmcuc2l6ZSgpID49IG1fbWF4UmVxdWVzdHNJbkZs aWdodCkgewogICAgICAgICAgICAgc2VydmVMb3dlclByaW9yaXR5ID0gZmFsc2U7CiAgICAgICAg ICAgICByZXR1cm47CiAgICAgICAgIH0KQEAgLTIzNyw2ICsyMzgsMjIgQEAgdm9pZCBMb2FkZXI6 Okhvc3Q6OnNlcnZlUGVuZGluZ1JlcXVlc3RzKAogICAgICAgICBpZiAoKHJlZmVycmVyLnByb3Rv Y29sSXMoImh0dHAiKSB8fCByZWZlcnJlci5wcm90b2NvbElzKCJodHRwcyIpKSAmJiByZWZlcnJl ci5wYXRoKCkuaXNFbXB0eSgpKQogICAgICAgICAgICAgcmVmZXJyZXIuc2V0UGF0aCgiLyIpOwog ICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyLnN0cmluZygp KTsKKyAgICAgICAgCisgICAgICAgIGlmIChyZXNvdXJjZUlzQ2FjaGVWYWxpZGF0b3IpIHsKKyAg ICAgICAgICAgIENhY2hlZFJlc291cmNlKiByZXNvdXJjZVRvUmV2YWxpZGF0ZSA9IHJlcXVlc3Qt PmNhY2hlZFJlc291cmNlKCktPnJlc291cmNlVG9SZXZhbGlkYXRlKCk7CisgICAgICAgICAgICBB U1NFUlQocmVzb3VyY2VUb1JldmFsaWRhdGUtPmNhblVzZUNhY2hlVmFsaWRhdG9yKCkpOworICAg ICAgICAgICAgQVNTRVJUKHJlc291cmNlVG9SZXZhbGlkYXRlLT5pc0xvYWRlZCgpKTsKKyAgICAg ICAgICAgIGNvbnN0IFN0cmluZyYgbGFzdE1vZGlmaWVkID0gcmVzb3VyY2VUb1JldmFsaWRhdGUt PnJlc3BvbnNlKCkuaHR0cEhlYWRlckZpZWxkKCJMYXN0LU1vZGlmaWVkIik7CisgICAgICAgICAg ICBjb25zdCBTdHJpbmcmIGVUYWcgPSByZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVzcG9uc2UoKS5o dHRwSGVhZGVyRmllbGQoIkVUYWciKTsKKyAgICAgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlz RW1wdHkoKSB8fCAhZVRhZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgICAgICBpZiAoZG9jTG9h ZGVyLT5jYWNoZVBvbGljeSgpID09IENhY2hlUG9saWN5UmVsb2FkIHx8IGRvY0xvYWRlci0+Y2Fj aGVQb2xpY3koKSA9PSBDYWNoZVBvbGljeVJlZnJlc2gpCisgICAgICAgICAgICAgICAgICAgIHJl c291cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIkNhY2hlLUNvbnRyb2wiLCAibWF4LWFn ZT0wIik7CisgICAgICAgICAgICAgICAgaWYgKCFsYXN0TW9kaWZpZWQuaXNFbXB0eSgpKQorICAg ICAgICAgICAgICAgICAgICByZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJJZi1N b2RpZmllZC1TaW5jZSIsIGxhc3RNb2RpZmllZCk7CisgICAgICAgICAgICAgICAgaWYgKCFlVGFn LmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBI ZWFkZXJGaWVsZCgiSWYtTm9uZS1NYXRjaCIsIGVUYWcpOworICAgICAgICAgICAgfQorICAgICAg ICB9CiAKICAgICAgICAgUmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBsb2FkZXIgPSBTdWJyZXNv dXJjZUxvYWRlcjo6Y3JlYXRlKGRvY0xvYWRlci0+ZG9jKCktPmZyYW1lKCksCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0aGlzLCByZXNvdXJjZVJlcXVlc3QsIHJlcXVlc3QtPnNob3VsZFNraXBDYW5Mb2FkQ2hlY2so KSwgcmVxdWVzdC0+c2VuZFJlc291cmNlTG9hZENhbGxiYWNrcygpKTsKQEAgLTI2OSw2ICsyODYs NyBAQCB2b2lkIExvYWRlcjo6SG9zdDo6ZGlkRmluaXNoTG9hZGluZyhTdWJyCiAgICAgICAgIGRv Y0xvYWRlci0+ZGVjcmVtZW50UmVxdWVzdENvdW50KCk7CiAKICAgICBDYWNoZWRSZXNvdXJjZSog cmVzb3VyY2UgPSByZXF1ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOworICAgIEFTU0VSVCghcmVzb3Vy Y2UtPnJlc291cmNlVG9SZXZhbGlkYXRlKCkpOwogCiAgICAgLy8gSWYgd2UgZ290IGEgNHh4IHJl c3BvbnNlLCB3ZSdyZSBwcmV0ZW5kaW5nIHRvIGhhdmUgcmVjZWl2ZWQgYSBuZXR3b3JrCiAgICAg Ly8gZXJyb3IsIHNvIHdlIGNhbid0IHNlbmQgdGhlIHN1Y2Nlc3NmdWwgZGF0YSgpIGFuZCBmaW5p c2goKSBjYWxsYmFja3MuCkBAIC0zMTEsNiArMzI5LDkgQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OmRp ZEZhaWwoU3VicmVzb3VyY2VMbwogICAgICAgICBkb2NMb2FkZXItPmRlY3JlbWVudFJlcXVlc3RD b3VudCgpOwogCiAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlID0gcmVxdWVzdC0+Y2FjaGVk UmVzb3VyY2UoKTsKKyAgICAKKyAgICBpZiAocmVzb3VyY2UtPnJlc291cmNlVG9SZXZhbGlkYXRl KCkpCisgICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGlvbkZhaWxlZChyZXNvdXJjZSk7CiAKICAg ICBpZiAoIWNhbmNlbGxlZCkgewogICAgICAgICBkb2NMb2FkZXItPnNldExvYWRJblByb2dyZXNz KHRydWUpOwpAQCAtMzQwLDcgKzM2MSwyNyBAQCB2b2lkIExvYWRlcjo6SG9zdDo6ZGlkUmVjZWl2 ZVJlc3BvbnNlKFN1CiAgICAgLy8gQVNTRVJUKHJlcXVlc3QpOwogICAgIGlmICghcmVxdWVzdCkK ICAgICAgICAgcmV0dXJuOwotICAgIHJlcXVlc3QtPmNhY2hlZFJlc291cmNlKCktPnNldFJlc3Bv bnNlKHJlc3BvbnNlKTsKKyAgICAKKyAgICBDYWNoZWRSZXNvdXJjZSogcmVzb3VyY2UgPSByZXF1 ZXN0LT5jYWNoZWRSZXNvdXJjZSgpOworICAgIAorICAgIGlmIChyZXNvdXJjZS0+aXNDYWNoZVZh bGlkYXRvcigpKSB7CisgICAgICAgIGlmIChyZXNwb25zZS5odHRwU3RhdHVzQ29kZSgpID09IDMw NCkgeworICAgICAgICAgICAgLy8gMzA0IE5vdCBtb2RpZmllZCAvIFVzZSBsb2NhbCBjb3B5Cisg ICAgICAgICAgICBtX3JlcXVlc3RzTG9hZGluZy5yZW1vdmUobG9hZGVyKTsKKyAgICAgICAgICAg IHJlcXVlc3QtPmRvY0xvYWRlcigpLT5kZWNyZW1lbnRSZXF1ZXN0Q291bnQoKTsKKworICAgICAg ICAgICAgLy8gRXhpc3RpbmcgcmVzb3VyY2UgaXMgb2ssIGp1c3QgdXNlIGl0IHVwZGF0aW5nIHRo ZSBleHBpcmF0aW9uIHRpbWUuCisgICAgICAgICAgICBjYWNoZSgpLT5yZXZhbGlkYXRpb25TdWNj ZWVkZWQocmVzb3VyY2UsIHJlc3BvbnNlKTsKKyAgICAgICAgICAgIGRlbGV0ZSByZXF1ZXN0Owor CisgICAgICAgICAgICBzZXJ2ZVBlbmRpbmdSZXF1ZXN0cygpOworICAgICAgICAgICAgcmV0dXJu OworICAgICAgICB9IAorICAgICAgICAvLyBEaWQgbm90IGdldCAzMDQgcmVzcG9uc2UsIGNvbnRp bnVlIGFzIGEgcmVndWxhciByZXNvdXJjZSBsb2FkLgorICAgICAgICBjYWNoZSgpLT5yZXZhbGlk YXRpb25GYWlsZWQocmVzb3VyY2UpOworICAgIH0KKyAgICAKKyAgICByZXNvdXJjZS0+c2V0UmVz cG9uc2UocmVzcG9uc2UpOwogICAgIAogICAgIFN0cmluZyBlbmNvZGluZyA9IHJlc3BvbnNlLnRl eHRFbmNvZGluZ05hbWUoKTsKICAgICBpZiAoIWVuY29kaW5nLmlzTnVsbCgpKQpAQCAtMzcxLDYg KzQxMiw4IEBAIHZvaWQgTG9hZGVyOjpIb3N0OjpkaWRSZWNlaXZlRGF0YShTdWJyZXMKICAgICAg ICAgcmV0dXJuOwogCiAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291cmNlID0gcmVxdWVzdC0+Y2Fj aGVkUmVzb3VyY2UoKTsgICAgCisgICAgQVNTRVJUKCFyZXNvdXJjZS0+aXNDYWNoZVZhbGlkYXRv cigpKTsKKyAgICAKICAgICBpZiAocmVzb3VyY2UtPmVycm9yT2NjdXJyZWQoKSkKICAgICAgICAg cmV0dXJuOwogICAgIApJbmRleDogV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9h ZGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNoZWV0TG9h ZGVyLmgJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9sb2FkZXIvbWFjL1VzZXJTdHlsZVNo ZWV0TG9hZGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDYgKzMwLDcgQEAKICNkZWZpbmUgVXNl clN0eWxlU2hlZXRMb2FkZXJfaAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIK KyNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogCiAjaW5jbHVkZSAiRG9jdW1lbnQu aCIKIApAQCAtNDgsNyArNDksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1 YWwgdm9pZCBzZXRDU1NTdHlsZVNoZWV0KGNvbnN0IFN0cmluZyYgVVJMLCBjb25zdCBTdHJpbmcm IGNoYXJzZXQsIGNvbnN0IENhY2hlZENTU1N0eWxlU2hlZXQqIHNoZWV0KTsKIAogICAgICAgICBS ZWZQdHI8RG9jdW1lbnQ+IG1fZG9jdW1lbnQ7Ci0gICAgICAgIENhY2hlZENTU1N0eWxlU2hlZXQq IG1fY2FjaGVkU2hlZXQ7CisgICAgICAgIENhY2hlZFJlc291cmNlSGFuZGxlPENhY2hlZENTU1N0 eWxlU2hlZXQ+IG1fY2FjaGVkU2hlZXQ7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTgxNSw3ICs4MTUsNyBAQCBD dXJzb3IgRXZlbnRIYW5kbGVyOjpzZWxlY3RDdXJzb3IoY29uc3QgCiAgICAgaWYgKHN0eWxlICYm IHN0eWxlLT5jdXJzb3JzKCkpIHsKICAgICAgICAgY29uc3QgQ3Vyc29yTGlzdCogY3Vyc29ycyA9 IHN0eWxlLT5jdXJzb3JzKCk7CiAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBjdXJz b3JzLT5zaXplKCk7ICsraSkgewotICAgICAgICAgICAgQ2FjaGVkSW1hZ2UqIGNpbWFnZSA9ICgq Y3Vyc29ycylbaV0uY3Vyc29ySW1hZ2U7CisgICAgICAgICAgICBDYWNoZWRJbWFnZSogY2ltYWdl ID0gKCpjdXJzb3JzKVtpXS5jdXJzb3JJbWFnZS5nZXQoKTsKICAgICAgICAgICAgIEludFBvaW50 IGhvdFNwb3QgPSAoKmN1cnNvcnMpW2ldLmhvdFNwb3Q7CiAgICAgICAgICAgICBpZiAoIWNpbWFn ZSkKICAgICAgICAgICAgICAgICBjb250aW51ZTsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckltYWdlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbWFn ZS5jcHAJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW1hZ2Uu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTYsNyArMTk2LDcgQEAgdm9pZCBSZW5kZXJJbWFnZTo6 c2V0Q2FjaGVkSW1hZ2UoQ2FjaGVkSQogICAgIGlmIChtX2NhY2hlZEltYWdlKSB7CiAgICAgICAg IG1fY2FjaGVkSW1hZ2UtPmFkZENsaWVudCh0aGlzKTsKICAgICAgICAgaWYgKG1fY2FjaGVkSW1h Z2UtPmVycm9yT2NjdXJyZWQoKSkKLSAgICAgICAgICAgIGltYWdlQ2hhbmdlZChtX2NhY2hlZElt YWdlKTsKKyAgICAgICAgICAgIGltYWdlQ2hhbmdlZChtX2NhY2hlZEltYWdlLmdldCgpKTsKICAg ICB9CiB9CiAKQEAgLTI1OSw3ICsyNTksNyBAQCB2b2lkIFJlbmRlckltYWdlOjppbWFnZUNoYW5n ZWQoV3JhcHBlZEltCiAKICAgICAvLyBTZXQgaW1hZ2UgZGltZW5zaW9ucywgdGFraW5nIGludG8g YWNjb3VudCB0aGUgc2l6ZSBvZiB0aGUgYWx0IHRleHQuCiAgICAgaWYgKGVycm9yT2NjdXJyZWQo KSkKLSAgICAgICAgaW1hZ2VTaXplQ2hhbmdlZCA9IHNldEltYWdlU2l6ZUZvckFsdFRleHQobV9j YWNoZWRJbWFnZSk7CisgICAgICAgIGltYWdlU2l6ZUNoYW5nZWQgPSBzZXRJbWFnZVNpemVGb3JB bHRUZXh0KG1fY2FjaGVkSW1hZ2UuZ2V0KCkpOwogICAgIAogICAgIGJvb2wgc2hvdWxkUmVwYWlu dCA9IHRydWU7CiAKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckltYWdlLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW1hZ2UuaAkocmV2aXNpb24gMzU5MjEp CisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbWFnZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0y Niw2ICsyNiw3IEBACiAjZGVmaW5lIFJlbmRlckltYWdlX2gKIAogI2luY2x1ZGUgIkNhY2hlZElt YWdlLmgiCisjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJSZW5k ZXJSZXBsYWNlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC01Myw3ICs1NCw3IEBAIHB1 YmxpYzoKICAgICB2b2lkIHVwZGF0ZUFsdFRleHQoKTsKIAogICAgIHZvaWQgc2V0Q2FjaGVkSW1h Z2UoQ2FjaGVkSW1hZ2UqKTsKLSAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UoKSBjb25zdCB7 IHJldHVybiBtX2NhY2hlZEltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlKCkg Y29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCBib29s IG5vZGVBdFBvaW50KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiwgSGl0VGVzdFJlc3VsdCYsIGludCB4 LCBpbnQgeSwgaW50IHR4LCBpbnQgdHksIEhpdFRlc3RBY3Rpb24pOwogCkBAIC03OCw3ICs3OSw3 IEBAIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGJvb2wgaW1hZ2VIYXNSZWxhdGl2ZVdpZHRoKCkg Y29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZSA/IG1fY2FjaGVkSW1hZ2UtPmltYWdlSGFzUmVs YXRpdmVXaWR0aCgpIDogZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgaW1hZ2VIYXNSZWxhdGl2 ZUhlaWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fY2FjaGVkSW1hZ2UgPyBtX2NhY2hlZEltYWdlLT5p bWFnZUhhc1JlbGF0aXZlSGVpZ2h0KCkgOiBmYWxzZTsgfQogICAgIHZpcnR1YWwgSW50U2l6ZSBp bWFnZVNpemUoZmxvYXQgbXVsdGlwbGllcikgY29uc3QgeyByZXR1cm4gbV9jYWNoZWRJbWFnZSA/ IG1fY2FjaGVkSW1hZ2UtPmltYWdlU2l6ZShtdWx0aXBsaWVyKSA6IEludFNpemUoKTsgfQotICAg IHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGltYWdlUHRyKCkgY29uc3QgeyByZXR1cm4gbV9jYWNo ZWRJbWFnZTsgfQorICAgIHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGltYWdlUHRyKCkgY29uc3Qg eyByZXR1cm4gbV9jYWNoZWRJbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCB2b2lkIGludHJp bnNpY1NpemVDaGFuZ2VkKCkgeyBpbWFnZUNoYW5nZWQoaW1hZ2VQdHIoKSk7IH0KIApAQCAtOTEs NyArOTIsNyBAQCBwcml2YXRlOgogCiBwcm90ZWN0ZWQ6CiAgICAgLy8gVGhlIGltYWdlIHdlIGFy ZSByZW5kZXJpbmcuCi0gICAgQ2FjaGVkSW1hZ2UqIG1fY2FjaGVkSW1hZ2U7CisgICAgQ2FjaGVk UmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IG1fY2FjaGVkSW1hZ2U7CiAKICAgICAvLyBUZXh0 IHRvIGRpc3BsYXkgYXMgbG9uZyBhcyB0aGUgaW1hZ2UgaXNuJ3QgYXZhaWxhYmxlLgogICAgIFN0 cmluZyBtX2FsdFRleHQ7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHls ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmgJ KHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUu aAkod29ya2luZyBjb3B5KQpAQCAtNDAsNiArNDAsOCBAQAogI2luY2x1ZGUgIkNTU1ByaW1pdGl2 ZVZhbHVlLmgiCiAjaW5jbHVkZSAiQ1NTUmVmbGVjdGlvbkRpcmVjdGlvbi5oIgogI2luY2x1ZGUg IkNTU1ZhbHVlTGlzdC5oIgorI2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCisjaW5jbHVkZSAiQ2Fj aGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUgIkRhdGFS ZWYuaCIKICNpbmNsdWRlICJGbG9hdFBvaW50LmgiCkBAIC0xNjQsMTMgKzE2NiwxMyBAQCBjbGFz cyBTdHlsZUNhY2hlZEltYWdlIDogcHVibGljIFN0eWxlSW1hCiB7CiBwdWJsaWM6CiAgICAgc3Rh dGljIFBhc3NSZWZQdHI8U3R5bGVDYWNoZWRJbWFnZT4gY3JlYXRlKENhY2hlZEltYWdlKiBpbWFn ZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFN0eWxlQ2FjaGVkSW1hZ2UoaW1hZ2UpKTsgfQotICAg IHZpcnR1YWwgV3JhcHBlZEltYWdlUHRyIGRhdGEoKSBjb25zdCB7IHJldHVybiBtX2ltYWdlOyB9 CisgICAgdmlydHVhbCBXcmFwcGVkSW1hZ2VQdHIgZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1faW1h Z2UuZ2V0KCk7IH0KIAogICAgIHZpcnR1YWwgYm9vbCBpc0NhY2hlZEltYWdlKCkgY29uc3QgeyBy ZXR1cm4gdHJ1ZTsgfQogICAgIAogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxDU1NWYWx1ZT4gY3Nz VmFsdWUoKTsKICAgICAKLSAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UoKSBjb25zdCB7IHJl dHVybiBtX2ltYWdlOyB9CisgICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlKCkgY29uc3QgeyBy ZXR1cm4gbV9pbWFnZS5nZXQoKTsgfQogCiAgICAgdmlydHVhbCBib29sIGNhblJlbmRlcihmbG9h dCBtdWx0aXBsaWVyKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNMb2FkZWQoKSBjb25zdDsK QEAgLTE5MCw3ICsxOTIsNyBAQCBwcml2YXRlOgogICAgIHsKICAgICB9CiAgICAgCi0gICAgQ2Fj aGVkSW1hZ2UqIG1faW1hZ2U7CisgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2FjaGVkSW1hZ2U+ IG1faW1hZ2U7CiB9OwogCiBjbGFzcyBTdHlsZUdlbmVyYXRlZEltYWdlIDogcHVibGljIFN0eWxl SW1hZ2UKQEAgLTE1OTcsNyArMTU5OSw3IEBAIHN0cnVjdCBDdXJzb3JEYXRhIHsKICAgICBib29s IG9wZXJhdG9yIT0oY29uc3QgQ3Vyc29yRGF0YSYgbykgY29uc3QgeyByZXR1cm4gISgqdGhpcyA9 PSBvKTsgfQogCiAgICAgSW50UG9pbnQgaG90U3BvdDsgLy8gZm9yIENTUzMgc3VwcG9ydAotICAg IENhY2hlZEltYWdlKiBjdXJzb3JJbWFnZTsgLy8gd2VhayBwb2ludGVyLCB0aGUgQ1NTVmFsdWVJ bWFnZSB0YWtlcyBjYXJlIG9mIGRlbGV0aW5nIGN1cnNvckltYWdlCisgICAgQ2FjaGVkUmVzb3Vy Y2VIYW5kbGU8Q2FjaGVkSW1hZ2U+IGN1cnNvckltYWdlOwogfTsKIAogY2xhc3MgQ3Vyc29yTGlz dCA6IHB1YmxpYyBSZWZDb3VudGVkPEN1cnNvckxpc3Q+IHsKSW5kZXg6IFdlYkNvcmUvc3ZnL1NW R0ZFSW1hZ2VFbGVtZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHRkVJbWFnZUVs ZW1lbnQuaAkocmV2aXNpb24gMzU5MjEpCisrKyBXZWJDb3JlL3N2Zy9TVkdGRUltYWdlRWxlbWVu dC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNCw2ICsyNCw3IEBACiAjZGVmaW5lIFNWR0ZFSW1hZ2VF bGVtZW50X2gKIAogI2lmIEVOQUJMRShTVkcpICYmIEVOQUJMRShTVkdfRklMVEVSUykKKyNpbmNs dWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNWR0ZpbHRlclByaW1pdGl2 ZVN0YW5kYXJkQXR0cmlidXRlcy5oIgogI2luY2x1ZGUgIlNWR1VSSVJlZmVyZW5jZS5oIgogI2lu Y2x1ZGUgIlNWR0xhbmdTcGFjZS5oIgpAQCAtNTUsNyArNTYsNyBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgQU5JTUFURURfUFJPUEVSVFlfREVDTEFSQVRJT05T KFNWR0ZFSW1hZ2VFbGVtZW50LCBTVkdOYW1lczo6ZmVJbWFnZVRhZ1N0cmluZywgU1ZHTmFtZXM6 OnByZXNlcnZlQXNwZWN0UmF0aW9BdHRyU3RyaW5nLCBTVkdQcmVzZXJ2ZUFzcGVjdFJhdGlvLCBQ cmVzZXJ2ZUFzcGVjdFJhdGlvLCBwcmVzZXJ2ZUFzcGVjdFJhdGlvKQogCi0gICAgICAgIENhY2hl ZEltYWdlKiBtX2NhY2hlZEltYWdlOworICAgICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNo ZWRJbWFnZT4gbV9jYWNoZWRJbWFnZTsKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8RkVJbWFnZT4g bV9maWx0ZXJFZmZlY3Q7CiAgICAgfTsKIApJbmRleDogV2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmls dGVycy9TVkdGRUltYWdlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvZ3JhcGhpY3MvZmls dGVycy9TVkdGRUltYWdlLmgJKHJldmlzaW9uIDM1OTIxKQorKysgV2ViQ29yZS9zdmcvZ3JhcGhp Y3MvZmlsdGVycy9TVkdGRUltYWdlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI1LDYgKzI1LDcgQEAK ICNpZiBFTkFCTEUoU1ZHKSAmJiBFTkFCTEUoU1ZHX0ZJTFRFUlMpCiAjaW5jbHVkZSAiQ2FjaGVk SW1hZ2UuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgorI2luY2x1ZGUgIkNh Y2hlZFJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiRmlsdGVyRWZmZWN0LmgiCiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKQEAgLTQ3LDcgKzQ4LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg IHByaXZhdGU6CiAgICAgICAgIEZFSW1hZ2UoQ2FjaGVkSW1hZ2UqKTsKIAotICAgICAgICBDYWNo ZWRJbWFnZSogbV9jYWNoZWRJbWFnZTsKKyAgICAgICAgQ2FjaGVkUmVzb3VyY2VIYW5kbGU8Q2Fj aGVkSW1hZ2U+IG1fY2FjaGVkSW1hZ2U7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpJbmRleDogV2ViQ29yZS94bWwvWFNMSW1wb3J0UnVsZS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUveG1sL1hTTEltcG9ydFJ1bGUuaAkocmV2aXNpb24gMzU5MjEpCisrKyBXZWJDb3JlL3htbC9Y U0xJbXBvcnRSdWxlLmgJKHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNpZiBFTkFC TEUoWFNMVCkKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAi Q2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJTdHlsZUJhc2UuaCIKICNpbmNsdWRl ICJYU0xTdHlsZVNoZWV0LmgiCiAKQEAgLTYwLDcgKzYxLDcgQEAgcHJpdmF0ZToKICAgICAKICAg ICBTdHJpbmcgbV9zdHJIcmVmOwogICAgIFJlZlB0cjxYU0xTdHlsZVNoZWV0PiBtX3N0eWxlU2hl ZXQ7Ci0gICAgQ2FjaGVkWFNMU3R5bGVTaGVldCogbV9jYWNoZWRTaGVldDsKKyAgICBDYWNoZWRS ZXNvdXJjZUhhbmRsZTxDYWNoZWRYU0xTdHlsZVNoZWV0PiBtX2NhY2hlZFNoZWV0OwogICAgIGJv b2wgbV9sb2FkaW5nOwogfTsKIAo= 25045 2008-11-11 02:51:58 -0800 2008-11-11 14:30:23 -0800 WebCore patch for enabling revalidation on reload reload-webcore-2.patch text/plain 28076 koivisto SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzODI5OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTkgQEAKKzIwMDgtMTEtMTEgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdo ZW4gYSByZXNvdXJjZSBpcyBjYWNoZWQgbG9jYWxseSwgV2ViS2l0IHNob3VsZCBmb2xsb3cgUkZD IDI2MTYgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBpbnN0ZWFkIG9mICJVbnNw ZWNpZmllZCBlbmQtdG8tZW5kIHJldmFsaWRhdGlvbiIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3OTk4IAorICAgICAgICAKKyAgICAgICAgLSBFbmFi bGUgY29uZGl0aW9uYWwgcmV2YWxpZGF0aW9uIGZvciByZWxvYWRzIGJ5IGRlZmF1bHQuIAorICAg ICAgICAtIEFkZCBhIHBhcmFtZXRlciB0byBGcmFtZUxvYWRlcjo6cmVsb2FkKCkgZm9yIGZvcmNp bmcgZW5kLXRvLWVuZCByZWxvYWQuCisgICAgICAgIC0gRm9yIHNpbXBsaWNpdHkgcmVtb3ZlIG1f Y2FjaGVQb2xpY3kgdmFyaWFibGVzIGZyb20gRnJhbWVMb2FkZXIgYW5kIERvY0xvYWRlciwgaW5z dGVhZCBzeW50aGV6aXNlIHRoZSBwb2xpY3kgb24gZGVtYW5kLgorICAgICAgICAKKyAgICAgICAg VGhpcyBzcGVlZHMgdXAgcmVsb2FkcyBhbmQgbWFrZXMgdGhlbSB1c2Ugd2F5IGxlc3MgYmFuZHdp ZHRoLgorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDoKKyAgICAgICAgKiBsb2FkZXIvQ2Fj aGVQb2xpY3kuaDogUmVuYW1lIENhY2hlUG9saWN5UmVmcmVzaCB0byBDYWNoZVBvbGljeVJldmFs aWRhdGUKKyAgICAgICAgKFdlYkNvcmU6Oik6CisgICAgICAgICogbG9hZGVyL0RvY0xvYWRlci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpEb2NMb2FkZXI6OkRvY0xvYWRlcik6CisgICAgICAgIChX ZWJDb3JlOjpEb2NMb2FkZXI6OmNoZWNrRm9yUmVsb2FkKTogU3VwcG9ydCBDYWNoZVBvbGljeVJl dmFsaWRhdGUuCisgICAgICAgIChXZWJDb3JlOjpEb2NMb2FkZXI6OnJlcXVlc3RSZXNvdXJjZSk6 CisgICAgICAgIChXZWJDb3JlOjpEb2NMb2FkZXI6OmNhY2hlUG9saWN5KToKKyAgICAgICAgKiBs b2FkZXIvRG9jTG9hZGVyLmg6IEdldCByaWQgb2YgbV9jYWNoZVBvbGljeSBtZW1iZXIuIAorICAg ICAgICAqIGxvYWRlci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTY2hlZHVs ZWRSZWRpcmVjdGlvbjo6U2NoZWR1bGVkUmVkaXJlY3Rpb24pOiBBZGQgcGFyYW1ldGVyIHRvIGRp ZmZlcmVudGlhdGUgcmVmcmVzaCBmcm9tIG90aGVyIHR5cGVzIG9mIHJlZGlyZWN0cy4KKyAgICAg ICAgKFdlYkNvcmU6OmlzQmFja0ZvcndhcmRMb2FkVHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpG cmFtZUxvYWRlcjo6RnJhbWVMb2FkZXIpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6 OmNoYW5nZUxvY2F0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpzdG9wTG9h ZGluZyk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6cmVjZWl2ZWRGaXJzdERhdGEp OgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OndyaXRlKToKKyAgICAgICAgKFdlYkNv cmU6OkZyYW1lTG9hZGVyOjpzdGFydEljb25Mb2FkZXIpOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVMb2FkZXI6OnJlc3RvcmVEb2N1bWVudFN0YXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1l TG9hZGVyOjpzY2hlZHVsZUhUVFBSZWRpcmVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlcjo6c2NoZWR1bGVMb2NhdGlvbkNoYW5nZSk6CisgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlcjo6c2NoZWR1bGVSZWZyZXNoKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVy OjpyZWRpcmVjdGlvblRpbWVyRmlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6 OmNhbkNhY2hlUGFnZSk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6bG9hZFVSTCk6 CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6cmVsb2FkKTogRGlmZmVyZW50aWF0ZSBi ZXR3ZWVuIHJldmFsaWRhdGlvbiBhbmQgcmVsb2FkLgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVM b2FkZXI6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxv YWRlcjo6Y2FjaGVQb2xpY3kpOiBEZXRlcm1pbmUgdGhlIGNhY2hlIHBvbGljeSBiYXNlZCBvbiBj dXJyZW50IGxvYWQgdHlwZS4gCisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6Y2hlY2tM b2FkQ29tcGxldGVGb3JUaGlzRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6 OmFkZEV4dHJhRmllbGRzVG9SZXF1ZXN0KTogU2V0IENhY2hlLWNvbnRyb2w6IG5vLWNhY2hlIGZv ciBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVM b2FkZXI6OnNob3VsZFNjcm9sbFRvQW5jaG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9h ZGVyOjpsb2FkSXRlbSk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6dXBkYXRlSGlz dG9yeUZvclJlbG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6dXBkYXRlSGlz dG9yeUZvckNvbW1pdCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6c3dpdGNoT3V0 TG93QmFuZHdpZHRoRGlzcGxheUlmUmVhZHkpOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRl ci5oOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlclR5cGVzLmg6IEFkZCBGcmFtZUxvYWRU eXBlUmVsb2FkRnJvbU9yaWdpbgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKiBsb2Fk ZXIvTmF2aWdhdGlvbkFjdGlvbi5jcHA6IAorICAgICAgICAoV2ViQ29yZTo6bmF2aWdhdGlvblR5 cGUpOiAgU3VwcG9ydCBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbgorICAgICAgICAqIGxv YWRlci9sb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TG9hZGVyOjpIb3N0OjpzZXJ2ZVBl bmRpbmdSZXF1ZXN0cyk6CisKIDIwMDgtMTEtMTAgIFN0ZXBoYW5pZSBMZXdpcyAgPHNsZXdpc0Bh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5kZXg6IFdl YkNvcmUvV2ViQ29yZS5iYXNlLmV4cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNvcmUuYmFz ZS5leHAJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCSh3b3Jr aW5nIGNvcHkpCkBAIC0xNzAsNyArMTcwLDcgQEAgX19aTjdXZWJDb3JlMTFGcmFtZUxvYWRlcjRs b2FkRVBOU18xNERvYwogX19aTjdXZWJDb3JlMTFGcmFtZUxvYWRlcjRsb2FkRVJLTlNfMTVSZXNv dXJjZVJlcXVlc3RFCiBfX1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyNGxvYWRFUktOU18xNVJlc291 cmNlUmVxdWVzdEVSS05TXzE0U3Vic3RpdHV0ZURhdGFFCiBfX1pON1dlYkNvcmUxMUZyYW1lTG9h ZGVyNGxvYWRFUktOU18xNVJlc291cmNlUmVxdWVzdEVSS05TXzZTdHJpbmdFCi1fX1pON1dlYkNv cmUxMUZyYW1lTG9hZGVyNnJlbG9hZEV2CitfX1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyNnJlbG9h ZEViCiBfX1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyN2FkZERhdGFFUEtjaQogX19aTjdXZWJDb3Jl MTFGcmFtZUxvYWRlcjdjYW5Mb2FkRVJLTlNfNEtVUkxFUktOU182U3RyaW5nRVBLTlNfOERvY3Vt ZW50RQogX19aTjdXZWJDb3JlMTFIaXN0b3J5SXRlbTEyYWRkQ2hpbGRJdGVtRU4zV1RGMTBQYXNz UmVmUHRySVMwX0VFCkluZGV4OiBXZWJDb3JlL2xvYWRlci9DYWNoZVBvbGljeS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0NhY2hlUG9saWN5LmgJKHJldmlzaW9uIDM4MjA5KQorKysg V2ViQ29yZS9sb2FkZXIvQ2FjaGVQb2xpY3kuaAkod29ya2luZyBjb3B5KQpAQCAtMzEsNyArMzEs NyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgZW51bSBDYWNoZVBvbGljeSB7CiAgICAgICAg IENhY2hlUG9saWN5Q2FjaGUsCiAgICAgICAgIENhY2hlUG9saWN5VmVyaWZ5LAotICAgICAgICBD YWNoZVBvbGljeVJlZnJlc2gsCisgICAgICAgIENhY2hlUG9saWN5UmV2YWxpZGF0ZSwKICAgICAg ICAgQ2FjaGVQb2xpY3lSZWxvYWQKICAgICB9OwogCkluZGV4OiBXZWJDb3JlL2xvYWRlci9Eb2NM b2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5jcHAJKHJl dmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIvRG9jTG9hZGVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNDgsNyArNDgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIERvY0xvYWRlcjo6 RG9jTG9hZGVyKERvY3VtZW50KiBkb2MpCiAgICAgOiBtX2NhY2hlKGNhY2hlKCkpCi0gICAgLCBt X2NhY2hlUG9saWN5KENhY2hlUG9saWN5VmVyaWZ5KQogICAgICwgbV9kb2MoZG9jKQogICAgICwg bV9yZXF1ZXN0Q291bnQoMCkKICAgICAsIG1fYXV0b0xvYWRJbWFnZXModHJ1ZSkKQEAgLTc5LDI0 ICs3OCwyOCBAQCB2b2lkIERvY0xvYWRlcjo6Y2hlY2tGb3JSZWxvYWQoY29uc3QgS1VSCiAKICAg ICBpZiAoZnVsbFVSTC5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybjsKLQotICAgIGlmIChtX2Nh Y2hlUG9saWN5ID09IENhY2hlUG9saWN5VmVyaWZ5IHx8IG1fY2FjaGVQb2xpY3kgPT0gQ2FjaGVQ b2xpY3lDYWNoZSkgewotICAgICAgIGlmICghbV9yZWxvYWRlZFVSTHMuY29udGFpbnMoZnVsbFVS TC5zdHJpbmcoKSkpIHsKLSAgICAgICAgICBDYWNoZWRSZXNvdXJjZSogZXhpc3RpbmcgPSBjYWNo ZSgpLT5yZXNvdXJjZUZvclVSTChmdWxsVVJMLnN0cmluZygpKTsKLSAgICAgICAgICBpZiAoZXhp c3RpbmcgJiYgIWV4aXN0aW5nLT5pc1ByZWxvYWRlZCgpICYmIGV4aXN0aW5nLT5tdXN0UmV2YWxp ZGF0ZShtX2NhY2hlUG9saWN5KSkgewotICAgICAgICAgICAgICBjYWNoZSgpLT5yZXZhbGlkYXRl UmVzb3VyY2UoZXhpc3RpbmcsIHRoaXMpOwotICAgICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5h ZGQoZnVsbFVSTC5zdHJpbmcoKSk7Ci0gICAgICAgICAgfQotICAgICAgIH0KLSAgICB9IGVsc2Ug aWYgKChtX2NhY2hlUG9saWN5ID09IENhY2hlUG9saWN5UmVsb2FkKSB8fCAobV9jYWNoZVBvbGlj eSA9PSBDYWNoZVBvbGljeVJlZnJlc2gpKSB7Ci0gICAgICAgaWYgKCFtX3JlbG9hZGVkVVJMcy5j b250YWlucyhmdWxsVVJMLnN0cmluZygpKSkgewotICAgICAgICAgICBDYWNoZWRSZXNvdXJjZSog ZXhpc3RpbmcgPSBjYWNoZSgpLT5yZXNvdXJjZUZvclVSTChmdWxsVVJMLnN0cmluZygpKTsKLSAg ICAgICAgICAgaWYgKGV4aXN0aW5nICYmICFleGlzdGluZy0+aXNQcmVsb2FkZWQoKSkgewotICAg ICAgICAgICAgICAgLy8gRklYTUU6IFVzZSByZXZhbGlkYXRlUmVzb3VyY2UoKSB0byBpbXBsZW1l bnQgSFRUUCAxLjEgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBmb3IgcmVndWxh ciByZWxvYWRpbmcKLSAgICAgICAgICAgICAgIGNhY2hlKCktPnJlbW92ZShleGlzdGluZyk7Ci0g ICAgICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5hZGQoZnVsbFVSTC5zdHJpbmcoKSk7Ci0gICAg ICAgICAgIH0KLSAgICAgICB9CisgICAgCisgICAgaWYgKG1fcmVsb2FkZWRVUkxzLmNvbnRhaW5z KGZ1bGxVUkwuc3RyaW5nKCkpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgQ2FjaGVQb2xp Y3kgY2FjaGVQb2xpY3kgPSB0aGlzLT5jYWNoZVBvbGljeSgpOworICAgIGlmIChjYWNoZVBvbGlj eSA9PSBDYWNoZVBvbGljeVZlcmlmeSB8fCBjYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeUNhY2hl KSB7CisgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGluZyA9IGNhY2hlKCktPnJlc291cmNl Rm9yVVJMKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAgICBpZiAoZXhpc3RpbmcgJiYgIWV4aXN0 aW5nLT5pc1ByZWxvYWRlZCgpICYmIGV4aXN0aW5nLT5tdXN0UmV2YWxpZGF0ZShjYWNoZVBvbGlj eSkpIHsKKyAgICAgICAgICAgIGNhY2hlKCktPnJldmFsaWRhdGVSZXNvdXJjZShleGlzdGluZywg dGhpcyk7CisgICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5hZGQoZnVsbFVSTC5zdHJpbmcoKSk7 CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBpZiAoY2FjaGVQb2xpY3kg PT0gQ2FjaGVQb2xpY3lSZWxvYWQgfHwgY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lSZXZhbGlk YXRlKSB7CisgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGluZyA9IGNhY2hlKCktPnJlc291 cmNlRm9yVVJMKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAgICBpZiAoZXhpc3RpbmcgJiYgIWV4 aXN0aW5nLT5pc1ByZWxvYWRlZCgpKSB7CisgICAgICAgICAgICBpZiAoY2FjaGVQb2xpY3kgPT0g Q2FjaGVQb2xpY3lSZWxvYWQpCisgICAgICAgICAgICAgICAgY2FjaGUoKS0+cmVtb3ZlKGV4aXN0 aW5nKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBjYWNoZSgpLT5yZXZhbGlk YXRlUmVzb3VyY2UoZXhpc3RpbmcsIHRoaXMpOworICAgICAgICAgICAgbV9yZWxvYWRlZFVSTHMu YWRkKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAgICB9CiAgICAgfQogfQogCkBAIC0xOTMsOSAr MTk2LDYgQEAgQ2FjaGVkUmVzb3VyY2UqIERvY0xvYWRlcjo6cmVxdWVzdFJlc291cgogICAgICAg ICB9CiAgICAgfQogCi0gICAgaWYgKGZyYW1lKCkgJiYgZnJhbWUoKS0+bG9hZGVyKCktPmlzUmVs b2FkaW5nKCkpCi0gICAgICAgIHNldENhY2hlUG9saWN5KENhY2hlUG9saWN5UmVsb2FkKTsKLQog ICAgIGNoZWNrRm9yUmVsb2FkKGZ1bGxVUkwpOwogCiAgICAgQ2FjaGVkUmVzb3VyY2UqIHJlc291 cmNlID0gY2FjaGUoKS0+cmVxdWVzdFJlc291cmNlKHRoaXMsIHR5cGUsIGZ1bGxVUkwsIGNoYXJz ZXQsIGlzUHJlbG9hZCk7CkBAIC0yNTcsOSArMjU3LDkgQEAgdm9pZCBEb2NMb2FkZXI6OnNldEF1 dG9Mb2FkSW1hZ2VzKGJvb2wgZQogICAgIH0KIH0KIAotdm9pZCBEb2NMb2FkZXI6OnNldENhY2hl UG9saWN5KENhY2hlUG9saWN5IGNhY2hlUG9saWN5KQorQ2FjaGVQb2xpY3kgRG9jTG9hZGVyOjpj YWNoZVBvbGljeSgpIGNvbnN0CiB7Ci0gICAgbV9jYWNoZVBvbGljeSA9IGNhY2hlUG9saWN5Owor ICAgIHJldHVybiBmcmFtZSgpID8gZnJhbWUoKS0+bG9hZGVyKCktPmNhY2hlUG9saWN5KCkgOiBD YWNoZVBvbGljeVZlcmlmeTsKIH0KIAogdm9pZCBEb2NMb2FkZXI6OnJlbW92ZUNhY2hlZFJlc291 cmNlKENhY2hlZFJlc291cmNlKiByZXNvdXJjZSkgY29uc3QKSW5kZXg6IFdlYkNvcmUvbG9hZGVy L0RvY0xvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5oCShy ZXZpc2lvbiAzODIwOSkKKysrIFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5oCSh3b3JraW5nIGNv cHkpCkBAIC03Niw4ICs3Niw3IEBAIHB1YmxpYzoKICAgICBib29sIGF1dG9Mb2FkSW1hZ2VzKCkg Y29uc3QgeyByZXR1cm4gbV9hdXRvTG9hZEltYWdlczsgfQogICAgIHZvaWQgc2V0QXV0b0xvYWRJ bWFnZXMoYm9vbCk7CiAgICAgCi0gICAgQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3koKSBjb25zdCB7 IHJldHVybiBtX2NhY2hlUG9saWN5OyB9Ci0gICAgdm9pZCBzZXRDYWNoZVBvbGljeShDYWNoZVBv bGljeSk7CisgICAgQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3koKSBjb25zdDsKICAgICAKICAgICBG cmFtZSogZnJhbWUoKSBjb25zdDsgLy8gQ2FuIGJlIE5VTEwKICAgICBEb2N1bWVudCogZG9jKCkg Y29uc3QgeyByZXR1cm4gbV9kb2M7IH0KQEAgLTExMyw3ICsxMTIsNiBAQCBwcml2YXRlOgogICAg IENhY2hlKiBtX2NhY2hlOwogICAgIEhhc2hTZXQ8U3RyaW5nPiBtX3JlbG9hZGVkVVJMczsKICAg ICBtdXRhYmxlIEhhc2hNYXA8U3RyaW5nLCBDYWNoZWRSZXNvdXJjZSo+IG1fZG9jUmVzb3VyY2Vz OwotICAgIENhY2hlUG9saWN5IG1fY2FjaGVQb2xpY3k7CiAgICAgRG9jdW1lbnQqIG1fZG9jOwog ICAgIAogICAgIGludCBtX3JlcXVlc3RDb3VudDsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0ZyYW1l TG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAJ KHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0xNDgsMjAgKzE0OCwyMiBAQCBzdHJ1Y3QgU2NoZWR1bGVkUmVkaXJlY3Rp b24gewogICAgIGludCBoaXN0b3J5U3RlcHM7CiAgICAgYm9vbCBsb2NrSGlzdG9yeTsKICAgICBi b29sIHdhc1VzZXJHZXN0dXJlOworICAgIGJvb2wgd2FzUmVmcmVzaDsKIAotICAgIFNjaGVkdWxl ZFJlZGlyZWN0aW9uKGRvdWJsZSByZWRpcmVjdERlbGF5LCBjb25zdCBTdHJpbmcmIHJlZGlyZWN0 VVJMLCBib29sIHJlZGlyZWN0TG9ja0hpc3RvcnksIGJvb2wgdXNlckdlc3R1cmUpCisgICAgU2No ZWR1bGVkUmVkaXJlY3Rpb24oZG91YmxlIHJlZGlyZWN0RGVsYXksIGNvbnN0IFN0cmluZyYgcmVk aXJlY3RVUkwsIGJvb2wgcmVkaXJlY3RMb2NrSGlzdG9yeSwgYm9vbCB1c2VyR2VzdHVyZSwgYm9v bCByZWZyZXNoKQogICAgICAgICA6IHR5cGUocmVkaXJlY3Rpb24pCiAgICAgICAgICwgZGVsYXko cmVkaXJlY3REZWxheSkKICAgICAgICAgLCB1cmwocmVkaXJlY3RVUkwpCiAgICAgICAgICwgaGlz dG9yeVN0ZXBzKDApCiAgICAgICAgICwgbG9ja0hpc3RvcnkocmVkaXJlY3RMb2NrSGlzdG9yeSkK ICAgICAgICAgLCB3YXNVc2VyR2VzdHVyZSh1c2VyR2VzdHVyZSkKKyAgICAgICAgLCB3YXNSZWZy ZXNoKHJlZnJlc2gpCiAgICAgewogICAgIH0KIAogICAgIFNjaGVkdWxlZFJlZGlyZWN0aW9uKFR5 cGUgbG9jYXRpb25DaGFuZ2VUeXBlLAogICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBsb2NhdGlv bkNoYW5nZVVSTCwgY29uc3QgU3RyaW5nJiBsb2NhdGlvbkNoYW5nZVJlZmVycmVyLAotICAgICAg ICAgICAgYm9vbCBsb2NhdGlvbkNoYW5nZUxvY2tIaXN0b3J5LCBib29sIGxvY2F0aW9uQ2hhbmdl V2FzVXNlckdlc3R1cmUpCisgICAgICAgICAgICBib29sIGxvY2F0aW9uQ2hhbmdlTG9ja0hpc3Rv cnksIGJvb2wgbG9jYXRpb25DaGFuZ2VXYXNVc2VyR2VzdHVyZSwgYm9vbCByZWZyZXNoKQogICAg ICAgICA6IHR5cGUobG9jYXRpb25DaGFuZ2VUeXBlKQogICAgICAgICAsIGRlbGF5KDApCiAgICAg ICAgICwgdXJsKGxvY2F0aW9uQ2hhbmdlVVJMKQpAQCAtMTY5LDYgKzE3MSw3IEBAIHN0cnVjdCBT Y2hlZHVsZWRSZWRpcmVjdGlvbiB7CiAgICAgICAgICwgaGlzdG9yeVN0ZXBzKDApCiAgICAgICAg ICwgbG9ja0hpc3RvcnkobG9jYXRpb25DaGFuZ2VMb2NrSGlzdG9yeSkKICAgICAgICAgLCB3YXNV c2VyR2VzdHVyZShsb2NhdGlvbkNoYW5nZVdhc1VzZXJHZXN0dXJlKQorICAgICAgICAsIHdhc1Jl ZnJlc2gocmVmcmVzaCkKICAgICB7CiAgICAgfQogCkBAIC0xNzgsNiArMTgxLDcgQEAgc3RydWN0 IFNjaGVkdWxlZFJlZGlyZWN0aW9uIHsKICAgICAgICAgLCBoaXN0b3J5U3RlcHMoaGlzdG9yeU5h dmlnYXRpb25TdGVwcykKICAgICAgICAgLCBsb2NrSGlzdG9yeShmYWxzZSkKICAgICAgICAgLCB3 YXNVc2VyR2VzdHVyZShmYWxzZSkKKyAgICAgICAgLCB3YXNSZWZyZXNoKGZhbHNlKQogICAgIHsK ICAgICB9CiB9OwpAQCAtMjAzLDYgKzIwNyw3IEBAIGJvb2wgaXNCYWNrRm9yd2FyZExvYWRUeXBl KEZyYW1lTG9hZFR5cGUKICAgICAgICAgY2FzZSBGcmFtZUxvYWRUeXBlU3RhbmRhcmQ6CiAgICAg ICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9hZDoKICAgICAgICAgY2FzZSBGcmFtZUxvYWRUeXBl UmVsb2FkQWxsb3dpbmdTdGFsZURhdGE6CisgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9h ZEZyb21PcmlnaW46CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVNhbWU6CiAgICAgICAgIGNh c2UgRnJhbWVMb2FkVHlwZVJlZGlyZWN0V2l0aExvY2tlZEhpc3Rvcnk6CiAgICAgICAgIGNhc2Ug RnJhbWVMb2FkVHlwZVJlcGxhY2U6CkBAIC0yMzgsNyArMjQzLDYgQEAgRnJhbWVMb2FkZXI6OkZy YW1lTG9hZGVyKEZyYW1lKiBmcmFtZSwgRgogICAgICwgbV9zZW50UmVkaXJlY3ROb3RpZmljYXRp b24oZmFsc2UpCiAgICAgLCBtX2luU3RvcEFsbExvYWRlcnMoZmFsc2UpCiAgICAgLCBtX25hdmln YXRpb25EdXJpbmdMb2FkKGZhbHNlKQotICAgICwgbV9jYWNoZVBvbGljeShDYWNoZVBvbGljeVZl cmlmeSkKICAgICAsIG1faXNFeGVjdXRpbmdKYXZhU2NyaXB0Rm9ybUFjdGlvbihmYWxzZSkKICAg ICAsIG1faXNSdW5uaW5nU2NyaXB0KGZhbHNlKQogICAgICwgbV9kaWRDYWxsSW1wbGljaXRDbG9z ZShmYWxzZSkKQEAgLTM3NCwxOSArMzc4LDE3IEBAIGJvb2wgRnJhbWVMb2FkZXI6OmNhbkhhbmRs ZVJlcXVlc3QoY29uc3QKICAgICByZXR1cm4gbV9jbGllbnQtPmNhbkhhbmRsZVJlcXVlc3QocmVx dWVzdCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXI6OmNoYW5nZUxvY2F0aW9uKGNvbnN0IFN0cmlu ZyYgdXJsLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5LCBib29sIHVz ZXJHZXN0dXJlKQordm9pZCBGcmFtZUxvYWRlcjo6Y2hhbmdlTG9jYXRpb24oY29uc3QgU3RyaW5n JiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgdXNl ckdlc3R1cmUsIGJvb2wgcmVmcmVzaCkKIHsKLSAgICBjaGFuZ2VMb2NhdGlvbihjb21wbGV0ZVVS TCh1cmwpLCByZWZlcnJlciwgbG9ja0hpc3RvcnksIHVzZXJHZXN0dXJlKTsKKyAgICBjaGFuZ2VM b2NhdGlvbihjb21wbGV0ZVVSTCh1cmwpLCByZWZlcnJlciwgbG9ja0hpc3RvcnksIHVzZXJHZXN0 dXJlLCByZWZyZXNoKTsKIH0KIAogCi12b2lkIEZyYW1lTG9hZGVyOjpjaGFuZ2VMb2NhdGlvbihj b25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wgbG9ja0hpc3Rvcnks IGJvb2wgdXNlckdlc3R1cmUpCit2b2lkIEZyYW1lTG9hZGVyOjpjaGFuZ2VMb2NhdGlvbihjb25z dCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wgbG9ja0hpc3RvcnksIGJv b2wgdXNlckdlc3R1cmUsIGJvb2wgcmVmcmVzaCkKIHsKICAgICBSZWZQdHI8RnJhbWU+IHByb3Rl Y3QobV9mcmFtZSk7CiAKLSAgICBSZXNvdXJjZVJlcXVlc3RDYWNoZVBvbGljeSBwb2xpY3kgPSAo bV9jYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeVJlbG9hZCkgfHwgKG1fY2FjaGVQb2xpY3kgPT0g Q2FjaGVQb2xpY3lSZWZyZXNoKQotICAgICAgICA/IFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhIDog VXNlUHJvdG9jb2xDYWNoZVBvbGljeTsKLSAgICBSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdCh1cmws IHJlZmVycmVyLCBwb2xpY3kpOworICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KHVybCwgcmVm ZXJyZXIsICByZWZyZXNoID8gUmVsb2FkSWdub3JpbmdDYWNoZURhdGEgOiBVc2VQcm90b2NvbENh Y2hlUG9saWN5KTsKICAgICAKICAgICBpZiAoZXhlY3V0ZUlmSmF2YVNjcmlwdFVSTChyZXF1ZXN0 LnVybCgpLCB1c2VyR2VzdHVyZSkpCiAgICAgICAgIHJldHVybjsKQEAgLTYwOCw3ICs2MTAsNiBA QCB2b2lkIEZyYW1lTG9hZGVyOjpzdG9wTG9hZGluZyhib29sIHNlbmRVCiAgICAgbV9pc0NvbXBs ZXRlID0gdHJ1ZTsgLy8gdG8gYXZvaWQgY2FsbGluZyBjb21wbGV0ZWQoKSBpbiBmaW5pc2hlZFBh cnNpbmcoKSAoRGF2aWQpCiAgICAgbV9pc0xvYWRpbmdNYWluUmVzb3VyY2UgPSBmYWxzZTsKICAg ICBtX2RpZENhbGxJbXBsaWNpdENsb3NlID0gdHJ1ZTsgLy8gZG9uJ3Qgd2FudCB0aGF0IG9uZSBl aXRoZXIKLSAgICBtX2NhY2hlUG9saWN5ID0gQ2FjaGVQb2xpY3lWZXJpZnk7IC8vIFdoeSBoZXJl PwogCiAgICAgaWYgKG1fZnJhbWUtPmRvY3VtZW50KCkgJiYgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+ cGFyc2luZygpKSB7CiAgICAgICAgIGZpbmlzaGVkUGFyc2luZygpOwpAQCAtODgwLDcgKzg4MSw2 IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlY2VpdmVkRmlyc3REYXRhKCkKICAgICBpZiAoIXB0aXRs ZS5pc051bGwoKSkKICAgICAgICAgbV9jbGllbnQtPmRpc3BhdGNoRGlkUmVjZWl2ZVRpdGxlKHB0 aXRsZSk7CiAKLSAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5kb2NMb2FkZXIoKS0+c2V0Q2FjaGVQ b2xpY3kobV9jYWNoZVBvbGljeSk7CiAgICAgbV93b3JraW5nVVJMID0gS1VSTCgpOwogCiAgICAg ZG91YmxlIGRlbGF5OwpAQCAtMTAyMyw5ICsxMDIzLDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6d3Jp dGUoY29uc3QgY2hhciogc3RyLAogCiAjaWYgVVNFKExPV19CQU5EV0lEVEhfRElTUExBWSkKICAg ICBpZiAobV9mcmFtZS0+ZG9jdW1lbnQoKS0+aW5Mb3dCYW5kd2lkdGhEaXNwbGF5KCkpCi0gICAg ICAgIG1fcGVuZGluZ1NvdXJjZUluTG93QmFuZHdpZHRoRGlzcGxheS5hcHBlbmQoZGVjb2RlZCk7 Ci0gICAgZWxzZSAvLyByZXNldCBwb2xpY3kgd2hpY2ggaXMgY2hhbmdlZCBpbiBzd2l0Y2hPdXRM b3dCYW5kd2lkdGhEaXNwbGF5SWZSZWFkeSgpCi0gICAgICAgIG1fZnJhbWUtPmRvY3VtZW50KCkt PmRvY0xvYWRlcigpLT5zZXRDYWNoZVBvbGljeShtX2NhY2hlUG9saWN5KTsgICAgCisgICAgICAg IG1fcGVuZGluZ1NvdXJjZUluTG93QmFuZHdpZHRoRGlzcGxheS5hcHBlbmQoZGVjb2RlZCk7ICAg CiAjZW5kaWYKIAogICAgIGlmICghbV9yZWNlaXZlZERhdGEpIHsKQEAgLTExMTQsNyArMTExMiw3 IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnN0YXJ0SWNvbkxvYWRlcigpCiAgICAgICAgIHJldHVybjsK IAogICAgIC8vIElmIHdlJ3JlIG5vdCByZWxvYWRpbmcgYW5kIHRoZSBpY29uIGRhdGFiYXNlIGRv ZXNuJ3Qgc2F5IHRvIGxvYWQgbm93IHRoZW4gYmFpbCBiZWZvcmUgd2UgYWN0dWFsbHkgc3RhcnQg dGhlIGxvYWQKLSAgICBpZiAobG9hZFR5cGUoKSAhPSBGcmFtZUxvYWRUeXBlUmVsb2FkKSB7Cisg ICAgaWYgKGxvYWRUeXBlKCkgIT0gRnJhbWVMb2FkVHlwZVJlbG9hZCAmJiBsb2FkVHlwZSgpICE9 IEZyYW1lTG9hZFR5cGVSZWxvYWRGcm9tT3JpZ2luKSB7CiAgICAgICAgIEljb25Mb2FkRGVjaXNp b24gZGVjaXNpb24gPSBpY29uRGF0YWJhc2UoKS0+bG9hZERlY2lzaW9uRm9ySWNvblVSTCh1cmxT dHJpbmcsIG1fZG9jdW1lbnRMb2FkZXIuZ2V0KCkpOwogICAgICAgICBpZiAoZGVjaXNpb24gPT0g SWNvbkxvYWRObykgewogICAgICAgICAgICAgTE9HKEljb25EYXRhYmFzZSwgIkZyYW1lTG9hZGVy OjpzdGFydEljb25Mb2FkZXIoKSAtIFRvbGQgbm90IHRvIGxvYWQgdGhpcyBpY29uLCBjb21taXR0 aW5nIGljb25VUkwgJXMgdG8gZGF0YWJhc2UgZm9yIHBhZ2VVUkwgbWFwcGluZyIsIHVybFN0cmlu Zy5hc2NpaSgpLmRhdGEoKSk7CkBAIC0xMjA2LDYgKzEyMDQsNyBAQCB2b2lkIEZyYW1lTG9hZGVy OjpyZXN0b3JlRG9jdW1lbnRTdGF0ZSgpCiAgICAgc3dpdGNoIChsb2FkVHlwZSgpKSB7CiAgICAg ICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9hZDoKICAgICAgICAgY2FzZSBGcmFtZUxvYWRUeXBl UmVsb2FkQWxsb3dpbmdTdGFsZURhdGE6CisgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9h ZEZyb21PcmlnaW46CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVNhbWU6CiAgICAgICAgIGNh c2UgRnJhbWVMb2FkVHlwZVJlcGxhY2U6CiAgICAgICAgICAgICBicmVhazsKQEAgLTEzODAsNyAr MTM3OSw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnNjaGVkdWxlSFRUUFJlZGlyZWN0aW8KIAogICAg IC8vIFdlIHdhbnQgYSBuZXcgaGlzdG9yeSBpdGVtIGlmIHRoZSByZWZyZXNoIHRpbWVvdXQgaXMg PiAxIHNlY29uZC4KICAgICBpZiAoIW1fc2NoZWR1bGVkUmVkaXJlY3Rpb24gfHwgZGVsYXkgPD0g bV9zY2hlZHVsZWRSZWRpcmVjdGlvbi0+ZGVsYXkpCi0gICAgICAgIHNjaGVkdWxlUmVkaXJlY3Rp b24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKGRlbGF5LCB1cmwsIGRlbGF5IDw9IDEsIGZhbHNl KSk7CisgICAgICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9u KGRlbGF5LCB1cmwsIGRlbGF5IDw9IDEsIGZhbHNlLCBmYWxzZSkpOwogfQogCiB2b2lkIEZyYW1l TG9hZGVyOjpzY2hlZHVsZUxvY2F0aW9uQ2hhbmdlKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBT dHJpbmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5LCBib29sIHdhc1VzZXJHZXN0dXJlKQpA QCAtMTM5Miw3ICsxMzkxLDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6c2NoZWR1bGVMb2NhdGlvbkNo YW5nZQogICAgIC8vIGZyYWdtZW50IHBhcnQsIHdlIGRvbid0IG5lZWQgdG8gc2NoZWR1bGUgdGhl IGxvY2F0aW9uIGNoYW5nZS4KICAgICBLVVJMIHBhcnNlZFVSTCh1cmwpOwogICAgIGlmIChwYXJz ZWRVUkwuaGFzUmVmKCkgJiYgZXF1YWxJZ25vcmluZ1JlZihtX1VSTCwgcGFyc2VkVVJMKSkgewot ICAgICAgICBjaGFuZ2VMb2NhdGlvbih1cmwsIHJlZmVycmVyLCBsb2NrSGlzdG9yeSwgd2FzVXNl ckdlc3R1cmUpOworICAgICAgICBjaGFuZ2VMb2NhdGlvbih1cmwsIHJlZmVycmVyLCBsb2NrSGlz dG9yeSwgd2FzVXNlckdlc3R1cmUsIGZhbHNlKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApA QCAtMTQxMSw3ICsxNDEwLDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6c2NoZWR1bGVMb2NhdGlvbkNo YW5nZQogCiAgICAgU2NoZWR1bGVkUmVkaXJlY3Rpb246OlR5cGUgdHlwZSA9IGR1cmluZ0xvYWQK ICAgICAgICAgPyBTY2hlZHVsZWRSZWRpcmVjdGlvbjo6bG9jYXRpb25DaGFuZ2VEdXJpbmdMb2Fk IDogU2NoZWR1bGVkUmVkaXJlY3Rpb246OmxvY2F0aW9uQ2hhbmdlOwotICAgIHNjaGVkdWxlUmVk aXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKHR5cGUsIHVybCwgcmVmZXJyZXIsIGxv Y2tIaXN0b3J5LCB3YXNVc2VyR2VzdHVyZSkpOworICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3 IFNjaGVkdWxlZFJlZGlyZWN0aW9uKHR5cGUsIHVybCwgcmVmZXJyZXIsIGxvY2tIaXN0b3J5LCB3 YXNVc2VyR2VzdHVyZSwgZmFsc2UpKTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlcjo6c2NoZWR1bGVS ZWZyZXNoKGJvb2wgd2FzVXNlckdlc3R1cmUpCkBAIC0xNDMxLDggKzE0MzAsNyBAQCB2b2lkIEZy YW1lTG9hZGVyOjpzY2hlZHVsZVJlZnJlc2goYm9vbCB3CiAKICAgICBTY2hlZHVsZWRSZWRpcmVj dGlvbjo6VHlwZSB0eXBlID0gZHVyaW5nTG9hZAogICAgICAgICA/IFNjaGVkdWxlZFJlZGlyZWN0 aW9uOjpsb2NhdGlvbkNoYW5nZUR1cmluZ0xvYWQgOiBTY2hlZHVsZWRSZWRpcmVjdGlvbjo6bG9j YXRpb25DaGFuZ2U7Ci0gICAgc2NoZWR1bGVSZWRpcmVjdGlvbihuZXcgU2NoZWR1bGVkUmVkaXJl Y3Rpb24odHlwZSwgbV9VUkwuc3RyaW5nKCksIG1fb3V0Z29pbmdSZWZlcnJlciwgdHJ1ZSwgd2Fz VXNlckdlc3R1cmUpKTsKLSAgICBtX2NhY2hlUG9saWN5ID0gQ2FjaGVQb2xpY3lSZWZyZXNoOwor ICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKHR5cGUsIG1f VVJMLnN0cmluZygpLCBtX291dGdvaW5nUmVmZXJyZXIsIHRydWUsIHdhc1VzZXJHZXN0dXJlLCB0 cnVlKSk7CiB9CiAKIGJvb2wgRnJhbWVMb2FkZXI6OmlzTG9jYXRpb25DaGFuZ2UoY29uc3QgU2No ZWR1bGVkUmVkaXJlY3Rpb24mIHJlZGlyZWN0aW9uKQpAQCAtMTUxNiw3ICsxNTE0LDcgQEAgdm9p ZCBGcmFtZUxvYWRlcjo6cmVkaXJlY3Rpb25UaW1lckZpcmVkKAogICAgICAgICBjYXNlIFNjaGVk dWxlZFJlZGlyZWN0aW9uOjpsb2NhdGlvbkNoYW5nZToKICAgICAgICAgY2FzZSBTY2hlZHVsZWRS ZWRpcmVjdGlvbjo6bG9jYXRpb25DaGFuZ2VEdXJpbmdMb2FkOgogICAgICAgICAgICAgY2hhbmdl TG9jYXRpb24ocmVkaXJlY3Rpb24tPnVybCwgcmVkaXJlY3Rpb24tPnJlZmVycmVyLAotICAgICAg ICAgICAgICAgIHJlZGlyZWN0aW9uLT5sb2NrSGlzdG9yeSwgcmVkaXJlY3Rpb24tPndhc1VzZXJH ZXN0dXJlKTsKKyAgICAgICAgICAgICAgICByZWRpcmVjdGlvbi0+bG9ja0hpc3RvcnksIHJlZGly ZWN0aW9uLT53YXNVc2VyR2VzdHVyZSwgcmVkaXJlY3Rpb24tPndhc1JlZnJlc2gpOwogICAgICAg ICAgICAgcmV0dXJuOwogICAgICAgICBjYXNlIFNjaGVkdWxlZFJlZGlyZWN0aW9uOjpoaXN0b3J5 TmF2aWdhdGlvbjoKICAgICAgICAgICAgIGlmIChyZWRpcmVjdGlvbi0+aGlzdG9yeVN0ZXBzID09 IDApIHsKQEAgLTE5MjMsNiArMTkyMSw3IEBAIGJvb2wgRnJhbWVMb2FkZXI6OmNhbkNhY2hlUGFn ZSgpCiAgICAgICAgICYmICFpc1F1aWNrUmVkaXJlY3RDb21pbmcoKQogICAgICAgICAmJiBsb2Fk VHlwZSAhPSBGcmFtZUxvYWRUeXBlUmVsb2FkIAogICAgICAgICAmJiBsb2FkVHlwZSAhPSBGcmFt ZUxvYWRUeXBlUmVsb2FkQWxsb3dpbmdTdGFsZURhdGEKKyAgICAgICAgJiYgbG9hZFR5cGUgIT0g RnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4KICAgICAgICAgJiYgbG9hZFR5cGUgIT0gRnJh bWVMb2FkVHlwZVNhbWUKICAgICAgICAgJiYgIW1fZG9jdW1lbnRMb2FkZXItPmlzTG9hZGluZ0lu QVBJU2Vuc2UoKQogICAgICAgICAmJiAhbV9kb2N1bWVudExvYWRlci0+aXNTdG9wcGluZygpCkBA IC0yMTQxLDcgKzIxNDAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJMKGNvbnN0IEtVUkwm IG5lCiAgICAgICAgIGFkZEhUVFBPcmlnaW5JZk5lZWRlZChyZXF1ZXN0LCByZWZlcnJlck9yaWdp bi0+dG9TdHJpbmcoKSk7CiAgICAgfQogICAgIGFkZEV4dHJhRmllbGRzVG9SZXF1ZXN0KHJlcXVl c3QsIHRydWUsIGV2ZW50IHx8IGlzRm9ybVN1Ym1pc3Npb24pOwotICAgIGlmIChuZXdMb2FkVHlw ZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkKQorICAgIGlmIChuZXdMb2FkVHlwZSA9PSBGcmFtZUxv YWRUeXBlUmVsb2FkIHx8IG5ld0xvYWRUeXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWRGcm9tT3Jp Z2luKQogICAgICAgICByZXF1ZXN0LnNldENhY2hlUG9saWN5KFJlbG9hZElnbm9yaW5nQ2FjaGVE YXRhKTsKIAogICAgIEFTU0VSVChuZXdMb2FkVHlwZSAhPSBGcmFtZUxvYWRUeXBlU2FtZSk7CkBA IC0yNDMyLDcgKzI0MzEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpyZWxvYWRBbGxvd2luZ1N0YWxl RGF0CiAgICAgbG9hZFdpdGhEb2N1bWVudExvYWRlcihsb2FkZXIuZ2V0KCksIEZyYW1lTG9hZFR5 cGVSZWxvYWRBbGxvd2luZ1N0YWxlRGF0YSwgMCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXI6OnJl bG9hZCgpCit2b2lkIEZyYW1lTG9hZGVyOjpyZWxvYWQoYm9vbCBlbmRUb0VuZFJlbG9hZCkKIHsK ICAgICBpZiAoIW1fZG9jdW1lbnRMb2FkZXIpCiAgICAgICAgIHJldHVybjsKQEAgLTI0NTUsOCAr MjQ1NCw4IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlbG9hZCgpCiAKICAgICBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QgPSBsb2FkZXItPnJlcXVlc3QoKTsKIAorICAgIC8vIEZJWE1FOiBXZSBkb24n dCBoYXZlIGEgbWVjaGFuaXNtIHRvIHJldmFsaWRhdGUgdGhlIG1haW4gcmVzb3VyY2Ugd2l0aG91 dCByZWxvYWRpbiBhdCB0aGUgbW9tZW50LgogICAgIHJlcXVlc3Quc2V0Q2FjaGVQb2xpY3koUmVs b2FkSWdub3JpbmdDYWNoZURhdGEpOwotICAgIHJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJD YWNoZS1Db250cm9sIiwgIm1heC1hZ2U9MCIpOwogCiAgICAgLy8gSWYgd2UncmUgYWJvdXQgdG8g cmUtcG9zdCwgc2V0IHVwIGFjdGlvbiBzbyB0aGUgYXBwbGljYXRpb24gY2FuIHdhcm4gdGhlIHVz ZXIuCiAgICAgaWYgKHJlcXVlc3QuaHR0cE1ldGhvZCgpID09ICJQT1NUIikKQEAgLTI0NjQsNyAr MjQ2Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlbG9hZCgpCiAKICAgICBsb2FkZXItPnNldE92 ZXJyaWRlRW5jb2RpbmcobV9kb2N1bWVudExvYWRlci0+b3ZlcnJpZGVFbmNvZGluZygpKTsKICAg ICAKLSAgICBsb2FkV2l0aERvY3VtZW50TG9hZGVyKGxvYWRlci5nZXQoKSwgRnJhbWVMb2FkVHlw ZVJlbG9hZCwgMCk7CisgICAgbG9hZFdpdGhEb2N1bWVudExvYWRlcihsb2FkZXIuZ2V0KCksIGVu ZFRvRW5kUmVsb2FkID8gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4gOiBGcmFtZUxvYWRU eXBlUmVsb2FkLCAwKTsKIH0KIAogc3RhdGljIGJvb2wgY2FuQWNjZXNzQW5jZXN0b3IoY29uc3Qg U2VjdXJpdHlPcmlnaW4qIGFjdGl2ZVNlY3VyaXR5T3JpZ2luLCBGcmFtZSogdGFyZ2V0RnJhbWUp CkBAIC0yNzk3LDYgKzI3OTYsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjp0cmFuc2l0aW9uVG9Db21t aXR0ZWQoCiAgICAgICAgICAgICBicmVhazsKIAogICAgICAgICBjYXNlIEZyYW1lTG9hZFR5cGVS ZWxvYWQ6CisgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW46CiAgICAg ICAgIGNhc2UgRnJhbWVMb2FkVHlwZVNhbWU6CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJl cGxhY2U6CiAgICAgICAgICAgICB1cGRhdGVIaXN0b3J5Rm9yUmVsb2FkKCk7CkBAIC0zMDkzLDYg KzMwOTMsMjYgQEAgRnJhbWVMb2FkVHlwZSBGcmFtZUxvYWRlcjo6bG9hZFR5cGUoKSBjbwogewog ICAgIHJldHVybiBtX2xvYWRUeXBlOwogfQorICAgIAorQ2FjaGVQb2xpY3kgRnJhbWVMb2FkZXI6 OmNhY2hlUG9saWN5KCkgY29uc3QKK3sKKyAgICBpZiAobV9pc0NvbXBsZXRlKQorICAgICAgICBy ZXR1cm4gQ2FjaGVQb2xpY3lWZXJpZnk7CisgICAgCisgICAgaWYgKG1fbG9hZFR5cGUgPT0gRnJh bWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4pCisgICAgICAgIHJldHVybiBDYWNoZVBvbGljeVJl bG9hZDsKKyAgICAKKyAgICBpZiAoRnJhbWUqIHBhcmVudEZyYW1lID0gbV9mcmFtZS0+dHJlZSgp LT5wYXJlbnQoKSkgeworICAgICAgICBDYWNoZVBvbGljeSBwYXJlbnRDYWNoZVBvbGljeSA9IHBh cmVudEZyYW1lLT5sb2FkZXIoKS0+Y2FjaGVQb2xpY3koKTsKKyAgICAgICAgaWYgKHBhcmVudENh Y2hlUG9saWN5ICE9IENhY2hlUG9saWN5VmVyaWZ5KQorICAgICAgICAgICAgcmV0dXJuIHBhcmVu dENhY2hlUG9saWN5OworICAgIH0KKworICAgIGlmIChtX2xvYWRUeXBlID09IEZyYW1lTG9hZFR5 cGVSZWxvYWQpCisgICAgICAgIHJldHVybiBDYWNoZVBvbGljeVJldmFsaWRhdGU7CisKKyAgICBy ZXR1cm4gQ2FjaGVQb2xpY3lWZXJpZnk7Cit9CiAKIHZvaWQgRnJhbWVMb2FkZXI6OnN0b3BQb2xp Y3lDaGVjaygpCiB7CkBAIC0zMTY5LDcgKzMxODksNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpjaGVj a0xvYWRDb21wbGV0ZUZvclRoCiAgICAgICAgICAgICAgCiAgICAgICAgICAgICAvLyBJZiB0aGUg dXNlciBoYWQgYSBzY3JvbGwgcG9pbnQsIHNjcm9sbCB0byBpdCwgb3ZlcnJpZGluZyB0aGUgYW5j aG9yIHBvaW50IGlmIGFueS4KICAgICAgICAgICAgIGlmIChQYWdlKiBwYWdlID0gbV9mcmFtZS0+ cGFnZSgpKQotICAgICAgICAgICAgICAgIGlmICgoaXNCYWNrRm9yd2FyZExvYWRUeXBlKG1fbG9h ZFR5cGUpIHx8IG1fbG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZCkgJiYgcGFnZS0+YmFj a0ZvcndhcmRMaXN0KCkpCisgICAgICAgICAgICAgICAgaWYgKChpc0JhY2tGb3J3YXJkTG9hZFR5 cGUobV9sb2FkVHlwZSkgfHwgbV9sb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkIHx8IG1f bG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4pICYmIHBhZ2UtPmJhY2tG b3J3YXJkTGlzdCgpKQogICAgICAgICAgICAgICAgICAgICByZXN0b3JlU2Nyb2xsUG9zaXRpb25B bmRWaWV3U3RhdGUoKTsKIAogICAgICAgICAgICAgaWYgKG1fY3JlYXRpbmdJbml0aWFsRW1wdHlE b2N1bWVudCB8fCAhbV9jb21taXR0ZWRGaXJzdFJlYWxEb2N1bWVudExvYWQpCkBAIC0zNDA0LDkg KzM0MjQsMTEgQEAgdm9pZCBGcmFtZUxvYWRlcjo6YWRkRXh0cmFGaWVsZHNUb1JlcXVlcwogewog ICAgIGFwcGx5VXNlckFnZW50KHJlcXVlc3QpOwogICAgIAotICAgIGlmIChtX2xvYWRUeXBlID09 IEZyYW1lTG9hZFR5cGVSZWxvYWQpIHsKLSAgICAgICAgcmVxdWVzdC5zZXRDYWNoZVBvbGljeShS ZWxvYWRJZ25vcmluZ0NhY2hlRGF0YSk7CisgICAgaWYgKG1fbG9hZFR5cGUgPT0gRnJhbWVMb2Fk VHlwZVJlbG9hZCkKICAgICAgICAgcmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIkNhY2hlLUNv bnRyb2wiLCAibWF4LWFnZT0wIik7CisgICAgZWxzZSBpZiAobV9sb2FkVHlwZSA9PSBGcmFtZUxv YWRUeXBlUmVsb2FkRnJvbU9yaWdpbikgeworICAgICAgICByZXF1ZXN0LnNldEhUVFBIZWFkZXJG aWVsZCgiQ2FjaGUtQ29udHJvbCIsICJuby1jYWNoZSIpOworICAgICAgICByZXF1ZXN0LnNldEhU VFBIZWFkZXJGaWVsZCgiUHJhZ21hIiwgIm5vLWNhY2hlIik7CiAgICAgfQogICAgIAogICAgIC8v IERvbid0IHNldCB0aGUgY29va2llIHBvbGljeSBVUkwgaWYgaXQncyBhbHJlYWR5IGJlZW4gc2V0 LgpAQCAtMzQ5OCwxMSArMzUyMCw2IEBAIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWRQb3N0UmVxdWVz dChjb25zdCAKICAgICAgICAgbG9hZFdpdGhOYXZpZ2F0aW9uQWN0aW9uKHdvcmtpbmdSZXNvdXJj ZVJlcXVlc3QsIGFjdGlvbiwgRnJhbWVMb2FkVHlwZVN0YW5kYXJkLCBmb3JtU3RhdGUucmVsZWFz ZSgpKTsgICAgCiB9CiAKLWJvb2wgRnJhbWVMb2FkZXI6OmlzUmVsb2FkaW5nKCkgY29uc3QKLXsK LSAgICByZXR1cm4gZG9jdW1lbnRMb2FkZXIoKS0+cmVxdWVzdCgpLmNhY2hlUG9saWN5KCkgPT0g UmVsb2FkSWdub3JpbmdDYWNoZURhdGE7Ci19Ci0KIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWRFbXB0 eURvY3VtZW50U3luY2hyb25vdXNseSgpCiB7CiAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Qo S1VSTCgiIikpOwpAQCAtMzY5NSw2ICszNzEyLDcgQEAgYm9vbCBGcmFtZUxvYWRlcjo6c2hvdWxk U2Nyb2xsVG9BbmNob3IoYgogCiAgICAgcmV0dXJuICFpc0Zvcm1TdWJtaXNzaW9uCiAgICAgICAg ICYmIGxvYWRUeXBlICE9IEZyYW1lTG9hZFR5cGVSZWxvYWQKKyAgICAgICAgJiYgbG9hZFR5cGUg IT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4KICAgICAgICAgJiYgbG9hZFR5cGUgIT0g RnJhbWVMb2FkVHlwZVNhbWUKICAgICAgICAgJiYgIXNob3VsZFJlbG9hZCh0aGlzLT51cmwoKSwg dXJsKQogICAgICAgICAvLyBXZSBkb24ndCB3YW50IHRvIGp1c3Qgc2Nyb2xsIGlmIGEgbGluayBm cm9tIHdpdGhpbiBhCkBAIC00Mzc1LDYgKzQzOTMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2Fk SXRlbShIaXN0b3J5SXRlbSogCiAgICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAg IHN3aXRjaCAobG9hZFR5cGUpIHsKICAgICAgICAgICAgICAgICAgICAgY2FzZSBGcmFtZUxvYWRU eXBlUmVsb2FkOgorICAgICAgICAgICAgICAgICAgICBjYXNlIEZyYW1lTG9hZFR5cGVSZWxvYWRG cm9tT3JpZ2luOgogICAgICAgICAgICAgICAgICAgICAgICAgcmVxdWVzdC5zZXRDYWNoZVBvbGlj eShSZWxvYWRJZ25vcmluZ0NhY2hlRGF0YSk7CiAgICAgICAgICAgICAgICAgICAgICAgICBicmVh azsKICAgICAgICAgICAgICAgICAgICAgY2FzZSBGcmFtZUxvYWRUeXBlQmFjazoKQEAgLTQ2MDgs NyArNDYyNyw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnVwZGF0ZUhpc3RvcnlGb3JSZWxvYWQKICAg ICBpZiAobV9jdXJyZW50SGlzdG9yeUl0ZW0pIHsKICAgICAgICAgcGFnZUNhY2hlKCktPnJlbW92 ZShtX2N1cnJlbnRIaXN0b3J5SXRlbS5nZXQoKSk7CiAgICAgCi0gICAgICAgIGlmIChsb2FkVHlw ZSgpID09IEZyYW1lTG9hZFR5cGVSZWxvYWQpCisgICAgICAgIGlmIChsb2FkVHlwZSgpID09IEZy YW1lTG9hZFR5cGVSZWxvYWQgfHwgbG9hZFR5cGUoKSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkRnJv bU9yaWdpbikKICAgICAgICAgICAgIHNhdmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdTdGF0ZVRvSXRl bShtX2N1cnJlbnRIaXN0b3J5SXRlbS5nZXQoKSk7CiAgICAgCiAgICAgICAgIC8vIFNvbWV0aW1l cyBsb2FkaW5nIGEgcGFnZSBhZ2FpbiBsZWFkcyB0byBhIGRpZmZlcmVudCByZXN1bHQgYmVjYXVz ZSBvZiBjb29raWVzLiBCdWd6aWxsYSA0MDcyCkBAIC00NjU4LDcgKzQ2NzcsNyBAQCB2b2lkIEZy YW1lTG9hZGVyOjp1cGRhdGVIaXN0b3J5Rm9yQ29tbWl0CiAjZW5kaWYKICAgICBGcmFtZUxvYWRU eXBlIHR5cGUgPSBsb2FkVHlwZSgpOwogICAgIGlmIChpc0JhY2tGb3J3YXJkTG9hZFR5cGUodHlw ZSkgfHwKLSAgICAgICAgKHR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZCAmJiAhcHJvdmlzaW9u YWxEb2N1bWVudExvYWRlcigpLT51bnJlYWNoYWJsZVVSTCgpLmlzRW1wdHkoKSkpIHsKKyAgICAg ICAgKCh0eXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWQgfHwgdHlwZSA9PSBGcmFtZUxvYWRUeXBl UmVsb2FkRnJvbU9yaWdpbikgJiYgIXByb3Zpc2lvbmFsRG9jdW1lbnRMb2FkZXIoKS0+dW5yZWFj aGFibGVVUkwoKS5pc0VtcHR5KCkpKSB7CiAgICAgICAgIC8vIE9uY2UgY29tbWl0dGVkLCB3ZSB3 YW50IHRvIHVzZSBjdXJyZW50IGl0ZW0gZm9yIHNhdmluZyBEb2NTdGF0ZSwgYW5kCiAgICAgICAg IC8vIHRoZSBwcm92aXNpb25hbCBpdGVtIGZvciByZXN0b3Jpbmcgc3RhdGUuCiAgICAgICAgIC8v IE5vdGUgcHJldmlvdXNJdGVtIG11c3QgYmUgc2V0IGJlZm9yZSB3ZSBjbG9zZSB0aGUgVVJMLCB3 aGljaCB3aWxsCkBAIC01MTU4LDcgKzUxNzcsNiBAQCB2b2lkIEZyYW1lTG9hZGVyOjpzd2l0Y2hP dXRMb3dCYW5kd2lkdGhECiAgICAgICAgICAgICAvLyB3cml0ZSBkZWNvZGVkIGRhdGEgdG8gdGhl IG5ldyBkb2MsIHNpbWlsYXIgdG8gd3JpdGUoKQogICAgICAgICAgICAgaWYgKG1fcGVuZGluZ1Nv dXJjZUluTG93QmFuZHdpZHRoRGlzcGxheS5sZW5ndGgoKSkgewogICAgICAgICAgICAgICAgIC8v IHNldCBjYWNoZVBvbGljeSB0byBDYWNoZSB0byB1c2UgdGhlIGxvYWRlZCByZXNvdXJjZQotICAg ICAgICAgICAgICAgIG5ld0RvYy0+ZG9jTG9hZGVyKCktPnNldENhY2hlUG9saWN5KENhY2hlUG9s aWN5Q2FjaGUpOwogICAgICAgICAgICAgICAgIGlmIChtX2RlY29kZXItPmVuY29kaW5nKCkudXNl c1Zpc3VhbE9yZGVyaW5nKCkpCiAgICAgICAgICAgICAgICAgICAgIG5ld0RvYy0+c2V0VmlzdWFs bHlPcmRlcmVkKCk7ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICBuZXdEb2Mt PnJlY2FsY1N0eWxlKE5vZGU6OkZvcmNlKTsgICAgICAgICAgICAgICAgCkluZGV4OiBXZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0ZyYW1l TG9hZGVyLmgJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIu aAkod29ya2luZyBjb3B5KQpAQCAtMTg2LDcgKzE4Niw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgYm9vbCBmcmFtZUhhc0xvYWRlZCgpIGNvbnN0OwogCiAgICAgICAgIGludCBudW1Q ZW5kaW5nT3JMb2FkaW5nUmVxdWVzdHMoYm9vbCByZWN1cnNlKSBjb25zdDsKLSAgICAgICAgYm9v bCBpc1JlbG9hZGluZygpIGNvbnN0OwogICAgICAgICBTdHJpbmcgcmVmZXJyZXIoKSBjb25zdDsK ICAgICAgICAgU3RyaW5nIG91dGdvaW5nUmVmZXJyZXIoKSBjb25zdDsKICAgICAgICAgU3RyaW5n IG91dGdvaW5nT3JpZ2luKCkgY29uc3Q7CkBAIC0yMzgsNyArMjM3LDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICB2b2lkIGNoZWNrQ29udGVudFBvbGljeShjb25zdCBTdHJpbmcmIE1J TUVUeXBlLCBDb250ZW50UG9saWN5RGVjaXNpb25GdW5jdGlvbiwgdm9pZCogYXJndW1lbnQpOwog ICAgICAgICB2b2lkIGNhbmNlbENvbnRlbnRQb2xpY3lDaGVjaygpOwogCi0gICAgICAgIHZvaWQg cmVsb2FkKCk7CisgICAgICAgIHZvaWQgcmVsb2FkKGJvb2wgZW5kVG9FbmRSZWxvYWQgPSBmYWxz ZSk7CiAgICAgICAgIHZvaWQgcmVsb2FkQWxsb3dpbmdTdGFsZURhdGEoY29uc3QgU3RyaW5nJiBv dmVycmlkZUVuY29kaW5nKTsKIAogICAgICAgICB2b2lkIGRpZFJlY2VpdmVTZXJ2ZXJSZWRpcmVj dEZvclByb3Zpc2lvbmFsTG9hZEZvckZyYW1lKCk7CkBAIC0yNTQsNiArMjUzLDcgQEAgbmFtZXNw YWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVy Kik7CiAKICAgICAgICAgRnJhbWVMb2FkVHlwZSBsb2FkVHlwZSgpIGNvbnN0OworICAgICAgICBD YWNoZVBvbGljeSBjYWNoZVBvbGljeSgpIGNvbnN0OwogCiAgICAgICAgIHZvaWQgZGlkRmlyc3RM YXlvdXQoKTsKICAgICAgICAgYm9vbCBmaXJzdExheW91dERvbmUoKSBjb25zdDsKQEAgLTI4MCw4 ICsyODAsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXREZWZlcnNM b2FkaW5nKGJvb2wpOwogCi0gICAgICAgIHZvaWQgY2hhbmdlTG9jYXRpb24oY29uc3QgU3RyaW5n JiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wgbG9ja0hpc3RvcnkgPSB0cnVlLCBi b29sIHVzZXJHZXN0dXJlID0gZmFsc2UpOwotICAgICAgICB2b2lkIGNoYW5nZUxvY2F0aW9uKGNv bnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5ID0gdHJ1 ZSwgYm9vbCB1c2VyR2VzdHVyZSA9IGZhbHNlKTsKKyAgICAgICAgdm9pZCBjaGFuZ2VMb2NhdGlv bihjb25zdCBTdHJpbmcmIHVybCwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgYm9vbCBsb2NrSGlz dG9yeSA9IHRydWUsIGJvb2wgdXNlckdlc3R1cmUgPSBmYWxzZSwgYm9vbCByZWZyZXNoID0gZmFs c2UpOworICAgICAgICB2b2lkIGNoYW5nZUxvY2F0aW9uKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJp bmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5ID0gdHJ1ZSwgYm9vbCB1c2VyR2VzdHVyZSA9 IGZhbHNlLCBib29sIHJlZnJlc2ggPSBmYWxzZSk7CiAgICAgICAgIHZvaWQgdXJsU2VsZWN0ZWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiB0YXJnZXQsIEV2ZW50KiwgYm9v bCBsb2NrSGlzdG9yeSwgYm9vbCB1c2VyR2VzdHVyZSk7CiAgICAgICAgIHZvaWQgdXJsU2VsZWN0 ZWQoY29uc3QgRnJhbWVMb2FkUmVxdWVzdCYsIEV2ZW50KiwgYm9vbCBsb2NrSGlzdG9yeSk7CiAg ICAgICAKQEAgLTYwNiw4ICs2MDYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAg U3RyaW5nIG1fb3V0Z29pbmdSZWZlcnJlcjsKIAotICAgICAgICBDYWNoZVBvbGljeSBtX2NhY2hl UG9saWN5OwotCiAgICAgICAgIEhhc2hTZXQ8U3RyaW5nPiBtX3VybHNDbGllbnRLbm93c0Fib3V0 OwogCiAgICAgICAgIE93blB0cjxGb3JtU3VibWlzc2lvbj4gbV9kZWZlcnJlZEZvcm1TdWJtaXNz aW9uOwpJbmRleDogV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJUeXBlcy5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyVHlwZXMuaAkocmV2aXNpb24gMzgyMDkpCisr KyBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlclR5cGVzLmgJKHdvcmtpbmcgY29weSkKQEAgLTU0 LDcgKzU0LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBGcmFtZUxvYWRUeXBlUmVs b2FkQWxsb3dpbmdTdGFsZURhdGEsCiAgICAgICAgIEZyYW1lTG9hZFR5cGVTYW1lLCAgICAgICAg ICAgICAgIC8vIHVzZXIgbG9hZHMgc2FtZSBVUkwgYWdhaW4gKGJ1dCBub3QgcmVsb2FkIGJ1dHRv bikKICAgICAgICAgRnJhbWVMb2FkVHlwZVJlZGlyZWN0V2l0aExvY2tlZEhpc3RvcnksCi0gICAg ICAgIEZyYW1lTG9hZFR5cGVSZXBsYWNlCisgICAgICAgIEZyYW1lTG9hZFR5cGVSZXBsYWNlLAor ICAgICAgICBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbgogICAgIH07CiAKICAgICBlbnVt IE5hdmlnYXRpb25UeXBlIHsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL05hdmlnYXRpb25BY3Rpb24u Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL05hdmlnYXRpb25BY3Rpb24uY3BwCShy ZXZpc2lvbiAzODIwOSkKKysrIFdlYkNvcmUvbG9hZGVyL05hdmlnYXRpb25BY3Rpb24uY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC00MCw3ICs0MCw3IEBAIHN0YXRpYyBOYXZpZ2F0aW9uVHlwZSBuYXZp Z2F0aW9uVHlwZShGcmEKICAgICAgICAgcmV0dXJuIE5hdmlnYXRpb25UeXBlRm9ybVN1Ym1pdHRl ZDsKICAgICBpZiAoaGF2ZUV2ZW50KQogICAgICAgICByZXR1cm4gTmF2aWdhdGlvblR5cGVMaW5r Q2xpY2tlZDsKLSAgICBpZiAoZnJhbWVMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkKQor ICAgIGlmIChmcmFtZUxvYWRUeXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWQgfHwgZnJhbWVMb2Fk VHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbikKICAgICAgICAgcmV0dXJuIE5h dmlnYXRpb25UeXBlUmVsb2FkOwogICAgIGlmIChpc0JhY2tGb3J3YXJkTG9hZFR5cGUoZnJhbWVM b2FkVHlwZSkpCiAgICAgICAgIHJldHVybiBOYXZpZ2F0aW9uVHlwZUJhY2tGb3J3YXJkOwpJbmRl eDogV2ViQ29yZS9sb2FkZXIvbG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRl ci9sb2FkZXIuY3BwCShyZXZpc2lvbiAzODIwOSkKKysrIFdlYkNvcmUvbG9hZGVyL2xvYWRlci5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTI0OSw3ICsyNDksOCBAQCB2b2lkIExvYWRlcjo6SG9zdDo6 c2VydmVQZW5kaW5nUmVxdWVzdHMoCiAgICAgICAgICAgICBjb25zdCBTdHJpbmcmIGxhc3RNb2Rp ZmllZCA9IHJlc291cmNlVG9SZXZhbGlkYXRlLT5yZXNwb25zZSgpLmh0dHBIZWFkZXJGaWVsZCgi TGFzdC1Nb2RpZmllZCIpOwogICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBlVGFnID0gcmVzb3Vy Y2VUb1JldmFsaWRhdGUtPnJlc3BvbnNlKCkuaHR0cEhlYWRlckZpZWxkKCJFVGFnIik7CiAgICAg ICAgICAgICBpZiAoIWxhc3RNb2RpZmllZC5pc0VtcHR5KCkgfHwgIWVUYWcuaXNFbXB0eSgpKSB7 Ci0gICAgICAgICAgICAgICAgaWYgKGRvY0xvYWRlci0+Y2FjaGVQb2xpY3koKSA9PSBDYWNoZVBv bGljeVJlbG9hZCB8fCBkb2NMb2FkZXItPmNhY2hlUG9saWN5KCkgPT0gQ2FjaGVQb2xpY3lSZWZy ZXNoKQorICAgICAgICAgICAgICAgIEFTU0VSVChkb2NMb2FkZXItPmNhY2hlUG9saWN5KCkgIT0g Q2FjaGVQb2xpY3lSZWxvYWQpOworICAgICAgICAgICAgICAgIGlmIChkb2NMb2FkZXItPmNhY2hl UG9saWN5KCkgPT0gQ2FjaGVQb2xpY3lSZXZhbGlkYXRlKQogICAgICAgICAgICAgICAgICAgICBy ZXNvdXJjZVJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJDYWNoZS1Db250cm9sIiwgIm1heC1h Z2U9MCIpOwogICAgICAgICAgICAgICAgIGlmICghbGFzdE1vZGlmaWVkLmlzRW1wdHkoKSkKICAg ICAgICAgICAgICAgICAgICAgcmVzb3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiSWYt TW9kaWZpZWQtU2luY2UiLCBsYXN0TW9kaWZpZWQpOwo= 25046 2008-11-11 02:54:29 -0800 2009-01-12 23:36:55 -0800 WebKit patch for enabling revalidation on reload reload-webkit-2.patch text/plain 4283 koivisto SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzODI5OCkKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMjAgQEAKKzIwMDgtMTEtMTEgIEFudHRpIEtvaXZpc3RvICA8YW50 dGlAYXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAg ICAgICAKKyAgICAgICAgLSBBZGQgW1dlYkZyYW1lIHJlbG9hZEZyb21PcmlnaW5dIGZvciBwZXJm b3JtaW5nIGVuZC10by1lbmQgcmVsb2FkLgorICAgICAgICAtIEFkZCBjb3JyZXNwb25kaW5nIElC QWN0aW9uIHRvIFdlYlZpZXcuCisgICAgICAgIC0gVGVtcG9yYXJpbHkgbWFrZSBbV2ViRnJhbWUg cmVsb2FkXSB0cmlnZ2VyIGVuZC10by1lbmQgcmVsb2FkIGlmIHNoaWZ0IG1vZGlmaWVyIGlzIHBy ZXNzZWQgd2hlbiBpdCBpcyBjYWxsZWQuCisKKyAgICAgICAgKiBXZWJWaWV3L1dlYkZyYW1lLmg6 CisgICAgICAgICogV2ViVmlldy9XZWJGcmFtZS5tbToKKyAgICAgICAgKC1bV2ViRnJhbWUgcmVs b2FkXSk6CisgICAgICAgICgtW1dlYkZyYW1lIHJlbG9hZEZyb21PcmlnaW5dKTogCisgICAgICAg ICogV2ViVmlldy9XZWJGcmFtZVByaXZhdGUuaDogTWF0Y2ggdGhlIEZyYW1lTG9hZFR5cGUgZW51 bSBpbiBXZWJDb3JlLgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5oOgorICAgICAgICAqIFdl YlZpZXcvV2ViVmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyByZWxvYWRGcm9tT3JpZ2luOl0p OgorCiAyMDA4LTExLTEwICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgS2V2aW4gRGVja2VyLgpJbmRleDogV2ViS2l0L21hYy9XZWJW aWV3L1dlYkZyYW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l LmgJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLmgJKHdv cmtpbmcgY29weSkKQEAgLTE2NSwxMCArMTY1LDE3IEBACiAKIC8qIQogICAgIEBtZXRob2QgcmVs b2FkCisgICAgQGRpc2N1c3Npb24gUGVyZm9ybXMgSFRUUC8xLjEgZW5kLXRvLWVuZCByZXZhbGlk YXRpb24gdXNpbmcgY2FjaGUtdmFsaWRhdGluZyBjb25kaXRpb25hbHMgaWYgcG9zc2libGUuCiAq LwogLSAodm9pZClyZWxvYWQ7CiAKIC8qIQorICAgIEBtZXRob2QgcmVsb2FkRnJvbU9yaWdpbgor ICAgIEBkaXNjdXNzaW9uIFBlcmZvcm1zIEhUVFAvMS4xIGVuZC10by1lbmQgcmVsb2FkLgorKi8K Ky0gKHZvaWQpcmVsb2FkRnJvbU9yaWdpbjsKKworLyohCiAgICAgQG1ldGhvZCBmaW5kRnJhbWVO YW1lZDoKICAgICBAZGlzY3Vzc2lvbiBUaGlzIG1ldGhvZCByZXR1cm5zIGEgZnJhbWUgd2l0aCB0 aGUgZ2l2ZW4gbmFtZS4gZmluZEZyYW1lTmFtZWQgcmV0dXJucyBzZWxmIAogICAgIGZvciBfc2Vs ZiBhbmQgX2N1cnJlbnQsIHRoZSBwYXJlbnQgZnJhbWUgZm9yIF9wYXJlbnQgYW5kIHRoZSBtYWlu IGZyYW1lIGZvciBfdG9wLiAKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbQo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0JKHJldmlzaW9uIDM4 MjA5KQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMzA4LDcgKzEzMDgsMTYgQEAgc3RhdGljIE5TVVJMICpjcmVhdGVVbmlxdWVXZWJEYXRhVVJM KCkKIAogLSAodm9pZClyZWxvYWQKIHsKLSAgICBfcHJpdmF0ZS0+Y29yZUZyYW1lLT5sb2FkZXIo KS0+cmVsb2FkKCk7CisgICAgLy8gRklYTUU6IFRoaXMgaXMgYSBoYWNrIHRvIG1ha2Ugc2hpZnQt cmVsb2FkIHdvcmsgb24gc2hpcHBpbmcgU2FmYXJpLiBSZW1vdmUgd2hlbiBTYWZhcmkgaGFzIHRo aXMgZnVuY3Rpb25hbGl0eS4KKyAgICBpZiAoW1tbTlNCdW5kbGUgbWFpbkJ1bmRsZV0gYnVuZGxl SWRlbnRpZmllcl0gaXNFcXVhbFRvU3RyaW5nOkAiY29tLmFwcGxlLlNhZmFyaSJdKQorICAgICAg ICBfcHJpdmF0ZS0+Y29yZUZyYW1lLT5sb2FkZXIoKS0+cmVsb2FkKEdldEN1cnJlbnRLZXlNb2Rp ZmllcnMoKSAmIHNoaWZ0S2V5KTsKKyAgICBlbHNlCisgICAgICAgIF9wcml2YXRlLT5jb3JlRnJh bWUtPmxvYWRlcigpLT5yZWxvYWQoZmFsc2UpOworfQorCistICh2b2lkKXJlbG9hZEZyb21Pcmln aW4KK3sKKyAgICBfcHJpdmF0ZS0+Y29yZUZyYW1lLT5sb2FkZXIoKS0+cmVsb2FkKHRydWUpOwog fQogCiAtIChXZWJGcmFtZSAqKWZpbmRGcmFtZU5hbWVkOihOU1N0cmluZyAqKW5hbWUKSW5kZXg6 IFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZVByaXZhdGUuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVQcml2YXRlLmgJKHJldmlzaW9uIDM4MjA5KQorKysgV2Vi S2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lUHJpdmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC01Miw3 ICs1Miw4IEBAIHR5cGVkZWYgZW51bSB7CiAgICAgV2ViRnJhbWVMb2FkVHlwZVJlbG9hZEFsbG93 aW5nU3RhbGVEYXRhLAogICAgIFdlYkZyYW1lTG9hZFR5cGVTYW1lLCAgICAgICAgICAgICAgIC8v IHVzZXIgbG9hZHMgc2FtZSBVUkwgYWdhaW4gKGJ1dCBub3QgcmVsb2FkIGJ1dHRvbikKICAgICBX ZWJGcmFtZUxvYWRUeXBlSW50ZXJuYWwsICAgICAgICAgICAvLyBtYXBzIHRvIFdlYkNvcmU6OkZy YW1lTG9hZFR5cGVSZWRpcmVjdFdpdGhMb2NrZWRIaXN0b3J5Ci0gICAgV2ViRnJhbWVMb2FkVHlw ZVJlcGxhY2UKKyAgICBXZWJGcmFtZUxvYWRUeXBlUmVwbGFjZSwKKyAgICBXZWJGcmFtZUxvYWRU eXBlUmVsb2FkRnJvbU9yaWdpbgogfSBXZWJGcmFtZUxvYWRUeXBlOwogCiBAaW50ZXJmYWNlIFdl YkZyYW1lIChXZWJQcml2YXRlKQpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5oCShyZXZpc2lvbiAzODIw OSkKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3LmgJKHdvcmtpbmcgY29weSkKQEAgLTY3 MCw2ICs2NzAsNyBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlZpZXdQcm9ncmVzc0ZpbmlzaGVkCiAt IChJQkFjdGlvbil0YWtlU3RyaW5nVVJMRnJvbTooaWQpc2VuZGVyOwogLSAoSUJBY3Rpb24pc3Rv cExvYWRpbmc6KGlkKXNlbmRlcjsKIC0gKElCQWN0aW9uKXJlbG9hZDooaWQpc2VuZGVyOworLSAo SUJBY3Rpb24pcmVsb2FkRnJvbU9yaWdpbjooaWQpc2VuZGVyOwogLSAoQk9PTCljYW5Hb0JhY2s7 CiAtIChJQkFjdGlvbilnb0JhY2s6KGlkKXNlbmRlcjsKIC0gKEJPT0wpY2FuR29Gb3J3YXJkOwpJ bmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L21hYy9XZWJWaWV3L1dlYlZpZXcubW0JKHJldmlzaW9uIDM4MjA5KQorKysgV2ViS2l0L21hYy9X ZWJWaWV3L1dlYlZpZXcubW0JKHdvcmtpbmcgY29weSkKQEAgLTMzMDQsNiArMzMwNCwxMSBAQCBz dGF0aWMgV2ViRnJhbWUgKmluY3JlbWVudEZyYW1lKFdlYkZyYW1lCiAgICAgW1tzZWxmIG1haW5G cmFtZV0gcmVsb2FkXTsKIH0KIAorLSAoSUJBY3Rpb24pcmVsb2FkRnJvbU9yaWdpbjooaWQpc2Vu ZGVyCit7CisgICAgW1tzZWxmIG1haW5GcmFtZV0gcmVsb2FkRnJvbU9yaWdpbl07Cit9CisKIC8v IEZJWE1FOiBUaGlzIGNvZGUgc2hvdWxkIG1vdmUgaW50byBXZWJDb3JlIHNvIHRoYXQgaXQgaXMg bm90IGR1cGxpY2F0ZWQgaW4gZWFjaCBXZWJLaXQuCiAvLyAoVGhpcyBpbmNsdWRlcyBjYW5NYWtl VGV4dFNtYWxsZXIvTGFyZ2VyLCBtYWtlVGV4dFNtYWxsZXIvTGFyZ2VyLCBhbmQgY2FuTWFrZVRl eHRTdGFuZGFyZFNpemUvbWFrZVRleHRTdGFuZGFyZFNpemUpCiAtIChCT09MKWNhbk1ha2VUZXh0 U21hbGxlcgo= 25055 2008-11-11 14:30:23 -0800 2009-01-12 23:37:11 -0800 updated WebCore patch reload-webcore-3.patch text/plain 28245 koivisto SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzODI5OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjMgQEAKKzIwMDgtMTEtMTEgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdo ZW4gYSByZXNvdXJjZSBpcyBjYWNoZWQgbG9jYWxseSwgV2ViS2l0IHNob3VsZCBmb2xsb3cgUkZD IDI2MTYgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2YWxpZGF0aW9uIiBpbnN0ZWFkIG9mICJVbnNw ZWNpZmllZCBlbmQtdG8tZW5kIHJldmFsaWRhdGlvbiIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3OTk4IAorICAgICAgICAKKyAgICAgICAgLSBFbmFi bGUgY29uZGl0aW9uYWwgcmV2YWxpZGF0aW9uIGZvciByZWxvYWRzIGJ5IGRlZmF1bHQuIAorICAg ICAgICAtIEFkZCBhIHBhcmFtZXRlciB0byBGcmFtZUxvYWRlcjo6cmVsb2FkKCkgZm9yIGZvcmNp bmcgZW5kLXRvLWVuZCByZWxvYWQuCisgICAgICAgIC0gRm9yIHNpbXBsaWNpdHkgcmVtb3ZlIG1f Y2FjaGVQb2xpY3kgdmFyaWFibGVzIGZyb20gRnJhbWVMb2FkZXIgYW5kIERvY0xvYWRlciwgaW5z dGVhZCBzeW50aGV6aXNlIHRoZSBwb2xpY3kgb24gZGVtYW5kLgorICAgICAgICAKKyAgICAgICAg VGhpcyBzcGVlZHMgdXAgcmVsb2FkcyBhbmQgbWFrZXMgdGhlbSB1c2Ugd2F5IGxlc3MgYmFuZHdp ZHRoLgorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDoKKyAgICAgICAgKiBsb2FkZXIvQ2Fj aGVQb2xpY3kuaDogUmVuYW1lIENhY2hlUG9saWN5UmVmcmVzaCB0byBDYWNoZVBvbGljeVJldmFs aWRhdGUuCisgICAgICAgIChXZWJDb3JlOjopOgorICAgICAgICAqIGxvYWRlci9Eb2NMb2FkZXIu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jTG9hZGVyOjpEb2NMb2FkZXIpOgorICAgICAgICAo V2ViQ29yZTo6RG9jTG9hZGVyOjpjaGVja0ZvclJlbG9hZCk6IFN1cHBvcnQgQ2FjaGVQb2xpY3lS ZXZhbGlkYXRlLgorICAgICAgICAoV2ViQ29yZTo6RG9jTG9hZGVyOjpyZXF1ZXN0UmVzb3VyY2Up OgorICAgICAgICAoV2ViQ29yZTo6RG9jTG9hZGVyOjpjYWNoZVBvbGljeSk6CisgICAgICAgICog bG9hZGVyL0RvY0xvYWRlci5oOiBHZXQgcmlkIG9mIG1fY2FjaGVQb2xpY3kgbWVtYmVyLiAKKyAg ICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NoZWR1 bGVkUmVkaXJlY3Rpb246OlNjaGVkdWxlZFJlZGlyZWN0aW9uKTogCisgICAgICAgICAgICBBZGQg cGFyYW1ldGVyIHRvIGRpZmZlcmVudGlhdGUgcmVmcmVzaCBmcm9tIG90aGVyIHR5cGVzIG9mIHJl ZGlyZWN0cy4gCisgICAgICAgICAgICBtX2NhY2hlUG9saWN5IHdhcyB1c2VkIGZvciBzaWduYWxp bmcgdGhpcyBiZWZvcmUuCisgICAgICAgIChXZWJDb3JlOjppc0JhY2tGb3J3YXJkTG9hZFR5cGUp OgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OkZyYW1lTG9hZGVyKToKKyAgICAgICAg KFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpjaGFuZ2VMb2NhdGlvbik6CisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2Fk ZXI6OnJlY2VpdmVkRmlyc3REYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjp3 cml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6c3RhcnRJY29uTG9hZGVyKToK KyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpyZXN0b3JlRG9jdW1lbnRTdGF0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6c2NoZWR1bGVIVFRQUmVkaXJlY3Rpb24pOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OnNjaGVkdWxlTG9jYXRpb25DaGFuZ2UpOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OnNjaGVkdWxlUmVmcmVzaCk6CisgICAgICAg IChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6cmVkaXJlY3Rpb25UaW1lckZpcmVkKToKKyAgICAgICAg KFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpjYW5DYWNoZVBhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6 RnJhbWVMb2FkZXI6OmxvYWRVUkwpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OnJl bG9hZCk6IAorICAgICAgICAgICAgRGlmZmVyZW50aWF0ZSBiZXR3ZWVuIHJldmFsaWRhdGlvbiBh bmQgcmVsb2FkLgorICAgICAgICAgICAgTm8gbmVlZCB0byB1c2Ugc2V0SFRUUEhlYWRlckZpZWxk IGhlcmUsIGFkZEV4dHJhRmllbGRzVG9SZXF1ZXN0IHdpbGwgc2V0IHRoZSBoZWFkZXJzLgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZCk6CisgICAg ICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6Y2FjaGVQb2xpY3kpOiBEZXRlcm1pbmUgdGhlIGNh Y2hlIHBvbGljeSBiYXNlZCBvbiBjdXJyZW50IGxvYWQgdHlwZS4gCisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6Y2hlY2tMb2FkQ29tcGxldGVGb3JUaGlzRnJhbWUpOgorICAgICAgICAo V2ViQ29yZTo6RnJhbWVMb2FkZXI6OmFkZEV4dHJhRmllbGRzVG9SZXF1ZXN0KTogU2V0IENhY2hl LWNvbnRyb2w6IG5vLWNhY2hlIGZvciBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OnNob3VsZFNjcm9sbFRvQW5jaG9yKToKKyAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpsb2FkSXRlbSk6CisgICAgICAgIChXZWJDb3JlOjpG cmFtZUxvYWRlcjo6dXBkYXRlSGlzdG9yeUZvclJlbG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpG cmFtZUxvYWRlcjo6dXBkYXRlSGlzdG9yeUZvckNvbW1pdCk6CisgICAgICAgIChXZWJDb3JlOjpG cmFtZUxvYWRlcjo6c3dpdGNoT3V0TG93QmFuZHdpZHRoRGlzcGxheUlmUmVhZHkpOgorICAgICAg ICAqIGxvYWRlci9GcmFtZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlclR5 cGVzLmg6IEFkZCBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9yaWdpbgorICAgICAgICAoV2ViQ29y ZTo6KToKKyAgICAgICAgKiBsb2FkZXIvTmF2aWdhdGlvbkFjdGlvbi5jcHA6IAorICAgICAgICAo V2ViQ29yZTo6bmF2aWdhdGlvblR5cGUpOiAgU3VwcG9ydCBGcmFtZUxvYWRUeXBlUmVsb2FkRnJv bU9yaWdpbgorICAgICAgICAqIGxvYWRlci9sb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 TG9hZGVyOjpIb3N0OjpzZXJ2ZVBlbmRpbmdSZXF1ZXN0cyk6CisKIDIwMDgtMTEtMTAgIFN0ZXBo YW5pZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFu IEJlcm5zdGVpbi4KSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9X ZWJDb3JlLmJhc2UuZXhwCSh3b3JraW5nIGNvcHkpCkBAIC0xNzAsNyArMTcwLDcgQEAgX19aTjdX ZWJDb3JlMTFGcmFtZUxvYWRlcjRsb2FkRVBOU18xNERvYwogX19aTjdXZWJDb3JlMTFGcmFtZUxv YWRlcjRsb2FkRVJLTlNfMTVSZXNvdXJjZVJlcXVlc3RFCiBfX1pON1dlYkNvcmUxMUZyYW1lTG9h ZGVyNGxvYWRFUktOU18xNVJlc291cmNlUmVxdWVzdEVSS05TXzE0U3Vic3RpdHV0ZURhdGFFCiBf X1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyNGxvYWRFUktOU18xNVJlc291cmNlUmVxdWVzdEVSS05T XzZTdHJpbmdFCi1fX1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyNnJlbG9hZEV2CitfX1pON1dlYkNv cmUxMUZyYW1lTG9hZGVyNnJlbG9hZEViCiBfX1pON1dlYkNvcmUxMUZyYW1lTG9hZGVyN2FkZERh dGFFUEtjaQogX19aTjdXZWJDb3JlMTFGcmFtZUxvYWRlcjdjYW5Mb2FkRVJLTlNfNEtVUkxFUktO U182U3RyaW5nRVBLTlNfOERvY3VtZW50RQogX19aTjdXZWJDb3JlMTFIaXN0b3J5SXRlbTEyYWRk Q2hpbGRJdGVtRU4zV1RGMTBQYXNzUmVmUHRySVMwX0VFCkluZGV4OiBXZWJDb3JlL2xvYWRlci9D YWNoZVBvbGljeS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0NhY2hlUG9saWN5LmgJ KHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIvQ2FjaGVQb2xpY3kuaAkod29ya2lu ZyBjb3B5KQpAQCAtMzEsNyArMzEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgZW51bSBD YWNoZVBvbGljeSB7CiAgICAgICAgIENhY2hlUG9saWN5Q2FjaGUsCiAgICAgICAgIENhY2hlUG9s aWN5VmVyaWZ5LAotICAgICAgICBDYWNoZVBvbGljeVJlZnJlc2gsCisgICAgICAgIENhY2hlUG9s aWN5UmV2YWxpZGF0ZSwKICAgICAgICAgQ2FjaGVQb2xpY3lSZWxvYWQKICAgICB9OwogCkluZGV4 OiBXZWJDb3JlL2xvYWRlci9Eb2NMb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbG9h ZGVyL0RvY0xvYWRlci5jcHAJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIvRG9j TG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDgsNyArNDgsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIERvY0xvYWRlcjo6RG9jTG9hZGVyKERvY3VtZW50KiBkb2MpCiAgICAgOiBtX2Nh Y2hlKGNhY2hlKCkpCi0gICAgLCBtX2NhY2hlUG9saWN5KENhY2hlUG9saWN5VmVyaWZ5KQogICAg ICwgbV9kb2MoZG9jKQogICAgICwgbV9yZXF1ZXN0Q291bnQoMCkKICAgICAsIG1fYXV0b0xvYWRJ bWFnZXModHJ1ZSkKQEAgLTc5LDI0ICs3OCwyOCBAQCB2b2lkIERvY0xvYWRlcjo6Y2hlY2tGb3JS ZWxvYWQoY29uc3QgS1VSCiAKICAgICBpZiAoZnVsbFVSTC5pc0VtcHR5KCkpCiAgICAgICAgIHJl dHVybjsKLQotICAgIGlmIChtX2NhY2hlUG9saWN5ID09IENhY2hlUG9saWN5VmVyaWZ5IHx8IG1f Y2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lDYWNoZSkgewotICAgICAgIGlmICghbV9yZWxvYWRl ZFVSTHMuY29udGFpbnMoZnVsbFVSTC5zdHJpbmcoKSkpIHsKLSAgICAgICAgICBDYWNoZWRSZXNv dXJjZSogZXhpc3RpbmcgPSBjYWNoZSgpLT5yZXNvdXJjZUZvclVSTChmdWxsVVJMLnN0cmluZygp KTsKLSAgICAgICAgICBpZiAoZXhpc3RpbmcgJiYgIWV4aXN0aW5nLT5pc1ByZWxvYWRlZCgpICYm IGV4aXN0aW5nLT5tdXN0UmV2YWxpZGF0ZShtX2NhY2hlUG9saWN5KSkgewotICAgICAgICAgICAg ICBjYWNoZSgpLT5yZXZhbGlkYXRlUmVzb3VyY2UoZXhpc3RpbmcsIHRoaXMpOwotICAgICAgICAg ICAgICBtX3JlbG9hZGVkVVJMcy5hZGQoZnVsbFVSTC5zdHJpbmcoKSk7Ci0gICAgICAgICAgfQot ICAgICAgIH0KLSAgICB9IGVsc2UgaWYgKChtX2NhY2hlUG9saWN5ID09IENhY2hlUG9saWN5UmVs b2FkKSB8fCAobV9jYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeVJlZnJlc2gpKSB7Ci0gICAgICAg aWYgKCFtX3JlbG9hZGVkVVJMcy5jb250YWlucyhmdWxsVVJMLnN0cmluZygpKSkgewotICAgICAg ICAgICBDYWNoZWRSZXNvdXJjZSogZXhpc3RpbmcgPSBjYWNoZSgpLT5yZXNvdXJjZUZvclVSTChm dWxsVVJMLnN0cmluZygpKTsKLSAgICAgICAgICAgaWYgKGV4aXN0aW5nICYmICFleGlzdGluZy0+ aXNQcmVsb2FkZWQoKSkgewotICAgICAgICAgICAgICAgLy8gRklYTUU6IFVzZSByZXZhbGlkYXRl UmVzb3VyY2UoKSB0byBpbXBsZW1lbnQgSFRUUCAxLjEgIlNwZWNpZmljIGVuZC10by1lbmQgcmV2 YWxpZGF0aW9uIiBmb3IgcmVndWxhciByZWxvYWRpbmcKLSAgICAgICAgICAgICAgIGNhY2hlKCkt PnJlbW92ZShleGlzdGluZyk7Ci0gICAgICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5hZGQoZnVs bFVSTC5zdHJpbmcoKSk7Ci0gICAgICAgICAgIH0KLSAgICAgICB9CisgICAgCisgICAgaWYgKG1f cmVsb2FkZWRVUkxzLmNvbnRhaW5zKGZ1bGxVUkwuc3RyaW5nKCkpKQorICAgICAgICByZXR1cm47 CisgICAgCisgICAgQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3kgPSB0aGlzLT5jYWNoZVBvbGljeSgp OworICAgIGlmIChjYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeVZlcmlmeSB8fCBjYWNoZVBvbGlj eSA9PSBDYWNoZVBvbGljeUNhY2hlKSB7CisgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlzdGlu ZyA9IGNhY2hlKCktPnJlc291cmNlRm9yVVJMKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAgICBp ZiAoZXhpc3RpbmcgJiYgIWV4aXN0aW5nLT5pc1ByZWxvYWRlZCgpICYmIGV4aXN0aW5nLT5tdXN0 UmV2YWxpZGF0ZShjYWNoZVBvbGljeSkpIHsKKyAgICAgICAgICAgIGNhY2hlKCktPnJldmFsaWRh dGVSZXNvdXJjZShleGlzdGluZywgdGhpcyk7CisgICAgICAgICAgICBtX3JlbG9hZGVkVVJMcy5h ZGQoZnVsbFVSTC5zdHJpbmcoKSk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuOworICAgIH0K KyAgICBpZiAoY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lSZWxvYWQgfHwgY2FjaGVQb2xpY3kg PT0gQ2FjaGVQb2xpY3lSZXZhbGlkYXRlKSB7CisgICAgICAgIENhY2hlZFJlc291cmNlKiBleGlz dGluZyA9IGNhY2hlKCktPnJlc291cmNlRm9yVVJMKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAg ICBpZiAoZXhpc3RpbmcgJiYgIWV4aXN0aW5nLT5pc1ByZWxvYWRlZCgpKSB7CisgICAgICAgICAg ICBpZiAoY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lSZWxvYWQpCisgICAgICAgICAgICAgICAg Y2FjaGUoKS0+cmVtb3ZlKGV4aXN0aW5nKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAg ICAgICBjYWNoZSgpLT5yZXZhbGlkYXRlUmVzb3VyY2UoZXhpc3RpbmcsIHRoaXMpOworICAgICAg ICAgICAgbV9yZWxvYWRlZFVSTHMuYWRkKGZ1bGxVUkwuc3RyaW5nKCkpOworICAgICAgICB9CiAg ICAgfQogfQogCkBAIC0xOTMsOSArMTk2LDYgQEAgQ2FjaGVkUmVzb3VyY2UqIERvY0xvYWRlcjo6 cmVxdWVzdFJlc291cgogICAgICAgICB9CiAgICAgfQogCi0gICAgaWYgKGZyYW1lKCkgJiYgZnJh bWUoKS0+bG9hZGVyKCktPmlzUmVsb2FkaW5nKCkpCi0gICAgICAgIHNldENhY2hlUG9saWN5KENh Y2hlUG9saWN5UmVsb2FkKTsKLQogICAgIGNoZWNrRm9yUmVsb2FkKGZ1bGxVUkwpOwogCiAgICAg Q2FjaGVkUmVzb3VyY2UqIHJlc291cmNlID0gY2FjaGUoKS0+cmVxdWVzdFJlc291cmNlKHRoaXMs IHR5cGUsIGZ1bGxVUkwsIGNoYXJzZXQsIGlzUHJlbG9hZCk7CkBAIC0yNTcsOSArMjU3LDkgQEAg dm9pZCBEb2NMb2FkZXI6OnNldEF1dG9Mb2FkSW1hZ2VzKGJvb2wgZQogICAgIH0KIH0KIAotdm9p ZCBEb2NMb2FkZXI6OnNldENhY2hlUG9saWN5KENhY2hlUG9saWN5IGNhY2hlUG9saWN5KQorQ2Fj aGVQb2xpY3kgRG9jTG9hZGVyOjpjYWNoZVBvbGljeSgpIGNvbnN0CiB7Ci0gICAgbV9jYWNoZVBv bGljeSA9IGNhY2hlUG9saWN5OworICAgIHJldHVybiBmcmFtZSgpID8gZnJhbWUoKS0+bG9hZGVy KCktPmNhY2hlUG9saWN5KCkgOiBDYWNoZVBvbGljeVZlcmlmeTsKIH0KIAogdm9pZCBEb2NMb2Fk ZXI6OnJlbW92ZUNhY2hlZFJlc291cmNlKENhY2hlZFJlc291cmNlKiByZXNvdXJjZSkgY29uc3QK SW5kZXg6IFdlYkNvcmUvbG9hZGVyL0RvY0xvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv bG9hZGVyL0RvY0xvYWRlci5oCShyZXZpc2lvbiAzODIwOSkKKysrIFdlYkNvcmUvbG9hZGVyL0Rv Y0xvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC03Niw4ICs3Niw3IEBAIHB1YmxpYzoKICAgICBi b29sIGF1dG9Mb2FkSW1hZ2VzKCkgY29uc3QgeyByZXR1cm4gbV9hdXRvTG9hZEltYWdlczsgfQog ICAgIHZvaWQgc2V0QXV0b0xvYWRJbWFnZXMoYm9vbCk7CiAgICAgCi0gICAgQ2FjaGVQb2xpY3kg Y2FjaGVQb2xpY3koKSBjb25zdCB7IHJldHVybiBtX2NhY2hlUG9saWN5OyB9Ci0gICAgdm9pZCBz ZXRDYWNoZVBvbGljeShDYWNoZVBvbGljeSk7CisgICAgQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3ko KSBjb25zdDsKICAgICAKICAgICBGcmFtZSogZnJhbWUoKSBjb25zdDsgLy8gQ2FuIGJlIE5VTEwK ICAgICBEb2N1bWVudCogZG9jKCkgY29uc3QgeyByZXR1cm4gbV9kb2M7IH0KQEAgLTExMyw3ICsx MTIsNiBAQCBwcml2YXRlOgogICAgIENhY2hlKiBtX2NhY2hlOwogICAgIEhhc2hTZXQ8U3RyaW5n PiBtX3JlbG9hZGVkVVJMczsKICAgICBtdXRhYmxlIEhhc2hNYXA8U3RyaW5nLCBDYWNoZWRSZXNv dXJjZSo+IG1fZG9jUmVzb3VyY2VzOwotICAgIENhY2hlUG9saWN5IG1fY2FjaGVQb2xpY3k7CiAg ICAgRG9jdW1lbnQqIG1fZG9jOwogICAgIAogICAgIGludCBtX3JlcXVlc3RDb3VudDsKSW5kZXg6 IFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xv YWRlci9GcmFtZUxvYWRlci5jcHAJKHJldmlzaW9uIDM4MjA5KQorKysgV2ViQ29yZS9sb2FkZXIv RnJhbWVMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNDgsMjAgKzE0OCwyMiBAQCBzdHJ1 Y3QgU2NoZWR1bGVkUmVkaXJlY3Rpb24gewogICAgIGludCBoaXN0b3J5U3RlcHM7CiAgICAgYm9v bCBsb2NrSGlzdG9yeTsKICAgICBib29sIHdhc1VzZXJHZXN0dXJlOworICAgIGJvb2wgd2FzUmVm cmVzaDsKIAotICAgIFNjaGVkdWxlZFJlZGlyZWN0aW9uKGRvdWJsZSByZWRpcmVjdERlbGF5LCBj b25zdCBTdHJpbmcmIHJlZGlyZWN0VVJMLCBib29sIHJlZGlyZWN0TG9ja0hpc3RvcnksIGJvb2wg dXNlckdlc3R1cmUpCisgICAgU2NoZWR1bGVkUmVkaXJlY3Rpb24oZG91YmxlIHJlZGlyZWN0RGVs YXksIGNvbnN0IFN0cmluZyYgcmVkaXJlY3RVUkwsIGJvb2wgcmVkaXJlY3RMb2NrSGlzdG9yeSwg Ym9vbCB1c2VyR2VzdHVyZSwgYm9vbCByZWZyZXNoKQogICAgICAgICA6IHR5cGUocmVkaXJlY3Rp b24pCiAgICAgICAgICwgZGVsYXkocmVkaXJlY3REZWxheSkKICAgICAgICAgLCB1cmwocmVkaXJl Y3RVUkwpCiAgICAgICAgICwgaGlzdG9yeVN0ZXBzKDApCiAgICAgICAgICwgbG9ja0hpc3Rvcnko cmVkaXJlY3RMb2NrSGlzdG9yeSkKICAgICAgICAgLCB3YXNVc2VyR2VzdHVyZSh1c2VyR2VzdHVy ZSkKKyAgICAgICAgLCB3YXNSZWZyZXNoKHJlZnJlc2gpCiAgICAgewogICAgIH0KIAogICAgIFNj aGVkdWxlZFJlZGlyZWN0aW9uKFR5cGUgbG9jYXRpb25DaGFuZ2VUeXBlLAogICAgICAgICAgICAg Y29uc3QgU3RyaW5nJiBsb2NhdGlvbkNoYW5nZVVSTCwgY29uc3QgU3RyaW5nJiBsb2NhdGlvbkNo YW5nZVJlZmVycmVyLAotICAgICAgICAgICAgYm9vbCBsb2NhdGlvbkNoYW5nZUxvY2tIaXN0b3J5 LCBib29sIGxvY2F0aW9uQ2hhbmdlV2FzVXNlckdlc3R1cmUpCisgICAgICAgICAgICBib29sIGxv Y2F0aW9uQ2hhbmdlTG9ja0hpc3RvcnksIGJvb2wgbG9jYXRpb25DaGFuZ2VXYXNVc2VyR2VzdHVy ZSwgYm9vbCByZWZyZXNoKQogICAgICAgICA6IHR5cGUobG9jYXRpb25DaGFuZ2VUeXBlKQogICAg ICAgICAsIGRlbGF5KDApCiAgICAgICAgICwgdXJsKGxvY2F0aW9uQ2hhbmdlVVJMKQpAQCAtMTY5 LDYgKzE3MSw3IEBAIHN0cnVjdCBTY2hlZHVsZWRSZWRpcmVjdGlvbiB7CiAgICAgICAgICwgaGlz dG9yeVN0ZXBzKDApCiAgICAgICAgICwgbG9ja0hpc3RvcnkobG9jYXRpb25DaGFuZ2VMb2NrSGlz dG9yeSkKICAgICAgICAgLCB3YXNVc2VyR2VzdHVyZShsb2NhdGlvbkNoYW5nZVdhc1VzZXJHZXN0 dXJlKQorICAgICAgICAsIHdhc1JlZnJlc2gocmVmcmVzaCkKICAgICB7CiAgICAgfQogCkBAIC0x NzgsNiArMTgxLDcgQEAgc3RydWN0IFNjaGVkdWxlZFJlZGlyZWN0aW9uIHsKICAgICAgICAgLCBo aXN0b3J5U3RlcHMoaGlzdG9yeU5hdmlnYXRpb25TdGVwcykKICAgICAgICAgLCBsb2NrSGlzdG9y eShmYWxzZSkKICAgICAgICAgLCB3YXNVc2VyR2VzdHVyZShmYWxzZSkKKyAgICAgICAgLCB3YXNS ZWZyZXNoKGZhbHNlKQogICAgIHsKICAgICB9CiB9OwpAQCAtMjAzLDYgKzIwNyw3IEBAIGJvb2wg aXNCYWNrRm9yd2FyZExvYWRUeXBlKEZyYW1lTG9hZFR5cGUKICAgICAgICAgY2FzZSBGcmFtZUxv YWRUeXBlU3RhbmRhcmQ6CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9hZDoKICAgICAg ICAgY2FzZSBGcmFtZUxvYWRUeXBlUmVsb2FkQWxsb3dpbmdTdGFsZURhdGE6CisgICAgICAgIGNh c2UgRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW46CiAgICAgICAgIGNhc2UgRnJhbWVMb2Fk VHlwZVNhbWU6CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlZGlyZWN0V2l0aExvY2tlZEhp c3Rvcnk6CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlcGxhY2U6CkBAIC0yMzgsNyArMjQz LDYgQEAgRnJhbWVMb2FkZXI6OkZyYW1lTG9hZGVyKEZyYW1lKiBmcmFtZSwgRgogICAgICwgbV9z ZW50UmVkaXJlY3ROb3RpZmljYXRpb24oZmFsc2UpCiAgICAgLCBtX2luU3RvcEFsbExvYWRlcnMo ZmFsc2UpCiAgICAgLCBtX25hdmlnYXRpb25EdXJpbmdMb2FkKGZhbHNlKQotICAgICwgbV9jYWNo ZVBvbGljeShDYWNoZVBvbGljeVZlcmlmeSkKICAgICAsIG1faXNFeGVjdXRpbmdKYXZhU2NyaXB0 Rm9ybUFjdGlvbihmYWxzZSkKICAgICAsIG1faXNSdW5uaW5nU2NyaXB0KGZhbHNlKQogICAgICwg bV9kaWRDYWxsSW1wbGljaXRDbG9zZShmYWxzZSkKQEAgLTM3NCwxOSArMzc4LDE3IEBAIGJvb2wg RnJhbWVMb2FkZXI6OmNhbkhhbmRsZVJlcXVlc3QoY29uc3QKICAgICByZXR1cm4gbV9jbGllbnQt PmNhbkhhbmRsZVJlcXVlc3QocmVxdWVzdCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXI6OmNoYW5n ZUxvY2F0aW9uKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBib29s IGxvY2tIaXN0b3J5LCBib29sIHVzZXJHZXN0dXJlKQordm9pZCBGcmFtZUxvYWRlcjo6Y2hhbmdl TG9jYXRpb24oY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wg bG9ja0hpc3RvcnksIGJvb2wgdXNlckdlc3R1cmUsIGJvb2wgcmVmcmVzaCkKIHsKLSAgICBjaGFu Z2VMb2NhdGlvbihjb21wbGV0ZVVSTCh1cmwpLCByZWZlcnJlciwgbG9ja0hpc3RvcnksIHVzZXJH ZXN0dXJlKTsKKyAgICBjaGFuZ2VMb2NhdGlvbihjb21wbGV0ZVVSTCh1cmwpLCByZWZlcnJlciwg bG9ja0hpc3RvcnksIHVzZXJHZXN0dXJlLCByZWZyZXNoKTsKIH0KIAogCi12b2lkIEZyYW1lTG9h ZGVyOjpjaGFuZ2VMb2NhdGlvbihjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJy ZXIsIGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgdXNlckdlc3R1cmUpCit2b2lkIEZyYW1lTG9hZGVy OjpjaGFuZ2VMb2NhdGlvbihjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIs IGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgdXNlckdlc3R1cmUsIGJvb2wgcmVmcmVzaCkKIHsKICAg ICBSZWZQdHI8RnJhbWU+IHByb3RlY3QobV9mcmFtZSk7CiAKLSAgICBSZXNvdXJjZVJlcXVlc3RD YWNoZVBvbGljeSBwb2xpY3kgPSAobV9jYWNoZVBvbGljeSA9PSBDYWNoZVBvbGljeVJlbG9hZCkg fHwgKG1fY2FjaGVQb2xpY3kgPT0gQ2FjaGVQb2xpY3lSZWZyZXNoKQotICAgICAgICA/IFJlbG9h ZElnbm9yaW5nQ2FjaGVEYXRhIDogVXNlUHJvdG9jb2xDYWNoZVBvbGljeTsKLSAgICBSZXNvdXJj ZVJlcXVlc3QgcmVxdWVzdCh1cmwsIHJlZmVycmVyLCBwb2xpY3kpOworICAgIFJlc291cmNlUmVx dWVzdCByZXF1ZXN0KHVybCwgcmVmZXJyZXIsICByZWZyZXNoID8gUmVsb2FkSWdub3JpbmdDYWNo ZURhdGEgOiBVc2VQcm90b2NvbENhY2hlUG9saWN5KTsKICAgICAKICAgICBpZiAoZXhlY3V0ZUlm SmF2YVNjcmlwdFVSTChyZXF1ZXN0LnVybCgpLCB1c2VyR2VzdHVyZSkpCiAgICAgICAgIHJldHVy bjsKQEAgLTYwOCw3ICs2MTAsNiBAQCB2b2lkIEZyYW1lTG9hZGVyOjpzdG9wTG9hZGluZyhib29s IHNlbmRVCiAgICAgbV9pc0NvbXBsZXRlID0gdHJ1ZTsgLy8gdG8gYXZvaWQgY2FsbGluZyBjb21w bGV0ZWQoKSBpbiBmaW5pc2hlZFBhcnNpbmcoKSAoRGF2aWQpCiAgICAgbV9pc0xvYWRpbmdNYWlu UmVzb3VyY2UgPSBmYWxzZTsKICAgICBtX2RpZENhbGxJbXBsaWNpdENsb3NlID0gdHJ1ZTsgLy8g ZG9uJ3Qgd2FudCB0aGF0IG9uZSBlaXRoZXIKLSAgICBtX2NhY2hlUG9saWN5ID0gQ2FjaGVQb2xp Y3lWZXJpZnk7IC8vIFdoeSBoZXJlPwogCiAgICAgaWYgKG1fZnJhbWUtPmRvY3VtZW50KCkgJiYg bV9mcmFtZS0+ZG9jdW1lbnQoKS0+cGFyc2luZygpKSB7CiAgICAgICAgIGZpbmlzaGVkUGFyc2lu ZygpOwpAQCAtODgwLDcgKzg4MSw2IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlY2VpdmVkRmlyc3RE YXRhKCkKICAgICBpZiAoIXB0aXRsZS5pc051bGwoKSkKICAgICAgICAgbV9jbGllbnQtPmRpc3Bh dGNoRGlkUmVjZWl2ZVRpdGxlKHB0aXRsZSk7CiAKLSAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5k b2NMb2FkZXIoKS0+c2V0Q2FjaGVQb2xpY3kobV9jYWNoZVBvbGljeSk7CiAgICAgbV93b3JraW5n VVJMID0gS1VSTCgpOwogCiAgICAgZG91YmxlIGRlbGF5OwpAQCAtMTAyMyw5ICsxMDIzLDcgQEAg dm9pZCBGcmFtZUxvYWRlcjo6d3JpdGUoY29uc3QgY2hhciogc3RyLAogCiAjaWYgVVNFKExPV19C QU5EV0lEVEhfRElTUExBWSkKICAgICBpZiAobV9mcmFtZS0+ZG9jdW1lbnQoKS0+aW5Mb3dCYW5k d2lkdGhEaXNwbGF5KCkpCi0gICAgICAgIG1fcGVuZGluZ1NvdXJjZUluTG93QmFuZHdpZHRoRGlz cGxheS5hcHBlbmQoZGVjb2RlZCk7Ci0gICAgZWxzZSAvLyByZXNldCBwb2xpY3kgd2hpY2ggaXMg Y2hhbmdlZCBpbiBzd2l0Y2hPdXRMb3dCYW5kd2lkdGhEaXNwbGF5SWZSZWFkeSgpCi0gICAgICAg IG1fZnJhbWUtPmRvY3VtZW50KCktPmRvY0xvYWRlcigpLT5zZXRDYWNoZVBvbGljeShtX2NhY2hl UG9saWN5KTsgICAgCisgICAgICAgIG1fcGVuZGluZ1NvdXJjZUluTG93QmFuZHdpZHRoRGlzcGxh eS5hcHBlbmQoZGVjb2RlZCk7ICAgCiAjZW5kaWYKIAogICAgIGlmICghbV9yZWNlaXZlZERhdGEp IHsKQEAgLTExMTQsNyArMTExMiw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnN0YXJ0SWNvbkxvYWRl cigpCiAgICAgICAgIHJldHVybjsKIAogICAgIC8vIElmIHdlJ3JlIG5vdCByZWxvYWRpbmcgYW5k IHRoZSBpY29uIGRhdGFiYXNlIGRvZXNuJ3Qgc2F5IHRvIGxvYWQgbm93IHRoZW4gYmFpbCBiZWZv cmUgd2UgYWN0dWFsbHkgc3RhcnQgdGhlIGxvYWQKLSAgICBpZiAobG9hZFR5cGUoKSAhPSBGcmFt ZUxvYWRUeXBlUmVsb2FkKSB7CisgICAgaWYgKGxvYWRUeXBlKCkgIT0gRnJhbWVMb2FkVHlwZVJl bG9hZCAmJiBsb2FkVHlwZSgpICE9IEZyYW1lTG9hZFR5cGVSZWxvYWRGcm9tT3JpZ2luKSB7CiAg ICAgICAgIEljb25Mb2FkRGVjaXNpb24gZGVjaXNpb24gPSBpY29uRGF0YWJhc2UoKS0+bG9hZERl Y2lzaW9uRm9ySWNvblVSTCh1cmxTdHJpbmcsIG1fZG9jdW1lbnRMb2FkZXIuZ2V0KCkpOwogICAg ICAgICBpZiAoZGVjaXNpb24gPT0gSWNvbkxvYWRObykgewogICAgICAgICAgICAgTE9HKEljb25E YXRhYmFzZSwgIkZyYW1lTG9hZGVyOjpzdGFydEljb25Mb2FkZXIoKSAtIFRvbGQgbm90IHRvIGxv YWQgdGhpcyBpY29uLCBjb21taXR0aW5nIGljb25VUkwgJXMgdG8gZGF0YWJhc2UgZm9yIHBhZ2VV UkwgbWFwcGluZyIsIHVybFN0cmluZy5hc2NpaSgpLmRhdGEoKSk7CkBAIC0xMjA2LDYgKzEyMDQs NyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpyZXN0b3JlRG9jdW1lbnRTdGF0ZSgpCiAgICAgc3dpdGNo IChsb2FkVHlwZSgpKSB7CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlbG9hZDoKICAgICAg ICAgY2FzZSBGcmFtZUxvYWRUeXBlUmVsb2FkQWxsb3dpbmdTdGFsZURhdGE6CisgICAgICAgIGNh c2UgRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW46CiAgICAgICAgIGNhc2UgRnJhbWVMb2Fk VHlwZVNhbWU6CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJlcGxhY2U6CiAgICAgICAgICAg ICBicmVhazsKQEAgLTEzODAsNyArMTM3OSw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnNjaGVkdWxl SFRUUFJlZGlyZWN0aW8KIAogICAgIC8vIFdlIHdhbnQgYSBuZXcgaGlzdG9yeSBpdGVtIGlmIHRo ZSByZWZyZXNoIHRpbWVvdXQgaXMgPiAxIHNlY29uZC4KICAgICBpZiAoIW1fc2NoZWR1bGVkUmVk aXJlY3Rpb24gfHwgZGVsYXkgPD0gbV9zY2hlZHVsZWRSZWRpcmVjdGlvbi0+ZGVsYXkpCi0gICAg ICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKGRlbGF5LCB1 cmwsIGRlbGF5IDw9IDEsIGZhbHNlKSk7CisgICAgICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3 IFNjaGVkdWxlZFJlZGlyZWN0aW9uKGRlbGF5LCB1cmwsIGRlbGF5IDw9IDEsIGZhbHNlLCBmYWxz ZSkpOwogfQogCiB2b2lkIEZyYW1lTG9hZGVyOjpzY2hlZHVsZUxvY2F0aW9uQ2hhbmdlKGNvbnN0 IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5LCBi b29sIHdhc1VzZXJHZXN0dXJlKQpAQCAtMTM5Miw3ICsxMzkxLDcgQEAgdm9pZCBGcmFtZUxvYWRl cjo6c2NoZWR1bGVMb2NhdGlvbkNoYW5nZQogICAgIC8vIGZyYWdtZW50IHBhcnQsIHdlIGRvbid0 IG5lZWQgdG8gc2NoZWR1bGUgdGhlIGxvY2F0aW9uIGNoYW5nZS4KICAgICBLVVJMIHBhcnNlZFVS TCh1cmwpOwogICAgIGlmIChwYXJzZWRVUkwuaGFzUmVmKCkgJiYgZXF1YWxJZ25vcmluZ1JlZiht X1VSTCwgcGFyc2VkVVJMKSkgewotICAgICAgICBjaGFuZ2VMb2NhdGlvbih1cmwsIHJlZmVycmVy LCBsb2NrSGlzdG9yeSwgd2FzVXNlckdlc3R1cmUpOworICAgICAgICBjaGFuZ2VMb2NhdGlvbih1 cmwsIHJlZmVycmVyLCBsb2NrSGlzdG9yeSwgd2FzVXNlckdlc3R1cmUsIGZhbHNlKTsKICAgICAg ICAgcmV0dXJuOwogICAgIH0KIApAQCAtMTQxMSw3ICsxNDEwLDcgQEAgdm9pZCBGcmFtZUxvYWRl cjo6c2NoZWR1bGVMb2NhdGlvbkNoYW5nZQogCiAgICAgU2NoZWR1bGVkUmVkaXJlY3Rpb246OlR5 cGUgdHlwZSA9IGR1cmluZ0xvYWQKICAgICAgICAgPyBTY2hlZHVsZWRSZWRpcmVjdGlvbjo6bG9j YXRpb25DaGFuZ2VEdXJpbmdMb2FkIDogU2NoZWR1bGVkUmVkaXJlY3Rpb246OmxvY2F0aW9uQ2hh bmdlOwotICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKHR5 cGUsIHVybCwgcmVmZXJyZXIsIGxvY2tIaXN0b3J5LCB3YXNVc2VyR2VzdHVyZSkpOworICAgIHNj aGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxlZFJlZGlyZWN0aW9uKHR5cGUsIHVybCwgcmVm ZXJyZXIsIGxvY2tIaXN0b3J5LCB3YXNVc2VyR2VzdHVyZSwgZmFsc2UpKTsKIH0KIAogdm9pZCBG cmFtZUxvYWRlcjo6c2NoZWR1bGVSZWZyZXNoKGJvb2wgd2FzVXNlckdlc3R1cmUpCkBAIC0xNDMx LDggKzE0MzAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpzY2hlZHVsZVJlZnJlc2goYm9vbCB3CiAK ICAgICBTY2hlZHVsZWRSZWRpcmVjdGlvbjo6VHlwZSB0eXBlID0gZHVyaW5nTG9hZAogICAgICAg ICA/IFNjaGVkdWxlZFJlZGlyZWN0aW9uOjpsb2NhdGlvbkNoYW5nZUR1cmluZ0xvYWQgOiBTY2hl ZHVsZWRSZWRpcmVjdGlvbjo6bG9jYXRpb25DaGFuZ2U7Ci0gICAgc2NoZWR1bGVSZWRpcmVjdGlv bihuZXcgU2NoZWR1bGVkUmVkaXJlY3Rpb24odHlwZSwgbV9VUkwuc3RyaW5nKCksIG1fb3V0Z29p bmdSZWZlcnJlciwgdHJ1ZSwgd2FzVXNlckdlc3R1cmUpKTsKLSAgICBtX2NhY2hlUG9saWN5ID0g Q2FjaGVQb2xpY3lSZWZyZXNoOworICAgIHNjaGVkdWxlUmVkaXJlY3Rpb24obmV3IFNjaGVkdWxl ZFJlZGlyZWN0aW9uKHR5cGUsIG1fVVJMLnN0cmluZygpLCBtX291dGdvaW5nUmVmZXJyZXIsIHRy dWUsIHdhc1VzZXJHZXN0dXJlLCB0cnVlKSk7CiB9CiAKIGJvb2wgRnJhbWVMb2FkZXI6OmlzTG9j YXRpb25DaGFuZ2UoY29uc3QgU2NoZWR1bGVkUmVkaXJlY3Rpb24mIHJlZGlyZWN0aW9uKQpAQCAt MTUxNiw3ICsxNTE0LDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6cmVkaXJlY3Rpb25UaW1lckZpcmVk KAogICAgICAgICBjYXNlIFNjaGVkdWxlZFJlZGlyZWN0aW9uOjpsb2NhdGlvbkNoYW5nZToKICAg ICAgICAgY2FzZSBTY2hlZHVsZWRSZWRpcmVjdGlvbjo6bG9jYXRpb25DaGFuZ2VEdXJpbmdMb2Fk OgogICAgICAgICAgICAgY2hhbmdlTG9jYXRpb24ocmVkaXJlY3Rpb24tPnVybCwgcmVkaXJlY3Rp b24tPnJlZmVycmVyLAotICAgICAgICAgICAgICAgIHJlZGlyZWN0aW9uLT5sb2NrSGlzdG9yeSwg cmVkaXJlY3Rpb24tPndhc1VzZXJHZXN0dXJlKTsKKyAgICAgICAgICAgICAgICByZWRpcmVjdGlv bi0+bG9ja0hpc3RvcnksIHJlZGlyZWN0aW9uLT53YXNVc2VyR2VzdHVyZSwgcmVkaXJlY3Rpb24t Pndhc1JlZnJlc2gpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICBjYXNlIFNjaGVkdWxl ZFJlZGlyZWN0aW9uOjpoaXN0b3J5TmF2aWdhdGlvbjoKICAgICAgICAgICAgIGlmIChyZWRpcmVj dGlvbi0+aGlzdG9yeVN0ZXBzID09IDApIHsKQEAgLTE5MjMsNiArMTkyMSw3IEBAIGJvb2wgRnJh bWVMb2FkZXI6OmNhbkNhY2hlUGFnZSgpCiAgICAgICAgICYmICFpc1F1aWNrUmVkaXJlY3RDb21p bmcoKQogICAgICAgICAmJiBsb2FkVHlwZSAhPSBGcmFtZUxvYWRUeXBlUmVsb2FkIAogICAgICAg ICAmJiBsb2FkVHlwZSAhPSBGcmFtZUxvYWRUeXBlUmVsb2FkQWxsb3dpbmdTdGFsZURhdGEKKyAg ICAgICAgJiYgbG9hZFR5cGUgIT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4KICAgICAg ICAgJiYgbG9hZFR5cGUgIT0gRnJhbWVMb2FkVHlwZVNhbWUKICAgICAgICAgJiYgIW1fZG9jdW1l bnRMb2FkZXItPmlzTG9hZGluZ0luQVBJU2Vuc2UoKQogICAgICAgICAmJiAhbV9kb2N1bWVudExv YWRlci0+aXNTdG9wcGluZygpCkBAIC0yMTQxLDcgKzIxNDAsNyBAQCB2b2lkIEZyYW1lTG9hZGVy Ojpsb2FkVVJMKGNvbnN0IEtVUkwmIG5lCiAgICAgICAgIGFkZEhUVFBPcmlnaW5JZk5lZWRlZChy ZXF1ZXN0LCByZWZlcnJlck9yaWdpbi0+dG9TdHJpbmcoKSk7CiAgICAgfQogICAgIGFkZEV4dHJh RmllbGRzVG9SZXF1ZXN0KHJlcXVlc3QsIHRydWUsIGV2ZW50IHx8IGlzRm9ybVN1Ym1pc3Npb24p OwotICAgIGlmIChuZXdMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkKQorICAgIGlmIChu ZXdMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkIHx8IG5ld0xvYWRUeXBlID09IEZyYW1l TG9hZFR5cGVSZWxvYWRGcm9tT3JpZ2luKQogICAgICAgICByZXF1ZXN0LnNldENhY2hlUG9saWN5 KFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhKTsKIAogICAgIEFTU0VSVChuZXdMb2FkVHlwZSAhPSBG cmFtZUxvYWRUeXBlU2FtZSk7CkBAIC0yNDMyLDcgKzI0MzEsNyBAQCB2b2lkIEZyYW1lTG9hZGVy OjpyZWxvYWRBbGxvd2luZ1N0YWxlRGF0CiAgICAgbG9hZFdpdGhEb2N1bWVudExvYWRlcihsb2Fk ZXIuZ2V0KCksIEZyYW1lTG9hZFR5cGVSZWxvYWRBbGxvd2luZ1N0YWxlRGF0YSwgMCk7CiB9CiAK LXZvaWQgRnJhbWVMb2FkZXI6OnJlbG9hZCgpCit2b2lkIEZyYW1lTG9hZGVyOjpyZWxvYWQoYm9v bCBlbmRUb0VuZFJlbG9hZCkKIHsKICAgICBpZiAoIW1fZG9jdW1lbnRMb2FkZXIpCiAgICAgICAg IHJldHVybjsKQEAgLTI0NTUsOCArMjQ1NCw4IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlbG9hZCgp CiAKICAgICBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QgPSBsb2FkZXItPnJlcXVlc3QoKTsKIAor ICAgIC8vIEZJWE1FOiBXZSBkb24ndCBoYXZlIGEgbWVjaGFuaXNtIHRvIHJldmFsaWRhdGUgdGhl IG1haW4gcmVzb3VyY2Ugd2l0aG91dCByZWxvYWRpbiBhdCB0aGUgbW9tZW50LgogICAgIHJlcXVl c3Quc2V0Q2FjaGVQb2xpY3koUmVsb2FkSWdub3JpbmdDYWNoZURhdGEpOwotICAgIHJlcXVlc3Qu c2V0SFRUUEhlYWRlckZpZWxkKCJDYWNoZS1Db250cm9sIiwgIm1heC1hZ2U9MCIpOwogCiAgICAg Ly8gSWYgd2UncmUgYWJvdXQgdG8gcmUtcG9zdCwgc2V0IHVwIGFjdGlvbiBzbyB0aGUgYXBwbGlj YXRpb24gY2FuIHdhcm4gdGhlIHVzZXIuCiAgICAgaWYgKHJlcXVlc3QuaHR0cE1ldGhvZCgpID09 ICJQT1NUIikKQEAgLTI0NjQsNyArMjQ2Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnJlbG9hZCgp CiAKICAgICBsb2FkZXItPnNldE92ZXJyaWRlRW5jb2RpbmcobV9kb2N1bWVudExvYWRlci0+b3Zl cnJpZGVFbmNvZGluZygpKTsKICAgICAKLSAgICBsb2FkV2l0aERvY3VtZW50TG9hZGVyKGxvYWRl ci5nZXQoKSwgRnJhbWVMb2FkVHlwZVJlbG9hZCwgMCk7CisgICAgbG9hZFdpdGhEb2N1bWVudExv YWRlcihsb2FkZXIuZ2V0KCksIGVuZFRvRW5kUmVsb2FkID8gRnJhbWVMb2FkVHlwZVJlbG9hZEZy b21PcmlnaW4gOiBGcmFtZUxvYWRUeXBlUmVsb2FkLCAwKTsKIH0KIAogc3RhdGljIGJvb2wgY2Fu QWNjZXNzQW5jZXN0b3IoY29uc3QgU2VjdXJpdHlPcmlnaW4qIGFjdGl2ZVNlY3VyaXR5T3JpZ2lu LCBGcmFtZSogdGFyZ2V0RnJhbWUpCkBAIC0yNzk3LDYgKzI3OTYsNyBAQCB2b2lkIEZyYW1lTG9h ZGVyOjp0cmFuc2l0aW9uVG9Db21taXR0ZWQoCiAgICAgICAgICAgICBicmVhazsKIAogICAgICAg ICBjYXNlIEZyYW1lTG9hZFR5cGVSZWxvYWQ6CisgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVJl bG9hZEZyb21PcmlnaW46CiAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZVNhbWU6CiAgICAgICAg IGNhc2UgRnJhbWVMb2FkVHlwZVJlcGxhY2U6CiAgICAgICAgICAgICB1cGRhdGVIaXN0b3J5Rm9y UmVsb2FkKCk7CkBAIC0zMDkzLDYgKzMwOTMsMjYgQEAgRnJhbWVMb2FkVHlwZSBGcmFtZUxvYWRl cjo6bG9hZFR5cGUoKSBjbwogewogICAgIHJldHVybiBtX2xvYWRUeXBlOwogfQorICAgIAorQ2Fj aGVQb2xpY3kgRnJhbWVMb2FkZXI6OmNhY2hlUG9saWN5KCkgY29uc3QKK3sKKyAgICBpZiAobV9p c0NvbXBsZXRlKQorICAgICAgICByZXR1cm4gQ2FjaGVQb2xpY3lWZXJpZnk7CisgICAgCisgICAg aWYgKG1fbG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4pCisgICAgICAg IHJldHVybiBDYWNoZVBvbGljeVJlbG9hZDsKKyAgICAKKyAgICBpZiAoRnJhbWUqIHBhcmVudEZy YW1lID0gbV9mcmFtZS0+dHJlZSgpLT5wYXJlbnQoKSkgeworICAgICAgICBDYWNoZVBvbGljeSBw YXJlbnRDYWNoZVBvbGljeSA9IHBhcmVudEZyYW1lLT5sb2FkZXIoKS0+Y2FjaGVQb2xpY3koKTsK KyAgICAgICAgaWYgKHBhcmVudENhY2hlUG9saWN5ICE9IENhY2hlUG9saWN5VmVyaWZ5KQorICAg ICAgICAgICAgcmV0dXJuIHBhcmVudENhY2hlUG9saWN5OworICAgIH0KKworICAgIGlmIChtX2xv YWRUeXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWQpCisgICAgICAgIHJldHVybiBDYWNoZVBvbGlj eVJldmFsaWRhdGU7CisKKyAgICByZXR1cm4gQ2FjaGVQb2xpY3lWZXJpZnk7Cit9CiAKIHZvaWQg RnJhbWVMb2FkZXI6OnN0b3BQb2xpY3lDaGVjaygpCiB7CkBAIC0zMTY5LDcgKzMxODksNyBAQCB2 b2lkIEZyYW1lTG9hZGVyOjpjaGVja0xvYWRDb21wbGV0ZUZvclRoCiAgICAgICAgICAgICAgCiAg ICAgICAgICAgICAvLyBJZiB0aGUgdXNlciBoYWQgYSBzY3JvbGwgcG9pbnQsIHNjcm9sbCB0byBp dCwgb3ZlcnJpZGluZyB0aGUgYW5jaG9yIHBvaW50IGlmIGFueS4KICAgICAgICAgICAgIGlmIChQ YWdlKiBwYWdlID0gbV9mcmFtZS0+cGFnZSgpKQotICAgICAgICAgICAgICAgIGlmICgoaXNCYWNr Rm9yd2FyZExvYWRUeXBlKG1fbG9hZFR5cGUpIHx8IG1fbG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlw ZVJlbG9hZCkgJiYgcGFnZS0+YmFja0ZvcndhcmRMaXN0KCkpCisgICAgICAgICAgICAgICAgaWYg KChpc0JhY2tGb3J3YXJkTG9hZFR5cGUobV9sb2FkVHlwZSkgfHwgbV9sb2FkVHlwZSA9PSBGcmFt ZUxvYWRUeXBlUmVsb2FkIHx8IG1fbG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21P cmlnaW4pICYmIHBhZ2UtPmJhY2tGb3J3YXJkTGlzdCgpKQogICAgICAgICAgICAgICAgICAgICBy ZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUoKTsKIAogICAgICAgICAgICAgaWYgKG1f Y3JlYXRpbmdJbml0aWFsRW1wdHlEb2N1bWVudCB8fCAhbV9jb21taXR0ZWRGaXJzdFJlYWxEb2N1 bWVudExvYWQpCkBAIC0zNDA3LDYgKzM0MjcsMTAgQEAgdm9pZCBGcmFtZUxvYWRlcjo6YWRkRXh0 cmFGaWVsZHNUb1JlcXVlcwogICAgIGlmIChtX2xvYWRUeXBlID09IEZyYW1lTG9hZFR5cGVSZWxv YWQpIHsKICAgICAgICAgcmVxdWVzdC5zZXRDYWNoZVBvbGljeShSZWxvYWRJZ25vcmluZ0NhY2hl RGF0YSk7CiAgICAgICAgIHJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKCJDYWNoZS1Db250cm9s IiwgIm1heC1hZ2U9MCIpOworICAgIH0gZWxzZSBpZiAobV9sb2FkVHlwZSA9PSBGcmFtZUxvYWRU eXBlUmVsb2FkRnJvbU9yaWdpbikgeworICAgICAgICByZXF1ZXN0LnNldENhY2hlUG9saWN5KFJl bG9hZElnbm9yaW5nQ2FjaGVEYXRhKTsKKyAgICAgICAgcmVxdWVzdC5zZXRIVFRQSGVhZGVyRmll bGQoIkNhY2hlLUNvbnRyb2wiLCAibm8tY2FjaGUiKTsKKyAgICAgICAgcmVxdWVzdC5zZXRIVFRQ SGVhZGVyRmllbGQoIlByYWdtYSIsICJuby1jYWNoZSIpOwogICAgIH0KICAgICAKICAgICAvLyBE b24ndCBzZXQgdGhlIGNvb2tpZSBwb2xpY3kgVVJMIGlmIGl0J3MgYWxyZWFkeSBiZWVuIHNldC4K QEAgLTM0OTgsMTEgKzM1MjIsNiBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkUG9zdFJlcXVlc3Qo Y29uc3QgCiAgICAgICAgIGxvYWRXaXRoTmF2aWdhdGlvbkFjdGlvbih3b3JraW5nUmVzb3VyY2VS ZXF1ZXN0LCBhY3Rpb24sIEZyYW1lTG9hZFR5cGVTdGFuZGFyZCwgZm9ybVN0YXRlLnJlbGVhc2Uo KSk7ICAgIAogfQogCi1ib29sIEZyYW1lTG9hZGVyOjppc1JlbG9hZGluZygpIGNvbnN0Ci17Ci0g ICAgcmV0dXJuIGRvY3VtZW50TG9hZGVyKCktPnJlcXVlc3QoKS5jYWNoZVBvbGljeSgpID09IFJl bG9hZElnbm9yaW5nQ2FjaGVEYXRhOwotfQotCiB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkRW1wdHlE b2N1bWVudFN5bmNocm9ub3VzbHkoKQogewogICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KEtV UkwoIiIpKTsKQEAgLTM2OTUsNiArMzcxNCw3IEBAIGJvb2wgRnJhbWVMb2FkZXI6OnNob3VsZFNj cm9sbFRvQW5jaG9yKGIKIAogICAgIHJldHVybiAhaXNGb3JtU3VibWlzc2lvbgogICAgICAgICAm JiBsb2FkVHlwZSAhPSBGcmFtZUxvYWRUeXBlUmVsb2FkCisgICAgICAgICYmIGxvYWRUeXBlICE9 IEZyYW1lTG9hZFR5cGVSZWxvYWRGcm9tT3JpZ2luCiAgICAgICAgICYmIGxvYWRUeXBlICE9IEZy YW1lTG9hZFR5cGVTYW1lCiAgICAgICAgICYmICFzaG91bGRSZWxvYWQodGhpcy0+dXJsKCksIHVy bCkKICAgICAgICAgLy8gV2UgZG9uJ3Qgd2FudCB0byBqdXN0IHNjcm9sbCBpZiBhIGxpbmsgZnJv bSB3aXRoaW4gYQpAQCAtNDM3NSw2ICs0Mzk1LDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6bG9hZEl0 ZW0oSGlzdG9yeUl0ZW0qIAogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICBz d2l0Y2ggKGxvYWRUeXBlKSB7CiAgICAgICAgICAgICAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlw ZVJlbG9hZDoKKyAgICAgICAgICAgICAgICAgICAgY2FzZSBGcmFtZUxvYWRUeXBlUmVsb2FkRnJv bU9yaWdpbjoKICAgICAgICAgICAgICAgICAgICAgICAgIHJlcXVlc3Quc2V0Q2FjaGVQb2xpY3ko UmVsb2FkSWdub3JpbmdDYWNoZURhdGEpOwogICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7 CiAgICAgICAgICAgICAgICAgICAgIGNhc2UgRnJhbWVMb2FkVHlwZUJhY2s6CkBAIC00NjA4LDcg KzQ2MjksNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjp1cGRhdGVIaXN0b3J5Rm9yUmVsb2FkCiAgICAg aWYgKG1fY3VycmVudEhpc3RvcnlJdGVtKSB7CiAgICAgICAgIHBhZ2VDYWNoZSgpLT5yZW1vdmUo bV9jdXJyZW50SGlzdG9yeUl0ZW0uZ2V0KCkpOwogICAgIAotICAgICAgICBpZiAobG9hZFR5cGUo KSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkKQorICAgICAgICBpZiAobG9hZFR5cGUoKSA9PSBGcmFt ZUxvYWRUeXBlUmVsb2FkIHx8IGxvYWRUeXBlKCkgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21P cmlnaW4pCiAgICAgICAgICAgICBzYXZlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGVUb0l0ZW0o bV9jdXJyZW50SGlzdG9yeUl0ZW0uZ2V0KCkpOwogICAgIAogICAgICAgICAvLyBTb21ldGltZXMg bG9hZGluZyBhIHBhZ2UgYWdhaW4gbGVhZHMgdG8gYSBkaWZmZXJlbnQgcmVzdWx0IGJlY2F1c2Ug b2YgY29va2llcy4gQnVnemlsbGEgNDA3MgpAQCAtNDY1OCw3ICs0Njc5LDcgQEAgdm9pZCBGcmFt ZUxvYWRlcjo6dXBkYXRlSGlzdG9yeUZvckNvbW1pdAogI2VuZGlmCiAgICAgRnJhbWVMb2FkVHlw ZSB0eXBlID0gbG9hZFR5cGUoKTsKICAgICBpZiAoaXNCYWNrRm9yd2FyZExvYWRUeXBlKHR5cGUp IHx8Ci0gICAgICAgICh0eXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWQgJiYgIXByb3Zpc2lvbmFs RG9jdW1lbnRMb2FkZXIoKS0+dW5yZWFjaGFibGVVUkwoKS5pc0VtcHR5KCkpKSB7CisgICAgICAg ICgodHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkIHx8IHR5cGUgPT0gRnJhbWVMb2FkVHlwZVJl bG9hZEZyb21PcmlnaW4pICYmICFwcm92aXNpb25hbERvY3VtZW50TG9hZGVyKCktPnVucmVhY2hh YmxlVVJMKCkuaXNFbXB0eSgpKSkgewogICAgICAgICAvLyBPbmNlIGNvbW1pdHRlZCwgd2Ugd2Fu dCB0byB1c2UgY3VycmVudCBpdGVtIGZvciBzYXZpbmcgRG9jU3RhdGUsIGFuZAogICAgICAgICAv LyB0aGUgcHJvdmlzaW9uYWwgaXRlbSBmb3IgcmVzdG9yaW5nIHN0YXRlLgogICAgICAgICAvLyBO b3RlIHByZXZpb3VzSXRlbSBtdXN0IGJlIHNldCBiZWZvcmUgd2UgY2xvc2UgdGhlIFVSTCwgd2hp Y2ggd2lsbApAQCAtNTE1OCw3ICs1MTc5LDYgQEAgdm9pZCBGcmFtZUxvYWRlcjo6c3dpdGNoT3V0 TG93QmFuZHdpZHRoRAogICAgICAgICAgICAgLy8gd3JpdGUgZGVjb2RlZCBkYXRhIHRvIHRoZSBu ZXcgZG9jLCBzaW1pbGFyIHRvIHdyaXRlKCkKICAgICAgICAgICAgIGlmIChtX3BlbmRpbmdTb3Vy Y2VJbkxvd0JhbmR3aWR0aERpc3BsYXkubGVuZ3RoKCkpIHsKICAgICAgICAgICAgICAgICAvLyBz ZXQgY2FjaGVQb2xpY3kgdG8gQ2FjaGUgdG8gdXNlIHRoZSBsb2FkZWQgcmVzb3VyY2UKLSAgICAg ICAgICAgICAgICBuZXdEb2MtPmRvY0xvYWRlcigpLT5zZXRDYWNoZVBvbGljeShDYWNoZVBvbGlj eUNhY2hlKTsKICAgICAgICAgICAgICAgICBpZiAobV9kZWNvZGVyLT5lbmNvZGluZygpLnVzZXNW aXN1YWxPcmRlcmluZygpKQogICAgICAgICAgICAgICAgICAgICBuZXdEb2MtPnNldFZpc3VhbGx5 T3JkZXJlZCgpOyAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgbmV3RG9jLT5y ZWNhbGNTdHlsZShOb2RlOjpGb3JjZSk7ICAgICAgICAgICAgICAgIApJbmRleDogV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9GcmFtZUxv YWRlci5oCShyZXZpc2lvbiAzODIwOSkKKysrIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgJ KHdvcmtpbmcgY29weSkKQEAgLTE4Niw3ICsxODYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgICAgIGJvb2wgZnJhbWVIYXNMb2FkZWQoKSBjb25zdDsKIAogICAgICAgICBpbnQgbnVtUGVu ZGluZ09yTG9hZGluZ1JlcXVlc3RzKGJvb2wgcmVjdXJzZSkgY29uc3Q7Ci0gICAgICAgIGJvb2wg aXNSZWxvYWRpbmcoKSBjb25zdDsKICAgICAgICAgU3RyaW5nIHJlZmVycmVyKCkgY29uc3Q7CiAg ICAgICAgIFN0cmluZyBvdXRnb2luZ1JlZmVycmVyKCkgY29uc3Q7CiAgICAgICAgIFN0cmluZyBv dXRnb2luZ09yaWdpbigpIGNvbnN0OwpAQCAtMjM4LDcgKzIzNyw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgdm9pZCBjaGVja0NvbnRlbnRQb2xpY3koY29uc3QgU3RyaW5nJiBNSU1F VHlwZSwgQ29udGVudFBvbGljeURlY2lzaW9uRnVuY3Rpb24sIHZvaWQqIGFyZ3VtZW50KTsKICAg ICAgICAgdm9pZCBjYW5jZWxDb250ZW50UG9saWN5Q2hlY2soKTsKIAotICAgICAgICB2b2lkIHJl bG9hZCgpOworICAgICAgICB2b2lkIHJlbG9hZChib29sIGVuZFRvRW5kUmVsb2FkID0gZmFsc2Up OwogICAgICAgICB2b2lkIHJlbG9hZEFsbG93aW5nU3RhbGVEYXRhKGNvbnN0IFN0cmluZyYgb3Zl cnJpZGVFbmNvZGluZyk7CiAKICAgICAgICAgdm9pZCBkaWRSZWNlaXZlU2VydmVyUmVkaXJlY3RG b3JQcm92aXNpb25hbExvYWRGb3JGcmFtZSgpOwpAQCAtMjU0LDYgKzI1Myw3IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciop OwogCiAgICAgICAgIEZyYW1lTG9hZFR5cGUgbG9hZFR5cGUoKSBjb25zdDsKKyAgICAgICAgQ2Fj aGVQb2xpY3kgY2FjaGVQb2xpY3koKSBjb25zdDsKIAogICAgICAgICB2b2lkIGRpZEZpcnN0TGF5 b3V0KCk7CiAgICAgICAgIGJvb2wgZmlyc3RMYXlvdXREb25lKCkgY29uc3Q7CkBAIC0yODAsOCAr MjgwLDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZvaWQgc2V0RGVmZXJzTG9h ZGluZyhib29sKTsKIAotICAgICAgICB2b2lkIGNoYW5nZUxvY2F0aW9uKGNvbnN0IFN0cmluZyYg dXJsLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5ID0gdHJ1ZSwgYm9v bCB1c2VyR2VzdHVyZSA9IGZhbHNlKTsKLSAgICAgICAgdm9pZCBjaGFuZ2VMb2NhdGlvbihjb25z dCBLVVJMJiwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgYm9vbCBsb2NrSGlzdG9yeSA9IHRydWUs IGJvb2wgdXNlckdlc3R1cmUgPSBmYWxzZSk7CisgICAgICAgIHZvaWQgY2hhbmdlTG9jYXRpb24o Y29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIGJvb2wgbG9ja0hpc3Rv cnkgPSB0cnVlLCBib29sIHVzZXJHZXN0dXJlID0gZmFsc2UsIGJvb2wgcmVmcmVzaCA9IGZhbHNl KTsKKyAgICAgICAgdm9pZCBjaGFuZ2VMb2NhdGlvbihjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5n JiByZWZlcnJlciwgYm9vbCBsb2NrSGlzdG9yeSA9IHRydWUsIGJvb2wgdXNlckdlc3R1cmUgPSBm YWxzZSwgYm9vbCByZWZyZXNoID0gZmFsc2UpOwogICAgICAgICB2b2lkIHVybFNlbGVjdGVkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBFdmVudCosIGJvb2wg bG9ja0hpc3RvcnksIGJvb2wgdXNlckdlc3R1cmUpOwogICAgICAgICB2b2lkIHVybFNlbGVjdGVk KGNvbnN0IEZyYW1lTG9hZFJlcXVlc3QmLCBFdmVudCosIGJvb2wgbG9ja0hpc3RvcnkpOwogICAg ICAgCkBAIC02MDYsOCArNjA2LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIFN0 cmluZyBtX291dGdvaW5nUmVmZXJyZXI7CiAKLSAgICAgICAgQ2FjaGVQb2xpY3kgbV9jYWNoZVBv bGljeTsKLQogICAgICAgICBIYXNoU2V0PFN0cmluZz4gbV91cmxzQ2xpZW50S25vd3NBYm91dDsK IAogICAgICAgICBPd25QdHI8Rm9ybVN1Ym1pc3Npb24+IG1fZGVmZXJyZWRGb3JtU3VibWlzc2lv bjsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyVHlwZXMuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlclR5cGVzLmgJKHJldmlzaW9uIDM4MjA5KQorKysg V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJUeXBlcy5oCSh3b3JraW5nIGNvcHkpCkBAIC01NCw3 ICs1NCw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgRnJhbWVMb2FkVHlwZVJlbG9h ZEFsbG93aW5nU3RhbGVEYXRhLAogICAgICAgICBGcmFtZUxvYWRUeXBlU2FtZSwgICAgICAgICAg ICAgICAvLyB1c2VyIGxvYWRzIHNhbWUgVVJMIGFnYWluIChidXQgbm90IHJlbG9hZCBidXR0b24p CiAgICAgICAgIEZyYW1lTG9hZFR5cGVSZWRpcmVjdFdpdGhMb2NrZWRIaXN0b3J5LAotICAgICAg ICBGcmFtZUxvYWRUeXBlUmVwbGFjZQorICAgICAgICBGcmFtZUxvYWRUeXBlUmVwbGFjZSwKKyAg ICAgICAgRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4KICAgICB9OwogCiAgICAgZW51bSBO YXZpZ2F0aW9uVHlwZSB7CkluZGV4OiBXZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcAkocmV2 aXNpb24gMzgyMDkpCisrKyBXZWJDb3JlL2xvYWRlci9OYXZpZ2F0aW9uQWN0aW9uLmNwcAkod29y a2luZyBjb3B5KQpAQCAtNDAsNyArNDAsNyBAQCBzdGF0aWMgTmF2aWdhdGlvblR5cGUgbmF2aWdh dGlvblR5cGUoRnJhCiAgICAgICAgIHJldHVybiBOYXZpZ2F0aW9uVHlwZUZvcm1TdWJtaXR0ZWQ7 CiAgICAgaWYgKGhhdmVFdmVudCkKICAgICAgICAgcmV0dXJuIE5hdmlnYXRpb25UeXBlTGlua0Ns aWNrZWQ7Ci0gICAgaWYgKGZyYW1lTG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZCkKKyAg ICBpZiAoZnJhbWVMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkIHx8IGZyYW1lTG9hZFR5 cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4pCiAgICAgICAgIHJldHVybiBOYXZp Z2F0aW9uVHlwZVJlbG9hZDsKICAgICBpZiAoaXNCYWNrRm9yd2FyZExvYWRUeXBlKGZyYW1lTG9h ZFR5cGUpKQogICAgICAgICByZXR1cm4gTmF2aWdhdGlvblR5cGVCYWNrRm9yd2FyZDsKSW5kZXg6 IFdlYkNvcmUvbG9hZGVyL2xvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIv bG9hZGVyLmNwcAkocmV2aXNpb24gMzgyMDkpCisrKyBXZWJDb3JlL2xvYWRlci9sb2FkZXIuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0yNDksNyArMjQ5LDggQEAgdm9pZCBMb2FkZXI6Okhvc3Q6OnNl cnZlUGVuZGluZ1JlcXVlc3RzKAogICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBsYXN0TW9kaWZp ZWQgPSByZXNvdXJjZVRvUmV2YWxpZGF0ZS0+cmVzcG9uc2UoKS5odHRwSGVhZGVyRmllbGQoIkxh c3QtTW9kaWZpZWQiKTsKICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgZVRhZyA9IHJlc291cmNl VG9SZXZhbGlkYXRlLT5yZXNwb25zZSgpLmh0dHBIZWFkZXJGaWVsZCgiRVRhZyIpOwogICAgICAg ICAgICAgaWYgKCFsYXN0TW9kaWZpZWQuaXNFbXB0eSgpIHx8ICFlVGFnLmlzRW1wdHkoKSkgewot ICAgICAgICAgICAgICAgIGlmIChkb2NMb2FkZXItPmNhY2hlUG9saWN5KCkgPT0gQ2FjaGVQb2xp Y3lSZWxvYWQgfHwgZG9jTG9hZGVyLT5jYWNoZVBvbGljeSgpID09IENhY2hlUG9saWN5UmVmcmVz aCkKKyAgICAgICAgICAgICAgICBBU1NFUlQoZG9jTG9hZGVyLT5jYWNoZVBvbGljeSgpICE9IENh Y2hlUG9saWN5UmVsb2FkKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9jTG9hZGVyLT5jYWNoZVBv bGljeSgpID09IENhY2hlUG9saWN5UmV2YWxpZGF0ZSkKICAgICAgICAgICAgICAgICAgICAgcmVz b3VyY2VSZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZCgiQ2FjaGUtQ29udHJvbCIsICJtYXgtYWdl PTAiKTsKICAgICAgICAgICAgICAgICBpZiAoIWxhc3RNb2RpZmllZC5pc0VtcHR5KCkpCiAgICAg ICAgICAgICAgICAgICAgIHJlc291cmNlUmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoIklmLU1v ZGlmaWVkLVNpbmNlIiwgbGFzdE1vZGlmaWVkKTsK