67229 2011-08-30 14:20:36 -0700 ThreadableLoaderClient should support 'didDownloadData' updates 2011-09-02 17:16:51 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 0 bbudge webkit-unassigned ap beidson darin fishd japhet levin webkit.review.bot oldest_to_newest 459187 0 bbudge 2011-08-30 14:20:36 -0700 ThreadableLoaderClient should have a 'didDownloadData' method, to allow us to pass progress updates from the underlying URL loader up to AssociatedURLLoader. Modify ResourceHandleInternal, ResourceLoader, SubresourceLoader, DocumentThreadableLoader, and finally AssociatedURLLoader to pass the updates to the WebURLLoaderClient. 459201 1 105697 bbudge 2011-08-30 14:29:56 -0700 Created attachment 105697 Proposed Patch 459269 2 ap 2011-08-30 15:33:59 -0700 Does this actually have something to do with downloading? This is a whole lot of completely mysterious code being added to core classes. + if (m_state != ConnectionStateReceivedResponse && m_state != ConnectionStateReceivingData) + CRASH(); Is this intentional? 459271 3 105697 ap 2011-08-30 15:35:27 -0700 Comment on attachment 105697 Proposed Patch I don't think that ResourceHandle ever downloads anything, so adding code to it that talks about downloading doesn't seem to make any sense. 459281 4 fishd 2011-08-30 15:45:41 -0700 The Chromium ResourceHandle knows how to download to disk (to a temporary file). I believe that other ports do not need this functionality. However, it could be generally useful. It could help us implement XMLHttpRequest.responseType("blob"). It could help us implement NPAPI StreamToFile better (without requiring WebCore to produce a temporary file). (This is something that Chromium already does for NPAPI.) We need this change to support the Chromium WebKit API (WebURLLoader returned via WebFrame::createAssociatedURLLoader). We need to plumb this notification through the DocumentThreadableLoader. You can think of didDownloadData as the response equivalent of didSendData, which all ports generate to produce upload notifications. XMLHttpRequest.responseType("blob") will need download progress events. So, this patch seems like a good step forward. 459293 5 beidson 2011-08-30 16:09:10 -0700 This doesn't really make sense. WebCore doesn't download files to disk. All platforms that implement a concept of downloading a file to disk do so in their API layers. If the Chromium loader process is doing the loading of data, and that data is for a file download, why does WebCore need to have this platform specific concept introduced to it instead of the Chromium loader process notifying the Chromium UI process directly? (In reply to comment #4) > The Chromium ResourceHandle knows how to download to disk (to a temporary file). I believe that other ports do not need this functionality. However, it could be generally useful. It could help us implement XMLHttpRequest.responseType("blob"). I think you're saying that this could help responseType("blob") on Chromium because Chromium's ResourceHandle already saves to temporary files. This is not true of WebCore in general. >It could help us implement NPAPI StreamToFile better (without requiring WebCore to produce a temporary file). (This is something that Chromium already does for NPAPI.) I don't understand how this can help any non-Chromium port support this since non-Chromium ports don't have their ResourceHandles stream to files. > We need this change to support the Chromium WebKit API (WebURLLoader returned via WebFrame::createAssociatedURLLoader). We need to plumb this notification through the DocumentThreadableLoader. My understanding of Chromium architecture is not sophisticated, but isn't it actually an opportunity in the case of a file download for the loader process to bypass the WebCore process and notify the UI process directly? > You can think of didDownloadData as the response equivalent of didSendData, which all ports generate to produce upload notifications. Except we already have symmetrical callbacks internal to WebCore - didSendData and didReceiveData. This patch tries to add a second form of didReceiveData which will just cause maintenance and code-comprehension headaches downstream. > XMLHttpRequest.responseType("blob") will need download progress events. So, this patch seems like a good step forward. Except for all platforms besides Chromium, those "download progress events" already exist in the form of didReceiveData. 459294 6 ap 2011-08-30 16:09:48 -0700 A major difference between didDownloadData and didSendData is that downloading is not related to anything that happens inside WebCore. Yet this patch introduces knowledge of unrelated functionality into ResourceLoader, SubresourceLoader and other core classes. 459296 7 beidson 2011-08-30 16:14:03 -0700 ResourceHandle is a super low-level class that arguably has too many high level semantics in it already. This seems like a move to add more high level semantics to it. The same holds true for (Sub)ResourceLoader, which purport to be about "resources" in the HTML/memory cache context. Could we slow down on this and try to work out a better design before we're locked in to something that all platforms regret later? 459321 8 fishd 2011-08-30 16:32:50 -0700 (In reply to comment #5) > This doesn't really make sense. I will try to help. Thank you for taking the time to comment on this review. > WebCore doesn't download files to disk. All platforms that implement a concept of downloading a file to disk do so in their API layers. Yes, but at some cost. In Chromium, the network stack lives in a central process. The child processes, where WebKit runs, do not have access to the disk. Therefore, the central process needs to write data to disk. Having to make the data flow through the child process, only to have high level layers in WebKit redirect that data back up to the central process where it can be written to disk would be very costly. > If the Chromium loader process is doing the loading of data, and that data is for a file download, why does WebCore need to have this platform specific concept introduced to it instead of the Chromium loader process notifying the Chromium UI process directly? We would like the signalling for downloading a resource to flow through WebCore. Our AssociatedURLLoader is a concept much like NetscapePlugInStreamLoader in that it is stopped when window.stop() is called. To support stream-to-file, and progress notifications associated with that, we need to pass this notification through WebCore. > (In reply to comment #4) > > The Chromium ResourceHandle knows how to download to disk (to a temporary file). I believe that other ports do not need this functionality. However, it could be generally useful. It could help us implement XMLHttpRequest.responseType("blob"). > > I think you're saying that this could help responseType("blob") on Chromium because Chromium's ResourceHandle already saves to temporary files. This is not true of WebCore in general. It could be. It is not an unreasonable constraint. The idea of having the network stack directly place data on disk for consumption by the renderer when it needs the data as a file is not foreign. Mozilla's network stack does it (again for NPAPI stream-to-file). > >It could help us implement NPAPI StreamToFile better (without requiring WebCore to produce a temporary file). (This is something that Chromium already does for NPAPI.) > > I don't understand how this can help any non-Chromium port support this since non-Chromium ports don't have their ResourceHandles stream to files. They could! > > We need this change to support the Chromium WebKit API (WebURLLoader returned via WebFrame::createAssociatedURLLoader). We need to plumb this notification through the DocumentThreadableLoader. > > My understanding of Chromium architecture is not sophisticated, but isn't it actually an opportunity in the case of a file download for the loader process to bypass the WebCore process and notify the UI process directly? This is not about the system we use to download files that have an unknown mime type. This is about plugin stream-to-file. In the case of plugins, requests are associated with the document just like other subresources. Again, see NetscapePlugInStreamLoader. We do not use NetscapePlugInStreamLoader because our plugin implementation is external to WebKit. > > You can think of didDownloadData as the response equivalent of didSendData, which all ports generate to produce upload notifications. > > Except we already have symmetrical callbacks internal to WebCore - didSendData and didReceiveData. Yes, but didReceiveData passes the data along. We could fake this in Chromium by using didReceiveData to pass an empty string if that would be helpful, but it seemed like a hack to me. > This patch tries to add a second form of didReceiveData which will just cause maintenance and code-comprehension headaches downstream. I don't think about it that way. ResourceHandle already has other notifications that are Safari specific, yet those are okay? Perhaps we should put didDownloadData in a #if PLATFORM(CHROMIUM) block just as you have put willCacheResponse and shouldCacheResponse in platform specific #ifdefs? 459374 9 beidson 2011-08-30 17:55:00 -0700 I've reordered things a bit to group my replies: (In reply to comment #8) > (In reply to comment #5) > > WebCore doesn't download files to disk. All platforms that implement a concept of downloading a file to disk do so in their API layers. > > Yes, but at some cost. In Chromium, the network stack lives in a central process. The child processes, where WebKit runs, do not have access to the disk. Therefore, the central process needs to write data to disk. Having to make the data flow through the child process, only to have high level layers in WebKit redirect that data back up to the central process where it can be written to disk would be very costly. I don't think anyone suggested this. What you're saying (That the network process is the only one that should be writing to disk) and what I'm saying (that WebCore::ResourceHandle shouldn't have this didDownloadData concept added to it) are not incompatible. > > If the Chromium loader process is doing the loading of data, and that data is for a file download, why does WebCore need to have this platform specific concept introduced to it instead of the Chromium loader process notifying the Chromium UI process directly? > > We would like the signalling for downloading a resource to flow through WebCore. Our AssociatedURLLoader is a concept much like NetscapePlugInStreamLoader in that it is stopped when window.stop() is called. To support stream-to-file, and progress notifications associated with that, we need to pass this notification through WebCore. ...and... > > > We need this change to support the Chromium WebKit API (WebURLLoader returned via WebFrame::createAssociatedURLLoader). We need to plumb this notification through the DocumentThreadableLoader. > > > > My understanding of Chromium architecture is not sophisticated, but isn't it actually an opportunity in the case of a file download for the loader process to bypass the WebCore process and notify the UI process directly? > > This is not about the system we use to download files that have an unknown mime type. This is about plugin stream-to-file. In the case of plugins, requests are associated with the document just like other subresources. Again, see NetscapePlugInStreamLoader. We do not use NetscapePlugInStreamLoader because our plugin implementation is external to WebKit. I think that canonically "download" means for a user to "download a file" to disk. If this is about plugin stream loader, then the name download doesn't quite seem to fit...? One of my main objections here (and I think one of Alexey's too) was that downloading - tradition downloading files to disk for the user to look at later - is not a concept that belongs in WebCore. So maybe that's just a matter of clearing the name up. However, that is definitely not the only objection... > > (In reply to comment #4) > > > The Chromium ResourceHandle knows how to download to disk (to a temporary file). I believe that other ports do not need this functionality. However, it could be generally useful. It could help us implement XMLHttpRequest.responseType("blob"). > > > > I think you're saying that this could help responseType("blob") on Chromium because Chromium's ResourceHandle already saves to temporary files. This is not true of WebCore in general. > > It could be. It is not an unreasonable constraint. The idea of having the network stack directly place data on disk for consumption by the renderer when it needs the data as a file is not foreign. Mozilla's network stack does it (again for NPAPI stream-to-file). > > > > >It could help us implement NPAPI StreamToFile better (without requiring WebCore to produce a temporary file). (This is something that Chromium already does for NPAPI.) > > > > I don't understand how this can help any non-Chromium port support this since non-Chromium ports don't have their ResourceHandles stream to files. > > They could! If they actually planned to, I would agree with this forward thinking. But AFAIK, none of them plan to, so putting this in is of dubious benefit. Now a few replies that contain suggestions for going forward: > > > You can think of didDownloadData as the response equivalent of didSendData, which all ports generate to produce upload notifications. > > > > Except we already have symmetrical callbacks internal to WebCore - didSendData and didReceiveData. > > Yes, but didReceiveData passes the data along. We could fake this in Chromium by using didReceiveData to pass an empty string if that would be helpful, but it seemed like a hack to me. I agree that the current form of didReceiveData passes the data a long, and in this one use case the data itself is not needed. I hate hate HATE the idea of having both a didReceiveData callback *and* a didDownloadData callback. How does a client know when one of them is expected and not the other? How do you decide which one you should listen to based on the names alone? Both internal to WebCore and at WebKit API boundaries, we've had problems like this already where two callbacks seem so similar it's impossible to understand the distinctions by looking at the boundary without an understanding of the history. Should both be called when a chunk of data is delivered? That'd be silly. But I suspect that if this lands, within a year, someone will assume that both should be called for the same chunk of data and we'll start down that slippery road. One possible solution is to change didReceiveData - throughout the entire stack - to account for a mode where it is simply a notification of a number of bytes and doesn't actually include the buffer. I don't know how I feel about this yet but it seems like a viable suggestion. > > This patch tries to add a second form of didReceiveData which will just cause maintenance and code-comprehension headaches downstream. > > I don't think about it that way. ResourceHandle already has other notifications that are Safari specific, yet those are okay? It's unfortunate that these exist, but... > Perhaps we should put didDownloadData in a #if PLATFORM(CHROMIUM) block just as you have put willCacheResponse and shouldCacheResponse in platform specific #ifdefs? ... the Safari-specific stuff is behind platform #ifdefs. Which - at the very least - makes it clear to all other platform coders that they probably don't need to worry about them. I agree that cruft has already been added here that isn't pleasing. The fact of the matter is that while many concepts of "the low level network layer" are common among all the platforms, there's bound to be platform specific additions. At least when they're guarded by #ifdefs in headers, it's clear that the other platforms don't need to worry about them. Also they're implementations tend to be in the platform specific files; from ResourceHandle all the way through ResourceLoader and SubresourceLoader and their clients. We've *mostly* done this with the will/shouldCacheResponse family but I see we didn't completely. That was an oversight. Perhaps another possible way to resolve this - as you suggested - would be to #ifdef it in the header and move the implementations to Chromium specific files. 459442 10 fishd 2011-08-30 22:10:51 -0700 > I think that canonically "download" means for a user to "download a file" to > disk. If this is about plugin stream loader, then the name download doesn't > quite seem to fit...? Hmm, I don't have that problem with the term "download". We use the term "upload" (e.g., XMLHttpRequest can report upload progress events), and "download" just seems like the companion term that refers quite nicely to receiving data over the network. > One of my main objections here (and I think one of Alexey's too) was that > downloading - tradition downloading files to disk for the user to look at later > - is not a concept that belongs in WebCore. So maybe that's just a matter of > clearing the name up. If it is just about the name, then maybe we can come up with something you will like better. To me, I think this is a great choice for a name. It tells you more precisely what is going on. In the Chromium port, we literally have a mode for ResourceHandle that allows it to produce a temporary file that holds the response body of the requested resource. This API is controlled from the ResourceRequest::downloadToFile attribute, and from ResourceResponse you can get the downloadFilePath. When you set downloadToFile to true, it means that the ResourceHandleClient will not have its didReceiveData method called because in this mode the data is not passed directly to the ResourceHandleClient. In this mode, the client only cares to receive the downloaded file. Again, the purpose of this design is to enable optimizations such as the one I described before where the downloaded file may just be a pointer to a file in the HTTP disk cache. This seems like a legitimate feature for a network stack. It may not be a feature that all network stacks possess, but it is surely one that could be emulated if need be. I feel that this is a good foundation for implementing NPAPI Stream-As-File, and it is also no surprise a good foundation for implementing Pepper's Stream-To-File mode. The only thing missing is a way to propagate download progress events. That's where this bug comes in. > I hate hate HATE the idea of having both a didReceiveData callback *and* a didDownloadData > callback. > > How does a client know when one of them is expected and not the other? I understand why this seems bad. Hopefully, my explanation of how the clients opt-in to this mode helps? It seems to me that since the client is asking to load the resource in "download mode" (they set downloadToFile to true), that it is natural for them to receive events named didDownloadData(int). It is also natural that they would not receive didReceiveData calls since in this download mode, there is no desire to receive the actual data directly. > How do you decide which one you should listen to based on the names alone? I think the names are helpful. Again, "download" usually makes people think about files. That's precisely what we are after in this case. > Both internal to WebCore and at WebKit API boundaries, we've had problems like this already > where two callbacks seem so similar it's impossible to understand the distinctions by > looking at the boundary without an understanding of the history. I know that kind of problem. I'm not seeing it in this case because of how strongly "download" makes you think about files. > One possible solution is to change didReceiveData - throughout the entire stack - to account > for a mode where it is simply a notification of a number of bytes and doesn't actually > include the buffer. I feel like this could create error prone code. For example, someone might write code that simply logs the received data. If they didn't realize that the data pointer could sometimes be null, then problems could occur. Overloading didRecieveData for an uncommon use case seems like it will create bugs as people will not remember about this special case. However, with didDownloadData, most people will be able to happily ignore it. Only consumers that care about having the network stack produce a file will care about didDownloadData. > Perhaps another possible way to resolve this - as you suggested - would be to #ifdef it in > the header and move the implementations to Chromium specific files. I now think that this would be the best solution (until other ports implement similar functionality in their network stacks). It is only the PLATFORM(CHROMIUM) version of ResourceRequest that has the downloadToFile attribute, so it can only be Chromium specific code that would care about didDownloadData. I hate #ifdefs, but in this case it probably is warranted. That way someone reading DocumentThreadableLoader and SubresourceLoader, who doesn't work on Chromium, won't need to be concerned about the distinction between didRecieveData and didDownloadData. Finally, another solution we could use is to expose another Client interface for the Chromium port's ResourceHandle. It could be some kind of auxilary Client interface that is used to pass this didDownloadData event upwards. We could expose a ResourceHandle getter on DocumentThreadableLoader that would then allow our AssociatedURLLoader to install this Client interface. To be clear, I find this solution quite unsavory. It is bypassing several layers to access the ResourceHandle directly. It seems like it could therefore be a fragile solution. 459754 11 bbudge 2011-08-31 11:17:50 -0700 Another solution would be to generalize this solution to make it potentially useful to all ports. What if we instead add a new 'didSendEvent' method: void didSendEvent(const ResourceEvent&); where ResourceEvent is like ResourceError, a simple base that can be customized by the ports. This would let us do what we need, and provide a useful mechanism for other ports to communicate up through the loader code, without having to constantly touch this code. I would prefer this to creating a bunch of platform-specific code here. 459855 12 ap 2011-08-31 13:29:47 -0700 CC'ing more people who may have input. We need a mechanism that wouldn't make clients guess what kind of callbacks their ResourceHandle is going to send, and what kind is not going to be sent. It's quite indirect for a client that wants a blob to know that it should listen for didDownloadData instead of didReceiveData. Also, this needs to be done in a way that doesn't expose unwanted concepts to subresource loaders. Finally, I'm still don't think that ResourceHandle is the right class to know about files. Its purpose is to abstract out platform network loading API, and network loading APIs on major platforms don't download to files bypassing memory. A WebCore loader abstraction can certainly do that (in particular, when network loading happens in another process), but it's not the job of an API wrapper. 459869 13 bbudge 2011-08-31 13:39:26 -0700 To clarify, in my last post I was proposing adding a new interface method to pass custom platform events through webkit. The idea is that these events contain extra information but that it is optional and platform specific, somewhat like ResourceError. Perhaps the method could be named slightly differently to emphasize that it's optional, and can be ignored, ie. sentMessage, or sentPlatformMessage, instead of didSendEvent. I'm new to Webkit but it seems like this could be generally useful in the future and could be expanded in a way that doesn't affect loader code. 459877 14 fishd 2011-08-31 13:46:31 -0700 (In reply to comment #12) > We need a mechanism that wouldn't make clients guess what kind of callbacks > their ResourceHandle is going to send, and what kind is not going to be sent. As I mention above, there is no guessing happening here. The mechanism is quite explicit because the client who cares about didDownloadData would have set downloadAsFile to true. > It's quite indirect for a client that wants a blob to know that it should > listen for didDownloadData instead of didReceiveData. Maybe I made a mistake in bringing up XMLHttpRequest.responseType("Blob"). The mechanism at the ResourceHandle level is not about Blobs. It is about producing files. > Also, this needs to be done in a way that doesn't expose unwanted concepts to > subresource loaders. I don't understand what this means. It would help if you could be more specific. > Finally, I'm still don't think that ResourceHandle is the right class to know > about files. Its purpose is to abstract out platform network loading API, and > network loading APIs on major platforms don't download to files bypassing > memory. How do you define "major platforms"? Gecko's network stack and Chromium's network stack each support this concept, and they are part of some very popular platforms. 460042 15 beidson 2011-08-31 16:25:56 -0700 (In reply to comment #14) > (In reply to comment #12) > > We need a mechanism that wouldn't make clients guess what kind of callbacks > > their ResourceHandle is going to send, and what kind is not going to be sent. > > As I mention above, there is no guessing happening here. The mechanism is > quite explicit because the client who cares about didDownloadData would have > set downloadAsFile to true. I don't see where this "downloadAsFile" concept is...? 460056 16 fishd 2011-08-31 16:31:51 -0700 (In reply to comment #15) > I don't see where this "downloadAsFile" concept is...? It exists on ResourceRequest as "downloadToFile". Sorry for the typo. Please see platform/network/chromium/ResourceRequest.h. 460372 17 105938 bbudge 2011-09-01 04:10:39 -0700 Created attachment 105938 Proposed Patch This patch is the same as the previous one, but uses #ifdef PLATFORM(CHROMIUM) to restrict new 'didDownloadData' methods to Chromium port only. 460522 18 ap 2011-09-01 09:41:57 -0700 Can contributors working on other ports ignore Chromium breakage when working on network loading now (like it is the case with v8 bindings)? Otherwise, adding this even under #ifdef adds burden on other ports that I personally consider excessive. 461373 19 105938 fishd 2011-09-02 11:34:42 -0700 Comment on attachment 105938 Proposed Patch View in context: https://bugs.webkit.org/attachment.cgi?id=105938&action=review > Source/WebCore/loader/ResourceLoader.cpp:577 > +#if PLATFORM(CHROMIUM) As discussed in person, I think we should move these method implementations to a separate file named ResourceLoaderChromium.cpp. It should live in loader/chromium/. See loader/mac/ResourceLoaderCFNet.cpp for example. Same goes for the other loader/*.cpp files in this patch. 461401 20 fishd 2011-09-02 11:57:30 -0700 (In reply to comment #18) > Can contributors working on other ports ignore Chromium breakage when working on network loading now (like it is the case with v8 bindings)? > > Otherwise, adding this even under #ifdef adds burden on other ports that I personally consider excessive. I don't understand why you view this as an *excessive* burden. It is simply connecting up some notifications that only the Chromium implementation of ResourceHandle will generate. No other port needs to worry about didDownloadData. There is already convention for routing port specific notifications through these interfaces. Under USE(CFNETWORK), ResourceLoader has willCacheResponse() and shouldCacheResponse() methods, and under HAVE(CFNETWORK_DATA_ARRAY_CALLBACK), SubresourceLoader has supportsDataArray() and didReceiveDataArray() methods. To be clear, I don't like #ifdefs very much, and I would like loader code to be cross-platform. I definitely would encourage work that moves us in that direction. However, it seems unfair to require a higher standard of PLATFORM(CHROMIUM) than what exists for USE(CFNETWORK). I believe that Bill's patch, with the changes I suggested, gets us to a point where PLATFORM(CHROMIUM) is not unlike USE(CFNETWORK) in terms of the ugliness that it imposes on loader/. Furthermore, I believe we've identified an opportunity with good use cases that might inspire better abstractions for encapsulating port-specific differences. That sounds like something we can work on. 461435 21 ap 2011-09-02 12:36:54 -0700 Data arrays are not conceptually different from what every port uses. It's just a different data format for efficiency, but you are still getting response data as normal. WillCache/ShouldCache are a bit more unusual, but they still don't go beyond what every low level network loading API is concerned with. I'm not exactly sure what your proposal is. Is it just like Bill's latest patch, but with part of implementation being in .cpp files, I'm not sure if it's much progress over the first version. Anyone refactoring resource loading would still have the alien concept of "downloading" in mind unless they are allowed to ignore it and break Chromium. 461449 22 106178 bbudge 2011-09-02 12:59:00 -0700 Created attachment 106178 Proposed Patch Here's the version of the patch with Chromium-specific implementation code segregated in separate files in case anyone wants to look at it. 461450 23 106178 fishd 2011-09-02 13:02:27 -0700 Comment on attachment 106178 Proposed Patch This change looks like a clean implementation of the proposed solution. R=me on that basis. CQ- since there is still debate about the solution. 461459 24 fishd 2011-09-02 13:09:30 -0700 (In reply to comment #21) > Data arrays are not conceptually different from what every port uses. It's just a different data format for efficiency, but you are still getting response data as normal. > > WillCache/ShouldCache are a bit more unusual, but they still don't go beyond what every low level network loading API is concerned with. Maybe you are biased toward the port you are most familiar with? I could not tell you what those functions are for unless I spent some time studying the implementation code. I would not feel comfortable refactoring those without reaching out to someone who is familiar with the CFNETWORK port, and that seems like the metric that matters most here. > I'm not exactly sure what your proposal is. Is it just like Bill's latest patch, but with part of implementation being in .cpp files, I'm not sure if it's much progress over the first version. From comment #9, it would appear that Brady is not against this approach. He at least seems to favor this over the original approach. We are open to alternative solutions. Simply asking us not to do this, when we have established that it is a reasonable and valuable thing for a network stack to implement (see comment #10, search for: "the purpose of this design is to enable optimizations"), does not seem constructive to me. If you do not have a constructive alternative solution, then please at least allow us to proceed with what appears to be a par-for-the-course solution. Thanks! 461469 25 ap 2011-09-02 13:23:13 -0700 While downloading is arguably a valuable thing for a network stack to implement, it's not a good thing for a platform network API wrapper to implement. Its goal is nothing more than to abstract away CFNetwork, NSURLConnection, Win32 APIs, etc. Just like ResourceHandle does not have a method to render an HTTP response to a bitmap, it should not have other higher level engine functionality. To proceed with this patch, I would really like to have Maciej weigh in. He is on vacation this week. 461597 26 fishd 2011-09-02 15:50:35 -0700 (In reply to comment #25) > While downloading is arguably a valuable thing for a network stack to implement, it's not a good thing for a platform network API wrapper to implement. Its goal is nothing more than to abstract away CFNetwork, NSURLConnection, Win32 APIs, etc. I don't agree. As I've been saying, a network stack may provide a way to directly reference a file from the HTTP disk cache. How can this be done by a higher layer? > Just like ResourceHandle does not have a method to render an HTTP response to a bitmap, it should not have other higher level engine functionality. I don't understand the relevance of this example. > To proceed with this patch, I would really like to have Maciej weigh in. He is on vacation this week. I am very happy to receive further input. This change is required to fix a bug that we consider a release blocker. I would like to therefore commit it and make revisions once we have received further design input. 461615 27 106219 bbudge 2011-09-02 16:28:32 -0700 Created attachment 106219 Proposed Patch Fixed incorrect copyright headers in new files. 461622 28 beidson 2011-09-02 16:35:41 -0700 (In reply to comment #26) > (In reply to comment #25) > > While downloading is arguably a valuable thing for a network stack to implement, it's not a good thing for a platform network API wrapper to implement. Its goal is nothing more than to abstract away CFNetwork, NSURLConnection, Win32 APIs, etc. > > I don't agree. As I've been saying, a network stack may provide a way to directly reference a file from the HTTP disk cache. How can this be done by a higher layer? But it's demonstrable that at least 2 major network stacks don't *have* files in their HTTP disk cache... 461627 29 fishd 2011-09-02 16:39:31 -0700 (In reply to comment #28) > But it's demonstrable that at least 2 major network stacks don't *have* files in their HTTP disk cache... I never said it was required. I said it could be a valuable optimization. (By the way, Mozilla's HTTP cache will only actually create a separate file if necessary: if the file is very large or if the user has requested to access the stream as a file.) 461629 30 106219 fishd 2011-09-02 16:40:21 -0700 Comment on attachment 106219 Proposed Patch R=me, thanks for fixing the license headers. 461637 31 ap 2011-09-02 16:56:26 -0700 > I don't agree. As I've been saying, a network stack may provide a way to directly reference a file from the HTTP disk cache. How can this be done by a higher layer? This is quite different from what's being done here. A platform specific method to access a file in cache would certainly belong to ResourceHandle if deemed necessary, but I don't think that it would involve generic downloading progress callbacks. I think that the patch has improved in that this code is no longer going to confuse people using ResourceHandle, although it is still not very good for people working on it. I would like to see a refactoring non-network parts of ResourceHandle into a separate class, as discussed before, and as we again discussed on IRC now. Given the apparent time constraints, it will have to be done later. 461640 32 ap 2011-09-02 16:57:49 -0700 > no longer going to confuse people using ResourceHandle More precisely, using the loader stack. 461641 33 fishd 2011-09-02 16:58:45 -0700 (In reply to comment #31) > > I don't agree. As I've been saying, a network stack may provide a way to directly reference a file from the HTTP disk cache. How can this be done by a higher layer? > > This is quite different from what's being done here. A platform specific method to access a file in cache would certainly belong to ResourceHandle if deemed necessary, but I don't think that it would involve generic downloading progress callbacks. Just for completeness, the idea is to provide an API that either transparently downloads a file or vends a file from the HTTP cache. In the first case, progress events are quite important. In the latter case, progress events are not necessary. > I think that the patch has improved in that this code is no longer going to confuse people using ResourceHandle, although it is still not very good for people working on it. I would like to see a refactoring non-network parts of ResourceHandle into a separate class, as discussed before, and as we again discussed on IRC now. Given the apparent time constraints, it will have to be done later. Thanks for understanding. CQ+'ing this patch now. Very happy to take ongoing feedback for improving this code. 461651 34 106219 webkit.review.bot 2011-09-02 17:16:45 -0700 Comment on attachment 106219 Proposed Patch Clearing flags on attachment: 106219 Committed r94466: <http://trac.webkit.org/changeset/94466> 461652 35 webkit.review.bot 2011-09-02 17:16:51 -0700 All reviewed patches have been landed. Closing bug. 105697 2011-08-30 14:29:56 -0700 2011-09-01 04:10:39 -0700 Proposed Patch didFinishLoading.diff text/plain 16617 bbudge SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0MTA4KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMDgtMzAgIEJpbGwgQnVk Z2UgIDxiYnVkZ2VAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBhIFRocmVhZGFibGVMb2Fk ZXJDbGllbnQ6OmRpZERvd25sb2FkRGF0YSBtZXRob2QsIHRvIGFsbG93IHVzIHRvIHBhc3MKKyAg ICAgICAgcHJvZ3Jlc3MgdXBkYXRlcyBmcm9tIHRoZSB1bmRlcmx5aW5nIFVSTCBsb2FkZXIgdXAg dG8gQXNzb2NpYXRlZFVSTExvYWRlci4KKyAgICAgICAgTW9kaWZ5IFJlc291cmNlSGFuZGxlSW50 ZXJuYWwsIFJlc291cmNlTG9hZGVyLCBTdWJyZXNvdXJjZUxvYWRlciwKKyAgICAgICAgRG9jdW1l bnRUaHJlYWRhYmxlTG9hZGVyLCBhbmQgZmluYWxseSBBc3NvY2lhdGVkVVJMTG9hZGVyIHRvIHBh c3MgdGhlCisgICAgICAgIHVwZGF0ZXMgdG8gdGhlIFdlYlVSTExvYWRlckNsaWVudC4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY3MjI5CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiBF eHBvc2VzIG5vIG5ldyBmdW5jdGlvbmFsaXR5LgorCisgICAgICAgICogbG9hZGVyL0RvY3VtZW50 VGhyZWFkYWJsZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFRocmVhZGFi bGVMb2FkZXI6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVyL0RvY3VtZW50VGhy ZWFkYWJsZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9SZXNvdXJjZUxvYWRlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAg ICAgKiBsb2FkZXIvUmVzb3VyY2VMb2FkZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvU3VicmVzb3Vy Y2VMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3VicmVzb3VyY2VMb2FkZXI6OmRpZERv d25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmg6CisgICAg ICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTdWJyZXNvdXJjZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBs b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFk YWJsZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBsb2FkZXIvVGhy ZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZGFi bGVMb2FkZXJDbGllbnRXcmFwcGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIHBsYXRm b3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlJl c291cmNlSGFuZGxlQ2xpZW50OjpkaWREb3dubG9hZERhdGEpOgorCiAyMDExLTA4LTMwICBUb255 IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgcmVmYWN0b3IgYm94LW9yZGlu YWwtZ3JvdXAgaGFuZGxpbmcgc28gd2UgZG9uJ3QgdGltZW91dCBvbiBsYXJnZSB2YWx1ZXMKSW5k ZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2Fk ZXIuY3BwCShyZXZpc2lvbiA5NDA2NCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVu dFRocmVhZGFibGVMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMjMsNiArMjIzLDE1IEBA IHZvaWQgRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyOjpkaWRSZWNlaXYKICAgICB9CiB9CiAKK3Zv aWQgRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyOjpkaWREb3dubG9hZERhdGEoU3VicmVzb3VyY2VM b2FkZXIqIGxvYWRlciwgaW50IGRhdGFMZW5ndGgpCit7CisgICAgQVNTRVJUKG1fY2xpZW50KTsK KyAgICBBU1NFUlRfVU5VU0VEKGxvYWRlciwgbG9hZGVyID09IG1fbG9hZGVyKTsKKyAgICBBU1NF UlQoIW1fYWN0dWFsUmVxdWVzdCk7CisKKyAgICBtX2NsaWVudC0+ZGlkRG93bmxvYWREYXRhKGRh dGFMZW5ndGgpOworfQorCiB2b2lkIERvY3VtZW50VGhyZWFkYWJsZUxvYWRlcjo6ZGlkUmVjZWl2 ZURhdGEoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgY29uc3QgY2hhciogZGF0YSwgaW50IGRh dGFMZW5ndGgpCiB7CiAgICAgQVNTRVJUKG1fY2xpZW50KTsKSW5kZXg6IFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmgJKHJldmlzaW9uIDk0MDY0 KQorKysgU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5oCSh3 b3JraW5nIGNvcHkpCkBAIC03Nyw2ICs3Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAg ICAgdmlydHVhbCB2b2lkIGRpZFNlbmREYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgdW5zaWduZWQg bG9uZyBsb25nIGJ5dGVzU2VudCwgdW5zaWduZWQgbG9uZyBsb25nIHRvdGFsQnl0ZXNUb0JlU2Vu dCk7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShTdWJyZXNvdXJj ZUxvYWRlciosIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsKKyAgICAgICAgdmlydHVhbCB2b2lk IGRpZERvd25sb2FkRGF0YShTdWJyZXNvdXJjZUxvYWRlciosIGludCBkYXRhTGVuZ3RoKTsKICAg ICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29u c3QgY2hhciosIGludCBkYXRhTGVuZ3RoKTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2Vp dmVDYWNoZWRNZXRhZGF0YShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IGNoYXIqLCBpbnQgZGF0 YUxlbmd0aCk7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRGaW5pc2hMb2FkaW5nKFN1YnJlc291 cmNlTG9hZGVyKiwgZG91YmxlKTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJj ZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvbG9hZGVyL1Jlc291cmNl TG9hZGVyLmNwcAkocmV2aXNpb24gOTQwNjQpCisrKyBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvUmVz b3VyY2VMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yODEsNiArMjgxLDE2IEBAIHZvaWQg UmVzb3VyY2VMb2FkZXI6OmRpZFJlY2VpdmVSZXNwb25zZSgKICAgICAgICAgZnJhbWVMb2FkZXIo KS0+bm90aWZpZXIoKS0+ZGlkUmVjZWl2ZVJlc3BvbnNlKHRoaXMsIG1fcmVzcG9uc2UpOwogfQog Cit2b2lkIFJlc291cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEoaW50IGxlbmd0aCkKK3sKKyNp ZiBFTkFCTEUoT0ZGTElORV9XRUJfQVBQTElDQVRJT05TKQorICAgIGlmICghbV9jYW5jZWxsZWQg JiYgIWZhc3RNYWxsb2NTaXplKGRvY3VtZW50TG9hZGVyKCktPmFwcGxpY2F0aW9uQ2FjaGVIb3N0 KCkpKQorICAgICAgICBDUkFTSCgpOworI2VuZGlmCisgICAgaWYgKCFtX2NhbmNlbGxlZCAmJiAh ZmFzdE1hbGxvY1NpemUoZG9jdW1lbnRMb2FkZXIoKS0+ZnJhbWUoKSkpCisgICAgICAgIENSQVNI KCk7Cit9CisKIHZvaWQgUmVzb3VyY2VMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIq IGRhdGEsIGludCBsZW5ndGgsIGxvbmcgbG9uZyBlbmNvZGVkRGF0YUxlbmd0aCwgYm9vbCBhbGxB dE9uY2UpCiB7CiAjaWYgRU5BQkxFKE9GRkxJTkVfV0VCX0FQUExJQ0FUSU9OUykKQEAgLTQ1NCw2 ICs0NjQsMTEgQEAgdm9pZCBSZXNvdXJjZUxvYWRlcjo6ZGlkUmVjZWl2ZVJlc3BvbnNlKAogICAg IGRpZFJlY2VpdmVSZXNwb25zZShyZXNwb25zZSk7CiB9CiAKK3ZvaWQgUmVzb3VyY2VMb2FkZXI6 OmRpZERvd25sb2FkRGF0YShSZXNvdXJjZUhhbmRsZSosIGludCBsZW5ndGgpCit7CisgICAgZGlk RG93bmxvYWREYXRhKGxlbmd0aCk7Cit9CisKIHZvaWQgUmVzb3VyY2VMb2FkZXI6OmRpZFJlY2Vp dmVEYXRhKFJlc291cmNlSGFuZGxlKiwgY29uc3QgY2hhciogZGF0YSwgaW50IGxlbmd0aCwgaW50 IGVuY29kZWREYXRhTGVuZ3RoKQogewogICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbkNvb2tp ZSBjb29raWUgPSBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OndpbGxSZWNlaXZlUmVzb3VyY2VE YXRhKG1fZnJhbWUuZ2V0KCksIGlkZW50aWZpZXIoKSk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvUmVzb3VyY2VMb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvUmVzb3VyY2VMb2FkZXIuaAkocmV2aXNpb24gOTQwNjQpCisrKyBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvUmVzb3VyY2VMb2FkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNzksNiArNzksNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3aWxsU2VuZFJlcXVlc3Qo UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVkaXJlY3RSZXNwb25z ZSk7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRTZW5kRGF0YSh1bnNpZ25lZCBsb25nIGxvbmcg Ynl0ZXNTZW50LCB1bnNpZ25lZCBsb25nIGxvbmcgdG90YWxCeXRlc1RvQmVTZW50KTsKICAgICAg ICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShjb25zdCBSZXNvdXJjZVJlc3BvbnNl Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoaW50KTsKICAgICAgICAg dmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIqLCBpbnQsIGxvbmcgbG9uZyBl bmNvZGVkRGF0YUxlbmd0aCwgYm9vbCBhbGxBdE9uY2UpOwogICAgICAgICB2aXJ0dWFsIHZvaWQg ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKGNvbnN0IGNoYXIqLCBpbnQpIHsgfQogICAgICAgICB2 b2lkIHdpbGxTdG9wQnVmZmVyaW5nRGF0YShjb25zdCBjaGFyKiwgaW50KTsKQEAgLTEwMCw2ICsx MDEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3aWxsU2Vu ZFJlcXVlc3QoUmVzb3VyY2VIYW5kbGUqLCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBSZXNvdXJj ZVJlc3BvbnNlJiByZWRpcmVjdFJlc3BvbnNlKTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFNl bmREYXRhKFJlc291cmNlSGFuZGxlKiwgdW5zaWduZWQgbG9uZyBsb25nIGJ5dGVzU2VudCwgdW5z aWduZWQgbG9uZyBsb25nIHRvdGFsQnl0ZXNUb0JlU2VudCk7CiAgICAgICAgIHZpcnR1YWwgdm9p ZCBkaWRSZWNlaXZlUmVzcG9uc2UoUmVzb3VyY2VIYW5kbGUqLCBjb25zdCBSZXNvdXJjZVJlc3Bv bnNlJik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5k bGUqLCBpbnQpOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGEoUmVzb3VyY2VI YW5kbGUqLCBjb25zdCBjaGFyKiwgaW50LCBpbnQgZW5jb2RlZERhdGFMZW5ndGgpOwogICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFJlc291cmNlSGFuZGxlKiwg Y29uc3QgY2hhciogZGF0YSwgaW50IGxlbmd0aCkgeyBkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEo ZGF0YSwgbGVuZ3RoKTsgfQogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRmluaXNoTG9hZGluZyhS ZXNvdXJjZUhhbmRsZSosIGRvdWJsZSBmaW5pc2hUaW1lKTsKSW5kZXg6IFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNv cmUvbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmNwcAkocmV2aXNpb24gOTQwNjQpCisrKyBTb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvU3VicmVzb3VyY2VMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xNTksNiArMTU5LDIwIEBAIHZvaWQgU3VicmVzb3VyY2VMb2FkZXI6OmRpZFJlY2VpdmVSZXNw b24KICAgICB9CiB9CiAKK3ZvaWQgU3VicmVzb3VyY2VMb2FkZXI6OmRpZERvd25sb2FkRGF0YShp bnQgbGVuZ3RoKQoreworICAgIC8vIFJlZmVyZW5jZSB0aGUgb2JqZWN0IGluIHRoaXMgbWV0aG9k IHNpbmNlIHRoZSBhZGRpdGlvbmFsIHByb2Nlc3NpbmcgY2FuIGRvCisgICAgLy8gYW55dGhpbmcg aW5jbHVkaW5nIHJlbW92aW5nIHRoZSBsYXN0IHJlZmVyZW5jZSB0byB0aGlzIG9iamVjdDsgb25l IGV4YW1wbGUgb2YgdGhpcyBpcyAzMjY2MjE2LgorICAgIFJlZlB0cjxTdWJyZXNvdXJjZUxvYWRl cj4gcHJvdGVjdCh0aGlzKTsKKyAgICAKKyAgICBSZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWRE YXRhKGxlbmd0aCk7CisKKyAgICAvLyBBIHN1YnJlc291cmNlIGxvYWRlciBkb2VzIG5vdCBsb2Fk IG11bHRpcGFydCBzZWN0aW9ucyBwcm9ncmVzc2l2ZWx5LgorICAgIC8vIFNvIGRvbid0IGRlbGl2 ZXIgYW55IGRhdGEgdG8gdGhlIGxvYWRlciB5ZXQuCisgICAgaWYgKG1fY2xpZW50KQorICAgICAg ICBtX2NsaWVudC0+ZGlkRG93bmxvYWREYXRhKHRoaXMsIGxlbmd0aCk7Cit9CisKIHZvaWQgU3Vi cmVzb3VyY2VMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIqIGRhdGEsIGludCBsZW5n dGgsIGxvbmcgbG9uZyBlbmNvZGVkRGF0YUxlbmd0aCwgYm9vbCBhbGxBdE9uY2UpCiB7CiAgICAg Ly8gUmVmZXJlbmNlIHRoZSBvYmplY3QgaW4gdGhpcyBtZXRob2Qgc2luY2UgdGhlIGFkZGl0aW9u YWwgcHJvY2Vzc2luZyBjYW4gZG8KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNv dXJjZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNv dXJjZUxvYWRlci5oCShyZXZpc2lvbiA5NDA2NCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9T dWJyZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC01Miw2ICs1Miw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lkIHdpbGxTZW5kUmVxdWVzdChSZXNv dXJjZVJlcXVlc3QmLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZWRpcmVjdFJlc3BvbnNlKTsK ICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFNlbmREYXRhKHVuc2lnbmVkIGxvbmcgbG9uZyBieXRl c1NlbnQsIHVuc2lnbmVkIGxvbmcgbG9uZyB0b3RhbEJ5dGVzVG9CZVNlbnQpOwogICAgICAgICB2 aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsK KyAgICAgICAgdmlydHVhbCB2b2lkIGRpZERvd25sb2FkRGF0YShpbnQpOwogICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGEoY29uc3QgY2hhciosIGludCwgbG9uZyBsb25nIGVuY29k ZWREYXRhTGVuZ3RoLCBib29sIGFsbEF0T25jZSk7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRS ZWNlaXZlQ2FjaGVkTWV0YWRhdGEoY29uc3QgY2hhciosIGludCk7CiAgICAgICAgIHZpcnR1YWwg dm9pZCBkaWRGaW5pc2hMb2FkaW5nKGRvdWJsZSBmaW5pc2hUaW1lKTsKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5 NDA2NCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC00Niw2ICs0Niw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZv aWQgZGlkU2VuZERhdGEoU3VicmVzb3VyY2VMb2FkZXIqLCB1bnNpZ25lZCBsb25nIGxvbmcgLypi eXRlc1NlbnQqLywgdW5zaWduZWQgbG9uZyBsb25nIC8qdG90YWxCeXRlc1RvQmVTZW50Ki8pIHsg fQogCiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShTdWJyZXNvdXJjZUxvYWRl ciosIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93 bmxvYWREYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KICAg ICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGEoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBj aGFyKiwgaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2 ZUNhY2hlZE1ldGFkYXRhKFN1YnJlc291cmNlTG9hZGVyKiwgY29uc3QgY2hhciosIGludCAvKmRh dGFMZW5ndGgqLykgeyB9CiAgICAgdmlydHVhbCB2b2lkIGRpZEZpbmlzaExvYWRpbmcoU3VicmVz b3VyY2VMb2FkZXIqLCBkb3VibGUgLypmaW5pc2hUaW1lKi8pIHsgfQpJbmRleDogU291cmNlL1dl YkNvcmUvbG9hZGVyL1RocmVhZGFibGVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5NDA2 NCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50LmgJKHdv cmtpbmcgY29weSkKQEAgLTQzLDYgKzQzLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlkU2VuZERhdGEodW5zaWduZWQgbG9uZyBsb25nIC8qYnl0ZXNTZW50 Ki8sIHVuc2lnbmVkIGxvbmcgbG9uZyAvKnRvdGFsQnl0ZXNUb0JlU2VudCovKSB7IH0KIAogICAg ICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKHVuc2lnbmVkIGxvbmcgLyppZGVu dGlmaWVyKi8sIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKSB7IH0KKyAgICAgICAgdmlydHVhbCB2 b2lkIGRpZERvd25sb2FkRGF0YShpbnQgLypkYXRhTGVuZ3RoKi8pIHsgfQogICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGEoY29uc3QgY2hhciosIGludCAvKmRhdGFMZW5ndGgqLykg eyB9CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEoY29uc3Qg Y2hhciosIGludCAvKmRhdGFMZW5ndGgqLykgeyB9CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRG aW5pc2hMb2FkaW5nKHVuc2lnbmVkIGxvbmcgLyppZGVudGlmaWVyKi8sIGRvdWJsZSAvKmZpbmlz aFRpbWUqLykgeyB9CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvVGhyZWFkYWJsZUxvYWRl ckNsaWVudFdyYXBwZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvVGhy ZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaAkocmV2aXNpb24gOTQwNjQpCisrKyBTb3VyY2Uv V2ViQ29yZS9sb2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaAkod29ya2luZyBj b3B5KQpAQCAtNjgsNiArNjgsMTIgQEAgcHVibGljOgogICAgICAgICAgICAgbV9jbGllbnQtPmRp ZFJlY2VpdmVSZXNwb25zZShpZGVudGlmaWVyLCByZXNwb25zZSk7CiAgICAgfQogCisgICAgdm9p ZCBkaWREb3dubG9hZERhdGEoaW50IGRhdGFMZW5ndGgpCisgICAgeworICAgICAgICBpZiAobV9j bGllbnQpCisgICAgICAgICAgICBtX2NsaWVudC0+ZGlkRG93bmxvYWREYXRhKGRhdGFMZW5ndGgp OworICAgIH0KKwogICAgIHZvaWQgZGlkUmVjZWl2ZURhdGEoY29uc3QgY2hhciogZGF0YSwgaW50 IGRhdGFMZW5ndGgpCiAgICAgewogICAgICAgICBpZiAobV9jbGllbnQpCkluZGV4OiBTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUNsaWVu dC5oCShyZXZpc2lvbiA5NDA2NCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv UmVzb3VyY2VIYW5kbGVDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAtNzUsNiArNzUsNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNw b25zZShSZXNvdXJjZUhhbmRsZSosIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKSB7IH0KICAgICAg ICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKFJlc291cmNlSGFuZGxlKiwgY29uc3QgY2hh ciosIGludCwgaW50IC8qZW5jb2RlZERhdGFMZW5ndGgqLykgeyB9CisgICAgICAgIHZpcnR1YWwg dm9pZCBkaWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5kbGUqLCBpbnQgLypkYXRhTGVuZ3RoKi8p IHsgfQogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKFJlc291 cmNlSGFuZGxlKiwgY29uc3QgY2hhciosIGludCkgeyB9CiAgICAgICAgIHZpcnR1YWwgdm9pZCBk aWRGaW5pc2hMb2FkaW5nKFJlc291cmNlSGFuZGxlKiwgZG91YmxlIC8qZmluaXNoVGltZSovKSB7 IH0KICAgICAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoUmVzb3VyY2VIYW5kbGUqLCBjb25zdCBS ZXNvdXJjZUVycm9yJikgeyB9CkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxv Zwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkocmV2aXNp b24gOTQxMTApCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDIzIEBACisyMDExLTA4LTMwICBCaWxsIEJ1ZGdlICA8YmJ1ZGdlQGNo cm9taXVtLm9yZz4KKworICAgICAgICBBZGQgYSBUaHJlYWRhYmxlTG9hZGVyQ2xpZW50OjpkaWRE b3dubG9hZERhdGEgbWV0aG9kLCB0byBhbGxvdyB1cyB0byBwYXNzCisgICAgICAgIHByb2dyZXNz IHVwZGF0ZXMgZnJvbSB0aGUgdW5kZXJseWluZyBVUkwgbG9hZGVyIHVwIHRvIEFzc29jaWF0ZWRV UkxMb2FkZXIuCisgICAgICAgIE1vZGlmeSBSZXNvdXJjZUhhbmRsZUludGVybmFsLCBSZXNvdXJj ZUxvYWRlciwgU3VicmVzb3VyY2VMb2FkZXIsCisgICAgICAgIERvY3VtZW50VGhyZWFkYWJsZUxv YWRlciwgYW5kIGZpbmFsbHkgQXNzb2NpYXRlZFVSTExvYWRlciB0byBwYXNzIHRoZQorICAgICAg ICB1cGRhdGVzIHRvIHRoZSBXZWJVUkxMb2FkZXJDbGllbnQuCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NzIyOQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogc3JjL0Fzc29jaWF0ZWRVUkxMb2FkZXIuY3Bw OgorICAgICAgICAoV2ViS2l0OjpBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVyOjpD bGllbnRBZGFwdGVyKToKKyAgICAgICAgKFdlYktpdDo6QXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xp ZW50QWRhcHRlcjo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKFdlYktpdDo6QXNzb2NpYXRl ZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkUmVjZWl2ZURhdGEpOgorICAgICAgICAoV2Vi S2l0OjpBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVyOjpkaWRGaW5pc2hMb2FkaW5n KToKKyAgICAgICAgKiBzcmMvUmVzb3VyY2VIYW5kbGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 UmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBzcmMv UmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oOgorCiAyMDExLTA4LTMwICBOYXQgRHVjYSAgPG5kdWNh QGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1dIEFsbG93IEdyYXBoaWNzQ29udGV4 dHMgdG8gYmUgY3JlYXRlZCBmcm9tIE1vY2tXZWJHcmFwaGljc0NvbnRleHRzCkluZGV4OiBTb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcAko cmV2aXNpb24gOTQwNjQpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NvY2lhdGVk VVJMTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjMsNiArNjMsNyBAQCBwdWJsaWM6CiAg ICAgdmlydHVhbCB2b2lkIHdpbGxTZW5kUmVxdWVzdChSZXNvdXJjZVJlcXVlc3QmIC8qbmV3UmVx dWVzdCovLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiAvKnJlZGlyZWN0UmVzcG9uc2UqLyk7CiAK ICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKHVuc2lnbmVkIGxvbmcsIGNvbnN0 IFJlc291cmNlUmVzcG9uc2UmKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGlu dCAvKmRhdGFMZW5ndGgqLyk7CiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVEYXRhKGNvbnN0 IGNoYXIqLCBpbnQgLypkYXRhTGVuZ3RoKi8pOwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZl Q2FjaGVkTWV0YWRhdGEoY29uc3QgY2hhciosIGludCAvKmRhdGFMZW5ndGgqLyk7CiAgICAgdmly dHVhbCB2b2lkIGRpZEZpbmlzaExvYWRpbmcodW5zaWduZWQgbG9uZyAvKmlkZW50aWZpZXIqLywg ZG91YmxlIC8qZmluaXNoVGltZSovKTsKQEAgLTg3LDcgKzg4LDYgQEAgcHJpdmF0ZToKICAgICBX ZWJVUkxFcnJvciBtX2Vycm9yOwogCiAgICAgVGltZXI8Q2xpZW50QWRhcHRlcj4gbV9lcnJvclRp bWVyOwotICAgIHVuc2lnbmVkIGxvbmcgbV9kb3dubG9hZExlbmd0aDsKICAgICBib29sIG1fZG93 bmxvYWRUb0ZpbGU7CiAgICAgYm9vbCBtX2VuYWJsZUVycm9yTm90aWZpY2F0aW9uczsKICAgICBi b29sIG1fZGlkRmFpbDsKQEAgLTEwMiw3ICsxMDIsNiBAQCBBc3NvY2lhdGVkVVJMTG9hZGVyOjpD bGllbnRBZGFwdGVyOjpDbGllCiAgICAgOiBtX2xvYWRlcihsb2FkZXIpCiAgICAgLCBtX2NsaWVu dChjbGllbnQpCiAgICAgLCBtX2Vycm9yVGltZXIodGhpcywgJkNsaWVudEFkYXB0ZXI6Om5vdGlm eUVycm9yKQotICAgICwgbV9kb3dubG9hZExlbmd0aCgwKQogICAgICwgbV9kb3dubG9hZFRvRmls ZShkb3dubG9hZFRvRmlsZSkKICAgICAsIG1fZW5hYmxlRXJyb3JOb3RpZmljYXRpb25zKGZhbHNl KQogICAgICwgbV9kaWRGYWlsKGZhbHNlKQpAQCAtMTM1LDEzICsxMzQsMjAgQEAgdm9pZCBBc3Nv Y2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVyOgogICAgIG1fY2xpZW50LT5kaWRSZWNlaXZl UmVzcG9uc2UobV9sb2FkZXIsIHdyYXBwZWRSZXNwb25zZSk7CiB9CiAKK3ZvaWQgQXNzb2NpYXRl ZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkRG93bmxvYWREYXRhKGludCBkYXRhTGVuZ3Ro KQoreworICAgIGlmICghbV9jbGllbnQpCisgICAgICAgIHJldHVybjsKKworICAgIG1fY2xpZW50 LT5kaWREb3dubG9hZERhdGEobV9sb2FkZXIsIGRhdGFMZW5ndGgpOworfQorCiB2b2lkIEFzc29j aWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6OmRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIq IGRhdGEsIGludCBkYXRhTGVuZ3RoKQogewogICAgIGlmICghbV9jbGllbnQpCiAgICAgICAgIHJl dHVybjsKIAogICAgIG1fY2xpZW50LT5kaWRSZWNlaXZlRGF0YShtX2xvYWRlciwgZGF0YSwgZGF0 YUxlbmd0aCwgLTEpOwotICAgIG1fZG93bmxvYWRMZW5ndGggKz0gZGF0YUxlbmd0aDsKIH0KIAog dm9pZCBBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVyOjpkaWRSZWNlaXZlQ2FjaGVk TWV0YWRhdGEoY29uc3QgY2hhciogZGF0YSwgaW50IGRhdGFMZW5ndGgpCkBAIC0xNTcsMTIgKzE2 Myw2IEBAIHZvaWQgQXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjoKICAgICBpZiAo IW1fY2xpZW50KQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAobV9kb3dubG9hZFRvRmlsZSkg ewotICAgICAgICBpbnQgZG93bmxvYWRMZW5ndGggPSBtX2Rvd25sb2FkTGVuZ3RoIDw9IElOVF9N QVggPyBtX2Rvd25sb2FkTGVuZ3RoIDogSU5UX01BWDsKLSAgICAgICAgbV9jbGllbnQtPmRpZERv d25sb2FkRGF0YShtX2xvYWRlciwgZG93bmxvYWRMZW5ndGgpOwotICAgICAgICAvLyBXaGlsZSB0 aGUgY2xpZW50IGNvdWxkIGhhdmUgY2FuY2VsZWQsIGNvbnRpbnVlLCBzaW5jZSB0aGUgbG9hZCBm aW5pc2hlZC4KLSAgICB9Ci0KICAgICBtX2NsaWVudC0+ZGlkRmluaXNoTG9hZGluZyhtX2xvYWRl ciwgZmluaXNoVGltZSk7CiB9CiAKSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jl c291cmNlSGFuZGxlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9SZXNvdXJjZUhhbmRsZS5jcHAJKHJldmlzaW9uIDk0MDY0KQorKysgU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5kbGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMjEsNiAr MTIxLDE2IEBAIHZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkUmVjZWl2ZVIKICAgICBt X2NsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKG1fb3duZXIsIHJlc3BvbnNlLnRvUmVzb3VyY2VS ZXNwb25zZSgpKTsKIH0KIAordm9pZCBSZXNvdXJjZUhhbmRsZUludGVybmFsOjpkaWREb3dubG9h ZERhdGEoV2ViVVJMTG9hZGVyKiwgaW50IGRhdGFMZW5ndGgpCit7CisgICAgQVNTRVJUKG1fY2xp ZW50KTsKKyAgICBpZiAobV9zdGF0ZSAhPSBDb25uZWN0aW9uU3RhdGVSZWNlaXZlZFJlc3BvbnNl ICYmIG1fc3RhdGUgIT0gQ29ubmVjdGlvblN0YXRlUmVjZWl2aW5nRGF0YSkKKyAgICAgICAgQ1JB U0goKTsKKyAgICBtX3N0YXRlID0gQ29ubmVjdGlvblN0YXRlUmVjZWl2aW5nRGF0YTsKKworICAg IG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9vd25lciwgZGF0YUxlbmd0aCk7Cit9CisKIHZv aWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkUmVjZWl2ZURhdGEoV2ViVVJMTG9hZGVyKiwg Y29uc3QgY2hhciogZGF0YSwgaW50IGRhdGFMZW5ndGgsIGludCBlbmNvZGVkRGF0YUxlbmd0aCkK IHsKICAgICBBU1NFUlQobV9jbGllbnQpOwpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaAkocmV2aXNpb24gOTQwNjQpCisr KyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgJKHdv cmtpbmcgY29weSkKQEAgLTU2LDYgKzU2LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCB3 aWxsU2VuZFJlcXVlc3QoV2ViS2l0OjpXZWJVUkxMb2FkZXIqLCBXZWJLaXQ6OldlYlVSTFJlcXVl c3QmLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlc3BvbnNlJik7CiAgICAgdmlydHVhbCB2b2lkIGRp ZFNlbmREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgdW5zaWduZWQgbG9uZyBsb25nIGJ5dGVz U2VudCwgdW5zaWduZWQgbG9uZyBsb25nIHRvdGFsQnl0ZXNUb0JlU2VudCk7CiAgICAgdmlydHVh bCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShXZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0IFdl YktpdDo6V2ViVVJMUmVzcG9uc2UmKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRh KFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgaW50IGRhdGFMZW5ndGgpOwogICAgIHZpcnR1YWwgdm9p ZCBkaWRSZWNlaXZlRGF0YShXZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0IGNoYXIqIGRhdGEs IGludCBkYXRhTGVuZ3RoLCBpbnQgZW5jb2RlZERhdGFMZW5ndGgpOwogCiAgICAgdmlydHVhbCB2 b2lkIGRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShXZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0 IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKTsK 105938 2011-09-01 04:10:39 -0700 2011-09-02 12:59:00 -0700 Proposed Patch diff.txt text/plain 14421 bbudge SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0MjgxKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMDktMDEgIEJpbGwgQnVk Z2UgIDxiYnVkZ2VAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBhIFRocmVhZGFibGVMb2Fk ZXJDbGllbnQ6OmRpZERvd25sb2FkRGF0YSBtZXRob2QsIHRvIGFsbG93IHVzIHRvIHBhc3MKKyAg ICAgICAgcHJvZ3Jlc3MgdXBkYXRlcyBmcm9tIHRoZSB1bmRlcmx5aW5nIFVSTCBsb2FkZXIgdXAg dG8gQXNzb2NpYXRlZFVSTExvYWRlci4KKyAgICAgICAgTW9kaWZ5IFJlc291cmNlSGFuZGxlSW50 ZXJuYWwsIFJlc291cmNlTG9hZGVyLCBTdWJyZXNvdXJjZUxvYWRlciwKKyAgICAgICAgRG9jdW1l bnRUaHJlYWRhYmxlTG9hZGVyLCBhbmQgZmluYWxseSBBc3NvY2lhdGVkVVJMTG9hZGVyIHRvIHBh c3MgdGhlCisgICAgICAgIHVwZGF0ZXMgdG8gdGhlIFdlYlVSTExvYWRlckNsaWVudC4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY3MjI5CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiBF eHBvc2VzIG5vIG5ldyBmdW5jdGlvbmFsaXR5LgorCisgICAgICAgICogbG9hZGVyL0RvY3VtZW50 VGhyZWFkYWJsZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFRocmVhZGFi bGVMb2FkZXI6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVyL0RvY3VtZW50VGhy ZWFkYWJsZUxvYWRlci5oOgorICAgICAgICAqIGxvYWRlci9SZXNvdXJjZUxvYWRlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAg ICAgKiBsb2FkZXIvUmVzb3VyY2VMb2FkZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvU3VicmVzb3Vy Y2VMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3VicmVzb3VyY2VMb2FkZXI6OmRpZERv d25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmg6CisgICAg ICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTdWJyZXNvdXJjZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBs b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFk YWJsZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBsb2FkZXIvVGhy ZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZGFi bGVMb2FkZXJDbGllbnRXcmFwcGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIHBsYXRm b3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlJl c291cmNlSGFuZGxlQ2xpZW50OjpkaWREb3dubG9hZERhdGEpOgorCiAyMDExLTA5LTAxICBLZWlz aGkgSGF0dG9yaSAgPGtlaXNoaUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJlbmFtZSBjb2xvclNl bGVjdGVkIHRvIGRpZENob29zZUNvbG9yCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9j dW1lbnRUaHJlYWRhYmxlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmNwcAkocmV2aXNpb24gOTQyODEpCisrKyBT b3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMjIzLDYgKzIyMywxNyBAQCB2b2lkIERvY3VtZW50VGhyZWFkYWJsZUxvYWRl cjo6ZGlkUmVjZWl2CiAgICAgfQogfQogCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCit2b2lkIERv Y3VtZW50VGhyZWFkYWJsZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKFN1YnJlc291cmNlTG9hZGVy KiBsb2FkZXIsIGludCBkYXRhTGVuZ3RoKQoreworICAgIEFTU0VSVChtX2NsaWVudCk7CisgICAg QVNTRVJUX1VOVVNFRChsb2FkZXIsIGxvYWRlciA9PSBtX2xvYWRlcik7CisgICAgQVNTRVJUKCFt X2FjdHVhbFJlcXVlc3QpOworCisgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YShkYXRhTGVu Z3RoKTsKK30KKyNlbmRpZgorCiB2b2lkIERvY3VtZW50VGhyZWFkYWJsZUxvYWRlcjo6ZGlkUmVj ZWl2ZURhdGEoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgY29uc3QgY2hhciogZGF0YSwgaW50 IGRhdGFMZW5ndGgpCiB7CiAgICAgQVNTRVJUKG1fY2xpZW50KTsKSW5kZXg6IFNvdXJjZS9XZWJD b3JlL2xvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmgJKHJldmlzaW9uIDk0 MjgxKQorKysgU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5o CSh3b3JraW5nIGNvcHkpCkBAIC04NCw2ICs4NCwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK ICAgICAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNoYWxsZW5nZShT dWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJik7CiAKKyNp ZiBQTEFURk9STShDSFJPTUlVTSkKKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZERvd25sb2FkRGF0 YShTdWJyZXNvdXJjZUxvYWRlciosIGludCBkYXRhTGVuZ3RoKTsKKyNlbmRpZgorCiAgICAgICAg IHZvaWQgZGlkUmVjZWl2ZVJlc3BvbnNlKHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgY29uc3Qg UmVzb3VyY2VSZXNwb25zZSYpOwogICAgICAgICB2b2lkIGRpZEZpbmlzaExvYWRpbmcodW5zaWdu ZWQgbG9uZyBpZGVudGlmaWVyLCBkb3VibGUgZmluaXNoVGltZSk7CiAgICAgICAgIHZvaWQgbWFr ZVNpbXBsZUNyb3NzT3JpZ2luQWNjZXNzUmVxdWVzdChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJl cXVlc3QpOwpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvUmVzb3VyY2VMb2FkZXIuY3BwCShy ZXZpc2lvbiA5NDI4MSkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxvYWRlci5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTU3NCw2ICs1NzQsMjQgQEAgdm9pZCBSZXNvdXJjZUxvYWRl cjo6d2lsbENhY2hlUmVzcG9uc2UoUgogICAgICAgICBwb2xpY3kgPSBTdG9yYWdlQWxsb3dlZElu TWVtb3J5T25seTsgICAgCiB9CiAKKyNpZiBQTEFURk9STShDSFJPTUlVTSkKK3ZvaWQgUmVzb3Vy Y2VMb2FkZXI6OmRpZERvd25sb2FkRGF0YShSZXNvdXJjZUhhbmRsZSosIGludCBsZW5ndGgpCit7 CisgICAgZGlkRG93bmxvYWREYXRhKGxlbmd0aCk7Cit9CisKK3ZvaWQgUmVzb3VyY2VMb2FkZXI6 OmRpZERvd25sb2FkRGF0YShpbnQgbGVuZ3RoKQoreworI2lmIEVOQUJMRShPRkZMSU5FX1dFQl9B UFBMSUNBVElPTlMpCisgICAgaWYgKCFtX2NhbmNlbGxlZCAmJiAhZmFzdE1hbGxvY1NpemUoZG9j dW1lbnRMb2FkZXIoKS0+YXBwbGljYXRpb25DYWNoZUhvc3QoKSkpCisgICAgICAgIENSQVNIKCk7 CisjZW5kaWYKKyAgICBpZiAoIW1fY2FuY2VsbGVkICYmICFmYXN0TWFsbG9jU2l6ZShkb2N1bWVu dExvYWRlcigpLT5mcmFtZSgpKSkKKyAgICAgICAgQ1JBU0goKTsKK30KKworI2VuZGlmIC8vIFBM QVRGT1JNKENIUk9NSVVNKQorCiAjaWYgRU5BQkxFKEJMT0IpCiBBc3luY0ZpbGVTdHJlYW0qIFJl c291cmNlTG9hZGVyOjpjcmVhdGVBc3luY0ZpbGVTdHJlYW0oRmlsZVN0cmVhbUNsaWVudCogY2xp ZW50KQogewpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgJKHJldmlz aW9uIDk0MjgxKQorKysgU291cmNlL1dlYkNvcmUvbG9hZGVyL1Jlc291cmNlTG9hZGVyLmgJKHdv cmtpbmcgY29weSkKQEAgLTEyOSw2ICsxMjksMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICAvLyBGSVhNRTogV2luZG93cyBzaG91bGQgdXNlIHdpbGxDYWNoZVJlc3BvbnNlIC0gPGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01NzI1Nz4uCiAgICAgICAgIHZp cnR1YWwgYm9vbCBzaG91bGRDYWNoZVJlc3BvbnNlKFJlc291cmNlSGFuZGxlKiwgQ0ZDYWNoZWRV UkxSZXNwb25zZVJlZik7CiAjZW5kaWYKKyNpZiBQTEFURk9STShDSFJPTUlVTSkKKyAgICAgICAg dmlydHVhbCB2b2lkIGRpZERvd25sb2FkRGF0YShSZXNvdXJjZUhhbmRsZSosIGludCk7CisgICAg ICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoaW50KTsKKyNlbmRpZgogI2lmIEVOQUJM RShCTE9CKQogICAgICAgICB2aXJ0dWFsIEFzeW5jRmlsZVN0cmVhbSogY3JlYXRlQXN5bmNGaWxl U3RyZWFtKEZpbGVTdHJlYW1DbGllbnQqKTsKICNlbmRpZgpJbmRleDogU291cmNlL1dlYkNvcmUv bG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29y ZS9sb2FkZXIvU3VicmVzb3VyY2VMb2FkZXIuY3BwCShyZXZpc2lvbiA5NDI4MSkKKysrIFNvdXJj ZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTE1OSw2ICsxNTksMjAgQEAgdm9pZCBTdWJyZXNvdXJjZUxvYWRlcjo6ZGlkUmVjZWl2ZVJlc3Bv bgogICAgIH0KIH0KIAorI2lmIFBMQVRGT1JNKENIUk9NSVVNKQordm9pZCBTdWJyZXNvdXJjZUxv YWRlcjo6ZGlkRG93bmxvYWREYXRhKGludCBsZW5ndGgpCit7CisgICAgLy8gUmVmZXJlbmNlIHRo ZSBvYmplY3QgaW4gdGhpcyBtZXRob2Qgc2luY2UgdGhlIGFkZGl0aW9uYWwgcHJvY2Vzc2luZyBj YW4gZG8KKyAgICAvLyBhbnl0aGluZyBpbmNsdWRpbmcgcmVtb3ZpbmcgdGhlIGxhc3QgcmVmZXJl bmNlIHRvIHRoaXMgb2JqZWN0OyBvbmUgZXhhbXBsZSBvZiB0aGlzIGlzIDMyNjYyMTYuCisgICAg UmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBwcm90ZWN0KHRoaXMpOworICAgIAorICAgIFJlc291 cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEobGVuZ3RoKTsKKworICAgIGlmIChtX2NsaWVudCkK KyAgICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YSh0aGlzLCBsZW5ndGgpOworfQorI2Vu ZGlmCisKIHZvaWQgU3VicmVzb3VyY2VMb2FkZXI6OmRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIq IGRhdGEsIGludCBsZW5ndGgsIGxvbmcgbG9uZyBlbmNvZGVkRGF0YUxlbmd0aCwgYm9vbCBhbGxB dE9uY2UpCiB7CiAgICAgLy8gUmVmZXJlbmNlIHRoZSBvYmplY3QgaW4gdGhpcyBtZXRob2Qgc2lu Y2UgdGhlIGFkZGl0aW9uYWwgcHJvY2Vzc2luZyBjYW4gZG8KSW5kZXg6IFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCShyZXZpc2lvbiA5NDI4MSkKKysrIFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC02NCw2 ICs2NCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBib29sIHN1cHBv cnRzRGF0YUFycmF5KCkgeyByZXR1cm4gdHJ1ZTsgfQogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlk UmVjZWl2ZURhdGFBcnJheShDRkFycmF5UmVmKTsKICNlbmRpZgorI2lmIFBMQVRGT1JNKENIUk9N SVVNKQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGludCk7CisjZW5kaWYK IAogICAgICAgICBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCogbV9jbGllbnQ7CiAgICAgICAgIGJv b2wgbV9sb2FkaW5nTXVsdGlwYXJ0Q29udGVudDsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRl ci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3Jl L2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5NDI4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCSh3b3JraW5nIGNv cHkpCkBAIC01Miw2ICs1MiwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwo U3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJikgeyB9CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNoYWxsZW5nZShTdWJyZXNvdXJj ZUxvYWRlciosIGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikgeyB9CisKKyNpZiBQTEFU Rk9STShDSFJPTUlVTSkKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKFN1YnJlc291 cmNlTG9hZGVyKiwgaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgogfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL1RocmVhZGFibGVM b2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvVGhyZWFk YWJsZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5NDI4MSkKKysrIFNvdXJjZS9XZWJDb3JlL2xv YWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTUxLDYgKzUx LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2aXJ0dWFsIGJvb2wgaXNEb2N1 bWVudFRocmVhZGFibGVMb2FkZXJDbGllbnQoKSB7IHJldHVybiBmYWxzZTsgfQogCisjaWYgUExB VEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoaW50 IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgorCiAgICAgcHJvdGVjdGVkOgogICAgICAgICBU aHJlYWRhYmxlTG9hZGVyQ2xpZW50KCkgeyB9CiAgICAgICAgIHZpcnR1YWwgflRocmVhZGFibGVM b2FkZXJDbGllbnQoKSB7IH0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxl TG9hZGVyQ2xpZW50V3JhcHBlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRl ci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCShyZXZpc2lvbiA5NDI4MSkKKysrIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0xMDcsNiArMTA3LDE0IEBAIHB1YmxpYzoKICAgICAgICAgICAgIG1fY2xp ZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaWRlbnRpZmllciwgcmVzcG9uc2UpOwogICAgIH0KIAor I2lmIFBMQVRGT1JNKENIUk9NSVVNKQorICAgIHZvaWQgZGlkRG93bmxvYWREYXRhKGludCBkYXRh TGVuZ3RoKQorICAgIHsKKyAgICAgICAgaWYgKG1fY2xpZW50KQorICAgICAgICAgICAgbV9jbGll bnQtPmRpZERvd25sb2FkRGF0YShkYXRhTGVuZ3RoKTsKKyAgICB9CisjZW5kaWYKKwogcHJvdGVj dGVkOgogICAgIFRocmVhZGFibGVMb2FkZXJDbGllbnRXcmFwcGVyKFRocmVhZGFibGVMb2FkZXJD bGllbnQqIGNsaWVudCkKICAgICAgICAgOiBtX2NsaWVudChjbGllbnQpCkluZGV4OiBTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUNsaWVu dC5oCShyZXZpc2lvbiA5NDI4MSkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv UmVzb3VyY2VIYW5kbGVDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTA3LDYgKzEwNyw5IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBQTEFURk9STShXSU4pICYmIFVTRShDRk5FVFdPUksp CiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRDYWNoZVJlc3BvbnNlKFJlc291cmNlSGFuZGxl KiwgQ0ZDYWNoZWRVUkxSZXNwb25zZVJlZikgeyByZXR1cm4gdHJ1ZTsgfQogI2VuZGlmCisjaWYg UExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEo UmVzb3VyY2VIYW5kbGUqLCBpbnQgLypkYXRhTGVuZ3RoKi8pIHsgfQorI2VuZGlmCiAjaWYgRU5B QkxFKEJMT0IpCiAgICAgICAgIHZpcnR1YWwgQXN5bmNGaWxlU3RyZWFtKiBjcmVhdGVBc3luY0Zp bGVTdHJlYW0oRmlsZVN0cmVhbUNsaWVudCopIHsgcmV0dXJuIDA7IH0KICNlbmRpZgpJbmRleDog U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0MjgxKQorKysgU291cmNlL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyMyBAQAorMjAx MS0wOS0wMSAgQmlsbCBCdWRnZSAgPGJidWRnZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRk IGEgVGhyZWFkYWJsZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhIG1ldGhvZCwgdG8gYWxs b3cgdXMgdG8gcGFzcworICAgICAgICBwcm9ncmVzcyB1cGRhdGVzIGZyb20gdGhlIHVuZGVybHlp bmcgVVJMIGxvYWRlciB1cCB0byBBc3NvY2lhdGVkVVJMTG9hZGVyLgorICAgICAgICBNb2RpZnkg UmVzb3VyY2VIYW5kbGVJbnRlcm5hbCwgUmVzb3VyY2VMb2FkZXIsIFN1YnJlc291cmNlTG9hZGVy LAorICAgICAgICBEb2N1bWVudFRocmVhZGFibGVMb2FkZXIsIGFuZCBmaW5hbGx5IEFzc29jaWF0 ZWRVUkxMb2FkZXIgdG8gcGFzcyB0aGUKKyAgICAgICAgdXBkYXRlcyB0byB0aGUgV2ViVVJMTG9h ZGVyQ2xpZW50LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjcyMjkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIHNyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6QXNzb2Np YXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6Q2xpZW50QWRhcHRlcik6CisgICAgICAgIChX ZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6OmRpZERvd25sb2FkRGF0 YSk6CisgICAgICAgIChXZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6 OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYktpdDo6QXNzb2NpYXRlZFVSTExvYWRlcjo6 Q2xpZW50QWRhcHRlcjo6ZGlkRmluaXNoTG9hZGluZyk6CisgICAgICAgICogc3JjL1Jlc291cmNl SGFuZGxlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlSW50ZXJuYWw6OmRp ZERvd25sb2FkRGF0YSk6CisgICAgICAgICogc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaDoK KwogMjAxMS0wOC0zMSAgR3JlZyBCaWxsb2NrICA8Z2JpbGxvY2tAZ29vZ2xlLmNvbT4KIAogICAg ICAgICBBZGQgcGFzcy10aHJvdWdocyBmb3IgTlBPYmplY3Qvdjg6OlZhbHVlIG1hcnNoYWxsaW5n IHRvIFdlYkJpbmRpbmdzCkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NvY2lh dGVkVVJMTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcAkocmV2aXNpb24gOTQyODEpCisrKyBTb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpA QCAtNjMsNiArNjMsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHdpbGxTZW5kUmVxdWVz dChSZXNvdXJjZVJlcXVlc3QmIC8qbmV3UmVxdWVzdCovLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNl JiAvKnJlZGlyZWN0UmVzcG9uc2UqLyk7CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZVJl c3BvbnNlKHVuc2lnbmVkIGxvbmcsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsKKyAgICB2aXJ0 dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGludCAvKmRhdGFMZW5ndGgqLyk7CiAgICAgdmlydHVh bCB2b2lkIGRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIqLCBpbnQgLypkYXRhTGVuZ3RoKi8pOwog ICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEoY29uc3QgY2hhciosIGlu dCAvKmRhdGFMZW5ndGgqLyk7CiAgICAgdmlydHVhbCB2b2lkIGRpZEZpbmlzaExvYWRpbmcodW5z aWduZWQgbG9uZyAvKmlkZW50aWZpZXIqLywgZG91YmxlIC8qZmluaXNoVGltZSovKTsKQEAgLTg3 LDcgKzg4LDYgQEAgcHJpdmF0ZToKICAgICBXZWJVUkxFcnJvciBtX2Vycm9yOwogCiAgICAgVGlt ZXI8Q2xpZW50QWRhcHRlcj4gbV9lcnJvclRpbWVyOwotICAgIHVuc2lnbmVkIGxvbmcgbV9kb3du bG9hZExlbmd0aDsKICAgICBib29sIG1fZG93bmxvYWRUb0ZpbGU7CiAgICAgYm9vbCBtX2VuYWJs ZUVycm9yTm90aWZpY2F0aW9uczsKICAgICBib29sIG1fZGlkRmFpbDsKQEAgLTEwMiw3ICsxMDIs NiBAQCBBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVyOjpDbGllCiAgICAgOiBtX2xv YWRlcihsb2FkZXIpCiAgICAgLCBtX2NsaWVudChjbGllbnQpCiAgICAgLCBtX2Vycm9yVGltZXIo dGhpcywgJkNsaWVudEFkYXB0ZXI6Om5vdGlmeUVycm9yKQotICAgICwgbV9kb3dubG9hZExlbmd0 aCgwKQogICAgICwgbV9kb3dubG9hZFRvRmlsZShkb3dubG9hZFRvRmlsZSkKICAgICAsIG1fZW5h YmxlRXJyb3JOb3RpZmljYXRpb25zKGZhbHNlKQogICAgICwgbV9kaWRGYWlsKGZhbHNlKQpAQCAt MTM1LDEzICsxMzQsMjAgQEAgdm9pZCBBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGllbnRBZGFwdGVy OgogICAgIG1fY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UobV9sb2FkZXIsIHdyYXBwZWRSZXNw b25zZSk7CiB9CiAKK3ZvaWQgQXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlk RG93bmxvYWREYXRhKGludCBkYXRhTGVuZ3RoKQoreworICAgIGlmICghbV9jbGllbnQpCisgICAg ICAgIHJldHVybjsKKworICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9sb2FkZXIsIGRh dGFMZW5ndGgpOworfQorCiB2b2lkIEFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6 OmRpZFJlY2VpdmVEYXRhKGNvbnN0IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKQogewogICAg IGlmICghbV9jbGllbnQpCiAgICAgICAgIHJldHVybjsKIAogICAgIG1fY2xpZW50LT5kaWRSZWNl aXZlRGF0YShtX2xvYWRlciwgZGF0YSwgZGF0YUxlbmd0aCwgLTEpOwotICAgIG1fZG93bmxvYWRM ZW5ndGggKz0gZGF0YUxlbmd0aDsKIH0KIAogdm9pZCBBc3NvY2lhdGVkVVJMTG9hZGVyOjpDbGll bnRBZGFwdGVyOjpkaWRSZWNlaXZlQ2FjaGVkTWV0YWRhdGEoY29uc3QgY2hhciogZGF0YSwgaW50 IGRhdGFMZW5ndGgpCkBAIC0xNTcsMTIgKzE2Myw2IEBAIHZvaWQgQXNzb2NpYXRlZFVSTExvYWRl cjo6Q2xpZW50QWRhcHRlcjoKICAgICBpZiAoIW1fY2xpZW50KQogICAgICAgICByZXR1cm47CiAK LSAgICBpZiAobV9kb3dubG9hZFRvRmlsZSkgewotICAgICAgICBpbnQgZG93bmxvYWRMZW5ndGgg PSBtX2Rvd25sb2FkTGVuZ3RoIDw9IElOVF9NQVggPyBtX2Rvd25sb2FkTGVuZ3RoIDogSU5UX01B WDsKLSAgICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YShtX2xvYWRlciwgZG93bmxvYWRM ZW5ndGgpOwotICAgICAgICAvLyBXaGlsZSB0aGUgY2xpZW50IGNvdWxkIGhhdmUgY2FuY2VsZWQs IGNvbnRpbnVlLCBzaW5jZSB0aGUgbG9hZCBmaW5pc2hlZC4KLSAgICB9Ci0KICAgICBtX2NsaWVu dC0+ZGlkRmluaXNoTG9hZGluZyhtX2xvYWRlciwgZmluaXNoVGltZSk7CiB9CiAKSW5kZXg6IFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jlc291cmNlSGFuZGxlLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZS5jcHAJKHJldmlzaW9u IDk0MjgxKQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5kbGUuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xMjEsNiArMTIxLDE2IEBAIHZvaWQgUmVzb3VyY2VIYW5kbGVJ bnRlcm5hbDo6ZGlkUmVjZWl2ZVIKICAgICBtX2NsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKG1f b3duZXIsIHJlc3BvbnNlLnRvUmVzb3VyY2VSZXNwb25zZSgpKTsKIH0KIAordm9pZCBSZXNvdXJj ZUhhbmRsZUludGVybmFsOjpkaWREb3dubG9hZERhdGEoV2ViVVJMTG9hZGVyKiwgaW50IGRhdGFM ZW5ndGgpCit7CisgICAgQVNTRVJUKG1fY2xpZW50KTsKKyAgICBpZiAobV9zdGF0ZSAhPSBDb25u ZWN0aW9uU3RhdGVSZWNlaXZlZFJlc3BvbnNlICYmIG1fc3RhdGUgIT0gQ29ubmVjdGlvblN0YXRl UmVjZWl2aW5nRGF0YSkKKyAgICAgICAgQ1JBU0goKTsKKyAgICBtX3N0YXRlID0gQ29ubmVjdGlv blN0YXRlUmVjZWl2aW5nRGF0YTsKKworICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9v d25lciwgZGF0YUxlbmd0aCk7Cit9CisKIHZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlk UmVjZWl2ZURhdGEoV2ViVVJMTG9hZGVyKiwgY29uc3QgY2hhciogZGF0YSwgaW50IGRhdGFMZW5n dGgsIGludCBlbmNvZGVkRGF0YUxlbmd0aCkKIHsKICAgICBBU1NFUlQobV9jbGllbnQpOwpJbmRl eDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jlc291cmNlSGFuZGxlSW50 ZXJuYWwuaAkocmV2aXNpb24gOTQyODEpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9S ZXNvdXJjZUhhbmRsZUludGVybmFsLmgJKHdvcmtpbmcgY29weSkKQEAgLTU2LDYgKzU2LDcgQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCB3aWxsU2VuZFJlcXVlc3QoV2ViS2l0OjpXZWJVUkxM b2FkZXIqLCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlc3Bv bnNlJik7CiAgICAgdmlydHVhbCB2b2lkIGRpZFNlbmREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVy KiwgdW5zaWduZWQgbG9uZyBsb25nIGJ5dGVzU2VudCwgdW5zaWduZWQgbG9uZyBsb25nIHRvdGFs Qnl0ZXNUb0JlU2VudCk7CiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShXZWJL aXQ6OldlYlVSTExvYWRlciosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVzcG9uc2UmKTsKKyAgICB2 aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgaW50IGRh dGFMZW5ndGgpOwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShXZWJLaXQ6OldlYlVS TExvYWRlciosIGNvbnN0IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoLCBpbnQgZW5jb2RlZERh dGFMZW5ndGgpOwogCiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShX ZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKTsK 106178 2011-09-02 12:59:00 -0700 2011-09-02 16:28:32 -0700 Proposed Patch aul.txt text/plain 19593 bbudge SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0NDQwKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTEtMDktMDIgIEJpbGwgQnVk Z2UgIDxiYnVkZ2VAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBhICdkaWREb3dubG9hZERh dGEnIG1ldGhvZCB0byBSZXNvdXJjZUxvYWRlciwgU3VicmVzb3VyY2VMb2FkZXIsCisgICAgICAg IFN1YnJlc291cmNlTG9hZGVyQ2xpZW50LCBEb2N1bWVudFRocmVhZGFibGVMb2FkZXIsIFJlc291 cmNlSGFuZGxlQ2xpZW50LAorICAgICAgICBhbmQgVGhyZWFkYWJsZUxvYWRlckNsaWVudCBmb3Ig dGhlIENocm9taXVtIHBvcnQgb25seSwgc28gd2UgY2FuIHBhc3MKKyAgICAgICAgdGhlc2Ugbm90 aWZpY2F0aW9ucyBmcm9tIG91ciBSZXNvdXJjZUhhbmRsZSBpbXBsZW1lbnRhdGlvbiB0aHJvdWdo IHRoZQorICAgICAgICBXZWJDb3JlIGxvYWRlciBmcmFtZXdvcmsuCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NzIyOQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gRXhwb3NlcyBubyBu ZXcgZnVuY3Rpb25hbGl0eS4KKworICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBs b2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmg6CisgICAgICAgICogbG9hZGVyL1Jlc291 cmNlTG9hZGVyLmg6CisgICAgICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmg6CisgICAg ICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTdWJyZXNvdXJjZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBs b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFk YWJsZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBsb2FkZXIvVGhy ZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZGFi bGVMb2FkZXJDbGllbnRXcmFwcGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIGxvYWRl ci9jaHJvbWl1bTogQWRkZWQuCisgICAgICAgICogbG9hZGVyL2Nocm9taXVtL0RvY3VtZW50VGhy ZWFkYWJsZUxvYWRlckNocm9taXVtLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudFRocmVhZGFibGVMb2FkZXI6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVy L2Nocm9taXVtL1Jlc291cmNlTG9hZGVyQ2hyb21pdW0uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlJlc291cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIGxvYWRl ci9jaHJvbWl1bS9TdWJyZXNvdXJjZUxvYWRlckNocm9taXVtLmNwcDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpTdWJyZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAg KiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50Lmg6CisgICAgICAgIChXZWJD b3JlOjpSZXNvdXJjZUhhbmRsZUNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKwogMjAxMS0wOS0w MiAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJlbW92ZSBCZWZvcmVQ cm9jZXNzRXZlbnQsIGl0IHdhcyBuZXZlciBtZWFudCB0byBiZQpJbmRleDogU291cmNlL1dlYkNv cmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lw aQkocmV2aXNpb24gOTQ0NDApCisrKyBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtp bmcgY29weSkKQEAgLTI4MjUsNiArMjgyNSw5IEBACiAgICAgICAgICAgICAnbG9hZGVyL2NhY2hl L0NhY2hlZFhTTFN0eWxlU2hlZXQuaCcsCiAgICAgICAgICAgICAnbG9hZGVyL2NhY2hlL01lbW9y eUNhY2hlLmNwcCcsCiAgICAgICAgICAgICAnbG9hZGVyL2NmL1Jlc291cmNlTG9hZGVyQ0ZOZXQu Y3BwJywKKyAgICAgICAgICAgICdsb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9h ZGVyQ2hyb21pdW0uY3BwJywKKyAgICAgICAgICAgICdsb2FkZXIvY2hyb21pdW0vUmVzb3VyY2VM b2FkZXJDaHJvbWl1bS5jcHAnLAorICAgICAgICAgICAgJ2xvYWRlci9jaHJvbWl1bS9TdWJyZXNv dXJjZUxvYWRlckNocm9taXVtLmNwcCcsCiAgICAgICAgICAgICAnbG9hZGVyL2ljb24vSWNvbkNv bnRyb2xsZXIuY3BwJywKICAgICAgICAgICAgICdsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3Bw JywKICAgICAgICAgICAgICdsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2VCYXNlLmNwcCcsCkluZGV4 OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5o CShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudFRocmVh ZGFibGVMb2FkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtODQsNiArODQsMTAgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlQXV0aGVudGljYXRp b25DaGFsbGVuZ2UoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBBdXRoZW50aWNhdGlvbkNoYWxs ZW5nZSYpOwogCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWREb3dubG9hZERhdGEoU3VicmVzb3VyY2VMb2FkZXIqLCBpbnQgZGF0YUxlbmd0aCk7CisjZW5k aWYKKwogICAgICAgICB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZSh1bnNpZ25lZCBsb25nIGlkZW50 aWZpZXIsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsKICAgICAgICAgdm9pZCBkaWRGaW5pc2hM b2FkaW5nKHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgZG91YmxlIGZpbmlzaFRpbWUpOwogICAg ICAgICB2b2lkIG1ha2VTaW1wbGVDcm9zc09yaWdpbkFjY2Vzc1JlcXVlc3QoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0KTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJj ZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxv YWRlci5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJj ZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMjksNiArMTI5LDEwIEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgLy8gRklYTUU6IFdpbmRvd3Mgc2hvdWxkIHVzZSB3aWxsQ2FjaGVS ZXNwb25zZSAtIDxodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTcyNTc+ LgogICAgICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkQ2FjaGVSZXNwb25zZShSZXNvdXJjZUhhbmRs ZSosIENGQ2FjaGVkVVJMUmVzcG9uc2VSZWYpOwogI2VuZGlmCisjaWYgUExBVEZPUk0oQ0hST01J VU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5kbGUq LCBpbnQpOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGludCk7CisjZW5k aWYKICNpZiBFTkFCTEUoQkxPQikKICAgICAgICAgdmlydHVhbCBBc3luY0ZpbGVTdHJlYW0qIGNy ZWF0ZUFzeW5jRmlsZVN0cmVhbShGaWxlU3RyZWFtQ2xpZW50Kik7CiAjZW5kaWYKSW5kZXg6IFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCShyZXZpc2lvbiA5NDQ0MCkK KysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNv cHkpCkBAIC02NCw2ICs2NCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVh bCBib29sIHN1cHBvcnRzRGF0YUFycmF5KCkgeyByZXR1cm4gdHJ1ZTsgfQogICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGFBcnJheShDRkFycmF5UmVmKTsKICNlbmRpZgorI2lmIFBM QVRGT1JNKENIUk9NSVVNKQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGlu dCk7CisjZW5kaWYKIAogICAgICAgICBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCogbV9jbGllbnQ7 CiAgICAgICAgIGJvb2wgbV9sb2FkaW5nTXVsdGlwYXJ0Q29udGVudDsKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5 NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC01Miw2ICs1MiwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJikgeyB9 CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNoYWxsZW5n ZShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikgeyB9 CisKKyNpZiBQTEFURk9STShDSFJPTUlVTSkKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWRE YXRhKFN1YnJlc291cmNlTG9hZGVyKiwgaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgog fTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVy L1RocmVhZGFibGVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJj ZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50LmgJKHdvcmtpbmcgY29weSkK QEAgLTUxLDYgKzUxLDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2aXJ0dWFs IGJvb2wgaXNEb2N1bWVudFRocmVhZGFibGVMb2FkZXJDbGllbnQoKSB7IHJldHVybiBmYWxzZTsg fQogCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3du bG9hZERhdGEoaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgorCiAgICAgcHJvdGVjdGVk OgogICAgICAgICBUaHJlYWRhYmxlTG9hZGVyQ2xpZW50KCkgeyB9CiAgICAgICAgIHZpcnR1YWwg flRocmVhZGFibGVMb2FkZXJDbGllbnQoKSB7IH0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRl ci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCShyZXZpc2lvbiA5 NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3Jh cHBlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMDcsNiArMTA3LDE0IEBAIHB1YmxpYzoKICAgICAg ICAgICAgIG1fY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaWRlbnRpZmllciwgcmVzcG9uc2Up OwogICAgIH0KIAorI2lmIFBMQVRGT1JNKENIUk9NSVVNKQorICAgIHZvaWQgZGlkRG93bmxvYWRE YXRhKGludCBkYXRhTGVuZ3RoKQorICAgIHsKKyAgICAgICAgaWYgKG1fY2xpZW50KQorICAgICAg ICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YShkYXRhTGVuZ3RoKTsKKyAgICB9CisjZW5k aWYKKwogcHJvdGVjdGVkOgogICAgIFRocmVhZGFibGVMb2FkZXJDbGllbnRXcmFwcGVyKFRocmVh ZGFibGVMb2FkZXJDbGllbnQqIGNsaWVudCkKICAgICAgICAgOiBtX2NsaWVudChjbGllbnQpCklu ZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9h ZGVyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9jaHJv bWl1bS9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDApCisr KyBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVy Q2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQ4IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlv bi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1l cyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21v dGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lm aWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJ UyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAq IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIkRvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5oIgorCisjaW5jbHVkZSAi U3VicmVzb3VyY2VMb2FkZXIuaCIKKyNpbmNsdWRlICJUaHJlYWRhYmxlTG9hZGVyQ2xpZW50Lmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBEb2N1bWVudFRocmVhZGFibGVMb2FkZXI6 OmRpZERvd25sb2FkRGF0YShTdWJyZXNvdXJjZUxvYWRlciogbG9hZGVyLCBpbnQgZGF0YUxlbmd0 aCkKK3sKKyAgICBBU1NFUlQobV9jbGllbnQpOworICAgIEFTU0VSVF9VTlVTRUQobG9hZGVyLCBs b2FkZXIgPT0gbV9sb2FkZXIpOworICAgIEFTU0VSVCghbV9hY3R1YWxSZXF1ZXN0KTsKKworICAg IG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEoZGF0YUxlbmd0aCk7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9jaHJvbWl1bS9SZXNvdXJj ZUxvYWRlckNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIv Y2hyb21pdW0vUmVzb3VyY2VMb2FkZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDApCisrKyBTb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vUmVzb3VyY2VMb2FkZXJDaHJvbWl1bS5jcHAJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsNTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29v Z2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuIAorICogMi4g IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uIAorICogMy4g IE5laXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0 aGUgbmFtZXMgb2YKKyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9y c2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJl IHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLiAKKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJ UyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiUmVzb3VyY2VMb2FkZXIuaCIKKworI2luY2x1ZGUgIkFwcGxpY2F0aW9uQ2FjaGVIb3N0 LmgiCisjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgUmVzb3VyY2VMb2FkZXI6OmRpZERvd25sb2FkRGF0 YShSZXNvdXJjZUhhbmRsZSosIGludCBsZW5ndGgpCit7CisgICAgZGlkRG93bmxvYWREYXRhKGxl bmd0aCk7Cit9CisKK3ZvaWQgUmVzb3VyY2VMb2FkZXI6OmRpZERvd25sb2FkRGF0YShpbnQgbGVu Z3RoKQoreworI2lmIEVOQUJMRShPRkZMSU5FX1dFQl9BUFBMSUNBVElPTlMpCisgICAgaWYgKCFt X2NhbmNlbGxlZCAmJiAhZmFzdE1hbGxvY1NpemUoZG9jdW1lbnRMb2FkZXIoKS0+YXBwbGljYXRp b25DYWNoZUhvc3QoKSkpCisgICAgICAgIENSQVNIKCk7CisjZW5kaWYKKyAgICBpZiAoIW1fY2Fu Y2VsbGVkICYmICFmYXN0TWFsbG9jU2l6ZShkb2N1bWVudExvYWRlcigpLT5mcmFtZSgpKSkKKyAg ICAgICAgQ1JBU0goKTsKK30KKworfQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL2Nocm9t aXVtL1N1YnJlc291cmNlTG9hZGVyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9jaHJvbWl1bS9TdWJyZXNvdXJjZUxvYWRlckNocm9taXVtLmNwcAkocmV2 aXNpb24gMCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9jaHJvbWl1bS9TdWJyZXNvdXJjZUxv YWRlckNocm9taXVtLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0OSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4gCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4gCisgKiAzLiAgTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwg SW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgorICogICAgIGl0cyBjb250cmlidXRvcnMg bWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAg ICBmcm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1p c3Npb24uIAorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElU UyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJ VFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwor ICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdWJyZXNvdXJjZUxvYWRlci5oIgorCisjaW5jbHVk ZSAiU3VicmVzb3VyY2VMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZExl YWtDb3VudGVyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBTdWJyZXNvdXJjZUxv YWRlcjo6ZGlkRG93bmxvYWREYXRhKGludCBsZW5ndGgpCit7CisgICAgLy8gUmVmZXJlbmNlIHRo ZSBvYmplY3QgaW4gdGhpcyBtZXRob2Qgc2luY2UgdGhlIGFkZGl0aW9uYWwgcHJvY2Vzc2luZyBj YW4gZG8KKyAgICAvLyBhbnl0aGluZyBpbmNsdWRpbmcgcmVtb3ZpbmcgdGhlIGxhc3QgcmVmZXJl bmNlIHRvIHRoaXMgb2JqZWN0OyBvbmUgZXhhbXBsZSBvZiB0aGlzIGlzIDMyNjYyMTYuCisgICAg UmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBwcm90ZWN0KHRoaXMpOworICAgIAorICAgIFJlc291 cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEobGVuZ3RoKTsKKworICAgIGlmIChtX2NsaWVudCkK KyAgICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YSh0aGlzLCBsZW5ndGgpOworfQorCit9 CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xp ZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNv dXJjZUhhbmRsZUNsaWVudC5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAt MTA3LDYgKzEwNyw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBQTEFURk9STShXSU4pICYm IFVTRShDRk5FVFdPUkspCiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRDYWNoZVJlc3BvbnNl KFJlc291cmNlSGFuZGxlKiwgQ0ZDYWNoZWRVUkxSZXNwb25zZVJlZikgeyByZXR1cm4gdHJ1ZTsg fQogI2VuZGlmCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5kbGUqLCBpbnQgLypkYXRhTGVuZ3RoKi8pIHsgfQor I2VuZGlmCiAjaWYgRU5BQkxFKEJMT0IpCiAgICAgICAgIHZpcnR1YWwgQXN5bmNGaWxlU3RyZWFt KiBjcmVhdGVBc3luY0ZpbGVTdHJlYW0oRmlsZVN0cmVhbUNsaWVudCopIHsgcmV0dXJuIDA7IH0K ICNlbmRpZgpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0NDQwKQor KysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwyMCBAQAorMjAxMS0wOS0wMiAgQmlsbCBCdWRnZSAgPGJidWRnZUBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIGEgJ2RpZERvd25sb2FkRGF0YScgbWV0aG9kIHRvIFJlc291cmNlSGFu ZGxlSW50ZXJuYWwgYW5kIHBhc3MgdGhlc2UKKyAgICAgICAgbm90aWZpY2F0aW9ucyB0byBXZWJV UkxMb2FkZXJDbGllbnRzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NjcyMjkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICAqIHNyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 QXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6Q2xpZW50QWRhcHRlcik6CisgICAg ICAgIChXZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6OmRpZERvd25s b2FkRGF0YSk6CisgICAgICAgIChXZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFk YXB0ZXI6OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYktpdDo6QXNzb2NpYXRlZFVSTExv YWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkRmluaXNoTG9hZGluZyk6CisgICAgICAgICogc3JjL1Jl c291cmNlSGFuZGxlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlSW50ZXJu YWw6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJu YWwuaDoKKwogMjAxMS0wOS0wMiAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29tPgog CiAgICAgICAgIFtjaHJvbWl1bV0gUmVtb3ZlIExheWVyUmVuZGVyZXJDaHJvbWl1bSByZWZlcmVu Y2VzIGZyb20gdGhlIExheWVyQ2hyb21pdW0gdHJlZQpJbmRleDogU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAJKHJldmlzaW9uIDk0NDQw KQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTYzLDYgKzYzLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCB3aWxsU2VuZFJlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiAvKm5ld1JlcXVlc3QqLywgY29uc3Qg UmVzb3VyY2VSZXNwb25zZSYgLypyZWRpcmVjdFJlc3BvbnNlKi8pOwogCiAgICAgdmlydHVhbCB2 b2lkIGRpZFJlY2VpdmVSZXNwb25zZSh1bnNpZ25lZCBsb25nLCBjb25zdCBSZXNvdXJjZVJlc3Bv bnNlJik7CisgICAgdmlydHVhbCB2b2lkIGRpZERvd25sb2FkRGF0YShpbnQgLypkYXRhTGVuZ3Ro Ki8pOwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShjb25zdCBjaGFyKiwgaW50IC8q ZGF0YUxlbmd0aCovKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRh KGNvbnN0IGNoYXIqLCBpbnQgLypkYXRhTGVuZ3RoKi8pOwogICAgIHZpcnR1YWwgdm9pZCBkaWRG aW5pc2hMb2FkaW5nKHVuc2lnbmVkIGxvbmcgLyppZGVudGlmaWVyKi8sIGRvdWJsZSAvKmZpbmlz aFRpbWUqLyk7CkBAIC04Nyw3ICs4OCw2IEBAIHByaXZhdGU6CiAgICAgV2ViVVJMRXJyb3IgbV9l cnJvcjsKIAogICAgIFRpbWVyPENsaWVudEFkYXB0ZXI+IG1fZXJyb3JUaW1lcjsKLSAgICB1bnNp Z25lZCBsb25nIG1fZG93bmxvYWRMZW5ndGg7CiAgICAgYm9vbCBtX2Rvd25sb2FkVG9GaWxlOwog ICAgIGJvb2wgbV9lbmFibGVFcnJvck5vdGlmaWNhdGlvbnM7CiAgICAgYm9vbCBtX2RpZEZhaWw7 CkBAIC0xMDIsNyArMTAyLDYgQEAgQXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6 Q2xpZQogICAgIDogbV9sb2FkZXIobG9hZGVyKQogICAgICwgbV9jbGllbnQoY2xpZW50KQogICAg ICwgbV9lcnJvclRpbWVyKHRoaXMsICZDbGllbnRBZGFwdGVyOjpub3RpZnlFcnJvcikKLSAgICAs IG1fZG93bmxvYWRMZW5ndGgoMCkKICAgICAsIG1fZG93bmxvYWRUb0ZpbGUoZG93bmxvYWRUb0Zp bGUpCiAgICAgLCBtX2VuYWJsZUVycm9yTm90aWZpY2F0aW9ucyhmYWxzZSkKICAgICAsIG1fZGlk RmFpbChmYWxzZSkKQEAgLTEzNSwxMyArMTM0LDIwIEBAIHZvaWQgQXNzb2NpYXRlZFVSTExvYWRl cjo6Q2xpZW50QWRhcHRlcjoKICAgICBtX2NsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKG1fbG9h ZGVyLCB3cmFwcGVkUmVzcG9uc2UpOwogfQogCit2b2lkIEFzc29jaWF0ZWRVUkxMb2FkZXI6OkNs aWVudEFkYXB0ZXI6OmRpZERvd25sb2FkRGF0YShpbnQgZGF0YUxlbmd0aCkKK3sKKyAgICBpZiAo IW1fY2xpZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBtX2NsaWVudC0+ZGlkRG93bmxvYWRE YXRhKG1fbG9hZGVyLCBkYXRhTGVuZ3RoKTsKK30KKwogdm9pZCBBc3NvY2lhdGVkVVJMTG9hZGVy OjpDbGllbnRBZGFwdGVyOjpkaWRSZWNlaXZlRGF0YShjb25zdCBjaGFyKiBkYXRhLCBpbnQgZGF0 YUxlbmd0aCkKIHsKICAgICBpZiAoIW1fY2xpZW50KQogICAgICAgICByZXR1cm47CiAKICAgICBt X2NsaWVudC0+ZGlkUmVjZWl2ZURhdGEobV9sb2FkZXIsIGRhdGEsIGRhdGFMZW5ndGgsIC0xKTsK LSAgICBtX2Rvd25sb2FkTGVuZ3RoICs9IGRhdGFMZW5ndGg7CiB9CiAKIHZvaWQgQXNzb2NpYXRl ZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKGNvbnN0 IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKQpAQCAtMTU3LDEyICsxNjMsNiBAQCB2b2lkIEFz c29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6CiAgICAgaWYgKCFtX2NsaWVudCkKICAg ICAgICAgcmV0dXJuOwogCi0gICAgaWYgKG1fZG93bmxvYWRUb0ZpbGUpIHsKLSAgICAgICAgaW50 IGRvd25sb2FkTGVuZ3RoID0gbV9kb3dubG9hZExlbmd0aCA8PSBJTlRfTUFYID8gbV9kb3dubG9h ZExlbmd0aCA6IElOVF9NQVg7Ci0gICAgICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9s b2FkZXIsIGRvd25sb2FkTGVuZ3RoKTsKLSAgICAgICAgLy8gV2hpbGUgdGhlIGNsaWVudCBjb3Vs ZCBoYXZlIGNhbmNlbGVkLCBjb250aW51ZSwgc2luY2UgdGhlIGxvYWQgZmluaXNoZWQuCi0gICAg fQotCiAgICAgbV9jbGllbnQtPmRpZEZpbmlzaExvYWRpbmcobV9sb2FkZXIsIGZpbmlzaFRpbWUp OwogfQogCkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5k bGUuY3BwCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jl c291cmNlSGFuZGxlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTIxLDYgKzEyMSwxNSBAQCB2b2lk IFJlc291cmNlSGFuZGxlSW50ZXJuYWw6OmRpZFJlY2VpdmVSCiAgICAgbV9jbGllbnQtPmRpZFJl Y2VpdmVSZXNwb25zZShtX293bmVyLCByZXNwb25zZS50b1Jlc291cmNlUmVzcG9uc2UoKSk7CiB9 CiAKK3ZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkRG93bmxvYWREYXRhKFdlYlVSTExv YWRlciosIGludCBkYXRhTGVuZ3RoKQoreworICAgIEFTU0VSVChtX2NsaWVudCk7CisgICAgaWYg KG1fc3RhdGUgIT0gQ29ubmVjdGlvblN0YXRlUmVjZWl2ZWRSZXNwb25zZSkKKyAgICAgICAgQ1JB U0goKTsKKworICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9vd25lciwgZGF0YUxlbmd0 aCk7Cit9CisKIHZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkUmVjZWl2ZURhdGEoV2Vi VVJMTG9hZGVyKiwgY29uc3QgY2hhciogZGF0YSwgaW50IGRhdGFMZW5ndGgsIGludCBlbmNvZGVk RGF0YUxlbmd0aCkKIHsKICAgICBBU1NFUlQobV9jbGllbnQpOwpJbmRleDogU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaAkocmV2aXNp b24gOTQ0NDApCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZUlu dGVybmFsLmgJKHdvcmtpbmcgY29weSkKQEAgLTU2LDYgKzU2LDcgQEAgcHVibGljOgogICAgIHZp cnR1YWwgdm9pZCB3aWxsU2VuZFJlcXVlc3QoV2ViS2l0OjpXZWJVUkxMb2FkZXIqLCBXZWJLaXQ6 OldlYlVSTFJlcXVlc3QmLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlc3BvbnNlJik7CiAgICAgdmly dHVhbCB2b2lkIGRpZFNlbmREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgdW5zaWduZWQgbG9u ZyBsb25nIGJ5dGVzU2VudCwgdW5zaWduZWQgbG9uZyBsb25nIHRvdGFsQnl0ZXNUb0JlU2VudCk7 CiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShXZWJLaXQ6OldlYlVSTExvYWRl ciosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVzcG9uc2UmKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlk RG93bmxvYWREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgaW50IGRhdGFMZW5ndGgpOwogICAg IHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShXZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0 IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoLCBpbnQgZW5jb2RlZERhdGFMZW5ndGgpOwogCiAg ICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShXZWJLaXQ6OldlYlVSTExv YWRlciosIGNvbnN0IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKTsK 106219 2011-09-02 16:28:32 -0700 2011-09-02 17:16:45 -0700 Proposed Patch aul.txt text/plain 19593 bbudge SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0NDQwKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTEtMDktMDIgIEJpbGwgQnVk Z2UgIDxiYnVkZ2VAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBhICdkaWREb3dubG9hZERh dGEnIG1ldGhvZCB0byBSZXNvdXJjZUxvYWRlciwgU3VicmVzb3VyY2VMb2FkZXIsCisgICAgICAg IFN1YnJlc291cmNlTG9hZGVyQ2xpZW50LCBEb2N1bWVudFRocmVhZGFibGVMb2FkZXIsIFJlc291 cmNlSGFuZGxlQ2xpZW50LAorICAgICAgICBhbmQgVGhyZWFkYWJsZUxvYWRlckNsaWVudCBmb3Ig dGhlIENocm9taXVtIHBvcnQgb25seSwgc28gd2UgY2FuIHBhc3MKKyAgICAgICAgdGhlc2Ugbm90 aWZpY2F0aW9ucyBmcm9tIG91ciBSZXNvdXJjZUhhbmRsZSBpbXBsZW1lbnRhdGlvbiB0aHJvdWdo IHRoZQorICAgICAgICBXZWJDb3JlIGxvYWRlciBmcmFtZXdvcmsuCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NzIyOQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gRXhwb3NlcyBubyBu ZXcgZnVuY3Rpb25hbGl0eS4KKworICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBs b2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmg6CisgICAgICAgICogbG9hZGVyL1Jlc291 cmNlTG9hZGVyLmg6CisgICAgICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyLmg6CisgICAg ICAgICogbG9hZGVyL1N1YnJlc291cmNlTG9hZGVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTdWJyZXNvdXJjZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBs b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFk YWJsZUxvYWRlckNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAgKiBsb2FkZXIvVGhy ZWFkYWJsZUxvYWRlckNsaWVudFdyYXBwZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZGFi bGVMb2FkZXJDbGllbnRXcmFwcGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIGxvYWRl ci9jaHJvbWl1bTogQWRkZWQuCisgICAgICAgICogbG9hZGVyL2Nocm9taXVtL0RvY3VtZW50VGhy ZWFkYWJsZUxvYWRlckNocm9taXVtLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudFRocmVhZGFibGVMb2FkZXI6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogbG9hZGVy L2Nocm9taXVtL1Jlc291cmNlTG9hZGVyQ2hyb21pdW0uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlJlc291cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEpOgorICAgICAgICAqIGxvYWRl ci9jaHJvbWl1bS9TdWJyZXNvdXJjZUxvYWRlckNocm9taXVtLmNwcDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpTdWJyZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKToKKyAgICAgICAg KiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xpZW50Lmg6CisgICAgICAgIChXZWJD b3JlOjpSZXNvdXJjZUhhbmRsZUNsaWVudDo6ZGlkRG93bmxvYWREYXRhKToKKwogMjAxMS0wOS0w MiAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJlbW92ZSBCZWZvcmVQ cm9jZXNzRXZlbnQsIGl0IHdhcyBuZXZlciBtZWFudCB0byBiZQpJbmRleDogU291cmNlL1dlYkNv cmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lw aQkocmV2aXNpb24gOTQ0NDApCisrKyBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtp bmcgY29weSkKQEAgLTI4MjUsNiArMjgyNSw5IEBACiAgICAgICAgICAgICAnbG9hZGVyL2NhY2hl L0NhY2hlZFhTTFN0eWxlU2hlZXQuaCcsCiAgICAgICAgICAgICAnbG9hZGVyL2NhY2hlL01lbW9y eUNhY2hlLmNwcCcsCiAgICAgICAgICAgICAnbG9hZGVyL2NmL1Jlc291cmNlTG9hZGVyQ0ZOZXQu Y3BwJywKKyAgICAgICAgICAgICdsb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9h ZGVyQ2hyb21pdW0uY3BwJywKKyAgICAgICAgICAgICdsb2FkZXIvY2hyb21pdW0vUmVzb3VyY2VM b2FkZXJDaHJvbWl1bS5jcHAnLAorICAgICAgICAgICAgJ2xvYWRlci9jaHJvbWl1bS9TdWJyZXNv dXJjZUxvYWRlckNocm9taXVtLmNwcCcsCiAgICAgICAgICAgICAnbG9hZGVyL2ljb24vSWNvbkNv bnRyb2xsZXIuY3BwJywKICAgICAgICAgICAgICdsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3Bw JywKICAgICAgICAgICAgICdsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2VCYXNlLmNwcCcsCkluZGV4 OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxvYWRlci5o CShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudFRocmVh ZGFibGVMb2FkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtODQsNiArODQsMTAgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlQXV0aGVudGljYXRp b25DaGFsbGVuZ2UoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBBdXRoZW50aWNhdGlvbkNoYWxs ZW5nZSYpOwogCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWREb3dubG9hZERhdGEoU3VicmVzb3VyY2VMb2FkZXIqLCBpbnQgZGF0YUxlbmd0aCk7CisjZW5k aWYKKwogICAgICAgICB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZSh1bnNpZ25lZCBsb25nIGlkZW50 aWZpZXIsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKTsKICAgICAgICAgdm9pZCBkaWRGaW5pc2hM b2FkaW5nKHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgZG91YmxlIGZpbmlzaFRpbWUpOwogICAg ICAgICB2b2lkIG1ha2VTaW1wbGVDcm9zc09yaWdpbkFjY2Vzc1JlcXVlc3QoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0KTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJj ZUxvYWRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJjZUxv YWRlci5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9SZXNvdXJj ZUxvYWRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMjksNiArMTI5LDEwIEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgLy8gRklYTUU6IFdpbmRvd3Mgc2hvdWxkIHVzZSB3aWxsQ2FjaGVS ZXNwb25zZSAtIDxodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTcyNTc+ LgogICAgICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkQ2FjaGVSZXNwb25zZShSZXNvdXJjZUhhbmRs ZSosIENGQ2FjaGVkVVJMUmVzcG9uc2VSZWYpOwogI2VuZGlmCisjaWYgUExBVEZPUk0oQ0hST01J VU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5kbGUq LCBpbnQpOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGludCk7CisjZW5k aWYKICNpZiBFTkFCTEUoQkxPQikKICAgICAgICAgdmlydHVhbCBBc3luY0ZpbGVTdHJlYW0qIGNy ZWF0ZUFzeW5jRmlsZVN0cmVhbShGaWxlU3RyZWFtQ2xpZW50Kik7CiAjZW5kaWYKSW5kZXg6IFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCShyZXZpc2lvbiA5NDQ0MCkK KysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlci5oCSh3b3JraW5nIGNv cHkpCkBAIC02NCw2ICs2NCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVh bCBib29sIHN1cHBvcnRzRGF0YUFycmF5KCkgeyByZXR1cm4gdHJ1ZTsgfQogICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkUmVjZWl2ZURhdGFBcnJheShDRkFycmF5UmVmKTsKICNlbmRpZgorI2lmIFBM QVRGT1JNKENIUk9NSVVNKQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWREYXRhKGlu dCk7CisjZW5kaWYKIAogICAgICAgICBTdWJyZXNvdXJjZUxvYWRlckNsaWVudCogbV9jbGllbnQ7 CiAgICAgICAgIGJvb2wgbV9sb2FkaW5nTXVsdGlwYXJ0Q29udGVudDsKSW5kZXg6IFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5 NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9TdWJyZXNvdXJjZUxvYWRlckNsaWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC01Miw2ICs1MiwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIGRpZEZhaWwoU3VicmVzb3VyY2VMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm9yJikgeyB9 CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVBdXRoZW50aWNhdGlvbkNoYWxsZW5n ZShTdWJyZXNvdXJjZUxvYWRlciosIGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikgeyB9 CisKKyNpZiBQTEFURk9STShDSFJPTUlVTSkKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRG93bmxvYWRE YXRhKFN1YnJlc291cmNlTG9hZGVyKiwgaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgog fTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVy L1RocmVhZGFibGVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvVGhyZWFkYWJsZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJj ZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50LmgJKHdvcmtpbmcgY29weSkK QEAgLTUxLDYgKzUxLDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2aXJ0dWFs IGJvb2wgaXNEb2N1bWVudFRocmVhZGFibGVMb2FkZXJDbGllbnQoKSB7IHJldHVybiBmYWxzZTsg fQogCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBkaWREb3du bG9hZERhdGEoaW50IC8qZGF0YUxlbmd0aCovKSB7IH0KKyNlbmRpZgorCiAgICAgcHJvdGVjdGVk OgogICAgICAgICBUaHJlYWRhYmxlTG9hZGVyQ2xpZW50KCkgeyB9CiAgICAgICAgIHZpcnR1YWwg flRocmVhZGFibGVMb2FkZXJDbGllbnQoKSB7IH0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRl ci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9X ZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3JhcHBlci5oCShyZXZpc2lvbiA5 NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9UaHJlYWRhYmxlTG9hZGVyQ2xpZW50V3Jh cHBlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMDcsNiArMTA3LDE0IEBAIHB1YmxpYzoKICAgICAg ICAgICAgIG1fY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaWRlbnRpZmllciwgcmVzcG9uc2Up OwogICAgIH0KIAorI2lmIFBMQVRGT1JNKENIUk9NSVVNKQorICAgIHZvaWQgZGlkRG93bmxvYWRE YXRhKGludCBkYXRhTGVuZ3RoKQorICAgIHsKKyAgICAgICAgaWYgKG1fY2xpZW50KQorICAgICAg ICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YShkYXRhTGVuZ3RoKTsKKyAgICB9CisjZW5k aWYKKwogcHJvdGVjdGVkOgogICAgIFRocmVhZGFibGVMb2FkZXJDbGllbnRXcmFwcGVyKFRocmVh ZGFibGVMb2FkZXJDbGllbnQqIGNsaWVudCkKICAgICAgICAgOiBtX2NsaWVudChjbGllbnQpCklu ZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9h ZGVyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9jaHJv bWl1bS9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDApCisr KyBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vRG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVy Q2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQ4IEBACisvKgorICogQ29weXJp Z2h0IChjKSAyMDExLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKyNpbmNsdWRlICJEb2N1bWVudFRocmVhZGFibGVMb2FkZXIuaCIKKworI2luY2x1 ZGUgIlN1YnJlc291cmNlTG9hZGVyLmgiCisjaW5jbHVkZSAiVGhyZWFkYWJsZUxvYWRlckNsaWVu dC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgRG9jdW1lbnRUaHJlYWRhYmxlTG9h ZGVyOjpkaWREb3dubG9hZERhdGEoU3VicmVzb3VyY2VMb2FkZXIqIGxvYWRlciwgaW50IGRhdGFM ZW5ndGgpCit7CisgICAgQVNTRVJUKG1fY2xpZW50KTsKKyAgICBBU1NFUlRfVU5VU0VEKGxvYWRl ciwgbG9hZGVyID09IG1fbG9hZGVyKTsKKyAgICBBU1NFUlQoIW1fYWN0dWFsUmVxdWVzdCk7CisK KyAgICBtX2NsaWVudC0+ZGlkRG93bmxvYWREYXRhKGRhdGFMZW5ndGgpOworfQorCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hyb21pdW0vUmVz b3VyY2VMb2FkZXJDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvbG9h ZGVyL2Nocm9taXVtL1Jlc291cmNlTG9hZGVyQ2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQorKysg U291cmNlL1dlYkNvcmUvbG9hZGVyL2Nocm9taXVtL1Jlc291cmNlTG9hZGVyQ2hyb21pdW0uY3Bw CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU1IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDEx LCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNp bmNsdWRlICJSZXNvdXJjZUxvYWRlci5oIgorCisjaW5jbHVkZSAiQXBwbGljYXRpb25DYWNoZUhv c3QuaCIKKyNpbmNsdWRlICJEb2N1bWVudExvYWRlci5oIgorI2luY2x1ZGUgIkZyYW1lLmgiCisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBSZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWRE YXRhKFJlc291cmNlSGFuZGxlKiwgaW50IGxlbmd0aCkKK3sKKyAgICBkaWREb3dubG9hZERhdGEo bGVuZ3RoKTsKK30KKwordm9pZCBSZXNvdXJjZUxvYWRlcjo6ZGlkRG93bmxvYWREYXRhKGludCBs ZW5ndGgpCit7CisjaWYgRU5BQkxFKE9GRkxJTkVfV0VCX0FQUExJQ0FUSU9OUykKKyAgICBpZiAo IW1fY2FuY2VsbGVkICYmICFmYXN0TWFsbG9jU2l6ZShkb2N1bWVudExvYWRlcigpLT5hcHBsaWNh dGlvbkNhY2hlSG9zdCgpKSkKKyAgICAgICAgQ1JBU0goKTsKKyNlbmRpZgorICAgIGlmICghbV9j YW5jZWxsZWQgJiYgIWZhc3RNYWxsb2NTaXplKGRvY3VtZW50TG9hZGVyKCktPmZyYW1lKCkpKQor ICAgICAgICBDUkFTSCgpOworfQorCit9CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvY2hy b21pdW0vU3VicmVzb3VyY2VMb2FkZXJDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvbG9hZGVyL2Nocm9taXVtL1N1YnJlc291cmNlTG9hZGVyQ2hyb21pdW0uY3BwCShy ZXZpc2lvbiAwKQorKysgU291cmNlL1dlYkNvcmUvbG9hZGVyL2Nocm9taXVtL1N1YnJlc291cmNl TG9hZGVyQ2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDUxIEBACisvKgorICog Q29weXJpZ2h0IChjKSAyMDExLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdWJyZXNvdXJjZUxvYWRlci5oIgorCisjaW5jbHVk ZSAiU3VicmVzb3VyY2VMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZExl YWtDb3VudGVyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBTdWJyZXNvdXJjZUxv YWRlcjo6ZGlkRG93bmxvYWREYXRhKGludCBsZW5ndGgpCit7CisgICAgLy8gUmVmZXJlbmNlIHRo ZSBvYmplY3QgaW4gdGhpcyBtZXRob2Qgc2luY2UgdGhlIGFkZGl0aW9uYWwgcHJvY2Vzc2luZyBj YW4gZG8KKyAgICAvLyBhbnl0aGluZyBpbmNsdWRpbmcgcmVtb3ZpbmcgdGhlIGxhc3QgcmVmZXJl bmNlIHRvIHRoaXMgb2JqZWN0OyBvbmUgZXhhbXBsZSBvZiB0aGlzIGlzIDMyNjYyMTYuCisgICAg UmVmUHRyPFN1YnJlc291cmNlTG9hZGVyPiBwcm90ZWN0KHRoaXMpOworICAgIAorICAgIFJlc291 cmNlTG9hZGVyOjpkaWREb3dubG9hZERhdGEobGVuZ3RoKTsKKworICAgIGlmIChtX2NsaWVudCkK KyAgICAgICAgbV9jbGllbnQtPmRpZERvd25sb2FkRGF0YSh0aGlzLCBsZW5ndGgpOworfQorCit9 CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlQ2xp ZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNv dXJjZUhhbmRsZUNsaWVudC5oCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAt MTA3LDYgKzEwNyw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNpZiBQTEFURk9STShXSU4pICYm IFVTRShDRk5FVFdPUkspCiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRDYWNoZVJlc3BvbnNl KFJlc291cmNlSGFuZGxlKiwgQ0ZDYWNoZWRVUkxSZXNwb25zZVJlZikgeyByZXR1cm4gdHJ1ZTsg fQogI2VuZGlmCisjaWYgUExBVEZPUk0oQ0hST01JVU0pCisgICAgICAgIHZpcnR1YWwgdm9pZCBk aWREb3dubG9hZERhdGEoUmVzb3VyY2VIYW5kbGUqLCBpbnQgLypkYXRhTGVuZ3RoKi8pIHsgfQor I2VuZGlmCiAjaWYgRU5BQkxFKEJMT0IpCiAgICAgICAgIHZpcnR1YWwgQXN5bmNGaWxlU3RyZWFt KiBjcmVhdGVBc3luY0ZpbGVTdHJlYW0oRmlsZVN0cmVhbUNsaWVudCopIHsgcmV0dXJuIDA7IH0K ICNlbmRpZgpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHJldmlzaW9uIDk0NDQwKQor KysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwyMCBAQAorMjAxMS0wOS0wMiAgQmlsbCBCdWRnZSAgPGJidWRnZUBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIGEgJ2RpZERvd25sb2FkRGF0YScgbWV0aG9kIHRvIFJlc291cmNlSGFu ZGxlSW50ZXJuYWwgYW5kIHBhc3MgdGhlc2UKKyAgICAgICAgbm90aWZpY2F0aW9ucyB0byBXZWJV UkxMb2FkZXJDbGllbnRzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NjcyMjkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICAqIHNyYy9Bc3NvY2lhdGVkVVJMTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 QXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6Q2xpZW50QWRhcHRlcik6CisgICAg ICAgIChXZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6OmRpZERvd25s b2FkRGF0YSk6CisgICAgICAgIChXZWJLaXQ6OkFzc29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFk YXB0ZXI6OmRpZFJlY2VpdmVEYXRhKToKKyAgICAgICAgKFdlYktpdDo6QXNzb2NpYXRlZFVSTExv YWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkRmluaXNoTG9hZGluZyk6CisgICAgICAgICogc3JjL1Jl c291cmNlSGFuZGxlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlSW50ZXJu YWw6OmRpZERvd25sb2FkRGF0YSk6CisgICAgICAgICogc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJu YWwuaDoKKwogMjAxMS0wOS0wMiAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29tPgog CiAgICAgICAgIFtjaHJvbWl1bV0gUmVtb3ZlIExheWVyUmVuZGVyZXJDaHJvbWl1bSByZWZlcmVu Y2VzIGZyb20gdGhlIExheWVyQ2hyb21pdW0gdHJlZQpJbmRleDogU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAJKHJldmlzaW9uIDk0NDQw KQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQXNzb2NpYXRlZFVSTExvYWRlci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTYzLDYgKzYzLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCB3aWxsU2VuZFJlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiAvKm5ld1JlcXVlc3QqLywgY29uc3Qg UmVzb3VyY2VSZXNwb25zZSYgLypyZWRpcmVjdFJlc3BvbnNlKi8pOwogCiAgICAgdmlydHVhbCB2 b2lkIGRpZFJlY2VpdmVSZXNwb25zZSh1bnNpZ25lZCBsb25nLCBjb25zdCBSZXNvdXJjZVJlc3Bv bnNlJik7CisgICAgdmlydHVhbCB2b2lkIGRpZERvd25sb2FkRGF0YShpbnQgLypkYXRhTGVuZ3Ro Ki8pOwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShjb25zdCBjaGFyKiwgaW50IC8q ZGF0YUxlbmd0aCovKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRh KGNvbnN0IGNoYXIqLCBpbnQgLypkYXRhTGVuZ3RoKi8pOwogICAgIHZpcnR1YWwgdm9pZCBkaWRG aW5pc2hMb2FkaW5nKHVuc2lnbmVkIGxvbmcgLyppZGVudGlmaWVyKi8sIGRvdWJsZSAvKmZpbmlz aFRpbWUqLyk7CkBAIC04Nyw3ICs4OCw2IEBAIHByaXZhdGU6CiAgICAgV2ViVVJMRXJyb3IgbV9l cnJvcjsKIAogICAgIFRpbWVyPENsaWVudEFkYXB0ZXI+IG1fZXJyb3JUaW1lcjsKLSAgICB1bnNp Z25lZCBsb25nIG1fZG93bmxvYWRMZW5ndGg7CiAgICAgYm9vbCBtX2Rvd25sb2FkVG9GaWxlOwog ICAgIGJvb2wgbV9lbmFibGVFcnJvck5vdGlmaWNhdGlvbnM7CiAgICAgYm9vbCBtX2RpZEZhaWw7 CkBAIC0xMDIsNyArMTAyLDYgQEAgQXNzb2NpYXRlZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6 Q2xpZQogICAgIDogbV9sb2FkZXIobG9hZGVyKQogICAgICwgbV9jbGllbnQoY2xpZW50KQogICAg ICwgbV9lcnJvclRpbWVyKHRoaXMsICZDbGllbnRBZGFwdGVyOjpub3RpZnlFcnJvcikKLSAgICAs IG1fZG93bmxvYWRMZW5ndGgoMCkKICAgICAsIG1fZG93bmxvYWRUb0ZpbGUoZG93bmxvYWRUb0Zp bGUpCiAgICAgLCBtX2VuYWJsZUVycm9yTm90aWZpY2F0aW9ucyhmYWxzZSkKICAgICAsIG1fZGlk RmFpbChmYWxzZSkKQEAgLTEzNSwxMyArMTM0LDIwIEBAIHZvaWQgQXNzb2NpYXRlZFVSTExvYWRl cjo6Q2xpZW50QWRhcHRlcjoKICAgICBtX2NsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKG1fbG9h ZGVyLCB3cmFwcGVkUmVzcG9uc2UpOwogfQogCit2b2lkIEFzc29jaWF0ZWRVUkxMb2FkZXI6OkNs aWVudEFkYXB0ZXI6OmRpZERvd25sb2FkRGF0YShpbnQgZGF0YUxlbmd0aCkKK3sKKyAgICBpZiAo IW1fY2xpZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBtX2NsaWVudC0+ZGlkRG93bmxvYWRE YXRhKG1fbG9hZGVyLCBkYXRhTGVuZ3RoKTsKK30KKwogdm9pZCBBc3NvY2lhdGVkVVJMTG9hZGVy OjpDbGllbnRBZGFwdGVyOjpkaWRSZWNlaXZlRGF0YShjb25zdCBjaGFyKiBkYXRhLCBpbnQgZGF0 YUxlbmd0aCkKIHsKICAgICBpZiAoIW1fY2xpZW50KQogICAgICAgICByZXR1cm47CiAKICAgICBt X2NsaWVudC0+ZGlkUmVjZWl2ZURhdGEobV9sb2FkZXIsIGRhdGEsIGRhdGFMZW5ndGgsIC0xKTsK LSAgICBtX2Rvd25sb2FkTGVuZ3RoICs9IGRhdGFMZW5ndGg7CiB9CiAKIHZvaWQgQXNzb2NpYXRl ZFVSTExvYWRlcjo6Q2xpZW50QWRhcHRlcjo6ZGlkUmVjZWl2ZUNhY2hlZE1ldGFkYXRhKGNvbnN0 IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKQpAQCAtMTU3LDEyICsxNjMsNiBAQCB2b2lkIEFz c29jaWF0ZWRVUkxMb2FkZXI6OkNsaWVudEFkYXB0ZXI6CiAgICAgaWYgKCFtX2NsaWVudCkKICAg ICAgICAgcmV0dXJuOwogCi0gICAgaWYgKG1fZG93bmxvYWRUb0ZpbGUpIHsKLSAgICAgICAgaW50 IGRvd25sb2FkTGVuZ3RoID0gbV9kb3dubG9hZExlbmd0aCA8PSBJTlRfTUFYID8gbV9kb3dubG9h ZExlbmd0aCA6IElOVF9NQVg7Ci0gICAgICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9s b2FkZXIsIGRvd25sb2FkTGVuZ3RoKTsKLSAgICAgICAgLy8gV2hpbGUgdGhlIGNsaWVudCBjb3Vs ZCBoYXZlIGNhbmNlbGVkLCBjb250aW51ZSwgc2luY2UgdGhlIGxvYWQgZmluaXNoZWQuCi0gICAg fQotCiAgICAgbV9jbGllbnQtPmRpZEZpbmlzaExvYWRpbmcobV9sb2FkZXIsIGZpbmlzaFRpbWUp OwogfQogCkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5k bGUuY3BwCShyZXZpc2lvbiA5NDQ0MCkKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jl c291cmNlSGFuZGxlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTIxLDYgKzEyMSwxNSBAQCB2b2lk IFJlc291cmNlSGFuZGxlSW50ZXJuYWw6OmRpZFJlY2VpdmVSCiAgICAgbV9jbGllbnQtPmRpZFJl Y2VpdmVSZXNwb25zZShtX293bmVyLCByZXNwb25zZS50b1Jlc291cmNlUmVzcG9uc2UoKSk7CiB9 CiAKK3ZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkRG93bmxvYWREYXRhKFdlYlVSTExv YWRlciosIGludCBkYXRhTGVuZ3RoKQoreworICAgIEFTU0VSVChtX2NsaWVudCk7CisgICAgaWYg KG1fc3RhdGUgIT0gQ29ubmVjdGlvblN0YXRlUmVjZWl2ZWRSZXNwb25zZSkKKyAgICAgICAgQ1JB U0goKTsKKworICAgIG1fY2xpZW50LT5kaWREb3dubG9hZERhdGEobV9vd25lciwgZGF0YUxlbmd0 aCk7Cit9CisKIHZvaWQgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6ZGlkUmVjZWl2ZURhdGEoV2Vi VVJMTG9hZGVyKiwgY29uc3QgY2hhciogZGF0YSwgaW50IGRhdGFMZW5ndGgsIGludCBlbmNvZGVk RGF0YUxlbmd0aCkKIHsKICAgICBBU1NFUlQobV9jbGllbnQpOwpJbmRleDogU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaAkocmV2aXNp b24gOTQ0NDApCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9SZXNvdXJjZUhhbmRsZUlu dGVybmFsLmgJKHdvcmtpbmcgY29weSkKQEAgLTU2LDYgKzU2LDcgQEAgcHVibGljOgogICAgIHZp cnR1YWwgdm9pZCB3aWxsU2VuZFJlcXVlc3QoV2ViS2l0OjpXZWJVUkxMb2FkZXIqLCBXZWJLaXQ6 OldlYlVSTFJlcXVlc3QmLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlc3BvbnNlJik7CiAgICAgdmly dHVhbCB2b2lkIGRpZFNlbmREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgdW5zaWduZWQgbG9u ZyBsb25nIGJ5dGVzU2VudCwgdW5zaWduZWQgbG9uZyBsb25nIHRvdGFsQnl0ZXNUb0JlU2VudCk7 CiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVSZXNwb25zZShXZWJLaXQ6OldlYlVSTExvYWRl ciosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVzcG9uc2UmKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlk RG93bmxvYWREYXRhKFdlYktpdDo6V2ViVVJMTG9hZGVyKiwgaW50IGRhdGFMZW5ndGgpOwogICAg IHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlRGF0YShXZWJLaXQ6OldlYlVSTExvYWRlciosIGNvbnN0 IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoLCBpbnQgZW5jb2RlZERhdGFMZW5ndGgpOwogCiAg ICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVDYWNoZWRNZXRhZGF0YShXZWJLaXQ6OldlYlVSTExv YWRlciosIGNvbnN0IGNoYXIqIGRhdGEsIGludCBkYXRhTGVuZ3RoKTsK