68460 2011-09-20 13:02:40 -0700 Add WebCore platform interfaces needed by updated PeerConnection design 2014-03-02 09:18:07 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 67946 68462 68464 0 adam.bergkvist webkit-unassigned abarth ap arun.patole donggwan.kim eric.carlson fishd grunell harald jonathon juberti per-erik.brodin sam scherkus s.choi tommyw webkit.review.bot oldest_to_newest 470262 0 adam.bergkvist 2011-09-20 13:02:40 -0700 Add the files in WebCore/platform/mediastream nedded by MediaStream and PeerConnection. 470264 1 108042 adam.bergkvist 2011-09-20 13:07:53 -0700 Created attachment 108042 Proposed patch 470309 2 108042 abarth 2011-09-20 13:59:23 -0700 Comment on attachment 108042 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=108042&action=review > Source/WebCore/platform/mediastream/MediaStreamManager.cpp:47 > +MediaStreamManager& mediaStreamManager() Historically WebKit has shied away from "manager" in class names. It's a very general name. If we had a more specific name, that might help focus what this class is about. > Source/WebCore/platform/mediastream/MediaStreamManager.cpp:73 > +void MediaStreamManager::setMediaStreamComponentEnabled(const MediaStreamDescriptor* streamDescriptor, unsigned componentIndex, bool enabled) enableMediaStreamComponent ? > Source/WebCore/platform/mediastream/MediaStreamManager.h:56 > + void setMediaStreamComponentEnabled(const MediaStreamDescriptor*, unsigned componentIndex, bool enabled); > + void stopLocalMediaStream(const MediaStreamDescriptor*); > + > + void streamEnded(MediaStreamDescriptor*); These methods looks suspiciously like they might be better as member functions of MediaStreamDescriptor. > Source/WebCore/platform/mediastream/MediaStreamManagerPrivate.h:48 > +class MediaStreamManagerPrivateInterface { > +public: > + virtual ~MediaStreamManagerPrivateInterface() { } > + > + virtual void setMediaStreamComponentEnabled(const MediaStreamDescriptor*, unsigned componentIndex, bool enabled) = 0; > + virtual void stopLocalMediaStream(const MediaStreamDescriptor*) = 0; > +}; I'm slightly unclear about what this class is for. Is this virtual interface something like PlatformSupport? MediaStreamManagerPrivateInterface is quite a mouthful and pretty opaque. > Source/WebCore/platform/mediastream/PeerHandler.h:44 > +class PeerHandlerPrivateInterface; I'm not super excited about this "private interface" approach. It seems like we should follow one of the existing design patterns. > Source/WebCore/platform/mediastream/PeerHandler.h:51 > + TypeNONE, > + TypeSTUN, > + TypeTURN I'm not quite clear which concepts are going to be in WebCore and which concepts are only in the underlying library. I was hoping that STUN would be a library-internal concept. Is there some reason WebCore needs to be aware of STUN? 470420 3 108042 tommyw 2011-09-20 15:45:08 -0700 Comment on attachment 108042 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=108042&action=review > Source/WebCore/platform/mediastream/PeerHandler.h:46 > +struct PeerHandlerConfiguration : public RefCounted<PeerHandlerConfiguration> { Shouldn't this class be called PeerConnectionConfiguration? >> Source/WebCore/platform/mediastream/PeerHandler.h:51 >> + TypeTURN > > I'm not quite clear which concepts are going to be in WebCore and which concepts are only in the underlying library. I was hoping that STUN would be a library-internal concept. Is there some reason WebCore needs to be aware of STUN? I agree with you here, but "unfortunately" the spec specifies exactly how the configuration string should look like. The alternative, which I prefer, is to just pass the string to the platform specific code. 470474 4 ap 2011-09-20 16:59:21 -0700 I'm certainly not an expert on MediaStream, but the code added here looks very specific to your high level task, not like building blocks that could be used for something else. As such, I think that putting this code in platform/ is wrong. 470498 5 abarth 2011-09-20 17:32:02 -0700 It seems clear that there should be some sort of platform abstraction in WebCore/platform. The question somewhat revolves around what that API should look like. 470762 6 adam.bergkvist 2011-09-21 06:51:42 -0700 (In reply to comment #2) > (From update of attachment 108042 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=108042&action=review > > > Source/WebCore/platform/mediastream/MediaStreamManager.cpp:47 > > +MediaStreamManager& mediaStreamManager() > > Historically WebKit has shied away from "manager" in class names. It's a very general name. If we had a more specific name, that might help focus what this class is about. > MediaStream is an abstract representation of a media stream in the platform backend. MediaStreamManager is a single entry point for propagating changes between LocalMediaStream/MediaStream/MediaStreamTrack and the platform backend. It also manages the lifetime of a LocalMediaStream, from querying the backend for media stream components, to revoking further access to the underlying media streams. If you have a suggestion for a better name we are more than happy to change it. > > Source/WebCore/platform/mediastream/MediaStreamManager.cpp:73 > > +void MediaStreamManager::setMediaStreamComponentEnabled(const MediaStreamDescriptor* streamDescriptor, unsigned componentIndex, bool enabled) > > enableMediaStreamComponent ? > The reason for the somewhat awkward name is that it takes a boolean argument which maps well to the 'enabled' property setter on MediaStreamTrack. enableMediaStreamComponent sort of implies that there is a disableMediaStreamComponent as well. > > Source/WebCore/platform/mediastream/MediaStreamManager.h:56 > > + void setMediaStreamComponentEnabled(const MediaStreamDescriptor*, unsigned componentIndex, bool enabled); > > + void stopLocalMediaStream(const MediaStreamDescriptor*); > > + > > + void streamEnded(MediaStreamDescriptor*); > > These methods looks suspiciously like they might be better as member functions of MediaStreamDescriptor. > The MediaStreamDescriptor struct is meant to be a lightweight platform-independent container for MediaStream to store its data in, to be used by the platform backend. Moving the methods above to MediaStreamDescriptor would mean that we also have to add a way for it to talk to the platform. > > Source/WebCore/platform/mediastream/MediaStreamManagerPrivate.h:48 > > +class MediaStreamManagerPrivateInterface { > > +public: > > + virtual ~MediaStreamManagerPrivateInterface() { } > > + > > + virtual void setMediaStreamComponentEnabled(const MediaStreamDescriptor*, unsigned componentIndex, bool enabled) = 0; > > + virtual void stopLocalMediaStream(const MediaStreamDescriptor*) = 0; > > +}; > > I'm slightly unclear about what this class is for. Is this virtual interface something like PlatformSupport? MediaStreamManagerPrivateInterface is quite a mouthful and pretty opaque. > > > Source/WebCore/platform/mediastream/PeerHandler.h:44 > > +class PeerHandlerPrivateInterface; > > I'm not super excited about this "private interface" approach. It seems like we should follow one of the existing design patterns. > This pattern is used by MediaPlayer to provide media backend abstractions for HTMLMediaElement. We prefer this pattern over other common patterns such as the one with a shared header file, which usually leads to the header file being cluttered with PLATFORM and OS ifdefs. 470776 7 adam.bergkvist 2011-09-21 07:10:41 -0700 (In reply to comment #3) > (From update of attachment 108042 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=108042&action=review > > > Source/WebCore/platform/mediastream/PeerHandler.h:46 > > +struct PeerHandlerConfiguration : public RefCounted<PeerHandlerConfiguration> { > > Shouldn't this class be called PeerConnectionConfiguration? > Perhaps PeerConnectionConfiguration would better explain that it's created from the PeerConnection serverConfiguration argument, but it's the object that configures the PeerHandler and it's never used by PeerConnection. It's also stored as a member on PeerHandler. > >> Source/WebCore/platform/mediastream/PeerHandler.h:51 > >> + TypeTURN > > > > I'm not quite clear which concepts are going to be in WebCore and which concepts are only in the underlying library. I was hoping that STUN would be a library-internal concept. Is there some reason WebCore needs to be aware of STUN? > > I agree with you here, but "unfortunately" the spec specifies exactly how the configuration string should look like. The alternative, which I prefer, is to just pass the string to the platform specific code. The serverConfiguration argument string must be specified in order to achieve interoperability between implementations. I think the parsing should be done in the shared WebCore code to make the behavior consistent between ports (and to avoid duplicate code). The PeerHandlerConfiguration struct could easily be serialized back to a string if it's easier to pass it to chromium that way. 470778 8 adam.bergkvist 2011-09-21 07:18:42 -0700 (In reply to comment #4) > I'm certainly not an expert on MediaStream, but the code added here looks very specific to your high level task, not like building blocks that could be used for something else. You're right, it's not reusable low-level building blocks, but rather platform abstractions for a media stream and peer-to-peer backends. Unless we want to perform ICE-processing logic in shared WebCore code I can't see how we could create more low-level abstractions. 470945 9 ap 2011-09-21 11:03:03 -0700 What is ICE-processing? 471073 10 abarth 2011-09-21 12:56:12 -0700 > What is ICE-processing? ICE is the network protocol used to establish peer-to-peer UDP connections. It's very complex, and we certainly don't want to re-implement it in WebCore. 471082 11 tommyw 2011-09-21 13:02:33 -0700 (In reply to comment #10) > > What is ICE-processing? > > ICE is the network protocol used to establish peer-to-peer UDP connections. It's very complex, and we certainly don't want to re-implement it in WebCore. http://en.wikipedia.org/wiki/Interactive_Connectivity_Establishment 471093 12 abarth 2011-09-21 13:10:07 -0700 > This pattern is used by MediaPlayer to provide media backend abstractions for HTMLMediaElement. Unfortunately, MediaPlayer isn't the best model to work off of. I feel like you're not being receptive to my comments, which makes me less interested in reviewing these patches. Other reviewers should feel free to take over reviewing this patch. 471485 13 adam.bergkvist 2011-09-22 04:31:29 -0700 (In reply to comment #12) > I feel like you're not being receptive to my comments, which makes me less interested in reviewing these patches. I apologize, it wasn't at all my intention to be unreceptive to you comments. I just wanted to provide motivations to some of the design decisions we've made, as a complement to the code. I didn't feel I had all that I needed to iterate the patch, and wanted to get another round of feedback from you. > Other reviewers should feel free to take over reviewing this patch. I certainly hope that you can reconsider your decision to stop reviewing our patches since I value your feedback and respect you as a reviewer with good knowledge about details as well as the structure and organization of the project as a whole. > Unfortunately, MediaPlayer isn't the best model to work off of. Could you point me to some feature/files in WebKit that uses a platform abstraction model you think would be more suitable in our case? 471565 14 abarth 2011-09-22 08:11:40 -0700 I think there's some miscommunication here, so let me start from the beginning. My sense is that we've got two somewhat competing approaches to implementing this feature. On the one hand, there's this patch and, on the other hand, there's https://bugs.webkit.org/attachment.cgi?id=105149&action=review. Neither of these approaches seems like exactly what we want, but they both have good aspects to them that hopefully we can combine. To start with, I like your approach of having a Platform layer and a WebCore/platform/mediastream directory. The main question, as Alexey points out, is what API the Platform layer should expose to the rest of WebCore. Ideally, we'd expose a simple API that could be implemented by multiple low-level libraries (e.g., that handle ICE and the various other RTC-specific bits). Tommy's patch has a relatively simple API that I'd be interested in whether you think would work here. (In his patch, he's put the API at the Client layer, but putting it at the Platform layer seems more appropriate.) Specifically, consider the API implied by this object: http://trac.webkit.org/browser/trunk/Source/WebCore/page/MediaStreamClient.h One thing we should change is to replace the various IDs with actual objects, but aside from that, these seem like the basic operations (and an appropriate level of detail) for the Platform to expose. How would feel about moving MediaStreamClient from being a Client interface to being a Platform interface? 471724 15 adam.bergkvist 2011-09-22 11:12:29 -0700 (In reply to comment #14) > I think there's some miscommunication here, so let me start from the beginning. My sense is that we've got two somewhat competing approaches to implementing this feature. On the one hand, there's this patch and, on the other hand, there's https://bugs.webkit.org/attachment.cgi?id=105149&action=review. > > Neither of these approaches seems like exactly what we want, but they both have good aspects to them that hopefully we can combine. To start with, I like your approach of having a Platform layer and a WebCore/platform/mediastream directory. The main question, as Alexey points out, is what API the Platform layer should expose to the rest of WebCore. Ideally, we'd expose a simple API that could be implemented by multiple low-level libraries (e.g., that handle ICE and the various other RTC-specific bits). > I was recently contacted by Tommy who thinks our code looks OK, and we intend to collaborate around this. > Tommy's patch has a relatively simple API that I'd be interested in whether you think would work here. (In his patch, he's put the API at the Client layer, but putting it at the Platform layer seems more appropriate.) Specifically, consider the API implied by this object: > > http://trac.webkit.org/browser/trunk/Source/WebCore/page/MediaStreamClient.h > > One thing we should change is to replace the various IDs with actual objects, but aside from that, these seem like the basic operations (and an appropriate level of detail) for the Platform to expose. > > How would feel about moving MediaStreamClient from being a Client interface to being a Platform interface? I think MediaStreamClient is too high-level. E.g., the PeerConnection-related methods in MediaStreamClient maps almost directly to the PeerConnection JavaScript API. This makes PeerConnection a thin layer that just forwards calls to the platform. The PeerHandler API is the result of us following the steps in the specification as closely as possible and call the platform when necessary. 471741 16 abarth 2011-09-22 11:39:15 -0700 > > How would feel about moving MediaStreamClient from being a Client interface to being a Platform interface? > > I think MediaStreamClient is too high-level. E.g., the PeerConnection-related methods in MediaStreamClient maps almost directly to the PeerConnection JavaScript API. This makes PeerConnection a thin layer that just forwards calls to the platform. The PeerHandler API is the result of us following the steps in the specification as closely as possible and call the platform when necessary. This raises the question of how much of the implementation should live in WebCore versus how much of the implementation should live in an external library. My understanding in talking with Tommy is that he'd like to use a relatively high-level library to perform those operations because they don't require any specific coupling with WebCore. You seem interested in using a lower-level library and including more code in WebCore. Both of these approaches seem somewhat reasonable. It's often a tough call what to do with code that's not coupled with the rest of WebCore. We can either put it in Platform, where it can be easily reused by multiple ports or we can factor it out into a separate library, which keeps WebCore lean. My preference is for the later. I actually wish we did more features that way, e.g. as depicted in this diagram: https://docs.google.com/drawings/d/10WlCj2J3arxf4cDGRKteNinaP755iFnmYtYtnNSCQOY/edit?authkey=CP6plYAI&hl=en_US# I don't want to twist your arm, but it seems like we could set this up in the following layers: JavaScript Bindings PeerConnection DOM objects / events / etc MediaStreamClient-like API -> Option to implement the API with a high-level library -> Option to implement the API with PeerHandler and a lower-level library My my ideal world, we'd have the PeerHandler implementation in svn.webkit.org in a new top-level module (as a peer to JavaScriptCore and WebCore), but that's more of a dream for the future than something we need to do in this iteration. 471949 17 adam.bergkvist 2011-09-22 17:03:08 -0700 (In reply to comment #16) > This raises the question of how much of the implementation should live in WebCore versus how much of the implementation should live in an external library. My understanding in talking with Tommy is that he'd like to use a relatively high-level library to perform those operations because they don't require any specific coupling with WebCore. You seem interested in using a lower-level library and including more code in WebCore. Yes, there will be some more code in WebCore with PeerHandler compared to MediaStreamClient. But PeerHandler is still very high-level. The extra code in WebCore is basically the algorithms from the HTML specification (a couple of hundred lines) that defines the behaviour of PeerConnection as a JavaScript API. Isn't it preferable to keep that kind of code in WebCore for consistent behavior between ports and to avoid having to change every implementation of the platform interface when the PeerConnection APi is updated? Please have a look at how PeerConnection uses PeerHandler in https://bugs.webkit.org/attachment.cgi?id=108421&action=review , as compared to how it uses MediaStreamClient at the moment. 471967 18 abarth 2011-09-22 17:29:47 -0700 > Isn't it preferable to keep that kind of code in WebCore for consistent behavior between ports and to avoid having to change every implementation of the platform interface when the PeerConnection APi is updated? There's definitely a trade-off between putting things in WebCore versus in libraries. It's not always clear where to draw the line. For example, if HTTP were invented today, it's very likely Hixie would have written the XMLHttpRequest as imperatively manipulating HTTP protocol elements. We could, of course, suck the implementation of the whole HTTP protocol into WebCore, as we have done with WebSockets, but there's a trade-off. In many ways, we're still feeling our way though these kinds of decisions. We can certainly discuss this topic more on webkit-dev if you'd like to get input from the broader community (who might not all be CCed on this bug). My perspective is that we'll need to modularize WebCore more as time goes on, otherwise WebCore will grow to be unbounded in complexity and won't be lean. Core functionality, like layout and rendering should stay, of course, but over time we should move more into separate libraries with clear dependencies. Whether those libraries are in svn.webkit.org or elsewhere is a separate issue. > Please have a look at how PeerConnection uses PeerHandler in https://bugs.webkit.org/attachment.cgi?id=108421&action=review , as compared to how it uses MediaStreamClient at the moment. I really appreciate that you've posted the whole patch so we can use that as a reference for discussion. There are a lot of details in how PeerConnection uses PeerHandler that I think are less than ideal. For example, I'd rather WebCore be ignorant of concepts like STUN. I suspect if you asked the vast majority of WebKit developers what STUN was, they'd have no idea. That means code that talks about STUN is mysterious and won't be well maintained. I guess I don't understand what you find objectionable about the layering diagram in Comment #16. It gives folks the option of using a high-level library or a lower-level library. The issue of whether to spin the PeerHandler-based implementation out into a separate library is something we can worry about in the future. 472227 19 tommyw 2011-09-23 07:43:40 -0700 Since I have gotten some comments and questions regarding this patch (I submitted most of the initial code) I just wanted to clarify that I am supportive of this effort. "My" implementation had a less-than-ideal design we discovered recently and this approach is better. I think that it is a good idea to move the options parsing to an optional module in WebCore/platform as I understand Adam suggested, but not further away. 472254 20 adam.bergkvist 2011-09-23 08:25:21 -0700 (In reply to comment #18) > I really appreciate that you've posted the whole patch so we can use that as a reference for discussion. There are a lot of details in how PeerConnection uses PeerHandler that I think are less than ideal. For example, I'd rather WebCore be ignorant of concepts like STUN. I suspect if you asked the vast majority of WebKit developers what STUN was, they'd have no idea. That means code that talks about STUN is mysterious and won't be well maintained. Yes, it's easier to talk about PeerHandler together with PeerConnection rather than out of context (since PeerConnection isn't included in the patch for this bug). The word "STUN" is used in the configuration string argument to the PeerConnection constructor and therefore a part of the configuration object. For example var pc = new PeerConnection("STUN stun.example.org:3478", callback); We can remove the parsing and simply pass the configuration string to the platform. Would that be acceptable? The logic we want to add to PeerConnection is only related to the JavaScript API. For example pc.addStream(stream1); pc.addStream(stream2); in the same event-loop iteration should, according to the specification, be treated as if you're adding a list of streams at once. The streams should be handled together and only result in one signaling message. That's why PeerHandler has addPendingStreams() rather than a direct counterpart to PeerConnection's addStream(). > I guess I don't understand what you find objectionable about the layering diagram in Comment #16. It gives folks the option of using a high-level library or a lower-level library. The issue of whether to spin the PeerHandler-based implementation out into a separate library is something we can worry about in the future. The layering diagram looks fine to me. I see the logic that we're adding to PeerConnection as part of the "Bindings" box and PeerHandler is the API towards the "P2P" box. The "P2P" box can then be implemented with either a high-level or a lower-level library. 474768 21 adam.bergkvist 2011-09-28 09:30:09 -0700 (In reply to comment #18) > There are a lot of details in how PeerConnection uses PeerHandler that I think are less than ideal. Other than the parsing of the configuration string, what more do you want me to change before I iterate the patch? 474799 22 abarth 2011-09-28 10:01:35 -0700 Are you planning to revise your patch along the lines described in Comment #16? In particular, it seems important to understand the interface between the DOM-layer code and the Platform-layer code. 475417 23 adam.bergkvist 2011-09-29 07:21:56 -0700 (In reply to comment #22) > Are you planning to revise your patch along the lines described in Comment #16? In particular, it seems important to understand the interface between the DOM-layer code and the Platform-layer code. To do that, I think it's important to define the border between the DOM-layer code and the Platform-layer code. The PeerConnection spec has a natural separation between the concerns of the API and the needs of the platform in the form of an "ICE Agent" (which hides ICE processing, RTP and other low-level stuff from PeerConnection). Could you please give your view on this? We think that this separation makes sense. The function names in PeerHandler, which are of course up for discussion, are derived from the spec text. Please have a look below at the current PeerHandler API, annotated with relevant sentences from the PeerConnection spec. We're confident that this API can be implemented with a high-level library like the one that Tommy is using. // ========== Calls from the DOM-layer to the Platform-layer ========== // "If connection's ICE started flag is still false, start the PeerConnection ICE Agent and send the initial offer." // "The initial offer must include a media description for [...] all the streams in localStreams" void produceInitialOffer(const MediaStreamDescriptorVector& pendingAddStreams); // "Start the PeerConnection ICE Agent and pass it sdp as the initial offer from the other peer;" // "the ICE Agent will then (asynchronously) construct the initial answer and transmit it as described above." void handleInitialOffer(const String& sdp); // "If connection's ICE started flag is true, then pass sdp to the PeerConnection ICE Agent as a subsequent offer // or answer, to be interpreted as appropriate given the current state of the ICE Agent" void processSDP(const String& sdp); // "Have the PeerConnection's PeerConnection ICE Agent add [or remove] a media stream for stream the next time the user // agent provides a stable state. Any other pending stream additions and removals must be processed at the same time." void processPendingStreams(const MediaStreamDescriptorVector& pendingAddStreams, const MediaStreamDescriptorVector& pendingRemoveStreams); // "Let data be message encoded as UTF-8." // "Transmit a data packet to a peer using the PeerConnection's PeerConnection data UDP media stream with data as the message." void sendDataStreamMessage(const char* data, unsigned length); // "Destroy the PeerConnection ICE Agent, abruptly ending any active ICE processing and any active streaming, // and releasing any relevant resources (e.g. TURN permissions)." void stop(); // ========== Calls from the Platform-layer to the DOM-layer ========== // "When a PeerConnection ICE Agent completes ICE processing (even if there are no active streams), the user // agent must queue a task that sets the PeerConnection object's [...]" void iceProcessingCompleted(); // "When a PeerConnection ICE Agent is required to send SDP offers or answers, the user agent must follow these steps:" // "Let sdp be the SDP offer or answer to be sent." void sdpGenerated(const String& sdp); // "When a packet that is part of a data UDP media stream is received, the user agent must run the following steps:" void dataStreamMessageReceived(const char* data, unsigned length); // "When a user agent starts receiving media for a component and a candidate was provided for that component // by a PeerConnection ICE Agent, the user agent must follow these steps:" void remoteStreamAdded(PassRefPtr<MediaStreamDescriptor>); // "When a PeerConnection ICE Agent finds that a stream from the remote peer has been removed (its port has been // set to zero in a media description sent on the signaling channel), the user agent must follow these steps:" void remoteStreamRemoved(MediaStreamDescriptor*); 477006 24 abarth 2011-10-03 08:57:32 -0700 Sorry for the delay in replying Adam. I've talked the issue over with Tommy, and he agrees that the API you propose in Comment #23 should work for Chromium as well. My sense we'll want to be able to choose different implementations of that API at compile time. For example, we'll likely have an implementation using Tommy's high-level library and an (larger) implementation using Gstreamer. Maybe a good first step is to check in the header files for the Platform API? Then we can proceed to add the callers and the implementations of the API in parallel. 477169 25 adam.bergkvist 2011-10-03 12:59:52 -0700 (In reply to comment #24) > Sorry for the delay in replying Adam. I've talked the issue over with Tommy, and he agrees that the API you propose in Comment #23 should work for Chromium as well. > > My sense we'll want to be able to choose different implementations of that API at compile time. For example, we'll likely have an implementation using Tommy's high-level library and an (larger) implementation using Gstreamer. > Our idea has been to have separate implementations of the PeerHandlerPrivate interface and select one at compile time as you describe. #if PLATFORM(CHROMIUM) #include "PeerHandlerPrivateChromium.h" #define PeerHandlerPrivateClassName PeerHandlerPrivateChromium #elif USE(GSTREAMER) ... The code above would be at line 40 in PeerHandler.cpp, but is omitted in this patch since there are no implementations available yet. > Maybe a good first step is to check in the header files for the Platform API? Then we can proceed to add the callers and the implementations of the API in parallel. Yes, that seems like a good starting point. I've created bugs 68462 and 68464 to add the caller code in PeerConnection and MediaStream respectivly. 477175 26 abarth 2011-10-03 13:07:43 -0700 > Our idea has been to have separate implementations of the PeerHandlerPrivate interface and select one at compile time as you describe. > > #if PLATFORM(CHROMIUM) > #include "PeerHandlerPrivateChromium.h" > #define PeerHandlerPrivateClassName PeerHandlerPrivateChromium > #elif USE(GSTREAMER) > ... That's not the usual way we do that sort of thing in WebKit. It's probably better follow the model used, for example, by ResourceHandle. In that approach, there is a shared h file and separate cpp files that different ports can link in. 478299 27 109780 adam.bergkvist 2011-10-05 06:28:28 -0700 Created attachment 109780 Updated patch Updated patch based on review feedback 478418 28 109780 abarth 2011-10-05 09:22:21 -0700 Comment on attachment 109780 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=109780&action=review Thanks for updating the patch. I feel like we're making progress here. My two main concerns with this patch are MediaStreamCenter, which I don't really understand, and the fact that your objects have a bunch of public member variables. One way to proceed is to not add MediaStreamCenter yet and add it when needed by later patches. That will help me understand it's role. As for the structs with public data members, can we start out with these private and make them public as needed in future patches? That will help us see whether they actually need to be public or whether we've be better served by having them private and exposing methods that manipulate them. > Source/WebCore/platform/mediastream/MediaStreamCenter.cpp:57 > +void MediaStreamCenter::streamEnded(MediaStreamDescriptor* streamDescriptor) > +{ > + MediaStream* stream = streamDescriptor->owner; > + if (stream) > + stream->streamEnded(); > + else > + streamDescriptor->ended = true; > +} This looks like it should be a method on MediaStreamDescriptor. > Source/WebCore/platform/mediastream/MediaStreamCenter.h:44 > +MediaStreamCenter& mediaStreamCenter(); I'm not sure I understand the role of this static. It's very unusual to have statics in WebKit because separate PageGroups should be almost entirely separate. That said, we do have some statics, so it's not a hand-and-fast rule. > Source/WebCore/platform/mediastream/MediaStreamCenter.h:53 > + void mediaStreamTrackEnabledSet(const MediaStreamDescriptor*, unsigned componentIndex); I'm not sure what this function does. It's a noun phrase, so I'd expect it to return a value, but it is a void function, so maybe it's an action? > Source/WebCore/platform/mediastream/MediaStreamCenter.h:54 > + void stopLocalMediaStream(const MediaStreamDescriptor*); Why isn't this a method on MediaStream ? > Source/WebCore/platform/mediastream/MediaStreamCenter.h:56 > + void streamEnded(MediaStreamDescriptor*); This sounds like a notification that the stream ended. Does that notification flow up from the network or down from the API? I think my main confusion is that I don't understand what this object is all about. MediaStreamCenter isn't really a name that means anything. I wonder if we can remove this object entirely. > Source/WebCore/platform/mediastream/MediaStreamComponent.h:54 > + { } Nit: These should be on separate lines. > Source/WebCore/platform/mediastream/MediaStreamDescriptor.h:63 > + { } Nit: These should be on separate lines. > Source/WebCore/platform/mediastream/MediaStreamSource.h:65 > + { } Nit: These should be on separate lines. > Source/WebCore/platform/mediastream/PeerHandler.cpp:41 > +// FIXME: remove when real implementations are available > +// Empty implementations for ports that build with MEDIA_STREAM enabled by default. > +#if PLATFORM(CHROMIUM) || PLATFORM(GTK) I would just remove this ifdef. We'd not going to need it. > Source/WebCore/platform/mediastream/PeerHandler.h:54 > +class PeerHandler { We'll probably need to split this into PeerHandlerBase and PeerHandler, like we do for ResourceHandle, but we can do that in the future when needed. 480085 29 110163 adam.bergkvist 2011-10-07 09:56:13 -0700 Created attachment 110163 Patch 3 (In reply to comment #28) > (From update of attachment 109780 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=109780&action=review > > Thanks for updating the patch. I feel like we're making progress here. My two main concerns with this patch are MediaStreamCenter, which I don't really understand, and the fact that your objects have a bunch of public member variables. Thank you for a quick review. > One way to proceed is to not add MediaStreamCenter yet and add it when needed by later patches. That will help me understand it's role. Let's do that. I've updated the name of this bug and I'll create a new one for the MediaStream platform stuff. I'll address the review comments about MediaStreamCenter in the new bug. > As for the structs with public data members, can we start out with these private and make them public as needed in future patches? That will help us see whether they actually need to be public or whether we've be better served by having them private and exposing methods that manipulate them. You're right, there are a few mebers that can be read-only. I've changed the structs to classes (with private data members) and added the necessary getters and setters. > > Source/WebCore/platform/mediastream/MediaStreamComponent.h:54 > > + { } > > Nit: These should be on separate lines. Fixed. > > Source/WebCore/platform/mediastream/MediaStreamDescriptor.h:63 > > + { } Fixed. > Nit: These should be on separate lines. > > > Source/WebCore/platform/mediastream/MediaStreamSource.h:65 > > + { } > > Nit: These should be on separate lines. Fixed. > > Source/WebCore/platform/mediastream/PeerHandler.cpp:41 > > +// FIXME: remove when real implementations are available > > +// Empty implementations for ports that build with MEDIA_STREAM enabled by default. > > +#if PLATFORM(CHROMIUM) || PLATFORM(GTK) > > I would just remove this ifdef. We'd not going to need it. That works. When a port has its own implementations it can opt out from using these empty ones. 480096 30 110163 abarth 2011-10-07 10:09:57 -0700 Comment on attachment 110163 Patch 3 This looks great. Thanks for iterating on the patch and discussing variations on your original design. 480142 31 110163 webkit.review.bot 2011-10-07 11:05:47 -0700 Comment on attachment 110163 Patch 3 Clearing flags on attachment: 110163 Committed r96959: <http://trac.webkit.org/changeset/96959> 480143 32 webkit.review.bot 2011-10-07 11:05:54 -0700 All reviewed patches have been landed. Closing bug. 480921 33 adam.bergkvist 2011-10-10 05:38:40 -0700 (In reply to comment #30) > (From update of attachment 110163 [details]) > This looks great. Thanks for iterating on the patch and discussing variations on your original design. Thank you for reviewing this. I've updated the patch in http://webkit.org/b/68462 to make PeerConnection use the platform interface. It would be great if you could take a look at it. 108042 2011-09-20 13:07:53 -0700 2011-10-03 13:00:38 -0700 Proposed patch mediastream_platform_files_1.patch text/plain 33775 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2Y2NhMzEwLi41MTJhOTEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzAg QEAKKzIwMTEtMDktMjAgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIEFkZCBXZWJDb3JlIHBsYXRmb3JtIGludGVyZmFjZXMgbmVlZGVkIGJ5 IHVwZGF0ZWQgTWVkaWFTdHJlYW0gYW5kIFBlZXJDb25uZWN0aW9uIGRlc2lnbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Njg0NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0aGUgTWVkaWFTdHJl YW0gYW5kIFBlZXJDb25uZWN0aW9uIHBsYXRmb3JtIGZpbGVzIHRvIFdlYkNvcmUvcGxhdGZvcm0v bWVkaWFzdHJlYW0uCisKKyAgICAgICAgQ3VycmVudGx5IG5vdCB0ZXN0YWJsZS4KKworICAgICAg ICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAg ICAgICogV2ViQ29yZS5neXAvV2ViQ29yZS5neXA6CisgICAgICAgICogV2ViQ29yZS5neXBpOgor ICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29tcG9uZW50Lmg6IEFk ZGVkLgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1Db21wb25lbnQ6OmNyZWF0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbUNvbXBvbmVudDo6TWVkaWFTdHJlYW1Db21wb25l bnQpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRGVzY3JpcHRv ci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtRGVzY3JpcHRvcjo6Y3Jl YXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtRGVzY3JpcHRvcjo6TWVkaWFTdHJl YW1EZXNjcmlwdG9yKToKKyAgICAgICAgKiBwbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVh bU1hbmFnZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Om1lZGlhU3RyZWFtTWFuYWdl cik6CisgICAgICAgIChXZWJDb3JlOjpOdWxsTWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZTo6Y3Jl YXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok51bGxNZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlOjpz ZXRNZWRpYVN0cmVhbUNvbXBvbmVudEVuYWJsZWQpOgorICAgICAgICAoV2ViQ29yZTo6TnVsbE1l ZGlhU3RyZWFtTWFuYWdlclByaXZhdGU6OnN0b3BMb2NhbE1lZGlhU3RyZWFtKToKKyAgICAgICAg KFdlYkNvcmU6Ok51bGxNZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlOjpOdWxsTWVkaWFTdHJlYW1N YW5hZ2VyUHJpdmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbU1hbmFnZXI6Ok1l ZGlhU3RyZWFtTWFuYWdlcik6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbU1hbmFnZXI6 OnNldE1lZGlhU3RyZWFtQ29tcG9uZW50RW5hYmxlZCk6CisgICAgICAgIChXZWJDb3JlOjpNZWRp YVN0cmVhbU1hbmFnZXI6OnN0b3BMb2NhbE1lZGlhU3RyZWFtKToKKyAgICAgICAgKFdlYkNvcmU6 Ok1lZGlhU3RyZWFtTWFuYWdlcjo6c3RyZWFtRW5kZWQpOgorICAgICAgICAqIHBsYXRmb3JtL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtTWFuYWdlci5oOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9y bS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlLmg6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZUludGVyZmFjZTo6fk1lZGlhU3Ry ZWFtTWFuYWdlclByaXZhdGVJbnRlcmZhY2UpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3Ry ZWFtL1BlZXJIYW5kbGVyLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpOdWxsUGVlckhh bmRsZXJQcml2YXRlOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6TnVsbFBlZXJIYW5kbGVy UHJpdmF0ZTo6cHJvZHVjZUluaXRpYWxPZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpOdWxsUGVl ckhhbmRsZXJQcml2YXRlOjpoYW5kbGVJbml0aWFsT2ZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6 TnVsbFBlZXJIYW5kbGVyUHJpdmF0ZTo6cHJvY2Vzc1NEUCk6CisgICAgICAgIChXZWJDb3JlOjpO dWxsUGVlckhhbmRsZXJQcml2YXRlOjphZGRQZW5kaW5nU3RyZWFtcyk6CisgICAgICAgIChXZWJD b3JlOjpOdWxsUGVlckhhbmRsZXJQcml2YXRlOjpyZW1vdmVQZW5kaW5nU3RyZWFtcyk6CisgICAg ICAgIChXZWJDb3JlOjpOdWxsUGVlckhhbmRsZXJQcml2YXRlOjpzZW5kRGF0YVN0cmVhbU1lc3Nh Z2UpOgorICAgICAgICAoV2ViQ29yZTo6TnVsbFBlZXJIYW5kbGVyUHJpdmF0ZTo6c3RvcCk6Cisg ICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6UGVlckhhbmRsZXIpOgorICAgICAgICAoV2Vi Q29yZTo6UGVlckhhbmRsZXI6On5QZWVySGFuZGxlcik6CisgICAgICAgIChXZWJDb3JlOjpQZWVy SGFuZGxlcjo6cHJvZHVjZUluaXRpYWxPZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFu ZGxlcjo6aGFuZGxlSW5pdGlhbE9mZmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVy Ojpwcm9jZXNzU0RQKToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVyOjphZGRQZW5kaW5n U3RyZWFtcyk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6cmVtb3ZlUGVuZGluZ1N0 cmVhbXMpOgorICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6OnNlbmREYXRhU3RyZWFtTWVz c2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6c3RvcCk6CisgICAgICAgIChX ZWJDb3JlOjpQZWVySGFuZGxlcjo6aWNlUHJvY2Vzc2luZ0NvbXBsZXRlZCk6CisgICAgICAgIChX ZWJDb3JlOjpQZWVySGFuZGxlcjo6c2RwR2VuZXJhdGVkKToKKyAgICAgICAgKFdlYkNvcmU6OlBl ZXJIYW5kbGVyOjpkYXRhU3RyZWFtTWVzc2FnZVJlY2VpdmVkKToKKyAgICAgICAgKFdlYkNvcmU6 OlBlZXJIYW5kbGVyOjpyZW1vdGVTdHJlYW1BZGRlZCk6CisgICAgICAgIChXZWJDb3JlOjpQZWVy SGFuZGxlcjo6cmVtb3RlU3RyZWFtUmVtb3ZlZCk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFu ZGxlcjo6Y29uZmlndXJhdGlvbik6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVl ckhhbmRsZXIuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlckNvbmZpZ3Vy YXRpb246OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlckNvbmZpZ3VyYXRp b246OlBlZXJIYW5kbGVyQ29uZmlndXJhdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFu ZGxlckNsaWVudDo6flBlZXJIYW5kbGVyQ2xpZW50KToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJI YW5kbGVyOjpjcmVhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5k bGVyUHJpdmF0ZS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVyUHJpdmF0 ZUludGVyZmFjZTo6UGVlckhhbmRsZXJQcml2YXRlSW50ZXJmYWNlKToKKyAgICAgICAgKFdlYkNv cmU6OlBlZXJIYW5kbGVyUHJpdmF0ZUludGVyZmFjZTo6flBlZXJIYW5kbGVyUHJpdmF0ZUludGVy ZmFjZSk6CisKIDIwMTEtMDktMTkgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNvbT4KIAog ICAgICAgICBSZWZhY3RvciBIZWFwIGFsbG9jYXRpb24gbG9naWMgaW50byBzZXBhcmF0ZSBBbGxv Y2F0aW9uU3BhY2UgY2xhc3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxl LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggZjcyY2Y2ZS4uNjc0YzVi MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTYwLDYgKzYwLDcgQEAgd2ViY29yZV9jcHBmbGFn cyArPSBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2Rl cnMvd2VicCBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVj b2RlcnMvcG5nIFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9sZXZlbGRi IFwKKwktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbSBcCiAJ LUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jayBcCiAJLUkkKHNyY2Rpcikv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yayBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vc3FsIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2Vm aWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IDk1 NjAzN2MuLmUxMjk4NWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxp c3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMjY3OCw2 ICsyNjc4LDE0IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vaW1hZ2UtZGVjb2RlcnMvd2VicC9XRUJQSW1hZ2VEZWNvZGVyLmggXAogCVNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL3BuZy9QTkdJbWFnZURlY29kZXIuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9wbmcvUE5HSW1hZ2VEZWNvZGVy LmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29t cG9uZW50LmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3Ry ZWFtRGVzY3JpcHRvci5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9N ZWRpYVN0cmVhbU1hbmFnZXIuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXIuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVk aWFzdHJlYW0vTWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZS5oIFwKKwlTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyUHJpdmF0ZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tb2NrL0RldmljZU9yaWVudGF0aW9uQ2xpZW50TW9jay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL21vY2svRGV2aWNlT3JpZW50YXRpb25DbGllbnRNb2NrLmggXAogCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL21vY2svR2VvbG9jYXRpb25DbGllbnRNb2NrLmNwcCBcCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cC9XZWJDb3JlLmd5cCBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUuZ3lwL1dlYkNvcmUuZ3lwCmluZGV4IDI4YzQ3YWMuLmU3YjliNDMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwL1dlYkNvcmUuZ3lwCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwL1dlYkNvcmUuZ3lwCkBAIC0xOTMsNiArMTkzLDcg QEAKICAgICAgICcuLi9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy93ZWJwJywKICAgICAgICcuLi9w bGF0Zm9ybS9pbWFnZS1lbmNvZGVycy9za2lhJywKICAgICAgICcuLi9wbGF0Zm9ybS9sZXZlbGRi JywKKyAgICAgICcuLi9wbGF0Zm9ybS9tZWRpYXN0cmVhbScsCiAgICAgICAnLi4vcGxhdGZvcm0v bW9jaycsCiAgICAgICAnLi4vcGxhdGZvcm0vbmV0d29yaycsCiAgICAgICAnLi4vcGxhdGZvcm0v bmV0d29yay9jaHJvbWl1bScsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5 cGkgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggOTIyOGQwNS4uOGRiMzNlMiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaQpAQCAtODA5LDYgKzgwOSwxNCBAQAogICAgICAgICAgICAgJ3BsYXRm b3JtL21hYy9XZWJDb3JlU3lzdGVtSW50ZXJmYWNlLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3Jt L21hYy9XZWJDb3JlVmlldy5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9tYWMvV2ViRm9udENh Y2hlLmgnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29t cG9uZW50LmgnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFt RGVzY3JpcHRvci5oJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0 cmVhbU1hbmFnZXIuY3BwJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbU1hbmFnZXIuaCcsCisgICAgICAgICAgICAncGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZS5oJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9tZWRpYXN0 cmVhbS9QZWVySGFuZGxlci5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlhc3RyZWFt L1BlZXJIYW5kbGVyLmgnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJI YW5kbGVyUHJpdmF0ZS5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9tb2NrL0RldmljZU9yaWVu dGF0aW9uQ2xpZW50TW9jay5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9tb2NrL0dlb2xvY2F0 aW9uQ2xpZW50TW9jay5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9uZXR3b3JrL0F1dGhlbnRp Y2F0aW9uQ2hhbGxlbmdlQmFzZS5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29tcG9uZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbXBvbmVudC5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIyNzQyMmEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbXBvbmVudC5oCkBAIC0w LDAgKzEsNzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5h bWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBt YXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRo aXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNz aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBI T0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBNZWRpYVN0cmVhbUNvbXBvbmVudF9oCisjZGVmaW5l IE1lZGlhU3RyZWFtQ29tcG9uZW50X2gKKworI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNp bmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+Cisj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0cnVjdCBN ZWRpYVN0cmVhbUNvbXBvbmVudCA6IHB1YmxpYyBSZWZDb3VudGVkPE1lZGlhU3RyZWFtQ29tcG9u ZW50PiB7CitwdWJsaWM6CisgICAgZW51bSBUeXBlIHsKKyAgICAgICAgVHlwZUF1ZGlvID0gMSA8 PCAwLAorICAgICAgICBUeXBlVmlkZW8gPSAxIDw8IDEKKyAgICB9OworCisgICAgc3RhdGljIFBh c3NSZWZQdHI8TWVkaWFTdHJlYW1Db21wb25lbnQ+IGNyZWF0ZShjb25zdCBTdHJpbmcmIGlkLCBU eXBlIHR5cGUsIGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBlbmFibGVkID0gdHJ1ZSkKKyAgICB7 CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgTWVkaWFTdHJlYW1Db21wb25lbnQoaWQsIHR5 cGUsIG5hbWUsIGVuYWJsZWQpKTsKKyAgICB9CisKKyAgICBTdHJpbmcgaWQ7CisgICAgVHlwZSB0 eXBlOworICAgIFN0cmluZyBuYW1lOworICAgIGJvb2wgZW5hYmxlZDsKKworcHJpdmF0ZToKKyAg ICBNZWRpYVN0cmVhbUNvbXBvbmVudChjb25zdCBTdHJpbmcmIGlkQXJnLCBUeXBlIHR5cGVBcmcs IGNvbnN0IFN0cmluZyYgbmFtZUFyZywgYm9vbCBlbmFibGVkQXJnKQorICAgICAgICA6IGlkKGlk QXJnKQorICAgICAgICAsIHR5cGUodHlwZUFyZykKKyAgICAgICAgLCBuYW1lKG5hbWVBcmcpCisg ICAgICAgICwgZW5hYmxlZChlbmFibGVkQXJnKQorICAgIHsgfQorfTsKKwordHlwZWRlZiBWZWN0 b3I8UmVmUHRyPE1lZGlhU3RyZWFtQ29tcG9uZW50PiA+IE1lZGlhU3RyZWFtQ29tcG9uZW50VmVj dG9yOworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFf U1RSRUFNKQorCisjZW5kaWYgLy8gTWVkaWFTdHJlYW1Db21wb25lbnRfaApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1EZXNjcmlwdG9y LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbURlc2Ny aXB0b3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40YmZiMjkxCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1EZXNjcmlwdG9yLmgKQEAgLTAsMCArMSw3MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9u LgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0 cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIE1lZGlhU3Ry ZWFtRGVzY3JpcHRvcl9oCisjZGVmaW5lIE1lZGlhU3RyZWFtRGVzY3JpcHRvcl9oCisKKyNpZiBF TkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1Db21wb25lbnQuaCIK KyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+ CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNz IE1lZGlhU3RyZWFtOworCitzdHJ1Y3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yIDogcHVibGljIFJl ZkNvdW50ZWQ8TWVkaWFTdHJlYW1EZXNjcmlwdG9yPiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NSZWZQdHI8TWVkaWFTdHJlYW1EZXNjcmlwdG9yPiBjcmVhdGUoY29uc3QgU3RyaW5nJiBsYWJl bCwgY29uc3QgTWVkaWFTdHJlYW1Db21wb25lbnRWZWN0b3ImIGNvbXBvbmVudHMpCisgICAgewor ICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IE1lZGlhU3RyZWFtRGVzY3JpcHRvcihsYWJlbCwg Y29tcG9uZW50cykpOworICAgIH0KKworICAgIE1lZGlhU3RyZWFtKiBvd25lcjsKKyAgICBTdHJp bmcgbGFiZWw7CisgICAgTWVkaWFTdHJlYW1Db21wb25lbnRWZWN0b3IgY29tcG9uZW50czsKKyAg ICBib29sIGVuZGVkOworCitwcml2YXRlOgorICAgIE1lZGlhU3RyZWFtRGVzY3JpcHRvcihjb25z dCBTdHJpbmcmIGxhYmVsQXJnLCBjb25zdCBNZWRpYVN0cmVhbUNvbXBvbmVudFZlY3RvciYgY29t cG9uZW50c0FyZykKKyAgICAgICAgOiBvd25lcigwKQorICAgICAgICAsIGxhYmVsKGxhYmVsQXJn KQorICAgICAgICAsIGNvbXBvbmVudHMoY29tcG9uZW50c0FyZykKKyAgICAgICAgLCBlbmRlZChm YWxzZSkKKyAgICB7IH0KK307CisKK3R5cGVkZWYgVmVjdG9yPFJlZlB0cjxNZWRpYVN0cmVhbURl c2NyaXB0b3I+ID4gTWVkaWFTdHJlYW1EZXNjcmlwdG9yVmVjdG9yOworCit9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8g TWVkaWFTdHJlYW1EZXNjcmlwdG9yX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtTWFuYWdlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXIuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjViNTBjNDYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXIuY3BwCkBAIC0w LDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5h bWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBt YXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRo aXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNz aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBI T0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKE1FRElB X1NUUkVBTSkKKworI2luY2x1ZGUgIk1lZGlhU3RyZWFtTWFuYWdlci5oIgorCisjaW5jbHVkZSAi TWFpblRocmVhZC5oIgorI2luY2x1ZGUgIk1lZGlhU3RyZWFtLmgiCisjaW5jbHVkZSAiTWVkaWFT dHJlYW1EZXNjcmlwdG9yLmgiCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZS5o IgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKKyNkZWZpbmUgTWVkaWFTdHJlYW1NYW5h Z2VyUHJpdmF0ZUNsYXNzTmFtZSBOdWxsTWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZQorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK01lZGlhU3RyZWFtTWFuYWdlciYgbWVkaWFTdHJlYW1NYW5hZ2Vy KCkKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIERFRklORV9TVEFUSUNfTE9D QUwoTWVkaWFTdHJlYW1NYW5hZ2VyLCBpbnN0YW5jZSwgKCkpOworICAgIHJldHVybiBpbnN0YW5j ZTsKK30KKworY2xhc3MgTnVsbE1lZGlhU3RyZWFtTWFuYWdlclByaXZhdGUgOiBwdWJsaWMgTWVk aWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZUludGVyZmFjZSB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NPd25QdHI8TWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZUludGVyZmFjZT4gY3JlYXRlKE1lZGlh U3RyZWFtTWFuYWdlciopCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IE51bGxN ZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlKCkpOworICAgIH0KKworICAgIHZvaWQgc2V0TWVkaWFT dHJlYW1Db21wb25lbnRFbmFibGVkKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvciosIHVuc2ln bmVkIGNvbXBvbmVudEluZGV4LCBib29sIGVuYWJsZWQpIHsgfQorICAgIHZvaWQgc3RvcExvY2Fs TWVkaWFTdHJlYW0oY29uc3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yKikgeyB9CisKK3ByaXZhdGU6 CisgICAgTnVsbE1lZGlhU3RyZWFtTWFuYWdlclByaXZhdGUoKSB7IH0KK307CisKK01lZGlhU3Ry ZWFtTWFuYWdlcjo6TWVkaWFTdHJlYW1NYW5hZ2VyKCkKKyAgICA6IG1fcHJpdmF0ZShNZWRpYVN0 cmVhbU1hbmFnZXJQcml2YXRlQ2xhc3NOYW1lOjpjcmVhdGUodGhpcykpCit7Cit9CisKK3ZvaWQg TWVkaWFTdHJlYW1NYW5hZ2VyOjpzZXRNZWRpYVN0cmVhbUNvbXBvbmVudEVuYWJsZWQoY29uc3Qg TWVkaWFTdHJlYW1EZXNjcmlwdG9yKiBzdHJlYW1EZXNjcmlwdG9yLCB1bnNpZ25lZCBjb21wb25l bnRJbmRleCwgYm9vbCBlbmFibGVkKQoreworICAgIHN0cmVhbURlc2NyaXB0b3ItPmNvbXBvbmVu dHNbY29tcG9uZW50SW5kZXhdLT5lbmFibGVkID0gZW5hYmxlZDsKKworICAgIG1fcHJpdmF0ZS0+ c2V0TWVkaWFTdHJlYW1Db21wb25lbnRFbmFibGVkKHN0cmVhbURlc2NyaXB0b3IsIGNvbXBvbmVu dEluZGV4LCBlbmFibGVkKTsKK30KKwordm9pZCBNZWRpYVN0cmVhbU1hbmFnZXI6OnN0b3BMb2Nh bE1lZGlhU3RyZWFtKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvciogc3RyZWFtRGVzY3JpcHRv cikKK3sKKyAgICBtX3ByaXZhdGUtPnN0b3BMb2NhbE1lZGlhU3RyZWFtKHN0cmVhbURlc2NyaXB0 b3IpOworfQorCit2b2lkIE1lZGlhU3RyZWFtTWFuYWdlcjo6c3RyZWFtRW5kZWQoTWVkaWFTdHJl YW1EZXNjcmlwdG9yKiBzdHJlYW1EZXNjcmlwdG9yKQoreworICAgIE1lZGlhU3RyZWFtKiBzdHJl YW0gPSBzdHJlYW1EZXNjcmlwdG9yLT5vd25lcjsKKyAgICBpZiAoc3RyZWFtKQorICAgICAgICBz dHJlYW0tPnN0cmVhbUVuZGVkKCk7CisgICAgZWxzZQorICAgICAgICBzdHJlYW1EZXNjcmlwdG9y LT5lbmRlZCA9IHRydWU7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtTWFuYWdlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjA3M2YwYjIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXIuaApAQCAtMCwwICsxLDY2 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAg ICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVy aWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAg ICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgTWVkaWFTdHJlYW1NYW5hZ2VyX2gKKyNkZWZpbmUgTWVkaWFTdHJl YW1NYW5hZ2VyX2gKKworI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJNZWRp YVN0cmVhbUNvbXBvbmVudC5oIgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitjbGFzcyBNZWRpYVN0cmVhbURlc2NyaXB0b3I7CitjbGFzcyBNZWRpYVN0 cmVhbU1hbmFnZXI7CitjbGFzcyBNZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlSW50ZXJmYWNlOwor CitNZWRpYVN0cmVhbU1hbmFnZXImIG1lZGlhU3RyZWFtTWFuYWdlcigpOworCitjbGFzcyBNZWRp YVN0cmVhbU1hbmFnZXIgeworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lZGlhU3RyZWFtTWFu YWdlcik7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CitwdWJsaWM6CisgICAgTWVkaWFT dHJlYW1NYW5hZ2VyKCk7CisKKyAgICB2b2lkIHNldE1lZGlhU3RyZWFtQ29tcG9uZW50RW5hYmxl ZChjb25zdCBNZWRpYVN0cmVhbURlc2NyaXB0b3IqLCB1bnNpZ25lZCBjb21wb25lbnRJbmRleCwg Ym9vbCBlbmFibGVkKTsKKyAgICB2b2lkIHN0b3BMb2NhbE1lZGlhU3RyZWFtKGNvbnN0IE1lZGlh U3RyZWFtRGVzY3JpcHRvciopOworCisgICAgdm9pZCBzdHJlYW1FbmRlZChNZWRpYVN0cmVhbURl c2NyaXB0b3IqKTsKKworcHJpdmF0ZToKKyAgICBPd25QdHI8TWVkaWFTdHJlYW1NYW5hZ2VyUHJp dmF0ZUludGVyZmFjZT4gbV9wcml2YXRlOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIE1lZGlhU3RyZWFt TWFuYWdlcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVh bS9NZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9t ZWRpYXN0cmVhbS9NZWRpYVN0cmVhbU1hbmFnZXJQcml2YXRlLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uY2MwNGVlOQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtTWFuYWdlclByaXZhdGUuaApAQCAt MCwwICsxLDU0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyCisgKiAgICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBu YW1lIG9mIEVyaWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAg bWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0 aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQg SE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisg KiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg VEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgTWVkaWFTdHJlYW1NYW5hZ2VyUHJpdmF0ZV9oCisj ZGVmaW5lIE1lZGlhU3RyZWFtTWFuYWdlclByaXZhdGVfaAorCisjaWYgRU5BQkxFKE1FRElBX1NU UkVBTSkKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworY2xhc3MgTWVkaWFTdHJlYW1EZXNjcmlwdG9yOworCitjbGFzcyBNZWRpYVN0cmVhbU1h bmFnZXJQcml2YXRlSW50ZXJmYWNlIHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIH5NZWRpYVN0cmVh bU1hbmFnZXJQcml2YXRlSW50ZXJmYWNlKCkgeyB9CisKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVk aWFTdHJlYW1Db21wb25lbnRFbmFibGVkKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvciosIHVu c2lnbmVkIGNvbXBvbmVudEluZGV4LCBib29sIGVuYWJsZWQpID0gMDsKKyAgICB2aXJ0dWFsIHZv aWQgc3RvcExvY2FsTWVkaWFTdHJlYW0oY29uc3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yKikgPSAw OworfTsKKworfQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8v IE1lZGlhU3RyZWFtTWFuYWdlclByaXZhdGVfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjA1NDVjNGMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5jcHAKQEAgLTAsMCArMSwxMzggQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4g UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRo ZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUK KyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24g bm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBl bmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05U UklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisg KiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2lu Y2x1ZGUgIlBlZXJIYW5kbGVyLmgiCisKKyNpbmNsdWRlICJQZWVySGFuZGxlclByaXZhdGUuaCIK KworI2RlZmluZSBQZWVySGFuZGxlclByaXZhdGVDbGFzc05hbWUgTnVsbFBlZXJIYW5kbGVyUHJp dmF0ZQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIE51bGxQZWVySGFuZGxlclByaXZh dGUgOiBwdWJsaWMgUGVlckhhbmRsZXJQcml2YXRlSW50ZXJmYWNlIHsKK3B1YmxpYzoKKyAgICBz dGF0aWMgUGFzc093blB0cjxQZWVySGFuZGxlclByaXZhdGVJbnRlcmZhY2U+IGNyZWF0ZShQZWVy SGFuZGxlciopCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IE51bGxQZWVySGFu ZGxlclByaXZhdGUoKSk7CisgICAgfQorCisgICAgdm9pZCBwcm9kdWNlSW5pdGlhbE9mZmVyKGNv bnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvciYpIHsgfQorICAgIHZvaWQgaGFuZGxlSW5p dGlhbE9mZmVyKGNvbnN0IFN0cmluZyYpIHsgfQorICAgIHZvaWQgcHJvY2Vzc1NEUChjb25zdCBT dHJpbmcmKSB7IH0KKyAgICB2b2lkIGFkZFBlbmRpbmdTdHJlYW1zKGNvbnN0IE1lZGlhU3RyZWFt RGVzY3JpcHRvclZlY3RvciYpIHsgfQorICAgIHZvaWQgcmVtb3ZlUGVuZGluZ1N0cmVhbXMoY29u c3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yVmVjdG9yJikgeyB9CisgICAgdm9pZCBzZW5kRGF0YVN0 cmVhbU1lc3NhZ2UoY29uc3QgY2hhciosIHVuc2lnbmVkKSB7IH0KKworICAgIHZvaWQgc3RvcCgp IHsgfQorfTsKKworUGVlckhhbmRsZXI6OlBlZXJIYW5kbGVyKFBlZXJIYW5kbGVyQ2xpZW50KiBj bGllbnQsIGNvbnN0IFBhc3NSZWZQdHI8UGVlckhhbmRsZXJDb25maWd1cmF0aW9uPiBjb25maWd1 cmF0aW9uKQorICAgIDogbV9jbGllbnQoY2xpZW50KQorICAgICwgbV9jb25maWd1cmF0aW9uKGNv bmZpZ3VyYXRpb24pCisgICAgLCBtX3ByaXZhdGUoUGVlckhhbmRsZXJQcml2YXRlQ2xhc3NOYW1l OjpjcmVhdGUodGhpcykpCit7Cit9CisKK1BlZXJIYW5kbGVyOjp+UGVlckhhbmRsZXIoKQorewor fQorCit2b2lkIFBlZXJIYW5kbGVyOjpwcm9kdWNlSW5pdGlhbE9mZmVyKGNvbnN0IE1lZGlhU3Ry ZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ1N0cmVhbXMpCit7CisgICAgbV9wcml2YXRlLT5w cm9kdWNlSW5pdGlhbE9mZmVyKHBlbmRpbmdTdHJlYW1zKTsKK30KKwordm9pZCBQZWVySGFuZGxl cjo6aGFuZGxlSW5pdGlhbE9mZmVyKGNvbnN0IFN0cmluZyYgc2RwKQoreworICAgIG1fcHJpdmF0 ZS0+aGFuZGxlSW5pdGlhbE9mZmVyKHNkcCk7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnByb2Nl c3NTRFAoY29uc3QgU3RyaW5nJiBzZHApCit7CisgICAgbV9wcml2YXRlLT5wcm9jZXNzU0RQKHNk cCk7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OmFkZFBlbmRpbmdTdHJlYW1zKGNvbnN0IE1lZGlh U3RyZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ1N0cmVhbXMpCit7CisgICAgbV9wcml2YXRl LT5hZGRQZW5kaW5nU3RyZWFtcyhwZW5kaW5nU3RyZWFtcyk7Cit9CisKK3ZvaWQgUGVlckhhbmRs ZXI6OnJlbW92ZVBlbmRpbmdTdHJlYW1zKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3Rv ciYgcGVuZGluZ1N0cmVhbXMpCit7CisgICAgbV9wcml2YXRlLT5yZW1vdmVQZW5kaW5nU3RyZWFt cyhwZW5kaW5nU3RyZWFtcyk7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnNlbmREYXRhU3RyZWFt TWVzc2FnZShjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBsZW5ndGgpCit7CisgICAgbV9wcml2 YXRlLT5zZW5kRGF0YVN0cmVhbU1lc3NhZ2UoZGF0YSwgbGVuZ3RoKTsKK30KKwordm9pZCBQZWVy SGFuZGxlcjo6c3RvcCgpCit7CisgICAgbV9wcml2YXRlLT5zdG9wKCk7Cit9CisKK3ZvaWQgUGVl ckhhbmRsZXI6OmljZVByb2Nlc3NpbmdDb21wbGV0ZWQoKQoreworICAgIG1fY2xpZW50LT5pY2VQ cm9jZXNzaW5nQ29tcGxldGVkKCk7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnNkcEdlbmVyYXRl ZChjb25zdCBTdHJpbmcmIHNkcCkKK3sKKyAgICBtX2NsaWVudC0+c2RwR2VuZXJhdGVkKHNkcCk7 Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OmRhdGFTdHJlYW1NZXNzYWdlUmVjZWl2ZWQoY29uc3Qg Y2hhciogZGF0YSwgdW5zaWduZWQgbGVuZ3RoKQoreworICAgIG1fY2xpZW50LT5kYXRhU3RyZWFt TWVzc2FnZVJlY2VpdmVkKGRhdGEsIGxlbmd0aCk7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnJl bW90ZVN0cmVhbUFkZGVkKFBhc3NSZWZQdHI8TWVkaWFTdHJlYW1EZXNjcmlwdG9yPiBzdHJlYW1E ZXNjcmlwdG9yKQoreworICAgIG1fY2xpZW50LT5yZW1vdGVTdHJlYW1BZGRlZChzdHJlYW1EZXNj cmlwdG9yKTsKK30KKwordm9pZCBQZWVySGFuZGxlcjo6cmVtb3RlU3RyZWFtUmVtb3ZlZChNZWRp YVN0cmVhbURlc2NyaXB0b3IqIHN0cmVhbURlc2NyaXB0b3IpCit7CisgICAgbV9jbGllbnQtPnJl bW90ZVN0cmVhbVJlbW92ZWQoc3RyZWFtRGVzY3JpcHRvcik7Cit9CisKK1BlZXJIYW5kbGVyQ29u ZmlndXJhdGlvbiogUGVlckhhbmRsZXI6OmNvbmZpZ3VyYXRpb24oKSBjb25zdAoreworICAgIHJl dHVybiBtX2NvbmZpZ3VyYXRpb24uZ2V0KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK KworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi42OTM1YTAxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaApAQCAtMCwwICsxLDEyNyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor ICogICAgZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBu b3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFBlZXJIYW5kbGVyX2gKKyNkZWZpbmUgUGVlckhhbmRsZXJfaAorCisjaWYgRU5B QkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIk1lZGlhU3RyZWFtLmgiCisjaW5jbHVkZSAi TWVkaWFTdHJlYW1EZXNjcmlwdG9yLmgiCisjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1 ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK2NsYXNzIFBlZXJIYW5kbGVyUHJpdmF0ZUludGVyZmFjZTsKKworc3Ry dWN0IFBlZXJIYW5kbGVyQ29uZmlndXJhdGlvbiA6IHB1YmxpYyBSZWZDb3VudGVkPFBlZXJIYW5k bGVyQ29uZmlndXJhdGlvbj4geworcHVibGljOgorICAgIGVudW0gVHlwZSB7CisgICAgICAgIFR5 cGVOT05FLAorICAgICAgICBUeXBlU1RVTiwKKyAgICAgICAgVHlwZVRVUk4KKyAgICB9OworCisg ICAgc3RhdGljIFBhc3NSZWZQdHI8UGVlckhhbmRsZXJDb25maWd1cmF0aW9uPiBjcmVhdGUoKQor ICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBQZWVySGFuZGxlckNvbmZpZ3VyYXRp b24oKSk7CisgICAgfQorCisgICAgVHlwZSB0eXBlOworICAgIGJvb2wgc2VjdXJlOworICAgIFN0 cmluZyBob3N0OworICAgIGludCBwb3J0OworICAgIFN0cmluZyB1c2VybmFtZTsKKyAgICBTdHJp bmcgcGFzc3dvcmQ7CisKK3ByaXZhdGU6CisgICAgUGVlckhhbmRsZXJDb25maWd1cmF0aW9uKCkK KyAgICAgICAgOiB0eXBlKFR5cGVOT05FKQorICAgICAgICAsIHNlY3VyZShmYWxzZSkKKyAgICAg ICAgLCBob3N0KCIiKQorICAgICAgICAsIHBvcnQoLTEpCisgICAgICAgICwgdXNlcm5hbWUoIiIp CisgICAgICAgICwgcGFzc3dvcmQoIiIpCisgICAgeyB9Cit9OworCitjbGFzcyBQZWVySGFuZGxl ckNsaWVudCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB+UGVlckhhbmRsZXJDbGllbnQoKSB7IH0K KworICAgIHZpcnR1YWwgdm9pZCBpY2VQcm9jZXNzaW5nQ29tcGxldGVkKCkgPSAwOworICAgIHZp cnR1YWwgdm9pZCBzZHBHZW5lcmF0ZWQoY29uc3QgU3RyaW5nJiBzZHApID0gMDsKKyAgICB2aXJ0 dWFsIHZvaWQgZGF0YVN0cmVhbU1lc3NhZ2VSZWNlaXZlZChjb25zdCBjaGFyKiBkYXRhLCB1bnNp Z25lZCBsZW5ndGgpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3RlU3RyZWFtQWRkZWQoUGFz c1JlZlB0cjxNZWRpYVN0cmVhbURlc2NyaXB0b3I+KSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHJl bW90ZVN0cmVhbVJlbW92ZWQoTWVkaWFTdHJlYW1EZXNjcmlwdG9yKikgPSAwOworfTsKKworY2xh c3MgUGVlckhhbmRsZXIgeworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFBlZXJIYW5kbGVyKTsK KyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093 blB0cjxQZWVySGFuZGxlcj4gY3JlYXRlKFBlZXJIYW5kbGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0 IFBhc3NSZWZQdHI8UGVlckhhbmRsZXJDb25maWd1cmF0aW9uPiBjb25maWd1cmF0aW9uKQorICAg IHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBQZWVySGFuZGxlcihjbGllbnQsIGNvbmZp Z3VyYXRpb24pKTsKKyAgICB9CisgICAgdmlydHVhbCB+UGVlckhhbmRsZXIoKTsKKworICAgIHZv aWQgcHJvZHVjZUluaXRpYWxPZmZlcihjb25zdCBNZWRpYVN0cmVhbURlc2NyaXB0b3JWZWN0b3Im IHBlbmRpbmdTdHJlYW1zKTsKKyAgICB2b2lkIGhhbmRsZUluaXRpYWxPZmZlcihjb25zdCBTdHJp bmcmIHNkcCk7CisgICAgdm9pZCBwcm9jZXNzU0RQKGNvbnN0IFN0cmluZyYgc2RwKTsKKyAgICB2 b2lkIGFkZFBlbmRpbmdTdHJlYW1zKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvciYg cGVuZGluZ1N0cmVhbXMpOworICAgIHZvaWQgcmVtb3ZlUGVuZGluZ1N0cmVhbXMoY29uc3QgTWVk aWFTdHJlYW1EZXNjcmlwdG9yVmVjdG9yJiBwZW5kaW5nU3RyZWFtcyk7CisgICAgdm9pZCBzZW5k RGF0YVN0cmVhbU1lc3NhZ2UoY29uc3QgY2hhciogZGF0YSwgdW5zaWduZWQgbGVuZ3RoKTsKKwor ICAgIHZvaWQgc3RvcCgpOworCisgICAgdm9pZCBpY2VQcm9jZXNzaW5nQ29tcGxldGVkKCk7Cisg ICAgdm9pZCBzZHBHZW5lcmF0ZWQoY29uc3QgU3RyaW5nJiBzZHApOworICAgIHZvaWQgZGF0YVN0 cmVhbU1lc3NhZ2VSZWNlaXZlZChjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBsZW5ndGgpOwor ICAgIHZvaWQgcmVtb3RlU3RyZWFtQWRkZWQoUGFzc1JlZlB0cjxNZWRpYVN0cmVhbURlc2NyaXB0 b3I+KTsKKyAgICB2b2lkIHJlbW90ZVN0cmVhbVJlbW92ZWQoTWVkaWFTdHJlYW1EZXNjcmlwdG9y Kik7CisKKyAgICBQZWVySGFuZGxlckNvbmZpZ3VyYXRpb24qIGNvbmZpZ3VyYXRpb24oKSBjb25z dDsKKworcHJpdmF0ZToKKyAgICBQZWVySGFuZGxlcihQZWVySGFuZGxlckNsaWVudCosIGNvbnN0 IFBhc3NSZWZQdHI8UGVlckhhbmRsZXJDb25maWd1cmF0aW9uPik7CisKKyAgICBQZWVySGFuZGxl ckNsaWVudCogbV9jbGllbnQ7CisgICAgUmVmUHRyPFBlZXJIYW5kbGVyQ29uZmlndXJhdGlvbj4g bV9jb25maWd1cmF0aW9uOworICAgIE93blB0cjxQZWVySGFuZGxlclByaXZhdGVJbnRlcmZhY2U+ IG1fcHJpdmF0ZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVO QUJMRShNRURJQV9TVFJFQU0pCisKKyNlbmRpZiAvLyBQZWVySGFuZGxlcl9oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlclByaXZhdGUu aCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyUHJpdmF0 ZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg1ZjZlMmEKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxl clByaXZhdGUuaApAQCAtMCwwICsxLDYxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVy aWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAz LiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRy aWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9y IHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgUGVlckhhbmRsZXJQcml2 YXRlX2gKKyNkZWZpbmUgUGVlckhhbmRsZXJQcml2YXRlX2gKKworI2lmIEVOQUJMRShNRURJQV9T VFJFQU0pCisKKyNpbmNsdWRlICJQZWVySGFuZGxlci5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKK2NsYXNzIFBlZXJIYW5kbGVyUHJpdmF0ZUludGVyZmFjZSB7CisgICAgV1RGX01BS0VfTk9O Q09QWUFCTEUoUGVlckhhbmRsZXJQcml2YXRlSW50ZXJmYWNlKTsKKyAgICBXVEZfTUFLRV9GQVNU X0FMTE9DQVRFRDsKK3B1YmxpYzoKKyAgICBQZWVySGFuZGxlclByaXZhdGVJbnRlcmZhY2UoKSB7 IH0KKyAgICB2aXJ0dWFsIH5QZWVySGFuZGxlclByaXZhdGVJbnRlcmZhY2UoKSB7IH0KKworICAg IHZpcnR1YWwgdm9pZCBwcm9kdWNlSW5pdGlhbE9mZmVyKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3Jp cHRvclZlY3RvciYgcGVuZGluZ1N0cmVhbXMpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxl SW5pdGlhbE9mZmVyKGNvbnN0IFN0cmluZyYgc2RwKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHBy b2Nlc3NTRFAoY29uc3QgU3RyaW5nJiBzZHApID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgYWRkUGVu ZGluZ1N0cmVhbXMoY29uc3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yVmVjdG9yJiBwZW5kaW5nU3Ry ZWFtcykgPSAwOworICAgIHZpcnR1YWwgdm9pZCByZW1vdmVQZW5kaW5nU3RyZWFtcyhjb25zdCBN ZWRpYVN0cmVhbURlc2NyaXB0b3JWZWN0b3ImIHBlbmRpbmdTdHJlYW1zKSA9IDA7CisgICAgdmly dHVhbCB2b2lkIHNlbmREYXRhU3RyZWFtTWVzc2FnZShjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25l ZCBsZW5ndGgpID0gMDsKKworICAgIHZpcnR1YWwgdm9pZCBzdG9wKCkgPSAwOworfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKwor I2VuZGlmIC8vIFBlZXJIYW5kbGVyUHJpdmF0ZV9oCg== 109780 2011-10-05 06:28:28 -0700 2011-10-07 09:56:13 -0700 Updated patch mediastream_platform_files_2.patch text/plain 25625 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1OWU4YzYzLi4wNjMyZDY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDgg QEAKKzIwMTEtMTAtMDUgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIEFkZCBXZWJDb3JlIHBsYXRmb3JtIGludGVyZmFjZXMgbmVlZGVkIGJ5 IHVwZGF0ZWQgTWVkaWFTdHJlYW0gYW5kIFBlZXJDb25uZWN0aW9uIGRlc2lnbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Njg0NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0aGUgTWVkaWFTdHJl YW0gYW5kIFBlZXJDb25uZWN0aW9uIHBsYXRmb3JtIGZpbGVzIHRvIFdlYkNvcmUvcGxhdGZvcm0v bWVkaWFzdHJlYW0uCisKKyAgICAgICAgQ3VycmVudGx5IG5vdCB0ZXN0YWJsZS4KKworICAgICAg ICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAg ICAgICogV2ViQ29yZS5neXAvV2ViQ29yZS5neXA6CisgICAgICAgICogV2ViQ29yZS5neXBpOgor ICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2VudGVyLmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjptZWRpYVN0cmVhbUNlbnRlcik6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVN0cmVhbUNlbnRlcjo6c3RyZWFtRW5kZWQpOgorICAgICAgICAoV2ViQ29yZTo6 TWVkaWFTdHJlYW1DZW50ZXI6Ok1lZGlhU3RyZWFtQ2VudGVyKToKKyAgICAgICAgKFdlYkNvcmU6 Ok1lZGlhU3RyZWFtQ2VudGVyOjp+TWVkaWFTdHJlYW1DZW50ZXIpOgorICAgICAgICAoV2ViQ29y ZTo6TWVkaWFTdHJlYW1DZW50ZXI6Om1lZGlhU3RyZWFtVHJhY2tFbmFibGVkU2V0KToKKyAgICAg ICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtQ2VudGVyOjpzdG9wTG9jYWxNZWRpYVN0cmVhbSk6Cisg ICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DZW50ZXIuaDogQWRkZWQu CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db21wb25lbnQuaDog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbUNvbXBvbmVudDo6Y3JlYXRlKToK KyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtQ29tcG9uZW50OjpNZWRpYVN0cmVhbUNvbXBv bmVudCk6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1EZXNjcmlw dG9yLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjpNZWRpYVN0 cmVhbURlc2NyaXB0b3IpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3Ry ZWFtU291cmNlLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1Tb3VyY2U6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbVNvdXJjZTo6TWVkaWFTdHJl YW1Tb3VyY2UpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyLmNw cDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6UGVlckhhbmRsZXIpOgor ICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6On5QZWVySGFuZGxlcik6CisgICAgICAgIChX ZWJDb3JlOjpQZWVySGFuZGxlcjo6cHJvZHVjZUluaXRpYWxPZmZlcik6CisgICAgICAgIChXZWJD b3JlOjpQZWVySGFuZGxlcjo6aGFuZGxlSW5pdGlhbE9mZmVyKToKKyAgICAgICAgKFdlYkNvcmU6 OlBlZXJIYW5kbGVyOjpwcm9jZXNzU0RQKToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVy Ojpwcm9jZXNzUGVuZGluZ1N0cmVhbXMpOgorICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6 OnNlbmREYXRhU3RyZWFtTWVzc2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6 c3RvcCk6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlckNsaWVudDo6flBlZXJIYW5kbGVyQ2xp ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVyOjpjcmVhdGUpOgorCiAyMDExLTEw LTA1ICBJbHlhIFRpa2hvbm92c2t5ICA8bG9pc2xvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBV bnJldmlld2VkIGJ1aWxkIGZpeCBmb3Igd2luZG93cyBib3RzIGFmdGVyIHI5NjY3OS4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvU291cmNlL1dlYkNvcmUvR05V bWFrZWZpbGUuYW0KaW5kZXggMTQ0NGI0ZS4uNjEyODg1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTYwLDYgKzYwLDcgQEAgd2ViY29yZV9jcHBmbGFncyArPSBcCiAJLUkkKHNyY2RpcikvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvd2VicCBcCiAJLUkkKHNyY2Rpcikv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvcG5nIFwKIAktSSQoc3JjZGly KS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9sZXZlbGRiIFwKKwktSSQoc3JjZGlyKS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbSBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbW9jayBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yayBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vc3FsIFwKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2Vi Q29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IDU3MmFmZmUuLmM1MWJhZTMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNv cmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMjY5MCw2ICsyNjkwLDEzIEBAIHdlYmNvcmVfc291 cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvd2VicC9X RUJQSW1hZ2VEZWNvZGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29k ZXJzL3BuZy9QTkdJbWFnZURlY29kZXIuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9p bWFnZS1kZWNvZGVycy9wbmcvUE5HSW1hZ2VEZWNvZGVyLmggXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2VudGVyLmNwcCBcCisJU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DZW50ZXIuaCBcCisJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db21wb25lbnQuaCBcCisJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1EZXNjcmlwdG9yLmgg XAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtU291cmNl LmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyLmNw cCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaCBc CiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9EZXZpY2VPcmllbnRhdGlvbkNsaWVudE1v Y2suY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tb2NrL0RldmljZU9yaWVudGF0aW9u Q2xpZW50TW9jay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tb2NrL0dlb2xvY2F0aW9u Q2xpZW50TW9jay5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXAv V2ViQ29yZS5neXAgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cC9XZWJDb3JlLmd5cAppbmRl eCBlNzgyNTczLi42OTUwNTFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5 cC9XZWJDb3JlLmd5cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cC9XZWJDb3JlLmd5 cApAQCAtMTkzLDYgKzE5Myw3IEBACiAgICAgICAnLi4vcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMv d2VicCcsCiAgICAgICAnLi4vcGxhdGZvcm0vaW1hZ2UtZW5jb2RlcnMvc2tpYScsCiAgICAgICAn Li4vcGxhdGZvcm0vbGV2ZWxkYicsCisgICAgICAnLi4vcGxhdGZvcm0vbWVkaWFzdHJlYW0nLAog ICAgICAgJy4uL3BsYXRmb3JtL21vY2snLAogICAgICAgJy4uL3BsYXRmb3JtL25ldHdvcmsnLAog ICAgICAgJy4uL3BsYXRmb3JtL25ldHdvcmsvY2hyb21pdW0nLApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4 IGU1ZjkxZTQuLmRhYTk3Y2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lw aQorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTgwOSw2ICs4MDksMTMgQEAK ICAgICAgICAgICAgICdwbGF0Zm9ybS9tYWMvV2ViQ29yZVN5c3RlbUludGVyZmFjZS5oJywKICAg ICAgICAgICAgICdwbGF0Zm9ybS9tYWMvV2ViQ29yZVZpZXcuaCcsCiAgICAgICAgICAgICAncGxh dGZvcm0vbWFjL1dlYkZvbnRDYWNoZS5oJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUNlbnRlci5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlh c3RyZWFtL01lZGlhU3RyZWFtQ2VudGVyLmgnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21lZGlh c3RyZWFtL01lZGlhU3RyZWFtQ29tcG9uZW50LmgnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtRGVzY3JpcHRvci5oJywKKyAgICAgICAgICAgICdwbGF0Zm9y bS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbVNvdXJjZS5oJywKKyAgICAgICAgICAgICdwbGF0Zm9y bS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL21l ZGlhc3RyZWFtL1BlZXJIYW5kbGVyLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL21vY2svRGV2 aWNlT3JpZW50YXRpb25DbGllbnRNb2NrLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL21vY2sv R2VvbG9jYXRpb25DbGllbnRNb2NrLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL25ldHdvcmsv QXV0aGVudGljYXRpb25DaGFsbGVuZ2VCYXNlLmgnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DZW50ZXIuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DZW50ZXIuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE3NjUzY2MKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNlbnRlci5jcHAK QEAgLTAsMCArMSw4MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICog YXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0 aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAq ICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZy b20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBl cm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJ R0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQor ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUo TUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1DZW50ZXIuaCIKKworI2luY2x1 ZGUgIk1haW5UaHJlYWQuaCIKKyNpbmNsdWRlICJNZWRpYVN0cmVhbS5oIgorI2luY2x1ZGUgIk1l ZGlhU3RyZWFtRGVzY3JpcHRvci5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK01lZGlhU3Ry ZWFtQ2VudGVyJiBtZWRpYVN0cmVhbUNlbnRlcigpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVh ZCgpKTsKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKE1lZGlhU3RyZWFtQ2VudGVyLCBpbnN0YW5j ZSwgKCkpOworICAgIHJldHVybiBpbnN0YW5jZTsKK30KKwordm9pZCBNZWRpYVN0cmVhbUNlbnRl cjo6c3RyZWFtRW5kZWQoTWVkaWFTdHJlYW1EZXNjcmlwdG9yKiBzdHJlYW1EZXNjcmlwdG9yKQor eworICAgIE1lZGlhU3RyZWFtKiBzdHJlYW0gPSBzdHJlYW1EZXNjcmlwdG9yLT5vd25lcjsKKyAg ICBpZiAoc3RyZWFtKQorICAgICAgICBzdHJlYW0tPnN0cmVhbUVuZGVkKCk7CisgICAgZWxzZQor ICAgICAgICBzdHJlYW1EZXNjcmlwdG9yLT5lbmRlZCA9IHRydWU7Cit9CisKKy8vIEZJWE1FOiBy ZW1vdmUgd2hlbiByZWFsIGltcGxlbWVudGF0aW9ucyBhcmUgYXZhaWxhYmxlCisvLyBFbXB0eSBp bXBsZW1lbnRhdGlvbnMgZm9yIHBvcnRzIHRoYXQgYnVpbGQgd2l0aCBNRURJQV9TVFJFQU0gZW5h YmxlZCBieSBkZWZhdWx0LgorI2lmIFBMQVRGT1JNKENIUk9NSVVNKSB8fCBQTEFURk9STShHVEsp CitNZWRpYVN0cmVhbUNlbnRlcjo6TWVkaWFTdHJlYW1DZW50ZXIoKQoreworfQorCitNZWRpYVN0 cmVhbUNlbnRlcjo6fk1lZGlhU3RyZWFtQ2VudGVyKCkKK3sKK30KKwordm9pZCBNZWRpYVN0cmVh bUNlbnRlcjo6bWVkaWFTdHJlYW1UcmFja0VuYWJsZWRTZXQoY29uc3QgTWVkaWFTdHJlYW1EZXNj cmlwdG9yKiwgdW5zaWduZWQpCit7Cit9CisKK3ZvaWQgTWVkaWFTdHJlYW1DZW50ZXI6OnN0b3BM b2NhbE1lZGlhU3RyZWFtKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvciopCit7Cit9CisjZW5k aWYKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NU UkVBTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtQ2VudGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9N ZWRpYVN0cmVhbUNlbnRlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVj NDYxZjAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUNlbnRlci5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3Ry aWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1l cyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQg c3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAq ICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBN ZWRpYVN0cmVhbUNlbnRlcl9oCisjZGVmaW5lIE1lZGlhU3RyZWFtQ2VudGVyX2gKKworI2lmIEVO QUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJNZWRpYVN0cmVhbVNvdXJjZS5oIgorI2lu Y2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBNZWRp YVN0cmVhbURlc2NyaXB0b3I7CitjbGFzcyBNZWRpYVN0cmVhbUNlbnRlcjsKKworTWVkaWFTdHJl YW1DZW50ZXImIG1lZGlhU3RyZWFtQ2VudGVyKCk7CisKK2NsYXNzIE1lZGlhU3RyZWFtQ2VudGVy IHsKKyAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZWRpYVN0cmVhbUNlbnRlcik7CisgICAgV1RG X01BS0VfRkFTVF9BTExPQ0FURUQ7CitwdWJsaWM6CisgICAgTWVkaWFTdHJlYW1DZW50ZXIoKTsK KyAgICB+TWVkaWFTdHJlYW1DZW50ZXIoKTsKKworICAgIHZvaWQgbWVkaWFTdHJlYW1UcmFja0Vu YWJsZWRTZXQoY29uc3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yKiwgdW5zaWduZWQgY29tcG9uZW50 SW5kZXgpOworICAgIHZvaWQgc3RvcExvY2FsTWVkaWFTdHJlYW0oY29uc3QgTWVkaWFTdHJlYW1E ZXNjcmlwdG9yKik7CisKKyAgICB2b2lkIHN0cmVhbUVuZGVkKE1lZGlhU3RyZWFtRGVzY3JpcHRv ciopOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1F RElBX1NUUkVBTSkKKworI2VuZGlmIC8vIE1lZGlhU3RyZWFtQ2VudGVyX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29tcG9uZW50 LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbXBv bmVudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUxMTkxOTIKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0 cmVhbUNvbXBvbmVudC5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4K KyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMg Y29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMg cHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBNZWRpYVN0cmVh bUNvbXBvbmVudF9oCisjZGVmaW5lIE1lZGlhU3RyZWFtQ29tcG9uZW50X2gKKworI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJNZWRpYVN0cmVhbVNvdXJjZS5oIgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK3N0cnVjdCBNZWRpYVN0cmVhbUNvbXBvbmVudCA6IHB1YmxpYyBS ZWZDb3VudGVkPE1lZGlhU3RyZWFtQ29tcG9uZW50PiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NSZWZQdHI8TWVkaWFTdHJlYW1Db21wb25lbnQ+IGNyZWF0ZShQYXNzUmVmUHRyPE1lZGlhU3Ry ZWFtU291cmNlPiBzb3VyY2UpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IE1l ZGlhU3RyZWFtQ29tcG9uZW50KHNvdXJjZSkpOworICAgIH0KKworICAgIFJlZlB0cjxNZWRpYVN0 cmVhbVNvdXJjZT4gc291cmNlOworICAgIGJvb2wgZW5hYmxlZDsKKworcHJpdmF0ZToKKyAgICBN ZWRpYVN0cmVhbUNvbXBvbmVudChQYXNzUmVmUHRyPE1lZGlhU3RyZWFtU291cmNlPiBzb3VyY2VB cmcpCisgICAgICAgIDogc291cmNlKHNvdXJjZUFyZykKKyAgICAgICAgLCBlbmFibGVkKHRydWUp CisgICAgeyB9Cit9OworCit0eXBlZGVmIFZlY3RvcjxSZWZQdHI8TWVkaWFTdHJlYW1Db21wb25l bnQ+ID4gTWVkaWFTdHJlYW1Db21wb25lbnRWZWN0b3I7CisKK30gLy8gbmFtZXNwYWNlIFdlYkNv cmUKKworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNlbmRpZiAvLyBNZWRpYVN0 cmVhbUNvbXBvbmVudF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRp YXN0cmVhbS9NZWRpYVN0cmVhbURlc2NyaXB0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRGVzY3JpcHRvci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjRiZmIyOTEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbURlc2NyaXB0b3IuaApAQCAtMCwwICsx LDcyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisg KiAgICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9m IEVyaWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisg KiAgICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAq IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpZm5kZWYgTWVkaWFTdHJlYW1EZXNjcmlwdG9yX2gKKyNkZWZpbmUgTWVk aWFTdHJlYW1EZXNjcmlwdG9yX2gKKworI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNs dWRlICJNZWRpYVN0cmVhbUNvbXBvbmVudC5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgi CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgTWVkaWFTdHJlYW07CisKK3N0cnVjdCBNZWRp YVN0cmVhbURlc2NyaXB0b3IgOiBwdWJsaWMgUmVmQ291bnRlZDxNZWRpYVN0cmVhbURlc2NyaXB0 b3I+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxNZWRpYVN0cmVhbURlc2NyaXB0 b3I+IGNyZWF0ZShjb25zdCBTdHJpbmcmIGxhYmVsLCBjb25zdCBNZWRpYVN0cmVhbUNvbXBvbmVu dFZlY3RvciYgY29tcG9uZW50cykKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg TWVkaWFTdHJlYW1EZXNjcmlwdG9yKGxhYmVsLCBjb21wb25lbnRzKSk7CisgICAgfQorCisgICAg TWVkaWFTdHJlYW0qIG93bmVyOworICAgIFN0cmluZyBsYWJlbDsKKyAgICBNZWRpYVN0cmVhbUNv bXBvbmVudFZlY3RvciBjb21wb25lbnRzOworICAgIGJvb2wgZW5kZWQ7CisKK3ByaXZhdGU6Cisg ICAgTWVkaWFTdHJlYW1EZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgbGFiZWxBcmcsIGNvbnN0IE1l ZGlhU3RyZWFtQ29tcG9uZW50VmVjdG9yJiBjb21wb25lbnRzQXJnKQorICAgICAgICA6IG93bmVy KDApCisgICAgICAgICwgbGFiZWwobGFiZWxBcmcpCisgICAgICAgICwgY29tcG9uZW50cyhjb21w b25lbnRzQXJnKQorICAgICAgICAsIGVuZGVkKGZhbHNlKQorICAgIHsgfQorfTsKKwordHlwZWRl ZiBWZWN0b3I8UmVmUHRyPE1lZGlhU3RyZWFtRGVzY3JpcHRvcj4gPiBNZWRpYVN0cmVhbURlc2Ny aXB0b3JWZWN0b3I7CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShNRURJQV9TVFJFQU0pCisKKyNlbmRpZiAvLyBNZWRpYVN0cmVhbURlc2NyaXB0b3JfaApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1T b3VyY2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFt U291cmNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2E4ODYyMgotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlh U3RyZWFtU291cmNlLmgKQEAgLTAsMCArMSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9uLgor ICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBj b250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9k dWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIE1lZGlhU3RyZWFt U291cmNlX2gKKyNkZWZpbmUgTWVkaWFTdHJlYW1Tb3VyY2VfaAorCisjaWYgRU5BQkxFKE1FRElB X1NUUkVBTSkKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSA8d3RmL1Jl ZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworc3RydWN0IE1lZGlhU3RyZWFtU291cmNlIDogcHVibGljIFJlZkNvdW50ZWQ8TWVkaWFT dHJlYW1Tb3VyY2U+IHsKK3B1YmxpYzoKKyAgICBlbnVtIFR5cGUgeworICAgICAgICBUeXBlQXVk aW8sCisgICAgICAgIFR5cGVWaWRlbworICAgIH07CisKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxN ZWRpYVN0cmVhbVNvdXJjZT4gY3JlYXRlKGNvbnN0IFN0cmluZyYgaWQsIFR5cGUgdHlwZSwgY29u c3QgU3RyaW5nJiBuYW1lKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBNZWRp YVN0cmVhbVNvdXJjZShpZCwgdHlwZSwgbmFtZSkpOworICAgIH0KKworICAgIFN0cmluZyBpZDsK KyAgICBUeXBlIHR5cGU7CisgICAgU3RyaW5nIG5hbWU7CisgICAgYm9vbCBtdXRlZDsKKworcHJp dmF0ZToKKyAgICBNZWRpYVN0cmVhbVNvdXJjZShjb25zdCBTdHJpbmcmIGlkQXJnLCBUeXBlIHR5 cGVBcmcsIGNvbnN0IFN0cmluZyYgbmFtZUFyZykKKyAgICAgICAgOiBpZChpZEFyZykKKyAgICAg ICAgLCB0eXBlKHR5cGVBcmcpCisgICAgICAgICwgbmFtZShuYW1lQXJnKQorICAgICAgICAsIG11 dGVkKGZhbHNlKQorICAgIHsgfQorfTsKKwordHlwZWRlZiBWZWN0b3I8UmVmUHRyPE1lZGlhU3Ry ZWFtU291cmNlPiA+IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yOworCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8gTWVk aWFTdHJlYW1Tb3VyY2VfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVk aWFzdHJlYW0vUGVlckhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFz dHJlYW0vUGVlckhhbmRsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmUzZjVjYjAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRp YXN0cmVhbS9QZWVySGFuZGxlci5jcHAKQEAgLTAsMCArMSw3NyBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJp YnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVz IG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiUGVlckhh bmRsZXIuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBGSVhNRTogcmVtb3ZlIHdoZW4g cmVhbCBpbXBsZW1lbnRhdGlvbnMgYXJlIGF2YWlsYWJsZQorLy8gRW1wdHkgaW1wbGVtZW50YXRp b25zIGZvciBwb3J0cyB0aGF0IGJ1aWxkIHdpdGggTUVESUFfU1RSRUFNIGVuYWJsZWQgYnkgZGVm YXVsdC4KKyNpZiBQTEFURk9STShDSFJPTUlVTSkgfHwgUExBVEZPUk0oR1RLKQorUGVlckhhbmRs ZXI6OlBlZXJIYW5kbGVyKFBlZXJIYW5kbGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJiwgY29uc3Qg U3RyaW5nJikKK3sKK30KKworUGVlckhhbmRsZXI6On5QZWVySGFuZGxlcigpCit7Cit9CisKK3Zv aWQgUGVlckhhbmRsZXI6OnByb2R1Y2VJbml0aWFsT2ZmZXIoY29uc3QgTWVkaWFTdHJlYW1EZXNj cmlwdG9yVmVjdG9yJikKK3sKK30KKwordm9pZCBQZWVySGFuZGxlcjo6aGFuZGxlSW5pdGlhbE9m ZmVyKGNvbnN0IFN0cmluZyYpCit7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnByb2Nlc3NTRFAo Y29uc3QgU3RyaW5nJikKK3sKK30KKwordm9pZCBQZWVySGFuZGxlcjo6cHJvY2Vzc1BlbmRpbmdT dHJlYW1zKGNvbnN0IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvciYsIGNvbnN0IE1lZGlhU3Ry ZWFtRGVzY3JpcHRvclZlY3RvciYpCit7Cit9CisKK3ZvaWQgUGVlckhhbmRsZXI6OnNlbmREYXRh U3RyZWFtTWVzc2FnZShjb25zdCBjaGFyKiwgdW5zaWduZWQpCit7Cit9CisKK3ZvaWQgUGVlckhh bmRsZXI6OnN0b3AoKQoreworfQorI2VuZGlmCisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwor I2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5jNjE0ZWRmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuaApAQCAtMCwwICsxLDgyIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0aGUgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiAg ICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0 aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8gZW5kb3Jz ZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3 aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVU T1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dO RVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQor ICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp Zm5kZWYgUGVlckhhbmRsZXJfaAorI2RlZmluZSBQZWVySGFuZGxlcl9oCisKKyNpZiBFTkFCTEUo TUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1EZXNjcmlwdG9yLmgiCisjaW5j bHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVk ZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBQZWVy SGFuZGxlckNsaWVudCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB+UGVlckhhbmRsZXJDbGllbnQo KSB7IH0KKworICAgIHZpcnR1YWwgdm9pZCBpY2VQcm9jZXNzaW5nQ29tcGxldGVkKCkgPSAwOwor ICAgIHZpcnR1YWwgdm9pZCBzZHBHZW5lcmF0ZWQoY29uc3QgU3RyaW5nJiBzZHApID0gMDsKKyAg ICB2aXJ0dWFsIHZvaWQgZGF0YVN0cmVhbU1lc3NhZ2VSZWNlaXZlZChjb25zdCBjaGFyKiBkYXRh LCB1bnNpZ25lZCBsZW5ndGgpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3RlU3RyZWFtQWRk ZWQoUGFzc1JlZlB0cjxNZWRpYVN0cmVhbURlc2NyaXB0b3I+KSA9IDA7CisgICAgdmlydHVhbCB2 b2lkIHJlbW90ZVN0cmVhbVJlbW92ZWQoTWVkaWFTdHJlYW1EZXNjcmlwdG9yKikgPSAwOworfTsK KworY2xhc3MgUGVlckhhbmRsZXIgeworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFBlZXJIYW5k bGVyKTsKKyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc093blB0cjxQZWVySGFuZGxlcj4gY3JlYXRlKFBlZXJIYW5kbGVyQ2xpZW50KiBjbGllbnQs IGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3QgU3RyaW5nJiB1c2VybmFt ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgUGVlckhhbmRsZXIoY2xpZW50 LCBzZXJ2ZXJDb25maWd1cmF0aW9uLCB1c2VybmFtZSkpOworICAgIH0KKyAgICB2aXJ0dWFsIH5Q ZWVySGFuZGxlcigpOworCisgICAgdm9pZCBwcm9kdWNlSW5pdGlhbE9mZmVyKGNvbnN0IE1lZGlh U3RyZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ0FkZFN0cmVhbXMpOworICAgIHZvaWQgaGFu ZGxlSW5pdGlhbE9mZmVyKGNvbnN0IFN0cmluZyYgc2RwKTsKKyAgICB2b2lkIHByb2Nlc3NTRFAo Y29uc3QgU3RyaW5nJiBzZHApOworICAgIHZvaWQgcHJvY2Vzc1BlbmRpbmdTdHJlYW1zKGNvbnN0 IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ0FkZFN0cmVhbXMsIGNvbnN0IE1l ZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ1JlbW92ZVN0cmVhbXMpOworICAgIHZv aWQgc2VuZERhdGFTdHJlYW1NZXNzYWdlKGNvbnN0IGNoYXIqIGRhdGEsIHVuc2lnbmVkIGxlbmd0 aCk7CisKKyAgICB2b2lkIHN0b3AoKTsKKworcHJpdmF0ZToKKyAgICBQZWVySGFuZGxlcihQZWVy SGFuZGxlckNsaWVudCosIGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3Qg U3RyaW5nJiB1c2VybmFtZSk7CisKKyAgICBQZWVySGFuZGxlckNsaWVudCogbV9jbGllbnQ7Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RS RUFNKQorCisjZW5kaWYgLy8gUGVlckhhbmRsZXJfaAo= 110163 2011-10-07 09:56:13 -0700 2011-10-07 11:05:46 -0700 Patch 3 peerconnection_platform_files_1.patch text/plain 20828 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBlYjdhMmVmLi4xMzI5MjMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTUg QEAKKzIwMTEtMTAtMDcgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIEFkZCBXZWJDb3JlIHBsYXRmb3JtIGludGVyZmFjZXMgbmVlZGVkIGJ5 IHVwZGF0ZWQgUGVlckNvbm5lY3Rpb24gZGVzaWduCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD02ODQ2MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHRoZSBQZWVyQ29ubmVjdGlvbiBwbGF0Zm9ybSBm aWxlcyB0byBXZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtCisKKyAgICAgICAgQ3VycmVudGx5 IG5vdCB0ZXN0YWJsZS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIEdO VW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogV2ViQ29yZS5neXAvV2ViQ29yZS5neXA6Cisg ICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIHBsYXRmb3JtL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtQ29tcG9uZW50Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJl YW1Db21wb25lbnQ6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbUNvbXBv bmVudDo6c291cmNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtQ29tcG9uZW50Ojpl bmFibGVkKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtQ29tcG9uZW50OjpzZXRFbmFi bGVkKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtQ29tcG9uZW50OjpNZWRpYVN0cmVh bUNvbXBvbmVudCk6CisgICAgICAgICogcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1E ZXNjcmlwdG9yLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlw dG9yOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjpv d25lcik6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbURlc2NyaXB0b3I6OnNldE93bmVy KToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtRGVzY3JpcHRvcjo6bGFiZWwpOgorICAg ICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjpjb21wb25lbnQpOgorICAgICAg ICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjpudW1iZXJPZkNvbXBvbmVudHMpOgor ICAgICAgICAoV2ViQ29yZTo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yOjplbmRlZCk6CisgICAgICAg IChXZWJDb3JlOjpNZWRpYVN0cmVhbURlc2NyaXB0b3I6OnNldEVuZGVkKToKKyAgICAgICAgKFdl YkNvcmU6Ok1lZGlhU3RyZWFtRGVzY3JpcHRvcjo6TWVkaWFTdHJlYW1EZXNjcmlwdG9yKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbVNvdXJjZS5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtU291cmNlOjpjcmVhdGUpOgorICAgICAgICAo V2ViQ29yZTo6TWVkaWFTdHJlYW1Tb3VyY2U6OmlkKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlh U3RyZWFtU291cmNlOjp0eXBlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtU291cmNl OjpuYW1lKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhU3RyZWFtU291cmNlOjptdXRlZCk6Cisg ICAgICAgIChXZWJDb3JlOjpNZWRpYVN0cmVhbVNvdXJjZTo6c2V0TXV0ZWQpOgorICAgICAgICAo V2ViQ29yZTo6TWVkaWFTdHJlYW1Tb3VyY2U6Ok1lZGlhU3RyZWFtU291cmNlKToKKyAgICAgICAg KiBwbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6UGVlckhhbmRsZXI6OlBlZXJIYW5kbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBl ZXJIYW5kbGVyOjp+UGVlckhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6 OnByb2R1Y2VJbml0aWFsT2ZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6Omhh bmRsZUluaXRpYWxPZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6cHJvY2Vz c1NEUCk6CisgICAgICAgIChXZWJDb3JlOjpQZWVySGFuZGxlcjo6cHJvY2Vzc1BlbmRpbmdTdHJl YW1zKToKKyAgICAgICAgKFdlYkNvcmU6OlBlZXJIYW5kbGVyOjpzZW5kRGF0YVN0cmVhbU1lc3Nh Z2UpOgorICAgICAgICAoV2ViQ29yZTo6UGVlckhhbmRsZXI6OnN0b3ApOgorICAgICAgICAqIHBs YXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVyLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6UGVlckhhbmRsZXJDbGllbnQ6On5QZWVySGFuZGxlckNsaWVudCk6CisgICAgICAgIChXZWJD b3JlOjpQZWVySGFuZGxlcjo6Y3JlYXRlKToKKwogMjAxMS0xMC0wNyAgTWFydGluIFJvYmluc29u ICA8bXJvYmluc29uQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0ZyZWV0eXBlXSBQc2V1ZG8taXRh bGljcyBkbyBub3Qgd29yawpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUu YW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAxNDQ0YjRlLi42MTI4ODU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9Tb3VyY2Uv V2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtNjAsNiArNjAsNyBAQCB3ZWJjb3JlX2NwcGZsYWdz ICs9IFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVy cy93ZWJwIFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNv ZGVycy9wbmcgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2xldmVsZGIg XAorCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtIFwKIAkt SSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tb2NrIFwKIAktSSQoc3JjZGlyKS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrIFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9zcWwgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZp bGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggZjEz NDQ5NS4uNWE5Mjg2NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlz dC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0yNjk1LDYg KzI2OTUsMTEgQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9pbWFnZS1kZWNvZGVycy93ZWJwL1dFQlBJbWFnZURlY29kZXIuaCBcCiAJU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvcG5nL1BOR0ltYWdlRGVjb2Rlci5jcHAgXAogCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL3BuZy9QTkdJbWFnZURlY29kZXIu aCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db21w b25lbnQuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJl YW1EZXNjcmlwdG9yLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtU291cmNlLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFt L1BlZXJIYW5kbGVyLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0v UGVlckhhbmRsZXIuaCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbW9jay9EZXZpY2VPcmll bnRhdGlvbkNsaWVudE1vY2suY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tb2NrL0Rl dmljZU9yaWVudGF0aW9uQ2xpZW50TW9jay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9t b2NrL0dlb2xvY2F0aW9uQ2xpZW50TW9jay5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvV2ViQ29yZS5neXAvV2ViQ29yZS5neXAgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cC9X ZWJDb3JlLmd5cAppbmRleCBlNzgyNTczLi42OTUwNTFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLmd5cC9XZWJDb3JlLmd5cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cC9XZWJDb3JlLmd5cApAQCAtMTkzLDYgKzE5Myw3IEBACiAgICAgICAnLi4vcGxhdGZvcm0v aW1hZ2UtZGVjb2RlcnMvd2VicCcsCiAgICAgICAnLi4vcGxhdGZvcm0vaW1hZ2UtZW5jb2RlcnMv c2tpYScsCiAgICAgICAnLi4vcGxhdGZvcm0vbGV2ZWxkYicsCisgICAgICAnLi4vcGxhdGZvcm0v bWVkaWFzdHJlYW0nLAogICAgICAgJy4uL3BsYXRmb3JtL21vY2snLAogICAgICAgJy4uL3BsYXRm b3JtL25ldHdvcmsnLAogICAgICAgJy4uL3BsYXRmb3JtL25ldHdvcmsvY2hyb21pdW0nLApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS5neXBpCmluZGV4IDFkYjAwMTIuLjQ4Nzk0ZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTgx MCw2ICs4MTAsMTEgQEAKICAgICAgICAgICAgICdwbGF0Zm9ybS9tYWMvV2ViQ29yZVN5c3RlbUlu dGVyZmFjZS5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9tYWMvV2ViQ29yZVZpZXcuaCcsCiAg ICAgICAgICAgICAncGxhdGZvcm0vbWFjL1dlYkZvbnRDYWNoZS5oJywKKyAgICAgICAgICAgICdw bGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbXBvbmVudC5oJywKKyAgICAgICAgICAg ICdwbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbURlc2NyaXB0b3IuaCcsCisgICAgICAg ICAgICAncGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Tb3VyY2UuaCcsCisgICAgICAg ICAgICAncGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRsZXIuY3BwJywKKyAgICAgICAgICAg ICdwbGF0Zm9ybS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5oJywKICAgICAgICAgICAgICdwbGF0 Zm9ybS9tb2NrL0RldmljZU9yaWVudGF0aW9uQ2xpZW50TW9jay5oJywKICAgICAgICAgICAgICdw bGF0Zm9ybS9tb2NrL0dlb2xvY2F0aW9uQ2xpZW50TW9jay5oJywKICAgICAgICAgICAgICdwbGF0 Zm9ybS9uZXR3b3JrL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlQmFzZS5oJywKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29tcG9uZW50 LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbXBv bmVudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4YjFhNjIKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tZWRpYXN0cmVhbS9NZWRpYVN0 cmVhbUNvbXBvbmVudC5oCkBAIC0wLDAgKzEsNjcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4K KyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMg Y29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMg cHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBNZWRpYVN0cmVh bUNvbXBvbmVudF9oCisjZGVmaW5lIE1lZGlhU3RyZWFtQ29tcG9uZW50X2gKKworI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJNZWRpYVN0cmVhbVNvdXJjZS5oIgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIE1lZGlhU3RyZWFtQ29tcG9uZW50IDogcHVibGljIFJl ZkNvdW50ZWQ8TWVkaWFTdHJlYW1Db21wb25lbnQ+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c1JlZlB0cjxNZWRpYVN0cmVhbUNvbXBvbmVudD4gY3JlYXRlKFBhc3NSZWZQdHI8TWVkaWFTdHJl YW1Tb3VyY2U+IHNvdXJjZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgTWVk aWFTdHJlYW1Db21wb25lbnQoc291cmNlKSk7CisgICAgfQorCisgICAgTWVkaWFTdHJlYW1Tb3Vy Y2UqIHNvdXJjZSgpIGNvbnN0IHsgcmV0dXJuIG1fc291cmNlLmdldCgpOyB9CisKKyAgICBib29s IGVuYWJsZWQoKSBjb25zdCB7IHJldHVybiBtX2VuYWJsZWQ7IH0KKyAgICB2b2lkIHNldEVuYWJs ZWQoYm9vbCBlbmFibGVkKSB7IG1fZW5hYmxlZCA9IGVuYWJsZWQ7IH0KKworcHJpdmF0ZToKKyAg ICBNZWRpYVN0cmVhbUNvbXBvbmVudChQYXNzUmVmUHRyPE1lZGlhU3RyZWFtU291cmNlPiBzb3Vy Y2UpCisgICAgICAgIDogbV9zb3VyY2Uoc291cmNlKQorICAgICAgICAsIG1fZW5hYmxlZCh0cnVl KQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8TWVkaWFTdHJlYW1Tb3VyY2U+IG1fc291cmNl OworICAgIGJvb2wgbV9lbmFibGVkOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisj ZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIE1lZGlhU3RyZWFtQ29t cG9uZW50X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFt L01lZGlhU3RyZWFtRGVzY3JpcHRvci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFz dHJlYW0vTWVkaWFTdHJlYW1EZXNjcmlwdG9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uNWQ3NTlmZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRGVzY3JpcHRvci5oCkBAIC0wLDAgKzEsODQgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGlu IHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nz b24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0 byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNv ZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBD T05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxB UiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hU CisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2lmbmRlZiBNZWRpYVN0cmVhbURlc2NyaXB0b3JfaAorI2RlZmluZSBNZWRpYVN0cmVh bURlc2NyaXB0b3JfaAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIk1l ZGlhU3RyZWFtQ29tcG9uZW50LmgiCisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKyNpbmNs dWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgTWVkaWFT dHJlYW07CisKK2NsYXNzIE1lZGlhU3RyZWFtRGVzY3JpcHRvciA6IHB1YmxpYyBSZWZDb3VudGVk PE1lZGlhU3RyZWFtRGVzY3JpcHRvcj4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRy PE1lZGlhU3RyZWFtRGVzY3JpcHRvcj4gY3JlYXRlKGNvbnN0IFN0cmluZyYgbGFiZWwsIGNvbnN0 IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQorICAgIHsKKyAgICAgICAgcmV0dXJu IGFkb3B0UmVmKG5ldyBNZWRpYVN0cmVhbURlc2NyaXB0b3IobGFiZWwsIHNvdXJjZXMpKTsKKyAg ICB9CisKKyAgICBNZWRpYVN0cmVhbSogb3duZXIoKSBjb25zdCB7IHJldHVybiBtX293bmVyOyB9 CisgICAgdm9pZCBzZXRPd25lcihNZWRpYVN0cmVhbSogb3duZXIpIHsgbV9vd25lciA9IG93bmVy OyB9CisKKyAgICBTdHJpbmcgbGFiZWwoKSBjb25zdCB7IHJldHVybiBtX2xhYmVsOyB9CisKKyAg ICBNZWRpYVN0cmVhbUNvbXBvbmVudCogY29tcG9uZW50KHVuc2lnbmVkIGluZGV4KSBjb25zdCB7 IHJldHVybiBtX2NvbXBvbmVudHNbaW5kZXhdLmdldCgpOyB9CisgICAgdW5zaWduZWQgbnVtYmVy T2ZDb21wb25lbnRzKCkgY29uc3QgeyByZXR1cm4gbV9jb21wb25lbnRzLnNpemUoKTsgfQorCisg ICAgYm9vbCBlbmRlZCgpIGNvbnN0IHsgcmV0dXJuIG1fZW5kZWQ7IH0KKyAgICB2b2lkIHNldEVu ZGVkKCkgeyBtX2VuZGVkID0gdHJ1ZTsgfQorCitwcml2YXRlOgorICAgIE1lZGlhU3RyZWFtRGVz Y3JpcHRvcihjb25zdCBTdHJpbmcmIGxhYmVsLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3Rv ciYgc291cmNlcykKKyAgICAgICAgOiBtX293bmVyKDApCisgICAgICAgICwgbV9sYWJlbChsYWJl bCkKKyAgICAgICAgLCBtX2VuZGVkKGZhbHNlKQorICAgIHsKKyAgICAgICAgZm9yIChzaXplX3Qg aSA9IDA7IGkgPCBzb3VyY2VzLnNpemUoKTsgaSsrKQorICAgICAgICAgICAgbV9jb21wb25lbnRz LmFwcGVuZChNZWRpYVN0cmVhbUNvbXBvbmVudDo6Y3JlYXRlKHNvdXJjZXNbaV0pKTsKKyAgICB9 CisKKyAgICBNZWRpYVN0cmVhbSogbV9vd25lcjsKKyAgICBTdHJpbmcgbV9sYWJlbDsKKyAgICBW ZWN0b3I8UmVmUHRyPE1lZGlhU3RyZWFtQ29tcG9uZW50PiA+IG1fY29tcG9uZW50czsKKyAgICBi b29sIG1fZW5kZWQ7Cit9OworCit0eXBlZGVmIFZlY3RvcjxSZWZQdHI8TWVkaWFTdHJlYW1EZXNj cmlwdG9yPiA+IE1lZGlhU3RyZWFtRGVzY3JpcHRvclZlY3RvcjsKKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIE1l ZGlhU3RyZWFtRGVzY3JpcHRvcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbVNvdXJjZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Tb3VyY2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi43NjM0ZTQwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Tb3VyY2UuaApAQCAtMCwwICsxLDgyIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBp biB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNz c29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgTWVkaWFTdHJlYW1Tb3VyY2VfaAorI2RlZmluZSBNZWRpYVN0cmVhbVNv dXJjZV9oCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiUGxhdGZvcm1T dHJpbmcuaCIKKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBNZWRpYVN0cmVhbVNvdXJjZSA6 IHB1YmxpYyBSZWZDb3VudGVkPE1lZGlhU3RyZWFtU291cmNlPiB7CitwdWJsaWM6CisgICAgZW51 bSBUeXBlIHsKKyAgICAgICAgVHlwZUF1ZGlvLAorICAgICAgICBUeXBlVmlkZW8KKyAgICB9Owor CisgICAgc3RhdGljIFBhc3NSZWZQdHI8TWVkaWFTdHJlYW1Tb3VyY2U+IGNyZWF0ZShjb25zdCBT dHJpbmcmIGlkLCBUeXBlIHR5cGUsIGNvbnN0IFN0cmluZyYgbmFtZSkKKyAgICB7CisgICAgICAg IHJldHVybiBhZG9wdFJlZihuZXcgTWVkaWFTdHJlYW1Tb3VyY2UoaWQsIHR5cGUsIG5hbWUpKTsK KyAgICB9CisKKyAgICBjb25zdCBTdHJpbmcmIGlkKCkgY29uc3QgeyByZXR1cm4gbV9pZDsgfQor ICAgIFR5cGUgdHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZTsgfQorICAgIGNvbnN0IFN0cmlu ZyYgbmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fbmFtZTsgfQorCisgICAgYm9vbCBtdXRlZCgpIGNv bnN0IHsgcmV0dXJuIG1fbXV0ZWQ7IH0KKyAgICB2b2lkIHNldE11dGVkKGJvb2wgbXV0ZWQpIHsg bV9tdXRlZCA9IG11dGVkOyB9CisKK3ByaXZhdGU6CisgICAgTWVkaWFTdHJlYW1Tb3VyY2UoY29u c3QgU3RyaW5nJiBpZCwgVHlwZSB0eXBlLCBjb25zdCBTdHJpbmcmIG5hbWUpCisgICAgICAgIDog bV9pZChpZCkKKyAgICAgICAgLCBtX3R5cGUodHlwZSkKKyAgICAgICAgLCBtX25hbWUobmFtZSkK KyAgICAgICAgLCBtX211dGVkKGZhbHNlKQorICAgIHsKKyAgICB9CisKKyAgICBTdHJpbmcgbV9p ZDsKKyAgICBUeXBlIG1fdHlwZTsKKyAgICBTdHJpbmcgbV9uYW1lOworICAgIGJvb2wgbV9tdXRl ZDsKK307CisKK3R5cGVkZWYgVmVjdG9yPFJlZlB0cjxNZWRpYVN0cmVhbVNvdXJjZT4gPiBNZWRp YVN0cmVhbVNvdXJjZVZlY3RvcjsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYg Ly8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIE1lZGlhU3RyZWFtU291cmNlX2gK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5k bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtL1BlZXJIYW5kbGVy LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zOTFjOGFhCi0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vUGVlckhhbmRs ZXIuY3BwCkBAIC0wLDAgKzEsNzUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nz b24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5l aXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0 b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYg RU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIlBlZXJIYW5kbGVyLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworLy8gRklYTUU6IHJlbW92ZSB3aGVuIHJlYWwgaW1wbGVtZW50YXRp b25zIGFyZSBhdmFpbGFibGUKKy8vIEVtcHR5IGltcGxlbWVudGF0aW9ucyBmb3IgcG9ydHMgdGhh dCBidWlsZCB3aXRoIE1FRElBX1NUUkVBTSBlbmFibGVkIGJ5IGRlZmF1bHQuCitQZWVySGFuZGxl cjo6UGVlckhhbmRsZXIoUGVlckhhbmRsZXJDbGllbnQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBT dHJpbmcmKQoreworfQorCitQZWVySGFuZGxlcjo6flBlZXJIYW5kbGVyKCkKK3sKK30KKwordm9p ZCBQZWVySGFuZGxlcjo6cHJvZHVjZUluaXRpYWxPZmZlcihjb25zdCBNZWRpYVN0cmVhbURlc2Ny aXB0b3JWZWN0b3ImKQoreworfQorCit2b2lkIFBlZXJIYW5kbGVyOjpoYW5kbGVJbml0aWFsT2Zm ZXIoY29uc3QgU3RyaW5nJikKK3sKK30KKwordm9pZCBQZWVySGFuZGxlcjo6cHJvY2Vzc1NEUChj b25zdCBTdHJpbmcmKQoreworfQorCit2b2lkIFBlZXJIYW5kbGVyOjpwcm9jZXNzUGVuZGluZ1N0 cmVhbXMoY29uc3QgTWVkaWFTdHJlYW1EZXNjcmlwdG9yVmVjdG9yJiwgY29uc3QgTWVkaWFTdHJl YW1EZXNjcmlwdG9yVmVjdG9yJikKK3sKK30KKwordm9pZCBQZWVySGFuZGxlcjo6c2VuZERhdGFT dHJlYW1NZXNzYWdlKGNvbnN0IGNoYXIqLCB1bnNpZ25lZCkKK3sKK30KKwordm9pZCBQZWVySGFu ZGxlcjo6c3RvcCgpCit7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tZWRpYXN0cmVhbS9QZWVySGFuZGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVk aWFzdHJlYW0vUGVlckhhbmRsZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5jNjE0ZWRmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWVk aWFzdHJlYW0vUGVlckhhbmRsZXIuaApAQCAtMCwwICsxLDgyIEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0aGUgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiAgICBkaXN0cmli dXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0aGUgbmFtZXMg b2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9t b3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgUGVl ckhhbmRsZXJfaAorI2RlZmluZSBQZWVySGFuZGxlcl9oCisKKyNpZiBFTkFCTEUoTUVESUFfU1RS RUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1EZXNjcmlwdG9yLmgiCisjaW5jbHVkZSA8d3Rm L093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bh c3NSZWZQdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBQZWVySGFuZGxlckNs aWVudCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB+UGVlckhhbmRsZXJDbGllbnQoKSB7IH0KKwor ICAgIHZpcnR1YWwgdm9pZCBpY2VQcm9jZXNzaW5nQ29tcGxldGVkKCkgPSAwOworICAgIHZpcnR1 YWwgdm9pZCBzZHBHZW5lcmF0ZWQoY29uc3QgU3RyaW5nJiBzZHApID0gMDsKKyAgICB2aXJ0dWFs IHZvaWQgZGF0YVN0cmVhbU1lc3NhZ2VSZWNlaXZlZChjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25l ZCBsZW5ndGgpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3RlU3RyZWFtQWRkZWQoUGFzc1Jl ZlB0cjxNZWRpYVN0cmVhbURlc2NyaXB0b3I+KSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHJlbW90 ZVN0cmVhbVJlbW92ZWQoTWVkaWFTdHJlYW1EZXNjcmlwdG9yKikgPSAwOworfTsKKworY2xhc3Mg UGVlckhhbmRsZXIgeworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFBlZXJIYW5kbGVyKTsKKyAg ICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0 cjxQZWVySGFuZGxlcj4gY3JlYXRlKFBlZXJIYW5kbGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0 cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3QgU3RyaW5nJiB1c2VybmFtZSkKKyAgICB7 CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgUGVlckhhbmRsZXIoY2xpZW50LCBzZXJ2ZXJD b25maWd1cmF0aW9uLCB1c2VybmFtZSkpOworICAgIH0KKyAgICB2aXJ0dWFsIH5QZWVySGFuZGxl cigpOworCisgICAgdm9pZCBwcm9kdWNlSW5pdGlhbE9mZmVyKGNvbnN0IE1lZGlhU3RyZWFtRGVz Y3JpcHRvclZlY3RvciYgcGVuZGluZ0FkZFN0cmVhbXMpOworICAgIHZvaWQgaGFuZGxlSW5pdGlh bE9mZmVyKGNvbnN0IFN0cmluZyYgc2RwKTsKKyAgICB2b2lkIHByb2Nlc3NTRFAoY29uc3QgU3Ry aW5nJiBzZHApOworICAgIHZvaWQgcHJvY2Vzc1BlbmRpbmdTdHJlYW1zKGNvbnN0IE1lZGlhU3Ry ZWFtRGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ0FkZFN0cmVhbXMsIGNvbnN0IE1lZGlhU3RyZWFt RGVzY3JpcHRvclZlY3RvciYgcGVuZGluZ1JlbW92ZVN0cmVhbXMpOworICAgIHZvaWQgc2VuZERh dGFTdHJlYW1NZXNzYWdlKGNvbnN0IGNoYXIqIGRhdGEsIHVuc2lnbmVkIGxlbmd0aCk7CisKKyAg ICB2b2lkIHN0b3AoKTsKKworcHJpdmF0ZToKKyAgICBQZWVySGFuZGxlcihQZWVySGFuZGxlckNs aWVudCosIGNvbnN0IFN0cmluZyYgc2VydmVyQ29uZmlndXJhdGlvbiwgY29uc3QgU3RyaW5nJiB1 c2VybmFtZSk7CisKKyAgICBQZWVySGFuZGxlckNsaWVudCogbV9jbGllbnQ7Cit9OworCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisj ZW5kaWYgLy8gUGVlckhhbmRsZXJfaAo=