70897 2011-10-26 02:46:43 -0700 Use a simple page client for user consent in getUserMedia() 2011-11-16 19:51:21 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 56459 71678 0 adam.bergkvist webkit-unassigned abarth dglazkov donggwan.kim grunell harald kpe per-erik.brodin s.choi s.choi tommyw webkit.review.bot oldest_to_newest 490704 0 adam.bergkvist 2011-10-26 02:46:43 -0700 The client should only be used for user consent when there are platform interfaces to do the low-level platform specific calls. 491468 1 tommyw 2011-10-27 05:08:13 -0700 Hmm, I am not 100% certain what you mean here. So this would be optional? In Chromium we definitely doesn't want a separate user content dialog since we will combine getting user consent with audio/video device selection. (In reply to comment #0) > The client should only be used for user consent when there are platform interfaces to do the low-level platform specific calls. 491472 2 adam.bergkvist 2011-10-27 05:15:06 -0700 (In reply to comment #1) > In Chromium we definitely doesn't want a separate user content dialog since we will combine getting user consent with audio/video device selection. That's how we do it as well. Selecting a device implies giving consent. 493802 3 113144 adam.bergkvist 2011-11-01 02:17:08 -0700 Created attachment 113144 Proposed patch 493804 4 113144 webkit.review.bot 2011-11-01 02:28:26 -0700 Comment on attachment 113144 Proposed patch Attachment 113144 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/10250177 493856 5 113144 tommyw 2011-11-01 05:28:07 -0700 Comment on attachment 113144 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > Source/WebCore/WebCore.gypi:2907 > + 'mediastream/UserMediaClient.h", " -> ' 493862 6 113144 tommyw 2011-11-01 05:56:08 -0700 Comment on attachment 113144 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > Source/WebCore/mediastream/UserMediaController.cpp:36 > + Need #include "DOMWindow.h" as well. 493893 7 113144 tommyw 2011-11-01 07:23:13 -0700 Comment on attachment 113144 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > Source/WebCore/mediastream/UserMediaController.h:50 > +class UserMediaQueryClient { One class per file > Source/WebCore/mediastream/UserMediaController.h:58 > +class UserMediaRequest : public RefCounted<UserMediaRequest> { One class per file 493894 8 tommyw 2011-11-01 07:27:07 -0700 Could you remove the user consent query functionality from this patch? It complicates the patch and nobody (at least that I know of) is going to use it. 493938 9 113144 abarth 2011-11-01 09:25:46 -0700 Comment on attachment 113144 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > Source/WebCore/mediastream/UserMediaClient.h:36 > +#include "PlatformString.h" Please include <wtf/WTFString.h>, which is the new name for PlatformString.h. > Source/WebCore/mediastream/UserMediaClient.h:47 > + virtual void requestUserMedia(const UserMediaRequest*) = 0; > + virtual void cancelUserMediaRequest(const UserMediaRequest*) = 0; > + We don't really use const pointers in parameters. They're kind of meaningless. > Source/WebCore/mediastream/UserMediaController.cpp:46 > +PassRefPtr<UserMediaRequest> UserMediaRequest::create(const String& options, PassRefPtr<NavigatorUserMediaSuccessCallback> successCallback, PassRefPtr<NavigatorUserMediaErrorCallback> errorCallback, Frame* frame) Should Frame be first? Usually we pass context objects like Frame as the first parameter. > Source/WebCore/mediastream/UserMediaController.cpp:63 > + , m_queryClient(0) m_queryClient ? Is there a better name we could use here? > Source/WebCore/mediastream/UserMediaController.cpp:68 > +void UserMediaRequest::parseOptions(const String& options) Does this need to be case insensitive. > Source/WebCore/mediastream/UserMediaController.cpp:73 > + for (size_t i = 0; i < optionsList.size(); i++) { ++i > Source/WebCore/mediastream/UserMediaController.cpp:98 > + m_client->userMediaControllerDestroyed(); userMediaControllerDestroyed -> willDestroyUserMedia probably. > Source/WebCore/mediastream/UserMediaController.cpp:108 > + request->setQueryClient(this); What is a query client? > Source/WebCore/mediastream/UserMediaController.cpp:134 > + DOMWindow* domWindow = request->frame()->existingDOMWindow(); > + if (!domWindow) > + return; This seems wrong. The request should hold the document as context, not the frame. This design runs the risk of delivering the response to the wrong document! > Source/WebCore/mediastream/UserMediaController.cpp:145 > + size_t i = m_requests.find(request); > + if (i != notFound) > + m_requests.remove(i); Should we assert that we're not in the middle of canceling all these requests? How it be that the request isn't found? > Source/WebCore/mediastream/UserMediaController.h:86 > + bool m_audio; > + bool m_video; > + > + bool m_cameraPreferenceUser; > + bool m_cameraPreferenceEnvironment; > + > + RefPtr<NavigatorUserMediaSuccessCallback> m_successCallback; > + RefPtr<NavigatorUserMediaErrorCallback> m_errorCallback; > + > + Frame* m_frame; > + UserMediaQueryClient* m_queryClient; These should all be private. > Source/WebCore/page/Frame.cpp:231 > #if ENABLE(MEDIA_STREAM) > - if (m_mediaStreamFrameController) > - m_mediaStreamFrameController->disconnectFrame(); > + if (m_page && m_page->userMediaController()) > + m_page->userMediaController()->cancelAllUserMediaRequestsFromFrame(this); > #endif userMediaController should be a FrameDestructionObserver rather than being explicitly understood by Frame. > Source/WebCore/page/Navigator.cpp:90 > +#if ENABLE(MEDIA_STREAM) > + if (m_frame && m_frame->page()) > + m_frame->page()->userMediaController()->cancelAllUserMediaRequestsFromFrame(m_frame); > +#endif There way too many of call points. This is likely to be very buggy. We need to figure out where the right place to cancel these requests is and do it exactly there. > Source/WebCore/page/Page.cpp:144 > +#if ENABLE(MEDIA_STREAM) > + , m_userMediaController(adoptPtr(new UserMediaController(this, pageClients.userMediaClient))) > +#endif I'm not 100% sold on a Page-level controller. Are there alternative designs? 498530 10 114178 adam.bergkvist 2011-11-08 17:01:15 -0800 Created attachment 114178 Updated patch (In reply to comment #5) > (From update of attachment 113144 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > > > Source/WebCore/WebCore.gypi:2907 > > + 'mediastream/UserMediaClient.h", > > " -> ' Fixed. (In reply to comment #6) > (From update of attachment 113144 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > > > Source/WebCore/mediastream/UserMediaController.cpp:36 > > + > > Need #include "DOMWindow.h" as well. Fixed. (In reply to comment #7) > (From update of attachment 113144 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > > > Source/WebCore/mediastream/UserMediaController.h:50 > > +class UserMediaQueryClient { > > One class per file Class removed. > > > Source/WebCore/mediastream/UserMediaController.h:58 > > +class UserMediaRequest : public RefCounted<UserMediaRequest> { > > One class per file Fixed. (In reply to comment #8) > Could you remove the user consent query functionality from this patch? It complicates the patch and nobody (at least that I know of) is going to use it. The query functionality in this patch is used to ask the platform about available media stream sources. The query results can then be presented to the user in the consent UI. (In reply to comment #9) > (From update of attachment 113144 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113144&action=review > > > Source/WebCore/mediastream/UserMediaClient.h:36 > > +#include "PlatformString.h" > > Please include <wtf/WTFString.h>, which is the new name for PlatformString.h. Fixed. > > Source/WebCore/mediastream/UserMediaClient.h:47 > > + virtual void requestUserMedia(const UserMediaRequest*) = 0; > > + virtual void cancelUserMediaRequest(const UserMediaRequest*) = 0; > > + > > We don't really use const pointers in parameters. They're kind of meaningless. Fixed. > > Source/WebCore/mediastream/UserMediaController.cpp:46 > > +PassRefPtr<UserMediaRequest> UserMediaRequest::create(const String& options, PassRefPtr<NavigatorUserMediaSuccessCallback> successCallback, PassRefPtr<NavigatorUserMediaErrorCallback> errorCallback, Frame* frame) > > Should Frame be first? Usually we pass context objects like Frame as the first parameter. Fixed. > > Source/WebCore/mediastream/UserMediaController.cpp:63 > > + , m_queryClient(0) > > m_queryClient ? Is there a better name we could use here? I've removed the UserMediaQueryClient interface so this member has been replaced. > > Source/WebCore/mediastream/UserMediaController.cpp:68 > > +void UserMediaRequest::parseOptions(const String& options) > > Does this need to be case insensitive. No, it should be case sensitive. > > Source/WebCore/mediastream/UserMediaController.cpp:73 > > + for (size_t i = 0; i < optionsList.size(); i++) { > > ++i ? > > Source/WebCore/mediastream/UserMediaController.cpp:98 > > + m_client->userMediaControllerDestroyed(); > > userMediaControllerDestroyed -> willDestroyUserMedia probably. I aligned this name with other clients (e.g. deviceMotionControllerDestroyed, dragControllerDestroyed). > > Source/WebCore/mediastream/UserMediaController.cpp:108 > > + request->setQueryClient(this); > > What is a query client? It was the client of the platform user media probing functionality; it has been removed in the updated patch. > > Source/WebCore/mediastream/UserMediaController.cpp:134 > > + DOMWindow* domWindow = request->frame()->existingDOMWindow(); > > + if (!domWindow) > > + return; > > This seems wrong. The request should hold the document as context, not the frame. This design runs the risk of delivering the response to the wrong document! True. Added a check to verify that the context is the same as when the request was made. > > Source/WebCore/mediastream/UserMediaController.cpp:145 > > + size_t i = m_requests.find(request); > > + if (i != notFound) > > + m_requests.remove(i); > > Should we assert that we're not in the middle of canceling all these requests? How it be that the request isn't found? Fixed. > > Source/WebCore/mediastream/UserMediaController.h:86 > > + bool m_audio; > > + bool m_video; > > + > > + bool m_cameraPreferenceUser; > > + bool m_cameraPreferenceEnvironment; > > + > > + RefPtr<NavigatorUserMediaSuccessCallback> m_successCallback; > > + RefPtr<NavigatorUserMediaErrorCallback> m_errorCallback; > > + > > + Frame* m_frame; > > + UserMediaQueryClient* m_queryClient; > > These should all be private. Fixed (this used to be a struct with public members and they were accidentally left public) > > Source/WebCore/page/Frame.cpp:231 > > #if ENABLE(MEDIA_STREAM) > > - if (m_mediaStreamFrameController) > > - m_mediaStreamFrameController->disconnectFrame(); > > + if (m_page && m_page->userMediaController()) > > + m_page->userMediaController()->cancelAllUserMediaRequestsFromFrame(this); > > #endif > > userMediaController should be a FrameDestructionObserver rather than being explicitly understood by Frame. Made UserMediaRequest a FrameDestructionObserver. > > Source/WebCore/page/Navigator.cpp:90 > > +#if ENABLE(MEDIA_STREAM) > > + if (m_frame && m_frame->page()) > > + m_frame->page()->userMediaController()->cancelAllUserMediaRequestsFromFrame(m_frame); > > +#endif > > There way too many of call points. This is likely to be very buggy. We need to figure out where the right place to cancel these requests is and do it exactly there. Handeled via FrameDescrutionObserver now. > > Source/WebCore/page/Page.cpp:144 > > +#if ENABLE(MEDIA_STREAM) > > + , m_userMediaController(adoptPtr(new UserMediaController(this, pageClients.userMediaClient))) > > +#endif > > I'm not 100% sold on a Page-level controller. Are there alternative designs? We could put more logic into the UserMediaRequest and skip the controller. However, it may be convenient to have the controller when we add stuff like muting of media sources from the browser chrome and similar. Btw, I seems that the bindings for getUserMedia() can be generated, except that the callbacks don't become FunctionOnly. 498671 11 114178 abarth 2011-11-08 22:56:31 -0800 Comment on attachment 114178 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=114178&action=review Below are a few nits. > Source/WebCore/mediastream/UserMediaController.cpp:90 > + DOMWindow* domWindow = request->frame()->existingDOMWindow(); > + if (!domWindow) > + return; > + > + ScriptExecutionContext* context = domWindow->scriptExecutionContext(); > + if (!context || context != request->scriptExecutionContext()) > + return; You should just get the ScriptExecutionContext from the frame without involving the DOMWindow: ScriptExecutionContext* context = request->frame()->document(); > Source/WebCore/mediastream/UserMediaRequest.cpp:57 > + , m_scriptExecutionContext(frame->existingDOMWindow()->scriptExecutionContext()) Please don't go through the DOMWindow. frame->document() should work just find here. > Source/WebCore/mediastream/UserMediaRequest.cpp:78 > + for (size_t i = 0; i < optionsList.size(); i++) { ++i > Source/WebCore/mediastream/UserMediaRequest.cpp:80 > + optionsList[i].split(" ", subOptionsList); Are you sure this is right? Usually these parsers use isHTMLSpace. Can you put a link the spec in the code? > Source/WebCore/mediastream/UserMediaRequest.cpp:82 > + if (subOptionsList[0] == "audio") This is really supposed to be case sensitive? > Source/WebCore/mediastream/UserMediaRequest.cpp:99 > + m_frame = 0; Do we need to zero out m_controller too? > Source/WebCore/mediastream/UserMediaRequest.h:82 > + ScriptExecutionContext* m_scriptExecutionContext; Does this need to be a RefPtr? 498674 12 abarth 2011-11-08 22:58:52 -0800 > > Could you remove the user consent query functionality from this patch? It complicates the patch and nobody (at least that I know of) is going to use it. > > The query functionality in this patch is used to ask the platform about available media stream sources. The query results can then be presented to the user in the consent UI. Tommy, are you happy with this response? 498747 13 114178 tommyw 2011-11-09 02:23:49 -0800 Comment on attachment 114178 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=114178&action=review > Source/WebCore/mediastream/UserMediaController.cpp:53 > + m_client->userMediaControllerDestroyed(); At this point have all outstanding requests been cancelled? Would be best, I think, to do so. >> Source/WebCore/mediastream/UserMediaRequest.cpp:78 >> + for (size_t i = 0; i < optionsList.size(); i++) { > > ++i FYI: This means that you should change your i++ to ++i. A prefix operator is generally much better than a postfix one. 498752 14 tommyw 2011-11-09 02:35:39 -0800 (In reply to comment #12) > > > Could you remove the user consent query functionality from this patch? It complicates the patch and nobody (at least that I know of) is going to use it. > > > > The query functionality in this patch is used to ask the platform about available media stream sources. The query results can then be presented to the user in the consent UI. > > Tommy, are you happy with this response? It's fine by me. I have nothing against a query interface, it just feels weird that the actual creation of the streams goes through a PageClient but the approval is supposed to go through the platform interface. My main objection was that it for this initial patch it might be better to not have a query interface for complexity reasons. Approvals/declines can just as well be handled through the userMediaRequestSucceeded/userMediaRequestFailed callbacks in the UserMediaController. 498874 15 114178 tommyw 2011-11-09 06:15:10 -0800 Comment on attachment 114178 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=114178&action=review > Source/WebCore/mediastream/UserMediaController.cpp:92 > + RefPtr<LocalMediaStream> stream = LocalMediaStream::create(context, sources); Would it be possible for the label to be provided by the embedder instead of the LocalMediaStream class? This would help us a lot! 498998 16 abarth 2011-11-09 08:35:34 -0800 > It's fine by me. I have nothing against a query interface, it just feels weird that the actual creation of the streams goes through a PageClient but the approval is supposed to go through the platform interface. Oh, I didn't understand that from the patch. That does seem backwards. Approvals should go through the Client and creation should go through the Platform. 499042 17 tommyw 2011-11-09 09:13:41 -0800 I think a design doc, flow charts or similar would be immensely helpful here and now. 499051 18 adam.bergkvist 2011-11-09 09:23:56 -0800 (In reply to comment #16) > > It's fine by me. I have nothing against a query interface, it just feels weird that the actual creation of the streams goes through a PageClient but the approval is supposed to go through the platform interface. > > Oh, I didn't understand that from the patch. That does seem backwards. Approvals should go through the Client and creation should go through the Platform. That's not how it works either. This patch leaves the approvals/declines to the implementor of the client via userMediaRequestSucceeded/userMediaRequestFailed as Tommy describes above. The query functionality is for "asking" the platform for a list of user media sources, which then can be presented in the user consent UI. This is necessary for us to access the GStreamer device probing functionality in the platform. If you don't need it, you don't have to use it. 499088 19 tommyw 2011-11-09 09:53:28 -0800 1) a JS function calls GetUserMedia which forwards the call to UserMediaController 2) The UserMediaController enumerates the available audio/video devices through the Platform interface. The devices are at this stage unopened. 3) The UserMediaController then sends the list for selection and approval from the user through the Client interface. 4) The user selects say a camera and a audio input device and thus approves the use. Have I gotten it right this time? I have been confused by the wording Query which for me sounds like "asking the user" and not "enumerating all devices". In that case the Client implementation must open the devices, otherwise we can't handle problems with device availability not show a self preview etc etc. This means that the Client implementation is going to to the bulk of the functionality and not just simply doing a policy decision. I personally is OK with this but I am bringing this up so that it won't pop up later in the process (been there, done that). 499807 20 114476 adam.bergkvist 2011-11-10 05:18:21 -0800 Created attachment 114476 Patch 3 (In reply to comment #11) > (From update of attachment 114178 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=114178&action=review > > Below are a few nits. > > > Source/WebCore/mediastream/UserMediaController.cpp:90 > > + DOMWindow* domWindow = request->frame()->existingDOMWindow(); > > + if (!domWindow) > > + return; > > + > > + ScriptExecutionContext* context = domWindow->scriptExecutionContext(); > > + if (!context || context != request->scriptExecutionContext()) > > + return; > > You should just get the ScriptExecutionContext from the frame without involving the DOMWindow: > > ScriptExecutionContext* context = request->frame()->document(); Fixed. > > Source/WebCore/mediastream/UserMediaRequest.cpp:57 > > + , m_scriptExecutionContext(frame->existingDOMWindow()->scriptExecutionContext()) > > Please don't go through the DOMWindow. frame->document() should work just find here. Fixed. > > Source/WebCore/mediastream/UserMediaRequest.cpp:78 > > + for (size_t i = 0; i < optionsList.size(); i++) { > > ++i Fixed (Perhaps this should be added to the style guidelines?) > > Source/WebCore/mediastream/UserMediaRequest.cpp:80 > > + optionsList[i].split(" ", subOptionsList); > > Are you sure this is right? Usually these parsers use isHTMLSpace. Can you put a link the spec in the code? You're right, the split was a bit naive. I use SpaceSplitString now. > > Source/WebCore/mediastream/UserMediaRequest.cpp:82 > > + if (subOptionsList[0] == "audio") > > This is really supposed to be case sensitive? Yes. "2. If the first token in list of suboptions is a case-sensitive match for the string "audio", let audio be true." > > Source/WebCore/mediastream/UserMediaRequest.cpp:99 > > + m_frame = 0; > > Do we need to zero out m_controller too? The controller is zeroed out in the call to cancelUserMediaRequset() on line before. > > Source/WebCore/mediastream/UserMediaRequest.h:82 > > + ScriptExecutionContext* m_scriptExecutionContext; > > Does this need to be a RefPtr? We only use this member to compare the pointer value with the context at the time a request succeeds or fails. (In reply to comment #13) > (From update of attachment 114178 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=114178&action=review > > > Source/WebCore/mediastream/UserMediaController.cpp:53 > > + m_client->userMediaControllerDestroyed(); > > At this point have all outstanding requests been cancelled? Would be best, I think, to do so. They should be canceled at this point. > >> Source/WebCore/mediastream/UserMediaRequest.cpp:78 > >> + for (size_t i = 0; i < optionsList.size(); i++) { > > > > ++i > > FYI: This means that you should change your i++ to ++i. A prefix operator is generally much better than a postfix one. I got that, but I was just wondering what the motivation was (it's a pure style issue in this particular case). I haven't got this comment before and there's nothing about it in the style guidelines (perhaps it should be added?). It's anyhow fixed now. (In reply to comment #19) > 1) a JS function calls GetUserMedia which forwards the call to UserMediaController > 2) The UserMediaController enumerates the available audio/video devices through the Platform interface. The devices are at this stage unopened. > 3) The UserMediaController then sends the list for selection and approval from the user through the Client interface. > 4) The user selects say a camera and a audio input device and thus approves the use. > > Have I gotten it right this time? I have been confused by the wording Query which for me sounds like "asking the user" and not "enumerating all devices". Yes, that's about it. 499810 21 tommyw 2011-11-10 05:24:38 -0800 > > >> Source/WebCore/mediastream/UserMediaRequest.cpp:78 > > >> + for (size_t i = 0; i < optionsList.size(); i++) { > > > > > > ++i > > > > FYI: This means that you should change your i++ to ++i. A prefix operator is generally much better than a postfix one. > > I got that, but I was just wondering what the motivation was (it's a pure style issue in this particular case). I haven't got this comment before and there's nothing about it in the style guidelines (perhaps it should be added?). It's anyhow fixed now. For an int etc it doesn't matter but if you have an object (like an iterator) the compiler has to clone the object if you use a postfix operator. Best all around to avoid postfix unless you really need it. 499812 22 114476 tommyw 2011-11-10 05:27:12 -0800 Comment on attachment 114476 Patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=114476&action=review > Source/WebCore/mediastream/UserMediaController.cpp:94 > +void UserMediaController::userMediaRequestSucceeded(UserMediaRequest* request, const MediaStreamSourceVector& sources) How about letting the embedder provide a label as well? Instead of letting LocalMediaStream create one. This would help at least the chromium port. 499813 23 114476 webkit.review.bot 2011-11-10 05:32:03 -0800 Comment on attachment 114476 Patch 3 Attachment 114476 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/10395309 499844 24 adam.bergkvist 2011-11-10 06:14:43 -0800 (In reply to comment #22) > (From update of attachment 114476 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=114476&action=review > > > Source/WebCore/mediastream/UserMediaController.cpp:94 > > +void UserMediaController::userMediaRequestSucceeded(UserMediaRequest* request, const MediaStreamSourceVector& sources) > > How about letting the embedder provide a label as well? Instead of letting LocalMediaStream create one. This would help at least the chromium port. I didn't think you wanted this anymore since MediaStream instances cannot be identified by the label. Why do you need it? (The label is a pure API related thing). 499918 25 tommyw 2011-11-10 08:15:21 -0800 > > > > How about letting the embedder provide a label as well? Instead of letting LocalMediaStream create one. This would help at least the chromium port. > > I didn't think you wanted this anymore since MediaStream instances cannot be identified by the label. Why do you need it? (The label is a pure API related thing). After discussions we are OK with the current patch, and we'll adjust the code accordingly. It was a request from the native library. 499948 26 114476 tommyw 2011-11-10 08:45:23 -0800 Comment on attachment 114476 Patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=114476&action=review > Source/WebCore/mediastream/UserMediaController.cpp:82 > + ASSERT(m_requests.contains(request)); This function needs to be part of UserMediaController to use m_requests > Source/WebCore/mediastream/UserMediaController.cpp:87 > + ScriptExecutionContext* context = request->frame()->document(); Need to #include "Document.h" for this to compile. > Source/WebCore/mediastream/UserMediaRequest.cpp:58 > + , m_scriptExecutionContext(frame->document()) Need to #include "Document.h" for this to compile. 499990 27 abarth 2011-11-10 09:16:43 -0800 > For an int etc it doesn't matter but if you have an object (like an iterator) the compiler has to clone the object if you use a postfix operator. Best all around to avoid postfix unless you really need it. It's totally not a big deal. I thought it was in the style guide, but I might be wrong. 500808 28 114706 adam.bergkvist 2011-11-11 08:44:01 -0800 Created attachment 114706 Patch 4 (In reply to comment #26) > (From update of attachment 114476 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=114476&action=review > > > Source/WebCore/mediastream/UserMediaController.cpp:82 > > + ASSERT(m_requests.contains(request)); > > This function needs to be part of UserMediaController to use m_requests Fixed. > > Source/WebCore/mediastream/UserMediaController.cpp:87 > > + ScriptExecutionContext* context = request->frame()->document(); > > Need to #include "Document.h" for this to compile. Fixed. > > Source/WebCore/mediastream/UserMediaRequest.cpp:58 > > + , m_scriptExecutionContext(frame->document()) > > Need to #include "Document.h" for this to compile. Fixed. 501617 29 114706 abarth 2011-11-13 22:08:08 -0800 Comment on attachment 114706 Patch 4 View in context: https://bugs.webkit.org/attachment.cgi?id=114706&action=review > Source/WebCore/mediastream/UserMediaClient.h:43 > + virtual void userMediaControllerDestroyed() = 0; On another bug, fishd had a question about this name because userMediaController is something of a WebCore-concept. It's probably better to have a more semantic name here, but that's something we can address in a follow-up patch. > Source/WebCore/mediastream/UserMediaController.cpp:64 > + m_requests.append(request); m_requests is something like m_outstandingRequests ? > Source/WebCore/mediastream/UserMediaController.cpp:88 > + ScriptExecutionContext* context = request->frame()->document(); The request should hold the document explicitly rather than via the Frame. Generally, using the Frame as the context object is dangerous because the frame persists across navigations. > Source/WebCore/mediastream/UserMediaController.cpp:89 > + if (!context || context != request->scriptExecutionContext()) I see. You check explicitly here.... This is somewhat of an error prone design. > Source/WebCore/mediastream/UserMediaController.cpp:101 > + request->successCallback()->handleEvent(stream.get()); I assume this can run arbitrary script. How do we know that |this| hasn't been destroyed? I'd remove request from m_requests before calling the success callback to avoid getting into inconsistent states. > Source/WebCore/mediastream/UserMediaController.cpp:115 > + request->errorCallback()->handleEvent(error.get()); Same comment there. > Source/WebCore/mediastream/UserMediaController.h:46 > +class UserMediaController { I don't get the point of this class. We do all this work to track the outstanding requests in m_requests, but then we never do anything with that collection. I was expecting some kind of "cancel all" operation when something got torn down, but I don't see that anywhere. > Source/WebCore/mediastream/UserMediaRequest.h:83 > + Frame* m_frame; > + ScriptExecutionContext* m_scriptExecutionContext; > + UserMediaController* m_controller; It's really strange to keep all of these context objects. Really, this object should hold only a ScriptExecutionContext and should be a ContextDestructionObserver. Moreover, it seems like UserMediaController isn't needed at all. > Source/WebCore/page/Navigator.cpp:302 > + page->userMediaController()->requestUserMedia(request.release()); IMHO, this should just talk directly to the UserMediaClient. 501618 30 abarth 2011-11-13 22:10:41 -0800 I see that previous iterations of this patch had a "cancel all" operation, but the most recent one doesn't seem to have that. 502018 31 adam.bergkvist 2011-11-14 09:49:46 -0800 > > I'm not 100% sold on a Page-level controller. Are there alternative designs? > > We could put more logic into the UserMediaRequest and skip the controller. However, it may be convenient to have the controller when we add stuff like muting of media sources from the browser chrome and similar. What's you opinion about skipping the controller as described above (from comment #10)? An other example of a client initiated action is if the browser wants to probe for devices via the platform on startup. 502047 32 abarth 2011-11-14 10:18:05 -0800 > What's you opinion about skipping the controller as described above (from comment #10)? An other example of a client initiated action is if the browser wants to probe for devices via the platform on startup. Let's skip the controller for now. We can always add it later if we need it. 504072 33 115412 adam.bergkvist 2011-11-16 11:12:52 -0800 Created attachment 115412 Patch 5 Removed the controller. 504082 34 115412 abarth 2011-11-16 11:23:42 -0800 Comment on attachment 115412 Patch 5 View in context: https://bugs.webkit.org/attachment.cgi?id=115412&action=review I think we should land this patch so we can move forward. This patch is generally very good. I have one memory-safety concern abou the lifetime of the UserMediaClient, which I've noted below, but we can address that issue in a follow-up patch. Thanks again for iterating on this patch. > Source/WebCore/mediastream/UserMediaRequest.cpp:105 > + if (m_client) { > + m_client->cancelUserMediaRequest(this); > + m_client = 0; > + } What is the lifetime of the UserMediaClient? In particular, can a document out-live the client? 504208 35 115412 webkit.review.bot 2011-11-16 13:42:20 -0800 Comment on attachment 115412 Patch 5 Attachment 115412 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/10483844 New failing tests: fast/dom/MediaStream/argument-types.html 504454 36 115493 adam.bergkvist 2011-11-16 17:37:39 -0800 Created attachment 115493 Patch 6 (In reply to comment #34) > (From update of attachment 115412 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=115412&action=review > > I think we should land this patch so we can move forward. This patch is generally very good. I have one memory-safety concern abou the lifetime of the UserMediaClient, which I've noted below, but we can address that issue in a follow-up patch. Thanks again for iterating on this patch. > > > Source/WebCore/mediastream/UserMediaRequest.cpp:105 > > + if (m_client) { > > + m_client->cancelUserMediaRequest(this); > > + m_client = 0; > > + } > > What is the lifetime of the UserMediaClient? In particular, can a document out-live the client? Yes, there is a potential lifetime problem if the document can out-live the page. Small fixes in new patch: * Removed early return on null-client in Navigator (caused test to fail; not needed since the client is checked before used). * Added functionality to be able to delete the UserMediaClient when the page is destroyed. 504462 37 115493 abarth 2011-11-16 17:45:58 -0800 Comment on attachment 115493 Patch 6 Yes, the document can live for an arbitrarily long period of time. Thanks. 504522 38 115493 webkit.review.bot 2011-11-16 19:51:12 -0800 Comment on attachment 115493 Patch 6 Clearing flags on attachment: 115493 Committed r100555: <http://trac.webkit.org/changeset/100555> 504523 39 webkit.review.bot 2011-11-16 19:51:21 -0800 All reviewed patches have been landed. Closing bug. 113144 2011-11-01 02:17:08 -0700 2011-11-08 17:01:15 -0800 Proposed patch usermedia_simple_controller_1.patch text/plain 58869 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxMzVmMTNhLi43YjE3ZmQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYg QEAKKzIwMTEtMTEtMDEgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudC9jb250cm9sbGVyIGZvciB1 c2VyIGNvbnNlbnQgaW4gZ2V0VXNlck1lZGlhKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcwODk3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBvbmUgaW4gYSBzZXJpZXMgb2YgcGF0Y2hlcyB0 aGF0IHVwZGF0ZSB0aGUgTWVkaWFTdHJlYW0gZmVhdHVyZQorICAgICAgICB0byB1c2UgV2ViQ29y ZSBwbGF0Zm9ybSBpbnRlcmZhY2VzLgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVz dHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFdlYkNvcmUu Z3lwaToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oOiBSZW1vdmVk LgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHA6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmg6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3Bw OiBSZW1vdmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyLmg6IFJlbW92ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50Lmg6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ2xpZW50Ojp+VXNlck1lZGlhQ2xp ZW50KToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUpOgorICAgICAg ICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6VXNlck1lZGlhUmVxdWVzdCk6CisgICAgICAg IChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpwYXJzZU9wdGlvbnMpOgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6VXNlck1lZGlhQ29udHJvbGxlcik6CisgICAgICAg IChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjp+VXNlck1lZGlhQ29udHJvbGxlcik6Cisg ICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpyZXF1ZXN0VXNlck1lZGlhKToK KyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OmNhbmNlbEFsbFVzZXJNZWRp YVJlcXVlc3RzRnJvbUZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xs ZXI6OnVzZXJNZWRpYVJlcXVlc3RTdWNjZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1l ZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUmVxdWVzdEZhaWxlZCk6CisgICAgICAgIChXZWJDb3Jl OjpVc2VyTWVkaWFDb250cm9sbGVyOjpxdWVyeVVzZXJNZWRpYSk6CisgICAgICAgIChXZWJDb3Jl OjpVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFRdWVyeUNvbXBsZXRlZCk6CisgICAgICAg ICogbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5oOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlVzZXJNZWRpYVF1ZXJ5Q2xpZW50Ojp+VXNlck1lZGlhUXVlcnlDbGllbnQpOgorICAg ICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6YXVkaW8pOgorICAgICAgICAoV2ViQ29y ZTo6VXNlck1lZGlhUmVxdWVzdDo6dmlkZW8pOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlh UmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZVVzZXIpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1l ZGlhUmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KToKKyAgICAgICAgKFdlYkNv cmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3Jl OjpVc2VyTWVkaWFSZXF1ZXN0OjplcnJvckNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYVJlcXVlc3Q6OmZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6OnF1ZXJ5Q2xpZW50KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnNl dFF1ZXJ5Q2xpZW50KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OmNs aWVudCk6CisgICAgICAgICogcGFnZS9DYWxsYmFja1Rhc2suaDogUmVtb3ZlZC4KKyAgICAgICAg KiBwYWdlL0ZyYW1lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjpGcmFtZSk6CisgICAg ICAgIChXZWJDb3JlOjpGcmFtZTo6fkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjpw YWdlRGVzdHJveWVkKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp0cmFuc2ZlckNoaWxkRnJh bWVUb05ld0RvY3VtZW50KToKKyAgICAgICAgKiBwYWdlL0ZyYW1lLmg6CisgICAgICAgICogcGFn ZS9OYXZpZ2F0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TmF2aWdhdG9yOjpkaXNjb25uZWN0 RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6TmF2aWdhdG9yOjp3ZWJraXRHZXRVc2VyTWVkaWEp OgorICAgICAgICAqIHBhZ2UvTmF2aWdhdG9yLmg6CisgICAgICAgICogcGFnZS9OYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrLmg6CisgICAgICAgICogcGFnZS9QYWdlLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlBhZ2U6OlBhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6UGFnZUNs aWVudHM6OlBhZ2VDbGllbnRzKToKKyAgICAgICAgKiBwYWdlL1BhZ2UuaDoKKyAgICAgICAgKFdl YkNvcmU6OlBhZ2U6OnVzZXJNZWRpYUNvbnRyb2xsZXIpOgorCiAyMDExLTEwLTMxICBBZGFtIFJv YmVuICA8YXJvYmVuQGFwcGxlLmNvbT4KIAogICAgICAgICBGaXggbGlua2VyIHdhcm5pbmdzIG9u IFdpbmRvd3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0g Yi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IGJmZTAxYzkuLjE0NDA2 NTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIv U291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMjI1NiwxMyArMjI1Niw4IEBA IHdlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTG9jYWxN ZWRpYVN0cmVhbS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbS5j cHAgXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtLmggXAotCVNvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50LmggXAotCVNvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHAgXAotCVNvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5oIFwKIAlTb3VyY2UvV2ViQ29y ZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUV2ZW50LmNwcCBcCiAJU291cmNlL1dlYkNvcmUvbWVk aWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5oIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5jcHAgXAotCVNvdXJjZS9XZWJDb3JlL21lZGlh c3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtTGlzdC5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL01lZGlhU3RyZWFtTGlzdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbVJlZ2lzdHJ5LmNwcCBcCkBAIC0yMjczLDYgKzIyNjgsOSBAQCB3ZWJjb3JlX3NvdXJj ZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtVHJhY2tMaXN0 LmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uaCBcCisJU291cmNlL1dl YkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50LmggXAorCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL1NpZ25hbGluZ0NhbGxiYWNrLmggXAogCVNvdXJjZS9XZWJDb3JlL25vdGlmaWNhdGlvbnMv Tm90aWZpY2F0aW9uQ2VudGVyLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvbm90aWZpY2F0aW9ucy9O b3RpZmljYXRpb25DZW50ZXIuaCBcCkBAIC0yMjk0LDcgKzIyOTIsNiBAQCB3ZWJjb3JlX3NvdXJj ZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQWRqdXN0Vmlld1NpemVPck5vdC5oIFwKIAlT b3VyY2UvV2ViQ29yZS9wYWdlL0JhckluZm8uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Jh ckluZm8uaCBcCi0JU291cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rhc2suaCBcCiAJU291cmNl L1dlYkNvcmUvcGFnZS9DaHJvbWUuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZS5o IFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZUNsaWVudC5oIFwKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpp bmRleCBiNjRlNmQ5Li44OGI4Y2MwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0yODkzLDExICsyODkz LDYgQEAKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbS5oJywKICAgICAgICAg ICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUV2ZW50LmNwcCcsCiAgICAgICAgICAgICAnbWVk aWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5oJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9N ZWRpYVN0cmVhbUNsaWVudC5oJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVh bUNvbnRyb2xsZXIuY3BwJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNv bnRyb2xsZXIuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNv bnRyb2xsZXIuY3BwJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1l Q29udHJvbGxlci5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3Qu Y3BwJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuaCcsCiAgICAg ICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1UcmFjay5jcHAnLApAQCAtMjkwOSw2ICsy OTA0LDkgQEAKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5jcHAnLAog ICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmgnLAogICAgICAgICAgICAg J21lZGlhc3RyZWFtL1NpZ25hbGluZ0NhbGxiYWNrLmgnLAorICAgICAgICAgICAgJ21lZGlhc3Ry ZWFtL1VzZXJNZWRpYUNsaWVudC5oIiwKKyAgICAgICAgICAgICdtZWRpYXN0cmVhbS9Vc2VyTWVk aWFDb250cm9sbGVyLmNwcCIsCisgICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29u dHJvbGxlci5oIiwKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbi5jcHAn LAogICAgICAgICAgICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uLmgnLAogICAgICAgICAg ICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ2VudGVyLmNwcCcsCkBAIC0yOTE2LDcgKzI5 MTQsNiBAQAogICAgICAgICAgICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ29udGVudHMu aCcsCiAgICAgICAgICAgICAncGFnZS9CYXJJbmZvLmNwcCcsCiAgICAgICAgICAgICAncGFnZS9C YXJJbmZvLmgnLAotICAgICAgICAgICAgJ3BhZ2UvQ2FsbGJhY2tUYXNrLmgnLAogICAgICAgICAg ICAgJ3BhZ2UvQ2hyb21lLmNwcCcsCiAgICAgICAgICAgICAncGFnZS9Db25zb2xlLmNwcCcsCiAg ICAgICAgICAgICAncGFnZS9Db250ZW50U2VjdXJpdHlQb2xpY3kuY3BwJywKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oCmRlbGV0ZWQgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCBhZjkwOTVjLi4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL21lZGlh c3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50LmgKKysrIC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBA Ci0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAg UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0g KiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQot ICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElT Ci0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtQ2xpZW50X2gKLSNkZWZpbmUgTWVk aWFTdHJlYW1DbGllbnRfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUg PHd0Zi9Gb3J3YXJkLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgU2VjdXJpdHlP cmlnaW47Ci0KLWVudW0gR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFnIHsKLSAgICBHZW5lcmF0ZVN0 cmVhbVJlcXVlc3RBdWRpbyA9IDEsCi0gICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNp bmdVc2VyID0gMSA8PCAxLAotICAgIEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nRW52 aXJvbm1lbnQgPSAxIDw8IDIsCi19OwotCi10eXBlZGVmIHVuc2lnbmVkIEdlbmVyYXRlU3RyZWFt T3B0aW9uRmxhZ3M7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ2xpZW50IHsKLXB1YmxpYzoKLSAgICAv LyBNZWRpYVN0cmVhbSBmdW5jdGlvbnMuCi0gICAgdmlydHVhbCB2b2lkIG1lZGlhU3RyZWFtRGVz dHJveWVkKCkgPSAwOwotICAgIHZpcnR1YWwgdm9pZCBnZW5lcmF0ZVN0cmVhbShpbnQgcmVxdWVz dElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2lu PikgPSAwOwotCi1wcm90ZWN0ZWQ6Ci0gICAgdmlydHVhbCB+TWVkaWFTdHJlYW1DbGllbnQoKSB7 IH0KLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVOQUJMRShNRURJ QV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBNZWRpYVN0cmVhbUNsaWVudF9oCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNwcApkZWxldGVk IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDRlMzA4ZS4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwCisrKyAvZGV2L251bGwK QEAgLTEsMTIzICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycg QU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAotICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNp bmNsdWRlICJNZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCIKLQotI2lmIEVOQUJMRShNRURJQV9TVFJF QU0pCi0KLSNpbmNsdWRlICJNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIgotI2luY2x1ZGUg IlNlY3VyaXR5T3JpZ2luLmgiCi0jaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgotCi1uYW1lc3BhY2Ug V2ViQ29yZSB7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6UmVxdWVzdCB7Ci1wdWJs aWM6Ci0gICAgUmVxdWVzdCgpCi0gICAgICAgIDogbV9sb2NhbElkKDApCi0gICAgICAgICwgbV9m cmFtZUNvbnRyb2xsZXIoMCkgeyB9Ci0KLSAgICBSZXF1ZXN0KGludCBsb2NhbElkLCBNZWRpYVN0 cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKQotICAgICAgICA6IG1fbG9jYWxJ ZChsb2NhbElkKQotICAgICAgICAsIG1fZnJhbWVDb250cm9sbGVyKGZyYW1lQ29udHJvbGxlcikg eyB9Ci0KLSAgICBpbnQgbG9jYWxJZCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxJZDsgfQotICAg IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNvbnRyb2xsZXIoKSBjb25zdCB7IHJl dHVybiBtX2ZyYW1lQ29udHJvbGxlcjsgfQotCi1wcml2YXRlOgotICAgIGludCBtX2xvY2FsSWQ7 Ci0gICAgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIG1fZnJhbWVDb250cm9sbGVyOwotfTsK LQotTWVkaWFTdHJlYW1Db250cm9sbGVyOjpNZWRpYVN0cmVhbUNvbnRyb2xsZXIoTWVkaWFTdHJl YW1DbGllbnQqIGNsaWVudCkKLSAgICA6IG1fY2xpZW50KGNsaWVudCkKLSAgICAsIG1fbmV4dEds b2JhbFJlcXVlc3RJZCgxKQotewotfQotCi1NZWRpYVN0cmVhbUNvbnRyb2xsZXI6On5NZWRpYVN0 cmVhbUNvbnRyb2xsZXIoKQotewotICAgIGlmIChtX2NsaWVudCkKLSAgICAgICAgbV9jbGllbnQt Pm1lZGlhU3RyZWFtRGVzdHJveWVkKCk7Ci19Ci0KLWJvb2wgTWVkaWFTdHJlYW1Db250cm9sbGVy Ojppc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fY2xpZW50OwotfQot Ci12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6dW5yZWdpc3RlckZyYW1lQ29udHJvbGxlcihN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKQotewotICAgIEFTU0VS VChmcmFtZUNvbnRyb2xsZXIpOwotCi0gICAgLy8gRG9uZSBpbiB0d28gc3RlcHMgdG8gYXZvaWQg cHJvYmxlbXMgYWJvdXQgaXRlcmF0b3JzIGJlaW5nIGludmFsaWRhdGVkIHdoaWxlIHJlbW92aW5n LgotICAgIFZlY3RvcjxpbnQ+IGZyYW1lUmVxdWVzdHM7Ci0gICAgZm9yIChSZXF1ZXN0TWFwOjpp dGVyYXRvciBpdCA9IG1fcmVxdWVzdHMuYmVnaW4oKTsgaXQgIT0gbV9yZXF1ZXN0cy5lbmQoKTsg KytpdCkKLSAgICAgICAgaWYgKGl0LT5zZWNvbmQuZnJhbWVDb250cm9sbGVyKCkgPT0gZnJhbWVD b250cm9sbGVyKQotICAgICAgICAgICAgZnJhbWVSZXF1ZXN0cy5hcHBlbmQoaXQtPmZpcnN0KTsK LQotICAgIGZvciAoVmVjdG9yPGludD46Oml0ZXJhdG9yIGl0ID0gZnJhbWVSZXF1ZXN0cy5iZWdp bigpOyBpdCAhPSBmcmFtZVJlcXVlc3RzLmVuZCgpOyArK2l0KQotICAgICAgICBtX3JlcXVlc3Rz LnJlbW92ZSgqaXQpOwotfQotCi1pbnQgTWVkaWFTdHJlYW1Db250cm9sbGVyOjpyZWdpc3RlclJl cXVlc3QoaW50IGxvY2FsSWQsIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNvbnRy b2xsZXIpCi17Ci0gICAgQVNTRVJUKGxvY2FsSWQgPiAwKTsKLSAgICBBU1NFUlQoZnJhbWVDb250 cm9sbGVyKTsKLSAgICBtX3JlcXVlc3RzLmFkZChtX25leHRHbG9iYWxSZXF1ZXN0SWQsIFJlcXVl c3QobG9jYWxJZCwgZnJhbWVDb250cm9sbGVyKSk7Ci0gICAgcmV0dXJuIG1fbmV4dEdsb2JhbFJl cXVlc3RJZCsrOwotfQotCi12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6Z2VuZXJhdGVTdHJl YW0oTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlciwgaW50IGxvY2Fs SWQsIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MsIFBhc3NSZWZQdHI8U2VjdXJpdHlP cmlnaW4+IHNlY3VyaXR5T3JpZ2luKQotewotICAgIEFTU0VSVChtX2NsaWVudCk7Ci0gICAgaW50 IGNvbnRyb2xsZXJSZXF1ZXN0SWQgPSByZWdpc3RlclJlcXVlc3QobG9jYWxJZCwgZnJhbWVDb250 cm9sbGVyKTsKLSAgICBtX2NsaWVudC0+Z2VuZXJhdGVTdHJlYW0oY29udHJvbGxlclJlcXVlc3RJ ZCwgZmxhZ3MsIHNlY3VyaXR5T3JpZ2luKTsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xs ZXI6OnN0cmVhbUdlbmVyYXRlZChpbnQgY29udHJvbGxlclJlcXVlc3RJZCwgY29uc3QgTWVkaWFT dHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCi17Ci0gICAgLy8gRG9uJ3QgYXNzZXJ0IHNpbmNl IHRoZSBmcmFtZSBjb250cm9sbGVyIGNhbiBoYXZlIGJlZW4gZGVzdHJveWVkIHdoaWxlIHRoZSBy ZXF1ZXN0IHJlcGx5IHdhcyBjb21pbmcgYmFjay4KLSAgICBpZiAobV9yZXF1ZXN0cy5jb250YWlu cyhjb250cm9sbGVyUmVxdWVzdElkKSkgewotICAgICAgICBjb25zdCBSZXF1ZXN0JiByZXF1ZXN0 ID0gbV9yZXF1ZXN0cy5nZXQoY29udHJvbGxlclJlcXVlc3RJZCk7Ci0gICAgICAgIG1fcmVxdWVz dHMucmVtb3ZlKGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAgICAgICBBU1NFUlQocmVxdWVzdC5m cmFtZUNvbnRyb2xsZXIoKSk7Ci0gICAgICAgIHJlcXVlc3QuZnJhbWVDb250cm9sbGVyKCktPnN0 cmVhbUdlbmVyYXRlZChyZXF1ZXN0LmxvY2FsSWQoKSwgc291cmNlcyk7Ci0gICAgfQotfQotCi12 b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGlvbkZhaWxlZChpbnQgY29u dHJvbGxlclJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OkVycm9yQ29kZSBjb2Rl KQotewotICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgZnJhbWUgY29udHJvbGxlciBjYW4g aGF2ZSBiZWVuIGRlc3Ryb3llZCB3aGlsZSB0aGUgcmVxdWVzdCByZXBseSB3YXMgY29taW5nIGJh Y2suCi0gICAgaWYgKG1fcmVxdWVzdHMuY29udGFpbnMoY29udHJvbGxlclJlcXVlc3RJZCkpIHsK LSAgICAgICAgY29uc3QgUmVxdWVzdCYgcmVxdWVzdCA9IG1fcmVxdWVzdHMuZ2V0KGNvbnRyb2xs ZXJSZXF1ZXN0SWQpOwotICAgICAgICBtX3JlcXVlc3RzLnJlbW92ZShjb250cm9sbGVyUmVxdWVz dElkKTsKLSAgICAgICAgcmVxdWVzdC5mcmFtZUNvbnRyb2xsZXIoKS0+c3RyZWFtR2VuZXJhdGlv bkZhaWxlZChyZXF1ZXN0LmxvY2FsSWQoKSwgY29kZSk7Ci0gICAgfQotfQotCi19IC8vIG5hbWVz cGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmggYi9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaApkZWxldGVk IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDg5MzA5NC4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaAorKysgL2Rldi9udWxsCkBA IC0xLDc0ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJl IG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5E IEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAotICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpZm5kZWYgTWVkaWFTdHJlYW1Db250cm9s bGVyX2gKLSNkZWZpbmUgTWVkaWFTdHJlYW1Db250cm9sbGVyX2gKLQotI2lmIEVOQUJMRShNRURJ QV9TVFJFQU0pCi0KLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNsaWVudC5oIgotI2luY2x1ZGUgIk1l ZGlhU3RyZWFtU291cmNlLmgiCi0jaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIK LSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+Ci0jaW5j bHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5o PgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ2xpZW50OwotY2xh c3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI7Ci1jbGFzcyBTZWN1cml0eU9yaWdpbjsKLQot Y2xhc3MgTWVkaWFTdHJlYW1Db250cm9sbGVyIHsKLSAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShN ZWRpYVN0cmVhbUNvbnRyb2xsZXIpOwotcHVibGljOgotICAgIE1lZGlhU3RyZWFtQ29udHJvbGxl cihNZWRpYVN0cmVhbUNsaWVudCopOwotICAgIHZpcnR1YWwgfk1lZGlhU3RyZWFtQ29udHJvbGxl cigpOwotCi0gICAgYm9vbCBpc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0OwotICAgIHZvaWQgdW5y ZWdpc3RlckZyYW1lQ29udHJvbGxlcihNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciopOwotCi0g ICAgdm9pZCBnZW5lcmF0ZVN0cmVhbShNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciosIGludCBy ZXF1ZXN0SWQsIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MsIFBhc3NSZWZQdHI8U2VjdXJpdHlP cmlnaW4+KTsKLQotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGVkKGludCByZXF1ZXN0SWQsIGNvbnN0 IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKTsKLSAgICB2b2lkIHN0cmVhbUdlbmVy YXRpb25GYWlsZWQoaW50IHJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OkVycm9y Q29kZSk7Ci0KLXByaXZhdGU6Ci0gICAgaW50IHJlZ2lzdGVyUmVxdWVzdChpbnQgbG9jYWxSZXF1 ZXN0SWQsIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKik7Ci0KLSAgICBjbGFzcyBSZXF1ZXN0 OwotICAgIHR5cGVkZWYgSGFzaE1hcDxpbnQsIFJlcXVlc3Q+IFJlcXVlc3RNYXA7Ci0KLSAgICBS ZXF1ZXN0TWFwIG1fcmVxdWVzdHM7Ci0KLSAgICBNZWRpYVN0cmVhbUNsaWVudCogbV9jbGllbnQ7 Ci0gICAgaW50IG1fbmV4dEdsb2JhbFJlcXVlc3RJZDsKLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKLQotI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBNZWRp YVN0cmVhbUNvbnRyb2xsZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJl YW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbWVkaWFz dHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEw MDY0NAppbmRleCBhM2ExOGNiLi4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDI4 MiArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6 Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkK LSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAq IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAi TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0p Ci0KLSNpbmNsdWRlICJET01XaW5kb3cuaCIKLSNpbmNsdWRlICJEb2N1bWVudC5oIgotI2luY2x1 ZGUgIkZyYW1lLmgiCi0jaW5jbHVkZSAiTG9jYWxNZWRpYVN0cmVhbS5oIgotI2luY2x1ZGUgIk1l ZGlhU3RyZWFtQ29udHJvbGxlci5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9y Q2FsbGJhY2suaCIKLSNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2su aCIKLSNpbmNsdWRlICJQYWdlLmgiCi0jaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKLSNpbmNs dWRlIDx3dGYvUmVmQ291bnRlZC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIE1l ZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0IDogcHVibGljIFJlZkNvdW50ZWQ8UmVx dWVzdD4gewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFJlcXVlc3QpOwotcHVibGljOgotICAg IHZpcnR1YWwgflJlcXVlc3QoKSB7IH0KLQotICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQ7IH0KLSAgICB2aXJ0dWFsIGJvb2wgaXNHZW5lcmF0ZVN0cmVhbVJlcXVlc3QoKSBjb25z dCB7IHJldHVybiBmYWxzZTsgfQotCi0gICAgdmlydHVhbCB2b2lkIGFib3J0KCkgPSAwOwotCi1w cm90ZWN0ZWQ6Ci0gICAgUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBzY3JpcHRFeGVj dXRpb25Db250ZXh0KQotICAgICAgICA6IG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChzY3JpcHRF eGVjdXRpb25Db250ZXh0KSB7IH0KLQotcHJpdmF0ZToKLSAgICAvLyBUaGlzIGlzIGd1YXJhbnRl ZWQgdG8gaGF2ZSB0aGUgbGlmZXRpbWUgb2YgdGhlIEZyYW1lLCBhbmQgaXQncyBvbmx5IHVzZWQg dG8gbWFrZQotICAgIC8vIHRoZSBjYWxsYmFjayBhc3luY2hyb25vdXMuIFRoZSBvcmlnaW5hbCBj YWxsYmFjayBjb250ZXh0IGlzIHVzZWQgaW4gdGhlIGNhbGwuCi0gICAgU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0OwotfTsKLQotY2xhc3MgTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXI6OkdlbmVyYXRlU3RyZWFtUmVxdWVzdCA6IHB1YmxpYyBSZXF1ZXN0 IHsKLSAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShHZW5lcmF0ZVN0cmVhbVJlcXVlc3QpOwotcHVi bGljOgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPEdlbmVyYXRlU3RyZWFtUmVxdWVzdD4gY3JlYXRl KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxO YXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRy PE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCi0gICAgewot ICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEdlbmVyYXRlU3RyZWFtUmVxdWVzdChzY3JpcHRF eGVjdXRpb25Db250ZXh0LCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spKTsKLSAgICB9 Ci0KLSAgICB2aXJ0dWFsIH5HZW5lcmF0ZVN0cmVhbVJlcXVlc3QoKSB7IH0KLQotICAgIHZpcnR1 YWwgYm9vbCBpc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0K LQotICAgIHZpcnR1YWwgdm9pZCBhYm9ydCgpCi0gICAgewotICAgICAgICBpZiAobV9lcnJvckNh bGxiYWNrKSB7Ci0gICAgICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVy cm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvcjo6UEVSTUlTU0lPTl9ERU5JRUQpOwotICAgICAgICAgICAgLy8gVGhlIGNhbGxiYWNrIGl0 c2VsZiBpcyBtYWRlIHdpdGggdGhlIEpTIGNhbGxiYWNrJ3MgY29udGV4dCwgbm90IHdpdGggdGhl IGZyYW1lJ3MgY29udGV4dC4KLSAgICAgICAgICAgIG1fZXJyb3JDYWxsYmFjay0+c2NoZWR1bGVD YWxsYmFjayhzY3JpcHRFeGVjdXRpb25Db250ZXh0KCksIGVycm9yKTsKLSAgICAgICAgfQotICAg IH0KLQotICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2soKSBjb25zdCB7IHJldHVybiBtX3N1Y2Nlc3NDYWxsYmFjazsgfQotICAg IFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFj aygpIGNvbnN0IHsgcmV0dXJuIG1fZXJyb3JDYWxsYmFjazsgfQotCi1wcml2YXRlOgotICAgIEdl bmVyYXRlU3RyZWFtUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBzY3JpcHRFeGVjdXRp b25Db250ZXh0LAotICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRv clVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLAotICAgICAgICAgICAg ICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+ IGVycm9yQ2FsbGJhY2spCi0gICAgICAgIDogUmVxdWVzdChzY3JpcHRFeGVjdXRpb25Db250ZXh0 KQotICAgICAgICAsIG1fc3VjY2Vzc0NhbGxiYWNrKHN1Y2Nlc3NDYWxsYmFjaykKLSAgICAgICAg LCBtX2Vycm9yQ2FsbGJhY2soZXJyb3JDYWxsYmFjaykgeyB9Ci0KLSAgICBSZWZQdHI8TmF2aWdh dG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBtX3N1Y2Nlc3NDYWxsYmFjazsKLSAgICBSZWZQ dHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gbV9lcnJvckNhbGxiYWNrOwotfTsK LQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6UmVxdWVzdE1hcDo6YWJvcnQoaW50 IHJlcXVlc3RJZCkKLXsKLSAgICBnZXQocmVxdWVzdElkKS0+YWJvcnQoKTsKLSAgICByZW1vdmUo cmVxdWVzdElkKTsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6UmVxdWVz dE1hcDo6YWJvcnRBbGwoKQotewotICAgIHdoaWxlICghaXNFbXB0eSgpKSB7Ci0gICAgICAgIGJl Z2luKCktPnNlY29uZC0+YWJvcnQoKTsKLSAgICAgICAgcmVtb3ZlKGJlZ2luKCkpOwotICAgIH0K LX0KLQotTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6Ok1lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyKEZyYW1lKiBmcmFtZSkKLSAgICA6IG1fZnJhbWUoZnJhbWUpCi0gICAgLCBtX2lzSW5EZXRh Y2hlZFN0YXRlKGZhbHNlKQotewotICAgIGlmICghaXNDbGllbnRBdmFpbGFibGUoKSkKLSAgICAg ICAgZW50ZXJEZXRhY2hlZFN0YXRlKCk7Ci19Ci0KLU1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy Ojp+TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKQotewotfQotCi1TZWN1cml0eU9yaWdpbiog TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKLXsKLSAg ICByZXR1cm4gbV9mcmFtZSA/IG1fZnJhbWUtPmV4aXN0aW5nRE9NV2luZG93KCktPnNlY3VyaXR5 T3JpZ2luKCkgOiAwOwotfQotCi1TY3JpcHRFeGVjdXRpb25Db250ZXh0KiBNZWRpYVN0cmVhbUZy YW1lQ29udHJvbGxlcjo6c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0Ci17Ci0gICAgcmV0 dXJuIG1fZnJhbWUgPyBtX2ZyYW1lLT5leGlzdGluZ0RPTVdpbmRvdygpLT5zY3JpcHRFeGVjdXRp b25Db250ZXh0KCkgOiAwOwotfQotCi1NZWRpYVN0cmVhbUNvbnRyb2xsZXIqIE1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyOjpwYWdlQ29udHJvbGxlcigpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1f ZnJhbWUgJiYgbV9mcmFtZS0+cGFnZSgpID8gbV9mcmFtZS0+cGFnZSgpLT5tZWRpYVN0cmVhbUNv bnRyb2xsZXIoKSA6IDA7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OmVu dGVyRGV0YWNoZWRTdGF0ZSgpCi17Ci0gICAgaWYgKG1faXNJbkRldGFjaGVkU3RhdGUpIHsKLSAg ICAgICAgQVNTRVJUKG1fcmVxdWVzdHMuaXNFbXB0eSgpKTsKLSAgICAgICAgcmV0dXJuOwotICAg IH0KLQotICAgIG1fcmVxdWVzdHMuYWJvcnRBbGwoKTsKLSAgICBtX2lzSW5EZXRhY2hlZFN0YXRl ID0gdHJ1ZTsKLX0KLQotYm9vbCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6aXNDbGllbnRB dmFpbGFibGUoKSBjb25zdAotewotICAgIGlmIChtX2lzSW5EZXRhY2hlZFN0YXRlKQotICAgICAg ICByZXR1cm4gZmFsc2U7Ci0KLSAgICBNZWRpYVN0cmVhbUNvbnRyb2xsZXIqIGNvbnRyb2xsZXIg PSBwYWdlQ29udHJvbGxlcigpOwotICAgIHJldHVybiBjb250cm9sbGVyICYmIGNvbnRyb2xsZXIt PmlzQ2xpZW50QXZhaWxhYmxlKCk7Ci19Ci0KLS8vIENhbGxlZCBhbHNvIHdoZW4gdGhlIGZyYW1l IGlzIGRldGFjaGVkIGZyb20gdGhlIHBhZ2UsIGluIHdoaWNoIGNhc2UgdGhlIHBhZ2UgY29udHJv bGxlciB3aWxsIHJlbWFpbiBhbGl2ZS4KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6 OmRpc2Nvbm5lY3RQYWdlKCkKLXsKLSAgICBpZiAocGFnZUNvbnRyb2xsZXIoKSkKLSAgICAgICAg cGFnZUNvbnRyb2xsZXIoKS0+dW5yZWdpc3RlckZyYW1lQ29udHJvbGxlcih0aGlzKTsKLQotICAg IGVudGVyRGV0YWNoZWRTdGF0ZSgpOwotfQotCi0vLyBDYWxsZWQgd2hlbiB0aGUgZnJhbWUgaXMg YmVpbmcgZGVzdHJveWVkLiBTaW5jZSB0aGUgZnJhbWUgY29udHJvbGxlciBpcyBvd25lZCBieSB0 aGUgZnJhbWUgaXQgd2lsbCBkaWUgc2hvcnRseSBhZnRlciB0aGlzLgotdm9pZCBNZWRpYVN0cmVh bUZyYW1lQ29udHJvbGxlcjo6ZGlzY29ubmVjdEZyYW1lKCkKLXsKLSAgICBkaXNjb25uZWN0UGFn ZSgpOwotCi0gICAgQVNTRVJUKG1fcmVxdWVzdHMuaXNFbXB0eSgpKTsKLQotICAgIG1fZnJhbWUg PSAwOwotfQotCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjp0cmFuc2ZlclRvTmV3 UGFnZShQYWdlKikKLXsKLSAgICAvLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSB3ZSBzaG91bGQga2Vl cCBydW5uaW5nIHRoZSBtZWRpYSBzdHJlYW0gc2VydmljZXMgd2hpbGUgdHJhbnNmZXJpbmcgZnJh bWVzIGJldHdlZW4gcGFnZXMuCi0gICAgLy8gSG93ZXZlciwgdW50aWwgYSBwcm9wZXIgd2F5IHRv IGRvIHRoaXMgaXMgZGVjaWRlZCwgd2UncmUgc2h1dHRpbmcgZG93biBzZXJ2aWNlcy4KLSAgICBk aXNjb25uZWN0UGFnZSgpOwotfQotCi1HZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyOjpwYXJzZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhjb25zdCBTdHJp bmcmIG9wdGlvbnMpCi17Ci0gICAgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBmbGFncyA9IDA7 Ci0gICAgVmVjdG9yPFN0cmluZz4gb3B0aW9uTGlzdDsKLSAgICBvcHRpb25zLnNwbGl0KCcsJywg b3B0aW9uTGlzdCk7Ci0KLSAgICBmb3IgKFZlY3RvcjxTdHJpbmc+Ojpjb25zdF9pdGVyYXRvciBv cHRpb24gPSBvcHRpb25MaXN0LmJlZ2luKCk7IG9wdGlvbiAhPSBvcHRpb25MaXN0LmVuZCgpOyAr K29wdGlvbikgewotICAgICAgICBWZWN0b3I8U3RyaW5nPiBzdWJvcHRpb25MaXN0OwotICAgICAg ICBvcHRpb24tPnNwbGl0KCcgJywgc3Vib3B0aW9uTGlzdCk7Ci0KLSAgICAgICAgaWYgKHN1Ym9w dGlvbkxpc3QuZmlyc3QoKSA9PSAiYXVkaW8iKQotICAgICAgICAgICAgZmxhZ3MgfD0gR2VuZXJh dGVTdHJlYW1SZXF1ZXN0QXVkaW87Ci0gICAgICAgIGVsc2UgaWYgKHN1Ym9wdGlvbkxpc3QuZmly c3QoKSA9PSAidmlkZW8iKSB7Ci0gICAgICAgICAgICBib29sIHZpZGVvU3Vib3B0aW9ucyA9IGZh bHNlOwotICAgICAgICAgICAgVmVjdG9yPFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIHN1Ym9wdGlv biA9IHN1Ym9wdGlvbkxpc3QuYmVnaW4oKTsKLSAgICAgICAgICAgIGZvciAoKytzdWJvcHRpb247 IHN1Ym9wdGlvbiAhPSBzdWJvcHRpb25MaXN0LmVuZCgpOyArK3N1Ym9wdGlvbikKLSAgICAgICAg ICAgICAgICBpZiAoKnN1Ym9wdGlvbiA9PSAidXNlciIpIHsKLSAgICAgICAgICAgICAgICAgICAg ZmxhZ3MgfD0gR2VuZXJhdGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdVc2VyOwotICAgICAgICAg ICAgICAgICAgICB2aWRlb1N1Ym9wdGlvbnMgPSB0cnVlOwotICAgICAgICAgICAgICAgIH0gZWxz ZSBpZiAoKnN1Ym9wdGlvbiA9PSAiZW52aXJvbm1lbnQiKSB7Ci0gICAgICAgICAgICAgICAgICAg IGZsYWdzIHw9IEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nRW52aXJvbm1lbnQ7Ci0g ICAgICAgICAgICAgICAgICAgIHZpZGVvU3Vib3B0aW9ucyA9IHRydWU7Ci0gICAgICAgICAgICAg ICAgfQotCi0gICAgICAgICAgICAvLyBBc2sgZm9yIGFsbCBraW5kIG9mIGNhbWVyYXMgaWYgbm8g c3Vib3B0aW9uIHdhcyBzcGVjaWZpZWQuCi0gICAgICAgICAgICBpZiAoIXZpZGVvU3Vib3B0aW9u cykKLSAgICAgICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RWaWRlb0Zh Y2luZ1VzZXIgfCBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ0Vudmlyb25tZW50Owot ICAgICAgICB9Ci0gICAgfQotCi0gICAgcmV0dXJuIGZsYWdzOwotfQotCi0vLyBJbXBsZW1lbnRz IHRoZSBnZXRVc2VyTWVkaWEgbWV0aG9kIGZyb20gaHR0cDovL3d3dy53aGF0d2cub3JnL3NwZWNz L3dlYi1hcHBzL2N1cnJlbnQtd29yay8jZG9tLW5hdmlnYXRvci1nZXR1c2VybWVkaWEuCi12b2lk IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpnZW5lcmF0ZVN0cmVhbShjb25zdCBTdHJpbmcm IG9wdGlvbnMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0Nh bGxiYWNrLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg UGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNr LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRXhjZXB0 aW9uQ29kZSYgZWMpCi17Ci0gICAgZWMgPSAwOwotICAgIGlmICghc3VjY2Vzc0NhbGxiYWNrKQot ICAgICAgICByZXR1cm47Ci0KLSAgICBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzID0g cGFyc2VHZW5lcmF0ZVN0cmVhbU9wdGlvbnMob3B0aW9ucyk7Ci0gICAgaWYgKCFmbGFncykgewot ICAgICAgICBlYyA9IE5PVF9TVVBQT1JURURfRVJSOwotICAgICAgICByZXR1cm47Ci0gICAgfQot Ci0gICAgaW50IHJlcXVlc3RJZCA9IG1fcmVxdWVzdHMuZ2V0TmV4dElkKCk7Ci0gICAgbV9yZXF1 ZXN0cy5hZGQocmVxdWVzdElkLCBHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q6OmNyZWF0ZShzY3JpcHRF eGVjdXRpb25Db250ZXh0KCksIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOwotCi0g ICAgaWYgKCFpc0NsaWVudEF2YWlsYWJsZSgpKSB7Ci0gICAgICAgIC8vIFRoaXMgbWFrZXMgc3Vy ZSB0byBjYWxsIHRoZSBlcnJvciBjYWxsYmFjayBpZiBwcm92aWRlZC4KLSAgICAgICAgbV9yZXF1 ZXN0cy5hYm9ydChyZXF1ZXN0SWQpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgcGFn ZUNvbnRyb2xsZXIoKS0+Z2VuZXJhdGVTdHJlYW0odGhpcywgcmVxdWVzdElkLCBmbGFncywgc2Vj dXJpdHlPcmlnaW4oKSk7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnN0 cmVhbUdlbmVyYXRlZChpbnQgcmVxdWVzdElkLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3Rv ciYgc291cmNlcykKLXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIHJlcXVlc3QgY2Fu IGhhdmUgYmVlbiBhYm9ydGVkIGFzIGEgcmVzdWx0IG9mIGVtYmVkZGVyIGRldGFjaG1lbnQuCi0g ICAgaWYgKCFtX3JlcXVlc3RzLmNvbnRhaW5zKHJlcXVlc3RJZCkpCi0gICAgICAgIHJldHVybjsK LQotICAgIEFTU0VSVChtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQpLT5pc0dlbmVyYXRlU3RyZWFt UmVxdWVzdCgpKTsKLQotICAgIFJlZlB0cjxHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IHN0cmVhbVJl cXVlc3QgPSBzdGF0aWNfY2FzdDxHZW5lcmF0ZVN0cmVhbVJlcXVlc3QqPihtX3JlcXVlc3RzLmdl dChyZXF1ZXN0SWQpLmdldCgpKTsKLSAgICBSZWZQdHI8TG9jYWxNZWRpYVN0cmVhbT4gZ2VuZXJh dGVkU3RyZWFtID0gTG9jYWxNZWRpYVN0cmVhbTo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKSwgc291cmNlcyk7Ci0gICAgbV9yZXF1ZXN0cy5yZW1vdmUocmVxdWVzdElkKTsKLSAgICBz dHJlYW1SZXF1ZXN0LT5zdWNjZXNzQ2FsbGJhY2soKS0+aGFuZGxlRXZlbnQoZ2VuZXJhdGVkU3Ry ZWFtLmdldCgpKTsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c3RyZWFt R2VuZXJhdGlvbkZhaWxlZChpbnQgcmVxdWVzdElkLCBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6 RXJyb3JDb2RlIGNvZGUpCi17Ci0gICAgLy8gRG9uJ3QgYXNzZXJ0IHNpbmNlIHRoZSByZXF1ZXN0 IGNhbiBoYXZlIGJlZW4gYWJvcnRlZCBhcyBhIHJlc3VsdCBvZiBlbWJlZGRlciBkZXRhY2htZW50 LgotICAgIGlmICghbV9yZXF1ZXN0cy5jb250YWlucyhyZXF1ZXN0SWQpKQotICAgICAgICByZXR1 cm47Ci0KLSAgICBBU1NFUlQobV9yZXF1ZXN0cy5nZXQocmVxdWVzdElkKS0+aXNHZW5lcmF0ZVN0 cmVhbVJlcXVlc3QoKSk7Ci0KLSAgICBSZWZQdHI8R2VuZXJhdGVTdHJlYW1SZXF1ZXN0PiBzdHJl YW1SZXF1ZXN0ID0gc3RhdGljX2Nhc3Q8R2VuZXJhdGVTdHJlYW1SZXF1ZXN0Kj4obV9yZXF1ZXN0 cy5nZXQocmVxdWVzdElkKS5nZXQoKSk7Ci0gICAgbV9yZXF1ZXN0cy5yZW1vdmUocmVxdWVzdElk KTsKLQotICAgIGlmIChzdHJlYW1SZXF1ZXN0LT5lcnJvckNhbGxiYWNrKCkpIHsKLSAgICAgICAg UmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBlcnJvciA9IE5hdmlnYXRvclVzZXJNZWRp YUVycm9yOjpjcmVhdGUoY29kZSk7Ci0gICAgICAgIHN0cmVhbVJlcXVlc3QtPmVycm9yQ2FsbGJh Y2soKS0+aGFuZGxlRXZlbnQoZXJyb3IuZ2V0KCkpOwotICAgIH0KLX0KLQotfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgg Yi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5o CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmOTEyNTZkLi4wMDAwMDAwCi0tLSBhL1Nv dXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgKKysr IC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBH b29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JT IGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF Ci0gKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlcl9oCi0jZGVmaW5lIE1lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyX2gKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlICJFeGNlcHRpb25D b2RlLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1DbGllbnQuaCIKLSNpbmNsdWRlICJNZWRpYVN0 cmVhbVNvdXJjZS5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCi0jaW5j bHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgotI2luY2x1ZGUg PHd0Zi9Ob25jb3B5YWJsZS5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KLQot bmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBGcmFtZTsKLWNsYXNzIE1lZGlhU3RyZWFtQ29u dHJvbGxlcjsKLWNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s7Ci1jbGFzcyBO YXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s7Ci1jbGFzcyBQYWdlOwotY2xhc3MgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dDsKLWNsYXNzIFNlY3VyaXR5T3JpZ2luOwotCi1jbGFzcyBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlciB7Ci0gICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWVkaWFT dHJlYW1GcmFtZUNvbnRyb2xsZXIpOwotcHVibGljOgotICAgIE1lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyKEZyYW1lKik7Ci0gICAgdmlydHVhbCB+TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIo KTsKLQotICAgIFNlY3VyaXR5T3JpZ2luKiBzZWN1cml0eU9yaWdpbigpIGNvbnN0OwotICAgIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdDsKLQot ICAgIGJvb2wgaXNDbGllbnRBdmFpbGFibGUoKSBjb25zdDsKLSAgICB2b2lkIGRpc2Nvbm5lY3RQ YWdlKCk7Ci0gICAgdm9pZCBkaXNjb25uZWN0RnJhbWUoKTsKLSAgICB2b2lkIHRyYW5zZmVyVG9O ZXdQYWdlKFBhZ2UqKTsKLQotICAgIHN0YXRpYyBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIHBh cnNlR2VuZXJhdGVTdHJlYW1PcHRpb25zKGNvbnN0IFN0cmluZyYpOwotICAgIHZvaWQgZ2VuZXJh dGVTdHJlYW0oY29uc3QgU3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJN ZWRpYVN1Y2Nlc3NDYWxsYmFjaz4sIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JD YWxsYmFjaz4sIEV4Y2VwdGlvbkNvZGUmKTsKLQotICAgIC8vIC0tLSBDYWxscyBjb21pbmcgYmFj ayBmcm9tIHRoZSBjb250cm9sbGVyLiAtLS0gLy8KLQotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGVk KGludCByZXF1ZXN0SWQsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKTsK LSAgICB2b2lkIHN0cmVhbUdlbmVyYXRpb25GYWlsZWQoaW50IHJlcXVlc3RJZCwgTmF2aWdhdG9y VXNlck1lZGlhRXJyb3I6OkVycm9yQ29kZSk7Ci0KLXByaXZhdGU6Ci0gICAgY2xhc3MgUmVxdWVz dDsKLSAgICBjbGFzcyBHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q7Ci0KLSAgICBjbGFzcyBJZEdlbmVy YXRvciB7Ci0gICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKElkR2VuZXJhdG9yKTsKLSAgICBw dWJsaWM6Ci0gICAgICAgIElkR2VuZXJhdG9yKCkgOiBtX2lkKDApIHsgfQotICAgICAgICBpbnQg Z2V0TmV4dElkKCkgeyByZXR1cm4gKyttX2lkOyB9Ci0KLSAgICBwcml2YXRlOgotICAgICAgICBp bnQgbV9pZDsKLSAgICB9OwotCi0gICAgY2xhc3MgUmVxdWVzdE1hcCA6IHB1YmxpYyBJZEdlbmVy YXRvciwgcHVibGljIEhhc2hNYXA8aW50LCBSZWZQdHI8UmVxdWVzdD4gPiB7Ci0gICAgcHVibGlj OgotICAgICAgICB2b2lkIGFib3J0KGludCByZXF1ZXN0SWQpOwotICAgICAgICB2b2lkIGFib3J0 QWxsKCk7Ci0gICAgfTsKLQotICAgIC8vIERldGFjaGVkIGZyb20gYSBwYWdlLCBhbmQgaGVuY2Ug ZnJvbSBhIGVtYmVkZGVyIGNsaWVudC4KLSAgICB2b2lkIGVudGVyRGV0YWNoZWRTdGF0ZSgpOwot Ci0gICAgTWVkaWFTdHJlYW1Db250cm9sbGVyKiBwYWdlQ29udHJvbGxlcigpIGNvbnN0OwotCi0g ICAgUmVxdWVzdE1hcCBtX3JlcXVlc3RzOwotCi0gICAgRnJhbWUqIG1fZnJhbWU7Ci0gICAgYm9v bCBtX2lzSW5EZXRhY2hlZFN0YXRlOwotfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0j ZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2VuZGlmIC8vIE1lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1Vz ZXJNZWRpYUNsaWVudC5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xp ZW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWRlMzczYQotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5o CkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIg dGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisg KiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBm cm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBw ZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlS SUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRP LCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBVc2VyTWVkaWFDbGllbnRfaAorI2RlZmlu ZSBVc2VyTWVkaWFDbGllbnRfaAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1 ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiVXNlck1lZGlhQ29udHJvbGxlci5oIgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFVzZXJNZWRpYUNsaWVudCB7CitwdWJsaWM6 CisgICAgdmlydHVhbCB2b2lkIHVzZXJNZWRpYUNvbnRyb2xsZXJEZXN0cm95ZWQoKSA9IDA7CisK KyAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFVzZXJNZWRpYShjb25zdCBVc2VyTWVkaWFSZXF1ZXN0 KikgPSAwOworICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxVc2VyTWVkaWFSZXF1ZXN0KGNvbnN0IFVz ZXJNZWRpYVJlcXVlc3QqKSA9IDA7CisKKyAgICB2aXJ0dWFsIHZvaWQgdXNlck1lZGlhUXVlcnlD b21wbGV0ZWQoY29uc3QgVXNlck1lZGlhUmVxdWVzdCosIGNvbnN0IE1lZGlhU3RyZWFtU291cmNl VmVjdG9yJikgPSAwOworCitwcm90ZWN0ZWQ6CisgICAgdmlydHVhbCB+VXNlck1lZGlhQ2xpZW50 KCkgeyB9Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo TUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8gVXNlck1lZGlhQ2xpZW50X2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjJmYjlmNAotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuY3BwCkBAIC0wLDAg KzEsMTc3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiAgICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1l IG9mIEVyaWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5 IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlz CisgKiAgICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9M REVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBB IFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhF IENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwK KyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShNRURJQV9T VFJFQU0pCisKKyNpbmNsdWRlICJVc2VyTWVkaWFDb250cm9sbGVyLmgiCisKKyNpbmNsdWRlICJG cmFtZS5oIgorI2luY2x1ZGUgIkxvY2FsTWVkaWFTdHJlYW0uaCIKKyNpbmNsdWRlICJOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvci5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVk ZSAiVXNlck1lZGlhQ2xpZW50LmgiCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gVXNlck1l ZGlhUmVxdWVzdDo6Y3JlYXRlKGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZp Z2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0 cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrLCBGcmFtZSog ZnJhbWUpCit7CisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVlc3QgPSBhZG9wdFJl ZihuZXcgVXNlck1lZGlhUmVxdWVzdChvcHRpb25zLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2Fs bGJhY2ssIGZyYW1lKSk7CisgICAgaWYgKCFyZXF1ZXN0LT5hdWRpbygpICYmICFyZXF1ZXN0LT52 aWRlbygpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiByZXF1ZXN0LnJlbGVhc2Uo KTsKK30KKworVXNlck1lZGlhUmVxdWVzdDo6VXNlck1lZGlhUmVxdWVzdChjb25zdCBTdHJpbmcm IG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFj az4gZXJyb3JDYWxsYmFjaywgRnJhbWUqIGZyYW1lKQorICAgIDogbV9hdWRpbyhmYWxzZSkKKyAg ICAsIG1fdmlkZW8oZmFsc2UpCisgICAgLCBtX2NhbWVyYVByZWZlcmVuY2VVc2VyKGZhbHNlKQor ICAgICwgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQoZmFsc2UpCisgICAgLCBtX3N1Y2Nl c3NDYWxsYmFjayhzdWNjZXNzQ2FsbGJhY2spCisgICAgLCBtX2Vycm9yQ2FsbGJhY2soZXJyb3JD YWxsYmFjaykKKyAgICAsIG1fZnJhbWUoZnJhbWUpCisgICAgLCBtX3F1ZXJ5Q2xpZW50KDApCit7 CisgICAgcGFyc2VPcHRpb25zKG9wdGlvbnMpOworfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6 OnBhcnNlT3B0aW9ucyhjb25zdCBTdHJpbmcmIG9wdGlvbnMpCit7CisgICAgVmVjdG9yPFN0cmlu Zz4gb3B0aW9uc0xpc3Q7CisgICAgb3B0aW9ucy5zcGxpdCgiLCIsIG9wdGlvbnNMaXN0KTsKKwor ICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgb3B0aW9uc0xpc3Quc2l6ZSgpOyBpKyspIHsKKyAg ICAgICAgVmVjdG9yPFN0cmluZz4gc3ViT3B0aW9uc0xpc3Q7CisgICAgICAgIG9wdGlvbnNMaXN0 W2ldLnNwbGl0KCIgIiwgc3ViT3B0aW9uc0xpc3QpOworCisgICAgICAgIGlmIChzdWJPcHRpb25z TGlzdFswXSA9PSAiYXVkaW8iKQorICAgICAgICAgICAgbV9hdWRpbyA9IHRydWU7CisgICAgICAg IGVsc2UgaWYgKHN1Yk9wdGlvbnNMaXN0WzBdID09ICJ2aWRlbyIpIHsKKyAgICAgICAgICAgIG1f dmlkZW8gPSB0cnVlOworICAgICAgICAgICAgaWYgKHN1Yk9wdGlvbnNMaXN0LmNvbnRhaW5zKCJ1 c2VyIikpCisgICAgICAgICAgICAgICAgbV9jYW1lcmFQcmVmZXJlbmNlVXNlciA9IHRydWU7Cisg ICAgICAgICAgICBpZiAoc3ViT3B0aW9uc0xpc3QuY29udGFpbnMoImVudmlyb25tZW50IikpCisg ICAgICAgICAgICAgICAgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQgPSB0cnVlOworICAg ICAgICB9CisgICAgfQorfQorCitVc2VyTWVkaWFDb250cm9sbGVyOjpVc2VyTWVkaWFDb250cm9s bGVyKFBhZ2UqIHBhZ2UsIFVzZXJNZWRpYUNsaWVudCogY2xpZW50KQorICAgIDogbV9wYWdlKHBh Z2UpCisgICAgLCBtX2NsaWVudChjbGllbnQpCit7Cit9CisKK1VzZXJNZWRpYUNvbnRyb2xsZXI6 On5Vc2VyTWVkaWFDb250cm9sbGVyKCkKK3sKKyAgICBpZiAobV9jbGllbnQpCisgICAgICAgIG1f Y2xpZW50LT51c2VyTWVkaWFDb250cm9sbGVyRGVzdHJveWVkKCk7Cit9CisKK3ZvaWQgVXNlck1l ZGlhQ29udHJvbGxlcjo6cmVxdWVzdFVzZXJNZWRpYShQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVl c3Q+IHBycFJlcXVlc3QpCit7CisgICAgaWYgKCFtX2NsaWVudCkKKyAgICAgICAgcmV0dXJuOwor CisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVlc3QgPSBwcnBSZXF1ZXN0OworCisg ICAgcmVxdWVzdC0+c2V0UXVlcnlDbGllbnQodGhpcyk7CisgICAgbV9yZXF1ZXN0cy5hcHBlbmQo cmVxdWVzdCk7CisgICAgbV9jbGllbnQtPnJlcXVlc3RVc2VyTWVkaWEocmVxdWVzdC5nZXQoKSk7 Cit9CisKK3ZvaWQgVXNlck1lZGlhQ29udHJvbGxlcjo6Y2FuY2VsQWxsVXNlck1lZGlhUmVxdWVz dHNGcm9tRnJhbWUoRnJhbWUqIGZyYW1lKQoreworICAgIGlmICghbV9jbGllbnQpCisgICAgICAg IHJldHVybjsKKworICAgIGZvciAoc2l6ZV90IGkgPSBtX3JlcXVlc3RzLnNpemUoKSAtIDE7IGkg IT0gbm90Rm91bmQ7IGktLSkgeworICAgICAgICBpZiAobV9yZXF1ZXN0c1tpXS0+ZnJhbWUoKSAh PSBmcmFtZSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIG1fY2xpZW50LT5jYW5j ZWxVc2VyTWVkaWFSZXF1ZXN0KG1fcmVxdWVzdHNbaV0uZ2V0KCkpOworICAgICAgICBtX3JlcXVl c3RzW2ldLT5zZXRRdWVyeUNsaWVudCgwKTsKKyAgICAgICAgbV9yZXF1ZXN0cy5yZW1vdmUoaSk7 CisgICAgfQorfQorCit2b2lkIFVzZXJNZWRpYUNvbnRyb2xsZXI6OnVzZXJNZWRpYVJlcXVlc3RT dWNjZWVkZWQoY29uc3QgVXNlck1lZGlhUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgTWVkaWFTdHJl YW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCit7CisgICAgQVNTRVJUKG1fcmVxdWVzdHMuY29udGFp bnMocmVxdWVzdCkpOworCisgICAgRE9NV2luZG93KiBkb21XaW5kb3cgPSByZXF1ZXN0LT5mcmFt ZSgpLT5leGlzdGluZ0RPTVdpbmRvdygpOworICAgIGlmICghZG9tV2luZG93KQorICAgICAgICBy ZXR1cm47CisKKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0ID0gZG9tV2luZG93 LT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCk7CisgICAgaWYgKCFjb250ZXh0KQorICAgICAgICBy ZXR1cm47CisKKyAgICBSZWZQdHI8TG9jYWxNZWRpYVN0cmVhbT4gc3RyZWFtID0gTG9jYWxNZWRp YVN0cmVhbTo6Y3JlYXRlKGNvbnRleHQsIHNvdXJjZXMpOworICAgIHJlcXVlc3QtPnN1Y2Nlc3ND YWxsYmFjaygpLT5oYW5kbGVFdmVudChzdHJlYW0uZ2V0KCkpOworCisgICAgc2l6ZV90IGkgPSBt X3JlcXVlc3RzLmZpbmQocmVxdWVzdCk7CisgICAgaWYgKGkgIT0gbm90Rm91bmQpCisgICAgICAg IG1fcmVxdWVzdHMucmVtb3ZlKGkpOworfQorCit2b2lkIFVzZXJNZWRpYUNvbnRyb2xsZXI6OnVz ZXJNZWRpYVJlcXVlc3RGYWlsZWQoY29uc3QgVXNlck1lZGlhUmVxdWVzdCogcmVxdWVzdCkKK3sK KyAgICBBU1NFUlQobV9yZXF1ZXN0cy5jb250YWlucyhyZXF1ZXN0KSk7CisKKyAgICBpZiAocmVx dWVzdC0+ZXJyb3JDYWxsYmFjaygpKSB7CisgICAgICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRv clVzZXJNZWRpYUVycm9yOjpQRVJNSVNTSU9OX0RFTklFRCk7CisgICAgICAgIHJlcXVlc3QtPmVy cm9yQ2FsbGJhY2soKS0+aGFuZGxlRXZlbnQoZXJyb3IuZ2V0KCkpOworICAgIH0KKworICAgIHNp emVfdCBpID0gbV9yZXF1ZXN0cy5maW5kKHJlcXVlc3QpOworICAgIGlmIChpICE9IG5vdEZvdW5k KQorICAgICAgICBtX3JlcXVlc3RzLnJlbW92ZShpKTsKK30KKwordm9pZCBVc2VyTWVkaWFDb250 cm9sbGVyOjpxdWVyeVVzZXJNZWRpYShjb25zdCBVc2VyTWVkaWFSZXF1ZXN0KiByZXF1ZXN0KQor eworICAgIEFTU0VSVChtX3JlcXVlc3RzLmNvbnRhaW5zKHJlcXVlc3QpKTsKKworICAgIC8vIEZJ WE1FOiBxdWVyeSB0aGUgcGxhdGZvcm0gZm9yIGF2YWlsYWJsZSB1c2VyIG1lZGlhLCBzZWUgaHR0 cDovL3dlYmtpdC5vcmcvYi83MDg5NQorfQorCit2b2lkIFVzZXJNZWRpYUNvbnRyb2xsZXI6OnVz ZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKGNvbnN0IFVzZXJNZWRpYVJlcXVlc3QqIHJlcXVlc3QsIGNv bnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQoreworICAgIGlmIChtX2NsaWVu dCkKKyAgICAgICAgbV9jbGllbnQtPnVzZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKHJlcXVlc3QsIHNv dXJjZXMpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo TUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNl ck1lZGlhQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlh Q29udHJvbGxlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzNGJmMGMK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFD b250cm9sbGVyLmgKQEAgLTAsMCArMSwxMjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEg RXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAq IDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29u dHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBVc2VyTWVkaWFDb250 cm9sbGVyX2gKKyNkZWZpbmUgVXNlck1lZGlhQ29udHJvbGxlcl9oCisKKyNpZiBFTkFCTEUoTUVE SUFfU1RSRUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJlYW1Tb3VyY2UuaCIKKyNpbmNsdWRlICJO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNl ck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNp bmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBGcmFtZTsKK2NsYXNzIFBhZ2U7CitjbGFzcyBVc2Vy TWVkaWFDbGllbnQ7CitjbGFzcyBVc2VyTWVkaWFSZXF1ZXN0OworCitjbGFzcyBVc2VyTWVkaWFR dWVyeUNsaWVudCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2b2lkIHVzZXJNZWRpYVF1ZXJ5Q29t cGxldGVkKGNvbnN0IFVzZXJNZWRpYVJlcXVlc3QqLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZl Y3RvciYpID0gMDsKKworcHJvdGVjdGVkOgorICAgIHZpcnR1YWwgflVzZXJNZWRpYVF1ZXJ5Q2xp ZW50KCkgeyB9Cit9OworCitjbGFzcyBVc2VyTWVkaWFSZXF1ZXN0IDogcHVibGljIFJlZkNvdW50 ZWQ8VXNlck1lZGlhUmVxdWVzdD4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFVz ZXJNZWRpYVJlcXVlc3Q+IGNyZWF0ZShjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8 TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1JlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrPiwgRnJhbWUqKTsKKworICAgIGJvb2wgYXVkaW8oKSBjb25z dCB7IHJldHVybiBtX2F1ZGlvOyB9CisgICAgYm9vbCB2aWRlbygpIGNvbnN0IHsgcmV0dXJuIG1f dmlkZW87IH0KKworICAgIGJvb2wgY2FtZXJhUHJlZmVyZW5jZVVzZXIoKSBjb25zdCB7IHJldHVy biBtX2NhbWVyYVByZWZlcmVuY2VVc2VyOyB9CisgICAgYm9vbCBjYW1lcmFQcmVmZXJlbmNlRW52 aXJvbm1lbnQoKSBjb25zdCB7IHJldHVybiBtX2NhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudDsg fQorCisgICAgTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrKiBzdWNjZXNzQ2FsbGJh Y2soKSBjb25zdCB7IHJldHVybiBtX3N1Y2Nlc3NDYWxsYmFjay5nZXQoKTsgfQorICAgIE5hdmln YXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2sqIGVycm9yQ2FsbGJhY2soKSBjb25zdCB7cmV0dXJu IG1fZXJyb3JDYWxsYmFjay5nZXQoKTsgfQorCisgICAgRnJhbWUqIGZyYW1lKCkgY29uc3QgeyBy ZXR1cm4gbV9mcmFtZTsgfQorCisgICAgVXNlck1lZGlhUXVlcnlDbGllbnQqIHF1ZXJ5Q2xpZW50 KCkgY29uc3QgeyByZXR1cm4gbV9xdWVyeUNsaWVudDsgfQorICAgIHZvaWQgc2V0UXVlcnlDbGll bnQoVXNlck1lZGlhUXVlcnlDbGllbnQqIHF1ZXJ5Q2xpZW50KSB7IG1fcXVlcnlDbGllbnQgPSBx dWVyeUNsaWVudDsgfQorCisgICAgYm9vbCBtX2F1ZGlvOworICAgIGJvb2wgbV92aWRlbzsKKwor ICAgIGJvb2wgbV9jYW1lcmFQcmVmZXJlbmNlVXNlcjsKKyAgICBib29sIG1fY2FtZXJhUHJlZmVy ZW5jZUVudmlyb25tZW50OworCisgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3ND YWxsYmFjaz4gbV9zdWNjZXNzQ2FsbGJhY2s7CisgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRp YUVycm9yQ2FsbGJhY2s+IG1fZXJyb3JDYWxsYmFjazsKKworICAgIEZyYW1lKiBtX2ZyYW1lOwor ICAgIFVzZXJNZWRpYVF1ZXJ5Q2xpZW50KiBtX3F1ZXJ5Q2xpZW50OworCitwcml2YXRlOgorICAg IFVzZXJNZWRpYVJlcXVlc3QoY29uc3QgU3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmln YXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4sIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1l ZGlhRXJyb3JDYWxsYmFjaz4sIEZyYW1lKik7CisKKyAgICB2b2lkIHBhcnNlT3B0aW9ucyhjb25z dCBTdHJpbmcmIG9wdGlvbnMpOworfTsKKworY2xhc3MgVXNlck1lZGlhQ29udHJvbGxlciA6IHB1 YmxpYyBVc2VyTWVkaWFRdWVyeUNsaWVudCB7CisgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVXNl ck1lZGlhQ29udHJvbGxlcik7CitwdWJsaWM6CisgICAgVXNlck1lZGlhQ29udHJvbGxlcihQYWdl KiwgVXNlck1lZGlhQ2xpZW50Kik7CisgICAgflVzZXJNZWRpYUNvbnRyb2xsZXIoKTsKKworICAg IHZvaWQgcmVxdWVzdFVzZXJNZWRpYShQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+KTsKKyAg ICB2b2lkIGNhbmNlbEFsbFVzZXJNZWRpYVJlcXVlc3RzRnJvbUZyYW1lKEZyYW1lKik7CisKKyAg ICB2b2lkIHVzZXJNZWRpYVJlcXVlc3RTdWNjZWVkZWQoY29uc3QgVXNlck1lZGlhUmVxdWVzdCos IGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJik7CisgICAgdm9pZCB1c2VyTWVkaWFSZXF1 ZXN0RmFpbGVkKGNvbnN0IFVzZXJNZWRpYVJlcXVlc3QqKTsKKworICAgIFVzZXJNZWRpYUNsaWVu dCogY2xpZW50KCkgY29uc3QgeyByZXR1cm4gbV9jbGllbnQ7IH0KKworICAgIHZvaWQgcXVlcnlV c2VyTWVkaWEoY29uc3QgVXNlck1lZGlhUmVxdWVzdCopOworCisgICAgLy8gVXNlck1lZGlhUXVl cnlDbGllbnQgaW50ZXJmYWNlCisgICAgdm9pZCB1c2VyTWVkaWFRdWVyeUNvbXBsZXRlZChjb25z dCBVc2VyTWVkaWFSZXF1ZXN0KiwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImKTsKKwor cHJpdmF0ZToKKyAgICBQYWdlKiBtX3BhZ2U7CisgICAgVXNlck1lZGlhQ2xpZW50KiBtX2NsaWVu dDsKKworICAgIFZlY3RvcjxSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gPiBtX3JlcXVlc3RzOwor fTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NU UkVBTSkKKworI2VuZGlmIC8vIFVzZXJNZWRpYUNvbnRyb2xsZXJfaApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rhc2suaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2Fs bGJhY2tUYXNrLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkMDBkMzEuLjAwMDAw MDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rhc2suaAorKysgL2Rldi9udWxs CkBAIC0xLDgxICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycg QU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAotICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpZm5kZWYgQ2FsbGJhY2tUYXNrX2gK LSNkZWZpbmUgQ2FsbGJhY2tUYXNrX2gKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNp bmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQu aD4KLSNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgotI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4K LQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0vLyBIZWxwZXIgdGVtcGxhdGUgdG8gc2NoZWR1bGUg Y2FsbHMgdG8gY2FsbGJhY2tzIHVzaW5nIHRoZWlyIG93biBzY3JpcHQgZXhlY3V0aW9uIGNvbnRl eHQuCi0vLyBDYWxsYmFja1R5cGUgaXMgYXNzdW1lZCB0byBpbXBsZW1lbnQgU2NoZWR1bGVyIGFu ZCB0byBiZSByZWZlcmVuY2UtY291bnRlZC4KLXRlbXBsYXRlIDx0eXBlbmFtZSBDYWxsYmFja1R5 cGUsIHR5cGVuYW1lIEFyZ3VtZW50VHlwZT4KLWNsYXNzIENhbGxiYWNrVGFzazEgOiBwdWJsaWMg U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NP d25QdHI8Q2FsbGJhY2tUYXNrMT4gY3JlYXRlKFBhc3NSZWZQdHI8Q2FsbGJhY2tUeXBlPiBjYWxs YmFjaywgUGFzc1JlZlB0cjxBcmd1bWVudFR5cGU+IGRhdGEpCi0gICAgewotICAgICAgICByZXR1 cm4gYWRvcHRQdHIobmV3IENhbGxiYWNrVGFzazEoY2FsbGJhY2ssIGRhdGEpKTsKLSAgICB9Ci0K LSAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopCi0g ICAgewotICAgICAgICBtX2NhbGxiYWNrLT5oYW5kbGVFdmVudChtX2RhdGEuZ2V0KCkpOwotICAg IH0KLQotICAgIGNsYXNzIFNjaGVkdWxlciB7Ci0gICAgcHVibGljOgotICAgICAgICB2aXJ0dWFs IH5TY2hlZHVsZXIoKSB7IH0KLQotICAgICAgICBib29sIHNjaGVkdWxlQ2FsbGJhY2soU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxBcmd1bWVudFR5cGU+IGRhdGEp Ci0gICAgICAgIHsKLSAgICAgICAgICAgIGlmIChjb250ZXh0KSB7Ci0gICAgICAgICAgICAgICAg Y29udGV4dC0+cG9zdFRhc2soQ2FsbGJhY2tUYXNrMTxDYWxsYmFja1R5cGUsIEFyZ3VtZW50VHlw ZT46OmNyZWF0ZShzdGF0aWNfY2FzdDxDYWxsYmFja1R5cGUqPih0aGlzKSwgZGF0YSkpOwotICAg ICAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAgICAgICAgICAgfQotICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOwotICAgICAgICB9Ci0gICAgfTsKLQotcHJpdmF0ZToKLSAgICBDYWxsYmFja1Rh c2sxKFBhc3NSZWZQdHI8Q2FsbGJhY2tUeXBlPiBjYWxsYmFjaywgUGFzc1JlZlB0cjxBcmd1bWVu dFR5cGU+IGRhdGEpCi0gICAgICAgIDogbV9jYWxsYmFjayhjYWxsYmFjaykKLSAgICAgICAgLCBt X2RhdGEoZGF0YSkKLSAgICB7Ci0gICAgfQotCi0gICAgUmVmUHRyPENhbGxiYWNrVHlwZT4gbV9j YWxsYmFjazsKLSAgICBSZWZQdHI8QXJndW1lbnRUeXBlPiBtX2RhdGE7Ci19OwotCi19Ci0KLSNl bmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jZW5kaWYgLy8gQ2FsbGJhY2tUYXNrX2gK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwIGIvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZS5jcHAKaW5kZXggMWEyM2ZhNS4uZDM4OTA1YiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZS5jcHAKQEAgLTEwNiwxNSArMTA2LDE1IEBACiAjaW5jbHVkZSAiU1ZHTmFtZXMuaCIKICNpbmNs dWRlICJYTGlua05hbWVzLmgiCiAKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorI2luY2x1ZGUg IlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKKyNlbmRpZgorCiAjaWYgRU5BQkxFKFNWRykKICNpbmNs dWRlICJTVkdEb2N1bWVudC5oIgogI2luY2x1ZGUgIlNWR0RvY3VtZW50RXh0ZW5zaW9ucy5oIgog I2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotI2luY2x1ZGUgIk1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyLmgiCi0jZW5kaWYKLQogI2lmIFVTRShUSUxFRF9CQUNLSU5HX1NUT1JF KQogI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCiAjZW5kaWYKQEAgLTE2OSw5ICsxNjks NiBAQCBpbmxpbmUgRnJhbWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRWxlbWVu dCogb3duZXJFbGVtZW50LCBGcmFtZUxvYWRlcgogICAgICwgbV9pblZpZXdTb3VyY2VNb2RlKGZh bHNlKQogICAgICwgbV9pc0Rpc2Nvbm5lY3RlZChmYWxzZSkKICAgICAsIG1fZXhjbHVkZUZyb21U ZXh0U2VhcmNoKGZhbHNlKQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgLCBtX21lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6Om1lZGlhU3RyZWFt RW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKHRoaXMp KSA6IFBhc3NPd25QdHI8TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI+KCkpCi0jZW5kaWYKIHsK ICAgICBBU1NFUlQocGFnZSk7CiAgICAgQXRvbWljU3RyaW5nOjppbml0KCk7CkBAIC0yMjksOCAr MjI2LDggQEAgRnJhbWU6On5GcmFtZSgpCiAgICAgICAgIG1fZG9tV2luZG93LT5kaXNjb25uZWN0 RnJhbWUoKTsKIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgaWYgKG1fbWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIpCi0gICAgICAgIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIt PmRpc2Nvbm5lY3RGcmFtZSgpOworICAgIGlmIChtX3BhZ2UgJiYgbV9wYWdlLT51c2VyTWVkaWFD b250cm9sbGVyKCkpCisgICAgICAgIG1fcGFnZS0+dXNlck1lZGlhQ29udHJvbGxlcigpLT5jYW5j ZWxBbGxVc2VyTWVkaWFSZXF1ZXN0c0Zyb21GcmFtZSh0aGlzKTsKICNlbmRpZgogCiAgICAgSGFz aFNldDxET01XaW5kb3cqPjo6aXRlcmF0b3IgZW5kID0gbV9saXZlRm9ybWVyV2luZG93cy5lbmQo KTsKQEAgLTY5OSw4ICs2OTYsOCBAQCB2b2lkIEZyYW1lOjpwYWdlRGVzdHJveWVkKCkKICAgICB9 CiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgIGlmIChtX21lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyKQotICAgICAgICBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLT5kaXNjb25u ZWN0UGFnZSgpOworICAgIGlmIChtX3BhZ2UgJiYgbV9wYWdlLT51c2VyTWVkaWFDb250cm9sbGVy KCkpCisgICAgICAgIG1fcGFnZS0+dXNlck1lZGlhQ29udHJvbGxlcigpLT5jYW5jZWxBbGxVc2Vy TWVkaWFSZXF1ZXN0c0Zyb21GcmFtZSh0aGlzKTsKICNlbmRpZgogCiAgICAgLy8gRklYTUU6IEl0 J3MgdW5jbGVhciBhcyB0byB3aHkgdGhpcyBpcyBjYWxsZWQgbW9yZSB0aGFuIG9uY2UsIGJ1dCBp dCBpcywKQEAgLTc1Nyw5ICs3NTQsMTAgQEAgdm9pZCBGcmFtZTo6dHJhbnNmZXJDaGlsZEZyYW1l VG9OZXdEb2N1bWVudCgpCiAgICAgICAgIH0KIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0g ICAgICAgIGlmIChtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKQotICAgICAgICAgICAgbV9t ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci0+dHJhbnNmZXJUb05ld1BhZ2UobmV3UGFnZSk7Cisg ICAgICAgIGlmIChtX3BhZ2UgJiYgbV9wYWdlLT51c2VyTWVkaWFDb250cm9sbGVyKCkpCisgICAg ICAgICAgICBtX3BhZ2UtPnVzZXJNZWRpYUNvbnRyb2xsZXIoKS0+Y2FuY2VsQWxsVXNlck1lZGlh UmVxdWVzdHNGcm9tRnJhbWUodGhpcyk7CiAjZW5kaWYKKwogICAgICAgICBtX3BhZ2UgPSBuZXdQ YWdlOwogCiAgICAgICAgIGlmIChuZXdQYWdlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZS5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCmluZGV4IGFkYTI2YTUu LjcxMTU2NDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgKQEAgLTY1LDcgKzY1LDYgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgIGNsYXNzIERvY3VtZW50OwogICAgIGNsYXNzIEZyYW1lVmlldzsKICAgICBj bGFzcyBIVE1MVGFibGVDZWxsRWxlbWVudDsKLSAgICBjbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29u dHJvbGxlcjsKICAgICBjbGFzcyBSZWd1bGFyRXhwcmVzc2lvbjsKICAgICBjbGFzcyBSZW5kZXJQ YXJ0OwogICAgIGNsYXNzIFRpbGVkQmFja2luZ1N0b3JlOwpAQCAtMjAwLDEwICsxOTksNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIE5TSW1hZ2UqIGltYWdlRnJvbVJlY3QoTlNSZWN0 KSBjb25zdDsKICNlbmRpZgogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAgICAgTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIG1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKCkgY29u c3QgeyByZXR1cm4gbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5nZXQoKTsgfQotI2VuZGlm Ci0gICAgICAgIAogICAgICAgICAvLyBTaG91bGQgb25seSBiZSBjYWxsZWQgb24gdGhlIG1haW4g ZnJhbWUgb2YgYSBwYWdlLgogICAgICAgICB2b2lkIG5vdGlmeUNocm9tZUNsaWVudFdoZWVsRXZl bnRIYW5kbGVyQ291bnRDaGFuZ2VkKCkgY29uc3Q7CiAKQEAgLTI2NSw5ICsyNjAsNiBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIE93blB0cjxUaWxlZEJhY2tpbmdTdG9yZT4gbV90aWxl ZEJhY2tpbmdTdG9yZTsKICNlbmRpZgogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAg ICAgT3duUHRyPE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyPiBtX21lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyOwotI2VuZGlmCiAgICAgfTsKIAogICAgIGlubGluZSB2b2lkIEZyYW1lOjppbml0 KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcAppbmRleCA1MzU3NWFmLi40OGFlZjc2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwCkBAIC00NSw5ICs0NSwxMSBAQAogI2luY2x1ZGUgPHd0 Zi9TdGRMaWJFeHRyYXMuaD4KIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0jaW5jbHVkZSAi TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKKyNpbmNsdWRlICJET01XaW5kb3cuaCIKICNp bmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCiAjaW5jbHVkZSAiTmF2 aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmln aW4uaCIKKyNpbmNsdWRlICJVc2VyTWVkaWFDb250cm9sbGVyLmgiCiAjZW5kaWYKIAogbmFtZXNw YWNlIFdlYkNvcmUgewpAQCAtODIsNiArODQsMTEgQEAgdm9pZCBOYXZpZ2F0b3I6OmRpc2Nvbm5l Y3RGcmFtZSgpCiAgICAgICAgIG1fZ2VvbG9jYXRpb24tPmRpc2Nvbm5lY3RGcmFtZSgpOwogICAg ICAgICBtX2dlb2xvY2F0aW9uID0gMDsKICAgICB9CisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkK KyAgICBpZiAobV9mcmFtZSAmJiBtX2ZyYW1lLT5wYWdlKCkpCisgICAgICAgIG1fZnJhbWUtPnBh Z2UoKS0+dXNlck1lZGlhQ29udHJvbGxlcigpLT5jYW5jZWxBbGxVc2VyTWVkaWFSZXF1ZXN0c0Zy b21GcmFtZShtX2ZyYW1lKTsKKyNlbmRpZgorCiAgICAgbV9mcmFtZSA9IDA7CiB9CiAKQEAgLTI4 Myw4ICsyOTAsMjMgQEAgdm9pZCBOYXZpZ2F0b3I6OnJlZ2lzdGVyUHJvdG9jb2xIYW5kbGVyKGNv bnN0IFN0cmluZyYgc2NoZW1lLCBjb25zdCBTdHJpbmcmIHVybCwKICNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQogdm9pZCBOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYShjb25zdCBTdHJpbmcm IG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFj az4gZXJyb3JDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYgKG1fZnJhbWUg JiYgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKSkKLSAgICAgICAgbV9mcmFt ZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKS0+Z2VuZXJhdGVTdHJlYW0ob3B0aW9ucywg c3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBlYyk7CisgICAgaWYgKCFzdWNjZXNzQ2Fs bGJhY2spCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9mcmFtZSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgUGFnZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKTsKKyAgICBpZiAoIXBhZ2Up CisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0 ID0gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKG9wdGlvbnMsIHN1Y2Nlc3NDYWxsYmFjaywgZXJy b3JDYWxsYmFjaywgbV9mcmFtZSk7CisgICAgaWYgKCFyZXF1ZXN0KSB7CisgICAgICAgIGVjID0g Tk9UX1NVUFBPUlRFRF9FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBwYWdlLT51 c2VyTWVkaWFDb250cm9sbGVyKCktPnJlcXVlc3RVc2VyTWVkaWEocmVxdWVzdC5yZWxlYXNlKCkp OwogfQogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9y LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5oCmluZGV4IDNhMWUwNDIuLjM1ZTYy YmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuaApAQCAtMzUsNiArMzUsNyBAQCBjbGFzcyBHZW9s b2NhdGlvbjsKIGNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s7CiBjbGFzcyBO YXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s7CiBjbGFzcyBQbHVnaW5EYXRhOworY2xh c3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFFcnJv ckNhbGxiYWNrLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9y Q2FsbGJhY2suaAppbmRleCAxNTM5NzA5Li5kZDNjOGIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaApAQCAtMjcsMTQg KzI3LDEyIEBACiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQogCi0jaW5jbHVkZSAiQ2FsbGJh Y2tUYXNrLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIKICNpbmNsdWRl IDx3dGYvUmVmQ291bnRlZC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIE5hdmln YXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2sgOiBwdWJsaWMgUmVmQ291bnRlZDxOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrPiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBwdWJsaWMgQ2FsbGJhY2tUYXNrMTxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxi YWNrLCBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj46OlNjaGVkdWxlciB7CitjbGFzcyBOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrIDogcHVibGljIFJlZkNvdW50ZWQ8TmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjaz4gewogcHVibGljOgogICAgIHZpcnR1YWwgfk5hdmlnYXRvclVz ZXJNZWRpYUVycm9yQ2FsbGJhY2soKSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlRXZlbnQo TmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL1BhZ2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcAppbmRleCA4YmJk ZWM5Li5jOTU2OTI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKQEAgLTgwLDggKzgwLDcgQEAKICNlbmRp ZgogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNsaWVu dC5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIlVzZXJN ZWRpYUNvbnRyb2xsZXIuaCIKICNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0xMzcs MTIgKzEzNiwxMiBAQCBQYWdlOjpQYWdlKFBhZ2VDbGllbnRzJiBwYWdlQ2xpZW50cykKICAgICAs IG1fZGV2aWNlTW90aW9uQ29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpkZXZpY2VN b3Rpb25FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcgRGV2aWNlTW90aW9uQ29udHJvbGxlcihwYWdl Q2xpZW50cy5kZXZpY2VNb3Rpb25DbGllbnQpKSA6IG51bGxwdHIpCiAgICAgLCBtX2RldmljZU9y aWVudGF0aW9uQ29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpkZXZpY2VPcmllbnRh dGlvbkVuYWJsZWQoKSA/IGFkb3B0UHRyKG5ldyBEZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIo dGhpcywgcGFnZUNsaWVudHMuZGV2aWNlT3JpZW50YXRpb25DbGllbnQpKSA6IG51bGxwdHIpCiAj ZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICwgbV9tZWRpYVN0cmVhbUNvbnRy b2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6bWVkaWFTdHJlYW1FbmFibGVkKCkgPyBhZG9w dFB0cihuZXcgTWVkaWFTdHJlYW1Db250cm9sbGVyKHBhZ2VDbGllbnRzLm1lZGlhU3RyZWFtQ2xp ZW50KSkgOiBQYXNzT3duUHRyPE1lZGlhU3RyZWFtQ29udHJvbGxlcj4oKSkKLSNlbmRpZgogI2lm IEVOQUJMRShJTlBVVF9TUEVFQ0gpCiAgICAgLCBtX3NwZWVjaElucHV0Q2xpZW50KHBhZ2VDbGll bnRzLnNwZWVjaElucHV0Q2xpZW50KQogI2VuZGlmCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkK KyAgICAsIG1fdXNlck1lZGlhQ29udHJvbGxlcihhZG9wdFB0cihuZXcgVXNlck1lZGlhQ29udHJv bGxlcih0aGlzLCBwYWdlQ2xpZW50cy51c2VyTWVkaWFDbGllbnQpKSkKKyNlbmRpZgogICAgICwg bV9zZXR0aW5ncyhhZG9wdFB0cihuZXcgU2V0dGluZ3ModGhpcykpKQogICAgICwgbV9wcm9ncmVz cyhhZG9wdFB0cihuZXcgUHJvZ3Jlc3NUcmFja2VyKSkKICAgICAsIG1fYmFja0ZvcndhcmRDb250 cm9sbGVyKGFkb3B0UHRyKG5ldyBCYWNrRm9yd2FyZENvbnRyb2xsZXIodGhpcywgcGFnZUNsaWVu dHMuYmFja0ZvcndhcmRDbGllbnQpKSkKQEAgLTEwMzEsNyArMTAzMCw3IEBAIFBhZ2U6OlBhZ2VD bGllbnRzOjpQYWdlQ2xpZW50cygpCiAgICAgLCBkZXZpY2VNb3Rpb25DbGllbnQoMCkKICAgICAs IGRldmljZU9yaWVudGF0aW9uQ2xpZW50KDApCiAgICAgLCBzcGVlY2hJbnB1dENsaWVudCgwKQot ICAgICwgbWVkaWFTdHJlYW1DbGllbnQoMCkKKyAgICAsIHVzZXJNZWRpYUNsaWVudCgwKQogewog fQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvUGFnZS5oCmluZGV4IDBmMTYxZjQuLjFhOTczNjEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCkBA IC03MSw4ICs3MSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBJbnNwZWN0b3JD bGllbnQ7CiAgICAgY2xhc3MgSW5zcGVjdG9yQ29udHJvbGxlcjsKICAgICBjbGFzcyBNZWRpYUNh blN0YXJ0TGlzdGVuZXI7Ci0gICAgY2xhc3MgTWVkaWFTdHJlYW1DbGllbnQ7Ci0gICAgY2xhc3Mg TWVkaWFTdHJlYW1Db250cm9sbGVyOwogICAgIGNsYXNzIE5vZGU7CiAgICAgY2xhc3MgUGFnZUdy b3VwOwogICAgIGNsYXNzIFBsdWdpbkRhdGE7CkBAIC04NCw2ICs4Miw4IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICBjbGFzcyBTZXR0aW5nczsKICAgICBjbGFzcyBTcGVlY2hJbnB1dDsKICAg ICBjbGFzcyBTcGVlY2hJbnB1dENsaWVudDsKKyAgICBjbGFzcyBVc2VyTWVkaWFDbGllbnQ7Cisg ICAgY2xhc3MgVXNlck1lZGlhQ29udHJvbGxlcjsKICAgICBjbGFzcyBTdG9yYWdlTmFtZXNwYWNl OwogI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQogICAgIGNsYXNzIE5vdGlmaWNhdGlvblByZXNl bnRlcjsKQEAgLTExOCw3ICsxMTgsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAg ICBEZXZpY2VPcmllbnRhdGlvbkNsaWVudCogZGV2aWNlT3JpZW50YXRpb25DbGllbnQ7CiAgICAg ICAgICAgICBSZWZQdHI8QmFja0ZvcndhcmRMaXN0PiBiYWNrRm9yd2FyZENsaWVudDsKICAgICAg ICAgICAgIFNwZWVjaElucHV0Q2xpZW50KiBzcGVlY2hJbnB1dENsaWVudDsKLSAgICAgICAgICAg IE1lZGlhU3RyZWFtQ2xpZW50KiBtZWRpYVN0cmVhbUNsaWVudDsKKyAgICAgICAgICAgIFVzZXJN ZWRpYUNsaWVudCogdXNlck1lZGlhQ2xpZW50OwogICAgICAgICB9OwogCiAgICAgICAgIFBhZ2Uo UGFnZUNsaWVudHMmKTsKQEAgLTE4NCwxMiArMTg0LDEyIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgRGV2aWNlTW90aW9uQ29udHJvbGxlciogZGV2aWNlTW90aW9uQ29udHJvbGxlcigp IGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlTW90aW9uQ29udHJvbGxlci5nZXQoKTsgfQogICAgICAg ICBEZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIqIGRldmljZU9yaWVudGF0aW9uQ29udHJvbGxl cigpIGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyLmdldCgpOyB9 CiAjZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBNZWRpYVN0cmVhbUNv bnRyb2xsZXIqIG1lZGlhU3RyZWFtQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fbWVkaWFT dHJlYW1Db250cm9sbGVyLmdldCgpOyB9Ci0jZW5kaWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNI KQogICAgICAgICBTcGVlY2hJbnB1dCogc3BlZWNoSW5wdXQoKTsKICNlbmRpZgorI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCisgICAgICAgIFVzZXJNZWRpYUNvbnRyb2xsZXIqIHVzZXJNZWRpYUNv bnRyb2xsZXIoKSBjb25zdCB7IHJldHVybiBtX3VzZXJNZWRpYUNvbnRyb2xsZXIuZ2V0KCk7IH0K KyNlbmRpZgogICAgICAgICBTZXR0aW5ncyogc2V0dGluZ3MoKSBjb25zdCB7IHJldHVybiBtX3Nl dHRpbmdzLmdldCgpOyB9CiAgICAgICAgIFByb2dyZXNzVHJhY2tlciogcHJvZ3Jlc3MoKSBjb25z dCB7IHJldHVybiBtX3Byb2dyZXNzLmdldCgpOyB9CiAgICAgICAgIEJhY2tGb3J3YXJkQ29udHJv bGxlciogYmFja0ZvcndhcmQoKSBjb25zdCB7IHJldHVybiBtX2JhY2tGb3J3YXJkQ29udHJvbGxl ci5nZXQoKTsgfQpAQCAtMzQ4LDEzICszNDgsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICBPd25QdHI8RGV2aWNlTW90aW9uQ29udHJvbGxlcj4gbV9kZXZpY2VNb3Rpb25Db250cm9s bGVyOwogICAgICAgICBPd25QdHI8RGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyPiBtX2Rldmlj ZU9yaWVudGF0aW9uQ29udHJvbGxlcjsKICNlbmRpZgotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0p Ci0gICAgICAgIE93blB0cjxNZWRpYVN0cmVhbUNvbnRyb2xsZXI+IG1fbWVkaWFTdHJlYW1Db250 cm9sbGVyOwotI2VuZGlmCiAjaWYgRU5BQkxFKElOUFVUX1NQRUVDSCkKICAgICAgICAgU3BlZWNo SW5wdXRDbGllbnQqIG1fc3BlZWNoSW5wdXRDbGllbnQ7CiAgICAgICAgIE93blB0cjxTcGVlY2hJ bnB1dD4gbV9zcGVlY2hJbnB1dDsKICNlbmRpZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisg ICAgICAgIE93blB0cjxVc2VyTWVkaWFDb250cm9sbGVyPiBtX3VzZXJNZWRpYUNvbnRyb2xsZXI7 CisjZW5kaWYKICAgICAgICAgT3duUHRyPFNldHRpbmdzPiBtX3NldHRpbmdzOwogICAgICAgICBP d25QdHI8UHJvZ3Jlc3NUcmFja2VyPiBtX3Byb2dyZXNzOwogICAgICAgICAK 114178 2011-11-08 17:01:15 -0800 2011-11-10 05:18:21 -0800 Updated patch usermedia_simple_controller_2.patch text/plain 63213 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1MDNiYmFmLi4zNTIzNTFlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzAg QEAKKzIwMTEtMTEtMDggIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudC9jb250cm9sbGVyIGZvciB1 c2VyIGNvbnNlbnQgaW4gZ2V0VXNlck1lZGlhKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcwODk3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBvbmUgaW4gYSBzZXJpZXMgb2YgcGF0Y2hlcyB0 aGF0IHVwZGF0ZSB0aGUgTWVkaWFTdHJlYW0gZmVhdHVyZQorICAgICAgICB0byB1c2UgV2ViQ29y ZSBwbGF0Zm9ybSBpbnRlcmZhY2VzLgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVz dHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFdlYkNvcmUu Z3lwaToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oOiBSZW1vdmVk LgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHA6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmg6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3Bw OiBSZW1vdmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyLmg6IFJlbW92ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50Lmg6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ2xpZW50Ojp+VXNlck1lZGlhQ2xp ZW50KToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpVc2VyTWVkaWFDb250 cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6On5Vc2VyTWVk aWFDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OnJl cXVlc3RVc2VyTWVkaWEpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6 Y2FuY2VsVXNlck1lZGlhUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250 cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0U3VjY2VlZGVkKToKKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYUNvbnRyb2xsZXI6OnVzZXJNZWRpYVJlcXVlc3RGYWlsZWQpOgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6cXVlcnlVc2VyTWVkaWEpOgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUXVlcnlDb21wbGV0ZWQpOgorICAg ICAgICAqIG1lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpjbGllbnQpOgorICAgICAgICAqIG1lZGlh c3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1 ZXN0OjpVc2VyTWVkaWFSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6On5Vc2VyTWVkaWFSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6OnBhcnNlT3B0aW9ucyk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0Ojpm cmFtZURlc3Ryb3llZCk6CisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5o OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmF1ZGlvKToKKyAg ICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnZpZGVvKToKKyAgICAgICAgKFdlYkNv cmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNhbWVyYVByZWZlcmVuY2VVc2VyKToKKyAgICAgICAgKFdl YkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCk6Cisg ICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpmcmFtZSk6CisgICAgICAgIChXZWJD b3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KToKKyAgICAgICAg KFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29y ZTo6VXNlck1lZGlhUmVxdWVzdDo6Y2xlYXJDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6 OlVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpV c2VyTWVkaWFSZXF1ZXN0OjplcnJvckNhbGxiYWNrKToKKyAgICAgICAgKiBwYWdlL0NhbGxiYWNr VGFzay5oOiBSZW1vdmVkLgorICAgICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RnJhbWU6OkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp+RnJhbWUpOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OnBhZ2VEZXN0cm95ZWQpOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWU6OnRyYW5zZmVyQ2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQpOgorICAgICAgICAqIHBh Z2UvRnJhbWUuaDoKKyAgICAgICAgKiBwYWdlL05hdmlnYXRvci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpOYXZpZ2F0b3I6OmRpc2Nvbm5lY3RGcmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpOYXZp Z2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYSk6CisgICAgICAgICogcGFnZS9OYXZpZ2F0b3IuaDoK KyAgICAgICAgKiBwYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaDoKKyAgICAg ICAgKiBwYWdlL1BhZ2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6UGFnZSk6CisgICAg ICAgIChXZWJDb3JlOjpQYWdlOjpQYWdlQ2xpZW50czo6UGFnZUNsaWVudHMpOgorICAgICAgICAq IHBhZ2UvUGFnZS5oOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6dXNlck1lZGlhQ29udHJvbGxl cik6CisKIDIwMTEtMTEtMDggIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAg ICAgICA8cmRhcjovL3Byb2JsZW0vMTAyNjIyMjU+IEFsbG93IFJlbmRlclZpZXcgdG8gaGF2ZSBj b2x1bW5zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtIGIv U291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQppbmRleCBhZTQwOWM3Li5jYWM0ZTkw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAgLTIyNzIsMTMgKzIyNzIsOCBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL0xvY2FsTWVk aWFTdHJlYW0uaCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW0uY3Bw IFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbS5oIFwKLQlTb3VyY2Uv V2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oIFwKLQlTb3VyY2UvV2ViQ29y ZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwIFwKLQlTb3VyY2UvV2ViQ29y ZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCBcCiAJU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL21lZGlh c3RyZWFtL01lZGlhU3RyZWFtRXZlbnQuaCBcCi0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUxpc3QuaCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1SZWdpc3RyeS5jcHAgXApAQCAtMjI5MCw2ICsyMjg1LDExIEBAIHdlYmNvcmVfc291cmNl cyArPSBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uY3BwIFwK IAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5oIFwKIAlTb3VyY2Uv V2ViQ29yZS9tZWRpYXN0cmVhbS9TaWduYWxpbmdDYWxsYmFjay5oIFwKKwlTb3VyY2UvV2ViQ29y ZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaCBcCisJU291cmNlL1dlYkNvcmUvbWVkaWFz dHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaCBcCisJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v VXNlck1lZGlhUmVxdWVzdC5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJN ZWRpYVJlcXVlc3QuaCBcCiAJU291cmNlL1dlYkNvcmUvbm90aWZpY2F0aW9ucy9Ob3RpZmljYXRp b25DZW50ZXIuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9ub3RpZmljYXRpb25zL05vdGlmaWNhdGlv bkNlbnRlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9ub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNv bnRlbnRzLmggXApAQCAtMjMxMCw3ICsyMzEwLDYgQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlT b3VyY2UvV2ViQ29yZS9wYWdlL0FkanVzdFZpZXdTaXplT3JOb3QuaCBcCiAJU291cmNlL1dlYkNv cmUvcGFnZS9CYXJJbmZvLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9CYXJJbmZvLmggXAot CVNvdXJjZS9XZWJDb3JlL3BhZ2UvQ2FsbGJhY2tUYXNrLmggXAogCVNvdXJjZS9XZWJDb3JlL3Bh Z2UvQ2hyb21lLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9DaHJvbWUuaCBcCiAJU291cmNl L1dlYkNvcmUvcGFnZS9DaHJvbWVDbGllbnQuaCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggNTkzZWQ1 OS4uZjBkMzZhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMjkwMiwxMSArMjkwMiw2IEBACiAgICAg ICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW0uaCcsCiAgICAgICAgICAgICAnbWVkaWFz dHJlYW0vTWVkaWFTdHJlYW1FdmVudC5jcHAnLAogICAgICAgICAgICAgJ21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtRXZlbnQuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1D bGllbnQuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVy LmNwcCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmgn LAotICAgICAgICAgICAgJ21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNw cCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIu aCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0LmNwcCcsCiAgICAg ICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0LmgnLAogICAgICAgICAgICAgJ21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtVHJhY2suY3BwJywKQEAgLTI5MTgsNiArMjkxMywxMSBAQAog ICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmNwcCcsCiAgICAgICAgICAg ICAnbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uaCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJl YW0vU2lnbmFsaW5nQ2FsbGJhY2suaCcsCisgICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNlck1l ZGlhQ2xpZW50LmgnLAorICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xs ZXIuY3BwJywKKyAgICAgICAgICAgICdtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmgn LAorICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwJywKKyAgICAg ICAgICAgICdtZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmgnLAogICAgICAgICAgICAgJ25v dGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uLmNwcCcsCiAgICAgICAgICAgICAnbm90aWZpY2F0aW9u cy9Ob3RpZmljYXRpb24uaCcsCiAgICAgICAgICAgICAnbm90aWZpY2F0aW9ucy9Ob3RpZmljYXRp b25DZW50ZXIuY3BwJywKQEAgLTI5MjUsNyArMjkyNSw2IEBACiAgICAgICAgICAgICAnbm90aWZp Y2F0aW9ucy9Ob3RpZmljYXRpb25Db250ZW50cy5oJywKICAgICAgICAgICAgICdwYWdlL0Jhcklu Zm8uY3BwJywKICAgICAgICAgICAgICdwYWdlL0JhckluZm8uaCcsCi0gICAgICAgICAgICAncGFn ZS9DYWxsYmFja1Rhc2suaCcsCiAgICAgICAgICAgICAncGFnZS9DaHJvbWUuY3BwJywKICAgICAg ICAgICAgICdwYWdlL0NvbnNvbGUuY3BwJywKICAgICAgICAgICAgICdwYWdlL0NvbnRlbnRTZWN1 cml0eVBvbGljeS5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v TWVkaWFTdHJlYW1DbGllbnQuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3Ry ZWFtQ2xpZW50LmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGFmOTA5NWMuLjAwMDAw MDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaAor KysgL2Rldi9udWxsCkBAIC0xLDU4ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEg R29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9S UyBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RQotICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAotICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpZm5kZWYgTWVk aWFTdHJlYW1DbGllbnRfaAotI2RlZmluZSBNZWRpYVN0cmVhbUNsaWVudF9oCi0KLSNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLQotbmFtZXNwYWNl IFdlYkNvcmUgewotCi1jbGFzcyBTZWN1cml0eU9yaWdpbjsKLQotZW51bSBHZW5lcmF0ZVN0cmVh bU9wdGlvbkZsYWcgewotICAgIEdlbmVyYXRlU3RyZWFtUmVxdWVzdEF1ZGlvID0gMSwKLSAgICBH ZW5lcmF0ZVN0cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ1VzZXIgPSAxIDw8IDEsCi0gICAgR2VuZXJh dGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdFbnZpcm9ubWVudCA9IDEgPDwgMiwKLX07Ci0KLXR5 cGVkZWYgdW5zaWduZWQgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFnczsKLQotY2xhc3MgTWVkaWFT dHJlYW1DbGllbnQgewotcHVibGljOgotICAgIC8vIE1lZGlhU3RyZWFtIGZ1bmN0aW9ucy4KLSAg ICB2aXJ0dWFsIHZvaWQgbWVkaWFTdHJlYW1EZXN0cm95ZWQoKSA9IDA7Ci0gICAgdmlydHVhbCB2 b2lkIGdlbmVyYXRlU3RyZWFtKGludCByZXF1ZXN0SWQsIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxh Z3MsIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+KSA9IDA7Ci0KLXByb3RlY3RlZDoKLSAgICB2 aXJ0dWFsIH5NZWRpYVN0cmVhbUNsaWVudCgpIHsgfQotfTsKLQotfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2VuZGlmIC8vIE1lZGlh U3RyZWFtQ2xpZW50X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbUNvbnRyb2xsZXIuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNGUz MDhlLi4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFt Q29udHJvbGxlci5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSwxMjMgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAg ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE Ci0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0g Ki8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ29udHJvbGxl ci5oIgotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUgIk1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKLSNpbmNsdWRl IDx3dGYvVmVjdG9yLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgTWVkaWFTdHJl YW1Db250cm9sbGVyOjpSZXF1ZXN0IHsKLXB1YmxpYzoKLSAgICBSZXF1ZXN0KCkKLSAgICAgICAg OiBtX2xvY2FsSWQoMCkKLSAgICAgICAgLCBtX2ZyYW1lQ29udHJvbGxlcigwKSB7IH0KLQotICAg IFJlcXVlc3QoaW50IGxvY2FsSWQsIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNv bnRyb2xsZXIpCi0gICAgICAgIDogbV9sb2NhbElkKGxvY2FsSWQpCi0gICAgICAgICwgbV9mcmFt ZUNvbnRyb2xsZXIoZnJhbWVDb250cm9sbGVyKSB7IH0KLQotICAgIGludCBsb2NhbElkKCkgY29u c3QgeyByZXR1cm4gbV9sb2NhbElkOyB9Ci0gICAgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIq IGZyYW1lQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWVDb250cm9sbGVyOyB9Ci0K LXByaXZhdGU6Ci0gICAgaW50IG1fbG9jYWxJZDsKLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlciogbV9mcmFtZUNvbnRyb2xsZXI7Ci19OwotCi1NZWRpYVN0cmVhbUNvbnRyb2xsZXI6Ok1l ZGlhU3RyZWFtQ29udHJvbGxlcihNZWRpYVN0cmVhbUNsaWVudCogY2xpZW50KQotICAgIDogbV9j bGllbnQoY2xpZW50KQotICAgICwgbV9uZXh0R2xvYmFsUmVxdWVzdElkKDEpCi17Ci19Ci0KLU1l ZGlhU3RyZWFtQ29udHJvbGxlcjo6fk1lZGlhU3RyZWFtQ29udHJvbGxlcigpCi17Ci0gICAgaWYg KG1fY2xpZW50KQotICAgICAgICBtX2NsaWVudC0+bWVkaWFTdHJlYW1EZXN0cm95ZWQoKTsKLX0K LQotYm9vbCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OmlzQ2xpZW50QXZhaWxhYmxlKCkgY29uc3QK LXsKLSAgICByZXR1cm4gbV9jbGllbnQ7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1Db250cm9sbGVy Ojp1bnJlZ2lzdGVyRnJhbWVDb250cm9sbGVyKE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBm cmFtZUNvbnRyb2xsZXIpCi17Ci0gICAgQVNTRVJUKGZyYW1lQ29udHJvbGxlcik7Ci0KLSAgICAv LyBEb25lIGluIHR3byBzdGVwcyB0byBhdm9pZCBwcm9ibGVtcyBhYm91dCBpdGVyYXRvcnMgYmVp bmcgaW52YWxpZGF0ZWQgd2hpbGUgcmVtb3ZpbmcuCi0gICAgVmVjdG9yPGludD4gZnJhbWVSZXF1 ZXN0czsKLSAgICBmb3IgKFJlcXVlc3RNYXA6Oml0ZXJhdG9yIGl0ID0gbV9yZXF1ZXN0cy5iZWdp bigpOyBpdCAhPSBtX3JlcXVlc3RzLmVuZCgpOyArK2l0KQotICAgICAgICBpZiAoaXQtPnNlY29u ZC5mcmFtZUNvbnRyb2xsZXIoKSA9PSBmcmFtZUNvbnRyb2xsZXIpCi0gICAgICAgICAgICBmcmFt ZVJlcXVlc3RzLmFwcGVuZChpdC0+Zmlyc3QpOwotCi0gICAgZm9yIChWZWN0b3I8aW50Pjo6aXRl cmF0b3IgaXQgPSBmcmFtZVJlcXVlc3RzLmJlZ2luKCk7IGl0ICE9IGZyYW1lUmVxdWVzdHMuZW5k KCk7ICsraXQpCi0gICAgICAgIG1fcmVxdWVzdHMucmVtb3ZlKCppdCk7Ci19Ci0KLWludCBNZWRp YVN0cmVhbUNvbnRyb2xsZXI6OnJlZ2lzdGVyUmVxdWVzdChpbnQgbG9jYWxJZCwgTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlcikKLXsKLSAgICBBU1NFUlQobG9jYWxJ ZCA+IDApOwotICAgIEFTU0VSVChmcmFtZUNvbnRyb2xsZXIpOwotICAgIG1fcmVxdWVzdHMuYWRk KG1fbmV4dEdsb2JhbFJlcXVlc3RJZCwgUmVxdWVzdChsb2NhbElkLCBmcmFtZUNvbnRyb2xsZXIp KTsKLSAgICByZXR1cm4gbV9uZXh0R2xvYmFsUmVxdWVzdElkKys7Ci19Ci0KLXZvaWQgTWVkaWFT dHJlYW1Db250cm9sbGVyOjpnZW5lcmF0ZVN0cmVhbShNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ciogZnJhbWVDb250cm9sbGVyLCBpbnQgbG9jYWxJZCwgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFn cyBmbGFncywgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4gc2VjdXJpdHlPcmlnaW4pCi17Ci0g ICAgQVNTRVJUKG1fY2xpZW50KTsKLSAgICBpbnQgY29udHJvbGxlclJlcXVlc3RJZCA9IHJlZ2lz dGVyUmVxdWVzdChsb2NhbElkLCBmcmFtZUNvbnRyb2xsZXIpOwotICAgIG1fY2xpZW50LT5nZW5l cmF0ZVN0cmVhbShjb250cm9sbGVyUmVxdWVzdElkLCBmbGFncywgc2VjdXJpdHlPcmlnaW4pOwot fQotCi12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGVkKGludCBjb250 cm9sbGVyUmVxdWVzdElkLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcykK LXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIGZyYW1lIGNvbnRyb2xsZXIgY2FuIGhh dmUgYmVlbiBkZXN0cm95ZWQgd2hpbGUgdGhlIHJlcXVlc3QgcmVwbHkgd2FzIGNvbWluZyBiYWNr LgotICAgIGlmIChtX3JlcXVlc3RzLmNvbnRhaW5zKGNvbnRyb2xsZXJSZXF1ZXN0SWQpKSB7Ci0g ICAgICAgIGNvbnN0IFJlcXVlc3QmIHJlcXVlc3QgPSBtX3JlcXVlc3RzLmdldChjb250cm9sbGVy UmVxdWVzdElkKTsKLSAgICAgICAgbV9yZXF1ZXN0cy5yZW1vdmUoY29udHJvbGxlclJlcXVlc3RJ ZCk7Ci0gICAgICAgIEFTU0VSVChyZXF1ZXN0LmZyYW1lQ29udHJvbGxlcigpKTsKLSAgICAgICAg cmVxdWVzdC5mcmFtZUNvbnRyb2xsZXIoKS0+c3RyZWFtR2VuZXJhdGVkKHJlcXVlc3QubG9jYWxJ ZCgpLCBzb3VyY2VzKTsKLSAgICB9Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1Db250cm9sbGVyOjpz dHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCBjb250cm9sbGVyUmVxdWVzdElkLCBOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCi17Ci0gICAgLy8gRG9uJ3QgYXNzZXJ0IHNp bmNlIHRoZSBmcmFtZSBjb250cm9sbGVyIGNhbiBoYXZlIGJlZW4gZGVzdHJveWVkIHdoaWxlIHRo ZSByZXF1ZXN0IHJlcGx5IHdhcyBjb21pbmcgYmFjay4KLSAgICBpZiAobV9yZXF1ZXN0cy5jb250 YWlucyhjb250cm9sbGVyUmVxdWVzdElkKSkgewotICAgICAgICBjb25zdCBSZXF1ZXN0JiByZXF1 ZXN0ID0gbV9yZXF1ZXN0cy5nZXQoY29udHJvbGxlclJlcXVlc3RJZCk7Ci0gICAgICAgIG1fcmVx dWVzdHMucmVtb3ZlKGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAgICAgICByZXF1ZXN0LmZyYW1l Q29udHJvbGxlcigpLT5zdHJlYW1HZW5lcmF0aW9uRmFpbGVkKHJlcXVlc3QubG9jYWxJZCgpLCBj b2RlKTsKLSAgICB9Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVO QUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtQ29udHJvbGxlci5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ODkz MDk0Li4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFt Q29udHJvbGxlci5oCisrKyAvZGV2L251bGwKQEAgLTEsNzQgKzAsMCBAQAotLyoKLSAqIENvcHly aWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0g KiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04K LSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8K LQotI2lmbmRlZiBNZWRpYVN0cmVhbUNvbnRyb2xsZXJfaAotI2RlZmluZSBNZWRpYVN0cmVhbUNv bnRyb2xsZXJfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUgIk1lZGlh U3RyZWFtQ2xpZW50LmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Tb3VyY2UuaCIKLSNpbmNsdWRl ICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvci5oIgotI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0j aW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KLSNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KLSNp bmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQot Y2xhc3MgTWVkaWFTdHJlYW1DbGllbnQ7Ci1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl cjsKLWNsYXNzIFNlY3VyaXR5T3JpZ2luOwotCi1jbGFzcyBNZWRpYVN0cmVhbUNvbnRyb2xsZXIg ewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lZGlhU3RyZWFtQ29udHJvbGxlcik7Ci1wdWJs aWM6Ci0gICAgTWVkaWFTdHJlYW1Db250cm9sbGVyKE1lZGlhU3RyZWFtQ2xpZW50Kik7Ci0gICAg dmlydHVhbCB+TWVkaWFTdHJlYW1Db250cm9sbGVyKCk7Ci0KLSAgICBib29sIGlzQ2xpZW50QXZh aWxhYmxlKCkgY29uc3Q7Ci0gICAgdm9pZCB1bnJlZ2lzdGVyRnJhbWVDb250cm9sbGVyKE1lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyKik7Ci0KLSAgICB2b2lkIGdlbmVyYXRlU3RyZWFtKE1lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyKiwgaW50IHJlcXVlc3RJZCwgR2VuZXJhdGVTdHJlYW1PcHRp b25GbGFncywgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4pOwotCi0gICAgdm9pZCBzdHJlYW1H ZW5lcmF0ZWQoaW50IHJlcXVlc3RJZCwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImIHNv dXJjZXMpOwotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGlvbkZhaWxlZChpbnQgcmVxdWVzdElkLCBO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6RXJyb3JDb2RlKTsKLQotcHJpdmF0ZToKLSAgICBpbnQg cmVnaXN0ZXJSZXF1ZXN0KGludCBsb2NhbFJlcXVlc3RJZCwgTWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIqKTsKLQotICAgIGNsYXNzIFJlcXVlc3Q7Ci0gICAgdHlwZWRlZiBIYXNoTWFwPGludCwg UmVxdWVzdD4gUmVxdWVzdE1hcDsKLQotICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0czsKLQotICAg IE1lZGlhU3RyZWFtQ2xpZW50KiBtX2NsaWVudDsKLSAgICBpbnQgbV9uZXh0R2xvYmFsUmVxdWVz dElkOwotfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1F RElBX1NUUkVBTSkKLQotI2VuZGlmIC8vIE1lZGlhU3RyZWFtQ29udHJvbGxlcl9oCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlci5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEzYTE4Y2IuLjAwMDAwMDAK LS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXIuY3BwCisrKyAvZGV2L251bGwKQEAgLTEsMjgyICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQg KEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K LSAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgot ICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENP TlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRQotICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBP UiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UwotICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBB TlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAotICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNp bmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5o IgotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUgIkRPTVdpbmRvdy5oIgot I2luY2x1ZGUgIkRvY3VtZW50LmgiCi0jaW5jbHVkZSAiRnJhbWUuaCIKLSNpbmNsdWRlICJMb2Nh bE1lZGlhU3RyZWFtLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgiCi0jaW5j bHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgotI2luY2x1ZGUgIk5hdmln YXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgotI2luY2x1ZGUgIlBhZ2UuaCIKLSNpbmNs dWRlICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+Ci0KLW5h bWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OlJl cXVlc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXF1ZXN0PiB7Ci0gICAgV1RGX01BS0VfTk9OQ09Q WUFCTEUoUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgdmlydHVhbCB+UmVxdWVzdCgpIHsgfQotCi0g ICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0 IHsgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dDsgfQotICAgIHZpcnR1YWwgYm9vbCBp c0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9Ci0KLSAgICB2 aXJ0dWFsIHZvaWQgYWJvcnQoKSA9IDA7Ci0KLXByb3RlY3RlZDoKLSAgICBSZXF1ZXN0KFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0gICAgICAgIDogbV9z Y3JpcHRFeGVjdXRpb25Db250ZXh0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpIHsgfQotCi1wcml2 YXRlOgotICAgIC8vIFRoaXMgaXMgZ3VhcmFudGVlZCB0byBoYXZlIHRoZSBsaWZldGltZSBvZiB0 aGUgRnJhbWUsIGFuZCBpdCdzIG9ubHkgdXNlZCB0byBtYWtlCi0gICAgLy8gdGhlIGNhbGxiYWNr IGFzeW5jaHJvbm91cy4gVGhlIG9yaWdpbmFsIGNhbGxiYWNrIGNvbnRleHQgaXMgdXNlZCBpbiB0 aGUgY2FsbC4KLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQ7Ci19OwotCi1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6R2VuZXJhdGVT dHJlYW1SZXF1ZXN0IDogcHVibGljIFJlcXVlc3QgewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxF KEdlbmVyYXRlU3RyZWFtUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8 R2VuZXJhdGVTdHJlYW1SZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2Ny aXB0RXhlY3V0aW9uQ29udGV4dCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxs YmFjaz4gc3VjY2Vzc0NhbGxiYWNrLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxs YmFjaz4gZXJyb3JDYWxsYmFjaykKLSAgICB7Ci0gICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcg R2VuZXJhdGVTdHJlYW1SZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIHN1Y2Nlc3NDYWxs YmFjaywgZXJyb3JDYWxsYmFjaykpOwotICAgIH0KLQotICAgIHZpcnR1YWwgfkdlbmVyYXRlU3Ry ZWFtUmVxdWVzdCgpIHsgfQotCi0gICAgdmlydHVhbCBib29sIGlzR2VuZXJhdGVTdHJlYW1SZXF1 ZXN0KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQotCi0gICAgdmlydHVhbCB2b2lkIGFib3J0KCkK LSAgICB7Ci0gICAgICAgIGlmIChtX2Vycm9yQ2FsbGJhY2spIHsKLSAgICAgICAgICAgIFJlZlB0 cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJv cjo6Y3JlYXRlKE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpQRVJNSVNTSU9OX0RFTklFRCk7Ci0g ICAgICAgICAgICAvLyBUaGUgY2FsbGJhY2sgaXRzZWxmIGlzIG1hZGUgd2l0aCB0aGUgSlMgY2Fs bGJhY2sncyBjb250ZXh0LCBub3Qgd2l0aCB0aGUgZnJhbWUncyBjb250ZXh0LgotICAgICAgICAg ICAgbV9lcnJvckNhbGxiYWNrLT5zY2hlZHVsZUNhbGxiYWNrKHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKSwgZXJyb3IpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgUGFzc1JlZlB0cjxOYXZpZ2F0 b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0 dXJuIG1fc3VjY2Vzc0NhbGxiYWNrOyB9Ci0gICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKCkgY29uc3QgeyByZXR1cm4gbV9lcnJvckNh bGxiYWNrOyB9Ci0KLXByaXZhdGU6Ci0gICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBz dWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2 aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKLSAgICAgICAgOiBS ZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0gICAgICAgICwgbV9zdWNjZXNzQ2FsbGJh Y2soc3VjY2Vzc0NhbGxiYWNrKQotICAgICAgICAsIG1fZXJyb3JDYWxsYmFjayhlcnJvckNhbGxi YWNrKSB7IH0KLQotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+ IG1fc3VjY2Vzc0NhbGxiYWNrOwotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNh bGxiYWNrPiBtX2Vycm9yQ2FsbGJhY2s7Ci19OwotCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydChpbnQgcmVxdWVzdElkKQotewotICAgIGdldChyZXF1 ZXN0SWQpLT5hYm9ydCgpOwotICAgIHJlbW92ZShyZXF1ZXN0SWQpOwotfQotCi12b2lkIE1lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydEFsbCgpCi17Ci0gICAgd2hp bGUgKCFpc0VtcHR5KCkpIHsKLSAgICAgICAgYmVnaW4oKS0+c2Vjb25kLT5hYm9ydCgpOwotICAg ICAgICByZW1vdmUoYmVnaW4oKSk7Ci0gICAgfQotfQotCi1NZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlcjo6TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoRnJhbWUqIGZyYW1lKQotICAgIDogbV9m cmFtZShmcmFtZSkKLSAgICAsIG1faXNJbkRldGFjaGVkU3RhdGUoZmFsc2UpCi17Ci0gICAgaWYg KCFpc0NsaWVudEF2YWlsYWJsZSgpKQotICAgICAgICBlbnRlckRldGFjaGVkU3RhdGUoKTsKLX0K LQotTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6On5NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl cigpCi17Ci19Ci0KLVNlY3VyaXR5T3JpZ2luKiBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6 c2VjdXJpdHlPcmlnaW4oKSBjb25zdAotewotICAgIHJldHVybiBtX2ZyYW1lID8gbV9mcmFtZS0+ ZXhpc3RpbmdET01XaW5kb3coKS0+c2VjdXJpdHlPcmlnaW4oKSA6IDA7Ci19Ci0KLVNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpzY3JpcHRFeGVjdXRp b25Db250ZXh0KCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSA/IG1fZnJhbWUtPmV4aXN0 aW5nRE9NV2luZG93KCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA6IDA7Ci19Ci0KLU1lZGlh U3RyZWFtQ29udHJvbGxlciogTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnBhZ2VDb250cm9s bGVyKCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSAmJiBtX2ZyYW1lLT5wYWdlKCkgPyBt X2ZyYW1lLT5wYWdlKCktPm1lZGlhU3RyZWFtQ29udHJvbGxlcigpIDogMDsKLX0KLQotdm9pZCBN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZW50ZXJEZXRhY2hlZFN0YXRlKCkKLXsKLSAgICBp ZiAobV9pc0luRGV0YWNoZWRTdGF0ZSkgewotICAgICAgICBBU1NFUlQobV9yZXF1ZXN0cy5pc0Vt cHR5KCkpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgbV9yZXF1ZXN0cy5hYm9ydEFs bCgpOwotICAgIG1faXNJbkRldGFjaGVkU3RhdGUgPSB0cnVlOwotfQotCi1ib29sIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyOjppc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0Ci17Ci0gICAgaWYg KG1faXNJbkRldGFjaGVkU3RhdGUpCi0gICAgICAgIHJldHVybiBmYWxzZTsKLQotICAgIE1lZGlh U3RyZWFtQ29udHJvbGxlciogY29udHJvbGxlciA9IHBhZ2VDb250cm9sbGVyKCk7Ci0gICAgcmV0 dXJuIGNvbnRyb2xsZXIgJiYgY29udHJvbGxlci0+aXNDbGllbnRBdmFpbGFibGUoKTsKLX0KLQot Ly8gQ2FsbGVkIGFsc28gd2hlbiB0aGUgZnJhbWUgaXMgZGV0YWNoZWQgZnJvbSB0aGUgcGFnZSwg aW4gd2hpY2ggY2FzZSB0aGUgcGFnZSBjb250cm9sbGVyIHdpbGwgcmVtYWluIGFsaXZlLgotdm9p ZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZGlzY29ubmVjdFBhZ2UoKQotewotICAgIGlm IChwYWdlQ29udHJvbGxlcigpKQotICAgICAgICBwYWdlQ29udHJvbGxlcigpLT51bnJlZ2lzdGVy RnJhbWVDb250cm9sbGVyKHRoaXMpOwotCi0gICAgZW50ZXJEZXRhY2hlZFN0YXRlKCk7Ci19Ci0K LS8vIENhbGxlZCB3aGVuIHRoZSBmcmFtZSBpcyBiZWluZyBkZXN0cm95ZWQuIFNpbmNlIHRoZSBm cmFtZSBjb250cm9sbGVyIGlzIG93bmVkIGJ5IHRoZSBmcmFtZSBpdCB3aWxsIGRpZSBzaG9ydGx5 IGFmdGVyIHRoaXMuCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpkaXNjb25uZWN0 RnJhbWUoKQotewotICAgIGRpc2Nvbm5lY3RQYWdlKCk7Ci0KLSAgICBBU1NFUlQobV9yZXF1ZXN0 cy5pc0VtcHR5KCkpOwotCi0gICAgbV9mcmFtZSA9IDA7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXI6OnRyYW5zZmVyVG9OZXdQYWdlKFBhZ2UqKQotewotICAgIC8vIEZJWE1F OiBJbiB0aGUgZnV0dXJlIHdlIHNob3VsZCBrZWVwIHJ1bm5pbmcgdGhlIG1lZGlhIHN0cmVhbSBz ZXJ2aWNlcyB3aGlsZSB0cmFuc2ZlcmluZyBmcmFtZXMgYmV0d2VlbiBwYWdlcy4KLSAgICAvLyBI b3dldmVyLCB1bnRpbCBhIHByb3BlciB3YXkgdG8gZG8gdGhpcyBpcyBkZWNpZGVkLCB3ZSdyZSBz aHV0dGluZyBkb3duIHNlcnZpY2VzLgotICAgIGRpc2Nvbm5lY3RQYWdlKCk7Ci19Ci0KLUdlbmVy YXRlU3RyZWFtT3B0aW9uRmxhZ3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnBhcnNlR2Vu ZXJhdGVTdHJlYW1PcHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucykKLXsKLSAgICBHZW5lcmF0 ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzID0gMDsKLSAgICBWZWN0b3I8U3RyaW5nPiBvcHRpb25M aXN0OwotICAgIG9wdGlvbnMuc3BsaXQoJywnLCBvcHRpb25MaXN0KTsKLQotICAgIGZvciAoVmVj dG9yPFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIG9wdGlvbiA9IG9wdGlvbkxpc3QuYmVnaW4oKTsg b3B0aW9uICE9IG9wdGlvbkxpc3QuZW5kKCk7ICsrb3B0aW9uKSB7Ci0gICAgICAgIFZlY3RvcjxT dHJpbmc+IHN1Ym9wdGlvbkxpc3Q7Ci0gICAgICAgIG9wdGlvbi0+c3BsaXQoJyAnLCBzdWJvcHRp b25MaXN0KTsKLQotICAgICAgICBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgpID09ICJhdWRpbyIp Ci0gICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RBdWRpbzsKLSAgICAg ICAgZWxzZSBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgpID09ICJ2aWRlbyIpIHsKLSAgICAgICAg ICAgIGJvb2wgdmlkZW9TdWJvcHRpb25zID0gZmFsc2U7Ci0gICAgICAgICAgICBWZWN0b3I8U3Ry aW5nPjo6Y29uc3RfaXRlcmF0b3Igc3Vib3B0aW9uID0gc3Vib3B0aW9uTGlzdC5iZWdpbigpOwot ICAgICAgICAgICAgZm9yICgrK3N1Ym9wdGlvbjsgc3Vib3B0aW9uICE9IHN1Ym9wdGlvbkxpc3Qu ZW5kKCk7ICsrc3Vib3B0aW9uKQotICAgICAgICAgICAgICAgIGlmICgqc3Vib3B0aW9uID09ICJ1 c2VyIikgewotICAgICAgICAgICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVl c3RWaWRlb0ZhY2luZ1VzZXI7Ci0gICAgICAgICAgICAgICAgICAgIHZpZGVvU3Vib3B0aW9ucyA9 IHRydWU7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIGlmICgqc3Vib3B0aW9uID09ICJlbnZpcm9u bWVudCIpIHsKLSAgICAgICAgICAgICAgICAgICAgZmxhZ3MgfD0gR2VuZXJhdGVTdHJlYW1SZXF1 ZXN0VmlkZW9GYWNpbmdFbnZpcm9ubWVudDsKLSAgICAgICAgICAgICAgICAgICAgdmlkZW9TdWJv cHRpb25zID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIC8vIEFzayBm b3IgYWxsIGtpbmQgb2YgY2FtZXJhcyBpZiBubyBzdWJvcHRpb24gd2FzIHNwZWNpZmllZC4KLSAg ICAgICAgICAgIGlmICghdmlkZW9TdWJvcHRpb25zKQotICAgICAgICAgICAgICAgIGZsYWdzIHw9 IEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nVXNlciB8IEdlbmVyYXRlU3RyZWFtUmVx dWVzdFZpZGVvRmFjaW5nRW52aXJvbm1lbnQ7Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAgICByZXR1 cm4gZmxhZ3M7Ci19Ci0KLS8vIEltcGxlbWVudHMgdGhlIGdldFVzZXJNZWRpYSBtZXRob2QgZnJv bSBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNkb20t bmF2aWdhdG9yLWdldHVzZXJtZWRpYS4KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6 OmdlbmVyYXRlU3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0aW9ucywKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1l ZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRp YUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBFeGNlcHRpb25Db2RlJiBlYykKLXsKLSAgICBlYyA9IDA7 Ci0gICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2spCi0gICAgICAgIHJldHVybjsKLQotICAgIEdlbmVy YXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MgPSBwYXJzZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhv cHRpb25zKTsKLSAgICBpZiAoIWZsYWdzKSB7Ci0gICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9F UlI7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBpbnQgcmVxdWVzdElkID0gbV9yZXF1 ZXN0cy5nZXROZXh0SWQoKTsKLSAgICBtX3JlcXVlc3RzLmFkZChyZXF1ZXN0SWQsIEdlbmVyYXRl U3RyZWFtUmVxdWVzdDo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgc3VjY2Vzc0Nh bGxiYWNrLCBlcnJvckNhbGxiYWNrKSk7Ci0KLSAgICBpZiAoIWlzQ2xpZW50QXZhaWxhYmxlKCkp IHsKLSAgICAgICAgLy8gVGhpcyBtYWtlcyBzdXJlIHRvIGNhbGwgdGhlIGVycm9yIGNhbGxiYWNr IGlmIHByb3ZpZGVkLgotICAgICAgICBtX3JlcXVlc3RzLmFib3J0KHJlcXVlc3RJZCk7Ci0gICAg ICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBwYWdlQ29udHJvbGxlcigpLT5nZW5lcmF0ZVN0cmVh bSh0aGlzLCByZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0eU9yaWdpbigpKTsKLX0KLQotdm9pZCBN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGVkKGludCByZXF1ZXN0SWQs IGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewotICAgIC8vIERvbid0 IGFzc2VydCBzaW5jZSB0aGUgcmVxdWVzdCBjYW4gaGF2ZSBiZWVuIGFib3J0ZWQgYXMgYSByZXN1 bHQgb2YgZW1iZWRkZXIgZGV0YWNobWVudC4KLSAgICBpZiAoIW1fcmVxdWVzdHMuY29udGFpbnMo cmVxdWVzdElkKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKG1fcmVxdWVzdHMuZ2V0 KHJlcXVlc3RJZCktPmlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkpOwotCi0gICAgUmVmUHRyPEdl bmVyYXRlU3RyZWFtUmVxdWVzdD4gc3RyZWFtUmVxdWVzdCA9IHN0YXRpY19jYXN0PEdlbmVyYXRl U3RyZWFtUmVxdWVzdCo+KG1fcmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCkuZ2V0KCkpOwotICAgIFJl ZlB0cjxMb2NhbE1lZGlhU3RyZWFtPiBnZW5lcmF0ZWRTdHJlYW0gPSBMb2NhbE1lZGlhU3RyZWFt OjpjcmVhdGUoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCBzb3VyY2VzKTsKLSAgICBtX3JlcXVl c3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotICAgIHN0cmVhbVJlcXVlc3QtPnN1Y2Nlc3NDYWxsYmFj aygpLT5oYW5kbGVFdmVudChnZW5lcmF0ZWRTdHJlYW0uZ2V0KCkpOwotfQotCi12b2lkIE1lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyOjpzdHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0 SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUgY29kZSkKLXsKLSAgICAvLyBE b24ndCBhc3NlcnQgc2luY2UgdGhlIHJlcXVlc3QgY2FuIGhhdmUgYmVlbiBhYm9ydGVkIGFzIGEg cmVzdWx0IG9mIGVtYmVkZGVyIGRldGFjaG1lbnQuCi0gICAgaWYgKCFtX3JlcXVlc3RzLmNvbnRh aW5zKHJlcXVlc3RJZCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIEFTU0VSVChtX3JlcXVlc3Rz LmdldChyZXF1ZXN0SWQpLT5pc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpKTsKLQotICAgIFJlZlB0 cjxHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IHN0cmVhbVJlcXVlc3QgPSBzdGF0aWNfY2FzdDxHZW5l cmF0ZVN0cmVhbVJlcXVlc3QqPihtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQpLmdldCgpKTsKLSAg ICBtX3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotCi0gICAgaWYgKHN0cmVhbVJlcXVlc3Qt PmVycm9yQ2FsbGJhY2soKSkgewotICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJy b3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShjb2RlKTsKLSAgICAg ICAgc3RyZWFtUmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygpLT5oYW5kbGVFdmVudChlcnJvci5nZXQo KSk7Ci0gICAgfQotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFC TEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFt L01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IGY5MTI1NmQuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaAorKysgL2Rldi9udWxsCkBAIC0xLDEwNiArMCwwIEBA Ci0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAg UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0g KiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQot ICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElT Ci0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyX2gKLSNk ZWZpbmUgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXJfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NU UkVBTSkKLQotI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVh bUNsaWVudC5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtU291cmNlLmgiCi0jaW5jbHVkZSAiTmF2 aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIKLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotI2luY2x1 ZGUgPHd0Zi9IYXNoTWFwLmg+Ci0jaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5jbHVk ZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNz IEZyYW1lOwotY2xhc3MgTWVkaWFTdHJlYW1Db250cm9sbGVyOwotY2xhc3MgTmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjazsKLWNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxs YmFjazsKLWNsYXNzIFBhZ2U7Ci1jbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwotY2xhc3Mg U2VjdXJpdHlPcmlnaW47Ci0KLWNsYXNzIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyIHsKLSAg ICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcik7Ci1wdWJs aWM6Ci0gICAgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoRnJhbWUqKTsKLSAgICB2aXJ0dWFs IH5NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigpOwotCi0gICAgU2VjdXJpdHlPcmlnaW4qIHNl Y3VyaXR5T3JpZ2luKCkgY29uc3Q7Ci0gICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0 RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0OwotCi0gICAgYm9vbCBpc0NsaWVudEF2YWlsYWJsZSgp IGNvbnN0OwotICAgIHZvaWQgZGlzY29ubmVjdFBhZ2UoKTsKLSAgICB2b2lkIGRpc2Nvbm5lY3RG cmFtZSgpOwotICAgIHZvaWQgdHJhbnNmZXJUb05ld1BhZ2UoUGFnZSopOwotCi0gICAgc3RhdGlj IEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgcGFyc2VHZW5lcmF0ZVN0cmVhbU9wdGlvbnMoY29u c3QgU3RyaW5nJik7Ci0gICAgdm9pZCBnZW5lcmF0ZVN0cmVhbShjb25zdCBTdHJpbmcmIG9wdGlv bnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1Jl ZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiwgRXhjZXB0aW9uQ29kZSYpOwot Ci0gICAgLy8gLS0tIENhbGxzIGNvbWluZyBiYWNrIGZyb20gdGhlIGNvbnRyb2xsZXIuIC0tLSAv LwotCi0gICAgdm9pZCBzdHJlYW1HZW5lcmF0ZWQoaW50IHJlcXVlc3RJZCwgY29uc3QgTWVkaWFT dHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpOwotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGlvbkZh aWxlZChpbnQgcmVxdWVzdElkLCBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6RXJyb3JDb2RlKTsK LQotcHJpdmF0ZToKLSAgICBjbGFzcyBSZXF1ZXN0OwotICAgIGNsYXNzIEdlbmVyYXRlU3RyZWFt UmVxdWVzdDsKLQotICAgIGNsYXNzIElkR2VuZXJhdG9yIHsKLSAgICAgICAgV1RGX01BS0VfTk9O Q09QWUFCTEUoSWRHZW5lcmF0b3IpOwotICAgIHB1YmxpYzoKLSAgICAgICAgSWRHZW5lcmF0b3Io KSA6IG1faWQoMCkgeyB9Ci0gICAgICAgIGludCBnZXROZXh0SWQoKSB7IHJldHVybiArK21faWQ7 IH0KLQotICAgIHByaXZhdGU6Ci0gICAgICAgIGludCBtX2lkOwotICAgIH07Ci0KLSAgICBjbGFz cyBSZXF1ZXN0TWFwIDogcHVibGljIElkR2VuZXJhdG9yLCBwdWJsaWMgSGFzaE1hcDxpbnQsIFJl ZlB0cjxSZXF1ZXN0PiA+IHsKLSAgICBwdWJsaWM6Ci0gICAgICAgIHZvaWQgYWJvcnQoaW50IHJl cXVlc3RJZCk7Ci0gICAgICAgIHZvaWQgYWJvcnRBbGwoKTsKLSAgICB9OwotCi0gICAgLy8gRGV0 YWNoZWQgZnJvbSBhIHBhZ2UsIGFuZCBoZW5jZSBmcm9tIGEgZW1iZWRkZXIgY2xpZW50LgotICAg IHZvaWQgZW50ZXJEZXRhY2hlZFN0YXRlKCk7Ci0KLSAgICBNZWRpYVN0cmVhbUNvbnRyb2xsZXIq IHBhZ2VDb250cm9sbGVyKCkgY29uc3Q7Ci0KLSAgICBSZXF1ZXN0TWFwIG1fcmVxdWVzdHM7Ci0K LSAgICBGcmFtZSogbV9mcmFtZTsKLSAgICBib29sIG1faXNJbkRldGFjaGVkU3RhdGU7Ci19Owot Ci19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFN KQotCi0jZW5kaWYgLy8gTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXJfaApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50LmggYi9Tb3VyY2UvV2Vi Q29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi43MzliNzAwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50LmgKQEAgLTAsMCArMSw1OCBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAg ZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhl IG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S UworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVS IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAq IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZu ZGVmIFVzZXJNZWRpYUNsaWVudF9oCisjZGVmaW5lIFVzZXJNZWRpYUNsaWVudF9oCisKKyNpZiBF TkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNs dWRlICJVc2VyTWVkaWFDb250cm9sbGVyLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xh c3MgVXNlck1lZGlhQ2xpZW50IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgdXNlck1lZGlh Q29udHJvbGxlckRlc3Ryb3llZCgpID0gMDsKKworICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0VXNl ck1lZGlhKFVzZXJNZWRpYVJlcXVlc3QqKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGNhbmNlbFVz ZXJNZWRpYVJlcXVlc3QoVXNlck1lZGlhUmVxdWVzdCopID0gMDsKKworICAgIHZpcnR1YWwgdm9p ZCB1c2VyTWVkaWFRdWVyeUNvbXBsZXRlZChVc2VyTWVkaWFSZXF1ZXN0KiwgY29uc3QgTWVkaWFT dHJlYW1Tb3VyY2VWZWN0b3ImKSA9IDA7CisKK3Byb3RlY3RlZDoKKyAgICB2aXJ0dWFsIH5Vc2Vy TWVkaWFDbGllbnQoKSB7IH0KK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNlbmRpZiAvLyBVc2VyTWVkaWFDbGllbnRfaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxl ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNw cApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jY2FiZTFmCi0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5j cHAKQEAgLTAsMCArMSwxMjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24g QUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRo ZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3Jz CisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZl ZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRl biBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENP UFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5B QkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKKwor I2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiTG9jYWxNZWRpYVN0cmVhbS5oIgorI2luY2x1 ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCisjaW5jbHVkZSAiVXNlck1lZGlhQ2xpZW50 LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworVXNlck1lZGlhQ29udHJvbGxlcjo6VXNlck1l ZGlhQ29udHJvbGxlcihQYWdlKiBwYWdlLCBVc2VyTWVkaWFDbGllbnQqIGNsaWVudCkKKyAgICA6 IG1fcGFnZShwYWdlKQorICAgICwgbV9jbGllbnQoY2xpZW50KQoreworfQorCitVc2VyTWVkaWFD b250cm9sbGVyOjp+VXNlck1lZGlhQ29udHJvbGxlcigpCit7CisgICAgaWYgKG1fY2xpZW50KQor ICAgICAgICBtX2NsaWVudC0+dXNlck1lZGlhQ29udHJvbGxlckRlc3Ryb3llZCgpOworfQorCit2 b2lkIFVzZXJNZWRpYUNvbnRyb2xsZXI6OnJlcXVlc3RVc2VyTWVkaWEoUGFzc1JlZlB0cjxVc2Vy TWVkaWFSZXF1ZXN0PiBwcnBSZXF1ZXN0KQoreworICAgIGlmICghbV9jbGllbnQpCisgICAgICAg IHJldHVybjsKKworICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gcHJwUmVx dWVzdDsKKworICAgIG1fcmVxdWVzdHMuYXBwZW5kKHJlcXVlc3QpOworICAgIG1fY2xpZW50LT5y ZXF1ZXN0VXNlck1lZGlhKHJlcXVlc3QuZ2V0KCkpOworfQorCit2b2lkIFVzZXJNZWRpYUNvbnRy b2xsZXI6OmNhbmNlbFVzZXJNZWRpYVJlcXVlc3QoVXNlck1lZGlhUmVxdWVzdCogcmVxdWVzdCkK K3sKKyAgICBpZiAoIW1fY2xpZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBtX2NsaWVudC0+ Y2FuY2VsVXNlck1lZGlhUmVxdWVzdChyZXF1ZXN0KTsKKyAgICByZXF1ZXN0LT5jbGVhckNvbnRy b2xsZXIoKTsKKworICAgIHNpemVfdCBpID0gbV9yZXF1ZXN0cy5maW5kKHJlcXVlc3QpOworICAg IEFTU0VSVChpICE9IG5vdEZvdW5kKTsKKyAgICBtX3JlcXVlc3RzLnJlbW92ZShpKTsKK30KKwor dm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0U3VjY2VlZGVkKFVzZXJN ZWRpYVJlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3Vy Y2VzKQoreworICAgIEFTU0VSVChtX3JlcXVlc3RzLmNvbnRhaW5zKHJlcXVlc3QpKTsKKworICAg IERPTVdpbmRvdyogZG9tV2luZG93ID0gcmVxdWVzdC0+ZnJhbWUoKS0+ZXhpc3RpbmdET01XaW5k b3coKTsKKyAgICBpZiAoIWRvbVdpbmRvdykKKyAgICAgICAgcmV0dXJuOworCisgICAgU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCA9IGRvbVdpbmRvdy0+c2NyaXB0RXhlY3V0aW9uQ29u dGV4dCgpOworICAgIGlmICghY29udGV4dCB8fCBjb250ZXh0ICE9IHJlcXVlc3QtPnNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVmUHRyPExvY2FsTWVk aWFTdHJlYW0+IHN0cmVhbSA9IExvY2FsTWVkaWFTdHJlYW06OmNyZWF0ZShjb250ZXh0LCBzb3Vy Y2VzKTsKKyAgICByZXF1ZXN0LT5zdWNjZXNzQ2FsbGJhY2soKS0+aGFuZGxlRXZlbnQoc3RyZWFt LmdldCgpKTsKKworICAgIHNpemVfdCBpID0gbV9yZXF1ZXN0cy5maW5kKHJlcXVlc3QpOworICAg IEFTU0VSVChpICE9IG5vdEZvdW5kKTsKKyAgICBtX3JlcXVlc3RzLnJlbW92ZShpKTsKK30KKwor dm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0RmFpbGVkKFVzZXJNZWRp YVJlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgQVNTRVJUKG1fcmVxdWVzdHMuY29udGFpbnMocmVx dWVzdCkpOworCisgICAgaWYgKHJlcXVlc3QtPmVycm9yQ2FsbGJhY2soKSkgeworICAgICAgICBS ZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlh RXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6UEVSTUlTU0lPTl9ERU5JRUQp OworICAgICAgICByZXF1ZXN0LT5lcnJvckNhbGxiYWNrKCktPmhhbmRsZUV2ZW50KGVycm9yLmdl dCgpKTsKKyAgICB9CisKKyAgICBzaXplX3QgaSA9IG1fcmVxdWVzdHMuZmluZChyZXF1ZXN0KTsK KyAgICBBU1NFUlQoaSAhPSBub3RGb3VuZCk7CisgICAgbV9yZXF1ZXN0cy5yZW1vdmUoaSk7Cit9 CisKK3ZvaWQgVXNlck1lZGlhQ29udHJvbGxlcjo6cXVlcnlVc2VyTWVkaWEoVXNlck1lZGlhUmVx dWVzdCogcmVxdWVzdCkKK3sKKyAgICBBU1NFUlQobV9yZXF1ZXN0cy5jb250YWlucyhyZXF1ZXN0 KSk7CisKKyAgICAvLyBGSVhNRTogcXVlcnkgdGhlIHBsYXRmb3JtIGZvciBhdmFpbGFibGUgdXNl ciBtZWRpYSwgc2VlIGh0dHA6Ly93ZWJraXQub3JnL2IvNzA4OTUKK30KKwordm9pZCBVc2VyTWVk aWFDb250cm9sbGVyOjp1c2VyTWVkaWFRdWVyeUNvbXBsZXRlZChVc2VyTWVkaWFSZXF1ZXN0KiBy ZXF1ZXN0LCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcykKK3sKKyAgICBp ZiAobV9jbGllbnQpCisgICAgICAgIG1fY2xpZW50LT51c2VyTWVkaWFRdWVyeUNvbXBsZXRlZChy ZXF1ZXN0LCBzb3VyY2VzKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYg Ly8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlh c3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFt L1VzZXJNZWRpYUNvbnRyb2xsZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li45ZTU4ZjhlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v VXNlck1lZGlhQ29udHJvbGxlci5oCkBAIC0wLDAgKzEsNzUgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAgIGluIHRoZSBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqICAgIGRpc3RyaWJ1 dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJpY3Nzb24gbm9yIHRoZSBuYW1lcyBv ZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21v dGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAgIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBVc2Vy TWVkaWFDb250cm9sbGVyX2gKKyNkZWZpbmUgVXNlck1lZGlhQ29udHJvbGxlcl9oCisKKyNpZiBF TkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiRE9NV2luZG93LmgiCisjaW5jbHVkZSAi TWVkaWFTdHJlYW1Tb3VyY2UuaCIKKyNpbmNsdWRlICJVc2VyTWVkaWFSZXF1ZXN0LmgiCisjaW5j bHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEZyYW1l OworY2xhc3MgUGFnZTsKK2NsYXNzIFVzZXJNZWRpYUNsaWVudDsKKworY2xhc3MgVXNlck1lZGlh Q29udHJvbGxlciB7CisgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVXNlck1lZGlhQ29udHJvbGxl cik7CitwdWJsaWM6CisgICAgVXNlck1lZGlhQ29udHJvbGxlcihQYWdlKiwgVXNlck1lZGlhQ2xp ZW50Kik7CisgICAgflVzZXJNZWRpYUNvbnRyb2xsZXIoKTsKKworICAgIHZvaWQgcmVxdWVzdFVz ZXJNZWRpYShQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+KTsKKyAgICB2b2lkIGNhbmNlbFVz ZXJNZWRpYVJlcXVlc3QoVXNlck1lZGlhUmVxdWVzdCopOworCisgICAgdm9pZCB1c2VyTWVkaWFS ZXF1ZXN0U3VjY2VlZGVkKFVzZXJNZWRpYVJlcXVlc3QqLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJj ZVZlY3RvciYpOworICAgIHZvaWQgdXNlck1lZGlhUmVxdWVzdEZhaWxlZChVc2VyTWVkaWFSZXF1 ZXN0Kik7CisKKyAgICBVc2VyTWVkaWFDbGllbnQqIGNsaWVudCgpIGNvbnN0IHsgcmV0dXJuIG1f Y2xpZW50OyB9CisKKyAgICB2b2lkIHF1ZXJ5VXNlck1lZGlhKFVzZXJNZWRpYVJlcXVlc3QqKTsK KyAgICB2b2lkIHVzZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKFVzZXJNZWRpYVJlcXVlc3QqLCBjb25z dCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYpOworCitwcml2YXRlOgorICAgIFBhZ2UqIG1fcGFn ZTsKKyAgICBVc2VyTWVkaWFDbGllbnQqIG1fY2xpZW50OworCisgICAgVmVjdG9yPFJlZlB0cjxV c2VyTWVkaWFSZXF1ZXN0PiA+IG1fcmVxdWVzdHM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8gVXNlck1l ZGlhQ29udHJvbGxlcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9V c2VyTWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRp YVJlcXVlc3QuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzNjRhNjUK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFS ZXF1ZXN0LmNwcApAQCAtMCwwICsxLDEwNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBF cmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4g UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9uLgorICog My4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250 cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisK KyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5o IgorCisjaW5jbHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVz ZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShGcmFtZSogZnJhbWUsIGNvbnN0IFN0cmluZyYgb3B0aW9u cywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3ND YWxsYmFjaywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJv ckNhbGxiYWNrKQoreworICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gYWRv cHRSZWYobmV3IFVzZXJNZWRpYVJlcXVlc3QoZnJhbWUsIG9wdGlvbnMsIHN1Y2Nlc3NDYWxsYmFj aywgZXJyb3JDYWxsYmFjaykpOworICAgIGlmICghcmVxdWVzdC0+YXVkaW8oKSAmJiAhcmVxdWVz dC0+dmlkZW8oKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1cm4gcmVxdWVzdC5yZWxl YXNlKCk7Cit9CisKK1VzZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJlcXVlc3QoRnJhbWUqIGZy YW1lLCBjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlh U3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKKyAgICA6IG1fYXVkaW8oZmFsc2Up CisgICAgLCBtX3ZpZGVvKGZhbHNlKQorICAgICwgbV9jYW1lcmFQcmVmZXJlbmNlVXNlcihmYWxz ZSkKKyAgICAsIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KGZhbHNlKQorICAgICwgbV9m cmFtZShmcmFtZSkKKyAgICAsIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChmcmFtZS0+ZXhpc3Rp bmdET01XaW5kb3coKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpKQorICAgICwgbV9jb250cm9s bGVyKGZyYW1lLT5wYWdlKCktPnVzZXJNZWRpYUNvbnRyb2xsZXIoKSkKKyAgICAsIG1fc3VjY2Vz c0NhbGxiYWNrKHN1Y2Nlc3NDYWxsYmFjaykKKyAgICAsIG1fZXJyb3JDYWxsYmFjayhlcnJvckNh bGxiYWNrKQoreworICAgIHBhcnNlT3B0aW9ucyhvcHRpb25zKTsKKworICAgIG1fZnJhbWUtPmFk ZERlc3RydWN0aW9uT2JzZXJ2ZXIodGhpcyk7Cit9CisKK1VzZXJNZWRpYVJlcXVlc3Q6On5Vc2Vy TWVkaWFSZXF1ZXN0KCkKK3sKKyAgICBpZiAobV9mcmFtZSkKKyAgICAgICAgbV9mcmFtZS0+cmVt b3ZlRGVzdHJ1Y3Rpb25PYnNlcnZlcih0aGlzKTsKK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0 OjpwYXJzZU9wdGlvbnMoY29uc3QgU3RyaW5nJiBvcHRpb25zKQoreworICAgIFZlY3RvcjxTdHJp bmc+IG9wdGlvbnNMaXN0OworICAgIG9wdGlvbnMuc3BsaXQoIiwiLCBvcHRpb25zTGlzdCk7CisK KyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG9wdGlvbnNMaXN0LnNpemUoKTsgaSsrKSB7Cisg ICAgICAgIFZlY3RvcjxTdHJpbmc+IHN1Yk9wdGlvbnNMaXN0OworICAgICAgICBvcHRpb25zTGlz dFtpXS5zcGxpdCgiICIsIHN1Yk9wdGlvbnNMaXN0KTsKKworICAgICAgICBpZiAoc3ViT3B0aW9u c0xpc3RbMF0gPT0gImF1ZGlvIikKKyAgICAgICAgICAgIG1fYXVkaW8gPSB0cnVlOworICAgICAg ICBlbHNlIGlmIChzdWJPcHRpb25zTGlzdFswXSA9PSAidmlkZW8iKSB7CisgICAgICAgICAgICBt X3ZpZGVvID0gdHJ1ZTsKKyAgICAgICAgICAgIGlmIChzdWJPcHRpb25zTGlzdC5jb250YWlucygi dXNlciIpKQorICAgICAgICAgICAgICAgIG1fY2FtZXJhUHJlZmVyZW5jZVVzZXIgPSB0cnVlOwor ICAgICAgICAgICAgaWYgKHN1Yk9wdGlvbnNMaXN0LmNvbnRhaW5zKCJlbnZpcm9ubWVudCIpKQor ICAgICAgICAgICAgICAgIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50ID0gdHJ1ZTsKKyAg ICAgICAgfQorICAgIH0KK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpmcmFtZURlc3Ryb3ll ZCgpCit7CisgICAgaWYgKG1fY29udHJvbGxlcikKKyAgICAgICAgbV9jb250cm9sbGVyLT5jYW5j ZWxVc2VyTWVkaWFSZXF1ZXN0KHRoaXMpOworCisgICAgbV9mcmFtZSA9IDA7Cit9CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmggYi9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmM4YzJiZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaApAQCAtMCwwICsxLDkzIEBA 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 ICovCisKKyNpZm5kZWYgVXNlck1lZGlhUmVxdWVzdF9oCisjZGVmaW5lIFVzZXJNZWRpYVJlcXVl c3RfaAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIkZyYW1lLmgiCisj aW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIk5h dmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3Ry aW5nLmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291 bnRlZC5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEZyYW1lOworY2xhc3MgVXNl ck1lZGlhQ29udHJvbGxlcjsKKworY2xhc3MgVXNlck1lZGlhUmVxdWVzdCA6IHB1YmxpYyBSZWZD b3VudGVkPFVzZXJNZWRpYVJlcXVlc3Q+LCBwdWJsaWMgRnJhbWVEZXN0cnVjdGlvbk9ic2VydmVy IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBjcmVh dGUoRnJhbWUqLCBjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNl ck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJv ckNhbGxiYWNrPik7CisgICAgflVzZXJNZWRpYVJlcXVlc3QoKTsKKworICAgIHZpcnR1YWwgdm9p ZCBmcmFtZURlc3Ryb3llZCgpOworCisgICAgYm9vbCBhdWRpbygpIGNvbnN0IHsgcmV0dXJuIG1f YXVkaW87IH0KKyAgICBib29sIHZpZGVvKCkgY29uc3QgeyByZXR1cm4gbV92aWRlbzsgfQorCisg ICAgYm9vbCBjYW1lcmFQcmVmZXJlbmNlVXNlcigpIGNvbnN0IHsgcmV0dXJuIG1fY2FtZXJhUHJl ZmVyZW5jZVVzZXI7IH0KKyAgICBib29sIGNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCgpIGNv bnN0IHsgcmV0dXJuIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50OyB9CisKKyAgICBGcmFt ZSogZnJhbWUoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lOyB9CisgICAgU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fc2NyaXB0 RXhlY3V0aW9uQ29udGV4dDsgfQorCisgICAgVXNlck1lZGlhQ29udHJvbGxlciogY29udHJvbGxl cigpIGNvbnN0IHsgcmV0dXJuIG1fY29udHJvbGxlcjsgfQorICAgIHZvaWQgY2xlYXJDb250cm9s bGVyKCkgeyBtX2NvbnRyb2xsZXIgPSAwOyB9CisKKyAgICBOYXZpZ2F0b3JVc2VyTWVkaWFTdWNj ZXNzQ2FsbGJhY2sqIHN1Y2Nlc3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fc3VjY2Vzc0Nh bGxiYWNrLmdldCgpOyB9CisgICAgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjayogZXJy b3JDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fZXJyb3JDYWxsYmFjay5nZXQoKTsgfQorCitw cml2YXRlOgorICAgIFVzZXJNZWRpYVJlcXVlc3QoRnJhbWUqLCBjb25zdCBTdHJpbmcmIG9wdGlv bnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1Jl ZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPik7CisKKyAgICB2b2lkIHBhcnNl T3B0aW9ucyhjb25zdCBTdHJpbmcmIG9wdGlvbnMpOworCisgICAgYm9vbCBtX2F1ZGlvOworICAg IGJvb2wgbV92aWRlbzsKKworICAgIGJvb2wgbV9jYW1lcmFQcmVmZXJlbmNlVXNlcjsKKyAgICBi b29sIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50OworCisgICAgRnJhbWUqIG1fZnJhbWU7 CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0Owor ICAgIFVzZXJNZWRpYUNvbnRyb2xsZXIqIG1fY29udHJvbGxlcjsKKworICAgIFJlZlB0cjxOYXZp Z2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IG1fc3VjY2Vzc0NhbGxiYWNrOworICAgIFJl ZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBtX2Vycm9yQ2FsbGJhY2s7Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RS RUFNKQorCisjZW5kaWYgLy8gVXNlck1lZGlhUmVxdWVzdF9oCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0NhbGxiYWNrVGFzay5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFj a1Rhc2suaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQwMGQzMS4uMDAwMDAwMAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0NhbGxiYWNrVGFzay5oCisrKyAvZGV2L251bGwKQEAg LTEsODEgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUg bWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQg QU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBDYWxsYmFja1Rhc2tfaAotI2Rl ZmluZSBDYWxsYmFja1Rhc2tfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1 ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgot I2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+Ci0jaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgotCi1u YW1lc3BhY2UgV2ViQ29yZSB7Ci0KLS8vIEhlbHBlciB0ZW1wbGF0ZSB0byBzY2hlZHVsZSBjYWxs cyB0byBjYWxsYmFja3MgdXNpbmcgdGhlaXIgb3duIHNjcmlwdCBleGVjdXRpb24gY29udGV4dC4K LS8vIENhbGxiYWNrVHlwZSBpcyBhc3N1bWVkIHRvIGltcGxlbWVudCBTY2hlZHVsZXIgYW5kIHRv IGJlIHJlZmVyZW5jZS1jb3VudGVkLgotdGVtcGxhdGUgPHR5cGVuYW1lIENhbGxiYWNrVHlwZSwg dHlwZW5hbWUgQXJndW1lbnRUeXBlPgotY2xhc3MgQ2FsbGJhY2tUYXNrMSA6IHB1YmxpYyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKLXB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc093blB0 cjxDYWxsYmFja1Rhc2sxPiBjcmVhdGUoUGFzc1JlZlB0cjxDYWxsYmFja1R5cGU+IGNhbGxiYWNr LCBQYXNzUmVmUHRyPEFyZ3VtZW50VHlwZT4gZGF0YSkKLSAgICB7Ci0gICAgICAgIHJldHVybiBh ZG9wdFB0cihuZXcgQ2FsbGJhY2tUYXNrMShjYWxsYmFjaywgZGF0YSkpOwotICAgIH0KLQotICAg IHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikKLSAgICB7 Ci0gICAgICAgIG1fY2FsbGJhY2stPmhhbmRsZUV2ZW50KG1fZGF0YS5nZXQoKSk7Ci0gICAgfQot Ci0gICAgY2xhc3MgU2NoZWR1bGVyIHsKLSAgICBwdWJsaWM6Ci0gICAgICAgIHZpcnR1YWwgflNj aGVkdWxlcigpIHsgfQotCi0gICAgICAgIGJvb2wgc2NoZWR1bGVDYWxsYmFjayhTY3JpcHRFeGVj dXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPEFyZ3VtZW50VHlwZT4gZGF0YSkKLSAg ICAgICAgewotICAgICAgICAgICAgaWYgKGNvbnRleHQpIHsKLSAgICAgICAgICAgICAgICBjb250 ZXh0LT5wb3N0VGFzayhDYWxsYmFja1Rhc2sxPENhbGxiYWNrVHlwZSwgQXJndW1lbnRUeXBlPjo6 Y3JlYXRlKHN0YXRpY19jYXN0PENhbGxiYWNrVHlwZSo+KHRoaXMpLCBkYXRhKSk7Ci0gICAgICAg ICAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgICAgIH0KLSAgICB9OwotCi1wcml2YXRlOgotICAgIENhbGxiYWNrVGFzazEo UGFzc1JlZlB0cjxDYWxsYmFja1R5cGU+IGNhbGxiYWNrLCBQYXNzUmVmUHRyPEFyZ3VtZW50VHlw ZT4gZGF0YSkKLSAgICAgICAgOiBtX2NhbGxiYWNrKGNhbGxiYWNrKQotICAgICAgICAsIG1fZGF0 YShkYXRhKQotICAgIHsKLSAgICB9Ci0KLSAgICBSZWZQdHI8Q2FsbGJhY2tUeXBlPiBtX2NhbGxi YWNrOwotICAgIFJlZlB0cjxBcmd1bWVudFR5cGU+IG1fZGF0YTsKLX07Ci0KLX0KLQotI2VuZGlm IC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBDYWxsYmFja1Rhc2tfaApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w YWdlL0ZyYW1lLmNwcAppbmRleCAxYTIzZmE1Li43MjNlY2RhIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmNw cApAQCAtMTExLDEwICsxMTEsNiBAQAogI2luY2x1ZGUgIlNWR0RvY3VtZW50RXh0ZW5zaW9ucy5o IgogI2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotI2luY2x1ZGUgIk1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyLmgiCi0jZW5kaWYKLQogI2lmIFVTRShUSUxFRF9CQUNLSU5HX1NU T1JFKQogI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCiAjZW5kaWYKQEAgLTE2OSw5ICsx NjUsNiBAQCBpbmxpbmUgRnJhbWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRWxl bWVudCogb3duZXJFbGVtZW50LCBGcmFtZUxvYWRlcgogICAgICwgbV9pblZpZXdTb3VyY2VNb2Rl KGZhbHNlKQogICAgICwgbV9pc0Rpc2Nvbm5lY3RlZChmYWxzZSkKICAgICAsIG1fZXhjbHVkZUZy b21UZXh0U2VhcmNoKGZhbHNlKQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgLCBtX21l ZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6Om1lZGlhU3Ry ZWFtRW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKHRo aXMpKSA6IFBhc3NPd25QdHI8TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI+KCkpCi0jZW5kaWYK IHsKICAgICBBU1NFUlQocGFnZSk7CiAgICAgQXRvbWljU3RyaW5nOjppbml0KCk7CkBAIC0yMjgs MTEgKzIyMSw2IEBAIEZyYW1lOjp+RnJhbWUoKQogICAgIGlmIChtX2RvbVdpbmRvdykKICAgICAg ICAgbV9kb21XaW5kb3ctPmRpc2Nvbm5lY3RGcmFtZSgpOwogCi0jaWYgRU5BQkxFKE1FRElBX1NU UkVBTSkKLSAgICBpZiAobV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgbV9t ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci0+ZGlzY29ubmVjdEZyYW1lKCk7Ci0jZW5kaWYKLQog ICAgIEhhc2hTZXQ8RE9NV2luZG93Kj46Oml0ZXJhdG9yIGVuZCA9IG1fbGl2ZUZvcm1lcldpbmRv d3MuZW5kKCk7CiAgICAgZm9yIChIYXNoU2V0PERPTVdpbmRvdyo+OjppdGVyYXRvciBpdCA9IG1f bGl2ZUZvcm1lcldpbmRvd3MuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQogICAgICAgICAoKml0 KS0+ZGlzY29ubmVjdEZyYW1lKCk7CkBAIC02OTgsMTEgKzY4Niw2IEBAIHZvaWQgRnJhbWU6OnBh Z2VEZXN0cm95ZWQoKQogICAgICAgICBtX2RvbVdpbmRvdy0+cGFnZURlc3Ryb3llZCgpOwogICAg IH0KIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgaWYgKG1fbWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXIpCi0gICAgICAgIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXItPmRpc2Nv bm5lY3RQYWdlKCk7Ci0jZW5kaWYKLQogICAgIC8vIEZJWE1FOiBJdCdzIHVuY2xlYXIgYXMgdG8g d2h5IHRoaXMgaXMgY2FsbGVkIG1vcmUgdGhhbiBvbmNlLCBidXQgaXQgaXMsCiAgICAgLy8gc28g cGFnZSgpIGNvdWxkIGJlIE5VTEwuCiAgICAgaWYgKHBhZ2UoKSAmJiBwYWdlKCktPmZvY3VzQ29u dHJvbGxlcigpLT5mb2N1c2VkRnJhbWUoKSA9PSB0aGlzKQpAQCAtNzU2LDEwICs3MzksNiBAQCB2 b2lkIEZyYW1lOjp0cmFuc2ZlckNoaWxkRnJhbWVUb05ld0RvY3VtZW50KCkKICNlbmRpZgogICAg ICAgICB9CiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBpZiAobV9tZWRpYVN0 cmVhbUZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgICAgIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXItPnRyYW5zZmVyVG9OZXdQYWdlKG5ld1BhZ2UpOwotI2VuZGlmCiAgICAgICAgIG1fcGFn ZSA9IG5ld1BhZ2U7CiAKICAgICAgICAgaWYgKG5ld1BhZ2UpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0ZyYW1lLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgKaW5kZXgg ODE2NjVjNi4uYjMyMDI2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaApAQCAtNjUsNyArNjUsNiBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgRG9jdW1lbnQ7CiAgICAgY2xhc3MgRnJhbWVWaWV3 OwogICAgIGNsYXNzIEhUTUxUYWJsZUNlbGxFbGVtZW50OwotICAgIGNsYXNzIE1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyOwogICAgIGNsYXNzIFJlZ3VsYXJFeHByZXNzaW9uOwogICAgIGNsYXNz IFJlbmRlclBhcnQ7CiAgICAgY2xhc3MgVGlsZWRCYWNraW5nU3RvcmU7CkBAIC0yMDEsMTAgKzIw MCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgTlNJbWFnZSogaW1hZ2VGcm9tUmVj dChOU1JlY3QpIGNvbnN0OwogI2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAg ICAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXIoKSBjb25zdCB7IHJldHVybiBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmdldCgpOyB9 Ci0jZW5kaWYKLSAgICAgICAgCiAgICAgICAgIC8vIFNob3VsZCBvbmx5IGJlIGNhbGxlZCBvbiB0 aGUgbWFpbiBmcmFtZSBvZiBhIHBhZ2UuCiAgICAgICAgIHZvaWQgbm90aWZ5Q2hyb21lQ2xpZW50 V2hlZWxFdmVudEhhbmRsZXJDb3VudENoYW5nZWQoKSBjb25zdDsKIApAQCAtMjY2LDkgKzI2MSw2 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgT3duUHRyPFRpbGVkQmFja2luZ1N0b3Jl PiBtX3RpbGVkQmFja2luZ1N0b3JlOwogI2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFN KQotICAgICAgICBPd25QdHI8TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI+IG1fbWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXI7Ci0jZW5kaWYKICAgICB9OwogCiAgICAgaW5saW5lIHZvaWQgRnJh bWU6OmluaXQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwCmluZGV4IDUzNTc1YWYuLmMxMmE5 NDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAKQEAgLTQ1LDkgKzQ1LDExIEBACiAjaW5j bHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNp bmNsdWRlICJNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIkRPTVdpbmRv dy5oIgogI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaCIKICNpbmNs dWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJTZWN1 cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKICNlbmRpZgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC04Miw2ICs4NCw3IEBAIHZvaWQgTmF2aWdhdG9yOjpk aXNjb25uZWN0RnJhbWUoKQogICAgICAgICBtX2dlb2xvY2F0aW9uLT5kaXNjb25uZWN0RnJhbWUo KTsKICAgICAgICAgbV9nZW9sb2NhdGlvbiA9IDA7CiAgICAgfQorCiAgICAgbV9mcmFtZSA9IDA7 CiB9CiAKQEAgLTI4Myw4ICsyODYsMjMgQEAgdm9pZCBOYXZpZ2F0b3I6OnJlZ2lzdGVyUHJvdG9j b2xIYW5kbGVyKGNvbnN0IFN0cmluZyYgc2NoZW1lLCBjb25zdCBTdHJpbmcmIHVybCwKICNpZiBF TkFCTEUoTUVESUFfU1RSRUFNKQogdm9pZCBOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYShj b25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vz c0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlh RXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAg aWYgKG1fZnJhbWUgJiYgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKSkKLSAg ICAgICAgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKS0+Z2VuZXJhdGVTdHJl YW0ob3B0aW9ucywgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBlYyk7CisgICAgaWYg KCFzdWNjZXNzQ2FsbGJhY2spCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9mcmFtZSkK KyAgICAgICAgcmV0dXJuOworCisgICAgUGFnZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKTsKKyAg ICBpZiAoIXBhZ2UpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1 ZXN0PiByZXF1ZXN0ID0gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKG1fZnJhbWUsIG9wdGlvbnMs IHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7CisgICAgaWYgKCFyZXF1ZXN0KSB7Cisg ICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBwYWdlLT51c2VyTWVkaWFDb250cm9sbGVyKCktPnJlcXVlc3RVc2VyTWVkaWEocmVxdWVz dC5yZWxlYXNlKCkpOwogfQogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvTmF2aWdhdG9yLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5oCmluZGV4IDNh MWUwNDIuLjM1ZTYyYmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9y LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuaApAQCAtMzUsNiArMzUsNyBA QCBjbGFzcyBHZW9sb2NhdGlvbjsKIGNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJh Y2s7CiBjbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s7CiBjbGFzcyBQbHVn aW5EYXRhOworY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIAogdHlwZWRlZiBpbnQgRXhj ZXB0aW9uQ29kZTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVz ZXJNZWRpYUVycm9yQ2FsbGJhY2suaAppbmRleCAxNTM5NzA5Li5kZDNjOGIzIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2su aApAQCAtMjcsMTQgKzI3LDEyIEBACiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQogCi0jaW5j bHVkZSAiQ2FsbGJhY2tUYXNrLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3Iu aCIKICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK LWNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2sgOiBwdWJsaWMgUmVmQ291bnRl ZDxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiwKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBwdWJsaWMgQ2FsbGJhY2tUYXNrMTxOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrLCBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj46OlNjaGVkdWxlciB7Citj bGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrIDogcHVibGljIFJlZkNvdW50ZWQ8 TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gewogcHVibGljOgogICAgIHZpcnR1YWwg fk5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2soKSB7IH0KICAgICB2aXJ0dWFsIGJvb2wg aGFuZGxlRXZlbnQoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqKSA9IDA7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNw cAppbmRleCA1OWYzNTc5Li41MTQyZTk5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L1BhZ2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKQEAgLTgwLDggKzgw LDcgQEAKICNlbmRpZgogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNpbmNsdWRlICJNZWRp YVN0cmVhbUNsaWVudC5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ29udHJvbGxlci5oIgorI2lu Y2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKICNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CkBAIC0xMzcsMTIgKzEzNiwxMiBAQCBQYWdlOjpQYWdlKFBhZ2VDbGllbnRzJiBwYWdlQ2xp ZW50cykKICAgICAsIG1fZGV2aWNlTW90aW9uQ29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1 cmVzOjpkZXZpY2VNb3Rpb25FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcgRGV2aWNlTW90aW9uQ29u dHJvbGxlcihwYWdlQ2xpZW50cy5kZXZpY2VNb3Rpb25DbGllbnQpKSA6IG51bGxwdHIpCiAgICAg LCBtX2RldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpk ZXZpY2VPcmllbnRhdGlvbkVuYWJsZWQoKSA/IGFkb3B0UHRyKG5ldyBEZXZpY2VPcmllbnRhdGlv bkNvbnRyb2xsZXIodGhpcywgcGFnZUNsaWVudHMuZGV2aWNlT3JpZW50YXRpb25DbGllbnQpKSA6 IG51bGxwdHIpCiAjZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICwgbV9tZWRp YVN0cmVhbUNvbnRyb2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6bWVkaWFTdHJlYW1FbmFi bGVkKCkgPyBhZG9wdFB0cihuZXcgTWVkaWFTdHJlYW1Db250cm9sbGVyKHBhZ2VDbGllbnRzLm1l ZGlhU3RyZWFtQ2xpZW50KSkgOiBQYXNzT3duUHRyPE1lZGlhU3RyZWFtQ29udHJvbGxlcj4oKSkK LSNlbmRpZgogI2lmIEVOQUJMRShJTlBVVF9TUEVFQ0gpCiAgICAgLCBtX3NwZWVjaElucHV0Q2xp ZW50KHBhZ2VDbGllbnRzLnNwZWVjaElucHV0Q2xpZW50KQogI2VuZGlmCisjaWYgRU5BQkxFKE1F RElBX1NUUkVBTSkKKyAgICAsIG1fdXNlck1lZGlhQ29udHJvbGxlcihhZG9wdFB0cihuZXcgVXNl ck1lZGlhQ29udHJvbGxlcih0aGlzLCBwYWdlQ2xpZW50cy51c2VyTWVkaWFDbGllbnQpKSkKKyNl bmRpZgogICAgICwgbV9zZXR0aW5ncyhhZG9wdFB0cihuZXcgU2V0dGluZ3ModGhpcykpKQogICAg ICwgbV9wcm9ncmVzcyhhZG9wdFB0cihuZXcgUHJvZ3Jlc3NUcmFja2VyKSkKICAgICAsIG1fYmFj a0ZvcndhcmRDb250cm9sbGVyKGFkb3B0UHRyKG5ldyBCYWNrRm9yd2FyZENvbnRyb2xsZXIodGhp cywgcGFnZUNsaWVudHMuYmFja0ZvcndhcmRDbGllbnQpKSkKQEAgLTEwNDIsNyArMTA0MSw3IEBA IFBhZ2U6OlBhZ2VDbGllbnRzOjpQYWdlQ2xpZW50cygpCiAgICAgLCBkZXZpY2VNb3Rpb25DbGll bnQoMCkKICAgICAsIGRldmljZU9yaWVudGF0aW9uQ2xpZW50KDApCiAgICAgLCBzcGVlY2hJbnB1 dENsaWVudCgwKQotICAgICwgbWVkaWFTdHJlYW1DbGllbnQoMCkKKyAgICAsIHVzZXJNZWRpYUNs aWVudCgwKQogewogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCmluZGV4IDNmMzBjZjMuLjFhMzQ3NzUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGFnZS5oCkBAIC03MSw4ICs3MSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFz cyBJbnNwZWN0b3JDbGllbnQ7CiAgICAgY2xhc3MgSW5zcGVjdG9yQ29udHJvbGxlcjsKICAgICBj bGFzcyBNZWRpYUNhblN0YXJ0TGlzdGVuZXI7Ci0gICAgY2xhc3MgTWVkaWFTdHJlYW1DbGllbnQ7 Ci0gICAgY2xhc3MgTWVkaWFTdHJlYW1Db250cm9sbGVyOwogICAgIGNsYXNzIE5vZGU7CiAgICAg Y2xhc3MgUGFnZUdyb3VwOwogICAgIGNsYXNzIFBsdWdpbkRhdGE7CkBAIC04NCw2ICs4Miw4IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBTZXR0aW5nczsKICAgICBjbGFzcyBTcGVl Y2hJbnB1dDsKICAgICBjbGFzcyBTcGVlY2hJbnB1dENsaWVudDsKKyAgICBjbGFzcyBVc2VyTWVk aWFDbGllbnQ7CisgICAgY2xhc3MgVXNlck1lZGlhQ29udHJvbGxlcjsKICAgICBjbGFzcyBTdG9y YWdlTmFtZXNwYWNlOwogI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQogICAgIGNsYXNzIE5vdGlm aWNhdGlvblByZXNlbnRlcjsKQEAgLTExOCw3ICsxMTgsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgICAgICAgICBEZXZpY2VPcmllbnRhdGlvbkNsaWVudCogZGV2aWNlT3JpZW50YXRpb25D bGllbnQ7CiAgICAgICAgICAgICBSZWZQdHI8QmFja0ZvcndhcmRMaXN0PiBiYWNrRm9yd2FyZENs aWVudDsKICAgICAgICAgICAgIFNwZWVjaElucHV0Q2xpZW50KiBzcGVlY2hJbnB1dENsaWVudDsK LSAgICAgICAgICAgIE1lZGlhU3RyZWFtQ2xpZW50KiBtZWRpYVN0cmVhbUNsaWVudDsKKyAgICAg ICAgICAgIFVzZXJNZWRpYUNsaWVudCogdXNlck1lZGlhQ2xpZW50OwogICAgICAgICB9OwogCiAg ICAgICAgIFBhZ2UoUGFnZUNsaWVudHMmKTsKQEAgLTE4NCwxMiArMTg0LDEyIEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgRGV2aWNlTW90aW9uQ29udHJvbGxlciogZGV2aWNlTW90aW9u Q29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlTW90aW9uQ29udHJvbGxlci5nZXQo KTsgfQogICAgICAgICBEZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIqIGRldmljZU9yaWVudGF0 aW9uQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlT3JpZW50YXRpb25Db250cm9s bGVyLmdldCgpOyB9CiAjZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBN ZWRpYVN0cmVhbUNvbnRyb2xsZXIqIG1lZGlhU3RyZWFtQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0 dXJuIG1fbWVkaWFTdHJlYW1Db250cm9sbGVyLmdldCgpOyB9Ci0jZW5kaWYKICNpZiBFTkFCTEUo SU5QVVRfU1BFRUNIKQogICAgICAgICBTcGVlY2hJbnB1dCogc3BlZWNoSW5wdXQoKTsKICNlbmRp ZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisgICAgICAgIFVzZXJNZWRpYUNvbnRyb2xsZXIq IHVzZXJNZWRpYUNvbnRyb2xsZXIoKSBjb25zdCB7IHJldHVybiBtX3VzZXJNZWRpYUNvbnRyb2xs ZXIuZ2V0KCk7IH0KKyNlbmRpZgogICAgICAgICBTZXR0aW5ncyogc2V0dGluZ3MoKSBjb25zdCB7 IHJldHVybiBtX3NldHRpbmdzLmdldCgpOyB9CiAgICAgICAgIFByb2dyZXNzVHJhY2tlciogcHJv Z3Jlc3MoKSBjb25zdCB7IHJldHVybiBtX3Byb2dyZXNzLmdldCgpOyB9CiAgICAgICAgIEJhY2tG b3J3YXJkQ29udHJvbGxlciogYmFja0ZvcndhcmQoKSBjb25zdCB7IHJldHVybiBtX2JhY2tGb3J3 YXJkQ29udHJvbGxlci5nZXQoKTsgfQpAQCAtMzY0LDEzICszNjQsMTMgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICBPd25QdHI8RGV2aWNlTW90aW9uQ29udHJvbGxlcj4gbV9kZXZpY2VN b3Rpb25Db250cm9sbGVyOwogICAgICAgICBPd25QdHI8RGV2aWNlT3JpZW50YXRpb25Db250cm9s bGVyPiBtX2RldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcjsKICNlbmRpZgotI2lmIEVOQUJMRShN RURJQV9TVFJFQU0pCi0gICAgICAgIE93blB0cjxNZWRpYVN0cmVhbUNvbnRyb2xsZXI+IG1fbWVk aWFTdHJlYW1Db250cm9sbGVyOwotI2VuZGlmCiAjaWYgRU5BQkxFKElOUFVUX1NQRUVDSCkKICAg ICAgICAgU3BlZWNoSW5wdXRDbGllbnQqIG1fc3BlZWNoSW5wdXRDbGllbnQ7CiAgICAgICAgIE93 blB0cjxTcGVlY2hJbnB1dD4gbV9zcGVlY2hJbnB1dDsKICNlbmRpZgorI2lmIEVOQUJMRShNRURJ QV9TVFJFQU0pCisgICAgICAgIE93blB0cjxVc2VyTWVkaWFDb250cm9sbGVyPiBtX3VzZXJNZWRp YUNvbnRyb2xsZXI7CisjZW5kaWYKICAgICAgICAgT3duUHRyPFNldHRpbmdzPiBtX3NldHRpbmdz OwogICAgICAgICBPd25QdHI8UHJvZ3Jlc3NUcmFja2VyPiBtX3Byb2dyZXNzOwogICAgICAgICAK 114476 2011-11-10 05:18:21 -0800 2011-11-11 08:44:01 -0800 Patch 3 usermedia_simple_controller_3.patch text/plain 63058 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3NjQ5MmI2Li5jNWI2YWZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzAg QEAKKzIwMTEtMTEtMTAgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudC9jb250cm9sbGVyIGZvciB1 c2VyIGNvbnNlbnQgaW4gZ2V0VXNlck1lZGlhKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcwODk3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBvbmUgaW4gYSBzZXJpZXMgb2YgcGF0Y2hlcyB0 aGF0IHVwZGF0ZSB0aGUgTWVkaWFTdHJlYW0gZmVhdHVyZQorICAgICAgICB0byB1c2UgV2ViQ29y ZSBwbGF0Zm9ybSBpbnRlcmZhY2VzLgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVz dHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFdlYkNvcmUu Z3lwaToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oOiBSZW1vdmVk LgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHA6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmg6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3Bw OiBSZW1vdmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyLmg6IFJlbW92ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50Lmg6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ2xpZW50Ojp+VXNlck1lZGlhQ2xp ZW50KToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpVc2VyTWVkaWFDb250 cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6On5Vc2VyTWVk aWFDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OnJl cXVlc3RVc2VyTWVkaWEpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6 Y2FuY2VsVXNlck1lZGlhUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpyZXF1ZXN0SXNWYWxp ZCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFSZXF1 ZXN0U3VjY2VlZGVkKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OnVz ZXJNZWRpYVJlcXVlc3RGYWlsZWQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ29udHJv bGxlcjo6cXVlcnlVc2VyTWVkaWEpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ29udHJv bGxlcjo6dXNlck1lZGlhUXVlcnlDb21wbGV0ZWQpOgorICAgICAgICAqIG1lZGlhc3RyZWFtL1Vz ZXJNZWRpYUNvbnRyb2xsZXIuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFD b250cm9sbGVyOjpjbGllbnQpOgorICAgICAgICAqIG1lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVl c3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0 ZSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpVc2VyTWVkaWFSZXF1ZXN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6On5Vc2VyTWVkaWFSZXF1ZXN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnBhcnNlT3B0aW9ucyk6Cisg ICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpmcmFtZURlc3Ryb3llZCk6CisgICAg ICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5oOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmF1ZGlvKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJN ZWRpYVJlcXVlc3Q6OnZpZGVvKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6 OmNhbWVyYVByZWZlcmVuY2VVc2VyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6OmNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCk6CisgICAgICAgIChXZWJDb3JlOjpVc2Vy TWVkaWFSZXF1ZXN0OjpmcmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0 OjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJl cXVlc3Q6OmNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6 Y2xlYXJDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnN1 Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjplcnJv ckNhbGxiYWNrKToKKyAgICAgICAgKiBwYWdlL0NhbGxiYWNrVGFzay5oOiBSZW1vdmVkLgorICAg ICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OkZyYW1lKToK KyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp+RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWU6OnBhZ2VEZXN0cm95ZWQpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OnRyYW5zZmVyQ2hp bGRGcmFtZVRvTmV3RG9jdW1lbnQpOgorICAgICAgICAqIHBhZ2UvRnJhbWUuaDoKKyAgICAgICAg KiBwYWdlL05hdmlnYXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOYXZpZ2F0b3I6OndlYmtp dEdldFVzZXJNZWRpYSk6CisgICAgICAgICogcGFnZS9OYXZpZ2F0b3IuaDoKKyAgICAgICAgKiBw YWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaDoKKyAgICAgICAgKiBwYWdlL1Bh Z2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6UGFnZSk6CisgICAgICAgIChXZWJDb3Jl OjpQYWdlOjpQYWdlQ2xpZW50czo6UGFnZUNsaWVudHMpOgorICAgICAgICAqIHBhZ2UvUGFnZS5o OgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6dXNlck1lZGlhQ29udHJvbGxlcik6CisKIDIwMTEt MTEtMTAgIEpheSBDaXZlbGxpICA8amNpdmVsbGlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEZp eCBwcm9ncmVzcyBsb2FkIHJlcG9ydGluZyBmb3IgTUhUTUwgZG9jdW1lbnRzLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggODY2OGNmMS4uNzNhMTdhYSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVt YWtlZmlsZS5saXN0LmFtCkBAIC0yMjcyLDEzICsyMjcyLDggQEAgd2ViY29yZV9zb3VyY2VzICs9 IFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Mb2NhbE1lZGlhU3RyZWFtLmggXAogCVNv dXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtLmNwcCBcCiAJU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW0uaCBcCi0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJl YW0vTWVkaWFTdHJlYW1DbGllbnQuaCBcCi0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1Db250cm9sbGVyLmNwcCBcCi0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1Db250cm9sbGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlh U3RyZWFtRXZlbnQuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVh bUV2ZW50LmggXAotCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyLmNwcCBcCi0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXIuaCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJl YW1MaXN0LmNwcCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0 LmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtUmVnaXN0cnkuY3Bw IFwKQEAgLTIyOTAsNiArMjI4NSwxMSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9X ZWJDb3JlL21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmNwcCBcCiAJU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uaCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJl YW0vU2lnbmFsaW5nQ2FsbGJhY2suaCBcCisJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNl ck1lZGlhQ2xpZW50LmggXAorCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNv bnRyb2xsZXIuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250 cm9sbGVyLmggXAorCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3Qu Y3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmggXAog CVNvdXJjZS9XZWJDb3JlL25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ2VudGVyLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvbm90aWZpY2F0aW9ucy9Ob3RpZmljYXRpb25DZW50ZXIuaCBcCiAJU291 cmNlL1dlYkNvcmUvbm90aWZpY2F0aW9ucy9Ob3RpZmljYXRpb25Db250ZW50cy5oIFwKQEAgLTIz MTAsNyArMjMxMCw2IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvcGFn ZS9BZGp1c3RWaWV3U2l6ZU9yTm90LmggXAogCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQmFySW5mby5j cHAgXAogCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQmFySW5mby5oIFwKLQlTb3VyY2UvV2ViQ29yZS9w YWdlL0NhbGxiYWNrVGFzay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZS5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL3BhZ2UvQ2hyb21lLmggXAogCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQ2hy b21lQ2xpZW50LmggXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIv U291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDNiYmMxYjUuLmJmMzliYzYzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUv V2ViQ29yZS5neXBpCkBAIC0yODk5LDExICsyODk5LDYgQEAKICAgICAgICAgICAgICdtZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbS5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVh bUV2ZW50LmNwcCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5o JywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oJywKLSAgICAg ICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwJywKLSAgICAgICAg ICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCcsCi0gICAgICAgICAgICAn bWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwJywKLSAgICAgICAgICAg ICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oJywKICAgICAgICAgICAg ICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuY3BwJywKICAgICAgICAgICAgICdtZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUxpc3QuaCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1UcmFjay5jcHAnLApAQCAtMjkxNSw2ICsyOTEwLDExIEBACiAgICAgICAgICAgICAnbWVk aWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uY3BwJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9Q ZWVyQ29ubmVjdGlvbi5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9TaWduYWxpbmdDYWxs YmFjay5oJywKKyAgICAgICAgICAgICdtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaCcsCisg ICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5jcHAnLAorICAgICAg ICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaCcsCisgICAgICAgICAgICAn bWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAnLAorICAgICAgICAgICAgJ21lZGlhc3Ry ZWFtL1VzZXJNZWRpYVJlcXVlc3QuaCcsCiAgICAgICAgICAgICAnbm90aWZpY2F0aW9ucy9Ob3Rp ZmljYXRpb24uY3BwJywKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbi5o JywKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNlbnRlci5jcHAnLApA QCAtMjkyMiw3ICsyOTIyLDYgQEAKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNh dGlvbkNvbnRlbnRzLmgnLAogICAgICAgICAgICAgJ3BhZ2UvQmFySW5mby5jcHAnLAogICAgICAg ICAgICAgJ3BhZ2UvQmFySW5mby5oJywKLSAgICAgICAgICAgICdwYWdlL0NhbGxiYWNrVGFzay5o JywKICAgICAgICAgICAgICdwYWdlL0Nocm9tZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvQ29u c29sZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvQ29udGVudFNlY3VyaXR5UG9saWN5LmNwcCcs CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVu dC5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaApkZWxl dGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWY5MDk1Yy4uMDAwMDAwMAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oCisrKyAvZGV2L251bGwKQEAg LTEsNTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUg bWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQg QU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBNZWRpYVN0cmVhbUNsaWVudF9o Ci0jZGVmaW5lIE1lZGlhU3RyZWFtQ2xpZW50X2gKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0p Ci0KLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNs YXNzIFNlY3VyaXR5T3JpZ2luOwotCi1lbnVtIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZyB7Ci0g ICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0QXVkaW8gPSAxLAotICAgIEdlbmVyYXRlU3RyZWFtUmVx dWVzdFZpZGVvRmFjaW5nVXNlciA9IDEgPDwgMSwKLSAgICBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RW aWRlb0ZhY2luZ0Vudmlyb25tZW50ID0gMSA8PCAyLAotfTsKLQotdHlwZWRlZiB1bnNpZ25lZCBH ZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzOwotCi1jbGFzcyBNZWRpYVN0cmVhbUNsaWVudCB7Ci1w dWJsaWM6Ci0gICAgLy8gTWVkaWFTdHJlYW0gZnVuY3Rpb25zLgotICAgIHZpcnR1YWwgdm9pZCBt ZWRpYVN0cmVhbURlc3Ryb3llZCgpID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgZ2VuZXJhdGVTdHJl YW0oaW50IHJlcXVlc3RJZCwgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncywgUGFzc1JlZlB0cjxT ZWN1cml0eU9yaWdpbj4pID0gMDsKLQotcHJvdGVjdGVkOgotICAgIHZpcnR1YWwgfk1lZGlhU3Ry ZWFtQ2xpZW50KCkgeyB9Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAv LyBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jZW5kaWYgLy8gTWVkaWFTdHJlYW1DbGllbnRfaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9s bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxl ci5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ0ZTMwOGUuLjAwMDAwMDAKLS0t IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNwcAor KysgL2Rldi9udWxsCkBAIC0xLDEyMyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDEx IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAg UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRP UlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAi Y29uZmlnLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgiCi0KLSNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIu aCIKLSNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4K LQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OlJl cXVlc3QgewotcHVibGljOgotICAgIFJlcXVlc3QoKQotICAgICAgICA6IG1fbG9jYWxJZCgwKQot ICAgICAgICAsIG1fZnJhbWVDb250cm9sbGVyKDApIHsgfQotCi0gICAgUmVxdWVzdChpbnQgbG9j YWxJZCwgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlcikKLSAgICAg ICAgOiBtX2xvY2FsSWQobG9jYWxJZCkKLSAgICAgICAgLCBtX2ZyYW1lQ29udHJvbGxlcihmcmFt ZUNvbnRyb2xsZXIpIHsgfQotCi0gICAgaW50IGxvY2FsSWQoKSBjb25zdCB7IHJldHVybiBtX2xv Y2FsSWQ7IH0KLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVy KCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZUNvbnRyb2xsZXI7IH0KLQotcHJpdmF0ZToKLSAgICBp bnQgbV9sb2NhbElkOwotICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBtX2ZyYW1lQ29u dHJvbGxlcjsKLX07Ci0KLU1lZGlhU3RyZWFtQ29udHJvbGxlcjo6TWVkaWFTdHJlYW1Db250cm9s bGVyKE1lZGlhU3RyZWFtQ2xpZW50KiBjbGllbnQpCi0gICAgOiBtX2NsaWVudChjbGllbnQpCi0g ICAgLCBtX25leHRHbG9iYWxSZXF1ZXN0SWQoMSkKLXsKLX0KLQotTWVkaWFTdHJlYW1Db250cm9s bGVyOjp+TWVkaWFTdHJlYW1Db250cm9sbGVyKCkKLXsKLSAgICBpZiAobV9jbGllbnQpCi0gICAg ICAgIG1fY2xpZW50LT5tZWRpYVN0cmVhbURlc3Ryb3llZCgpOwotfQotCi1ib29sIE1lZGlhU3Ry ZWFtQ29udHJvbGxlcjo6aXNDbGllbnRBdmFpbGFibGUoKSBjb25zdAotewotICAgIHJldHVybiBt X2NsaWVudDsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnVucmVnaXN0ZXJGcmFt ZUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlcikK LXsKLSAgICBBU1NFUlQoZnJhbWVDb250cm9sbGVyKTsKLQotICAgIC8vIERvbmUgaW4gdHdvIHN0 ZXBzIHRvIGF2b2lkIHByb2JsZW1zIGFib3V0IGl0ZXJhdG9ycyBiZWluZyBpbnZhbGlkYXRlZCB3 aGlsZSByZW1vdmluZy4KLSAgICBWZWN0b3I8aW50PiBmcmFtZVJlcXVlc3RzOwotICAgIGZvciAo UmVxdWVzdE1hcDo6aXRlcmF0b3IgaXQgPSBtX3JlcXVlc3RzLmJlZ2luKCk7IGl0ICE9IG1fcmVx dWVzdHMuZW5kKCk7ICsraXQpCi0gICAgICAgIGlmIChpdC0+c2Vjb25kLmZyYW1lQ29udHJvbGxl cigpID09IGZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgICAgIGZyYW1lUmVxdWVzdHMuYXBwZW5k KGl0LT5maXJzdCk7Ci0KLSAgICBmb3IgKFZlY3RvcjxpbnQ+OjppdGVyYXRvciBpdCA9IGZyYW1l UmVxdWVzdHMuYmVnaW4oKTsgaXQgIT0gZnJhbWVSZXF1ZXN0cy5lbmQoKTsgKytpdCkKLSAgICAg ICAgbV9yZXF1ZXN0cy5yZW1vdmUoKml0KTsKLX0KLQotaW50IE1lZGlhU3RyZWFtQ29udHJvbGxl cjo6cmVnaXN0ZXJSZXF1ZXN0KGludCBsb2NhbElkLCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ciogZnJhbWVDb250cm9sbGVyKQotewotICAgIEFTU0VSVChsb2NhbElkID4gMCk7Ci0gICAgQVNT RVJUKGZyYW1lQ29udHJvbGxlcik7Ci0gICAgbV9yZXF1ZXN0cy5hZGQobV9uZXh0R2xvYmFsUmVx dWVzdElkLCBSZXF1ZXN0KGxvY2FsSWQsIGZyYW1lQ29udHJvbGxlcikpOwotICAgIHJldHVybiBt X25leHRHbG9iYWxSZXF1ZXN0SWQrKzsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6 OmdlbmVyYXRlU3RyZWFtKE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNvbnRyb2xs ZXIsIGludCBsb2NhbElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzLCBQYXNzUmVm UHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKLXsKLSAgICBBU1NFUlQobV9jbGll bnQpOwotICAgIGludCBjb250cm9sbGVyUmVxdWVzdElkID0gcmVnaXN0ZXJSZXF1ZXN0KGxvY2Fs SWQsIGZyYW1lQ29udHJvbGxlcik7Ci0gICAgbV9jbGllbnQtPmdlbmVyYXRlU3RyZWFtKGNvbnRy b2xsZXJSZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0eU9yaWdpbik7Ci19Ci0KLXZvaWQgTWVkaWFT dHJlYW1Db250cm9sbGVyOjpzdHJlYW1HZW5lcmF0ZWQoaW50IGNvbnRyb2xsZXJSZXF1ZXN0SWQs IGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewotICAgIC8vIERvbid0 IGFzc2VydCBzaW5jZSB0aGUgZnJhbWUgY29udHJvbGxlciBjYW4gaGF2ZSBiZWVuIGRlc3Ryb3ll ZCB3aGlsZSB0aGUgcmVxdWVzdCByZXBseSB3YXMgY29taW5nIGJhY2suCi0gICAgaWYgKG1fcmVx dWVzdHMuY29udGFpbnMoY29udHJvbGxlclJlcXVlc3RJZCkpIHsKLSAgICAgICAgY29uc3QgUmVx dWVzdCYgcmVxdWVzdCA9IG1fcmVxdWVzdHMuZ2V0KGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAg ICAgICBtX3JlcXVlc3RzLnJlbW92ZShjb250cm9sbGVyUmVxdWVzdElkKTsKLSAgICAgICAgQVNT RVJUKHJlcXVlc3QuZnJhbWVDb250cm9sbGVyKCkpOwotICAgICAgICByZXF1ZXN0LmZyYW1lQ29u dHJvbGxlcigpLT5zdHJlYW1HZW5lcmF0ZWQocmVxdWVzdC5sb2NhbElkKCksIHNvdXJjZXMpOwot ICAgIH0KLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnN0cmVhbUdlbmVyYXRpb25G YWlsZWQoaW50IGNvbnRyb2xsZXJSZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpF cnJvckNvZGUgY29kZSkKLXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIGZyYW1lIGNv bnRyb2xsZXIgY2FuIGhhdmUgYmVlbiBkZXN0cm95ZWQgd2hpbGUgdGhlIHJlcXVlc3QgcmVwbHkg d2FzIGNvbWluZyBiYWNrLgotICAgIGlmIChtX3JlcXVlc3RzLmNvbnRhaW5zKGNvbnRyb2xsZXJS ZXF1ZXN0SWQpKSB7Ci0gICAgICAgIGNvbnN0IFJlcXVlc3QmIHJlcXVlc3QgPSBtX3JlcXVlc3Rz LmdldChjb250cm9sbGVyUmVxdWVzdElkKTsKLSAgICAgICAgbV9yZXF1ZXN0cy5yZW1vdmUoY29u dHJvbGxlclJlcXVlc3RJZCk7Ci0gICAgICAgIHJlcXVlc3QuZnJhbWVDb250cm9sbGVyKCktPnN0 cmVhbUdlbmVyYXRpb25GYWlsZWQocmVxdWVzdC5sb2NhbElkKCksIGNvZGUpOwotICAgIH0KLX0K LQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVB TSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29u dHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9s bGVyLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4OTMwOTQuLjAwMDAwMDAKLS0t IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmgKKysr IC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdv b2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMg YGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUK LSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlh U3RyZWFtQ29udHJvbGxlcl9oCi0jZGVmaW5lIE1lZGlhU3RyZWFtQ29udHJvbGxlcl9oCi0KLSNp ZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1DbGllbnQuaCIK LSNpbmNsdWRlICJNZWRpYVN0cmVhbVNvdXJjZS5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJN ZWRpYUVycm9yLmgiCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNsdWRlIDx3dGYvSGFz aE1hcC5oPgotI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0 L1N0cmluZ0hhc2guaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVh bUNsaWVudDsKLWNsYXNzIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOwotY2xhc3MgU2VjdXJp dHlPcmlnaW47Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlciB7Ci0gICAgV1RGX01BS0Vf Tk9OQ09QWUFCTEUoTWVkaWFTdHJlYW1Db250cm9sbGVyKTsKLXB1YmxpYzoKLSAgICBNZWRpYVN0 cmVhbUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1DbGllbnQqKTsKLSAgICB2aXJ0dWFsIH5NZWRpYVN0 cmVhbUNvbnRyb2xsZXIoKTsKLQotICAgIGJvb2wgaXNDbGllbnRBdmFpbGFibGUoKSBjb25zdDsK LSAgICB2b2lkIHVucmVnaXN0ZXJGcmFtZUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIqKTsKLQotICAgIHZvaWQgZ2VuZXJhdGVTdHJlYW0oTWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIqLCBpbnQgcmVxdWVzdElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzLCBQYXNzUmVm UHRyPFNlY3VyaXR5T3JpZ2luPik7Ci0KLSAgICB2b2lkIHN0cmVhbUdlbmVyYXRlZChpbnQgcmVx dWVzdElkLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcyk7Ci0gICAgdm9p ZCBzdHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRp YUVycm9yOjpFcnJvckNvZGUpOwotCi1wcml2YXRlOgotICAgIGludCByZWdpc3RlclJlcXVlc3Qo aW50IGxvY2FsUmVxdWVzdElkLCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciopOwotCi0gICAg Y2xhc3MgUmVxdWVzdDsKLSAgICB0eXBlZGVmIEhhc2hNYXA8aW50LCBSZXF1ZXN0PiBSZXF1ZXN0 TWFwOwotCi0gICAgUmVxdWVzdE1hcCBtX3JlcXVlc3RzOwotCi0gICAgTWVkaWFTdHJlYW1DbGll bnQqIG1fY2xpZW50OwotICAgIGludCBtX25leHRHbG9iYWxSZXF1ZXN0SWQ7Ci19OwotCi19IC8v IG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0j ZW5kaWYgLy8gTWVkaWFTdHJlYW1Db250cm9sbGVyX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcApkZWxldGVk IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGM3NTdlNC4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5jcHAKKysrIC9kZXYv bnVsbApAQCAtMSwyODMgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z Ci0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMg SVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0g KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5o IgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgiCi0KLSNpZiBFTkFCTEUo TUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiRE9NV2luZG93LmgiCi0jaW5jbHVkZSAiRG9jdW1l bnQuaCIKLSNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAiRnJhbWUuaCIKLSNp bmNsdWRlICJMb2NhbE1lZGlhU3RyZWFtLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9s bGVyLmgiCi0jaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgotI2lu Y2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgotI2luY2x1ZGUgIlBh Z2UuaCIKLSNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0Zi9SZWZDb3Vu dGVkLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNv bnRyb2xsZXI6OlJlcXVlc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXF1ZXN0PiB7Ci0gICAgV1RG X01BS0VfTk9OQ09QWUFCTEUoUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgdmlydHVhbCB+UmVxdWVz dCgpIHsgfQotCi0gICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29u dGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dDsgfQotICAgIHZp cnR1YWwgYm9vbCBpc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9Ci0KLSAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKSA9IDA7Ci0KLXByb3RlY3RlZDoKLSAgICBS ZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0g ICAgICAgIDogbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQp IHsgfQotCi1wcml2YXRlOgotICAgIC8vIFRoaXMgaXMgZ3VhcmFudGVlZCB0byBoYXZlIHRoZSBs aWZldGltZSBvZiB0aGUgRnJhbWUsIGFuZCBpdCdzIG9ubHkgdXNlZCB0byBtYWtlCi0gICAgLy8g dGhlIGNhbGxiYWNrIGFzeW5jaHJvbm91cy4gVGhlIG9yaWdpbmFsIGNhbGxiYWNrIGNvbnRleHQg aXMgdXNlZCBpbiB0aGUgY2FsbC4KLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQ7Ci19OwotCi1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl cjo6R2VuZXJhdGVTdHJlYW1SZXF1ZXN0IDogcHVibGljIFJlcXVlc3QgewotICAgIFdURl9NQUtF X05PTkNPUFlBQkxFKEdlbmVyYXRlU3RyZWFtUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgc3RhdGlj IFBhc3NSZWZQdHI8R2VuZXJhdGVTdHJlYW1SZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRp YVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1l ZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKLSAgICB7Ci0gICAgICAgIHJldHVybiBh ZG9wdFJlZihuZXcgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQs IHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOwotICAgIH0KLQotICAgIHZpcnR1YWwg fkdlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIHsgfQotCi0gICAgdmlydHVhbCBib29sIGlzR2VuZXJh dGVTdHJlYW1SZXF1ZXN0KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQotCi0gICAgdmlydHVhbCB2 b2lkIGFib3J0KCkKLSAgICB7Ci0gICAgICAgIGlmIChtX2Vycm9yQ2FsbGJhY2spIHsKLSAgICAg ICAgICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpQRVJNSVNTSU9O X0RFTklFRCk7Ci0gICAgICAgICAgICAvLyBUaGUgY2FsbGJhY2sgaXRzZWxmIGlzIG1hZGUgd2l0 aCB0aGUgSlMgY2FsbGJhY2sncyBjb250ZXh0LCBub3Qgd2l0aCB0aGUgZnJhbWUncyBjb250ZXh0 LgotICAgICAgICAgICAgbV9lcnJvckNhbGxiYWNrLT5zY2hlZHVsZUNhbGxiYWNrKHNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKSwgZXJyb3IpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgUGFzc1Jl ZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaygp IGNvbnN0IHsgcmV0dXJuIG1fc3VjY2Vzc0NhbGxiYWNrOyB9Ci0gICAgUGFzc1JlZlB0cjxOYXZp Z2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKCkgY29uc3QgeyByZXR1 cm4gbV9lcnJvckNhbGxiYWNrOyB9Ci0KLXByaXZhdGU6Ci0gICAgR2VuZXJhdGVTdHJlYW1SZXF1 ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vz c0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAgIFBh c3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykK LSAgICAgICAgOiBSZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0gICAgICAgICwgbV9z dWNjZXNzQ2FsbGJhY2soc3VjY2Vzc0NhbGxiYWNrKQotICAgICAgICAsIG1fZXJyb3JDYWxsYmFj ayhlcnJvckNhbGxiYWNrKSB7IH0KLQotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNj ZXNzQ2FsbGJhY2s+IG1fc3VjY2Vzc0NhbGxiYWNrOwotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2Vy TWVkaWFFcnJvckNhbGxiYWNrPiBtX2Vycm9yQ2FsbGJhY2s7Ci19OwotCi12b2lkIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydChpbnQgcmVxdWVzdElkKQotewot ICAgIGdldChyZXF1ZXN0SWQpLT5hYm9ydCgpOwotICAgIHJlbW92ZShyZXF1ZXN0SWQpOwotfQot Ci12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydEFsbCgp Ci17Ci0gICAgd2hpbGUgKCFpc0VtcHR5KCkpIHsKLSAgICAgICAgYmVnaW4oKS0+c2Vjb25kLT5h Ym9ydCgpOwotICAgICAgICByZW1vdmUoYmVnaW4oKSk7Ci0gICAgfQotfQotCi1NZWRpYVN0cmVh bUZyYW1lQ29udHJvbGxlcjo6TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoRnJhbWUqIGZyYW1l KQotICAgIDogbV9mcmFtZShmcmFtZSkKLSAgICAsIG1faXNJbkRldGFjaGVkU3RhdGUoZmFsc2Up Ci17Ci0gICAgaWYgKCFpc0NsaWVudEF2YWlsYWJsZSgpKQotICAgICAgICBlbnRlckRldGFjaGVk U3RhdGUoKTsKLX0KLQotTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6On5NZWRpYVN0cmVhbUZy YW1lQ29udHJvbGxlcigpCi17Ci19Ci0KLVNlY3VyaXR5T3JpZ2luKiBNZWRpYVN0cmVhbUZyYW1l Q29udHJvbGxlcjo6c2VjdXJpdHlPcmlnaW4oKSBjb25zdAotewotICAgIHJldHVybiBtX2ZyYW1l ID8gbV9mcmFtZS0+ZXhpc3RpbmdET01XaW5kb3coKS0+c2VjdXJpdHlPcmlnaW4oKSA6IDA7Ci19 Ci0KLVNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpz Y3JpcHRFeGVjdXRpb25Db250ZXh0KCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSA/IG1f ZnJhbWUtPmV4aXN0aW5nRE9NV2luZG93KCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA6IDA7 Ci19Ci0KLU1lZGlhU3RyZWFtQ29udHJvbGxlciogTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6 OnBhZ2VDb250cm9sbGVyKCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSAmJiBtX2ZyYW1l LT5wYWdlKCkgPyBtX2ZyYW1lLT5wYWdlKCktPm1lZGlhU3RyZWFtQ29udHJvbGxlcigpIDogMDsK LX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZW50ZXJEZXRhY2hlZFN0YXRl KCkKLXsKLSAgICBpZiAobV9pc0luRGV0YWNoZWRTdGF0ZSkgewotICAgICAgICBBU1NFUlQobV9y ZXF1ZXN0cy5pc0VtcHR5KCkpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgbV9yZXF1 ZXN0cy5hYm9ydEFsbCgpOwotICAgIG1faXNJbkRldGFjaGVkU3RhdGUgPSB0cnVlOwotfQotCi1i b29sIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjppc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0 Ci17Ci0gICAgaWYgKG1faXNJbkRldGFjaGVkU3RhdGUpCi0gICAgICAgIHJldHVybiBmYWxzZTsK LQotICAgIE1lZGlhU3RyZWFtQ29udHJvbGxlciogY29udHJvbGxlciA9IHBhZ2VDb250cm9sbGVy KCk7Ci0gICAgcmV0dXJuIGNvbnRyb2xsZXIgJiYgY29udHJvbGxlci0+aXNDbGllbnRBdmFpbGFi bGUoKTsKLX0KLQotLy8gQ2FsbGVkIGFsc28gd2hlbiB0aGUgZnJhbWUgaXMgZGV0YWNoZWQgZnJv bSB0aGUgcGFnZSwgaW4gd2hpY2ggY2FzZSB0aGUgcGFnZSBjb250cm9sbGVyIHdpbGwgcmVtYWlu IGFsaXZlLgotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZGlzY29ubmVjdFBhZ2Uo KQotewotICAgIGlmIChwYWdlQ29udHJvbGxlcigpKQotICAgICAgICBwYWdlQ29udHJvbGxlcigp LT51bnJlZ2lzdGVyRnJhbWVDb250cm9sbGVyKHRoaXMpOwotCi0gICAgZW50ZXJEZXRhY2hlZFN0 YXRlKCk7Ci19Ci0KLS8vIENhbGxlZCB3aGVuIHRoZSBmcmFtZSBpcyBiZWluZyBkZXN0cm95ZWQu IFNpbmNlIHRoZSBmcmFtZSBjb250cm9sbGVyIGlzIG93bmVkIGJ5IHRoZSBmcmFtZSBpdCB3aWxs IGRpZSBzaG9ydGx5IGFmdGVyIHRoaXMuCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy OjpkaXNjb25uZWN0RnJhbWUoKQotewotICAgIGRpc2Nvbm5lY3RQYWdlKCk7Ci0KLSAgICBBU1NF UlQobV9yZXF1ZXN0cy5pc0VtcHR5KCkpOwotCi0gICAgbV9mcmFtZSA9IDA7Ci19Ci0KLXZvaWQg TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnRyYW5zZmVyVG9OZXdQYWdlKFBhZ2UqKQotewot ICAgIC8vIEZJWE1FOiBJbiB0aGUgZnV0dXJlIHdlIHNob3VsZCBrZWVwIHJ1bm5pbmcgdGhlIG1l ZGlhIHN0cmVhbSBzZXJ2aWNlcyB3aGlsZSB0cmFuc2ZlcmluZyBmcmFtZXMgYmV0d2VlbiBwYWdl cy4KLSAgICAvLyBIb3dldmVyLCB1bnRpbCBhIHByb3BlciB3YXkgdG8gZG8gdGhpcyBpcyBkZWNp ZGVkLCB3ZSdyZSBzaHV0dGluZyBkb3duIHNlcnZpY2VzLgotICAgIGRpc2Nvbm5lY3RQYWdlKCk7 Ci19Ci0KLUdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXI6OnBhcnNlR2VuZXJhdGVTdHJlYW1PcHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucykKLXsK LSAgICBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzID0gMDsKLSAgICBWZWN0b3I8U3Ry aW5nPiBvcHRpb25MaXN0OwotICAgIG9wdGlvbnMuc3BsaXQoJywnLCBvcHRpb25MaXN0KTsKLQot ICAgIGZvciAoVmVjdG9yPFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIG9wdGlvbiA9IG9wdGlvbkxp c3QuYmVnaW4oKTsgb3B0aW9uICE9IG9wdGlvbkxpc3QuZW5kKCk7ICsrb3B0aW9uKSB7Ci0gICAg ICAgIFZlY3RvcjxTdHJpbmc+IHN1Ym9wdGlvbkxpc3Q7Ci0gICAgICAgIG9wdGlvbi0+c3BsaXQo JyAnLCBzdWJvcHRpb25MaXN0KTsKLQotICAgICAgICBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgp ID09ICJhdWRpbyIpCi0gICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RB dWRpbzsKLSAgICAgICAgZWxzZSBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgpID09ICJ2aWRlbyIp IHsKLSAgICAgICAgICAgIGJvb2wgdmlkZW9TdWJvcHRpb25zID0gZmFsc2U7Ci0gICAgICAgICAg ICBWZWN0b3I8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3Igc3Vib3B0aW9uID0gc3Vib3B0aW9uTGlz dC5iZWdpbigpOwotICAgICAgICAgICAgZm9yICgrK3N1Ym9wdGlvbjsgc3Vib3B0aW9uICE9IHN1 Ym9wdGlvbkxpc3QuZW5kKCk7ICsrc3Vib3B0aW9uKQotICAgICAgICAgICAgICAgIGlmICgqc3Vi b3B0aW9uID09ICJ1c2VyIikgewotICAgICAgICAgICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0 ZVN0cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ1VzZXI7Ci0gICAgICAgICAgICAgICAgICAgIHZpZGVv U3Vib3B0aW9ucyA9IHRydWU7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIGlmICgqc3Vib3B0aW9u ID09ICJlbnZpcm9ubWVudCIpIHsKLSAgICAgICAgICAgICAgICAgICAgZmxhZ3MgfD0gR2VuZXJh dGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdFbnZpcm9ubWVudDsKLSAgICAgICAgICAgICAgICAg ICAgdmlkZW9TdWJvcHRpb25zID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICB9Ci0KLSAgICAgICAg ICAgIC8vIEFzayBmb3IgYWxsIGtpbmQgb2YgY2FtZXJhcyBpZiBubyBzdWJvcHRpb24gd2FzIHNw ZWNpZmllZC4KLSAgICAgICAgICAgIGlmICghdmlkZW9TdWJvcHRpb25zKQotICAgICAgICAgICAg ICAgIGZsYWdzIHw9IEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nVXNlciB8IEdlbmVy YXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nRW52aXJvbm1lbnQ7Ci0gICAgICAgIH0KLSAgICB9 Ci0KLSAgICByZXR1cm4gZmxhZ3M7Ci19Ci0KLS8vIEltcGxlbWVudHMgdGhlIGdldFVzZXJNZWRp YSBtZXRob2QgZnJvbSBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVu dC13b3JrLyNkb20tbmF2aWdhdG9yLWdldHVzZXJtZWRpYS4KLXZvaWQgTWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXI6OmdlbmVyYXRlU3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0aW9ucywKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2 aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmln YXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFeGNlcHRpb25Db2RlJiBlYykKLXsK LSAgICBlYyA9IDA7Ci0gICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2spCi0gICAgICAgIHJldHVybjsK LQotICAgIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MgPSBwYXJzZUdlbmVyYXRlU3Ry ZWFtT3B0aW9ucyhvcHRpb25zKTsKLSAgICBpZiAoIWZsYWdzKSB7Ci0gICAgICAgIGVjID0gTk9U X1NVUFBPUlRFRF9FUlI7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBpbnQgcmVxdWVz dElkID0gbV9yZXF1ZXN0cy5nZXROZXh0SWQoKTsKLSAgICBtX3JlcXVlc3RzLmFkZChyZXF1ZXN0 SWQsIEdlbmVyYXRlU3RyZWFtUmVxdWVzdDo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQo KSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKSk7Ci0KLSAgICBpZiAoIWlzQ2xpZW50 QXZhaWxhYmxlKCkpIHsKLSAgICAgICAgLy8gVGhpcyBtYWtlcyBzdXJlIHRvIGNhbGwgdGhlIGVy cm9yIGNhbGxiYWNrIGlmIHByb3ZpZGVkLgotICAgICAgICBtX3JlcXVlc3RzLmFib3J0KHJlcXVl c3RJZCk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBwYWdlQ29udHJvbGxlcigpLT5n ZW5lcmF0ZVN0cmVhbSh0aGlzLCByZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0eU9yaWdpbigpKTsK LX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGVkKGlu dCByZXF1ZXN0SWQsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewot ICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgcmVxdWVzdCBjYW4gaGF2ZSBiZWVuIGFib3J0 ZWQgYXMgYSByZXN1bHQgb2YgZW1iZWRkZXIgZGV0YWNobWVudC4KLSAgICBpZiAoIW1fcmVxdWVz dHMuY29udGFpbnMocmVxdWVzdElkKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKG1f cmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCktPmlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkpOwotCi0g ICAgUmVmUHRyPEdlbmVyYXRlU3RyZWFtUmVxdWVzdD4gc3RyZWFtUmVxdWVzdCA9IHN0YXRpY19j YXN0PEdlbmVyYXRlU3RyZWFtUmVxdWVzdCo+KG1fcmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCkuZ2V0 KCkpOwotICAgIFJlZlB0cjxMb2NhbE1lZGlhU3RyZWFtPiBnZW5lcmF0ZWRTdHJlYW0gPSBMb2Nh bE1lZGlhU3RyZWFtOjpjcmVhdGUoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCBzb3VyY2VzKTsK LSAgICBtX3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotICAgIHN0cmVhbVJlcXVlc3QtPnN1 Y2Nlc3NDYWxsYmFjaygpLT5oYW5kbGVFdmVudChnZW5lcmF0ZWRTdHJlYW0uZ2V0KCkpOwotfQot Ci12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpzdHJlYW1HZW5lcmF0aW9uRmFpbGVk KGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUgY29kZSkK LXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIHJlcXVlc3QgY2FuIGhhdmUgYmVlbiBh Ym9ydGVkIGFzIGEgcmVzdWx0IG9mIGVtYmVkZGVyIGRldGFjaG1lbnQuCi0gICAgaWYgKCFtX3Jl cXVlc3RzLmNvbnRhaW5zKHJlcXVlc3RJZCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIEFTU0VS VChtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQpLT5pc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpKTsK LQotICAgIFJlZlB0cjxHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IHN0cmVhbVJlcXVlc3QgPSBzdGF0 aWNfY2FzdDxHZW5lcmF0ZVN0cmVhbVJlcXVlc3QqPihtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQp LmdldCgpKTsKLSAgICBtX3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotCi0gICAgaWYgKHN0 cmVhbVJlcXVlc3QtPmVycm9yQ2FsbGJhY2soKSkgewotICAgICAgICBSZWZQdHI8TmF2aWdhdG9y VXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShj b2RlKTsKLSAgICAgICAgc3RyZWFtUmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygpLT5oYW5kbGVFdmVu dChlcnJvci5nZXQoKSk7Ci0gICAgfQotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNl bmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgKZGVsZXRlZCBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDhjMDkzYTMuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVk aWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaAorKysgL2Rldi9udWxsCkBAIC0x LDEwNyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBt ZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBB TlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsK LSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyX2gKLSNkZWZpbmUgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXJfaAotCi0jaWYgRU5B QkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ2xpZW50LmgiCi0jaW5j bHVkZSAiTWVkaWFTdHJlYW1Tb3VyY2UuaCIKLSNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvci5oIgotI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0jaW5jbHVkZSA8d3RmL0hhc2hNYXAu aD4KLSNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KLSNpbmNsdWRlIDx3dGYvdGV4dC9TdHJp bmdIYXNoLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgRnJhbWU7Ci1jbGFzcyBN ZWRpYVN0cmVhbUNvbnRyb2xsZXI7Ci1jbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxi YWNrOwotY2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrOwotY2xhc3MgUGFn ZTsKLWNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7Ci1jbGFzcyBTZWN1cml0eU9yaWdpbjsK LQotdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKLQotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNv bnRyb2xsZXIgewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyKTsKLXB1YmxpYzoKLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcihGcmFtZSop OwotICAgIHZpcnR1YWwgfk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKCk7Ci0KLSAgICBTZWN1 cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKLSAgICBTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgY29uc3Q7Ci0KLSAgICBib29sIGlzQ2xp ZW50QXZhaWxhYmxlKCkgY29uc3Q7Ci0gICAgdm9pZCBkaXNjb25uZWN0UGFnZSgpOwotICAgIHZv aWQgZGlzY29ubmVjdEZyYW1lKCk7Ci0gICAgdm9pZCB0cmFuc2ZlclRvTmV3UGFnZShQYWdlKik7 Ci0KLSAgICBzdGF0aWMgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBwYXJzZUdlbmVyYXRlU3Ry ZWFtT3B0aW9ucyhjb25zdCBTdHJpbmcmKTsKLSAgICB2b2lkIGdlbmVyYXRlU3RyZWFtKGNvbnN0 IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2Fs bGJhY2s+LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+LCBFeGNl cHRpb25Db2RlJik7Ci0KLSAgICAvLyAtLS0gQ2FsbHMgY29taW5nIGJhY2sgZnJvbSB0aGUgY29u dHJvbGxlci4gLS0tIC8vCi0KLSAgICB2b2lkIHN0cmVhbUdlbmVyYXRlZChpbnQgcmVxdWVzdElk LCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcyk7Ci0gICAgdm9pZCBzdHJl YW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9y OjpFcnJvckNvZGUpOwotCi1wcml2YXRlOgotICAgIGNsYXNzIFJlcXVlc3Q7Ci0gICAgY2xhc3Mg R2VuZXJhdGVTdHJlYW1SZXF1ZXN0OwotCi0gICAgY2xhc3MgSWRHZW5lcmF0b3IgewotICAgICAg ICBXVEZfTUFLRV9OT05DT1BZQUJMRShJZEdlbmVyYXRvcik7Ci0gICAgcHVibGljOgotICAgICAg ICBJZEdlbmVyYXRvcigpIDogbV9pZCgwKSB7IH0KLSAgICAgICAgaW50IGdldE5leHRJZCgpIHsg cmV0dXJuICsrbV9pZDsgfQotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgaW50IG1faWQ7Ci0gICAg fTsKLQotICAgIGNsYXNzIFJlcXVlc3RNYXAgOiBwdWJsaWMgSWRHZW5lcmF0b3IsIHB1YmxpYyBI YXNoTWFwPGludCwgUmVmUHRyPFJlcXVlc3Q+ID4gewotICAgIHB1YmxpYzoKLSAgICAgICAgdm9p ZCBhYm9ydChpbnQgcmVxdWVzdElkKTsKLSAgICAgICAgdm9pZCBhYm9ydEFsbCgpOwotICAgIH07 Ci0KLSAgICAvLyBEZXRhY2hlZCBmcm9tIGEgcGFnZSwgYW5kIGhlbmNlIGZyb20gYSBlbWJlZGRl ciBjbGllbnQuCi0gICAgdm9pZCBlbnRlckRldGFjaGVkU3RhdGUoKTsKLQotICAgIE1lZGlhU3Ry ZWFtQ29udHJvbGxlciogcGFnZUNvbnRyb2xsZXIoKSBjb25zdDsKLQotICAgIFJlcXVlc3RNYXAg bV9yZXF1ZXN0czsKLQotICAgIEZyYW1lKiBtX2ZyYW1lOwotICAgIGJvb2wgbV9pc0luRGV0YWNo ZWRTdGF0ZTsKLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVOQUJM RShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcl9o CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQu aCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjczOWI3MDAKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaApAQCAtMCwwICsxLDU4 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 LgorICovCisKKyNpZm5kZWYgVXNlck1lZGlhQ2xpZW50X2gKKyNkZWZpbmUgVXNlck1lZGlhQ2xp ZW50X2gKKworI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeworCitjbGFzcyBVc2VyTWVkaWFDbGllbnQgeworcHVibGljOgorICAgIHZpcnR1YWwg dm9pZCB1c2VyTWVkaWFDb250cm9sbGVyRGVzdHJveWVkKCkgPSAwOworCisgICAgdmlydHVhbCB2 b2lkIHJlcXVlc3RVc2VyTWVkaWEoVXNlck1lZGlhUmVxdWVzdCopID0gMDsKKyAgICB2aXJ0dWFs IHZvaWQgY2FuY2VsVXNlck1lZGlhUmVxdWVzdChVc2VyTWVkaWFSZXF1ZXN0KikgPSAwOworCisg ICAgdmlydHVhbCB2b2lkIHVzZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKFVzZXJNZWRpYVJlcXVlc3Qq LCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYpID0gMDsKKworcHJvdGVjdGVkOgorICAg IHZpcnR1YWwgflVzZXJNZWRpYUNsaWVudCgpIHsgfQorfTsKKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIFVzZXJN ZWRpYUNsaWVudF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRp YUNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk2YmMx YzQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVk aWFDb250cm9sbGVyLmNwcApAQCAtMCwwICsxLDEzNyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg 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 IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiVXNlck1lZGlhQ29u dHJvbGxlci5oIgorCisjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJMb2NhbE1lZGlhU3Ry ZWFtLmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIKKyNpbmNsdWRlICJV c2VyTWVkaWFDbGllbnQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitVc2VyTWVkaWFDb250 cm9sbGVyOjpVc2VyTWVkaWFDb250cm9sbGVyKFBhZ2UqIHBhZ2UsIFVzZXJNZWRpYUNsaWVudCog Y2xpZW50KQorICAgIDogbV9wYWdlKHBhZ2UpCisgICAgLCBtX2NsaWVudChjbGllbnQpCit7Cit9 CisKK1VzZXJNZWRpYUNvbnRyb2xsZXI6On5Vc2VyTWVkaWFDb250cm9sbGVyKCkKK3sKKyAgICBp ZiAobV9jbGllbnQpCisgICAgICAgIG1fY2xpZW50LT51c2VyTWVkaWFDb250cm9sbGVyRGVzdHJv eWVkKCk7Cit9CisKK3ZvaWQgVXNlck1lZGlhQ29udHJvbGxlcjo6cmVxdWVzdFVzZXJNZWRpYShQ YXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHBycFJlcXVlc3QpCit7CisgICAgaWYgKCFtX2Ns aWVudCkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJl cXVlc3QgPSBwcnBSZXF1ZXN0OworCisgICAgbV9yZXF1ZXN0cy5hcHBlbmQocmVxdWVzdCk7Cisg ICAgbV9jbGllbnQtPnJlcXVlc3RVc2VyTWVkaWEocmVxdWVzdC5nZXQoKSk7Cit9CisKK3ZvaWQg VXNlck1lZGlhQ29udHJvbGxlcjo6Y2FuY2VsVXNlck1lZGlhUmVxdWVzdChVc2VyTWVkaWFSZXF1 ZXN0KiByZXF1ZXN0KQoreworICAgIGlmICghbV9jbGllbnQpCisgICAgICAgIHJldHVybjsKKwor ICAgIG1fY2xpZW50LT5jYW5jZWxVc2VyTWVkaWFSZXF1ZXN0KHJlcXVlc3QpOworICAgIHJlcXVl c3QtPmNsZWFyQ29udHJvbGxlcigpOworCisgICAgc2l6ZV90IGkgPSBtX3JlcXVlc3RzLmZpbmQo cmVxdWVzdCk7CisgICAgQVNTRVJUKGkgIT0gbm90Rm91bmQpOworICAgIG1fcmVxdWVzdHMucmVt b3ZlKGkpOworfQorCitzdGF0aWMgYm9vbCByZXF1ZXN0SXNWYWxpZChVc2VyTWVkaWFSZXF1ZXN0 KiByZXF1ZXN0KQoreworICAgIEFTU0VSVChtX3JlcXVlc3RzLmNvbnRhaW5zKHJlcXVlc3QpKTsK KworICAgIGlmICghcmVxdWVzdC0+ZnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCA9IHJlcXVlc3QtPmZyYW1lKCktPmRv Y3VtZW50KCk7CisgICAgaWYgKCFjb250ZXh0IHx8IGNvbnRleHQgIT0gcmVxdWVzdC0+c2NyaXB0 RXhlY3V0aW9uQ29udGV4dCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICByZXR1cm4g dHJ1ZTsKK30KKwordm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0U3Vj Y2VlZGVkKFVzZXJNZWRpYVJlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNl VmVjdG9yJiBzb3VyY2VzKQoreworICAgIGlmICghcmVxdWVzdElzVmFsaWQocmVxdWVzdCkpCisg ICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2NhbE1lZGlhU3RyZWFtPiBzdHJlYW0gPSBM b2NhbE1lZGlhU3RyZWFtOjpjcmVhdGUocmVxdWVzdC0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgp LCBzb3VyY2VzKTsKKyAgICByZXF1ZXN0LT5zdWNjZXNzQ2FsbGJhY2soKS0+aGFuZGxlRXZlbnQo c3RyZWFtLmdldCgpKTsKKworICAgIHNpemVfdCBpID0gbV9yZXF1ZXN0cy5maW5kKHJlcXVlc3Qp OworICAgIEFTU0VSVChpICE9IG5vdEZvdW5kKTsKKyAgICBtX3JlcXVlc3RzLnJlbW92ZShpKTsK K30KKwordm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0RmFpbGVkKFVz ZXJNZWRpYVJlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgaWYgKCFyZXF1ZXN0SXNWYWxpZChyZXF1 ZXN0KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKHJlcXVlc3QtPmVycm9yQ2FsbGJhY2so KSkgeworICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2 aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6UEVS TUlTU0lPTl9ERU5JRUQpOworICAgICAgICByZXF1ZXN0LT5lcnJvckNhbGxiYWNrKCktPmhhbmRs ZUV2ZW50KGVycm9yLmdldCgpKTsKKyAgICB9CisKKyAgICBzaXplX3QgaSA9IG1fcmVxdWVzdHMu ZmluZChyZXF1ZXN0KTsKKyAgICBBU1NFUlQoaSAhPSBub3RGb3VuZCk7CisgICAgbV9yZXF1ZXN0 cy5yZW1vdmUoaSk7Cit9CisKK3ZvaWQgVXNlck1lZGlhQ29udHJvbGxlcjo6cXVlcnlVc2VyTWVk aWEoVXNlck1lZGlhUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBBU1NFUlQobV9yZXF1ZXN0cy5j b250YWlucyhyZXF1ZXN0KSk7CisKKyAgICAvLyBGSVhNRTogcXVlcnkgdGhlIHBsYXRmb3JtIGZv ciBhdmFpbGFibGUgdXNlciBtZWRpYSwgc2VlIGh0dHA6Ly93ZWJraXQub3JnL2IvNzA4OTUKK30K Kwordm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjp1c2VyTWVkaWFRdWVyeUNvbXBsZXRlZChVc2Vy TWVkaWFSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291 cmNlcykKK3sKKyAgICBpZiAobV9jbGllbnQpCisgICAgICAgIG1fY2xpZW50LT51c2VyTWVkaWFR dWVyeUNvbXBsZXRlZChyZXF1ZXN0LCBzb3VyY2VzKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi5kNDk0MTFlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5oCkBAIC0wLDAgKzEsNzQgQEAKKy8q 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 KworI2lmbmRlZiBVc2VyTWVkaWFDb250cm9sbGVyX2gKKyNkZWZpbmUgVXNlck1lZGlhQ29udHJv bGxlcl9oCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiTWVkaWFTdHJl YW1Tb3VyY2UuaCIKKyNpbmNsdWRlICJVc2VyTWVkaWFSZXF1ZXN0LmgiCisjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEZyYW1lOworY2xhc3Mg UGFnZTsKK2NsYXNzIFVzZXJNZWRpYUNsaWVudDsKKworY2xhc3MgVXNlck1lZGlhQ29udHJvbGxl ciB7CisgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVXNlck1lZGlhQ29udHJvbGxlcik7CitwdWJs aWM6CisgICAgVXNlck1lZGlhQ29udHJvbGxlcihQYWdlKiwgVXNlck1lZGlhQ2xpZW50Kik7Cisg ICAgflVzZXJNZWRpYUNvbnRyb2xsZXIoKTsKKworICAgIHZvaWQgcmVxdWVzdFVzZXJNZWRpYShQ YXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+KTsKKyAgICB2b2lkIGNhbmNlbFVzZXJNZWRpYVJl cXVlc3QoVXNlck1lZGlhUmVxdWVzdCopOworCisgICAgdm9pZCB1c2VyTWVkaWFSZXF1ZXN0U3Vj Y2VlZGVkKFVzZXJNZWRpYVJlcXVlc3QqLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYp OworICAgIHZvaWQgdXNlck1lZGlhUmVxdWVzdEZhaWxlZChVc2VyTWVkaWFSZXF1ZXN0Kik7CisK KyAgICBVc2VyTWVkaWFDbGllbnQqIGNsaWVudCgpIGNvbnN0IHsgcmV0dXJuIG1fY2xpZW50OyB9 CisKKyAgICB2b2lkIHF1ZXJ5VXNlck1lZGlhKFVzZXJNZWRpYVJlcXVlc3QqKTsKKyAgICB2b2lk IHVzZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKFVzZXJNZWRpYVJlcXVlc3QqLCBjb25zdCBNZWRpYVN0 cmVhbVNvdXJjZVZlY3RvciYpOworCitwcml2YXRlOgorICAgIFBhZ2UqIG1fcGFnZTsKKyAgICBV c2VyTWVkaWFDbGllbnQqIG1fY2xpZW50OworCisgICAgVmVjdG9yPFJlZlB0cjxVc2VyTWVkaWFS ZXF1ZXN0PiA+IG1fcmVxdWVzdHM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNl bmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8gVXNlck1lZGlhQ29udHJv bGxlcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFS ZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3Qu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg2MWRmMTEKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNw cApAQCAtMCwwICsxLDEwNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBB Qi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhl ciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMK KyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVk IGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVu IHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09Q WVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQg VE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5oIgorCisjaW5j bHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlNwYWNlU3BsaXRTdHJpbmcuaCIKKyNpbmNsdWRlICJV c2VyTWVkaWFDb250cm9sbGVyLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc1JlZlB0 cjxVc2VyTWVkaWFSZXF1ZXN0PiBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoRnJhbWUqIGZyYW1l LCBjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3Vj Y2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1l ZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBSZWZQdHI8VXNlck1lZGlh UmVxdWVzdD4gcmVxdWVzdCA9IGFkb3B0UmVmKG5ldyBVc2VyTWVkaWFSZXF1ZXN0KGZyYW1lLCBv cHRpb25zLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spKTsKKyAgICBpZiAoIXJlcXVl c3QtPmF1ZGlvKCkgJiYgIXJlcXVlc3QtPnZpZGVvKCkpCisgICAgICAgIHJldHVybiAwOworCisg ICAgcmV0dXJuIHJlcXVlc3QucmVsZWFzZSgpOworfQorCitVc2VyTWVkaWFSZXF1ZXN0OjpVc2Vy TWVkaWFSZXF1ZXN0KEZyYW1lKiBmcmFtZSwgY29uc3QgU3RyaW5nJiBvcHRpb25zLCBQYXNzUmVm UHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQ YXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2sp CisgICAgOiBtX2F1ZGlvKGZhbHNlKQorICAgICwgbV92aWRlbyhmYWxzZSkKKyAgICAsIG1fY2Ft ZXJhUHJlZmVyZW5jZVVzZXIoZmFsc2UpCisgICAgLCBtX2NhbWVyYVByZWZlcmVuY2VFbnZpcm9u bWVudChmYWxzZSkKKyAgICAsIG1fZnJhbWUoZnJhbWUpCisgICAgLCBtX3NjcmlwdEV4ZWN1dGlv bkNvbnRleHQoZnJhbWUtPmRvY3VtZW50KCkpCisgICAgLCBtX2NvbnRyb2xsZXIoZnJhbWUtPnBh Z2UoKS0+dXNlck1lZGlhQ29udHJvbGxlcigpKQorICAgICwgbV9zdWNjZXNzQ2FsbGJhY2soc3Vj Y2Vzc0NhbGxiYWNrKQorICAgICwgbV9lcnJvckNhbGxiYWNrKGVycm9yQ2FsbGJhY2spCit7Cisg ICAgcGFyc2VPcHRpb25zKG9wdGlvbnMpOworCisgICAgbV9mcmFtZS0+YWRkRGVzdHJ1Y3Rpb25P YnNlcnZlcih0aGlzKTsKK30KKworVXNlck1lZGlhUmVxdWVzdDo6flVzZXJNZWRpYVJlcXVlc3Qo KQoreworICAgIGlmIChtX2ZyYW1lKQorICAgICAgICBtX2ZyYW1lLT5yZW1vdmVEZXN0cnVjdGlv bk9ic2VydmVyKHRoaXMpOworfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OnBhcnNlT3B0aW9u cyhjb25zdCBTdHJpbmcmIG9wdGlvbnMpCit7CisgICAgVmVjdG9yPFN0cmluZz4gb3B0aW9uc0xp c3Q7CisgICAgb3B0aW9ucy5zcGxpdCgiLCIsIG9wdGlvbnNMaXN0KTsKKworICAgIGZvciAoc2l6 ZV90IGkgPSAwOyBpIDwgb3B0aW9uc0xpc3Quc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgU3BhY2VT cGxpdFN0cmluZyBzdWJPcHRpb25zKG9wdGlvbnNMaXN0W2ldLCBmYWxzZSk7CisKKyAgICAgICAg aWYgKHN1Yk9wdGlvbnNbMF0gPT0gImF1ZGlvIikKKyAgICAgICAgICAgIG1fYXVkaW8gPSB0cnVl OworICAgICAgICBlbHNlIGlmIChzdWJPcHRpb25zWzBdID09ICJ2aWRlbyIpIHsKKyAgICAgICAg ICAgIG1fdmlkZW8gPSB0cnVlOworICAgICAgICAgICAgaWYgKHN1Yk9wdGlvbnMuY29udGFpbnMo InVzZXIiKSkKKyAgICAgICAgICAgICAgICBtX2NhbWVyYVByZWZlcmVuY2VVc2VyID0gdHJ1ZTsK KyAgICAgICAgICAgIGlmIChzdWJPcHRpb25zLmNvbnRhaW5zKCJlbnZpcm9ubWVudCIpKQorICAg ICAgICAgICAgICAgIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50ID0gdHJ1ZTsKKyAgICAg ICAgfQorICAgIH0KK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpmcmFtZURlc3Ryb3llZCgp Cit7CisgICAgaWYgKG1fY29udHJvbGxlcikKKyAgICAgICAgbV9jb250cm9sbGVyLT5jYW5jZWxV c2VyTWVkaWFSZXF1ZXN0KHRoaXMpOworCisgICAgbV9mcmFtZSA9IDA7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmggYi9Tb3Vy Y2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uYmM4YzJiZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaApAQCAtMCwwICsxLDkzIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEu IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0 aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl CisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29u IG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8g ZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0 d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09O VFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAor ICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpZm5kZWYgVXNlck1lZGlhUmVxdWVzdF9oCisjZGVmaW5lIFVzZXJNZWRpYVJlcXVlc3Rf aAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5j bHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgorI2luY2x1ZGUgIk5hdmln YXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5n LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRl ZC5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEZyYW1lOworY2xhc3MgVXNlck1l ZGlhQ29udHJvbGxlcjsKKworY2xhc3MgVXNlck1lZGlhUmVxdWVzdCA6IHB1YmxpYyBSZWZDb3Vu dGVkPFVzZXJNZWRpYVJlcXVlc3Q+LCBwdWJsaWMgRnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyIHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBjcmVhdGUo RnJhbWUqLCBjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1l ZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNh bGxiYWNrPik7CisgICAgflVzZXJNZWRpYVJlcXVlc3QoKTsKKworICAgIHZpcnR1YWwgdm9pZCBm cmFtZURlc3Ryb3llZCgpOworCisgICAgYm9vbCBhdWRpbygpIGNvbnN0IHsgcmV0dXJuIG1fYXVk aW87IH0KKyAgICBib29sIHZpZGVvKCkgY29uc3QgeyByZXR1cm4gbV92aWRlbzsgfQorCisgICAg Ym9vbCBjYW1lcmFQcmVmZXJlbmNlVXNlcigpIGNvbnN0IHsgcmV0dXJuIG1fY2FtZXJhUHJlZmVy ZW5jZVVzZXI7IH0KKyAgICBib29sIGNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCgpIGNvbnN0 IHsgcmV0dXJuIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50OyB9CisKKyAgICBGcmFtZSog ZnJhbWUoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lOyB9CisgICAgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dDsgfQorCisgICAgVXNlck1lZGlhQ29udHJvbGxlciogY29udHJvbGxlcigp IGNvbnN0IHsgcmV0dXJuIG1fY29udHJvbGxlcjsgfQorICAgIHZvaWQgY2xlYXJDb250cm9sbGVy KCkgeyBtX2NvbnRyb2xsZXIgPSAwOyB9CisKKyAgICBOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNz Q2FsbGJhY2sqIHN1Y2Nlc3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fc3VjY2Vzc0NhbGxi YWNrLmdldCgpOyB9CisgICAgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjayogZXJyb3JD YWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fZXJyb3JDYWxsYmFjay5nZXQoKTsgfQorCitwcml2 YXRlOgorICAgIFVzZXJNZWRpYVJlcXVlc3QoRnJhbWUqLCBjb25zdCBTdHJpbmcmIG9wdGlvbnMs IFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiwgUGFzc1JlZlB0 cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPik7CisKKyAgICB2b2lkIHBhcnNlT3B0 aW9ucyhjb25zdCBTdHJpbmcmIG9wdGlvbnMpOworCisgICAgYm9vbCBtX2F1ZGlvOworICAgIGJv b2wgbV92aWRlbzsKKworICAgIGJvb2wgbV9jYW1lcmFQcmVmZXJlbmNlVXNlcjsKKyAgICBib29s IG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50OworCisgICAgRnJhbWUqIG1fZnJhbWU7Cisg ICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0OworICAg IFVzZXJNZWRpYUNvbnRyb2xsZXIqIG1fY29udHJvbGxlcjsKKworICAgIFJlZlB0cjxOYXZpZ2F0 b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IG1fc3VjY2Vzc0NhbGxiYWNrOworICAgIFJlZlB0 cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBtX2Vycm9yQ2FsbGJhY2s7Cit9Owor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFN KQorCisjZW5kaWYgLy8gVXNlck1lZGlhUmVxdWVzdF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0NhbGxiYWNrVGFzay5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rh c2suaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQwMGQzMS4uMDAwMDAwMAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0NhbGxiYWNrVGFzay5oCisrKyAvZGV2L251bGwKQEAgLTEs ODEgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0 OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5Z Ci0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0g KiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBDYWxsYmFja1Rhc2tfaAotI2RlZmlu ZSBDYWxsYmFja1Rhc2tfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUg IlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotI2lu Y2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+Ci0jaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgotCi1uYW1l c3BhY2UgV2ViQ29yZSB7Ci0KLS8vIEhlbHBlciB0ZW1wbGF0ZSB0byBzY2hlZHVsZSBjYWxscyB0 byBjYWxsYmFja3MgdXNpbmcgdGhlaXIgb3duIHNjcmlwdCBleGVjdXRpb24gY29udGV4dC4KLS8v IENhbGxiYWNrVHlwZSBpcyBhc3N1bWVkIHRvIGltcGxlbWVudCBTY2hlZHVsZXIgYW5kIHRvIGJl IHJlZmVyZW5jZS1jb3VudGVkLgotdGVtcGxhdGUgPHR5cGVuYW1lIENhbGxiYWNrVHlwZSwgdHlw ZW5hbWUgQXJndW1lbnRUeXBlPgotY2xhc3MgQ2FsbGJhY2tUYXNrMSA6IHB1YmxpYyBTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrIHsKLXB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc093blB0cjxD YWxsYmFja1Rhc2sxPiBjcmVhdGUoUGFzc1JlZlB0cjxDYWxsYmFja1R5cGU+IGNhbGxiYWNrLCBQ YXNzUmVmUHRyPEFyZ3VtZW50VHlwZT4gZGF0YSkKLSAgICB7Ci0gICAgICAgIHJldHVybiBhZG9w dFB0cihuZXcgQ2FsbGJhY2tUYXNrMShjYWxsYmFjaywgZGF0YSkpOwotICAgIH0KLQotICAgIHZp cnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikKLSAgICB7Ci0g ICAgICAgIG1fY2FsbGJhY2stPmhhbmRsZUV2ZW50KG1fZGF0YS5nZXQoKSk7Ci0gICAgfQotCi0g ICAgY2xhc3MgU2NoZWR1bGVyIHsKLSAgICBwdWJsaWM6Ci0gICAgICAgIHZpcnR1YWwgflNjaGVk dWxlcigpIHsgfQotCi0gICAgICAgIGJvb2wgc2NoZWR1bGVDYWxsYmFjayhTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPEFyZ3VtZW50VHlwZT4gZGF0YSkKLSAgICAg ICAgewotICAgICAgICAgICAgaWYgKGNvbnRleHQpIHsKLSAgICAgICAgICAgICAgICBjb250ZXh0 LT5wb3N0VGFzayhDYWxsYmFja1Rhc2sxPENhbGxiYWNrVHlwZSwgQXJndW1lbnRUeXBlPjo6Y3Jl YXRlKHN0YXRpY19jYXN0PENhbGxiYWNrVHlwZSo+KHRoaXMpLCBkYXRhKSk7Ci0gICAgICAgICAg ICAgICAgcmV0dXJuIHRydWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICByZXR1cm4gZmFs c2U7Ci0gICAgICAgIH0KLSAgICB9OwotCi1wcml2YXRlOgotICAgIENhbGxiYWNrVGFzazEoUGFz c1JlZlB0cjxDYWxsYmFja1R5cGU+IGNhbGxiYWNrLCBQYXNzUmVmUHRyPEFyZ3VtZW50VHlwZT4g ZGF0YSkKLSAgICAgICAgOiBtX2NhbGxiYWNrKGNhbGxiYWNrKQotICAgICAgICAsIG1fZGF0YShk YXRhKQotICAgIHsKLSAgICB9Ci0KLSAgICBSZWZQdHI8Q2FsbGJhY2tUeXBlPiBtX2NhbGxiYWNr OwotICAgIFJlZlB0cjxBcmd1bWVudFR5cGU+IG1fZGF0YTsKLX07Ci0KLX0KLQotI2VuZGlmIC8v IEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBDYWxsYmFja1Rhc2tfaApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L0ZyYW1lLmNwcAppbmRleCBhODhmMTg1Li44M2ZjNjI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcApA QCAtMTExLDEwICsxMTEsNiBAQAogI2luY2x1ZGUgIlNWR0RvY3VtZW50RXh0ZW5zaW9ucy5oIgog I2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotI2luY2x1ZGUgIk1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyLmgiCi0jZW5kaWYKLQogI2lmIFVTRShUSUxFRF9CQUNLSU5HX1NUT1JF KQogI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCiAjZW5kaWYKQEAgLTE2OSw5ICsxNjUs NiBAQCBpbmxpbmUgRnJhbWU6OkZyYW1lKFBhZ2UqIHBhZ2UsIEhUTUxGcmFtZU93bmVyRWxlbWVu dCogb3duZXJFbGVtZW50LCBGcmFtZUxvYWRlcgogICAgICwgbV9pblZpZXdTb3VyY2VNb2RlKGZh bHNlKQogICAgICwgbV9pc0Rpc2Nvbm5lY3RlZChmYWxzZSkKICAgICAsIG1fZXhjbHVkZUZyb21U ZXh0U2VhcmNoKGZhbHNlKQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgLCBtX21lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6Om1lZGlhU3RyZWFt RW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKHRoaXMp KSA6IFBhc3NPd25QdHI8TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI+KCkpCi0jZW5kaWYKIHsK ICAgICBBU1NFUlQocGFnZSk7CiAgICAgQXRvbWljU3RyaW5nOjppbml0KCk7CkBAIC0yMjgsMTEg KzIyMSw2IEBAIEZyYW1lOjp+RnJhbWUoKQogICAgIGlmIChtX2RvbVdpbmRvdykKICAgICAgICAg bV9kb21XaW5kb3ctPmRpc2Nvbm5lY3RGcmFtZSgpOwogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVB TSkKLSAgICBpZiAobV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgbV9tZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlci0+ZGlzY29ubmVjdEZyYW1lKCk7Ci0jZW5kaWYKLQogICAg IEhhc2hTZXQ8RE9NV2luZG93Kj46Oml0ZXJhdG9yIGVuZCA9IG1fbGl2ZUZvcm1lcldpbmRvd3Mu ZW5kKCk7CiAgICAgZm9yIChIYXNoU2V0PERPTVdpbmRvdyo+OjppdGVyYXRvciBpdCA9IG1fbGl2 ZUZvcm1lcldpbmRvd3MuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQogICAgICAgICAoKml0KS0+ ZGlzY29ubmVjdEZyYW1lKCk7CkBAIC02OTgsMTEgKzY4Niw2IEBAIHZvaWQgRnJhbWU6OnBhZ2VE ZXN0cm95ZWQoKQogICAgICAgICBtX2RvbVdpbmRvdy0+cGFnZURlc3Ryb3llZCgpOwogICAgIH0K IAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgaWYgKG1fbWVkaWFTdHJlYW1GcmFtZUNv bnRyb2xsZXIpCi0gICAgICAgIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXItPmRpc2Nvbm5l Y3RQYWdlKCk7Ci0jZW5kaWYKLQogICAgIC8vIEZJWE1FOiBJdCdzIHVuY2xlYXIgYXMgdG8gd2h5 IHRoaXMgaXMgY2FsbGVkIG1vcmUgdGhhbiBvbmNlLCBidXQgaXQgaXMsCiAgICAgLy8gc28gcGFn ZSgpIGNvdWxkIGJlIE5VTEwuCiAgICAgaWYgKHBhZ2UoKSAmJiBwYWdlKCktPmZvY3VzQ29udHJv bGxlcigpLT5mb2N1c2VkRnJhbWUoKSA9PSB0aGlzKQpAQCAtNzU2LDEwICs3MzksNiBAQCB2b2lk IEZyYW1lOjp0cmFuc2ZlckNoaWxkRnJhbWVUb05ld0RvY3VtZW50KCkKICNlbmRpZgogICAgICAg ICB9CiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBpZiAobV9tZWRpYVN0cmVh bUZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgICAgIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXItPnRyYW5zZmVyVG9OZXdQYWdlKG5ld1BhZ2UpOwotI2VuZGlmCiAgICAgICAgIG1fcGFnZSA9 IG5ld1BhZ2U7CiAKICAgICAgICAgaWYgKG5ld1BhZ2UpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgKaW5kZXggODE2 NjVjNi4uYjMyMDI2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaApAQCAtNjUsNyArNjUsNiBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgRG9jdW1lbnQ7CiAgICAgY2xhc3MgRnJhbWVWaWV3Owog ICAgIGNsYXNzIEhUTUxUYWJsZUNlbGxFbGVtZW50OwotICAgIGNsYXNzIE1lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyOwogICAgIGNsYXNzIFJlZ3VsYXJFeHByZXNzaW9uOwogICAgIGNsYXNzIFJl bmRlclBhcnQ7CiAgICAgY2xhc3MgVGlsZWRCYWNraW5nU3RvcmU7CkBAIC0yMDEsMTAgKzIwMCw2 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgTlNJbWFnZSogaW1hZ2VGcm9tUmVjdChO U1JlY3QpIGNvbnN0OwogI2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAg ICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIo KSBjb25zdCB7IHJldHVybiBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmdldCgpOyB9Ci0j ZW5kaWYKLSAgICAgICAgCiAgICAgICAgIC8vIFNob3VsZCBvbmx5IGJlIGNhbGxlZCBvbiB0aGUg bWFpbiBmcmFtZSBvZiBhIHBhZ2UuCiAgICAgICAgIHZvaWQgbm90aWZ5Q2hyb21lQ2xpZW50V2hl ZWxFdmVudEhhbmRsZXJDb3VudENoYW5nZWQoKSBjb25zdDsKIApAQCAtMjY2LDkgKzI2MSw2IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgT3duUHRyPFRpbGVkQmFja2luZ1N0b3JlPiBt X3RpbGVkQmFja2luZ1N0b3JlOwogI2VuZGlmCiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQot ICAgICAgICBPd25QdHI8TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI+IG1fbWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXI7Ci0jZW5kaWYKICAgICB9OwogCiAgICAgaW5saW5lIHZvaWQgRnJhbWU6 OmluaXQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwIGIv U291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwCmluZGV4IDUzNTc1YWYuLjU5NzEyYTcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAKQEAgLTQ1LDkgKzQ1LDkgQEAKICNpbmNsdWRl IDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotI2luY2x1 ZGUgIk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjay5oIgogI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nl c3NDYWxsYmFjay5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKICNlbmRpZgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0yODMsOCArMjgzLDIzIEBAIHZvaWQgTmF2aWdhdG9y OjpyZWdpc3RlclByb3RvY29sSGFuZGxlcihjb25zdCBTdHJpbmcmIHNjaGVtZSwgY29uc3QgU3Ry aW5nJiB1cmwsCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKIHZvaWQgTmF2aWdhdG9yOjp3ZWJr aXRHZXRVc2VyTWVkaWEoY29uc3QgU3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRv clVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPE5h dmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssIEV4Y2VwdGlvbkNv ZGUmIGVjKQogewotICAgIGlmIChtX2ZyYW1lICYmIG1fZnJhbWUtPm1lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyKCkpCi0gICAgICAgIG1fZnJhbWUtPm1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy KCktPmdlbmVyYXRlU3RyZWFtKG9wdGlvbnMsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFj aywgZWMpOworICAgIGlmICghc3VjY2Vzc0NhbGxiYWNrKQorICAgICAgICByZXR1cm47CisKKyAg ICBpZiAoIW1fZnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIFBhZ2UqIHBhZ2UgPSBtX2Zy YW1lLT5wYWdlKCk7CisgICAgaWYgKCFwYWdlKQorICAgICAgICByZXR1cm47CisKKyAgICBSZWZQ dHI8VXNlck1lZGlhUmVxdWVzdD4gcmVxdWVzdCA9IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZSht X2ZyYW1lLCBvcHRpb25zLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAgIGlm ICghcmVxdWVzdCkgeworICAgICAgICBlYyA9IE5PVF9TVVBQT1JURURfRVJSOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgcGFnZS0+dXNlck1lZGlhQ29udHJvbGxlcigpLT5yZXF1ZXN0 VXNlck1lZGlhKHJlcXVlc3QucmVsZWFzZSgpKTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZp Z2F0b3IuaAppbmRleCAzYTFlMDQyLi4zNWU2MmJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL05hdmlnYXRvci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmgK QEAgLTM1LDYgKzM1LDcgQEAgY2xhc3MgR2VvbG9jYXRpb247CiBjbGFzcyBOYXZpZ2F0b3JVc2Vy TWVkaWFFcnJvckNhbGxiYWNrOwogY2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxi YWNrOwogY2xhc3MgUGx1Z2luRGF0YTsKK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiAK IHR5cGVkZWYgaW50IEV4Y2VwdGlvbkNvZGU7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIGIvU291cmNlL1dlYkNvcmUv cGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgKaW5kZXggMTUzOTcwOS4uZGQz YzhiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFF cnJvckNhbGxiYWNrLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrLmgKQEAgLTI3LDE0ICsyNywxMiBAQAogCiAjaWYgRU5BQkxFKE1FRElB X1NUUkVBTSkKIAotI2luY2x1ZGUgIkNhbGxiYWNrVGFzay5oIgogI2luY2x1ZGUgIk5hdmlnYXRv clVzZXJNZWRpYUVycm9yLmgiCiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCi1jbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrIDog cHVibGljIFJlZkNvdW50ZWQ8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4sCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHVibGljIENhbGxiYWNrVGFzazE8 TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaywgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+ OjpTY2hlZHVsZXIgeworY2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjayA6IHB1 YmxpYyBSZWZDb3VudGVkPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IHsKIHB1Ymxp YzoKICAgICB2aXJ0dWFsIH5OYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrKCkgeyB9CiAg ICAgdmlydHVhbCBib29sIGhhbmRsZUV2ZW50KE5hdmlnYXRvclVzZXJNZWRpYUVycm9yKikgPSAw OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvUGFnZS5jcHAKaW5kZXggNTlmMzU3OS4uNTE0MmU5OSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2Uu Y3BwCkBAIC04MCw4ICs4MCw3IEBACiAjZW5kaWYKIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0p Ci0jaW5jbHVkZSAiTWVkaWFTdHJlYW1DbGllbnQuaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNv bnRyb2xsZXIuaCIKKyNpbmNsdWRlICJVc2VyTWVkaWFDb250cm9sbGVyLmgiCiAjZW5kaWYKIAog bmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMTM3LDEyICsxMzYsMTIgQEAgUGFnZTo6UGFnZShQYWdl Q2xpZW50cyYgcGFnZUNsaWVudHMpCiAgICAgLCBtX2RldmljZU1vdGlvbkNvbnRyb2xsZXIoUnVu dGltZUVuYWJsZWRGZWF0dXJlczo6ZGV2aWNlTW90aW9uRW5hYmxlZCgpID8gYWRvcHRQdHIobmV3 IERldmljZU1vdGlvbkNvbnRyb2xsZXIocGFnZUNsaWVudHMuZGV2aWNlTW90aW9uQ2xpZW50KSkg OiBudWxscHRyKQogICAgICwgbV9kZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIoUnVudGltZUVu YWJsZWRGZWF0dXJlczo6ZGV2aWNlT3JpZW50YXRpb25FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcg RGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyKHRoaXMsIHBhZ2VDbGllbnRzLmRldmljZU9yaWVu dGF0aW9uQ2xpZW50KSkgOiBudWxscHRyKQogI2VuZGlmCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVB TSkKLSAgICAsIG1fbWVkaWFTdHJlYW1Db250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6 Om1lZGlhU3RyZWFtRW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IE1lZGlhU3RyZWFtQ29udHJvbGxl cihwYWdlQ2xpZW50cy5tZWRpYVN0cmVhbUNsaWVudCkpIDogUGFzc093blB0cjxNZWRpYVN0cmVh bUNvbnRyb2xsZXI+KCkpCi0jZW5kaWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNIKQogICAgICwg bV9zcGVlY2hJbnB1dENsaWVudChwYWdlQ2xpZW50cy5zcGVlY2hJbnB1dENsaWVudCkKICNlbmRp ZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisgICAgLCBtX3VzZXJNZWRpYUNvbnRyb2xsZXIo YWRvcHRQdHIobmV3IFVzZXJNZWRpYUNvbnRyb2xsZXIodGhpcywgcGFnZUNsaWVudHMudXNlck1l ZGlhQ2xpZW50KSkpCisjZW5kaWYKICAgICAsIG1fc2V0dGluZ3MoYWRvcHRQdHIobmV3IFNldHRp bmdzKHRoaXMpKSkKICAgICAsIG1fcHJvZ3Jlc3MoYWRvcHRQdHIobmV3IFByb2dyZXNzVHJhY2tl cikpCiAgICAgLCBtX2JhY2tGb3J3YXJkQ29udHJvbGxlcihhZG9wdFB0cihuZXcgQmFja0Zvcndh cmRDb250cm9sbGVyKHRoaXMsIHBhZ2VDbGllbnRzLmJhY2tGb3J3YXJkQ2xpZW50KSkpCkBAIC0x MDQyLDcgKzEwNDEsNyBAQCBQYWdlOjpQYWdlQ2xpZW50czo6UGFnZUNsaWVudHMoKQogICAgICwg ZGV2aWNlTW90aW9uQ2xpZW50KDApCiAgICAgLCBkZXZpY2VPcmllbnRhdGlvbkNsaWVudCgwKQog ICAgICwgc3BlZWNoSW5wdXRDbGllbnQoMCkKLSAgICAsIG1lZGlhU3RyZWFtQ2xpZW50KDApCisg ICAgLCB1c2VyTWVkaWFDbGllbnQoMCkKIHsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGFnZS9QYWdlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaAppbmRleCAzZjMwY2Yz Li4xYTM0Nzc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaApAQCAtNzEsOCArNzEsNiBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgY2xhc3MgSW5zcGVjdG9yQ2xpZW50OwogICAgIGNsYXNzIEluc3BlY3RvckNv bnRyb2xsZXI7CiAgICAgY2xhc3MgTWVkaWFDYW5TdGFydExpc3RlbmVyOwotICAgIGNsYXNzIE1l ZGlhU3RyZWFtQ2xpZW50OwotICAgIGNsYXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlcjsKICAgICBj bGFzcyBOb2RlOwogICAgIGNsYXNzIFBhZ2VHcm91cDsKICAgICBjbGFzcyBQbHVnaW5EYXRhOwpA QCAtODQsNiArODIsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgU2V0dGluZ3M7 CiAgICAgY2xhc3MgU3BlZWNoSW5wdXQ7CiAgICAgY2xhc3MgU3BlZWNoSW5wdXRDbGllbnQ7Cisg ICAgY2xhc3MgVXNlck1lZGlhQ2xpZW50OworICAgIGNsYXNzIFVzZXJNZWRpYUNvbnRyb2xsZXI7 CiAgICAgY2xhc3MgU3RvcmFnZU5hbWVzcGFjZTsKICNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykK ICAgICBjbGFzcyBOb3RpZmljYXRpb25QcmVzZW50ZXI7CkBAIC0xMTgsNyArMTE4LDcgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAgICAgRGV2aWNlT3JpZW50YXRpb25DbGllbnQqIGRl dmljZU9yaWVudGF0aW9uQ2xpZW50OwogICAgICAgICAgICAgUmVmUHRyPEJhY2tGb3J3YXJkTGlz dD4gYmFja0ZvcndhcmRDbGllbnQ7CiAgICAgICAgICAgICBTcGVlY2hJbnB1dENsaWVudCogc3Bl ZWNoSW5wdXRDbGllbnQ7Ci0gICAgICAgICAgICBNZWRpYVN0cmVhbUNsaWVudCogbWVkaWFTdHJl YW1DbGllbnQ7CisgICAgICAgICAgICBVc2VyTWVkaWFDbGllbnQqIHVzZXJNZWRpYUNsaWVudDsK ICAgICAgICAgfTsKIAogICAgICAgICBQYWdlKFBhZ2VDbGllbnRzJik7CkBAIC0xODQsMTIgKzE4 NCwxMiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIERldmljZU1vdGlvbkNvbnRyb2xs ZXIqIGRldmljZU1vdGlvbkNvbnRyb2xsZXIoKSBjb25zdCB7IHJldHVybiBtX2RldmljZU1vdGlv bkNvbnRyb2xsZXIuZ2V0KCk7IH0KICAgICAgICAgRGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVy KiBkZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIoKSBjb25zdCB7IHJldHVybiBtX2RldmljZU9y aWVudGF0aW9uQ29udHJvbGxlci5nZXQoKTsgfQogI2VuZGlmCi0jaWYgRU5BQkxFKE1FRElBX1NU UkVBTSkKLSAgICAgICAgTWVkaWFTdHJlYW1Db250cm9sbGVyKiBtZWRpYVN0cmVhbUNvbnRyb2xs ZXIoKSBjb25zdCB7IHJldHVybiBtX21lZGlhU3RyZWFtQ29udHJvbGxlci5nZXQoKTsgfQotI2Vu ZGlmCiAjaWYgRU5BQkxFKElOUFVUX1NQRUVDSCkKICAgICAgICAgU3BlZWNoSW5wdXQqIHNwZWVj aElucHV0KCk7CiAjZW5kaWYKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorICAgICAgICBVc2Vy TWVkaWFDb250cm9sbGVyKiB1c2VyTWVkaWFDb250cm9sbGVyKCkgY29uc3QgeyByZXR1cm4gbV91 c2VyTWVkaWFDb250cm9sbGVyLmdldCgpOyB9CisjZW5kaWYKICAgICAgICAgU2V0dGluZ3MqIHNl dHRpbmdzKCkgY29uc3QgeyByZXR1cm4gbV9zZXR0aW5ncy5nZXQoKTsgfQogICAgICAgICBQcm9n cmVzc1RyYWNrZXIqIHByb2dyZXNzKCkgY29uc3QgeyByZXR1cm4gbV9wcm9ncmVzcy5nZXQoKTsg fQogICAgICAgICBCYWNrRm9yd2FyZENvbnRyb2xsZXIqIGJhY2tGb3J3YXJkKCkgY29uc3QgeyBy ZXR1cm4gbV9iYWNrRm9yd2FyZENvbnRyb2xsZXIuZ2V0KCk7IH0KQEAgLTM2NCwxMyArMzY0LDEz IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgT3duUHRyPERldmljZU1vdGlvbkNvbnRy b2xsZXI+IG1fZGV2aWNlTW90aW9uQ29udHJvbGxlcjsKICAgICAgICAgT3duUHRyPERldmljZU9y aWVudGF0aW9uQ29udHJvbGxlcj4gbV9kZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXI7CiAjZW5k aWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBPd25QdHI8TWVkaWFTdHJlYW1D b250cm9sbGVyPiBtX21lZGlhU3RyZWFtQ29udHJvbGxlcjsKLSNlbmRpZgogI2lmIEVOQUJMRShJ TlBVVF9TUEVFQ0gpCiAgICAgICAgIFNwZWVjaElucHV0Q2xpZW50KiBtX3NwZWVjaElucHV0Q2xp ZW50OwogICAgICAgICBPd25QdHI8U3BlZWNoSW5wdXQ+IG1fc3BlZWNoSW5wdXQ7CiAjZW5kaWYK KyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorICAgICAgICBPd25QdHI8VXNlck1lZGlhQ29udHJv bGxlcj4gbV91c2VyTWVkaWFDb250cm9sbGVyOworI2VuZGlmCiAgICAgICAgIE93blB0cjxTZXR0 aW5ncz4gbV9zZXR0aW5nczsKICAgICAgICAgT3duUHRyPFByb2dyZXNzVHJhY2tlcj4gbV9wcm9n cmVzczsKICAgICAgICAgCg== 114706 2011-11-11 08:44:01 -0800 2011-11-16 11:12:52 -0800 Patch 4 usermedia_simple_controller_4.patch text/plain 63234 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhNzM4YjJkLi4wM2Q5YjIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzAg QEAKKzIwMTEtMTEtMTEgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudC9jb250cm9sbGVyIGZvciB1 c2VyIGNvbnNlbnQgaW4gZ2V0VXNlck1lZGlhKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcwODk3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBvbmUgaW4gYSBzZXJpZXMgb2YgcGF0Y2hlcyB0 aGF0IHVwZGF0ZSB0aGUgTWVkaWFTdHJlYW0gZmVhdHVyZQorICAgICAgICB0byB1c2UgV2ViQ29y ZSBwbGF0Zm9ybSBpbnRlcmZhY2VzLgorCisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgdGVz dHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFdlYkNvcmUu Z3lwaToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oOiBSZW1vdmVk LgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHA6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmg6IFJlbW92 ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3Bw OiBSZW1vdmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyLmg6IFJlbW92ZWQuCisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50Lmg6 IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ2xpZW50Ojp+VXNlck1lZGlhQ2xp ZW50KToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpVc2VyTWVkaWFDb250 cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6On5Vc2VyTWVk aWFDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNvbnRyb2xsZXI6OnJl cXVlc3RVc2VyTWVkaWEpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6 Y2FuY2VsVXNlck1lZGlhUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250 cm9sbGVyOjpyZXF1ZXN0SXNWYWxpZCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFDb250 cm9sbGVyOjp1c2VyTWVkaWFSZXF1ZXN0U3VjY2VlZGVkKToKKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYUNvbnRyb2xsZXI6OnVzZXJNZWRpYVJlcXVlc3RGYWlsZWQpOgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6cXVlcnlVc2VyTWVkaWEpOgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUXVlcnlDb21wbGV0ZWQpOgorICAg ICAgICAqIG1lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpVc2VyTWVkaWFDb250cm9sbGVyOjpjbGllbnQpOgorICAgICAgICAqIG1lZGlh c3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1 ZXN0OjpVc2VyTWVkaWFSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6On5Vc2VyTWVkaWFSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVl c3Q6OnBhcnNlT3B0aW9ucyk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0Ojpm cmFtZURlc3Ryb3llZCk6CisgICAgICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5o OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmF1ZGlvKToKKyAg ICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnZpZGVvKToKKyAgICAgICAgKFdlYkNv cmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNhbWVyYVByZWZlcmVuY2VVc2VyKToKKyAgICAgICAgKFdl YkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCk6Cisg ICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpmcmFtZSk6CisgICAgICAgIChXZWJD b3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KToKKyAgICAgICAg KFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29y ZTo6VXNlck1lZGlhUmVxdWVzdDo6Y2xlYXJDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6 OlVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpV c2VyTWVkaWFSZXF1ZXN0OjplcnJvckNhbGxiYWNrKToKKyAgICAgICAgKiBwYWdlL0NhbGxiYWNr VGFzay5oOiBSZW1vdmVkLgorICAgICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RnJhbWU6OkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp+RnJhbWUpOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OnBhZ2VEZXN0cm95ZWQpOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWU6OnRyYW5zZmVyQ2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQpOgorICAgICAgICAqIHBh Z2UvRnJhbWUuaDoKKyAgICAgICAgKiBwYWdlL05hdmlnYXRvci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYSk6CisgICAgICAgICogcGFnZS9OYXZp Z2F0b3IuaDoKKyAgICAgICAgKiBwYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2su aDoKKyAgICAgICAgKiBwYWdlL1BhZ2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6UGFn ZSk6CisgICAgICAgIChXZWJDb3JlOjpQYWdlOjpQYWdlQ2xpZW50czo6UGFnZUNsaWVudHMpOgor ICAgICAgICAqIHBhZ2UvUGFnZS5oOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6dXNlck1lZGlh Q29udHJvbGxlcik6CisKIDIwMTEtMTEtMTEgIFl1cnkgU2VtaWtoYXRza3kgIDx5dXJ5c0BjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogW2Nocm9taXVtXSBsaXN0IGRlZGlj YXRlZCB3b3JrZXJzIGluIGNhc2UgaW5zcGVjdG9yIG9wZW5lZCBwb3N0LXdvcmtlciBjcmVhdGlv bi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3Vy Y2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IDdlOWRhZmYuLmEyODliM2YgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMjI3MiwxMyArMjI3Miw4IEBAIHdlYmNv cmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTG9jYWxNZWRpYVN0 cmVhbS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbS5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtLmggXAotCVNvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50LmggXAotCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHAgXAotCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9NZWRpYVN0cmVhbUV2ZW50LmNwcCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJl YW0vTWVkaWFTdHJlYW1FdmVudC5oIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlci5jcHAgXAotCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFt L01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL01lZGlhU3RyZWFtTGlzdC5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtTGlzdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVh bVJlZ2lzdHJ5LmNwcCBcCkBAIC0yMjkwLDYgKzIyODUsMTEgQEAgd2ViY29yZV9zb3VyY2VzICs9 IFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5jcHAgXAogCVNv dXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmggXAogCVNvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL1NpZ25hbGluZ0NhbGxiYWNrLmggXAorCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oIFwKKwlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcCBcCisJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0v VXNlck1lZGlhQ29udHJvbGxlci5oIFwKKwlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFSZXF1ZXN0LmNwcCBcCisJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlh UmVxdWVzdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9ub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNl bnRlci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ2Vu dGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ29udGVu dHMuaCBcCkBAIC0yMzEwLDcgKzIzMTAsNiBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJj ZS9XZWJDb3JlL3BhZ2UvQWRqdXN0Vmlld1NpemVPck5vdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9w YWdlL0JhckluZm8uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0JhckluZm8uaCBcCi0JU291 cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rhc2suaCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9D aHJvbWUuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZS5oIFwKIAlTb3VyY2UvV2Vi Q29yZS9wYWdlL0Nocm9tZUNsaWVudC5oIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBjNjFhY2RlLi42 OTYyOWY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0yODk5LDExICsyODk5LDYgQEAKICAgICAgICAg ICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbS5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUV2ZW50LmNwcCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1FdmVudC5oJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVu dC5oJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3Bw JywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCcsCi0g ICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwJywK LSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oJywK ICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuY3BwJywKICAgICAgICAg ICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuaCcsCiAgICAgICAgICAgICAnbWVkaWFz dHJlYW0vTWVkaWFTdHJlYW1UcmFjay5jcHAnLApAQCAtMjkxNSw2ICsyOTEwLDExIEBACiAgICAg ICAgICAgICAnbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uY3BwJywKICAgICAgICAgICAgICdt ZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9T aWduYWxpbmdDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdtZWRpYXN0cmVhbS9Vc2VyTWVkaWFD bGllbnQuaCcsCisgICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNlck1lZGlhQ29udHJvbGxlci5j cHAnLAorICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaCcsCisg ICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAnLAorICAgICAgICAg ICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaCcsCiAgICAgICAgICAgICAnbm90aWZp Y2F0aW9ucy9Ob3RpZmljYXRpb24uY3BwJywKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05v dGlmaWNhdGlvbi5oJywKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNl bnRlci5jcHAnLApAQCAtMjkyMiw3ICsyOTIyLDYgQEAKICAgICAgICAgICAgICdub3RpZmljYXRp b25zL05vdGlmaWNhdGlvbkNvbnRlbnRzLmgnLAogICAgICAgICAgICAgJ3BhZ2UvQmFySW5mby5j cHAnLAogICAgICAgICAgICAgJ3BhZ2UvQmFySW5mby5oJywKLSAgICAgICAgICAgICdwYWdlL0Nh bGxiYWNrVGFzay5oJywKICAgICAgICAgICAgICdwYWdlL0Nocm9tZS5jcHAnLAogICAgICAgICAg ICAgJ3BhZ2UvQ29uc29sZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvQ29udGVudFNlY3VyaXR5 UG9saWN5LmNwcCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbUNsaWVudC5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1D bGllbnQuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYWY5MDk1Yy4uMDAwMDAwMAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oCisrKyAv ZGV2L251bGwKQEAgLTEsNTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29n bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0g KiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU Ci0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2lmbmRlZiBNZWRpYVN0 cmVhbUNsaWVudF9oCi0jZGVmaW5lIE1lZGlhU3RyZWFtQ2xpZW50X2gKLQotI2lmIEVOQUJMRShN RURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotCi1uYW1lc3BhY2UgV2Vi Q29yZSB7Ci0KLWNsYXNzIFNlY3VyaXR5T3JpZ2luOwotCi1lbnVtIEdlbmVyYXRlU3RyZWFtT3B0 aW9uRmxhZyB7Ci0gICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0QXVkaW8gPSAxLAotICAgIEdlbmVy YXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nVXNlciA9IDEgPDwgMSwKLSAgICBHZW5lcmF0ZVN0 cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ0Vudmlyb25tZW50ID0gMSA8PCAyLAotfTsKLQotdHlwZWRl ZiB1bnNpZ25lZCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzOwotCi1jbGFzcyBNZWRpYVN0cmVh bUNsaWVudCB7Ci1wdWJsaWM6Ci0gICAgLy8gTWVkaWFTdHJlYW0gZnVuY3Rpb25zLgotICAgIHZp cnR1YWwgdm9pZCBtZWRpYVN0cmVhbURlc3Ryb3llZCgpID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQg Z2VuZXJhdGVTdHJlYW0oaW50IHJlcXVlc3RJZCwgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncywg UGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4pID0gMDsKLQotcHJvdGVjdGVkOgotICAgIHZpcnR1 YWwgfk1lZGlhU3RyZWFtQ2xpZW50KCkgeyB9Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3Jl Ci0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jZW5kaWYgLy8gTWVkaWFTdHJl YW1DbGllbnRfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3Ry ZWFtQ29udHJvbGxlci5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ0ZTMwOGUu LjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250 cm9sbGVyLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDEyMyArMCwwIEBACi0vKgotICogQ29weXJp Z2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAq IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgot ICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwot Ci0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgi Ci0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0 Zi9WZWN0b3IuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVhbUNv bnRyb2xsZXI6OlJlcXVlc3QgewotcHVibGljOgotICAgIFJlcXVlc3QoKQotICAgICAgICA6IG1f bG9jYWxJZCgwKQotICAgICAgICAsIG1fZnJhbWVDb250cm9sbGVyKDApIHsgfQotCi0gICAgUmVx dWVzdChpbnQgbG9jYWxJZCwgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJv bGxlcikKLSAgICAgICAgOiBtX2xvY2FsSWQobG9jYWxJZCkKLSAgICAgICAgLCBtX2ZyYW1lQ29u dHJvbGxlcihmcmFtZUNvbnRyb2xsZXIpIHsgfQotCi0gICAgaW50IGxvY2FsSWQoKSBjb25zdCB7 IHJldHVybiBtX2xvY2FsSWQ7IH0KLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJh bWVDb250cm9sbGVyKCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZUNvbnRyb2xsZXI7IH0KLQotcHJp dmF0ZToKLSAgICBpbnQgbV9sb2NhbElkOwotICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy KiBtX2ZyYW1lQ29udHJvbGxlcjsKLX07Ci0KLU1lZGlhU3RyZWFtQ29udHJvbGxlcjo6TWVkaWFT dHJlYW1Db250cm9sbGVyKE1lZGlhU3RyZWFtQ2xpZW50KiBjbGllbnQpCi0gICAgOiBtX2NsaWVu dChjbGllbnQpCi0gICAgLCBtX25leHRHbG9iYWxSZXF1ZXN0SWQoMSkKLXsKLX0KLQotTWVkaWFT dHJlYW1Db250cm9sbGVyOjp+TWVkaWFTdHJlYW1Db250cm9sbGVyKCkKLXsKLSAgICBpZiAobV9j bGllbnQpCi0gICAgICAgIG1fY2xpZW50LT5tZWRpYVN0cmVhbURlc3Ryb3llZCgpOwotfQotCi1i b29sIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6aXNDbGllbnRBdmFpbGFibGUoKSBjb25zdAotewot ICAgIHJldHVybiBtX2NsaWVudDsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnVu cmVnaXN0ZXJGcmFtZUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1l Q29udHJvbGxlcikKLXsKLSAgICBBU1NFUlQoZnJhbWVDb250cm9sbGVyKTsKLQotICAgIC8vIERv bmUgaW4gdHdvIHN0ZXBzIHRvIGF2b2lkIHByb2JsZW1zIGFib3V0IGl0ZXJhdG9ycyBiZWluZyBp bnZhbGlkYXRlZCB3aGlsZSByZW1vdmluZy4KLSAgICBWZWN0b3I8aW50PiBmcmFtZVJlcXVlc3Rz OwotICAgIGZvciAoUmVxdWVzdE1hcDo6aXRlcmF0b3IgaXQgPSBtX3JlcXVlc3RzLmJlZ2luKCk7 IGl0ICE9IG1fcmVxdWVzdHMuZW5kKCk7ICsraXQpCi0gICAgICAgIGlmIChpdC0+c2Vjb25kLmZy YW1lQ29udHJvbGxlcigpID09IGZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgICAgIGZyYW1lUmVx dWVzdHMuYXBwZW5kKGl0LT5maXJzdCk7Ci0KLSAgICBmb3IgKFZlY3RvcjxpbnQ+OjppdGVyYXRv ciBpdCA9IGZyYW1lUmVxdWVzdHMuYmVnaW4oKTsgaXQgIT0gZnJhbWVSZXF1ZXN0cy5lbmQoKTsg KytpdCkKLSAgICAgICAgbV9yZXF1ZXN0cy5yZW1vdmUoKml0KTsKLX0KLQotaW50IE1lZGlhU3Ry ZWFtQ29udHJvbGxlcjo6cmVnaXN0ZXJSZXF1ZXN0KGludCBsb2NhbElkLCBNZWRpYVN0cmVhbUZy YW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKQotewotICAgIEFTU0VSVChsb2NhbElkID4g MCk7Ci0gICAgQVNTRVJUKGZyYW1lQ29udHJvbGxlcik7Ci0gICAgbV9yZXF1ZXN0cy5hZGQobV9u ZXh0R2xvYmFsUmVxdWVzdElkLCBSZXF1ZXN0KGxvY2FsSWQsIGZyYW1lQ29udHJvbGxlcikpOwot ICAgIHJldHVybiBtX25leHRHbG9iYWxSZXF1ZXN0SWQrKzsKLX0KLQotdm9pZCBNZWRpYVN0cmVh bUNvbnRyb2xsZXI6OmdlbmVyYXRlU3RyZWFtKE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBm cmFtZUNvbnRyb2xsZXIsIGludCBsb2NhbElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZs YWdzLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKLXsKLSAgICBB U1NFUlQobV9jbGllbnQpOwotICAgIGludCBjb250cm9sbGVyUmVxdWVzdElkID0gcmVnaXN0ZXJS ZXF1ZXN0KGxvY2FsSWQsIGZyYW1lQ29udHJvbGxlcik7Ci0gICAgbV9jbGllbnQtPmdlbmVyYXRl U3RyZWFtKGNvbnRyb2xsZXJSZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0eU9yaWdpbik7Ci19Ci0K LXZvaWQgTWVkaWFTdHJlYW1Db250cm9sbGVyOjpzdHJlYW1HZW5lcmF0ZWQoaW50IGNvbnRyb2xs ZXJSZXF1ZXN0SWQsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewot ICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgZnJhbWUgY29udHJvbGxlciBjYW4gaGF2ZSBi ZWVuIGRlc3Ryb3llZCB3aGlsZSB0aGUgcmVxdWVzdCByZXBseSB3YXMgY29taW5nIGJhY2suCi0g ICAgaWYgKG1fcmVxdWVzdHMuY29udGFpbnMoY29udHJvbGxlclJlcXVlc3RJZCkpIHsKLSAgICAg ICAgY29uc3QgUmVxdWVzdCYgcmVxdWVzdCA9IG1fcmVxdWVzdHMuZ2V0KGNvbnRyb2xsZXJSZXF1 ZXN0SWQpOwotICAgICAgICBtX3JlcXVlc3RzLnJlbW92ZShjb250cm9sbGVyUmVxdWVzdElkKTsK LSAgICAgICAgQVNTRVJUKHJlcXVlc3QuZnJhbWVDb250cm9sbGVyKCkpOwotICAgICAgICByZXF1 ZXN0LmZyYW1lQ29udHJvbGxlcigpLT5zdHJlYW1HZW5lcmF0ZWQocmVxdWVzdC5sb2NhbElkKCks IHNvdXJjZXMpOwotICAgIH0KLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnN0cmVh bUdlbmVyYXRpb25GYWlsZWQoaW50IGNvbnRyb2xsZXJSZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yOjpFcnJvckNvZGUgY29kZSkKLXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2Ug dGhlIGZyYW1lIGNvbnRyb2xsZXIgY2FuIGhhdmUgYmVlbiBkZXN0cm95ZWQgd2hpbGUgdGhlIHJl cXVlc3QgcmVwbHkgd2FzIGNvbWluZyBiYWNrLgotICAgIGlmIChtX3JlcXVlc3RzLmNvbnRhaW5z KGNvbnRyb2xsZXJSZXF1ZXN0SWQpKSB7Ci0gICAgICAgIGNvbnN0IFJlcXVlc3QmIHJlcXVlc3Qg PSBtX3JlcXVlc3RzLmdldChjb250cm9sbGVyUmVxdWVzdElkKTsKLSAgICAgICAgbV9yZXF1ZXN0 cy5yZW1vdmUoY29udHJvbGxlclJlcXVlc3RJZCk7Ci0gICAgICAgIHJlcXVlc3QuZnJhbWVDb250 cm9sbGVyKCktPnN0cmVhbUdlbmVyYXRpb25GYWlsZWQocmVxdWVzdC5sb2NhbElkKCksIGNvZGUp OwotICAgIH0KLX0KLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxF KE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1Db250cm9sbGVyLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4OTMwOTQu LjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250 cm9sbGVyLmgKKysrIC9kZXYvbnVsbApAQCAtMSw3NCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0 IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu Ci0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K LSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBD T05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICog QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0j aWZuZGVmIE1lZGlhU3RyZWFtQ29udHJvbGxlcl9oCi0jZGVmaW5lIE1lZGlhU3RyZWFtQ29udHJv bGxlcl9oCi0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJl YW1DbGllbnQuaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVhbVNvdXJjZS5oIgotI2luY2x1ZGUgIk5h dmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNs dWRlIDx3dGYvSGFzaE1hcC5oPgotI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgotI2luY2x1 ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFz cyBNZWRpYVN0cmVhbUNsaWVudDsKLWNsYXNzIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOwot Y2xhc3MgU2VjdXJpdHlPcmlnaW47Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlciB7Ci0g ICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWVkaWFTdHJlYW1Db250cm9sbGVyKTsKLXB1YmxpYzoK LSAgICBNZWRpYVN0cmVhbUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1DbGllbnQqKTsKLSAgICB2aXJ0 dWFsIH5NZWRpYVN0cmVhbUNvbnRyb2xsZXIoKTsKLQotICAgIGJvb2wgaXNDbGllbnRBdmFpbGFi bGUoKSBjb25zdDsKLSAgICB2b2lkIHVucmVnaXN0ZXJGcmFtZUNvbnRyb2xsZXIoTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIqKTsKLQotICAgIHZvaWQgZ2VuZXJhdGVTdHJlYW0oTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIqLCBpbnQgcmVxdWVzdElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZs YWdzLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPik7Ci0KLSAgICB2b2lkIHN0cmVhbUdlbmVy YXRlZChpbnQgcmVxdWVzdElkLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNl cyk7Ci0gICAgdm9pZCBzdHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmln YXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUpOwotCi1wcml2YXRlOgotICAgIGludCByZWdp c3RlclJlcXVlc3QoaW50IGxvY2FsUmVxdWVzdElkLCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ciopOwotCi0gICAgY2xhc3MgUmVxdWVzdDsKLSAgICB0eXBlZGVmIEhhc2hNYXA8aW50LCBSZXF1 ZXN0PiBSZXF1ZXN0TWFwOwotCi0gICAgUmVxdWVzdE1hcCBtX3JlcXVlc3RzOwotCi0gICAgTWVk aWFTdHJlYW1DbGllbnQqIG1fY2xpZW50OwotICAgIGludCBtX25leHRHbG9iYWxSZXF1ZXN0SWQ7 Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFf U1RSRUFNKQotCi0jZW5kaWYgLy8gTWVkaWFTdHJlYW1Db250cm9sbGVyX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy LmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZGM3NTdlNC4uMDAwMDAwMAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5j cHAKKysrIC9kZXYvbnVsbApAQCAtMSwyODMgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykg MjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAot ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICog Mi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgot ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFCi0gKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0g KiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2luY2x1 ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgiCi0K LSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiRE9NV2luZG93LmgiCi0jaW5j bHVkZSAiRG9jdW1lbnQuaCIKLSNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAi RnJhbWUuaCIKLSNpbmNsdWRlICJMb2NhbE1lZGlhU3RyZWFtLmgiCi0jaW5jbHVkZSAiTWVkaWFT dHJlYW1Db250cm9sbGVyLmgiCi0jaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxs YmFjay5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgot I2luY2x1ZGUgIlBhZ2UuaCIKLSNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUg PHd0Zi9SZWZDb3VudGVkLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgTWVkaWFT dHJlYW1GcmFtZUNvbnRyb2xsZXI6OlJlcXVlc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXF1ZXN0 PiB7Ci0gICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgdmly dHVhbCB+UmVxdWVzdCgpIHsgfQotCi0gICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0 RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4 dDsgfQotICAgIHZpcnR1YWwgYm9vbCBpc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIGNvbnN0IHsg cmV0dXJuIGZhbHNlOyB9Ci0KLSAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKSA9IDA7Ci0KLXByb3Rl Y3RlZDoKLSAgICBSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQpCi0gICAgICAgIDogbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0KHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQpIHsgfQotCi1wcml2YXRlOgotICAgIC8vIFRoaXMgaXMgZ3VhcmFudGVlZCB0 byBoYXZlIHRoZSBsaWZldGltZSBvZiB0aGUgRnJhbWUsIGFuZCBpdCdzIG9ubHkgdXNlZCB0byBt YWtlCi0gICAgLy8gdGhlIGNhbGxiYWNrIGFzeW5jaHJvbm91cy4gVGhlIG9yaWdpbmFsIGNhbGxi YWNrIGNvbnRleHQgaXMgdXNlZCBpbiB0aGUgY2FsbC4KLSAgICBTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7Ci19OwotCi1jbGFzcyBNZWRpYVN0cmVhbUZy YW1lQ29udHJvbGxlcjo6R2VuZXJhdGVTdHJlYW1SZXF1ZXN0IDogcHVibGljIFJlcXVlc3Qgewot ICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKEdlbmVyYXRlU3RyZWFtUmVxdWVzdCk7Ci1wdWJsaWM6 Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8R2VuZXJhdGVTdHJlYW1SZXF1ZXN0PiBjcmVhdGUoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmln YXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2 aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKLSAgICB7Ci0gICAg ICAgIHJldHVybiBhZG9wdFJlZihuZXcgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOwotICAgIH0KLQot ICAgIHZpcnR1YWwgfkdlbmVyYXRlU3RyZWFtUmVxdWVzdCgpIHsgfQotCi0gICAgdmlydHVhbCBi b29sIGlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQotCi0g ICAgdmlydHVhbCB2b2lkIGFib3J0KCkKLSAgICB7Ci0gICAgICAgIGlmIChtX2Vycm9yQ2FsbGJh Y2spIHsKLSAgICAgICAgICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3Ig PSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRvclVzZXJNZWRpYUVycm9y OjpQRVJNSVNTSU9OX0RFTklFRCk7Ci0gICAgICAgICAgICAvLyBUaGUgY2FsbGJhY2sgaXRzZWxm IGlzIG1hZGUgd2l0aCB0aGUgSlMgY2FsbGJhY2sncyBjb250ZXh0LCBub3Qgd2l0aCB0aGUgZnJh bWUncyBjb250ZXh0LgotICAgICAgICAgICAgbV9lcnJvckNhbGxiYWNrLT5zY2hlZHVsZUNhbGxi YWNrKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgZXJyb3IpOwotICAgICAgICB9Ci0gICAgfQot Ci0gICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nl c3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fc3VjY2Vzc0NhbGxiYWNrOyB9Ci0gICAgUGFz c1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKCkg Y29uc3QgeyByZXR1cm4gbV9lcnJvckNhbGxiYWNrOyB9Ci0KLXByaXZhdGU6Ci0gICAgR2VuZXJh dGVTdHJlYW1SZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNv bnRleHQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNl ck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAg ICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJy b3JDYWxsYmFjaykKLSAgICAgICAgOiBSZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0g ICAgICAgICwgbV9zdWNjZXNzQ2FsbGJhY2soc3VjY2Vzc0NhbGxiYWNrKQotICAgICAgICAsIG1f ZXJyb3JDYWxsYmFjayhlcnJvckNhbGxiYWNrKSB7IH0KLQotICAgIFJlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IG1fc3VjY2Vzc0NhbGxiYWNrOwotICAgIFJlZlB0cjxO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBtX2Vycm9yQ2FsbGJhY2s7Ci19OwotCi12 b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydChpbnQgcmVx dWVzdElkKQotewotICAgIGdldChyZXF1ZXN0SWQpLT5hYm9ydCgpOwotICAgIHJlbW92ZShyZXF1 ZXN0SWQpOwotfQotCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFw OjphYm9ydEFsbCgpCi17Ci0gICAgd2hpbGUgKCFpc0VtcHR5KCkpIHsKLSAgICAgICAgYmVnaW4o KS0+c2Vjb25kLT5hYm9ydCgpOwotICAgICAgICByZW1vdmUoYmVnaW4oKSk7Ci0gICAgfQotfQot Ci1NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIo RnJhbWUqIGZyYW1lKQotICAgIDogbV9mcmFtZShmcmFtZSkKLSAgICAsIG1faXNJbkRldGFjaGVk U3RhdGUoZmFsc2UpCi17Ci0gICAgaWYgKCFpc0NsaWVudEF2YWlsYWJsZSgpKQotICAgICAgICBl bnRlckRldGFjaGVkU3RhdGUoKTsKLX0KLQotTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6On5N ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigpCi17Ci19Ci0KLVNlY3VyaXR5T3JpZ2luKiBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c2VjdXJpdHlPcmlnaW4oKSBjb25zdAotewotICAgIHJl dHVybiBtX2ZyYW1lID8gbV9mcmFtZS0+ZXhpc3RpbmdET01XaW5kb3coKS0+c2VjdXJpdHlPcmln aW4oKSA6IDA7Ci19Ci0KLVNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIE1lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyOjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgY29uc3QKLXsKLSAgICByZXR1cm4g bV9mcmFtZSA/IG1fZnJhbWUtPmV4aXN0aW5nRE9NV2luZG93KCktPnNjcmlwdEV4ZWN1dGlvbkNv bnRleHQoKSA6IDA7Ci19Ci0KLU1lZGlhU3RyZWFtQ29udHJvbGxlciogTWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXI6OnBhZ2VDb250cm9sbGVyKCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFt ZSAmJiBtX2ZyYW1lLT5wYWdlKCkgPyBtX2ZyYW1lLT5wYWdlKCktPm1lZGlhU3RyZWFtQ29udHJv bGxlcigpIDogMDsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZW50ZXJE ZXRhY2hlZFN0YXRlKCkKLXsKLSAgICBpZiAobV9pc0luRGV0YWNoZWRTdGF0ZSkgewotICAgICAg ICBBU1NFUlQobV9yZXF1ZXN0cy5pc0VtcHR5KCkpOwotICAgICAgICByZXR1cm47Ci0gICAgfQot Ci0gICAgbV9yZXF1ZXN0cy5hYm9ydEFsbCgpOwotICAgIG1faXNJbkRldGFjaGVkU3RhdGUgPSB0 cnVlOwotfQotCi1ib29sIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjppc0NsaWVudEF2YWls YWJsZSgpIGNvbnN0Ci17Ci0gICAgaWYgKG1faXNJbkRldGFjaGVkU3RhdGUpCi0gICAgICAgIHJl dHVybiBmYWxzZTsKLQotICAgIE1lZGlhU3RyZWFtQ29udHJvbGxlciogY29udHJvbGxlciA9IHBh Z2VDb250cm9sbGVyKCk7Ci0gICAgcmV0dXJuIGNvbnRyb2xsZXIgJiYgY29udHJvbGxlci0+aXND bGllbnRBdmFpbGFibGUoKTsKLX0KLQotLy8gQ2FsbGVkIGFsc28gd2hlbiB0aGUgZnJhbWUgaXMg ZGV0YWNoZWQgZnJvbSB0aGUgcGFnZSwgaW4gd2hpY2ggY2FzZSB0aGUgcGFnZSBjb250cm9sbGVy IHdpbGwgcmVtYWluIGFsaXZlLgotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZGlz Y29ubmVjdFBhZ2UoKQotewotICAgIGlmIChwYWdlQ29udHJvbGxlcigpKQotICAgICAgICBwYWdl Q29udHJvbGxlcigpLT51bnJlZ2lzdGVyRnJhbWVDb250cm9sbGVyKHRoaXMpOwotCi0gICAgZW50 ZXJEZXRhY2hlZFN0YXRlKCk7Ci19Ci0KLS8vIENhbGxlZCB3aGVuIHRoZSBmcmFtZSBpcyBiZWlu ZyBkZXN0cm95ZWQuIFNpbmNlIHRoZSBmcmFtZSBjb250cm9sbGVyIGlzIG93bmVkIGJ5IHRoZSBm cmFtZSBpdCB3aWxsIGRpZSBzaG9ydGx5IGFmdGVyIHRoaXMuCi12b2lkIE1lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyOjpkaXNjb25uZWN0RnJhbWUoKQotewotICAgIGRpc2Nvbm5lY3RQYWdlKCk7 Ci0KLSAgICBBU1NFUlQobV9yZXF1ZXN0cy5pc0VtcHR5KCkpOwotCi0gICAgbV9mcmFtZSA9IDA7 Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnRyYW5zZmVyVG9OZXdQYWdl KFBhZ2UqKQotewotICAgIC8vIEZJWE1FOiBJbiB0aGUgZnV0dXJlIHdlIHNob3VsZCBrZWVwIHJ1 bm5pbmcgdGhlIG1lZGlhIHN0cmVhbSBzZXJ2aWNlcyB3aGlsZSB0cmFuc2ZlcmluZyBmcmFtZXMg YmV0d2VlbiBwYWdlcy4KLSAgICAvLyBIb3dldmVyLCB1bnRpbCBhIHByb3BlciB3YXkgdG8gZG8g dGhpcyBpcyBkZWNpZGVkLCB3ZSdyZSBzaHV0dGluZyBkb3duIHNlcnZpY2VzLgotICAgIGRpc2Nv bm5lY3RQYWdlKCk7Ci19Ci0KLUdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXI6OnBhcnNlR2VuZXJhdGVTdHJlYW1PcHRpb25zKGNvbnN0IFN0cmluZyYg b3B0aW9ucykKLXsKLSAgICBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzID0gMDsKLSAg ICBWZWN0b3I8U3RyaW5nPiBvcHRpb25MaXN0OwotICAgIG9wdGlvbnMuc3BsaXQoJywnLCBvcHRp b25MaXN0KTsKLQotICAgIGZvciAoVmVjdG9yPFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIG9wdGlv biA9IG9wdGlvbkxpc3QuYmVnaW4oKTsgb3B0aW9uICE9IG9wdGlvbkxpc3QuZW5kKCk7ICsrb3B0 aW9uKSB7Ci0gICAgICAgIFZlY3RvcjxTdHJpbmc+IHN1Ym9wdGlvbkxpc3Q7Ci0gICAgICAgIG9w dGlvbi0+c3BsaXQoJyAnLCBzdWJvcHRpb25MaXN0KTsKLQotICAgICAgICBpZiAoc3Vib3B0aW9u TGlzdC5maXJzdCgpID09ICJhdWRpbyIpCi0gICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0 cmVhbVJlcXVlc3RBdWRpbzsKLSAgICAgICAgZWxzZSBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgp ID09ICJ2aWRlbyIpIHsKLSAgICAgICAgICAgIGJvb2wgdmlkZW9TdWJvcHRpb25zID0gZmFsc2U7 Ci0gICAgICAgICAgICBWZWN0b3I8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3Igc3Vib3B0aW9uID0g c3Vib3B0aW9uTGlzdC5iZWdpbigpOwotICAgICAgICAgICAgZm9yICgrK3N1Ym9wdGlvbjsgc3Vi b3B0aW9uICE9IHN1Ym9wdGlvbkxpc3QuZW5kKCk7ICsrc3Vib3B0aW9uKQotICAgICAgICAgICAg ICAgIGlmICgqc3Vib3B0aW9uID09ICJ1c2VyIikgewotICAgICAgICAgICAgICAgICAgICBmbGFn cyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ1VzZXI7Ci0gICAgICAgICAgICAg ICAgICAgIHZpZGVvU3Vib3B0aW9ucyA9IHRydWU7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIGlm ICgqc3Vib3B0aW9uID09ICJlbnZpcm9ubWVudCIpIHsKLSAgICAgICAgICAgICAgICAgICAgZmxh Z3MgfD0gR2VuZXJhdGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdFbnZpcm9ubWVudDsKLSAgICAg ICAgICAgICAgICAgICAgdmlkZW9TdWJvcHRpb25zID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICB9 Ci0KLSAgICAgICAgICAgIC8vIEFzayBmb3IgYWxsIGtpbmQgb2YgY2FtZXJhcyBpZiBubyBzdWJv cHRpb24gd2FzIHNwZWNpZmllZC4KLSAgICAgICAgICAgIGlmICghdmlkZW9TdWJvcHRpb25zKQot ICAgICAgICAgICAgICAgIGZsYWdzIHw9IEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5n VXNlciB8IEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nRW52aXJvbm1lbnQ7Ci0gICAg ICAgIH0KLSAgICB9Ci0KLSAgICByZXR1cm4gZmxhZ3M7Ci19Ci0KLS8vIEltcGxlbWVudHMgdGhl IGdldFVzZXJNZWRpYSBtZXRob2QgZnJvbSBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2Vi LWFwcHMvY3VycmVudC13b3JrLyNkb20tbmF2aWdhdG9yLWdldHVzZXJtZWRpYS4KLXZvaWQgTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OmdlbmVyYXRlU3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0 aW9ucywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBh c3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJh Y2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNz UmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFeGNlcHRpb25D b2RlJiBlYykKLXsKLSAgICBlYyA9IDA7Ci0gICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2spCi0gICAg ICAgIHJldHVybjsKLQotICAgIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MgPSBwYXJz ZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhvcHRpb25zKTsKLSAgICBpZiAoIWZsYWdzKSB7Ci0gICAg ICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAg ICBpbnQgcmVxdWVzdElkID0gbV9yZXF1ZXN0cy5nZXROZXh0SWQoKTsKLSAgICBtX3JlcXVlc3Rz LmFkZChyZXF1ZXN0SWQsIEdlbmVyYXRlU3RyZWFtUmVxdWVzdDo6Y3JlYXRlKHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQoKSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKSk7Ci0KLSAgICBp ZiAoIWlzQ2xpZW50QXZhaWxhYmxlKCkpIHsKLSAgICAgICAgLy8gVGhpcyBtYWtlcyBzdXJlIHRv IGNhbGwgdGhlIGVycm9yIGNhbGxiYWNrIGlmIHByb3ZpZGVkLgotICAgICAgICBtX3JlcXVlc3Rz LmFib3J0KHJlcXVlc3RJZCk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBwYWdlQ29u dHJvbGxlcigpLT5nZW5lcmF0ZVN0cmVhbSh0aGlzLCByZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0 eU9yaWdpbigpKTsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c3RyZWFt R2VuZXJhdGVkKGludCByZXF1ZXN0SWQsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBz b3VyY2VzKQotewotICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgcmVxdWVzdCBjYW4gaGF2 ZSBiZWVuIGFib3J0ZWQgYXMgYSByZXN1bHQgb2YgZW1iZWRkZXIgZGV0YWNobWVudC4KLSAgICBp ZiAoIW1fcmVxdWVzdHMuY29udGFpbnMocmVxdWVzdElkKSkKLSAgICAgICAgcmV0dXJuOwotCi0g ICAgQVNTRVJUKG1fcmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCktPmlzR2VuZXJhdGVTdHJlYW1SZXF1 ZXN0KCkpOwotCi0gICAgUmVmUHRyPEdlbmVyYXRlU3RyZWFtUmVxdWVzdD4gc3RyZWFtUmVxdWVz dCA9IHN0YXRpY19jYXN0PEdlbmVyYXRlU3RyZWFtUmVxdWVzdCo+KG1fcmVxdWVzdHMuZ2V0KHJl cXVlc3RJZCkuZ2V0KCkpOwotICAgIFJlZlB0cjxMb2NhbE1lZGlhU3RyZWFtPiBnZW5lcmF0ZWRT dHJlYW0gPSBMb2NhbE1lZGlhU3RyZWFtOjpjcmVhdGUoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgp LCBzb3VyY2VzKTsKLSAgICBtX3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotICAgIHN0cmVh bVJlcXVlc3QtPnN1Y2Nlc3NDYWxsYmFjaygpLT5oYW5kbGVFdmVudChnZW5lcmF0ZWRTdHJlYW0u Z2V0KCkpOwotfQotCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpzdHJlYW1HZW5l cmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJv ckNvZGUgY29kZSkKLXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIHJlcXVlc3QgY2Fu IGhhdmUgYmVlbiBhYm9ydGVkIGFzIGEgcmVzdWx0IG9mIGVtYmVkZGVyIGRldGFjaG1lbnQuCi0g ICAgaWYgKCFtX3JlcXVlc3RzLmNvbnRhaW5zKHJlcXVlc3RJZCkpCi0gICAgICAgIHJldHVybjsK LQotICAgIEFTU0VSVChtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQpLT5pc0dlbmVyYXRlU3RyZWFt UmVxdWVzdCgpKTsKLQotICAgIFJlZlB0cjxHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IHN0cmVhbVJl cXVlc3QgPSBzdGF0aWNfY2FzdDxHZW5lcmF0ZVN0cmVhbVJlcXVlc3QqPihtX3JlcXVlc3RzLmdl dChyZXF1ZXN0SWQpLmdldCgpKTsKLSAgICBtX3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwot Ci0gICAgaWYgKHN0cmVhbVJlcXVlc3QtPmVycm9yQ2FsbGJhY2soKSkgewotICAgICAgICBSZWZQ dHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJy b3I6OmNyZWF0ZShjb2RlKTsKLSAgICAgICAgc3RyZWFtUmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygp LT5oYW5kbGVFdmVudChlcnJvci5nZXQoKSk7Ci0gICAgfQotfQotCi19IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCBiL1Nv dXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgKZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhjMDkzYTMuLjAwMDAwMDAKLS0tIGEvU291cmNl L1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaAorKysgL2Rl di9udWxsCkBAIC0xLDEwNyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2ds ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAq IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK LSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyX2gKLSNkZWZpbmUgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXJf aAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ2xp ZW50LmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Tb3VyY2UuaCIKLSNpbmNsdWRlICJOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvci5oIgotI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0jaW5jbHVkZSA8 d3RmL0hhc2hNYXAuaD4KLSNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KLSNpbmNsdWRlIDx3 dGYvdGV4dC9TdHJpbmdIYXNoLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgRnJh bWU7Ci1jbGFzcyBNZWRpYVN0cmVhbUNvbnRyb2xsZXI7Ci1jbGFzcyBOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrOwotY2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNr OwotY2xhc3MgUGFnZTsKLWNsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7Ci1jbGFzcyBTZWN1 cml0eU9yaWdpbjsKLQotdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKLQotY2xhc3MgTWVkaWFT dHJlYW1GcmFtZUNvbnRyb2xsZXIgewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyKTsKLXB1YmxpYzoKLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlcihGcmFtZSopOwotICAgIHZpcnR1YWwgfk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKCk7 Ci0KLSAgICBTZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKLSAgICBTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgY29uc3Q7Ci0KLSAg ICBib29sIGlzQ2xpZW50QXZhaWxhYmxlKCkgY29uc3Q7Ci0gICAgdm9pZCBkaXNjb25uZWN0UGFn ZSgpOwotICAgIHZvaWQgZGlzY29ubmVjdEZyYW1lKCk7Ci0gICAgdm9pZCB0cmFuc2ZlclRvTmV3 UGFnZShQYWdlKik7Ci0KLSAgICBzdGF0aWMgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBwYXJz ZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhjb25zdCBTdHJpbmcmKTsKLSAgICB2b2lkIGdlbmVyYXRl U3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFTdWNjZXNzQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2Fs bGJhY2s+LCBFeGNlcHRpb25Db2RlJik7Ci0KLSAgICAvLyAtLS0gQ2FsbHMgY29taW5nIGJhY2sg ZnJvbSB0aGUgY29udHJvbGxlci4gLS0tIC8vCi0KLSAgICB2b2lkIHN0cmVhbUdlbmVyYXRlZChp bnQgcmVxdWVzdElkLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcyk7Ci0g ICAgdm9pZCBzdHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVz ZXJNZWRpYUVycm9yOjpFcnJvckNvZGUpOwotCi1wcml2YXRlOgotICAgIGNsYXNzIFJlcXVlc3Q7 Ci0gICAgY2xhc3MgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0OwotCi0gICAgY2xhc3MgSWRHZW5lcmF0 b3IgewotICAgICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShJZEdlbmVyYXRvcik7Ci0gICAgcHVi bGljOgotICAgICAgICBJZEdlbmVyYXRvcigpIDogbV9pZCgwKSB7IH0KLSAgICAgICAgaW50IGdl dE5leHRJZCgpIHsgcmV0dXJuICsrbV9pZDsgfQotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgaW50 IG1faWQ7Ci0gICAgfTsKLQotICAgIGNsYXNzIFJlcXVlc3RNYXAgOiBwdWJsaWMgSWRHZW5lcmF0 b3IsIHB1YmxpYyBIYXNoTWFwPGludCwgUmVmUHRyPFJlcXVlc3Q+ID4gewotICAgIHB1YmxpYzoK LSAgICAgICAgdm9pZCBhYm9ydChpbnQgcmVxdWVzdElkKTsKLSAgICAgICAgdm9pZCBhYm9ydEFs bCgpOwotICAgIH07Ci0KLSAgICAvLyBEZXRhY2hlZCBmcm9tIGEgcGFnZSwgYW5kIGhlbmNlIGZy b20gYSBlbWJlZGRlciBjbGllbnQuCi0gICAgdm9pZCBlbnRlckRldGFjaGVkU3RhdGUoKTsKLQot ICAgIE1lZGlhU3RyZWFtQ29udHJvbGxlciogcGFnZUNvbnRyb2xsZXIoKSBjb25zdDsKLQotICAg IFJlcXVlc3RNYXAgbV9yZXF1ZXN0czsKLQotICAgIEZyYW1lKiBtX2ZyYW1lOwotICAgIGJvb2wg bV9pc0luRGV0YWNoZWRTdGF0ZTsKLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2Vu ZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBNZWRpYVN0cmVhbUZyYW1l Q29udHJvbGxlcl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFDbGllbnQuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVu dC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjczOWI3MDAKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaApA QCAtMCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyCisgKiAgICBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisgKiAgICBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRo ZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0aGUgbmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICog ICAgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJv bSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgVXNlck1lZGlhQ2xpZW50X2gKKyNkZWZpbmUg VXNlck1lZGlhQ2xpZW50X2gKKworI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBVc2VyTWVkaWFDbGllbnQgeworcHVibGljOgor ICAgIHZpcnR1YWwgdm9pZCB1c2VyTWVkaWFDb250cm9sbGVyRGVzdHJveWVkKCkgPSAwOworCisg ICAgdmlydHVhbCB2b2lkIHJlcXVlc3RVc2VyTWVkaWEoVXNlck1lZGlhUmVxdWVzdCopID0gMDsK KyAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsVXNlck1lZGlhUmVxdWVzdChVc2VyTWVkaWFSZXF1ZXN0 KikgPSAwOworCisgICAgdmlydHVhbCB2b2lkIHVzZXJNZWRpYVF1ZXJ5Q29tcGxldGVkKFVzZXJN ZWRpYVJlcXVlc3QqLCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYpID0gMDsKKworcHJv dGVjdGVkOgorICAgIHZpcnR1YWwgflVzZXJNZWRpYUNsaWVudCgpIHsgfQorfTsKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2Vu ZGlmIC8vIFVzZXJNZWRpYUNsaWVudF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjY1MDRjMmMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0 cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmNwcApAQCAtMCwwICsxLDEzOCBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAgaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogICAg ZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhl IG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S UworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVS IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAq IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAi VXNlck1lZGlhQ29udHJvbGxlci5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkxvY2FsTWVkaWFTdHJlYW0uaCIKKyNpbmNsdWRlICJOYXZp Z2F0b3JVc2VyTWVkaWFFcnJvci5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNsaWVudC5oIgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK1VzZXJNZWRpYUNvbnRyb2xsZXI6OlVzZXJNZWRpYUNvbnRy b2xsZXIoUGFnZSogcGFnZSwgVXNlck1lZGlhQ2xpZW50KiBjbGllbnQpCisgICAgOiBtX3BhZ2Uo cGFnZSkKKyAgICAsIG1fY2xpZW50KGNsaWVudCkKK3sKK30KKworVXNlck1lZGlhQ29udHJvbGxl cjo6flVzZXJNZWRpYUNvbnRyb2xsZXIoKQoreworICAgIGlmIChtX2NsaWVudCkKKyAgICAgICAg bV9jbGllbnQtPnVzZXJNZWRpYUNvbnRyb2xsZXJEZXN0cm95ZWQoKTsKK30KKwordm9pZCBVc2Vy TWVkaWFDb250cm9sbGVyOjpyZXF1ZXN0VXNlck1lZGlhKFBhc3NSZWZQdHI8VXNlck1lZGlhUmVx dWVzdD4gcHJwUmVxdWVzdCkKK3sKKyAgICBpZiAoIW1fY2xpZW50KQorICAgICAgICByZXR1cm47 CisKKyAgICBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gcmVxdWVzdCA9IHBycFJlcXVlc3Q7CisK KyAgICBtX3JlcXVlc3RzLmFwcGVuZChyZXF1ZXN0KTsKKyAgICBtX2NsaWVudC0+cmVxdWVzdFVz ZXJNZWRpYShyZXF1ZXN0LmdldCgpKTsKK30KKwordm9pZCBVc2VyTWVkaWFDb250cm9sbGVyOjpj YW5jZWxVc2VyTWVkaWFSZXF1ZXN0KFVzZXJNZWRpYVJlcXVlc3QqIHJlcXVlc3QpCit7CisgICAg aWYgKCFtX2NsaWVudCkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9jbGllbnQtPmNhbmNlbFVz ZXJNZWRpYVJlcXVlc3QocmVxdWVzdCk7CisgICAgcmVxdWVzdC0+Y2xlYXJDb250cm9sbGVyKCk7 CisKKyAgICBzaXplX3QgaSA9IG1fcmVxdWVzdHMuZmluZChyZXF1ZXN0KTsKKyAgICBBU1NFUlQo aSAhPSBub3RGb3VuZCk7CisgICAgbV9yZXF1ZXN0cy5yZW1vdmUoaSk7Cit9CisKK2Jvb2wgVXNl ck1lZGlhQ29udHJvbGxlcjo6cmVxdWVzdElzVmFsaWQoVXNlck1lZGlhUmVxdWVzdCogcmVxdWVz dCkKK3sKKyAgICBBU1NFUlQobV9yZXF1ZXN0cy5jb250YWlucyhyZXF1ZXN0KSk7CisKKyAgICBp ZiAoIXJlcXVlc3QtPmZyYW1lKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQgPSByZXF1ZXN0LT5mcmFtZSgpLT5kb2N1bWVudCgp OworICAgIGlmICghY29udGV4dCB8fCBjb250ZXh0ICE9IHJlcXVlc3QtPnNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIHRydWU7Cit9 CisKK3ZvaWQgVXNlck1lZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUmVxdWVzdFN1Y2NlZWRlZChV c2VyTWVkaWFSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYg c291cmNlcykKK3sKKyAgICBpZiAoIXJlcXVlc3RJc1ZhbGlkKHJlcXVlc3QpKQorICAgICAgICBy ZXR1cm47CisKKyAgICBSZWZQdHI8TG9jYWxNZWRpYVN0cmVhbT4gc3RyZWFtID0gTG9jYWxNZWRp YVN0cmVhbTo6Y3JlYXRlKHJlcXVlc3QtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgc291cmNl cyk7CisgICAgcmVxdWVzdC0+c3VjY2Vzc0NhbGxiYWNrKCktPmhhbmRsZUV2ZW50KHN0cmVhbS5n ZXQoKSk7CisKKyAgICBzaXplX3QgaSA9IG1fcmVxdWVzdHMuZmluZChyZXF1ZXN0KTsKKyAgICBB U1NFUlQoaSAhPSBub3RGb3VuZCk7CisgICAgbV9yZXF1ZXN0cy5yZW1vdmUoaSk7Cit9CisKK3Zv aWQgVXNlck1lZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUmVxdWVzdEZhaWxlZChVc2VyTWVkaWFS ZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGlmICghcmVxdWVzdElzVmFsaWQocmVxdWVzdCkpCisg ICAgICAgIHJldHVybjsKKworICAgIGlmIChyZXF1ZXN0LT5lcnJvckNhbGxiYWNrKCkpIHsKKyAg ICAgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBlcnJvciA9IE5hdmlnYXRvclVz ZXJNZWRpYUVycm9yOjpjcmVhdGUoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OlBFUk1JU1NJT05f REVOSUVEKTsKKyAgICAgICAgcmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygpLT5oYW5kbGVFdmVudChl cnJvci5nZXQoKSk7CisgICAgfQorCisgICAgc2l6ZV90IGkgPSBtX3JlcXVlc3RzLmZpbmQocmVx dWVzdCk7CisgICAgQVNTRVJUKGkgIT0gbm90Rm91bmQpOworICAgIG1fcmVxdWVzdHMucmVtb3Zl KGkpOworfQorCit2b2lkIFVzZXJNZWRpYUNvbnRyb2xsZXI6OnF1ZXJ5VXNlck1lZGlhKFVzZXJN ZWRpYVJlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgQVNTRVJUKG1fcmVxdWVzdHMuY29udGFpbnMo cmVxdWVzdCkpOworCisgICAgLy8gRklYTUU6IHF1ZXJ5IHRoZSBwbGF0Zm9ybSBmb3IgYXZhaWxh YmxlIHVzZXIgbWVkaWEsIHNlZSBodHRwOi8vd2Via2l0Lm9yZy9iLzcwODk1Cit9CisKK3ZvaWQg VXNlck1lZGlhQ29udHJvbGxlcjo6dXNlck1lZGlhUXVlcnlDb21wbGV0ZWQoVXNlck1lZGlhUmVx dWVzdCogcmVxdWVzdCwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCit7 CisgICAgaWYgKG1fY2xpZW50KQorICAgICAgICBtX2NsaWVudC0+dXNlck1lZGlhUXVlcnlDb21w bGV0ZWQocmVxdWVzdCwgc291cmNlcyk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwor I2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9Vc2VyTWVkaWFDb250cm9sbGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uNmIzYzU5MQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL21lZGlh c3RyZWFtL1VzZXJNZWRpYUNvbnRyb2xsZXIuaApAQCAtMCwwICsxLDc2IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0aGUgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiAgICBk aXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0aGUg bmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBv ciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5k ZWYgVXNlck1lZGlhQ29udHJvbGxlcl9oCisjZGVmaW5lIFVzZXJNZWRpYUNvbnRyb2xsZXJfaAor CisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIk1lZGlhU3RyZWFtU291cmNl LmgiCisjaW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5oIgorI2luY2x1ZGUgPHd0Zi9WZWN0b3Iu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBGcmFtZTsKK2NsYXNzIFBhZ2U7Citj bGFzcyBVc2VyTWVkaWFDbGllbnQ7CisKK2NsYXNzIFVzZXJNZWRpYUNvbnRyb2xsZXIgeworICAg IFdURl9NQUtFX05PTkNPUFlBQkxFKFVzZXJNZWRpYUNvbnRyb2xsZXIpOworcHVibGljOgorICAg IFVzZXJNZWRpYUNvbnRyb2xsZXIoUGFnZSosIFVzZXJNZWRpYUNsaWVudCopOworICAgIH5Vc2Vy TWVkaWFDb250cm9sbGVyKCk7CisKKyAgICB2b2lkIHJlcXVlc3RVc2VyTWVkaWEoUGFzc1JlZlB0 cjxVc2VyTWVkaWFSZXF1ZXN0Pik7CisgICAgdm9pZCBjYW5jZWxVc2VyTWVkaWFSZXF1ZXN0KFVz ZXJNZWRpYVJlcXVlc3QqKTsKKworICAgIHZvaWQgdXNlck1lZGlhUmVxdWVzdFN1Y2NlZWRlZChV c2VyTWVkaWFSZXF1ZXN0KiwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImKTsKKyAgICB2 b2lkIHVzZXJNZWRpYVJlcXVlc3RGYWlsZWQoVXNlck1lZGlhUmVxdWVzdCopOworCisgICAgVXNl ck1lZGlhQ2xpZW50KiBjbGllbnQoKSBjb25zdCB7IHJldHVybiBtX2NsaWVudDsgfQorCisgICAg dm9pZCBxdWVyeVVzZXJNZWRpYShVc2VyTWVkaWFSZXF1ZXN0Kik7CisgICAgdm9pZCB1c2VyTWVk aWFRdWVyeUNvbXBsZXRlZChVc2VyTWVkaWFSZXF1ZXN0KiwgY29uc3QgTWVkaWFTdHJlYW1Tb3Vy Y2VWZWN0b3ImKTsKKworcHJpdmF0ZToKKyAgICBib29sIHJlcXVlc3RJc1ZhbGlkKFVzZXJNZWRp YVJlcXVlc3QqKTsKKworICAgIFBhZ2UqIG1fcGFnZTsKKyAgICBVc2VyTWVkaWFDbGllbnQqIG1f Y2xpZW50OworCisgICAgVmVjdG9yPFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiA+IG1fcmVxdWVz dHM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoTUVE SUFfU1RSRUFNKQorCisjZW5kaWYgLy8gVXNlck1lZGlhQ29udHJvbGxlcl9oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNhYjRjYTkKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcApAQCAtMCwwICsxLDEwNSBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisg KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogICAg aW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZQorICogICAgZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBFcmlj c3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBiZSB1c2Vk IHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcworICogICAg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQor CisjaW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIK KyNpbmNsdWRlICJQYWdlLmgiCisjaW5jbHVkZSAiU3BhY2VTcGxpdFN0cmluZy5oIgorI2luY2x1 ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNz UmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShGcmFtZSog ZnJhbWUsIGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQoreworICAgIFJlZlB0cjxVc2Vy TWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gYWRvcHRSZWYobmV3IFVzZXJNZWRpYVJlcXVlc3QoZnJh bWUsIG9wdGlvbnMsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOworICAgIGlmICgh cmVxdWVzdC0+YXVkaW8oKSAmJiAhcmVxdWVzdC0+dmlkZW8oKSkKKyAgICAgICAgcmV0dXJuIDA7 CisKKyAgICByZXR1cm4gcmVxdWVzdC5yZWxlYXNlKCk7Cit9CisKK1VzZXJNZWRpYVJlcXVlc3Q6 OlVzZXJNZWRpYVJlcXVlc3QoRnJhbWUqIGZyYW1lLCBjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBh c3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJh Y2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxs YmFjaykKKyAgICA6IG1fYXVkaW8oZmFsc2UpCisgICAgLCBtX3ZpZGVvKGZhbHNlKQorICAgICwg bV9jYW1lcmFQcmVmZXJlbmNlVXNlcihmYWxzZSkKKyAgICAsIG1fY2FtZXJhUHJlZmVyZW5jZUVu dmlyb25tZW50KGZhbHNlKQorICAgICwgbV9mcmFtZShmcmFtZSkKKyAgICAsIG1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dChmcmFtZS0+ZG9jdW1lbnQoKSkKKyAgICAsIG1fY29udHJvbGxlcihmcmFt ZS0+cGFnZSgpLT51c2VyTWVkaWFDb250cm9sbGVyKCkpCisgICAgLCBtX3N1Y2Nlc3NDYWxsYmFj ayhzdWNjZXNzQ2FsbGJhY2spCisgICAgLCBtX2Vycm9yQ2FsbGJhY2soZXJyb3JDYWxsYmFjaykK K3sKKyAgICBwYXJzZU9wdGlvbnMob3B0aW9ucyk7CisKKyAgICBtX2ZyYW1lLT5hZGREZXN0cnVj dGlvbk9ic2VydmVyKHRoaXMpOworfQorCitVc2VyTWVkaWFSZXF1ZXN0Ojp+VXNlck1lZGlhUmVx dWVzdCgpCit7CisgICAgaWYgKG1fZnJhbWUpCisgICAgICAgIG1fZnJhbWUtPnJlbW92ZURlc3Ry dWN0aW9uT2JzZXJ2ZXIodGhpcyk7Cit9CisKK3ZvaWQgVXNlck1lZGlhUmVxdWVzdDo6cGFyc2VP cHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucykKK3sKKyAgICBWZWN0b3I8U3RyaW5nPiBvcHRp b25zTGlzdDsKKyAgICBvcHRpb25zLnNwbGl0KCIsIiwgb3B0aW9uc0xpc3QpOworCisgICAgZm9y IChzaXplX3QgaSA9IDA7IGkgPCBvcHRpb25zTGlzdC5zaXplKCk7ICsraSkgeworICAgICAgICBT cGFjZVNwbGl0U3RyaW5nIHN1Yk9wdGlvbnMob3B0aW9uc0xpc3RbaV0sIGZhbHNlKTsKKworICAg ICAgICBpZiAoc3ViT3B0aW9uc1swXSA9PSAiYXVkaW8iKQorICAgICAgICAgICAgbV9hdWRpbyA9 IHRydWU7CisgICAgICAgIGVsc2UgaWYgKHN1Yk9wdGlvbnNbMF0gPT0gInZpZGVvIikgeworICAg ICAgICAgICAgbV92aWRlbyA9IHRydWU7CisgICAgICAgICAgICBpZiAoc3ViT3B0aW9ucy5jb250 YWlucygidXNlciIpKQorICAgICAgICAgICAgICAgIG1fY2FtZXJhUHJlZmVyZW5jZVVzZXIgPSB0 cnVlOworICAgICAgICAgICAgaWYgKHN1Yk9wdGlvbnMuY29udGFpbnMoImVudmlyb25tZW50Iikp CisgICAgICAgICAgICAgICAgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQgPSB0cnVlOwor ICAgICAgICB9CisgICAgfQorfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OmZyYW1lRGVzdHJv eWVkKCkKK3sKKyAgICBpZiAobV9jb250cm9sbGVyKQorICAgICAgICBtX2NvbnRyb2xsZXItPmNh bmNlbFVzZXJNZWRpYVJlcXVlc3QodGhpcyk7CisKKyAgICBtX2ZyYW1lID0gMDsKK30KKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaCBi L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iYzhjMmJkCi0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5oCkBAIC0wLDAgKzEsOTMg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRXJpY3Nzb24gQUIuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqICAg IGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUKKyAqICAgIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgRXJp Y3Nzb24gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMKKyAqICAg IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworI2lmbmRlZiBVc2VyTWVkaWFSZXF1ZXN0X2gKKyNkZWZpbmUgVXNlck1lZGlhUmVx dWVzdF9oCisKKyNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjaW5jbHVkZSAiRnJhbWUuaCIK KyNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCisjaW5jbHVkZSAi TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1T dHJpbmcuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZD b3VudGVkLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgRnJhbWU7CitjbGFzcyBV c2VyTWVkaWFDb250cm9sbGVyOworCitjbGFzcyBVc2VyTWVkaWFSZXF1ZXN0IDogcHVibGljIFJl ZkNvdW50ZWQ8VXNlck1lZGlhUmVxdWVzdD4sIHB1YmxpYyBGcmFtZURlc3RydWN0aW9uT2JzZXJ2 ZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IGNy ZWF0ZShGcmFtZSosIGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVy cm9yQ2FsbGJhY2s+KTsKKyAgICB+VXNlck1lZGlhUmVxdWVzdCgpOworCisgICAgdmlydHVhbCB2 b2lkIGZyYW1lRGVzdHJveWVkKCk7CisKKyAgICBib29sIGF1ZGlvKCkgY29uc3QgeyByZXR1cm4g bV9hdWRpbzsgfQorICAgIGJvb2wgdmlkZW8oKSBjb25zdCB7IHJldHVybiBtX3ZpZGVvOyB9CisK KyAgICBib29sIGNhbWVyYVByZWZlcmVuY2VVc2VyKCkgY29uc3QgeyByZXR1cm4gbV9jYW1lcmFQ cmVmZXJlbmNlVXNlcjsgfQorICAgIGJvb2wgY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KCkg Y29uc3QgeyByZXR1cm4gbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQ7IH0KKworICAgIEZy YW1lKiBmcmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWU7IH0KKyAgICBTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0OyB9CisKKyAgICBVc2VyTWVkaWFDb250cm9sbGVyKiBjb250cm9s bGVyKCkgY29uc3QgeyByZXR1cm4gbV9jb250cm9sbGVyOyB9CisgICAgdm9pZCBjbGVhckNvbnRy b2xsZXIoKSB7IG1fY29udHJvbGxlciA9IDA7IH0KKworICAgIE5hdmlnYXRvclVzZXJNZWRpYVN1 Y2Nlc3NDYWxsYmFjayogc3VjY2Vzc0NhbGxiYWNrKCkgY29uc3QgeyByZXR1cm4gbV9zdWNjZXNz Q2FsbGJhY2suZ2V0KCk7IH0KKyAgICBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrKiBl cnJvckNhbGxiYWNrKCkgY29uc3QgeyByZXR1cm4gbV9lcnJvckNhbGxiYWNrLmdldCgpOyB9CisK K3ByaXZhdGU6CisgICAgVXNlck1lZGlhUmVxdWVzdChGcmFtZSosIGNvbnN0IFN0cmluZyYgb3B0 aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+LCBQYXNz UmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+KTsKKworICAgIHZvaWQgcGFy c2VPcHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucyk7CisKKyAgICBib29sIG1fYXVkaW87Cisg ICAgYm9vbCBtX3ZpZGVvOworCisgICAgYm9vbCBtX2NhbWVyYVByZWZlcmVuY2VVc2VyOworICAg IGJvb2wgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQ7CisKKyAgICBGcmFtZSogbV9mcmFt ZTsKKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7 CisgICAgVXNlck1lZGlhQ29udHJvbGxlciogbV9jb250cm9sbGVyOworCisgICAgUmVmUHRyPE5h dmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gbV9zdWNjZXNzQ2FsbGJhY2s7CisgICAg UmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IG1fZXJyb3JDYWxsYmFjazsK K307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9T VFJFQU0pCisKKyNlbmRpZiAvLyBVc2VyTWVkaWFSZXF1ZXN0X2gKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvQ2FsbGJhY2tUYXNrLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0NhbGxi YWNrVGFzay5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDAwZDMxLi4wMDAwMDAw Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2FsbGJhY2tUYXNrLmgKKysrIC9kZXYvbnVsbApA QCAtMSw4MSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFy ZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFO RCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIENhbGxiYWNrVGFza19oCi0j ZGVmaW5lIENhbGxiYWNrVGFza19oCi0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5j bHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgotI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+ Ci0jaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KLSNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+Ci0K LW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotLy8gSGVscGVyIHRlbXBsYXRlIHRvIHNjaGVkdWxlIGNh bGxzIHRvIGNhbGxiYWNrcyB1c2luZyB0aGVpciBvd24gc2NyaXB0IGV4ZWN1dGlvbiBjb250ZXh0 LgotLy8gQ2FsbGJhY2tUeXBlIGlzIGFzc3VtZWQgdG8gaW1wbGVtZW50IFNjaGVkdWxlciBhbmQg dG8gYmUgcmVmZXJlbmNlLWNvdW50ZWQuCi10ZW1wbGF0ZSA8dHlwZW5hbWUgQ2FsbGJhY2tUeXBl LCB0eXBlbmFtZSBBcmd1bWVudFR5cGU+Ci1jbGFzcyBDYWxsYmFja1Rhc2sxIDogcHVibGljIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgewotcHVibGljOgotICAgIHN0YXRpYyBQYXNzT3du UHRyPENhbGxiYWNrVGFzazE+IGNyZWF0ZShQYXNzUmVmUHRyPENhbGxiYWNrVHlwZT4gY2FsbGJh Y2ssIFBhc3NSZWZQdHI8QXJndW1lbnRUeXBlPiBkYXRhKQotICAgIHsKLSAgICAgICAgcmV0dXJu IGFkb3B0UHRyKG5ldyBDYWxsYmFja1Rhc2sxKGNhbGxiYWNrLCBkYXRhKSk7Ci0gICAgfQotCi0g ICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQotICAg IHsKLSAgICAgICAgbV9jYWxsYmFjay0+aGFuZGxlRXZlbnQobV9kYXRhLmdldCgpKTsKLSAgICB9 Ci0KLSAgICBjbGFzcyBTY2hlZHVsZXIgewotICAgIHB1YmxpYzoKLSAgICAgICAgdmlydHVhbCB+ U2NoZWR1bGVyKCkgeyB9Ci0KLSAgICAgICAgYm9vbCBzY2hlZHVsZUNhbGxiYWNrKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8QXJndW1lbnRUeXBlPiBkYXRhKQot ICAgICAgICB7Ci0gICAgICAgICAgICBpZiAoY29udGV4dCkgewotICAgICAgICAgICAgICAgIGNv bnRleHQtPnBvc3RUYXNrKENhbGxiYWNrVGFzazE8Q2FsbGJhY2tUeXBlLCBBcmd1bWVudFR5cGU+ OjpjcmVhdGUoc3RhdGljX2Nhc3Q8Q2FsbGJhY2tUeXBlKj4odGhpcyksIGRhdGEpKTsKLSAgICAg ICAgICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIHJldHVy biBmYWxzZTsKLSAgICAgICAgfQotICAgIH07Ci0KLXByaXZhdGU6Ci0gICAgQ2FsbGJhY2tUYXNr MShQYXNzUmVmUHRyPENhbGxiYWNrVHlwZT4gY2FsbGJhY2ssIFBhc3NSZWZQdHI8QXJndW1lbnRU eXBlPiBkYXRhKQotICAgICAgICA6IG1fY2FsbGJhY2soY2FsbGJhY2spCi0gICAgICAgICwgbV9k YXRhKGRhdGEpCi0gICAgewotICAgIH0KLQotICAgIFJlZlB0cjxDYWxsYmFja1R5cGU+IG1fY2Fs bGJhY2s7Ci0gICAgUmVmUHRyPEFyZ3VtZW50VHlwZT4gbV9kYXRhOwotfTsKLQotfQotCi0jZW5k aWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKLQotI2VuZGlmIC8vIENhbGxiYWNrVGFza19oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWUuY3BwCmluZGV4IDYyNzAzMTAuLmVkODg3NzEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUu Y3BwCkBAIC0xMTEsMTAgKzExMSw2IEBACiAjaW5jbHVkZSAiU1ZHRG9jdW1lbnRFeHRlbnNpb25z LmgiCiAjZW5kaWYKIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0jaW5jbHVkZSAiTWVkaWFT dHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKLSNlbmRpZgotCiAjaWYgVVNFKFRJTEVEX0JBQ0tJTkdf U1RPUkUpCiAjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKICNlbmRpZgpAQCAtMTY5LDkg KzE2NSw2IEBAIGlubGluZSBGcmFtZTo6RnJhbWUoUGFnZSogcGFnZSwgSFRNTEZyYW1lT3duZXJF bGVtZW50KiBvd25lckVsZW1lbnQsIEZyYW1lTG9hZGVyCiAgICAgLCBtX2luVmlld1NvdXJjZU1v ZGUoZmFsc2UpCiAgICAgLCBtX2lzRGlzY29ubmVjdGVkKGZhbHNlKQogICAgICwgbV9leGNsdWRl RnJvbVRleHRTZWFyY2goZmFsc2UpCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAsIG1f bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6bWVkaWFT dHJlYW1FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIo dGhpcykpIDogUGFzc093blB0cjxNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcj4oKSkKLSNlbmRp ZgogewogICAgIEFTU0VSVChwYWdlKTsKICAgICBBdG9taWNTdHJpbmc6OmluaXQoKTsKQEAgLTIy OCwxMSArMjIxLDYgQEAgRnJhbWU6On5GcmFtZSgpCiAgICAgaWYgKG1fZG9tV2luZG93KQogICAg ICAgICBtX2RvbVdpbmRvdy0+ZGlzY29ubmVjdEZyYW1lKCk7CiAKLSNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQotICAgIGlmIChtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKQotICAgICAgICBt X21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLT5kaXNjb25uZWN0RnJhbWUoKTsKLSNlbmRpZgot CiAgICAgSGFzaFNldDxET01XaW5kb3cqPjo6aXRlcmF0b3IgZW5kID0gbV9saXZlRm9ybWVyV2lu ZG93cy5lbmQoKTsKICAgICBmb3IgKEhhc2hTZXQ8RE9NV2luZG93Kj46Oml0ZXJhdG9yIGl0ID0g bV9saXZlRm9ybWVyV2luZG93cy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCiAgICAgICAgICgq aXQpLT5kaXNjb25uZWN0RnJhbWUoKTsKQEAgLTY5OCwxMSArNjg2LDYgQEAgdm9pZCBGcmFtZTo6 cGFnZURlc3Ryb3llZCgpCiAgICAgICAgIG1fZG9tV2luZG93LT5wYWdlRGVzdHJveWVkKCk7CiAg ICAgfQogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICBpZiAobV9tZWRpYVN0cmVhbUZy YW1lQ29udHJvbGxlcikKLSAgICAgICAgbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci0+ZGlz Y29ubmVjdFBhZ2UoKTsKLSNlbmRpZgotCiAgICAgLy8gRklYTUU6IEl0J3MgdW5jbGVhciBhcyB0 byB3aHkgdGhpcyBpcyBjYWxsZWQgbW9yZSB0aGFuIG9uY2UsIGJ1dCBpdCBpcywKICAgICAvLyBz byBwYWdlKCkgY291bGQgYmUgTlVMTC4KICAgICBpZiAocGFnZSgpICYmIHBhZ2UoKS0+Zm9jdXND b250cm9sbGVyKCktPmZvY3VzZWRGcmFtZSgpID09IHRoaXMpCkBAIC03NTYsMTAgKzczOSw2IEBA IHZvaWQgRnJhbWU6OnRyYW5zZmVyQ2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQoKQogI2VuZGlmCiAg ICAgICAgIH0KIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAgIGlmIChtX21lZGlh U3RyZWFtRnJhbWVDb250cm9sbGVyKQotICAgICAgICAgICAgbV9tZWRpYVN0cmVhbUZyYW1lQ29u dHJvbGxlci0+dHJhbnNmZXJUb05ld1BhZ2UobmV3UGFnZSk7Ci0jZW5kaWYKICAgICAgICAgbV9w YWdlID0gbmV3UGFnZTsKIAogICAgICAgICBpZiAobmV3UGFnZSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaAppbmRl eCA4MTY2NWM2Li5iMzIwMjZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1l LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCkBAIC02NSw3ICs2NSw2IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBEb2N1bWVudDsKICAgICBjbGFzcyBGcmFtZVZp ZXc7CiAgICAgY2xhc3MgSFRNTFRhYmxlQ2VsbEVsZW1lbnQ7Ci0gICAgY2xhc3MgTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXI7CiAgICAgY2xhc3MgUmVndWxhckV4cHJlc3Npb247CiAgICAgY2xh c3MgUmVuZGVyUGFydDsKICAgICBjbGFzcyBUaWxlZEJhY2tpbmdTdG9yZTsKQEAgLTIwMSwxMCAr MjAwLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBOU0ltYWdlKiBpbWFnZUZyb21S ZWN0KE5TUmVjdCkgY29uc3Q7CiAjZW5kaWYKIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0g ICAgICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBtZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuZ2V0KCk7 IH0KLSNlbmRpZgotICAgICAgICAKICAgICAgICAgLy8gU2hvdWxkIG9ubHkgYmUgY2FsbGVkIG9u IHRoZSBtYWluIGZyYW1lIG9mIGEgcGFnZS4KICAgICAgICAgdm9pZCBub3RpZnlDaHJvbWVDbGll bnRXaGVlbEV2ZW50SGFuZGxlckNvdW50Q2hhbmdlZCgpIGNvbnN0OwogCkBAIC0yNjYsOSArMjYx LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBPd25QdHI8VGlsZWRCYWNraW5nU3Rv cmU+IG1fdGlsZWRCYWNraW5nU3RvcmU7CiAjZW5kaWYKIAotI2lmIEVOQUJMRShNRURJQV9TVFJF QU0pCi0gICAgICAgIE93blB0cjxNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcj4gbV9tZWRpYVN0 cmVhbUZyYW1lQ29udHJvbGxlcjsKLSNlbmRpZgogICAgIH07CiAKICAgICBpbmxpbmUgdm9pZCBG cmFtZTo6aW5pdCgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAKaW5kZXggNTM1NzVhZi4uNTk3 MTJhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcApAQCAtNDUsOSArNDUsOSBAQAogI2lu Y2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0j aW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlh U3VjY2Vzc0NhbGxiYWNrLmgiCisjaW5jbHVkZSAiVXNlck1lZGlhQ29udHJvbGxlci5oIgogI2Vu ZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTI4Myw4ICsyODMsMjMgQEAgdm9pZCBOYXZp Z2F0b3I6OnJlZ2lzdGVyUHJvdG9jb2xIYW5kbGVyKGNvbnN0IFN0cmluZyYgc2NoZW1lLCBjb25z dCBTdHJpbmcmIHVybCwKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQogdm9pZCBOYXZpZ2F0b3I6 OndlYmtpdEdldFVzZXJNZWRpYShjb25zdCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2 aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQ dHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywgRXhjZXB0 aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYgKG1fZnJhbWUgJiYgbV9mcmFtZS0+bWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXIoKSkKLSAgICAgICAgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIoKS0+Z2VuZXJhdGVTdHJlYW0ob3B0aW9ucywgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNh bGxiYWNrLCBlYyk7CisgICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2spCisgICAgICAgIHJldHVybjsK KworICAgIGlmICghbV9mcmFtZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUGFnZSogcGFnZSA9 IG1fZnJhbWUtPnBhZ2UoKTsKKyAgICBpZiAoIXBhZ2UpCisgICAgICAgIHJldHVybjsKKworICAg IFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gVXNlck1lZGlhUmVxdWVzdDo6Y3Jl YXRlKG1fZnJhbWUsIG9wdGlvbnMsIHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjayk7Cisg ICAgaWYgKCFyZXF1ZXN0KSB7CisgICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICBwYWdlLT51c2VyTWVkaWFDb250cm9sbGVyKCktPnJl cXVlc3RVc2VyTWVkaWEocmVxdWVzdC5yZWxlYXNlKCkpOwogfQogI2VuZGlmCiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L05hdmlnYXRvci5oCmluZGV4IDNhMWUwNDIuLjM1ZTYyYmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0 b3IuaApAQCAtMzUsNiArMzUsNyBAQCBjbGFzcyBHZW9sb2NhdGlvbjsKIGNsYXNzIE5hdmlnYXRv clVzZXJNZWRpYUVycm9yQ2FsbGJhY2s7CiBjbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNz Q2FsbGJhY2s7CiBjbGFzcyBQbHVnaW5EYXRhOworY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4 dDsKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmggYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaAppbmRleCAxNTM5NzA5 Li5kZDNjOGIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJN ZWRpYUVycm9yQ2FsbGJhY2suaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVz ZXJNZWRpYUVycm9yQ2FsbGJhY2suaApAQCAtMjcsMTQgKzI3LDEyIEBACiAKICNpZiBFTkFCTEUo TUVESUFfU1RSRUFNKQogCi0jaW5jbHVkZSAiQ2FsbGJhY2tUYXNrLmgiCiAjaW5jbHVkZSAiTmF2 aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIKICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJh Y2sgOiBwdWJsaWMgUmVmQ291bnRlZDxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwdWJsaWMgQ2FsbGJhY2tU YXNrMTxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLCBOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvcj46OlNjaGVkdWxlciB7CitjbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNr IDogcHVibGljIFJlZkNvdW50ZWQ8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gewog cHVibGljOgogICAgIHZpcnR1YWwgfk5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2soKSB7 IH0KICAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlRXZlbnQoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3Iq KSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIGIvU291cmNl L1dlYkNvcmUvcGFnZS9QYWdlLmNwcAppbmRleCA1OWYzNTc5Li41MTQyZTk5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv UGFnZS5jcHAKQEAgLTgwLDggKzgwLDcgQEAKICNlbmRpZgogCiAjaWYgRU5BQkxFKE1FRElBX1NU UkVBTSkKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNsaWVudC5oIgotI2luY2x1ZGUgIk1lZGlhU3Ry ZWFtQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIlVzZXJNZWRpYUNvbnRyb2xsZXIuaCIKICNlbmRp ZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0xMzcsMTIgKzEzNiwxMiBAQCBQYWdlOjpQYWdl KFBhZ2VDbGllbnRzJiBwYWdlQ2xpZW50cykKICAgICAsIG1fZGV2aWNlTW90aW9uQ29udHJvbGxl cihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjpkZXZpY2VNb3Rpb25FbmFibGVkKCkgPyBhZG9wdFB0 cihuZXcgRGV2aWNlTW90aW9uQ29udHJvbGxlcihwYWdlQ2xpZW50cy5kZXZpY2VNb3Rpb25DbGll bnQpKSA6IG51bGxwdHIpCiAgICAgLCBtX2RldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcihSdW50 aW1lRW5hYmxlZEZlYXR1cmVzOjpkZXZpY2VPcmllbnRhdGlvbkVuYWJsZWQoKSA/IGFkb3B0UHRy KG5ldyBEZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIodGhpcywgcGFnZUNsaWVudHMuZGV2aWNl T3JpZW50YXRpb25DbGllbnQpKSA6IG51bGxwdHIpCiAjZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQotICAgICwgbV9tZWRpYVN0cmVhbUNvbnRyb2xsZXIoUnVudGltZUVuYWJsZWRGZWF0 dXJlczo6bWVkaWFTdHJlYW1FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcgTWVkaWFTdHJlYW1Db250 cm9sbGVyKHBhZ2VDbGllbnRzLm1lZGlhU3RyZWFtQ2xpZW50KSkgOiBQYXNzT3duUHRyPE1lZGlh U3RyZWFtQ29udHJvbGxlcj4oKSkKLSNlbmRpZgogI2lmIEVOQUJMRShJTlBVVF9TUEVFQ0gpCiAg ICAgLCBtX3NwZWVjaElucHV0Q2xpZW50KHBhZ2VDbGllbnRzLnNwZWVjaElucHV0Q2xpZW50KQog I2VuZGlmCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKyAgICAsIG1fdXNlck1lZGlhQ29udHJv bGxlcihhZG9wdFB0cihuZXcgVXNlck1lZGlhQ29udHJvbGxlcih0aGlzLCBwYWdlQ2xpZW50cy51 c2VyTWVkaWFDbGllbnQpKSkKKyNlbmRpZgogICAgICwgbV9zZXR0aW5ncyhhZG9wdFB0cihuZXcg U2V0dGluZ3ModGhpcykpKQogICAgICwgbV9wcm9ncmVzcyhhZG9wdFB0cihuZXcgUHJvZ3Jlc3NU cmFja2VyKSkKICAgICAsIG1fYmFja0ZvcndhcmRDb250cm9sbGVyKGFkb3B0UHRyKG5ldyBCYWNr Rm9yd2FyZENvbnRyb2xsZXIodGhpcywgcGFnZUNsaWVudHMuYmFja0ZvcndhcmRDbGllbnQpKSkK QEAgLTEwNDIsNyArMTA0MSw3IEBAIFBhZ2U6OlBhZ2VDbGllbnRzOjpQYWdlQ2xpZW50cygpCiAg ICAgLCBkZXZpY2VNb3Rpb25DbGllbnQoMCkKICAgICAsIGRldmljZU9yaWVudGF0aW9uQ2xpZW50 KDApCiAgICAgLCBzcGVlY2hJbnB1dENsaWVudCgwKQotICAgICwgbWVkaWFTdHJlYW1DbGllbnQo MCkKKyAgICAsIHVzZXJNZWRpYUNsaWVudCgwKQogewogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1BhZ2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCmluZGV4IDNm MzBjZjMuLjFhMzQ3NzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCkBAIC03MSw4ICs3MSw2IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICBjbGFzcyBJbnNwZWN0b3JDbGllbnQ7CiAgICAgY2xhc3MgSW5zcGVj dG9yQ29udHJvbGxlcjsKICAgICBjbGFzcyBNZWRpYUNhblN0YXJ0TGlzdGVuZXI7Ci0gICAgY2xh c3MgTWVkaWFTdHJlYW1DbGllbnQ7Ci0gICAgY2xhc3MgTWVkaWFTdHJlYW1Db250cm9sbGVyOwog ICAgIGNsYXNzIE5vZGU7CiAgICAgY2xhc3MgUGFnZUdyb3VwOwogICAgIGNsYXNzIFBsdWdpbkRh dGE7CkBAIC04NCw2ICs4Miw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBTZXR0 aW5nczsKICAgICBjbGFzcyBTcGVlY2hJbnB1dDsKICAgICBjbGFzcyBTcGVlY2hJbnB1dENsaWVu dDsKKyAgICBjbGFzcyBVc2VyTWVkaWFDbGllbnQ7CisgICAgY2xhc3MgVXNlck1lZGlhQ29udHJv bGxlcjsKICAgICBjbGFzcyBTdG9yYWdlTmFtZXNwYWNlOwogI2lmIEVOQUJMRShOT1RJRklDQVRJ T05TKQogICAgIGNsYXNzIE5vdGlmaWNhdGlvblByZXNlbnRlcjsKQEAgLTExOCw3ICsxMTgsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICBEZXZpY2VPcmllbnRhdGlvbkNsaWVu dCogZGV2aWNlT3JpZW50YXRpb25DbGllbnQ7CiAgICAgICAgICAgICBSZWZQdHI8QmFja0Zvcndh cmRMaXN0PiBiYWNrRm9yd2FyZENsaWVudDsKICAgICAgICAgICAgIFNwZWVjaElucHV0Q2xpZW50 KiBzcGVlY2hJbnB1dENsaWVudDsKLSAgICAgICAgICAgIE1lZGlhU3RyZWFtQ2xpZW50KiBtZWRp YVN0cmVhbUNsaWVudDsKKyAgICAgICAgICAgIFVzZXJNZWRpYUNsaWVudCogdXNlck1lZGlhQ2xp ZW50OwogICAgICAgICB9OwogCiAgICAgICAgIFBhZ2UoUGFnZUNsaWVudHMmKTsKQEAgLTE4NCwx MiArMTg0LDEyIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgRGV2aWNlTW90aW9uQ29u dHJvbGxlciogZGV2aWNlTW90aW9uQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNl TW90aW9uQ29udHJvbGxlci5nZXQoKTsgfQogICAgICAgICBEZXZpY2VPcmllbnRhdGlvbkNvbnRy b2xsZXIqIGRldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fZGV2 aWNlT3JpZW50YXRpb25Db250cm9sbGVyLmdldCgpOyB9CiAjZW5kaWYKLSNpZiBFTkFCTEUoTUVE SUFfU1RSRUFNKQotICAgICAgICBNZWRpYVN0cmVhbUNvbnRyb2xsZXIqIG1lZGlhU3RyZWFtQ29u dHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fbWVkaWFTdHJlYW1Db250cm9sbGVyLmdldCgpOyB9 Ci0jZW5kaWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNIKQogICAgICAgICBTcGVlY2hJbnB1dCog c3BlZWNoSW5wdXQoKTsKICNlbmRpZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisgICAgICAg IFVzZXJNZWRpYUNvbnRyb2xsZXIqIHVzZXJNZWRpYUNvbnRyb2xsZXIoKSBjb25zdCB7IHJldHVy biBtX3VzZXJNZWRpYUNvbnRyb2xsZXIuZ2V0KCk7IH0KKyNlbmRpZgogICAgICAgICBTZXR0aW5n cyogc2V0dGluZ3MoKSBjb25zdCB7IHJldHVybiBtX3NldHRpbmdzLmdldCgpOyB9CiAgICAgICAg IFByb2dyZXNzVHJhY2tlciogcHJvZ3Jlc3MoKSBjb25zdCB7IHJldHVybiBtX3Byb2dyZXNzLmdl dCgpOyB9CiAgICAgICAgIEJhY2tGb3J3YXJkQ29udHJvbGxlciogYmFja0ZvcndhcmQoKSBjb25z dCB7IHJldHVybiBtX2JhY2tGb3J3YXJkQ29udHJvbGxlci5nZXQoKTsgfQpAQCAtMzY0LDEzICsz NjQsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBPd25QdHI8RGV2aWNlTW90aW9u Q29udHJvbGxlcj4gbV9kZXZpY2VNb3Rpb25Db250cm9sbGVyOwogICAgICAgICBPd25QdHI8RGV2 aWNlT3JpZW50YXRpb25Db250cm9sbGVyPiBtX2RldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcjsK ICNlbmRpZgotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAgIE93blB0cjxNZWRpYVN0 cmVhbUNvbnRyb2xsZXI+IG1fbWVkaWFTdHJlYW1Db250cm9sbGVyOwotI2VuZGlmCiAjaWYgRU5B QkxFKElOUFVUX1NQRUVDSCkKICAgICAgICAgU3BlZWNoSW5wdXRDbGllbnQqIG1fc3BlZWNoSW5w dXRDbGllbnQ7CiAgICAgICAgIE93blB0cjxTcGVlY2hJbnB1dD4gbV9zcGVlY2hJbnB1dDsKICNl bmRpZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisgICAgICAgIE93blB0cjxVc2VyTWVkaWFD b250cm9sbGVyPiBtX3VzZXJNZWRpYUNvbnRyb2xsZXI7CisjZW5kaWYKICAgICAgICAgT3duUHRy PFNldHRpbmdzPiBtX3NldHRpbmdzOwogICAgICAgICBPd25QdHI8UHJvZ3Jlc3NUcmFja2VyPiBt X3Byb2dyZXNzOwogICAgICAgICAK 115412 2011-11-16 11:12:52 -0800 2011-11-16 17:37:39 -0800 Patch 5 usermedia_simple_client_5.patch text/plain 54900 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA5NDI0NjJlLi5kNTMyM2NhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTcg QEAKKzIwMTEtMTEtMTYgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudCBmb3IgdXNlciBjb25zZW50 IGluIGdldFVzZXJNZWRpYSgpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD03MDg5NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgaXMgb25lIGluIGEgc2VyaWVzIG9mIHBhdGNoZXMgdGhhdCB1cGRhdGUg dGhlIE1lZGlhU3RyZWFtIGZlYXR1cmUKKyAgICAgICAgdG8gdXNlIFdlYkNvcmUgcGxhdGZvcm0g aW50ZXJmYWNlcy4KKworICAgICAgICBDb3ZlcmVkIGJ5IGV4aXN0aW5nIHRlc3RzLgorCisgICAg ICAgICogR05VbWFrZWZpbGUubGlzdC5hbToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAg ICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaDogUmVtb3ZlZC4KKyAgICAgICAg KiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwOiBSZW1vdmVkLgorICAgICAg ICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5oOiBSZW1vdmVkLgorICAgICAg ICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcDogUmVtb3ZlZC4K KyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oOiBSZW1v dmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNsaWVudDo6flVzZXJNZWRpYUNsaWVudCk6CisgICAg ICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6flVzZXJNZWRpYVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVz dDo6bWVkaWFTdHJlYW1Tb3VyY2VzUXVlcnlDb21wbGV0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6 VXNlck1lZGlhUmVxdWVzdDo6c3VjY2VlZCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFS ZXF1ZXN0OjpmYWlsKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNvbnRl eHREZXN0cm95ZWQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6cGFyc2VP cHRpb25zKToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0Lmg6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6YXVkaW8pOgorICAgICAgICAo V2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6dmlkZW8pOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZVVzZXIpOgorICAgICAgICAoV2ViQ29yZTo6 VXNlck1lZGlhUmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChX ZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjplcnJvckNhbGxiYWNrKToKKyAgICAgICAgKiBwYWdl L0NhbGxiYWNrVGFzay5oOiBSZW1vdmVkLgorICAgICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWU6OkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp+ RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OnBhZ2VEZXN0cm95ZWQpOgorICAgICAg ICAoV2ViQ29yZTo6RnJhbWU6OnRyYW5zZmVyQ2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQpOgorICAg ICAgICAqIHBhZ2UvRnJhbWUuaDoKKyAgICAgICAgKiBwYWdlL05hdmlnYXRvci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYSk6CisgICAgICAgICog cGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmg6CisgICAgICAgICogcGFnZS9Q YWdlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhZ2U6OlBhZ2UpOgorICAgICAgICAoV2ViQ29y ZTo6UGFnZTo6UGFnZUNsaWVudHM6OlBhZ2VDbGllbnRzKToKKyAgICAgICAgKiBwYWdlL1BhZ2Uu aDoKKyAgICAgICAgKFdlYkNvcmU6OlBhZ2U6OnVzZXJNZWRpYUNsaWVudCk6CisKIDIwMTEtMTEt MTYgIFZzZXZvbG9kIFZsYXNvdiAgPHZzZXZpa0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2Vi IEluc3BlY3RvcjogQXBwbGljYXRpb24gY2FjaGUgc3RhdHVzIHNob3VsZCBiZSB1cGRhdGVkIGFm dGVyIHN3YXBDYWNoZSgpLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUu bGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggMzQ3ZTk2 My4uMTYxNjczOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5h bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0yMjgwLDEzICsy MjgwLDggQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9Mb2NhbE1lZGlhU3RyZWFtLmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlh U3RyZWFtLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW0uaCBc Ci0JU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaCBcCi0JU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNwcCBcCi0JU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmggXAogCVNvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRXZlbnQuY3BwIFwKIAlTb3VyY2UvV2Vi Q29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUV2ZW50LmggXAotCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcCBcCi0JU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCBcCiAJU291cmNlL1dl YkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0LmNwcCBcCiAJU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0LmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL01lZGlhU3RyZWFtUmVnaXN0cnkuY3BwIFwKQEAgLTIyOTgsNiArMjI5Myw5IEBAIHdlYmNv cmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rp b24uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5oIFwK IAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9TaWduYWxpbmdDYWxsYmFjay5oIFwKKwlTb3Vy Y2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaCBcCisJU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaCBcCiAJU291cmNlL1dlYkNvcmUvbm90aWZpY2F0 aW9ucy9Ob3RpZmljYXRpb25DZW50ZXIuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9ub3RpZmljYXRp b25zL05vdGlmaWNhdGlvbkNlbnRlci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9ub3RpZmljYXRpb25z L05vdGlmaWNhdGlvbkNvbnRlbnRzLmggXApAQCAtMjMxOCw3ICsyMzE2LDYgQEAgd2ViY29yZV9z b3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0FkanVzdFZpZXdTaXplT3JOb3QuaCBc CiAJU291cmNlL1dlYkNvcmUvcGFnZS9CYXJJbmZvLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGFn ZS9CYXJJbmZvLmggXAotCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQ2FsbGJhY2tUYXNrLmggXAogCVNv dXJjZS9XZWJDb3JlL3BhZ2UvQ2hyb21lLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9DaHJv bWUuaCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9DaHJvbWVDbGllbnQuaCBcCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5 cGkKaW5kZXggYjVjY2FkMC4uZjJmMDcyMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMjkwNSwxMSAr MjkwNSw2IEBACiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW0uaCcsCiAgICAg ICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5jcHAnLAogICAgICAgICAgICAg J21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRXZlbnQuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJl YW0vTWVkaWFTdHJlYW1DbGllbnQuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1Db250cm9sbGVyLmNwcCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJl YW1Db250cm9sbGVyLmgnLAotICAgICAgICAgICAgJ21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyLmNwcCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXIuaCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1M aXN0LmNwcCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1MaXN0LmgnLAog ICAgICAgICAgICAgJ21lZGlhc3RyZWFtL01lZGlhU3RyZWFtVHJhY2suY3BwJywKQEAgLTI5MjEs NiArMjkxNiw5IEBACiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vUGVlckNvbm5lY3Rpb24uY3Bw JywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9QZWVyQ29ubmVjdGlvbi5oJywKICAgICAgICAg ICAgICdtZWRpYXN0cmVhbS9TaWduYWxpbmdDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdtZWRp YXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaCcsCisgICAgICAgICAgICAnbWVkaWFzdHJlYW0vVXNl ck1lZGlhUmVxdWVzdC5jcHAnLAorICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYVJl cXVlc3QuaCcsCiAgICAgICAgICAgICAnbm90aWZpY2F0aW9ucy9Ob3RpZmljYXRpb24uY3BwJywK ICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbi5oJywKICAgICAgICAgICAg ICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNlbnRlci5jcHAnLApAQCAtMjkyOCw3ICsyOTI2 LDYgQEAKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNvbnRlbnRzLmgn LAogICAgICAgICAgICAgJ3BhZ2UvQmFySW5mby5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvQmFy SW5mby5oJywKLSAgICAgICAgICAgICdwYWdlL0NhbGxiYWNrVGFzay5oJywKICAgICAgICAgICAg ICdwYWdlL0Nocm9tZS5jcHAnLAogICAgICAgICAgICAgJ3BhZ2UvQ29uc29sZS5jcHAnLAogICAg ICAgICAgICAgJ3BhZ2UvQ29udGVudFNlY3VyaXR5UG9saWN5LmNwcCcsCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oIGIvU291cmNlL1dl YkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaApkZWxldGVkIGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggYWY5MDk1Yy4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oCisrKyAvZGV2L251bGwKQEAgLTEsNTggKzAsMCBAQAot LyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICog ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKLSAq IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUwot ICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCi0gKi8KLQotI2lmbmRlZiBNZWRpYVN0cmVhbUNsaWVudF9oCi0jZGVmaW5lIE1lZGlh U3RyZWFtQ2xpZW50X2gKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlIDx3 dGYvRm9yd2FyZC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIFNlY3VyaXR5T3Jp Z2luOwotCi1lbnVtIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZyB7Ci0gICAgR2VuZXJhdGVTdHJl YW1SZXF1ZXN0QXVkaW8gPSAxLAotICAgIEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5n VXNlciA9IDEgPDwgMSwKLSAgICBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ0Vudmly b25tZW50ID0gMSA8PCAyLAotfTsKLQotdHlwZWRlZiB1bnNpZ25lZCBHZW5lcmF0ZVN0cmVhbU9w dGlvbkZsYWdzOwotCi1jbGFzcyBNZWRpYVN0cmVhbUNsaWVudCB7Ci1wdWJsaWM6Ci0gICAgLy8g TWVkaWFTdHJlYW0gZnVuY3Rpb25zLgotICAgIHZpcnR1YWwgdm9pZCBtZWRpYVN0cmVhbURlc3Ry b3llZCgpID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgZ2VuZXJhdGVTdHJlYW0oaW50IHJlcXVlc3RJ ZCwgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncywgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4p ID0gMDsKLQotcHJvdGVjdGVkOgotICAgIHZpcnR1YWwgfk1lZGlhU3RyZWFtQ2xpZW50KCkgeyB9 Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFf U1RSRUFNKQotCi0jZW5kaWYgLy8gTWVkaWFTdHJlYW1DbGllbnRfaApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5jcHAKZGVsZXRlZCBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ0ZTMwOGUuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNwcAorKysgL2Rldi9udWxsCkBA IC0xLDEyMyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFy ZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFO RCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5j bHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgiCi0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFN KQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJT ZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KLQotbmFtZXNwYWNlIFdl YkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OlJlcXVlc3QgewotcHVibGlj OgotICAgIFJlcXVlc3QoKQotICAgICAgICA6IG1fbG9jYWxJZCgwKQotICAgICAgICAsIG1fZnJh bWVDb250cm9sbGVyKDApIHsgfQotCi0gICAgUmVxdWVzdChpbnQgbG9jYWxJZCwgTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlcikKLSAgICAgICAgOiBtX2xvY2FsSWQo bG9jYWxJZCkKLSAgICAgICAgLCBtX2ZyYW1lQ29udHJvbGxlcihmcmFtZUNvbnRyb2xsZXIpIHsg fQotCi0gICAgaW50IGxvY2FsSWQoKSBjb25zdCB7IHJldHVybiBtX2xvY2FsSWQ7IH0KLSAgICBN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKCkgY29uc3QgeyByZXR1 cm4gbV9mcmFtZUNvbnRyb2xsZXI7IH0KLQotcHJpdmF0ZToKLSAgICBpbnQgbV9sb2NhbElkOwot ICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBtX2ZyYW1lQ29udHJvbGxlcjsKLX07Ci0K LU1lZGlhU3RyZWFtQ29udHJvbGxlcjo6TWVkaWFTdHJlYW1Db250cm9sbGVyKE1lZGlhU3RyZWFt Q2xpZW50KiBjbGllbnQpCi0gICAgOiBtX2NsaWVudChjbGllbnQpCi0gICAgLCBtX25leHRHbG9i YWxSZXF1ZXN0SWQoMSkKLXsKLX0KLQotTWVkaWFTdHJlYW1Db250cm9sbGVyOjp+TWVkaWFTdHJl YW1Db250cm9sbGVyKCkKLXsKLSAgICBpZiAobV9jbGllbnQpCi0gICAgICAgIG1fY2xpZW50LT5t ZWRpYVN0cmVhbURlc3Ryb3llZCgpOwotfQotCi1ib29sIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6 aXNDbGllbnRBdmFpbGFibGUoKSBjb25zdAotewotICAgIHJldHVybiBtX2NsaWVudDsKLX0KLQot dm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnVucmVnaXN0ZXJGcmFtZUNvbnRyb2xsZXIoTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlcikKLXsKLSAgICBBU1NFUlQo ZnJhbWVDb250cm9sbGVyKTsKLQotICAgIC8vIERvbmUgaW4gdHdvIHN0ZXBzIHRvIGF2b2lkIHBy b2JsZW1zIGFib3V0IGl0ZXJhdG9ycyBiZWluZyBpbnZhbGlkYXRlZCB3aGlsZSByZW1vdmluZy4K LSAgICBWZWN0b3I8aW50PiBmcmFtZVJlcXVlc3RzOwotICAgIGZvciAoUmVxdWVzdE1hcDo6aXRl cmF0b3IgaXQgPSBtX3JlcXVlc3RzLmJlZ2luKCk7IGl0ICE9IG1fcmVxdWVzdHMuZW5kKCk7ICsr aXQpCi0gICAgICAgIGlmIChpdC0+c2Vjb25kLmZyYW1lQ29udHJvbGxlcigpID09IGZyYW1lQ29u dHJvbGxlcikKLSAgICAgICAgICAgIGZyYW1lUmVxdWVzdHMuYXBwZW5kKGl0LT5maXJzdCk7Ci0K LSAgICBmb3IgKFZlY3RvcjxpbnQ+OjppdGVyYXRvciBpdCA9IGZyYW1lUmVxdWVzdHMuYmVnaW4o KTsgaXQgIT0gZnJhbWVSZXF1ZXN0cy5lbmQoKTsgKytpdCkKLSAgICAgICAgbV9yZXF1ZXN0cy5y ZW1vdmUoKml0KTsKLX0KLQotaW50IE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6cmVnaXN0ZXJSZXF1 ZXN0KGludCBsb2NhbElkLCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9s bGVyKQotewotICAgIEFTU0VSVChsb2NhbElkID4gMCk7Ci0gICAgQVNTRVJUKGZyYW1lQ29udHJv bGxlcik7Ci0gICAgbV9yZXF1ZXN0cy5hZGQobV9uZXh0R2xvYmFsUmVxdWVzdElkLCBSZXF1ZXN0 KGxvY2FsSWQsIGZyYW1lQ29udHJvbGxlcikpOwotICAgIHJldHVybiBtX25leHRHbG9iYWxSZXF1 ZXN0SWQrKzsKLX0KLQotdm9pZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OmdlbmVyYXRlU3RyZWFt KE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNvbnRyb2xsZXIsIGludCBsb2NhbElk LCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIGZsYWdzLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3Jp Z2luPiBzZWN1cml0eU9yaWdpbikKLXsKLSAgICBBU1NFUlQobV9jbGllbnQpOwotICAgIGludCBj b250cm9sbGVyUmVxdWVzdElkID0gcmVnaXN0ZXJSZXF1ZXN0KGxvY2FsSWQsIGZyYW1lQ29udHJv bGxlcik7Ci0gICAgbV9jbGllbnQtPmdlbmVyYXRlU3RyZWFtKGNvbnRyb2xsZXJSZXF1ZXN0SWQs IGZsYWdzLCBzZWN1cml0eU9yaWdpbik7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1Db250cm9sbGVy OjpzdHJlYW1HZW5lcmF0ZWQoaW50IGNvbnRyb2xsZXJSZXF1ZXN0SWQsIGNvbnN0IE1lZGlhU3Ry ZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewotICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0 aGUgZnJhbWUgY29udHJvbGxlciBjYW4gaGF2ZSBiZWVuIGRlc3Ryb3llZCB3aGlsZSB0aGUgcmVx dWVzdCByZXBseSB3YXMgY29taW5nIGJhY2suCi0gICAgaWYgKG1fcmVxdWVzdHMuY29udGFpbnMo Y29udHJvbGxlclJlcXVlc3RJZCkpIHsKLSAgICAgICAgY29uc3QgUmVxdWVzdCYgcmVxdWVzdCA9 IG1fcmVxdWVzdHMuZ2V0KGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAgICAgICBtX3JlcXVlc3Rz LnJlbW92ZShjb250cm9sbGVyUmVxdWVzdElkKTsKLSAgICAgICAgQVNTRVJUKHJlcXVlc3QuZnJh bWVDb250cm9sbGVyKCkpOwotICAgICAgICByZXF1ZXN0LmZyYW1lQ29udHJvbGxlcigpLT5zdHJl YW1HZW5lcmF0ZWQocmVxdWVzdC5sb2NhbElkKCksIHNvdXJjZXMpOwotICAgIH0KLX0KLQotdm9p ZCBNZWRpYVN0cmVhbUNvbnRyb2xsZXI6OnN0cmVhbUdlbmVyYXRpb25GYWlsZWQoaW50IGNvbnRy b2xsZXJSZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUgY29kZSkK LXsKLSAgICAvLyBEb24ndCBhc3NlcnQgc2luY2UgdGhlIGZyYW1lIGNvbnRyb2xsZXIgY2FuIGhh dmUgYmVlbiBkZXN0cm95ZWQgd2hpbGUgdGhlIHJlcXVlc3QgcmVwbHkgd2FzIGNvbWluZyBiYWNr LgotICAgIGlmIChtX3JlcXVlc3RzLmNvbnRhaW5zKGNvbnRyb2xsZXJSZXF1ZXN0SWQpKSB7Ci0g ICAgICAgIGNvbnN0IFJlcXVlc3QmIHJlcXVlc3QgPSBtX3JlcXVlc3RzLmdldChjb250cm9sbGVy UmVxdWVzdElkKTsKLSAgICAgICAgbV9yZXF1ZXN0cy5yZW1vdmUoY29udHJvbGxlclJlcXVlc3RJ ZCk7Ci0gICAgICAgIHJlcXVlc3QuZnJhbWVDb250cm9sbGVyKCktPnN0cmVhbUdlbmVyYXRpb25G YWlsZWQocmVxdWVzdC5sb2NhbElkKCksIGNvZGUpOwotICAgIH0KLX0KLQotfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5oIGIvU291 cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmgKZGVsZXRlZCBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ4OTMwOTQuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmgKKysrIC9kZXYvbnVsbApAQCAt MSw3NCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBt ZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBB TlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsK LSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtQ29udHJvbGxl cl9oCi0jZGVmaW5lIE1lZGlhU3RyZWFtQ29udHJvbGxlcl9oCi0KLSNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1DbGllbnQuaCIKLSNpbmNsdWRlICJNZWRp YVN0cmVhbVNvdXJjZS5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCi0j aW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgotI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4K LQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVhbUNsaWVudDsKLWNsYXNz IE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOwotY2xhc3MgU2VjdXJpdHlPcmlnaW47Ci0KLWNs YXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlciB7Ci0gICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWVk aWFTdHJlYW1Db250cm9sbGVyKTsKLXB1YmxpYzoKLSAgICBNZWRpYVN0cmVhbUNvbnRyb2xsZXIo TWVkaWFTdHJlYW1DbGllbnQqKTsKLSAgICB2aXJ0dWFsIH5NZWRpYVN0cmVhbUNvbnRyb2xsZXIo KTsKLQotICAgIGJvb2wgaXNDbGllbnRBdmFpbGFibGUoKSBjb25zdDsKLSAgICB2b2lkIHVucmVn aXN0ZXJGcmFtZUNvbnRyb2xsZXIoTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqKTsKLQotICAg IHZvaWQgZ2VuZXJhdGVTdHJlYW0oTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqLCBpbnQgcmVx dWVzdElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzLCBQYXNzUmVmUHRyPFNlY3VyaXR5T3Jp Z2luPik7Ci0KLSAgICB2b2lkIHN0cmVhbUdlbmVyYXRlZChpbnQgcmVxdWVzdElkLCBjb25zdCBN ZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcyk7Ci0gICAgdm9pZCBzdHJlYW1HZW5lcmF0 aW9uRmFpbGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNv ZGUpOwotCi1wcml2YXRlOgotICAgIGludCByZWdpc3RlclJlcXVlc3QoaW50IGxvY2FsUmVxdWVz dElkLCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciopOwotCi0gICAgY2xhc3MgUmVxdWVzdDsK LSAgICB0eXBlZGVmIEhhc2hNYXA8aW50LCBSZXF1ZXN0PiBSZXF1ZXN0TWFwOwotCi0gICAgUmVx dWVzdE1hcCBtX3JlcXVlc3RzOwotCi0gICAgTWVkaWFTdHJlYW1DbGllbnQqIG1fY2xpZW50Owot ICAgIGludCBtX25leHRHbG9iYWxSZXF1ZXN0SWQ7Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJD b3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jZW5kaWYgLy8gTWVkaWFT dHJlYW1Db250cm9sbGVyX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFt L01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3Ry ZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggZGM3NTdlNC4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSwyODMg KzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0Ogot ICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQotICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCi0g KiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVECi0gKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCi0gKiBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkKLSAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCi0gKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Ci0gKiBM T1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04KLSAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUwotICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIk1l ZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgiCi0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQot Ci0jaW5jbHVkZSAiRE9NV2luZG93LmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKLSNpbmNsdWRl ICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAiRnJhbWUuaCIKLSNpbmNsdWRlICJMb2NhbE1l ZGlhU3RyZWFtLmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgiCi0jaW5jbHVk ZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgotI2luY2x1ZGUgIk5hdmlnYXRv clVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgotI2luY2x1ZGUgIlBhZ2UuaCIKLSNpbmNsdWRl ICJTZWN1cml0eU9yaWdpbi5oIgotI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+Ci0KLW5hbWVz cGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OlJlcXVl c3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXF1ZXN0PiB7Ci0gICAgV1RGX01BS0VfTk9OQ09QWUFC TEUoUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgdmlydHVhbCB+UmVxdWVzdCgpIHsgfQotCi0gICAg U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0IHsg cmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dDsgfQotICAgIHZpcnR1YWwgYm9vbCBpc0dl bmVyYXRlU3RyZWFtUmVxdWVzdCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9Ci0KLSAgICB2aXJ0 dWFsIHZvaWQgYWJvcnQoKSA9IDA7Ci0KLXByb3RlY3RlZDoKLSAgICBSZXF1ZXN0KFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0gICAgICAgIDogbV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpIHsgfQotCi1wcml2YXRl OgotICAgIC8vIFRoaXMgaXMgZ3VhcmFudGVlZCB0byBoYXZlIHRoZSBsaWZldGltZSBvZiB0aGUg RnJhbWUsIGFuZCBpdCdzIG9ubHkgdXNlZCB0byBtYWtlCi0gICAgLy8gdGhlIGNhbGxiYWNrIGFz eW5jaHJvbm91cy4gVGhlIG9yaWdpbmFsIGNhbGxiYWNrIGNvbnRleHQgaXMgdXNlZCBpbiB0aGUg Y2FsbC4KLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ7Ci19OwotCi1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6R2VuZXJhdGVTdHJl YW1SZXF1ZXN0IDogcHVibGljIFJlcXVlc3QgewotICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKEdl bmVyYXRlU3RyZWFtUmVxdWVzdCk7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8R2Vu ZXJhdGVTdHJlYW1SZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0 RXhlY3V0aW9uQ29udGV4dCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFj az4gc3VjY2Vzc0NhbGxiYWNrLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFj az4gZXJyb3JDYWxsYmFjaykKLSAgICB7Ci0gICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgR2Vu ZXJhdGVTdHJlYW1SZXF1ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIHN1Y2Nlc3NDYWxsYmFj aywgZXJyb3JDYWxsYmFjaykpOwotICAgIH0KLQotICAgIHZpcnR1YWwgfkdlbmVyYXRlU3RyZWFt UmVxdWVzdCgpIHsgfQotCi0gICAgdmlydHVhbCBib29sIGlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0 KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQotCi0gICAgdmlydHVhbCB2b2lkIGFib3J0KCkKLSAg ICB7Ci0gICAgICAgIGlmIChtX2Vycm9yQ2FsbGJhY2spIHsKLSAgICAgICAgICAgIFJlZlB0cjxO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6 Y3JlYXRlKE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpQRVJNSVNTSU9OX0RFTklFRCk7Ci0gICAg ICAgICAgICAvLyBUaGUgY2FsbGJhY2sgaXRzZWxmIGlzIG1hZGUgd2l0aCB0aGUgSlMgY2FsbGJh Y2sncyBjb250ZXh0LCBub3Qgd2l0aCB0aGUgZnJhbWUncyBjb250ZXh0LgotICAgICAgICAgICAg bV9lcnJvckNhbGxiYWNrLT5zY2hlZHVsZUNhbGxiYWNrKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQo KSwgZXJyb3IpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJu IG1fc3VjY2Vzc0NhbGxiYWNrOyB9Ci0gICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKCkgY29uc3QgeyByZXR1cm4gbV9lcnJvckNhbGxi YWNrOyB9Ci0KLXByaXZhdGU6Ci0gICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsCi0gICAgICAgICAgICAgICAgICAg ICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrPiBzdWNj ZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdh dG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKLSAgICAgICAgOiBSZXF1 ZXN0KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpCi0gICAgICAgICwgbV9zdWNjZXNzQ2FsbGJhY2so c3VjY2Vzc0NhbGxiYWNrKQotICAgICAgICAsIG1fZXJyb3JDYWxsYmFjayhlcnJvckNhbGxiYWNr KSB7IH0KLQotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IG1f c3VjY2Vzc0NhbGxiYWNrOwotICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxi YWNrPiBtX2Vycm9yQ2FsbGJhY2s7Ci19OwotCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyOjpSZXF1ZXN0TWFwOjphYm9ydChpbnQgcmVxdWVzdElkKQotewotICAgIGdldChyZXF1ZXN0 SWQpLT5hYm9ydCgpOwotICAgIHJlbW92ZShyZXF1ZXN0SWQpOwotfQotCi12b2lkIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0TWFwOjphYm9ydEFsbCgpCi17Ci0gICAgd2hpbGUg KCFpc0VtcHR5KCkpIHsKLSAgICAgICAgYmVnaW4oKS0+c2Vjb25kLT5hYm9ydCgpOwotICAgICAg ICByZW1vdmUoYmVnaW4oKSk7Ci0gICAgfQotfQotCi1NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl cjo6TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoRnJhbWUqIGZyYW1lKQotICAgIDogbV9mcmFt ZShmcmFtZSkKLSAgICAsIG1faXNJbkRldGFjaGVkU3RhdGUoZmFsc2UpCi17Ci0gICAgaWYgKCFp c0NsaWVudEF2YWlsYWJsZSgpKQotICAgICAgICBlbnRlckRldGFjaGVkU3RhdGUoKTsKLX0KLQot TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6On5NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigp Ci17Ci19Ci0KLVNlY3VyaXR5T3JpZ2luKiBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c2Vj dXJpdHlPcmlnaW4oKSBjb25zdAotewotICAgIHJldHVybiBtX2ZyYW1lID8gbV9mcmFtZS0+ZXhp c3RpbmdET01XaW5kb3coKS0+c2VjdXJpdHlPcmlnaW4oKSA6IDA7Ci19Ci0KLVNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpzY3JpcHRFeGVjdXRpb25D b250ZXh0KCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSA/IG1fZnJhbWUtPmV4aXN0aW5n RE9NV2luZG93KCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA6IDA7Ci19Ci0KLU1lZGlhU3Ry ZWFtQ29udHJvbGxlciogTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnBhZ2VDb250cm9sbGVy KCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9mcmFtZSAmJiBtX2ZyYW1lLT5wYWdlKCkgPyBtX2Zy YW1lLT5wYWdlKCktPm1lZGlhU3RyZWFtQ29udHJvbGxlcigpIDogMDsKLX0KLQotdm9pZCBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZW50ZXJEZXRhY2hlZFN0YXRlKCkKLXsKLSAgICBpZiAo bV9pc0luRGV0YWNoZWRTdGF0ZSkgewotICAgICAgICBBU1NFUlQobV9yZXF1ZXN0cy5pc0VtcHR5 KCkpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgbV9yZXF1ZXN0cy5hYm9ydEFsbCgp OwotICAgIG1faXNJbkRldGFjaGVkU3RhdGUgPSB0cnVlOwotfQotCi1ib29sIE1lZGlhU3RyZWFt RnJhbWVDb250cm9sbGVyOjppc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0Ci17Ci0gICAgaWYgKG1f aXNJbkRldGFjaGVkU3RhdGUpCi0gICAgICAgIHJldHVybiBmYWxzZTsKLQotICAgIE1lZGlhU3Ry ZWFtQ29udHJvbGxlciogY29udHJvbGxlciA9IHBhZ2VDb250cm9sbGVyKCk7Ci0gICAgcmV0dXJu IGNvbnRyb2xsZXIgJiYgY29udHJvbGxlci0+aXNDbGllbnRBdmFpbGFibGUoKTsKLX0KLQotLy8g Q2FsbGVkIGFsc28gd2hlbiB0aGUgZnJhbWUgaXMgZGV0YWNoZWQgZnJvbSB0aGUgcGFnZSwgaW4g d2hpY2ggY2FzZSB0aGUgcGFnZSBjb250cm9sbGVyIHdpbGwgcmVtYWluIGFsaXZlLgotdm9pZCBN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6ZGlzY29ubmVjdFBhZ2UoKQotewotICAgIGlmIChw YWdlQ29udHJvbGxlcigpKQotICAgICAgICBwYWdlQ29udHJvbGxlcigpLT51bnJlZ2lzdGVyRnJh bWVDb250cm9sbGVyKHRoaXMpOwotCi0gICAgZW50ZXJEZXRhY2hlZFN0YXRlKCk7Ci19Ci0KLS8v IENhbGxlZCB3aGVuIHRoZSBmcmFtZSBpcyBiZWluZyBkZXN0cm95ZWQuIFNpbmNlIHRoZSBmcmFt ZSBjb250cm9sbGVyIGlzIG93bmVkIGJ5IHRoZSBmcmFtZSBpdCB3aWxsIGRpZSBzaG9ydGx5IGFm dGVyIHRoaXMuCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpkaXNjb25uZWN0RnJh bWUoKQotewotICAgIGRpc2Nvbm5lY3RQYWdlKCk7Ci0KLSAgICBBU1NFUlQobV9yZXF1ZXN0cy5p c0VtcHR5KCkpOwotCi0gICAgbV9mcmFtZSA9IDA7Ci19Ci0KLXZvaWQgTWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXI6OnRyYW5zZmVyVG9OZXdQYWdlKFBhZ2UqKQotewotICAgIC8vIEZJWE1FOiBJ biB0aGUgZnV0dXJlIHdlIHNob3VsZCBrZWVwIHJ1bm5pbmcgdGhlIG1lZGlhIHN0cmVhbSBzZXJ2 aWNlcyB3aGlsZSB0cmFuc2ZlcmluZyBmcmFtZXMgYmV0d2VlbiBwYWdlcy4KLSAgICAvLyBIb3dl dmVyLCB1bnRpbCBhIHByb3BlciB3YXkgdG8gZG8gdGhpcyBpcyBkZWNpZGVkLCB3ZSdyZSBzaHV0 dGluZyBkb3duIHNlcnZpY2VzLgotICAgIGRpc2Nvbm5lY3RQYWdlKCk7Ci19Ci0KLUdlbmVyYXRl U3RyZWFtT3B0aW9uRmxhZ3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnBhcnNlR2VuZXJh dGVTdHJlYW1PcHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucykKLXsKLSAgICBHZW5lcmF0ZVN0 cmVhbU9wdGlvbkZsYWdzIGZsYWdzID0gMDsKLSAgICBWZWN0b3I8U3RyaW5nPiBvcHRpb25MaXN0 OwotICAgIG9wdGlvbnMuc3BsaXQoJywnLCBvcHRpb25MaXN0KTsKLQotICAgIGZvciAoVmVjdG9y PFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIG9wdGlvbiA9IG9wdGlvbkxpc3QuYmVnaW4oKTsgb3B0 aW9uICE9IG9wdGlvbkxpc3QuZW5kKCk7ICsrb3B0aW9uKSB7Ci0gICAgICAgIFZlY3RvcjxTdHJp bmc+IHN1Ym9wdGlvbkxpc3Q7Ci0gICAgICAgIG9wdGlvbi0+c3BsaXQoJyAnLCBzdWJvcHRpb25M aXN0KTsKLQotICAgICAgICBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgpID09ICJhdWRpbyIpCi0g ICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RBdWRpbzsKLSAgICAgICAg ZWxzZSBpZiAoc3Vib3B0aW9uTGlzdC5maXJzdCgpID09ICJ2aWRlbyIpIHsKLSAgICAgICAgICAg IGJvb2wgdmlkZW9TdWJvcHRpb25zID0gZmFsc2U7Ci0gICAgICAgICAgICBWZWN0b3I8U3RyaW5n Pjo6Y29uc3RfaXRlcmF0b3Igc3Vib3B0aW9uID0gc3Vib3B0aW9uTGlzdC5iZWdpbigpOwotICAg ICAgICAgICAgZm9yICgrK3N1Ym9wdGlvbjsgc3Vib3B0aW9uICE9IHN1Ym9wdGlvbkxpc3QuZW5k KCk7ICsrc3Vib3B0aW9uKQotICAgICAgICAgICAgICAgIGlmICgqc3Vib3B0aW9uID09ICJ1c2Vy IikgewotICAgICAgICAgICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0cmVhbVJlcXVlc3RW aWRlb0ZhY2luZ1VzZXI7Ci0gICAgICAgICAgICAgICAgICAgIHZpZGVvU3Vib3B0aW9ucyA9IHRy dWU7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIGlmICgqc3Vib3B0aW9uID09ICJlbnZpcm9ubWVu dCIpIHsKLSAgICAgICAgICAgICAgICAgICAgZmxhZ3MgfD0gR2VuZXJhdGVTdHJlYW1SZXF1ZXN0 VmlkZW9GYWNpbmdFbnZpcm9ubWVudDsKLSAgICAgICAgICAgICAgICAgICAgdmlkZW9TdWJvcHRp b25zID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIC8vIEFzayBmb3Ig YWxsIGtpbmQgb2YgY2FtZXJhcyBpZiBubyBzdWJvcHRpb24gd2FzIHNwZWNpZmllZC4KLSAgICAg ICAgICAgIGlmICghdmlkZW9TdWJvcHRpb25zKQotICAgICAgICAgICAgICAgIGZsYWdzIHw9IEdl bmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVvRmFjaW5nVXNlciB8IEdlbmVyYXRlU3RyZWFtUmVxdWVz dFZpZGVvRmFjaW5nRW52aXJvbm1lbnQ7Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAgICByZXR1cm4g ZmxhZ3M7Ci19Ci0KLS8vIEltcGxlbWVudHMgdGhlIGdldFVzZXJNZWRpYSBtZXRob2QgZnJvbSBo dHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNkb20tbmF2 aWdhdG9yLWdldHVzZXJtZWRpYS4KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6Omdl bmVyYXRlU3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0aW9ucywKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlh U3VjY2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVy cm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBFeGNlcHRpb25Db2RlJiBlYykKLXsKLSAgICBlYyA9IDA7Ci0g ICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2spCi0gICAgICAgIHJldHVybjsKLQotICAgIEdlbmVyYXRl U3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MgPSBwYXJzZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhvcHRp b25zKTsKLSAgICBpZiAoIWZsYWdzKSB7Ci0gICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7 Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBpbnQgcmVxdWVzdElkID0gbV9yZXF1ZXN0 cy5nZXROZXh0SWQoKTsKLSAgICBtX3JlcXVlc3RzLmFkZChyZXF1ZXN0SWQsIEdlbmVyYXRlU3Ry ZWFtUmVxdWVzdDo6Y3JlYXRlKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgc3VjY2Vzc0NhbGxi YWNrLCBlcnJvckNhbGxiYWNrKSk7Ci0KLSAgICBpZiAoIWlzQ2xpZW50QXZhaWxhYmxlKCkpIHsK LSAgICAgICAgLy8gVGhpcyBtYWtlcyBzdXJlIHRvIGNhbGwgdGhlIGVycm9yIGNhbGxiYWNrIGlm IHByb3ZpZGVkLgotICAgICAgICBtX3JlcXVlc3RzLmFib3J0KHJlcXVlc3RJZCk7Ci0gICAgICAg IHJldHVybjsKLSAgICB9Ci0KLSAgICBwYWdlQ29udHJvbGxlcigpLT5nZW5lcmF0ZVN0cmVhbSh0 aGlzLCByZXF1ZXN0SWQsIGZsYWdzLCBzZWN1cml0eU9yaWdpbigpKTsKLX0KLQotdm9pZCBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGVkKGludCByZXF1ZXN0SWQsIGNv bnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKQotewotICAgIC8vIERvbid0IGFz c2VydCBzaW5jZSB0aGUgcmVxdWVzdCBjYW4gaGF2ZSBiZWVuIGFib3J0ZWQgYXMgYSByZXN1bHQg b2YgZW1iZWRkZXIgZGV0YWNobWVudC4KLSAgICBpZiAoIW1fcmVxdWVzdHMuY29udGFpbnMocmVx dWVzdElkKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKG1fcmVxdWVzdHMuZ2V0KHJl cXVlc3RJZCktPmlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkpOwotCi0gICAgUmVmUHRyPEdlbmVy YXRlU3RyZWFtUmVxdWVzdD4gc3RyZWFtUmVxdWVzdCA9IHN0YXRpY19jYXN0PEdlbmVyYXRlU3Ry ZWFtUmVxdWVzdCo+KG1fcmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCkuZ2V0KCkpOwotICAgIFJlZlB0 cjxMb2NhbE1lZGlhU3RyZWFtPiBnZW5lcmF0ZWRTdHJlYW0gPSBMb2NhbE1lZGlhU3RyZWFtOjpj cmVhdGUoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCBzb3VyY2VzKTsKLSAgICBtX3JlcXVlc3Rz LnJlbW92ZShyZXF1ZXN0SWQpOwotICAgIHN0cmVhbVJlcXVlc3QtPnN1Y2Nlc3NDYWxsYmFjaygp LT5oYW5kbGVFdmVudChnZW5lcmF0ZWRTdHJlYW0uZ2V0KCkpOwotfQotCi12b2lkIE1lZGlhU3Ry ZWFtRnJhbWVDb250cm9sbGVyOjpzdHJlYW1HZW5lcmF0aW9uRmFpbGVkKGludCByZXF1ZXN0SWQs IE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUgY29kZSkKLXsKLSAgICAvLyBEb24n dCBhc3NlcnQgc2luY2UgdGhlIHJlcXVlc3QgY2FuIGhhdmUgYmVlbiBhYm9ydGVkIGFzIGEgcmVz dWx0IG9mIGVtYmVkZGVyIGRldGFjaG1lbnQuCi0gICAgaWYgKCFtX3JlcXVlc3RzLmNvbnRhaW5z KHJlcXVlc3RJZCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIEFTU0VSVChtX3JlcXVlc3RzLmdl dChyZXF1ZXN0SWQpLT5pc0dlbmVyYXRlU3RyZWFtUmVxdWVzdCgpKTsKLQotICAgIFJlZlB0cjxH ZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IHN0cmVhbVJlcXVlc3QgPSBzdGF0aWNfY2FzdDxHZW5lcmF0 ZVN0cmVhbVJlcXVlc3QqPihtX3JlcXVlc3RzLmdldChyZXF1ZXN0SWQpLmdldCgpKTsKLSAgICBt X3JlcXVlc3RzLnJlbW92ZShyZXF1ZXN0SWQpOwotCi0gICAgaWYgKHN0cmVhbVJlcXVlc3QtPmVy cm9yQ2FsbGJhY2soKSkgewotICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+ IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShjb2RlKTsKLSAgICAgICAg c3RyZWFtUmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygpLT5oYW5kbGVFdmVudChlcnJvci5nZXQoKSk7 Ci0gICAgfQotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUo TUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01l ZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDhjMDkzYTMuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFT dHJlYW1GcmFtZUNvbnRyb2xsZXIuaAorKysgL2Rldi9udWxsCkBAIC0xLDEwNyArMCwwIEBACi0v KgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu Ci0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAg ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF IElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICog RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNF LCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0g KiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyX2gKLSNkZWZp bmUgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXJfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVB TSkKLQotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ2xpZW50LmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJl YW1Tb3VyY2UuaCIKLSNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvci5oIgotI2luY2x1 ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0jaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KLSNpbmNsdWRlIDx3 dGYvTm9uY29weWFibGUuaD4KLSNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+Ci0KLW5h bWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3MgRnJhbWU7Ci1jbGFzcyBNZWRpYVN0cmVhbUNvbnRy b2xsZXI7Ci1jbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrOwotY2xhc3MgTmF2 aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrOwotY2xhc3MgUGFnZTsKLWNsYXNzIFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ7Ci1jbGFzcyBTZWN1cml0eU9yaWdpbjsKLQotdHlwZWRlZiBpbnQg RXhjZXB0aW9uQ29kZTsKLQotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIgewotICAg IFdURl9NQUtFX05PTkNPUFlBQkxFKE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKTsKLXB1Ymxp YzoKLSAgICBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcihGcmFtZSopOwotICAgIHZpcnR1YWwg fk1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKCk7Ci0KLSAgICBTZWN1cml0eU9yaWdpbiogc2Vj dXJpdHlPcmlnaW4oKSBjb25zdDsKLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBzY3JpcHRF eGVjdXRpb25Db250ZXh0KCkgY29uc3Q7Ci0KLSAgICBib29sIGlzQ2xpZW50QXZhaWxhYmxlKCkg Y29uc3Q7Ci0gICAgdm9pZCBkaXNjb25uZWN0UGFnZSgpOwotICAgIHZvaWQgZGlzY29ubmVjdEZy YW1lKCk7Ci0gICAgdm9pZCB0cmFuc2ZlclRvTmV3UGFnZShQYWdlKik7Ci0KLSAgICBzdGF0aWMg R2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBwYXJzZUdlbmVyYXRlU3RyZWFtT3B0aW9ucyhjb25z dCBTdHJpbmcmKTsKLSAgICB2b2lkIGdlbmVyYXRlU3RyZWFtKGNvbnN0IFN0cmluZyYgb3B0aW9u cywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+LCBQYXNzUmVm UHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+LCBFeGNlcHRpb25Db2RlJik7Ci0K LSAgICAvLyAtLS0gQ2FsbHMgY29taW5nIGJhY2sgZnJvbSB0aGUgY29udHJvbGxlci4gLS0tIC8v Ci0KLSAgICB2b2lkIHN0cmVhbUdlbmVyYXRlZChpbnQgcmVxdWVzdElkLCBjb25zdCBNZWRpYVN0 cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcyk7Ci0gICAgdm9pZCBzdHJlYW1HZW5lcmF0aW9uRmFp bGVkKGludCByZXF1ZXN0SWQsIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpFcnJvckNvZGUpOwot Ci1wcml2YXRlOgotICAgIGNsYXNzIFJlcXVlc3Q7Ci0gICAgY2xhc3MgR2VuZXJhdGVTdHJlYW1S ZXF1ZXN0OwotCi0gICAgY2xhc3MgSWRHZW5lcmF0b3IgewotICAgICAgICBXVEZfTUFLRV9OT05D T1BZQUJMRShJZEdlbmVyYXRvcik7Ci0gICAgcHVibGljOgotICAgICAgICBJZEdlbmVyYXRvcigp IDogbV9pZCgwKSB7IH0KLSAgICAgICAgaW50IGdldE5leHRJZCgpIHsgcmV0dXJuICsrbV9pZDsg fQotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgaW50IG1faWQ7Ci0gICAgfTsKLQotICAgIGNsYXNz IFJlcXVlc3RNYXAgOiBwdWJsaWMgSWRHZW5lcmF0b3IsIHB1YmxpYyBIYXNoTWFwPGludCwgUmVm UHRyPFJlcXVlc3Q+ID4gewotICAgIHB1YmxpYzoKLSAgICAgICAgdm9pZCBhYm9ydChpbnQgcmVx dWVzdElkKTsKLSAgICAgICAgdm9pZCBhYm9ydEFsbCgpOwotICAgIH07Ci0KLSAgICAvLyBEZXRh Y2hlZCBmcm9tIGEgcGFnZSwgYW5kIGhlbmNlIGZyb20gYSBlbWJlZGRlciBjbGllbnQuCi0gICAg dm9pZCBlbnRlckRldGFjaGVkU3RhdGUoKTsKLQotICAgIE1lZGlhU3RyZWFtQ29udHJvbGxlciog cGFnZUNvbnRyb2xsZXIoKSBjb25zdDsKLQotICAgIFJlcXVlc3RNYXAgbV9yZXF1ZXN0czsKLQot ICAgIEZyYW1lKiBtX2ZyYW1lOwotICAgIGJvb2wgbV9pc0luRGV0YWNoZWRTdGF0ZTsKLX07Ci0K LX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0p Ci0KLSNlbmRpZiAvLyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcl9oCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaCBiL1NvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjc2MDUzMWYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9t ZWRpYXN0cmVhbS9Vc2VyTWVkaWFDbGllbnQuaApAQCAtMCwwICsxLDU0IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiAgICBpbiB0aGUgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiAgICBk aXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBuYW1lIG9mIEVyaWNzc29uIG5vciB0aGUg bmFtZXMgb2YgaXRzIGNvbnRyaWJ1dG9ycworICogICAgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBv ciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzCisgKiAgICBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5k ZWYgVXNlck1lZGlhQ2xpZW50X2gKKyNkZWZpbmUgVXNlck1lZGlhQ2xpZW50X2gKKworI2lmIEVO QUJMRShNRURJQV9TVFJFQU0pCisKKyNpbmNsdWRlICJVc2VyTWVkaWFSZXF1ZXN0LmgiCisjaW5j bHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xh c3MgVXNlck1lZGlhQ2xpZW50IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFVz ZXJNZWRpYShQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+LCBjb25zdCBNZWRpYVN0cmVhbVNv dXJjZVZlY3RvciYpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsVXNlck1lZGlhUmVxdWVz dChVc2VyTWVkaWFSZXF1ZXN0KikgPSAwOworCitwcm90ZWN0ZWQ6CisgICAgdmlydHVhbCB+VXNl ck1lZGlhQ2xpZW50KCkgeyB9Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRp ZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQorCisjZW5kaWYgLy8gVXNlck1lZGlhQ2xpZW50X2gK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3Qu Y3BwIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzRjZjg3MAotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwCkBAIC0w LDAgKzEsMTMyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVyaWNzc29uIEFCLiBBbGwg 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 Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShNRURJ QV9TVFJFQU0pCisKKyNpbmNsdWRlICJVc2VyTWVkaWFSZXF1ZXN0LmgiCisKKyNpbmNsdWRlICJM b2NhbE1lZGlhU3RyZWFtLmgiCisjaW5jbHVkZSAiU3BhY2VTcGxpdFN0cmluZy5oIgorI2luY2x1 ZGUgIlVzZXJNZWRpYUNsaWVudC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQ dHI8VXNlck1lZGlhUmVxdWVzdD4gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIGNvbnRleHQsIFVzZXJNZWRpYUNsaWVudCogY2xpZW50LCBjb25zdCBTdHJp bmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNr PiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxs YmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gcmVx dWVzdCA9IGFkb3B0UmVmKG5ldyBVc2VyTWVkaWFSZXF1ZXN0KGNvbnRleHQsIGNsaWVudCwgb3B0 aW9ucywgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKSk7CisgICAgaWYgKCFyZXF1ZXN0 LT5hdWRpbygpICYmICFyZXF1ZXN0LT52aWRlbygpKQorICAgICAgICByZXR1cm4gMDsKKworICAg IHJldHVybiByZXF1ZXN0LnJlbGVhc2UoKTsKK30KKworVXNlck1lZGlhUmVxdWVzdDo6VXNlck1l ZGlhUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDbGll bnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVz ZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPE5hdmln YXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spCisgICAgOiBDb250ZXh0 RGVzdHJ1Y3Rpb25PYnNlcnZlcihjb250ZXh0KQorICAgICwgbV9hdWRpbyhmYWxzZSkKKyAgICAs IG1fdmlkZW8oZmFsc2UpCisgICAgLCBtX2NhbWVyYVByZWZlcmVuY2VVc2VyKGZhbHNlKQorICAg ICwgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQoZmFsc2UpCisgICAgLCBtX2NsaWVudChj bGllbnQpCisgICAgLCBtX3N1Y2Nlc3NDYWxsYmFjayhzdWNjZXNzQ2FsbGJhY2spCisgICAgLCBt X2Vycm9yQ2FsbGJhY2soZXJyb3JDYWxsYmFjaykKK3sKKyAgICBwYXJzZU9wdGlvbnMob3B0aW9u cyk7Cit9CisKK1VzZXJNZWRpYVJlcXVlc3Q6On5Vc2VyTWVkaWFSZXF1ZXN0KCkKK3sKK30KKwor dm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpzdGFydCgpCit7CisgICAgLy8gRklYTUU6IHF1ZXJ5IHRo ZSBwbGF0Zm9ybSBmb3IgYXZhaWxhYmxlIG1lZGlhIHN0cmVhbSBzb3VyY2VzLCBzZWUgaHR0cDov L3dlYmtpdC5vcmcvYi83MDg5NQorfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6Om1lZGlhU3Ry ZWFtU291cmNlc1F1ZXJ5Q29tcGxldGVkKGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBz b3VyY2VzKQoreworICAgIGlmIChtX2NsaWVudCkKKyAgICAgICAgbV9jbGllbnQtPnJlcXVlc3RV c2VyTWVkaWEodGhpcywgc291cmNlcyk7Cit9CisKK3ZvaWQgVXNlck1lZGlhUmVxdWVzdDo6c3Vj Y2VlZChjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNlcykKK3sKKyAgICBpZiAo IW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVmUHRy PExvY2FsTWVkaWFTdHJlYW0+IHN0cmVhbSA9IExvY2FsTWVkaWFTdHJlYW06OmNyZWF0ZShtX3Nj cmlwdEV4ZWN1dGlvbkNvbnRleHQsIHNvdXJjZXMpOworICAgIG1fc3VjY2Vzc0NhbGxiYWNrLT5o YW5kbGVFdmVudChzdHJlYW0uZ2V0KCkpOworfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OmZh aWwoKQoreworICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0KQorICAgICAgICByZXR1 cm47CisKKyAgICBpZiAobV9lcnJvckNhbGxiYWNrKSB7CisgICAgICAgIFJlZlB0cjxOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRl KE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpQRVJNSVNTSU9OX0RFTklFRCk7CisgICAgICAgIG1f ZXJyb3JDYWxsYmFjay0+aGFuZGxlRXZlbnQoZXJyb3IuZ2V0KCkpOworICAgIH0KK30KKwordm9p ZCBVc2VyTWVkaWFSZXF1ZXN0Ojpjb250ZXh0RGVzdHJveWVkKCkKK3sKKyAgICBpZiAobV9jbGll bnQpIHsKKyAgICAgICAgbV9jbGllbnQtPmNhbmNlbFVzZXJNZWRpYVJlcXVlc3QodGhpcyk7Cisg ICAgICAgIG1fY2xpZW50ID0gMDsKKyAgICB9CisKKyAgICBDb250ZXh0RGVzdHJ1Y3Rpb25PYnNl cnZlcjo6Y29udGV4dERlc3Ryb3llZCgpOworfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OnBh cnNlT3B0aW9ucyhjb25zdCBTdHJpbmcmIG9wdGlvbnMpCit7CisgICAgVmVjdG9yPFN0cmluZz4g b3B0aW9uc0xpc3Q7CisgICAgb3B0aW9ucy5zcGxpdCgiLCIsIG9wdGlvbnNMaXN0KTsKKworICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgb3B0aW9uc0xpc3Quc2l6ZSgpOyArK2kpIHsKKyAgICAg ICAgU3BhY2VTcGxpdFN0cmluZyBzdWJPcHRpb25zKG9wdGlvbnNMaXN0W2ldLCBmYWxzZSk7CisK KyAgICAgICAgaWYgKHN1Yk9wdGlvbnNbMF0gPT0gImF1ZGlvIikKKyAgICAgICAgICAgIG1fYXVk aW8gPSB0cnVlOworICAgICAgICBlbHNlIGlmIChzdWJPcHRpb25zWzBdID09ICJ2aWRlbyIpIHsK KyAgICAgICAgICAgIG1fdmlkZW8gPSB0cnVlOworICAgICAgICAgICAgaWYgKHN1Yk9wdGlvbnMu Y29udGFpbnMoInVzZXIiKSkKKyAgICAgICAgICAgICAgICBtX2NhbWVyYVByZWZlcmVuY2VVc2Vy ID0gdHJ1ZTsKKyAgICAgICAgICAgIGlmIChzdWJPcHRpb25zLmNvbnRhaW5zKCJlbnZpcm9ubWVu dCIpKQorICAgICAgICAgICAgICAgIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50ID0gdHJ1 ZTsKKyAgICAgICAgfQorICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21l ZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuaCBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFt L1VzZXJNZWRpYVJlcXVlc3QuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4x MDliZDQ3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNl ck1lZGlhUmVxdWVzdC5oCkBAIC0wLDAgKzEsOTIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw 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 SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBVc2VyTWVkaWFS ZXF1ZXN0X2gKKyNkZWZpbmUgVXNlck1lZGlhUmVxdWVzdF9oCisKKyNpZiBFTkFCTEUoTUVESUFf U1RSRUFNKQorCisjaW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCisjaW5jbHVkZSAiTWVkaWFT dHJlYW1Tb3VyY2UuaCIKKyNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNr LmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCisjaW5j bHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2Ns YXNzIFVzZXJNZWRpYUNsaWVudDsKKworY2xhc3MgVXNlck1lZGlhUmVxdWVzdCA6IHB1YmxpYyBS ZWZDb3VudGVkPFVzZXJNZWRpYVJlcXVlc3Q+LCBwdWJsaWMgQ29udGV4dERlc3RydWN0aW9uT2Jz ZXJ2ZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+ IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgVXNlck1lZGlhQ2xpZW50KiwgY29uc3Qg U3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxs YmFjaz4sIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4pOworICAg IH5Vc2VyTWVkaWFSZXF1ZXN0KCk7CisKKyAgICBib29sIGF1ZGlvKCkgY29uc3QgeyByZXR1cm4g bV9hdWRpbzsgfQorICAgIGJvb2wgdmlkZW8oKSBjb25zdCB7IHJldHVybiBtX3ZpZGVvOyB9CisK KyAgICBib29sIGNhbWVyYVByZWZlcmVuY2VVc2VyKCkgY29uc3QgeyByZXR1cm4gbV9jYW1lcmFQ cmVmZXJlbmNlVXNlcjsgfQorICAgIGJvb2wgY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KCkg Y29uc3QgeyByZXR1cm4gbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQ7IH0KKworICAgIE5h dmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjayogc3VjY2Vzc0NhbGxiYWNrKCkgY29uc3Qg eyByZXR1cm4gbV9zdWNjZXNzQ2FsbGJhY2suZ2V0KCk7IH0KKyAgICBOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrKiBlcnJvckNhbGxiYWNrKCkgY29uc3QgeyByZXR1cm4gbV9lcnJvckNh bGxiYWNrLmdldCgpOyB9CisKKyAgICB2b2lkIHN0YXJ0KCk7CisgICAgdm9pZCBtZWRpYVN0cmVh bVNvdXJjZXNRdWVyeUNvbXBsZXRlZChjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYpOwor CisgICAgdm9pZCBzdWNjZWVkKGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJik7CisgICAg dm9pZCBmYWlsKCk7CisKKyAgICAvLyBDb250ZXh0RGVzdHJ1Y3Rpb25PYnNlcnZlcgorICAgIHZp cnR1YWwgdm9pZCBjb250ZXh0RGVzdHJveWVkKCk7CisKK3ByaXZhdGU6CisgICAgVXNlck1lZGlh UmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgVXNlck1lZGlhQ2xpZW50KiwgY29uc3Qg U3RyaW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxs YmFjaz4sIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4pOworCisg ICAgdm9pZCBwYXJzZU9wdGlvbnMoY29uc3QgU3RyaW5nJiBvcHRpb25zKTsKKworICAgIGJvb2wg bV9hdWRpbzsKKyAgICBib29sIG1fdmlkZW87CisKKyAgICBib29sIG1fY2FtZXJhUHJlZmVyZW5j ZVVzZXI7CisgICAgYm9vbCBtX2NhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudDsKKworICAgIFVz ZXJNZWRpYUNsaWVudCogbV9jbGllbnQ7CisKKyAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlh U3VjY2Vzc0NhbGxiYWNrPiBtX3N1Y2Nlc3NDYWxsYmFjazsKKyAgICBSZWZQdHI8TmF2aWdhdG9y VXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gbV9lcnJvckNhbGxiYWNrOworfTsKKworfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlm IC8vIFVzZXJNZWRpYVJlcXVlc3RfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9D YWxsYmFja1Rhc2suaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2FsbGJhY2tUYXNrLmgKZGVsZXRl ZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVkMDBkMzEuLjAwMDAwMDAKLS0tIGEvU291cmNlL1dl YkNvcmUvcGFnZS9DYWxsYmFja1Rhc2suaAorKysgL2Rldi9udWxsCkBAIC0xLDgxICswLDAgQEAK LS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuICBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAq ICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCi0g KiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwotICogTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAotICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMK LSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgotICovCi0KLSNpZm5kZWYgQ2FsbGJhY2tUYXNrX2gKLSNkZWZpbmUgQ2FsbGJhY2tU YXNrX2gKLQotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlICJTY3JpcHRFeGVj dXRpb25Db250ZXh0LmgiCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNsdWRlIDx3dGYv UGFzc1JlZlB0ci5oPgotI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KLQotbmFtZXNwYWNlIFdlYkNv cmUgewotCi0vLyBIZWxwZXIgdGVtcGxhdGUgdG8gc2NoZWR1bGUgY2FsbHMgdG8gY2FsbGJhY2tz IHVzaW5nIHRoZWlyIG93biBzY3JpcHQgZXhlY3V0aW9uIGNvbnRleHQuCi0vLyBDYWxsYmFja1R5 cGUgaXMgYXNzdW1lZCB0byBpbXBsZW1lbnQgU2NoZWR1bGVyIGFuZCB0byBiZSByZWZlcmVuY2Ut Y291bnRlZC4KLXRlbXBsYXRlIDx0eXBlbmFtZSBDYWxsYmFja1R5cGUsIHR5cGVuYW1lIEFyZ3Vt ZW50VHlwZT4KLWNsYXNzIENhbGxiYWNrVGFzazEgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzayB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NPd25QdHI8Q2FsbGJhY2tUYXNr MT4gY3JlYXRlKFBhc3NSZWZQdHI8Q2FsbGJhY2tUeXBlPiBjYWxsYmFjaywgUGFzc1JlZlB0cjxB cmd1bWVudFR5cGU+IGRhdGEpCi0gICAgewotICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IENh bGxiYWNrVGFzazEoY2FsbGJhY2ssIGRhdGEpKTsKLSAgICB9Ci0KLSAgICB2aXJ0dWFsIHZvaWQg cGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopCi0gICAgewotICAgICAgICBtX2Nh bGxiYWNrLT5oYW5kbGVFdmVudChtX2RhdGEuZ2V0KCkpOwotICAgIH0KLQotICAgIGNsYXNzIFNj aGVkdWxlciB7Ci0gICAgcHVibGljOgotICAgICAgICB2aXJ0dWFsIH5TY2hlZHVsZXIoKSB7IH0K LQotICAgICAgICBib29sIHNjaGVkdWxlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgUGFzc1JlZlB0cjxBcmd1bWVudFR5cGU+IGRhdGEpCi0gICAgICAgIHsKLSAgICAg ICAgICAgIGlmIChjb250ZXh0KSB7Ci0gICAgICAgICAgICAgICAgY29udGV4dC0+cG9zdFRhc2so Q2FsbGJhY2tUYXNrMTxDYWxsYmFja1R5cGUsIEFyZ3VtZW50VHlwZT46OmNyZWF0ZShzdGF0aWNf Y2FzdDxDYWxsYmFja1R5cGUqPih0aGlzKSwgZGF0YSkpOwotICAgICAgICAgICAgICAgIHJldHVy biB0cnVlOwotICAgICAgICAgICAgfQotICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAg ICB9Ci0gICAgfTsKLQotcHJpdmF0ZToKLSAgICBDYWxsYmFja1Rhc2sxKFBhc3NSZWZQdHI8Q2Fs bGJhY2tUeXBlPiBjYWxsYmFjaywgUGFzc1JlZlB0cjxBcmd1bWVudFR5cGU+IGRhdGEpCi0gICAg ICAgIDogbV9jYWxsYmFjayhjYWxsYmFjaykKLSAgICAgICAgLCBtX2RhdGEoZGF0YSkKLSAgICB7 Ci0gICAgfQotCi0gICAgUmVmUHRyPENhbGxiYWNrVHlwZT4gbV9jYWxsYmFjazsKLSAgICBSZWZQ dHI8QXJndW1lbnRUeXBlPiBtX2RhdGE7Ci19OwotCi19Ci0KLSNlbmRpZiAvLyBFTkFCTEUoTUVE SUFfU1RSRUFNKQotCi0jZW5kaWYgLy8gQ2FsbGJhY2tUYXNrX2gKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5jcHAK aW5kZXggZTM1M2I0OS4uODM2OTFhYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9G cmFtZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5jcHAKQEAgLTExMSwxMCAr MTExLDYgQEAKICNpbmNsdWRlICJTVkdEb2N1bWVudEV4dGVuc2lvbnMuaCIKICNlbmRpZgogCi0j aWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlci5oIgotI2VuZGlmCi0KICNpZiBVU0UoVElMRURfQkFDS0lOR19TVE9SRSkKICNpbmNsdWRl ICJUaWxlZEJhY2tpbmdTdG9yZS5oIgogI2VuZGlmCkBAIC0xNjksOSArMTY1LDYgQEAgaW5saW5l IEZyYW1lOjpGcmFtZShQYWdlKiBwYWdlLCBIVE1MRnJhbWVPd25lckVsZW1lbnQqIG93bmVyRWxl bWVudCwgRnJhbWVMb2FkZXIKICAgICAsIG1faW5WaWV3U291cmNlTW9kZShmYWxzZSkKICAgICAs IG1faXNEaXNjb25uZWN0ZWQoZmFsc2UpCiAgICAgLCBtX2V4Y2x1ZGVGcm9tVGV4dFNlYXJjaChm YWxzZSkKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICwgbV9tZWRpYVN0cmVhbUZyYW1l Q29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjptZWRpYVN0cmVhbUVuYWJsZWQoKSA/ IGFkb3B0UHRyKG5ldyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcih0aGlzKSkgOiBQYXNzT3du UHRyPE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyPigpKQotI2VuZGlmCiB7CiAgICAgQVNTRVJU KHBhZ2UpOwogICAgIEF0b21pY1N0cmluZzo6aW5pdCgpOwpAQCAtMjI4LDExICsyMjEsNiBAQCBG cmFtZTo6fkZyYW1lKCkKICAgICBpZiAobV9kb21XaW5kb3cpCiAgICAgICAgIG1fZG9tV2luZG93 LT5kaXNjb25uZWN0RnJhbWUoKTsKIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgaWYg KG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIpCi0gICAgICAgIG1fbWVkaWFTdHJlYW1GcmFt ZUNvbnRyb2xsZXItPmRpc2Nvbm5lY3RGcmFtZSgpOwotI2VuZGlmCi0KICAgICBIYXNoU2V0PERP TVdpbmRvdyo+OjppdGVyYXRvciBlbmQgPSBtX2xpdmVGb3JtZXJXaW5kb3dzLmVuZCgpOwogICAg IGZvciAoSGFzaFNldDxET01XaW5kb3cqPjo6aXRlcmF0b3IgaXQgPSBtX2xpdmVGb3JtZXJXaW5k b3dzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKICAgICAgICAgKCppdCktPmRpc2Nvbm5lY3RG cmFtZSgpOwpAQCAtNjk4LDExICs2ODYsNiBAQCB2b2lkIEZyYW1lOjpwYWdlRGVzdHJveWVkKCkK ICAgICAgICAgbV9kb21XaW5kb3ctPnBhZ2VEZXN0cm95ZWQoKTsKICAgICB9CiAKLSNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQotICAgIGlmIChtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKQot ICAgICAgICBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLT5kaXNjb25uZWN0UGFnZSgpOwot I2VuZGlmCi0KICAgICAvLyBGSVhNRTogSXQncyB1bmNsZWFyIGFzIHRvIHdoeSB0aGlzIGlzIGNh bGxlZCBtb3JlIHRoYW4gb25jZSwgYnV0IGl0IGlzLAogICAgIC8vIHNvIHBhZ2UoKSBjb3VsZCBi ZSBOVUxMLgogICAgIGlmIChwYWdlKCkgJiYgcGFnZSgpLT5mb2N1c0NvbnRyb2xsZXIoKS0+Zm9j dXNlZEZyYW1lKCkgPT0gdGhpcykKQEAgLTc1NiwxMCArNzM5LDYgQEAgdm9pZCBGcmFtZTo6dHJh bnNmZXJDaGlsZEZyYW1lVG9OZXdEb2N1bWVudCgpCiAjZW5kaWYKICAgICAgICAgfQogCi0jaWYg RU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAgICAgaWYgKG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIpCi0gICAgICAgICAgICBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLT50cmFuc2Zl clRvTmV3UGFnZShuZXdQYWdlKTsKLSNlbmRpZgogICAgICAgICBtX3BhZ2UgPSBuZXdQYWdlOwog CiAgICAgICAgIGlmIChuZXdQYWdlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9G cmFtZS5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZS5oCmluZGV4IDljZTNhZWMuLmU0ZjU4 ODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0ZyYW1lLmgKQEAgLTY1LDcgKzY1LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgIGNsYXNzIERvY3VtZW50OwogICAgIGNsYXNzIEZyYW1lVmlldzsKICAgICBjbGFzcyBI VE1MVGFibGVDZWxsRWxlbWVudDsKLSAgICBjbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl cjsKICAgICBjbGFzcyBSZWd1bGFyRXhwcmVzc2lvbjsKICAgICBjbGFzcyBSZW5kZXJQYXJ0Owog ICAgIGNsYXNzIFRpbGVkQmFja2luZ1N0b3JlOwpAQCAtMjAxLDEwICsyMDAsNiBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgICAgIE5TSW1hZ2UqIGltYWdlRnJvbVJlY3QoTlNSZWN0KSBjb25z dDsKICNlbmRpZgogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAgICAgTWVkaWFTdHJl YW1GcmFtZUNvbnRyb2xsZXIqIG1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKCkgY29uc3QgeyBy ZXR1cm4gbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5nZXQoKTsgfQotI2VuZGlmCi0gICAg ICAgIAogICAgICAgICAvLyBTaG91bGQgb25seSBiZSBjYWxsZWQgb24gdGhlIG1haW4gZnJhbWUg b2YgYSBwYWdlLgogICAgICAgICB2b2lkIG5vdGlmeUNocm9tZUNsaWVudFdoZWVsRXZlbnRIYW5k bGVyQ291bnRDaGFuZ2VkKCkgY29uc3Q7CiAKQEAgLTI2Niw5ICsyNjEsNiBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIE93blB0cjxUaWxlZEJhY2tpbmdTdG9yZT4gbV90aWxlZEJhY2tp bmdTdG9yZTsKICNlbmRpZgogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAgICAgT3du UHRyPE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyPiBtX21lZGlhU3RyZWFtRnJhbWVDb250cm9s bGVyOwotI2VuZGlmCiAgICAgfTsKIAogICAgIGlubGluZSB2b2lkIEZyYW1lOjppbml0KCkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvTmF2aWdhdG9yLmNwcAppbmRleCBjY2ZiZmI5Li4wYTA3NTZkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGFnZS9OYXZpZ2F0b3IuY3BwCkBAIC00Niw5ICs0Niw5IEBACiAjaW5jbHVkZSA8d3RmL1N0ZExp YkV4dHJhcy5oPgogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNpbmNsdWRlICJNZWRpYVN0 cmVhbUZyYW1lQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9y Q2FsbGJhY2suaCIKICNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2su aCIKKyNpbmNsdWRlICJVc2VyTWVkaWFSZXF1ZXN0LmgiCiAjZW5kaWYKIAogbmFtZXNwYWNlIFdl YkNvcmUgewpAQCAtMjg0LDggKzI4NCwyNyBAQCB2b2lkIE5hdmlnYXRvcjo6cmVnaXN0ZXJQcm90 b2NvbEhhbmRsZXIoY29uc3QgU3RyaW5nJiBzY2hlbWUsIGNvbnN0IFN0cmluZyYgdXJsLAogI2lm IEVOQUJMRShNRURJQV9TVFJFQU0pCiB2b2lkIE5hdmlnYXRvcjo6d2Via2l0R2V0VXNlck1lZGlh KGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNj ZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKLSAg ICBpZiAobV9mcmFtZSAmJiBtX2ZyYW1lLT5tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigpKQot ICAgICAgICBtX2ZyYW1lLT5tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigpLT5nZW5lcmF0ZVN0 cmVhbShvcHRpb25zLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGVjKTsKKyAgICBp ZiAoIXN1Y2Nlc3NDYWxsYmFjaykKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2ZyYW1l KQorICAgICAgICByZXR1cm47CisKKyAgICBQYWdlKiBwYWdlID0gbV9mcmFtZS0+cGFnZSgpOwor ICAgIGlmICghcGFnZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgVXNlck1lZGlhQ2xpZW50KiBj bGllbnQgPSBwYWdlLT51c2VyTWVkaWFDbGllbnQoKTsKKyAgICBpZiAoIWNsaWVudCkKKyAgICAg ICAgcmV0dXJuOworCisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVlc3QgPSBVc2Vy TWVkaWFSZXF1ZXN0OjpjcmVhdGUobV9mcmFtZS0+ZG9jdW1lbnQoKSwgY2xpZW50LCBvcHRpb25z LCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spOworICAgIGlmICghcmVxdWVzdCkgewor ICAgICAgICBlYyA9IE5PVF9TVVBQT1JURURfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgcmVxdWVzdC0+c3RhcnQoKTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL05hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2suaCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oCmluZGV4IDE1Mzk3 MDkuLmRkM2M4YjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9y VXNlck1lZGlhRXJyb3JDYWxsYmFjay5oCkBAIC0yNywxNCArMjcsMTIgQEAKIAogI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCiAKLSNpbmNsdWRlICJDYWxsYmFja1Rhc2suaCIKICNpbmNsdWRlICJO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvci5oIgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotY2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxs YmFjayA6IHB1YmxpYyBSZWZDb3VudGVkPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+ LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHB1YmxpYyBDYWxsYmFj a1Rhc2sxPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2ssIE5hdmlnYXRvclVzZXJNZWRp YUVycm9yPjo6U2NoZWR1bGVyIHsKK2NsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJh Y2sgOiBwdWJsaWMgUmVmQ291bnRlZDxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiB7 CiBwdWJsaWM6CiAgICAgdmlydHVhbCB+TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaygp IHsgfQogICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVFdmVudChOYXZpZ2F0b3JVc2VyTWVkaWFFcnJv ciopID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCmluZGV4IDg2OTU1OTEuLmE1ODhhMzAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9QYWdlLmNwcApAQCAtNzksMTEgKzc5LDYgQEAKICNpbmNsdWRlICJHZW9sb2NhdGlvbkNvbnRy b2xsZXIuaCIKICNlbmRpZgogCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSNpbmNsdWRlICJN ZWRpYVN0cmVhbUNsaWVudC5oIgotI2luY2x1ZGUgIk1lZGlhU3RyZWFtQ29udHJvbGxlci5oIgot I2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIEhhc2hTZXQ8UGFnZSo+KiBh bGxQYWdlczsKQEAgLTEzNywxMiArMTMyLDEyIEBAIFBhZ2U6OlBhZ2UoUGFnZUNsaWVudHMmIHBh Z2VDbGllbnRzKQogICAgICwgbV9kZXZpY2VNb3Rpb25Db250cm9sbGVyKFJ1bnRpbWVFbmFibGVk RmVhdHVyZXM6OmRldmljZU1vdGlvbkVuYWJsZWQoKSA/IGFkb3B0UHRyKG5ldyBEZXZpY2VNb3Rp b25Db250cm9sbGVyKHBhZ2VDbGllbnRzLmRldmljZU1vdGlvbkNsaWVudCkpIDogbnVsbHB0cikK ICAgICAsIG1fZGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVy ZXM6OmRldmljZU9yaWVudGF0aW9uRW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IERldmljZU9yaWVu dGF0aW9uQ29udHJvbGxlcih0aGlzLCBwYWdlQ2xpZW50cy5kZXZpY2VPcmllbnRhdGlvbkNsaWVu dCkpIDogbnVsbHB0cikKICNlbmRpZgotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgLCBt X21lZGlhU3RyZWFtQ29udHJvbGxlcihSdW50aW1lRW5hYmxlZEZlYXR1cmVzOjptZWRpYVN0cmVh bUVuYWJsZWQoKSA/IGFkb3B0UHRyKG5ldyBNZWRpYVN0cmVhbUNvbnRyb2xsZXIocGFnZUNsaWVu dHMubWVkaWFTdHJlYW1DbGllbnQpKSA6IFBhc3NPd25QdHI8TWVkaWFTdHJlYW1Db250cm9sbGVy PigpKQotI2VuZGlmCiAjaWYgRU5BQkxFKElOUFVUX1NQRUVDSCkKICAgICAsIG1fc3BlZWNoSW5w dXRDbGllbnQocGFnZUNsaWVudHMuc3BlZWNoSW5wdXRDbGllbnQpCiAjZW5kaWYKKyNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQorICAgICwgbV91c2VyTWVkaWFDbGllbnQocGFnZUNsaWVudHMudXNl ck1lZGlhQ2xpZW50KQorI2VuZGlmCiAgICAgLCBtX3NldHRpbmdzKGFkb3B0UHRyKG5ldyBTZXR0 aW5ncyh0aGlzKSkpCiAgICAgLCBtX3Byb2dyZXNzKGFkb3B0UHRyKG5ldyBQcm9ncmVzc1RyYWNr ZXIpKQogICAgICwgbV9iYWNrRm9yd2FyZENvbnRyb2xsZXIoYWRvcHRQdHIobmV3IEJhY2tGb3J3 YXJkQ29udHJvbGxlcih0aGlzLCBwYWdlQ2xpZW50cy5iYWNrRm9yd2FyZENsaWVudCkpKQpAQCAt MTA0Miw3ICsxMDM3LDcgQEAgUGFnZTo6UGFnZUNsaWVudHM6OlBhZ2VDbGllbnRzKCkKICAgICAs IGRldmljZU1vdGlvbkNsaWVudCgwKQogICAgICwgZGV2aWNlT3JpZW50YXRpb25DbGllbnQoMCkK ICAgICAsIHNwZWVjaElucHV0Q2xpZW50KDApCi0gICAgLCBtZWRpYVN0cmVhbUNsaWVudCgwKQor ICAgICwgdXNlck1lZGlhQ2xpZW50KDApCiB7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BhZ2UvUGFnZS5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmgKaW5kZXggNGE3NDQ4 ZC4uMDI1ZTEwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmgKQEAgLTcxLDggKzcxLDYgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgIGNsYXNzIEluc3BlY3RvckNsaWVudDsKICAgICBjbGFzcyBJbnNwZWN0b3JD b250cm9sbGVyOwogICAgIGNsYXNzIE1lZGlhQ2FuU3RhcnRMaXN0ZW5lcjsKLSAgICBjbGFzcyBN ZWRpYVN0cmVhbUNsaWVudDsKLSAgICBjbGFzcyBNZWRpYVN0cmVhbUNvbnRyb2xsZXI7CiAgICAg Y2xhc3MgTm9kZTsKICAgICBjbGFzcyBQYWdlR3JvdXA7CiAgICAgY2xhc3MgUGx1Z2luRGF0YTsK QEAgLTg0LDYgKzgyLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIFNldHRpbmdz OwogICAgIGNsYXNzIFNwZWVjaElucHV0OwogICAgIGNsYXNzIFNwZWVjaElucHV0Q2xpZW50Owor ICAgIGNsYXNzIFVzZXJNZWRpYUNsaWVudDsKICAgICBjbGFzcyBTdG9yYWdlTmFtZXNwYWNlOwog I2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQogICAgIGNsYXNzIE5vdGlmaWNhdGlvblByZXNlbnRl cjsKQEAgLTExOCw3ICsxMTcsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICBE ZXZpY2VPcmllbnRhdGlvbkNsaWVudCogZGV2aWNlT3JpZW50YXRpb25DbGllbnQ7CiAgICAgICAg ICAgICBSZWZQdHI8QmFja0ZvcndhcmRMaXN0PiBiYWNrRm9yd2FyZENsaWVudDsKICAgICAgICAg ICAgIFNwZWVjaElucHV0Q2xpZW50KiBzcGVlY2hJbnB1dENsaWVudDsKLSAgICAgICAgICAgIE1l ZGlhU3RyZWFtQ2xpZW50KiBtZWRpYVN0cmVhbUNsaWVudDsKKyAgICAgICAgICAgIFVzZXJNZWRp YUNsaWVudCogdXNlck1lZGlhQ2xpZW50OwogICAgICAgICB9OwogCiAgICAgICAgIFBhZ2UoUGFn ZUNsaWVudHMmKTsKQEAgLTE4NCwxMiArMTgzLDEyIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgRGV2aWNlTW90aW9uQ29udHJvbGxlciogZGV2aWNlTW90aW9uQ29udHJvbGxlcigpIGNv bnN0IHsgcmV0dXJuIG1fZGV2aWNlTW90aW9uQ29udHJvbGxlci5nZXQoKTsgfQogICAgICAgICBE ZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIqIGRldmljZU9yaWVudGF0aW9uQ29udHJvbGxlcigp IGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyLmdldCgpOyB9CiAj ZW5kaWYKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgICAgICBNZWRpYVN0cmVhbUNvbnRy b2xsZXIqIG1lZGlhU3RyZWFtQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJuIG1fbWVkaWFTdHJl YW1Db250cm9sbGVyLmdldCgpOyB9Ci0jZW5kaWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNIKQog ICAgICAgICBTcGVlY2hJbnB1dCogc3BlZWNoSW5wdXQoKTsKICNlbmRpZgorI2lmIEVOQUJMRShN RURJQV9TVFJFQU0pCisgICAgICAgIFVzZXJNZWRpYUNsaWVudCogdXNlck1lZGlhQ2xpZW50KCkg Y29uc3QgeyByZXR1cm4gbV91c2VyTWVkaWFDbGllbnQ7IH0KKyNlbmRpZgogICAgICAgICBTZXR0 aW5ncyogc2V0dGluZ3MoKSBjb25zdCB7IHJldHVybiBtX3NldHRpbmdzLmdldCgpOyB9CiAgICAg ICAgIFByb2dyZXNzVHJhY2tlciogcHJvZ3Jlc3MoKSBjb25zdCB7IHJldHVybiBtX3Byb2dyZXNz LmdldCgpOyB9CiAgICAgICAgIEJhY2tGb3J3YXJkQ29udHJvbGxlciogYmFja0ZvcndhcmQoKSBj b25zdCB7IHJldHVybiBtX2JhY2tGb3J3YXJkQ29udHJvbGxlci5nZXQoKTsgfQpAQCAtMzY0LDEz ICszNjMsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBPd25QdHI8RGV2aWNlTW90 aW9uQ29udHJvbGxlcj4gbV9kZXZpY2VNb3Rpb25Db250cm9sbGVyOwogICAgICAgICBPd25QdHI8 RGV2aWNlT3JpZW50YXRpb25Db250cm9sbGVyPiBtX2RldmljZU9yaWVudGF0aW9uQ29udHJvbGxl cjsKICNlbmRpZgotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAgIE93blB0cjxNZWRp YVN0cmVhbUNvbnRyb2xsZXI+IG1fbWVkaWFTdHJlYW1Db250cm9sbGVyOwotI2VuZGlmCiAjaWYg RU5BQkxFKElOUFVUX1NQRUVDSCkKICAgICAgICAgU3BlZWNoSW5wdXRDbGllbnQqIG1fc3BlZWNo SW5wdXRDbGllbnQ7CiAgICAgICAgIE93blB0cjxTcGVlY2hJbnB1dD4gbV9zcGVlY2hJbnB1dDsK ICNlbmRpZgorI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCisgICAgICAgIFVzZXJNZWRpYUNsaWVu dCogbV91c2VyTWVkaWFDbGllbnQ7CisjZW5kaWYKICAgICAgICAgT3duUHRyPFNldHRpbmdzPiBt X3NldHRpbmdzOwogICAgICAgICBPd25QdHI8UHJvZ3Jlc3NUcmFja2VyPiBtX3Byb2dyZXNzOwog ICAgICAgICAK 115493 2011-11-16 17:37:39 -0800 2011-11-16 19:51:12 -0800 Patch 6 usermedia_simple_client_6.patch text/plain 55088 adam.bergkvist ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBjNmZlNjQwLi5hZjQxMWU3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTgg QEAKKzIwMTEtMTEtMTYgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24u Y29tPgorCisgICAgICAgIFVzZSBhIHNpbXBsZSBwYWdlIGNsaWVudCBmb3IgdXNlciBjb25zZW50 IGluIGdldFVzZXJNZWRpYSgpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD03MDg5NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgaXMgb25lIGluIGEgc2VyaWVzIG9mIHBhdGNoZXMgdGhhdCB1cGRhdGUg dGhlIE1lZGlhU3RyZWFtIGZlYXR1cmUKKyAgICAgICAgdG8gdXNlIFdlYkNvcmUgcGxhdGZvcm0g aW50ZXJmYWNlcy4KKworICAgICAgICBDb3ZlcmVkIGJ5IGV4aXN0aW5nIHRlc3RzLgorCisgICAg ICAgICogR05VbWFrZWZpbGUubGlzdC5hbToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAg ICAgICogbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1DbGllbnQuaDogUmVtb3ZlZC4KKyAgICAgICAg KiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwOiBSZW1vdmVkLgorICAgICAg ICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ29udHJvbGxlci5oOiBSZW1vdmVkLgorICAgICAg ICAqIG1lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcDogUmVtb3ZlZC4K KyAgICAgICAgKiBtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oOiBSZW1v dmVkLgorICAgICAgICAqIG1lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYUNsaWVudDo6flVzZXJNZWRpYUNsaWVudCk6CisgICAg ICAgICogbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlVz ZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6flVzZXJNZWRpYVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVz dDo6bWVkaWFTdHJlYW1Tb3VyY2VzUXVlcnlDb21wbGV0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6 VXNlck1lZGlhUmVxdWVzdDo6c3VjY2VlZCk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyTWVkaWFS ZXF1ZXN0OjpmYWlsKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmNvbnRl eHREZXN0cm95ZWQpOgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6cGFyc2VP cHRpb25zKToKKyAgICAgICAgKiBtZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0Lmg6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6YXVkaW8pOgorICAgICAgICAo V2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6dmlkZW8pOgorICAgICAgICAoV2ViQ29yZTo6VXNl ck1lZGlhUmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZVVzZXIpOgorICAgICAgICAoV2ViQ29yZTo6 VXNlck1lZGlhUmVxdWVzdDo6Y2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2Nlc3NDYWxsYmFjayk6CisgICAgICAgIChX ZWJDb3JlOjpVc2VyTWVkaWFSZXF1ZXN0OjplcnJvckNhbGxiYWNrKToKKyAgICAgICAgKiBwYWdl L0NhbGxiYWNrVGFzay5oOiBSZW1vdmVkLgorICAgICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWU6OkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lOjp+ RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWU6OnBhZ2VEZXN0cm95ZWQpOgorICAgICAg ICAoV2ViQ29yZTo6RnJhbWU6OnRyYW5zZmVyQ2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQpOgorICAg ICAgICAqIHBhZ2UvRnJhbWUuaDoKKyAgICAgICAgKiBwYWdlL05hdmlnYXRvci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYSk6CisgICAgICAgICog cGFnZS9OYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmg6CisgICAgICAgICogcGFnZS9Q YWdlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhZ2U6OlBhZ2UpOgorICAgICAgICAoV2ViQ29y ZTo6UGFnZTo6flBhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6UGFnZUNsaWVudHM6OlBh Z2VDbGllbnRzKToKKyAgICAgICAgKiBwYWdlL1BhZ2UuaDoKKyAgICAgICAgKFdlYkNvcmU6OlBh Z2U6OnVzZXJNZWRpYUNsaWVudCk6CisKIDIwMTEtMTEtMTYgIERhbmllbCBTaWV2ZXJzICA8c2ll dmVyc0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW0Nocm9taXVtXSBBdm9pZCBjb2xvciBtYXNr IG9wZXJhdGlvbnMgZm9yIHJvb3QgbGF5ZXJzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9H TlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpp bmRleCBmOTIxM2ZkLi42YzY3Yzg2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAg LTIyODAsMTMgKzIyODAsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3Jl L21lZGlhc3RyZWFtL0xvY2FsTWVkaWFTdHJlYW0uaCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFz dHJlYW0vTWVkaWFTdHJlYW0uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRp YVN0cmVhbS5oIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVu dC5oIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIu Y3BwIFwKLQlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIu aCBcCiAJU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRXZlbnQuaCBcCi0JU291cmNl L1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwIFwKLQlT b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIFwK IAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuY3BwIFwKIAlTb3Vy Y2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUxpc3QuaCBcCiAJU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1SZWdpc3RyeS5jcHAgXApAQCAtMjI5OCw2ICsyMjkz LDkgQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Q ZWVyQ29ubmVjdGlvbi5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1BlZXJDb25u ZWN0aW9uLmggXAogCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1NpZ25hbGluZ0NhbGxiYWNr LmggXAorCVNvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oIFwKKwlT b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBcCisJU291cmNl L1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhUmVxdWVzdC5oIFwKIAlTb3VyY2UvV2ViQ29y ZS9ub3RpZmljYXRpb25zL05vdGlmaWNhdGlvbkNlbnRlci5jcHAgXAogCVNvdXJjZS9XZWJDb3Jl L25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ2VudGVyLmggXAogCVNvdXJjZS9XZWJDb3JlL25v dGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ29udGVudHMuaCBcCkBAIC0yMzE4LDcgKzIzMTYsNiBA QCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BhZ2UvQWRqdXN0Vmlld1Np emVPck5vdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0JhckluZm8uY3BwIFwKIAlTb3VyY2Uv V2ViQ29yZS9wYWdlL0JhckluZm8uaCBcCi0JU291cmNlL1dlYkNvcmUvcGFnZS9DYWxsYmFja1Rh c2suaCBcCiAJU291cmNlL1dlYkNvcmUvcGFnZS9DaHJvbWUuY3BwIFwKIAlTb3VyY2UvV2ViQ29y ZS9wYWdlL0Nocm9tZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZUNsaWVudC5oIFwK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaQppbmRleCA4YTBmMWI0Li44ZDcyMDcxIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBA IC0yOTA1LDExICsyOTA1LDYgQEAKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVh bS5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUV2ZW50LmNwcCcsCiAg ICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1FdmVudC5oJywKLSAgICAgICAgICAg ICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oJywKLSAgICAgICAgICAgICdtZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVh bS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCcsCi0gICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVk aWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwJywKLSAgICAgICAgICAgICdtZWRpYXN0cmVhbS9N ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9N ZWRpYVN0cmVhbUxpc3QuY3BwJywKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9NZWRpYVN0cmVh bUxpc3QuaCcsCiAgICAgICAgICAgICAnbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1UcmFjay5jcHAn LApAQCAtMjkyMSw2ICsyOTE2LDkgQEAKICAgICAgICAgICAgICdtZWRpYXN0cmVhbS9QZWVyQ29u bmVjdGlvbi5jcHAnLAogICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1BlZXJDb25uZWN0aW9uLmgn LAogICAgICAgICAgICAgJ21lZGlhc3RyZWFtL1NpZ25hbGluZ0NhbGxiYWNrLmgnLAorICAgICAg ICAgICAgJ21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oJywKKyAgICAgICAgICAgICdtZWRp YXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCcsCisgICAgICAgICAgICAnbWVkaWFzdHJlYW0v VXNlck1lZGlhUmVxdWVzdC5oJywKICAgICAgICAgICAgICdub3RpZmljYXRpb25zL05vdGlmaWNh dGlvbi5jcHAnLAogICAgICAgICAgICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uLmgnLAog ICAgICAgICAgICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9uQ2VudGVyLmNwcCcsCkBAIC0y OTI4LDcgKzI5MjYsNiBAQAogICAgICAgICAgICAgJ25vdGlmaWNhdGlvbnMvTm90aWZpY2F0aW9u Q29udGVudHMuaCcsCiAgICAgICAgICAgICAncGFnZS9CYXJJbmZvLmNwcCcsCiAgICAgICAgICAg ICAncGFnZS9CYXJJbmZvLmgnLAotICAgICAgICAgICAgJ3BhZ2UvQ2FsbGJhY2tUYXNrLmgnLAog ICAgICAgICAgICAgJ3BhZ2UvQ2hyb21lLmNwcCcsCiAgICAgICAgICAgICAncGFnZS9Db25zb2xl LmNwcCcsCiAgICAgICAgICAgICAncGFnZS9Db250ZW50U2VjdXJpdHlQb2xpY3kuY3BwJywKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50Lmgg Yi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNsaWVudC5oCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhZjkwOTVjLi4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJD b3JlL21lZGlhc3RyZWFtL01lZGlhU3RyZWFtQ2xpZW50LmgKKysrIC9kZXYvbnVsbApAQCAtMSw1 OCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6 Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkK LSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAq IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaWZuZGVmIE1lZGlhU3RyZWFtQ2xpZW50X2gKLSNk ZWZpbmUgTWVkaWFTdHJlYW1DbGllbnRfaAotCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLQot I2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotY2xhc3Mg U2VjdXJpdHlPcmlnaW47Ci0KLWVudW0gR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFnIHsKLSAgICBH ZW5lcmF0ZVN0cmVhbVJlcXVlc3RBdWRpbyA9IDEsCi0gICAgR2VuZXJhdGVTdHJlYW1SZXF1ZXN0 VmlkZW9GYWNpbmdVc2VyID0gMSA8PCAxLAotICAgIEdlbmVyYXRlU3RyZWFtUmVxdWVzdFZpZGVv RmFjaW5nRW52aXJvbm1lbnQgPSAxIDw8IDIsCi19OwotCi10eXBlZGVmIHVuc2lnbmVkIEdlbmVy YXRlU3RyZWFtT3B0aW9uRmxhZ3M7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ2xpZW50IHsKLXB1Ymxp YzoKLSAgICAvLyBNZWRpYVN0cmVhbSBmdW5jdGlvbnMuCi0gICAgdmlydHVhbCB2b2lkIG1lZGlh U3RyZWFtRGVzdHJveWVkKCkgPSAwOwotICAgIHZpcnR1YWwgdm9pZCBnZW5lcmF0ZVN0cmVhbShp bnQgcmVxdWVzdElkLCBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzLCBQYXNzUmVmUHRyPFNlY3Vy aXR5T3JpZ2luPikgPSAwOwotCi1wcm90ZWN0ZWQ6Ci0gICAgdmlydHVhbCB+TWVkaWFTdHJlYW1D bGllbnQoKSB7IH0KLX07Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVO QUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRpZiAvLyBNZWRpYVN0cmVhbUNsaWVudF9oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIu Y3BwIGIvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9sbGVyLmNw cApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDRlMzA4ZS4uMDAwMDAwMAotLS0gYS9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuY3BwCisrKyAv ZGV2L251bGwKQEAgLTEsMTIzICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29v Z2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwotICogYXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQot ICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAotICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpbmNsdWRlICJjb25m aWcuaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNvbnRyb2xsZXIuaCIKLQotI2lmIEVOQUJMRShN RURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlICJNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIgot I2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCi0jaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgotCi1u YW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6UmVxdWVz dCB7Ci1wdWJsaWM6Ci0gICAgUmVxdWVzdCgpCi0gICAgICAgIDogbV9sb2NhbElkKDApCi0gICAg ICAgICwgbV9mcmFtZUNvbnRyb2xsZXIoMCkgeyB9Ci0KLSAgICBSZXF1ZXN0KGludCBsb2NhbElk LCBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKQotICAgICAgICA6 IG1fbG9jYWxJZChsb2NhbElkKQotICAgICAgICAsIG1fZnJhbWVDb250cm9sbGVyKGZyYW1lQ29u dHJvbGxlcikgeyB9Ci0KLSAgICBpbnQgbG9jYWxJZCgpIGNvbnN0IHsgcmV0dXJuIG1fbG9jYWxJ ZDsgfQotICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBmcmFtZUNvbnRyb2xsZXIoKSBj b25zdCB7IHJldHVybiBtX2ZyYW1lQ29udHJvbGxlcjsgfQotCi1wcml2YXRlOgotICAgIGludCBt X2xvY2FsSWQ7Ci0gICAgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIG1fZnJhbWVDb250cm9s bGVyOwotfTsKLQotTWVkaWFTdHJlYW1Db250cm9sbGVyOjpNZWRpYVN0cmVhbUNvbnRyb2xsZXIo TWVkaWFTdHJlYW1DbGllbnQqIGNsaWVudCkKLSAgICA6IG1fY2xpZW50KGNsaWVudCkKLSAgICAs IG1fbmV4dEdsb2JhbFJlcXVlc3RJZCgxKQotewotfQotCi1NZWRpYVN0cmVhbUNvbnRyb2xsZXI6 On5NZWRpYVN0cmVhbUNvbnRyb2xsZXIoKQotewotICAgIGlmIChtX2NsaWVudCkKLSAgICAgICAg bV9jbGllbnQtPm1lZGlhU3RyZWFtRGVzdHJveWVkKCk7Ci19Ci0KLWJvb2wgTWVkaWFTdHJlYW1D b250cm9sbGVyOjppc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fY2xp ZW50OwotfQotCi12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6dW5yZWdpc3RlckZyYW1lQ29u dHJvbGxlcihNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlciogZnJhbWVDb250cm9sbGVyKQotewot ICAgIEFTU0VSVChmcmFtZUNvbnRyb2xsZXIpOwotCi0gICAgLy8gRG9uZSBpbiB0d28gc3RlcHMg dG8gYXZvaWQgcHJvYmxlbXMgYWJvdXQgaXRlcmF0b3JzIGJlaW5nIGludmFsaWRhdGVkIHdoaWxl IHJlbW92aW5nLgotICAgIFZlY3RvcjxpbnQ+IGZyYW1lUmVxdWVzdHM7Ci0gICAgZm9yIChSZXF1 ZXN0TWFwOjppdGVyYXRvciBpdCA9IG1fcmVxdWVzdHMuYmVnaW4oKTsgaXQgIT0gbV9yZXF1ZXN0 cy5lbmQoKTsgKytpdCkKLSAgICAgICAgaWYgKGl0LT5zZWNvbmQuZnJhbWVDb250cm9sbGVyKCkg PT0gZnJhbWVDb250cm9sbGVyKQotICAgICAgICAgICAgZnJhbWVSZXF1ZXN0cy5hcHBlbmQoaXQt PmZpcnN0KTsKLQotICAgIGZvciAoVmVjdG9yPGludD46Oml0ZXJhdG9yIGl0ID0gZnJhbWVSZXF1 ZXN0cy5iZWdpbigpOyBpdCAhPSBmcmFtZVJlcXVlc3RzLmVuZCgpOyArK2l0KQotICAgICAgICBt X3JlcXVlc3RzLnJlbW92ZSgqaXQpOwotfQotCi1pbnQgTWVkaWFTdHJlYW1Db250cm9sbGVyOjpy ZWdpc3RlclJlcXVlc3QoaW50IGxvY2FsSWQsIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKiBm cmFtZUNvbnRyb2xsZXIpCi17Ci0gICAgQVNTRVJUKGxvY2FsSWQgPiAwKTsKLSAgICBBU1NFUlQo ZnJhbWVDb250cm9sbGVyKTsKLSAgICBtX3JlcXVlc3RzLmFkZChtX25leHRHbG9iYWxSZXF1ZXN0 SWQsIFJlcXVlc3QobG9jYWxJZCwgZnJhbWVDb250cm9sbGVyKSk7Ci0gICAgcmV0dXJuIG1fbmV4 dEdsb2JhbFJlcXVlc3RJZCsrOwotfQotCi12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6Z2Vu ZXJhdGVTdHJlYW0oTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIqIGZyYW1lQ29udHJvbGxlciwg aW50IGxvY2FsSWQsIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MsIFBhc3NSZWZQdHI8 U2VjdXJpdHlPcmlnaW4+IHNlY3VyaXR5T3JpZ2luKQotewotICAgIEFTU0VSVChtX2NsaWVudCk7 Ci0gICAgaW50IGNvbnRyb2xsZXJSZXF1ZXN0SWQgPSByZWdpc3RlclJlcXVlc3QobG9jYWxJZCwg ZnJhbWVDb250cm9sbGVyKTsKLSAgICBtX2NsaWVudC0+Z2VuZXJhdGVTdHJlYW0oY29udHJvbGxl clJlcXVlc3RJZCwgZmxhZ3MsIHNlY3VyaXR5T3JpZ2luKTsKLX0KLQotdm9pZCBNZWRpYVN0cmVh bUNvbnRyb2xsZXI6OnN0cmVhbUdlbmVyYXRlZChpbnQgY29udHJvbGxlclJlcXVlc3RJZCwgY29u c3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCi17Ci0gICAgLy8gRG9uJ3QgYXNz ZXJ0IHNpbmNlIHRoZSBmcmFtZSBjb250cm9sbGVyIGNhbiBoYXZlIGJlZW4gZGVzdHJveWVkIHdo aWxlIHRoZSByZXF1ZXN0IHJlcGx5IHdhcyBjb21pbmcgYmFjay4KLSAgICBpZiAobV9yZXF1ZXN0 cy5jb250YWlucyhjb250cm9sbGVyUmVxdWVzdElkKSkgewotICAgICAgICBjb25zdCBSZXF1ZXN0 JiByZXF1ZXN0ID0gbV9yZXF1ZXN0cy5nZXQoY29udHJvbGxlclJlcXVlc3RJZCk7Ci0gICAgICAg IG1fcmVxdWVzdHMucmVtb3ZlKGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAgICAgICBBU1NFUlQo cmVxdWVzdC5mcmFtZUNvbnRyb2xsZXIoKSk7Ci0gICAgICAgIHJlcXVlc3QuZnJhbWVDb250cm9s bGVyKCktPnN0cmVhbUdlbmVyYXRlZChyZXF1ZXN0LmxvY2FsSWQoKSwgc291cmNlcyk7Ci0gICAg fQotfQotCi12b2lkIE1lZGlhU3RyZWFtQ29udHJvbGxlcjo6c3RyZWFtR2VuZXJhdGlvbkZhaWxl ZChpbnQgY29udHJvbGxlclJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OkVycm9y Q29kZSBjb2RlKQotewotICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgZnJhbWUgY29udHJv bGxlciBjYW4gaGF2ZSBiZWVuIGRlc3Ryb3llZCB3aGlsZSB0aGUgcmVxdWVzdCByZXBseSB3YXMg Y29taW5nIGJhY2suCi0gICAgaWYgKG1fcmVxdWVzdHMuY29udGFpbnMoY29udHJvbGxlclJlcXVl c3RJZCkpIHsKLSAgICAgICAgY29uc3QgUmVxdWVzdCYgcmVxdWVzdCA9IG1fcmVxdWVzdHMuZ2V0 KGNvbnRyb2xsZXJSZXF1ZXN0SWQpOwotICAgICAgICBtX3JlcXVlc3RzLnJlbW92ZShjb250cm9s bGVyUmVxdWVzdElkKTsKLSAgICAgICAgcmVxdWVzdC5mcmFtZUNvbnRyb2xsZXIoKS0+c3RyZWFt R2VuZXJhdGlvbkZhaWxlZChyZXF1ZXN0LmxvY2FsSWQoKSwgY29kZSk7Ci0gICAgfQotfQotCi19 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1Db250cm9s bGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIu aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDg5MzA5NC4uMDAwMDAwMAotLS0gYS9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9NZWRpYVN0cmVhbUNvbnRyb2xsZXIuaAorKysgL2Rl di9udWxsCkBAIC0xLDc0ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cwotICogYXJlIG1ldDoKLSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFT IElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICog RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAot ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpZm5kZWYgTWVkaWFTdHJl YW1Db250cm9sbGVyX2gKLSNkZWZpbmUgTWVkaWFTdHJlYW1Db250cm9sbGVyX2gKLQotI2lmIEVO QUJMRShNRURJQV9TVFJFQU0pCi0KLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNsaWVudC5oIgotI2lu Y2x1ZGUgIk1lZGlhU3RyZWFtU291cmNlLmgiCi0jaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlh RXJyb3IuaCIKLSNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgotI2luY2x1ZGUgPHd0Zi9IYXNoTWFw Lmg+Ci0jaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvU3Ry aW5nSGFzaC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIE1lZGlhU3RyZWFtQ2xp ZW50OwotY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI7Ci1jbGFzcyBTZWN1cml0eU9y aWdpbjsKLQotY2xhc3MgTWVkaWFTdHJlYW1Db250cm9sbGVyIHsKLSAgICBXVEZfTUFLRV9OT05D T1BZQUJMRShNZWRpYVN0cmVhbUNvbnRyb2xsZXIpOwotcHVibGljOgotICAgIE1lZGlhU3RyZWFt Q29udHJvbGxlcihNZWRpYVN0cmVhbUNsaWVudCopOwotICAgIHZpcnR1YWwgfk1lZGlhU3RyZWFt Q29udHJvbGxlcigpOwotCi0gICAgYm9vbCBpc0NsaWVudEF2YWlsYWJsZSgpIGNvbnN0OwotICAg IHZvaWQgdW5yZWdpc3RlckZyYW1lQ29udHJvbGxlcihNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ciopOwotCi0gICAgdm9pZCBnZW5lcmF0ZVN0cmVhbShNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxl ciosIGludCByZXF1ZXN0SWQsIEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MsIFBhc3NSZWZQdHI8 U2VjdXJpdHlPcmlnaW4+KTsKLQotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGVkKGludCByZXF1ZXN0 SWQsIGNvbnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKTsKLSAgICB2b2lkIHN0 cmVhbUdlbmVyYXRpb25GYWlsZWQoaW50IHJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJy b3I6OkVycm9yQ29kZSk7Ci0KLXByaXZhdGU6Ci0gICAgaW50IHJlZ2lzdGVyUmVxdWVzdChpbnQg bG9jYWxSZXF1ZXN0SWQsIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKik7Ci0KLSAgICBjbGFz cyBSZXF1ZXN0OwotICAgIHR5cGVkZWYgSGFzaE1hcDxpbnQsIFJlcXVlc3Q+IFJlcXVlc3RNYXA7 Ci0KLSAgICBSZXF1ZXN0TWFwIG1fcmVxdWVzdHM7Ci0KLSAgICBNZWRpYVN0cmVhbUNsaWVudCog bV9jbGllbnQ7Ci0gICAgaW50IG1fbmV4dEdsb2JhbFJlcXVlc3RJZDsKLX07Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCi0KLSNlbmRp ZiAvLyBNZWRpYVN0cmVhbUNvbnRyb2xsZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv bWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNv cmUvbWVkaWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuY3BwCmRlbGV0ZWQgZmls ZSBtb2RlIDEwMDY0NAppbmRleCBkYzc1N2U0Li4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3Jl L21lZGlhc3RyZWFtL01lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyLmNwcAorKysgL2Rldi9udWxs CkBAIC0xLDI4MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAq IGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAq ICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCi0gKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycn IEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWQotICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsKLSAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTCi0gKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0j aW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaCIKLQotI2lmIEVOQUJMRShNRURJ QV9TVFJFQU0pCi0KLSNpbmNsdWRlICJET01XaW5kb3cuaCIKLSNpbmNsdWRlICJEb2N1bWVudC5o IgotI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKLSNpbmNsdWRlICJGcmFtZS5oIgotI2luY2x1 ZGUgIkxvY2FsTWVkaWFTdHJlYW0uaCIKLSNpbmNsdWRlICJNZWRpYVN0cmVhbUNvbnRyb2xsZXIu aCIKLSNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCi0jaW5jbHVk ZSAiTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCi0jaW5jbHVkZSAiUGFnZS5o IgotI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCi0jaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQu aD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlcjo6UmVxdWVzdCA6IHB1YmxpYyBSZWZDb3VudGVkPFJlcXVlc3Q+IHsKLSAgICBXVEZfTUFL RV9OT05DT1BZQUJMRShSZXF1ZXN0KTsKLXB1YmxpYzoKLSAgICB2aXJ0dWFsIH5SZXF1ZXN0KCkg eyB9Ci0KLSAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0 KCkgY29uc3QgeyByZXR1cm4gbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0OyB9Ci0gICAgdmlydHVh bCBib29sIGlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0K LQotICAgIHZpcnR1YWwgdm9pZCBhYm9ydCgpID0gMDsKLQotcHJvdGVjdGVkOgotICAgIFJlcXVl c3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkKLSAgICAg ICAgOiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkgeyB9 Ci0KLXByaXZhdGU6Ci0gICAgLy8gVGhpcyBpcyBndWFyYW50ZWVkIHRvIGhhdmUgdGhlIGxpZmV0 aW1lIG9mIHRoZSBGcmFtZSwgYW5kIGl0J3Mgb25seSB1c2VkIHRvIG1ha2UKLSAgICAvLyB0aGUg Y2FsbGJhY2sgYXN5bmNocm9ub3VzLiBUaGUgb3JpZ2luYWwgY2FsbGJhY2sgY29udGV4dCBpcyB1 c2VkIGluIHRoZSBjYWxsLgotICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIG1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dDsKLX07Ci0KLWNsYXNzIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpH ZW5lcmF0ZVN0cmVhbVJlcXVlc3QgOiBwdWJsaWMgUmVxdWVzdCB7Ci0gICAgV1RGX01BS0VfTk9O Q09QWUFCTEUoR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KTsKLXB1YmxpYzoKLSAgICBzdGF0aWMgUGFz c1JlZlB0cjxHZW5lcmF0ZVN0cmVhbVJlcXVlc3Q+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBzY3JpcHRFeGVjdXRpb25Db250ZXh0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3Vj Y2Vzc0NhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFF cnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQotICAgIHsKLSAgICAgICAgcmV0dXJuIGFkb3B0 UmVmKG5ldyBHZW5lcmF0ZVN0cmVhbVJlcXVlc3Qoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgc3Vj Y2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrKSk7Ci0gICAgfQotCi0gICAgdmlydHVhbCB+R2Vu ZXJhdGVTdHJlYW1SZXF1ZXN0KCkgeyB9Ci0KLSAgICB2aXJ0dWFsIGJvb2wgaXNHZW5lcmF0ZVN0 cmVhbVJlcXVlc3QoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Ci0KLSAgICB2aXJ0dWFsIHZvaWQg YWJvcnQoKQotICAgIHsKLSAgICAgICAgaWYgKG1fZXJyb3JDYWxsYmFjaykgewotICAgICAgICAg ICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBlcnJvciA9IE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yOjpjcmVhdGUoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OlBFUk1JU1NJT05fREVO SUVEKTsKLSAgICAgICAgICAgIC8vIFRoZSBjYWxsYmFjayBpdHNlbGYgaXMgbWFkZSB3aXRoIHRo ZSBKUyBjYWxsYmFjaydzIGNvbnRleHQsIG5vdCB3aXRoIHRoZSBmcmFtZSdzIGNvbnRleHQuCi0g ICAgICAgICAgICBtX2Vycm9yQ2FsbGJhY2stPnNjaGVkdWxlQ2FsbGJhY2soc2NyaXB0RXhlY3V0 aW9uQ29udGV4dCgpLCBlcnJvcik7Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAgICBQYXNzUmVmUHRy PE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrKCkgY29u c3QgeyByZXR1cm4gbV9zdWNjZXNzQ2FsbGJhY2s7IH0KLSAgICBQYXNzUmVmUHRyPE5hdmlnYXRv clVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2soKSBjb25zdCB7IHJldHVybiBt X2Vycm9yQ2FsbGJhY2s7IH0KLQotcHJpdmF0ZToKLSAgICBHZW5lcmF0ZVN0cmVhbVJlcXVlc3Qo U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2Fs bGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1Jl ZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQotICAg ICAgICA6IFJlcXVlc3Qoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkKLSAgICAgICAgLCBtX3N1Y2Nl c3NDYWxsYmFjayhzdWNjZXNzQ2FsbGJhY2spCi0gICAgICAgICwgbV9lcnJvckNhbGxiYWNrKGVy cm9yQ2FsbGJhY2spIHsgfQotCi0gICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3ND YWxsYmFjaz4gbV9zdWNjZXNzQ2FsbGJhY2s7Ci0gICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRp YUVycm9yQ2FsbGJhY2s+IG1fZXJyb3JDYWxsYmFjazsKLX07Ci0KLXZvaWQgTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXI6OlJlcXVlc3RNYXA6OmFib3J0KGludCByZXF1ZXN0SWQpCi17Ci0gICAg Z2V0KHJlcXVlc3RJZCktPmFib3J0KCk7Ci0gICAgcmVtb3ZlKHJlcXVlc3RJZCk7Ci19Ci0KLXZv aWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OlJlcXVlc3RNYXA6OmFib3J0QWxsKCkKLXsK LSAgICB3aGlsZSAoIWlzRW1wdHkoKSkgewotICAgICAgICBiZWdpbigpLT5zZWNvbmQtPmFib3J0 KCk7Ci0gICAgICAgIHJlbW92ZShiZWdpbigpKTsKLSAgICB9Ci19Ci0KLU1lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyOjpNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcihGcmFtZSogZnJhbWUpCi0g ICAgOiBtX2ZyYW1lKGZyYW1lKQotICAgICwgbV9pc0luRGV0YWNoZWRTdGF0ZShmYWxzZSkKLXsK LSAgICBpZiAoIWlzQ2xpZW50QXZhaWxhYmxlKCkpCi0gICAgICAgIGVudGVyRGV0YWNoZWRTdGF0 ZSgpOwotfQotCi1NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6fk1lZGlhU3RyZWFtRnJhbWVD b250cm9sbGVyKCkKLXsKLX0KLQotU2VjdXJpdHlPcmlnaW4qIE1lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyOjpzZWN1cml0eU9yaWdpbigpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fZnJhbWUgPyBt X2ZyYW1lLT5leGlzdGluZ0RPTVdpbmRvdygpLT5zZWN1cml0eU9yaWdpbigpIDogMDsKLX0KLQot U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnNjcmlw dEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdAotewotICAgIHJldHVybiBtX2ZyYW1lID8gbV9mcmFt ZS0+ZXhpc3RpbmdET01XaW5kb3coKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIDogMDsKLX0K LQotTWVkaWFTdHJlYW1Db250cm9sbGVyKiBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6cGFn ZUNvbnRyb2xsZXIoKSBjb25zdAotewotICAgIHJldHVybiBtX2ZyYW1lICYmIG1fZnJhbWUtPnBh Z2UoKSA/IG1fZnJhbWUtPnBhZ2UoKS0+bWVkaWFTdHJlYW1Db250cm9sbGVyKCkgOiAwOwotfQot Ci12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjplbnRlckRldGFjaGVkU3RhdGUoKQot ewotICAgIGlmIChtX2lzSW5EZXRhY2hlZFN0YXRlKSB7Ci0gICAgICAgIEFTU0VSVChtX3JlcXVl c3RzLmlzRW1wdHkoKSk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBtX3JlcXVlc3Rz LmFib3J0QWxsKCk7Ci0gICAgbV9pc0luRGV0YWNoZWRTdGF0ZSA9IHRydWU7Ci19Ci0KLWJvb2wg TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OmlzQ2xpZW50QXZhaWxhYmxlKCkgY29uc3QKLXsK LSAgICBpZiAobV9pc0luRGV0YWNoZWRTdGF0ZSkKLSAgICAgICAgcmV0dXJuIGZhbHNlOwotCi0g ICAgTWVkaWFTdHJlYW1Db250cm9sbGVyKiBjb250cm9sbGVyID0gcGFnZUNvbnRyb2xsZXIoKTsK LSAgICByZXR1cm4gY29udHJvbGxlciAmJiBjb250cm9sbGVyLT5pc0NsaWVudEF2YWlsYWJsZSgp OwotfQotCi0vLyBDYWxsZWQgYWxzbyB3aGVuIHRoZSBmcmFtZSBpcyBkZXRhY2hlZCBmcm9tIHRo ZSBwYWdlLCBpbiB3aGljaCBjYXNlIHRoZSBwYWdlIGNvbnRyb2xsZXIgd2lsbCByZW1haW4gYWxp dmUuCi12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpkaXNjb25uZWN0UGFnZSgpCi17 Ci0gICAgaWYgKHBhZ2VDb250cm9sbGVyKCkpCi0gICAgICAgIHBhZ2VDb250cm9sbGVyKCktPnVu cmVnaXN0ZXJGcmFtZUNvbnRyb2xsZXIodGhpcyk7Ci0KLSAgICBlbnRlckRldGFjaGVkU3RhdGUo KTsKLX0KLQotLy8gQ2FsbGVkIHdoZW4gdGhlIGZyYW1lIGlzIGJlaW5nIGRlc3Ryb3llZC4gU2lu Y2UgdGhlIGZyYW1lIGNvbnRyb2xsZXIgaXMgb3duZWQgYnkgdGhlIGZyYW1lIGl0IHdpbGwgZGll IHNob3J0bHkgYWZ0ZXIgdGhpcy4KLXZvaWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OmRp c2Nvbm5lY3RGcmFtZSgpCi17Ci0gICAgZGlzY29ubmVjdFBhZ2UoKTsKLQotICAgIEFTU0VSVCht X3JlcXVlc3RzLmlzRW1wdHkoKSk7Ci0KLSAgICBtX2ZyYW1lID0gMDsKLX0KLQotdm9pZCBNZWRp YVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6dHJhbnNmZXJUb05ld1BhZ2UoUGFnZSopCi17Ci0gICAg Ly8gRklYTUU6IEluIHRoZSBmdXR1cmUgd2Ugc2hvdWxkIGtlZXAgcnVubmluZyB0aGUgbWVkaWEg c3RyZWFtIHNlcnZpY2VzIHdoaWxlIHRyYW5zZmVyaW5nIGZyYW1lcyBiZXR3ZWVuIHBhZ2VzLgot ICAgIC8vIEhvd2V2ZXIsIHVudGlsIGEgcHJvcGVyIHdheSB0byBkbyB0aGlzIGlzIGRlY2lkZWQs IHdlJ3JlIHNodXR0aW5nIGRvd24gc2VydmljZXMuCi0gICAgZGlzY29ubmVjdFBhZ2UoKTsKLX0K LQotR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjo6 cGFyc2VHZW5lcmF0ZVN0cmVhbU9wdGlvbnMoY29uc3QgU3RyaW5nJiBvcHRpb25zKQotewotICAg IEdlbmVyYXRlU3RyZWFtT3B0aW9uRmxhZ3MgZmxhZ3MgPSAwOwotICAgIFZlY3RvcjxTdHJpbmc+ IG9wdGlvbkxpc3Q7Ci0gICAgb3B0aW9ucy5zcGxpdCgnLCcsIG9wdGlvbkxpc3QpOwotCi0gICAg Zm9yIChWZWN0b3I8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3Igb3B0aW9uID0gb3B0aW9uTGlzdC5i ZWdpbigpOyBvcHRpb24gIT0gb3B0aW9uTGlzdC5lbmQoKTsgKytvcHRpb24pIHsKLSAgICAgICAg VmVjdG9yPFN0cmluZz4gc3Vib3B0aW9uTGlzdDsKLSAgICAgICAgb3B0aW9uLT5zcGxpdCgnICcs IHN1Ym9wdGlvbkxpc3QpOwotCi0gICAgICAgIGlmIChzdWJvcHRpb25MaXN0LmZpcnN0KCkgPT0g ImF1ZGlvIikKLSAgICAgICAgICAgIGZsYWdzIHw9IEdlbmVyYXRlU3RyZWFtUmVxdWVzdEF1ZGlv OwotICAgICAgICBlbHNlIGlmIChzdWJvcHRpb25MaXN0LmZpcnN0KCkgPT0gInZpZGVvIikgewot ICAgICAgICAgICAgYm9vbCB2aWRlb1N1Ym9wdGlvbnMgPSBmYWxzZTsKLSAgICAgICAgICAgIFZl Y3RvcjxTdHJpbmc+Ojpjb25zdF9pdGVyYXRvciBzdWJvcHRpb24gPSBzdWJvcHRpb25MaXN0LmJl Z2luKCk7Ci0gICAgICAgICAgICBmb3IgKCsrc3Vib3B0aW9uOyBzdWJvcHRpb24gIT0gc3Vib3B0 aW9uTGlzdC5lbmQoKTsgKytzdWJvcHRpb24pCi0gICAgICAgICAgICAgICAgaWYgKCpzdWJvcHRp b24gPT0gInVzZXIiKSB7Ci0gICAgICAgICAgICAgICAgICAgIGZsYWdzIHw9IEdlbmVyYXRlU3Ry ZWFtUmVxdWVzdFZpZGVvRmFjaW5nVXNlcjsKLSAgICAgICAgICAgICAgICAgICAgdmlkZW9TdWJv cHRpb25zID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKCpzdWJvcHRpb24gPT0g ImVudmlyb25tZW50IikgewotICAgICAgICAgICAgICAgICAgICBmbGFncyB8PSBHZW5lcmF0ZVN0 cmVhbVJlcXVlc3RWaWRlb0ZhY2luZ0Vudmlyb25tZW50OwotICAgICAgICAgICAgICAgICAgICB2 aWRlb1N1Ym9wdGlvbnMgPSB0cnVlOwotICAgICAgICAgICAgICAgIH0KLQotICAgICAgICAgICAg Ly8gQXNrIGZvciBhbGwga2luZCBvZiBjYW1lcmFzIGlmIG5vIHN1Ym9wdGlvbiB3YXMgc3BlY2lm aWVkLgotICAgICAgICAgICAgaWYgKCF2aWRlb1N1Ym9wdGlvbnMpCi0gICAgICAgICAgICAgICAg ZmxhZ3MgfD0gR2VuZXJhdGVTdHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdVc2VyIHwgR2VuZXJhdGVT dHJlYW1SZXF1ZXN0VmlkZW9GYWNpbmdFbnZpcm9ubWVudDsKLSAgICAgICAgfQotICAgIH0KLQot ICAgIHJldHVybiBmbGFnczsKLX0KLQotLy8gSW1wbGVtZW50cyB0aGUgZ2V0VXNlck1lZGlhIG1l dGhvZCBmcm9tIGh0dHA6Ly93d3cud2hhdHdnLm9yZy9zcGVjcy93ZWItYXBwcy9jdXJyZW50LXdv cmsvI2RvbS1uYXZpZ2F0b3ItZ2V0dXNlcm1lZGlhLgotdm9pZCBNZWRpYVN0cmVhbUZyYW1lQ29u dHJvbGxlcjo6Z2VuZXJhdGVTdHJlYW0oY29uc3QgU3RyaW5nJiBvcHRpb25zLAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxOYXZpZ2F0 b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8TmF2aWdhdG9y VXNlck1lZGlhRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUmIGVjKQotewotICAg IGVjID0gMDsKLSAgICBpZiAoIXN1Y2Nlc3NDYWxsYmFjaykKLSAgICAgICAgcmV0dXJuOwotCi0g ICAgR2VuZXJhdGVTdHJlYW1PcHRpb25GbGFncyBmbGFncyA9IHBhcnNlR2VuZXJhdGVTdHJlYW1P cHRpb25zKG9wdGlvbnMpOwotICAgIGlmICghZmxhZ3MpIHsKLSAgICAgICAgZWMgPSBOT1RfU1VQ UE9SVEVEX0VSUjsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQotICAgIGludCByZXF1ZXN0SWQg PSBtX3JlcXVlc3RzLmdldE5leHRJZCgpOwotICAgIG1fcmVxdWVzdHMuYWRkKHJlcXVlc3RJZCwg R2VuZXJhdGVTdHJlYW1SZXF1ZXN0OjpjcmVhdGUoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCBz dWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2spKTsKLQotICAgIGlmICghaXNDbGllbnRBdmFp bGFibGUoKSkgewotICAgICAgICAvLyBUaGlzIG1ha2VzIHN1cmUgdG8gY2FsbCB0aGUgZXJyb3Ig Y2FsbGJhY2sgaWYgcHJvdmlkZWQuCi0gICAgICAgIG1fcmVxdWVzdHMuYWJvcnQocmVxdWVzdElk KTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQotICAgIHBhZ2VDb250cm9sbGVyKCktPmdlbmVy YXRlU3RyZWFtKHRoaXMsIHJlcXVlc3RJZCwgZmxhZ3MsIHNlY3VyaXR5T3JpZ2luKCkpOwotfQot Ci12b2lkIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyOjpzdHJlYW1HZW5lcmF0ZWQoaW50IHJl cXVlc3RJZCwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCi17Ci0gICAg Ly8gRG9uJ3QgYXNzZXJ0IHNpbmNlIHRoZSByZXF1ZXN0IGNhbiBoYXZlIGJlZW4gYWJvcnRlZCBh cyBhIHJlc3VsdCBvZiBlbWJlZGRlciBkZXRhY2htZW50LgotICAgIGlmICghbV9yZXF1ZXN0cy5j b250YWlucyhyZXF1ZXN0SWQpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBBU1NFUlQobV9yZXF1 ZXN0cy5nZXQocmVxdWVzdElkKS0+aXNHZW5lcmF0ZVN0cmVhbVJlcXVlc3QoKSk7Ci0KLSAgICBS ZWZQdHI8R2VuZXJhdGVTdHJlYW1SZXF1ZXN0PiBzdHJlYW1SZXF1ZXN0ID0gc3RhdGljX2Nhc3Q8 R2VuZXJhdGVTdHJlYW1SZXF1ZXN0Kj4obV9yZXF1ZXN0cy5nZXQocmVxdWVzdElkKS5nZXQoKSk7 Ci0gICAgUmVmUHRyPExvY2FsTWVkaWFTdHJlYW0+IGdlbmVyYXRlZFN0cmVhbSA9IExvY2FsTWVk aWFTdHJlYW06OmNyZWF0ZShzY3JpcHRFeGVjdXRpb25Db250ZXh0KCksIHNvdXJjZXMpOwotICAg IG1fcmVxdWVzdHMucmVtb3ZlKHJlcXVlc3RJZCk7Ci0gICAgc3RyZWFtUmVxdWVzdC0+c3VjY2Vz c0NhbGxiYWNrKCktPmhhbmRsZUV2ZW50KGdlbmVyYXRlZFN0cmVhbS5nZXQoKSk7Ci19Ci0KLXZv aWQgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI6OnN0cmVhbUdlbmVyYXRpb25GYWlsZWQoaW50 IHJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OkVycm9yQ29kZSBjb2RlKQotewot ICAgIC8vIERvbid0IGFzc2VydCBzaW5jZSB0aGUgcmVxdWVzdCBjYW4gaGF2ZSBiZWVuIGFib3J0 ZWQgYXMgYSByZXN1bHQgb2YgZW1iZWRkZXIgZGV0YWNobWVudC4KLSAgICBpZiAoIW1fcmVxdWVz dHMuY29udGFpbnMocmVxdWVzdElkKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgQVNTRVJUKG1f cmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCktPmlzR2VuZXJhdGVTdHJlYW1SZXF1ZXN0KCkpOwotCi0g ICAgUmVmUHRyPEdlbmVyYXRlU3RyZWFtUmVxdWVzdD4gc3RyZWFtUmVxdWVzdCA9IHN0YXRpY19j YXN0PEdlbmVyYXRlU3RyZWFtUmVxdWVzdCo+KG1fcmVxdWVzdHMuZ2V0KHJlcXVlc3RJZCkuZ2V0 KCkpOwotICAgIG1fcmVxdWVzdHMucmVtb3ZlKHJlcXVlc3RJZCk7Ci0KLSAgICBpZiAoc3RyZWFt UmVxdWVzdC0+ZXJyb3JDYWxsYmFjaygpKSB7Ci0gICAgICAgIFJlZlB0cjxOYXZpZ2F0b3JVc2Vy TWVkaWFFcnJvcj4gZXJyb3IgPSBOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKGNvZGUp OwotICAgICAgICBzdHJlYW1SZXF1ZXN0LT5lcnJvckNhbGxiYWNrKCktPmhhbmRsZUV2ZW50KGVy cm9yLmdldCgpKTsKLSAgICB9Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlm IC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRp YXN0cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvbWVk aWFzdHJlYW0vTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuaApkZWxldGVkIGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggOGMwOTNhMy4uMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0 cmVhbS9NZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci5oCisrKyAvZGV2L251bGwKQEAgLTEsMTA3 ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoK LSAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAotICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKLSAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFOWQot ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRAotICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQotICogRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZCi0gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwotICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwotICog TE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OCi0gKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAotICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF IE9GIFRISVMKLSAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpZm5kZWYgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXJfaAotI2RlZmluZSBNZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcl9oCi0KLSNpZiBFTkFCTEUo TUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1DbGllbnQuaCIKLSNpbmNsdWRl ICJNZWRpYVN0cmVhbVNvdXJjZS5oIgotI2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYUVycm9y LmgiCi0jaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KLSNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgot I2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hh c2guaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1jbGFzcyBGcmFtZTsKLWNsYXNzIE1lZGlh U3RyZWFtQ29udHJvbGxlcjsKLWNsYXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s7 Ci1jbGFzcyBOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s7Ci1jbGFzcyBQYWdlOwot Y2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKLWNsYXNzIFNlY3VyaXR5T3JpZ2luOwotCi10 eXBlZGVmIGludCBFeGNlcHRpb25Db2RlOwotCi1jbGFzcyBNZWRpYVN0cmVhbUZyYW1lQ29udHJv bGxlciB7Ci0gICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xs ZXIpOwotcHVibGljOgotICAgIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKEZyYW1lKik7Ci0g ICAgdmlydHVhbCB+TWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKTsKLQotICAgIFNlY3VyaXR5 T3JpZ2luKiBzZWN1cml0eU9yaWdpbigpIGNvbnN0OwotICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdDsKLQotICAgIGJvb2wgaXNDbGllbnRB dmFpbGFibGUoKSBjb25zdDsKLSAgICB2b2lkIGRpc2Nvbm5lY3RQYWdlKCk7Ci0gICAgdm9pZCBk aXNjb25uZWN0RnJhbWUoKTsKLSAgICB2b2lkIHRyYW5zZmVyVG9OZXdQYWdlKFBhZ2UqKTsKLQot ICAgIHN0YXRpYyBHZW5lcmF0ZVN0cmVhbU9wdGlvbkZsYWdzIHBhcnNlR2VuZXJhdGVTdHJlYW1P cHRpb25zKGNvbnN0IFN0cmluZyYpOwotICAgIHZvaWQgZ2VuZXJhdGVTdHJlYW0oY29uc3QgU3Ry aW5nJiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFj az4sIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaz4sIEV4Y2VwdGlv bkNvZGUmKTsKLQotICAgIC8vIC0tLSBDYWxscyBjb21pbmcgYmFjayBmcm9tIHRoZSBjb250cm9s bGVyLiAtLS0gLy8KLQotICAgIHZvaWQgc3RyZWFtR2VuZXJhdGVkKGludCByZXF1ZXN0SWQsIGNv bnN0IE1lZGlhU3RyZWFtU291cmNlVmVjdG9yJiBzb3VyY2VzKTsKLSAgICB2b2lkIHN0cmVhbUdl bmVyYXRpb25GYWlsZWQoaW50IHJlcXVlc3RJZCwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OkVy cm9yQ29kZSk7Ci0KLXByaXZhdGU6Ci0gICAgY2xhc3MgUmVxdWVzdDsKLSAgICBjbGFzcyBHZW5l cmF0ZVN0cmVhbVJlcXVlc3Q7Ci0KLSAgICBjbGFzcyBJZEdlbmVyYXRvciB7Ci0gICAgICAgIFdU Rl9NQUtFX05PTkNPUFlBQkxFKElkR2VuZXJhdG9yKTsKLSAgICBwdWJsaWM6Ci0gICAgICAgIElk R2VuZXJhdG9yKCkgOiBtX2lkKDApIHsgfQotICAgICAgICBpbnQgZ2V0TmV4dElkKCkgeyByZXR1 cm4gKyttX2lkOyB9Ci0KLSAgICBwcml2YXRlOgotICAgICAgICBpbnQgbV9pZDsKLSAgICB9Owot Ci0gICAgY2xhc3MgUmVxdWVzdE1hcCA6IHB1YmxpYyBJZEdlbmVyYXRvciwgcHVibGljIEhhc2hN YXA8aW50LCBSZWZQdHI8UmVxdWVzdD4gPiB7Ci0gICAgcHVibGljOgotICAgICAgICB2b2lkIGFi b3J0KGludCByZXF1ZXN0SWQpOwotICAgICAgICB2b2lkIGFib3J0QWxsKCk7Ci0gICAgfTsKLQot ICAgIC8vIERldGFjaGVkIGZyb20gYSBwYWdlLCBhbmQgaGVuY2UgZnJvbSBhIGVtYmVkZGVyIGNs aWVudC4KLSAgICB2b2lkIGVudGVyRGV0YWNoZWRTdGF0ZSgpOwotCi0gICAgTWVkaWFTdHJlYW1D b250cm9sbGVyKiBwYWdlQ29udHJvbGxlcigpIGNvbnN0OwotCi0gICAgUmVxdWVzdE1hcCBtX3Jl cXVlc3RzOwotCi0gICAgRnJhbWUqIG1fZnJhbWU7Ci0gICAgYm9vbCBtX2lzSW5EZXRhY2hlZFN0 YXRlOwotfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRU5BQkxFKE1F RElBX1NUUkVBTSkKLQotI2VuZGlmIC8vIE1lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyX2gKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oIGIv U291cmNlL1dlYkNvcmUvbWVkaWFzdHJlYW0vVXNlck1lZGlhQ2xpZW50LmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWNiNTRmYgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYUNsaWVudC5oCkBAIC0wLDAgKzEsNTYgQEAK 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 Ki8KKworI2lmbmRlZiBVc2VyTWVkaWFDbGllbnRfaAorI2RlZmluZSBVc2VyTWVkaWFDbGllbnRf aAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2luY2x1ZGUgIlVzZXJNZWRpYVJlcXVl c3QuaCIKKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitjbGFzcyBVc2VyTWVkaWFDbGllbnQgeworcHVibGljOgorICAgIHZpcnR1YWwgdm9p ZCBwYWdlRGVzdHJveWVkKCkgPSAwOworCisgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RVc2VyTWVk aWEoUGFzc1JlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiwgY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VW ZWN0b3ImKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGNhbmNlbFVzZXJNZWRpYVJlcXVlc3QoVXNl ck1lZGlhUmVxdWVzdCopID0gMDsKKworcHJvdGVjdGVkOgorICAgIHZpcnR1YWwgflVzZXJNZWRp YUNsaWVudCgpIHsgfQorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8g RU5BQkxFKE1FRElBX1NUUkVBTSkKKworI2VuZGlmIC8vIFVzZXJNZWRpYUNsaWVudF9oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBi L1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM0Y2Y4NzAKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcApAQCAtMCwwICsx LDEzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQorICogICAgZGlzdHJpYnV0aW9uLgorICogMy4gTmVpdGhlciB0aGUgbmFtZSBv ZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBi ZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcwor ICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERF UlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQ QVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBD T1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisg KiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoTUVESUFfU1RS RUFNKQorCisjaW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5oIgorCisjaW5jbHVkZSAiTG9jYWxN ZWRpYVN0cmVhbS5oIgorI2luY2x1ZGUgIlNwYWNlU3BsaXRTdHJpbmcuaCIKKyNpbmNsdWRlICJV c2VyTWVkaWFDbGllbnQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzUmVmUHRyPFVz ZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBv cHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3Vj Y2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+ IGVycm9yQ2FsbGJhY2spCit7CisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVlc3Qg PSBhZG9wdFJlZihuZXcgVXNlck1lZGlhUmVxdWVzdChjb250ZXh0LCBjbGllbnQsIG9wdGlvbnMs IHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOworICAgIGlmICghcmVxdWVzdC0+YXVk aW8oKSAmJiAhcmVxdWVzdC0+dmlkZW8oKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1 cm4gcmVxdWVzdC5yZWxlYXNlKCk7Cit9CisKK1VzZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJl cXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgVXNlck1lZGlhQ2xpZW50KiBj bGllbnQsIGNvbnN0IFN0cmluZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVk aWFTdWNjZXNzQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQorICAgIDogQ29udGV4dERlc3Ry dWN0aW9uT2JzZXJ2ZXIoY29udGV4dCkKKyAgICAsIG1fYXVkaW8oZmFsc2UpCisgICAgLCBtX3Zp ZGVvKGZhbHNlKQorICAgICwgbV9jYW1lcmFQcmVmZXJlbmNlVXNlcihmYWxzZSkKKyAgICAsIG1f Y2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50KGZhbHNlKQorICAgICwgbV9jbGllbnQoY2xpZW50 KQorICAgICwgbV9zdWNjZXNzQ2FsbGJhY2soc3VjY2Vzc0NhbGxiYWNrKQorICAgICwgbV9lcnJv ckNhbGxiYWNrKGVycm9yQ2FsbGJhY2spCit7CisgICAgcGFyc2VPcHRpb25zKG9wdGlvbnMpOwor fQorCitVc2VyTWVkaWFSZXF1ZXN0Ojp+VXNlck1lZGlhUmVxdWVzdCgpCit7Cit9CisKK3ZvaWQg VXNlck1lZGlhUmVxdWVzdDo6c3RhcnQoKQoreworICAgIC8vIEZJWE1FOiBxdWVyeSB0aGUgcGxh dGZvcm0gZm9yIGF2YWlsYWJsZSBtZWRpYSBzdHJlYW0gc291cmNlcywgc2VlIGh0dHA6Ly93ZWJr aXQub3JnL2IvNzA4OTUKK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjptZWRpYVN0cmVhbVNv dXJjZXNRdWVyeUNvbXBsZXRlZChjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYgc291cmNl cykKK3sKKyAgICBpZiAobV9jbGllbnQpCisgICAgICAgIG1fY2xpZW50LT5yZXF1ZXN0VXNlck1l ZGlhKHRoaXMsIHNvdXJjZXMpOworfQorCit2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OnN1Y2NlZWQo Y29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImIHNvdXJjZXMpCit7CisgICAgaWYgKCFtX3Nj cmlwdEV4ZWN1dGlvbkNvbnRleHQpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2Nh bE1lZGlhU3RyZWFtPiBzdHJlYW0gPSBMb2NhbE1lZGlhU3RyZWFtOjpjcmVhdGUobV9zY3JpcHRF eGVjdXRpb25Db250ZXh0LCBzb3VyY2VzKTsKKyAgICBtX3N1Y2Nlc3NDYWxsYmFjay0+aGFuZGxl RXZlbnQoc3RyZWFtLmdldCgpKTsKK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpmYWlsKCkK K3sKKyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dCkKKyAgICAgICAgcmV0dXJuOwor CisgICAgaWYgKG1fZXJyb3JDYWxsYmFjaykgeworICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNl ck1lZGlhRXJyb3I+IGVycm9yID0gTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZp Z2F0b3JVc2VyTWVkaWFFcnJvcjo6UEVSTUlTU0lPTl9ERU5JRUQpOworICAgICAgICBtX2Vycm9y Q2FsbGJhY2stPmhhbmRsZUV2ZW50KGVycm9yLmdldCgpKTsKKyAgICB9Cit9CisKK3ZvaWQgVXNl ck1lZGlhUmVxdWVzdDo6Y29udGV4dERlc3Ryb3llZCgpCit7CisgICAgaWYgKG1fY2xpZW50KSB7 CisgICAgICAgIG1fY2xpZW50LT5jYW5jZWxVc2VyTWVkaWFSZXF1ZXN0KHRoaXMpOworICAgICAg ICBtX2NsaWVudCA9IDA7CisgICAgfQorCisgICAgQ29udGV4dERlc3RydWN0aW9uT2JzZXJ2ZXI6 OmNvbnRleHREZXN0cm95ZWQoKTsKK30KKwordm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpwYXJzZU9w dGlvbnMoY29uc3QgU3RyaW5nJiBvcHRpb25zKQoreworICAgIFZlY3RvcjxTdHJpbmc+IG9wdGlv bnNMaXN0OworICAgIG9wdGlvbnMuc3BsaXQoIiwiLCBvcHRpb25zTGlzdCk7CisKKyAgICBmb3Ig KHNpemVfdCBpID0gMDsgaSA8IG9wdGlvbnNMaXN0LnNpemUoKTsgKytpKSB7CisgICAgICAgIFNw YWNlU3BsaXRTdHJpbmcgc3ViT3B0aW9ucyhvcHRpb25zTGlzdFtpXSwgZmFsc2UpOworCisgICAg ICAgIGlmIChzdWJPcHRpb25zWzBdID09ICJhdWRpbyIpCisgICAgICAgICAgICBtX2F1ZGlvID0g dHJ1ZTsKKyAgICAgICAgZWxzZSBpZiAoc3ViT3B0aW9uc1swXSA9PSAidmlkZW8iKSB7CisgICAg ICAgICAgICBtX3ZpZGVvID0gdHJ1ZTsKKyAgICAgICAgICAgIGlmIChzdWJPcHRpb25zLmNvbnRh aW5zKCJ1c2VyIikpCisgICAgICAgICAgICAgICAgbV9jYW1lcmFQcmVmZXJlbmNlVXNlciA9IHRy dWU7CisgICAgICAgICAgICBpZiAoc3ViT3B0aW9ucy5jb250YWlucygiZW52aXJvbm1lbnQiKSkK KyAgICAgICAgICAgICAgICBtX2NhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCA9IHRydWU7Cisg ICAgICAgIH0KKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IEVOQUJMRShNRURJQV9TVFJFQU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0 cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmggYi9Tb3VyY2UvV2ViQ29yZS9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFSZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTA5YmQ0 NwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL21lZGlhc3RyZWFtL1VzZXJNZWRp YVJlcXVlc3QuaApAQCAtMCwwICsxLDkyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEVy 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 U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgVXNlck1lZGlhUmVxdWVz dF9oCisjZGVmaW5lIFVzZXJNZWRpYVJlcXVlc3RfaAorCisjaWYgRU5BQkxFKE1FRElBX1NUUkVB TSkKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIk1lZGlhU3RyZWFt U291cmNlLmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oIgor I2luY2x1ZGUgIk5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjay5oIgorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKyNpbmNsdWRl IDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBV c2VyTWVkaWFDbGllbnQ7CisKK2NsYXNzIFVzZXJNZWRpYVJlcXVlc3QgOiBwdWJsaWMgUmVmQ291 bnRlZDxVc2VyTWVkaWFSZXF1ZXN0PiwgcHVibGljIENvbnRleHREZXN0cnVjdGlvbk9ic2VydmVy IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBjcmVh dGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFVzZXJNZWRpYUNsaWVudCosIGNvbnN0IFN0cmlu ZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+ LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+KTsKKyAgICB+VXNl ck1lZGlhUmVxdWVzdCgpOworCisgICAgYm9vbCBhdWRpbygpIGNvbnN0IHsgcmV0dXJuIG1fYXVk aW87IH0KKyAgICBib29sIHZpZGVvKCkgY29uc3QgeyByZXR1cm4gbV92aWRlbzsgfQorCisgICAg Ym9vbCBjYW1lcmFQcmVmZXJlbmNlVXNlcigpIGNvbnN0IHsgcmV0dXJuIG1fY2FtZXJhUHJlZmVy ZW5jZVVzZXI7IH0KKyAgICBib29sIGNhbWVyYVByZWZlcmVuY2VFbnZpcm9ubWVudCgpIGNvbnN0 IHsgcmV0dXJuIG1fY2FtZXJhUHJlZmVyZW5jZUVudmlyb25tZW50OyB9CisKKyAgICBOYXZpZ2F0 b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2sqIHN1Y2Nlc3NDYWxsYmFjaygpIGNvbnN0IHsgcmV0 dXJuIG1fc3VjY2Vzc0NhbGxiYWNrLmdldCgpOyB9CisgICAgTmF2aWdhdG9yVXNlck1lZGlhRXJy b3JDYWxsYmFjayogZXJyb3JDYWxsYmFjaygpIGNvbnN0IHsgcmV0dXJuIG1fZXJyb3JDYWxsYmFj ay5nZXQoKTsgfQorCisgICAgdm9pZCBzdGFydCgpOworICAgIHZvaWQgbWVkaWFTdHJlYW1Tb3Vy Y2VzUXVlcnlDb21wbGV0ZWQoY29uc3QgTWVkaWFTdHJlYW1Tb3VyY2VWZWN0b3ImKTsKKworICAg IHZvaWQgc3VjY2VlZChjb25zdCBNZWRpYVN0cmVhbVNvdXJjZVZlY3RvciYpOworICAgIHZvaWQg ZmFpbCgpOworCisgICAgLy8gQ29udGV4dERlc3RydWN0aW9uT2JzZXJ2ZXIKKyAgICB2aXJ0dWFs IHZvaWQgY29udGV4dERlc3Ryb3llZCgpOworCitwcml2YXRlOgorICAgIFVzZXJNZWRpYVJlcXVl c3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFVzZXJNZWRpYUNsaWVudCosIGNvbnN0IFN0cmlu ZyYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZpZ2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+ LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+KTsKKworICAgIHZv aWQgcGFyc2VPcHRpb25zKGNvbnN0IFN0cmluZyYgb3B0aW9ucyk7CisKKyAgICBib29sIG1fYXVk aW87CisgICAgYm9vbCBtX3ZpZGVvOworCisgICAgYm9vbCBtX2NhbWVyYVByZWZlcmVuY2VVc2Vy OworICAgIGJvb2wgbV9jYW1lcmFQcmVmZXJlbmNlRW52aXJvbm1lbnQ7CisKKyAgICBVc2VyTWVk aWFDbGllbnQqIG1fY2xpZW50OworCisgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nl c3NDYWxsYmFjaz4gbV9zdWNjZXNzQ2FsbGJhY2s7CisgICAgUmVmUHRyPE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yQ2FsbGJhY2s+IG1fZXJyb3JDYWxsYmFjazsKK307CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShNRURJQV9TVFJFQU0pCisKKyNlbmRpZiAvLyBV c2VyTWVkaWFSZXF1ZXN0X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2FsbGJh Y2tUYXNrLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0NhbGxiYWNrVGFzay5oCmRlbGV0ZWQgZmls ZSBtb2RlIDEwMDY0NAppbmRleCBlZDAwZDMxLi4wMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvQ2FsbGJhY2tUYXNrLmgKKysrIC9kZXYvbnVsbApAQCAtMSw4MSArMCwwIEBACi0vKgot ICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0g KgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiAgUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK LSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCi0gKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElN UExJRUQKLSAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKLSAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQotICogRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMKLSAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKLSAqIExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTgotICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCi0gKiBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KLSAqLwotCi0jaWZuZGVmIENhbGxiYWNrVGFza19oCi0jZGVmaW5lIENhbGxiYWNrVGFza19o Ci0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotCi0jaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5oIgotI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+Ci0jaW5jbHVkZSA8d3RmL1Bhc3NS ZWZQdHIuaD4KLSNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsK LQotLy8gSGVscGVyIHRlbXBsYXRlIHRvIHNjaGVkdWxlIGNhbGxzIHRvIGNhbGxiYWNrcyB1c2lu ZyB0aGVpciBvd24gc2NyaXB0IGV4ZWN1dGlvbiBjb250ZXh0LgotLy8gQ2FsbGJhY2tUeXBlIGlz IGFzc3VtZWQgdG8gaW1wbGVtZW50IFNjaGVkdWxlciBhbmQgdG8gYmUgcmVmZXJlbmNlLWNvdW50 ZWQuCi10ZW1wbGF0ZSA8dHlwZW5hbWUgQ2FsbGJhY2tUeXBlLCB0eXBlbmFtZSBBcmd1bWVudFR5 cGU+Ci1jbGFzcyBDYWxsYmFja1Rhc2sxIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2sgewotcHVibGljOgotICAgIHN0YXRpYyBQYXNzT3duUHRyPENhbGxiYWNrVGFzazE+IGNy ZWF0ZShQYXNzUmVmUHRyPENhbGxiYWNrVHlwZT4gY2FsbGJhY2ssIFBhc3NSZWZQdHI8QXJndW1l bnRUeXBlPiBkYXRhKQotICAgIHsKLSAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBDYWxsYmFj a1Rhc2sxKGNhbGxiYWNrLCBkYXRhKSk7Ci0gICAgfQotCi0gICAgdmlydHVhbCB2b2lkIHBlcmZv cm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQotICAgIHsKLSAgICAgICAgbV9jYWxsYmFj ay0+aGFuZGxlRXZlbnQobV9kYXRhLmdldCgpKTsKLSAgICB9Ci0KLSAgICBjbGFzcyBTY2hlZHVs ZXIgewotICAgIHB1YmxpYzoKLSAgICAgICAgdmlydHVhbCB+U2NoZWR1bGVyKCkgeyB9Ci0KLSAg ICAgICAgYm9vbCBzY2hlZHVsZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIFBhc3NSZWZQdHI8QXJndW1lbnRUeXBlPiBkYXRhKQotICAgICAgICB7Ci0gICAgICAgICAg ICBpZiAoY29udGV4dCkgewotICAgICAgICAgICAgICAgIGNvbnRleHQtPnBvc3RUYXNrKENhbGxi YWNrVGFzazE8Q2FsbGJhY2tUeXBlLCBBcmd1bWVudFR5cGU+OjpjcmVhdGUoc3RhdGljX2Nhc3Q8 Q2FsbGJhY2tUeXBlKj4odGhpcyksIGRhdGEpKTsKLSAgICAgICAgICAgICAgICByZXR1cm4gdHJ1 ZTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAgICAgfQot ICAgIH07Ci0KLXByaXZhdGU6Ci0gICAgQ2FsbGJhY2tUYXNrMShQYXNzUmVmUHRyPENhbGxiYWNr VHlwZT4gY2FsbGJhY2ssIFBhc3NSZWZQdHI8QXJndW1lbnRUeXBlPiBkYXRhKQotICAgICAgICA6 IG1fY2FsbGJhY2soY2FsbGJhY2spCi0gICAgICAgICwgbV9kYXRhKGRhdGEpCi0gICAgewotICAg IH0KLQotICAgIFJlZlB0cjxDYWxsYmFja1R5cGU+IG1fY2FsbGJhY2s7Ci0gICAgUmVmUHRyPEFy Z3VtZW50VHlwZT4gbV9kYXRhOwotfTsKLQotfQotCi0jZW5kaWYgLy8gRU5BQkxFKE1FRElBX1NU UkVBTSkKLQotI2VuZGlmIC8vIENhbGxiYWNrVGFza19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCmluZGV4 IGUzNTNiNDkuLjgzNjkxYWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCkBAIC0xMTEsMTAgKzExMSw2 IEBACiAjaW5jbHVkZSAiU1ZHRG9jdW1lbnRFeHRlbnNpb25zLmgiCiAjZW5kaWYKIAotI2lmIEVO QUJMRShNRURJQV9TVFJFQU0pCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIu aCIKLSNlbmRpZgotCiAjaWYgVVNFKFRJTEVEX0JBQ0tJTkdfU1RPUkUpCiAjaW5jbHVkZSAiVGls ZWRCYWNraW5nU3RvcmUuaCIKICNlbmRpZgpAQCAtMTY5LDkgKzE2NSw2IEBAIGlubGluZSBGcmFt ZTo6RnJhbWUoUGFnZSogcGFnZSwgSFRNTEZyYW1lT3duZXJFbGVtZW50KiBvd25lckVsZW1lbnQs IEZyYW1lTG9hZGVyCiAgICAgLCBtX2luVmlld1NvdXJjZU1vZGUoZmFsc2UpCiAgICAgLCBtX2lz RGlzY29ubmVjdGVkKGZhbHNlKQogICAgICwgbV9leGNsdWRlRnJvbVRleHRTZWFyY2goZmFsc2Up Ci0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAsIG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRy b2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6bWVkaWFTdHJlYW1FbmFibGVkKCkgPyBhZG9w dFB0cihuZXcgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIodGhpcykpIDogUGFzc093blB0cjxN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcj4oKSkKLSNlbmRpZgogewogICAgIEFTU0VSVChwYWdl KTsKICAgICBBdG9taWNTdHJpbmc6OmluaXQoKTsKQEAgLTIyOCwxMSArMjIxLDYgQEAgRnJhbWU6 On5GcmFtZSgpCiAgICAgaWYgKG1fZG9tV2luZG93KQogICAgICAgICBtX2RvbVdpbmRvdy0+ZGlz Y29ubmVjdEZyYW1lKCk7CiAKLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotICAgIGlmIChtX21l ZGlhU3RyZWFtRnJhbWVDb250cm9sbGVyKQotICAgICAgICBtX21lZGlhU3RyZWFtRnJhbWVDb250 cm9sbGVyLT5kaXNjb25uZWN0RnJhbWUoKTsKLSNlbmRpZgotCiAgICAgSGFzaFNldDxET01XaW5k b3cqPjo6aXRlcmF0b3IgZW5kID0gbV9saXZlRm9ybWVyV2luZG93cy5lbmQoKTsKICAgICBmb3Ig KEhhc2hTZXQ8RE9NV2luZG93Kj46Oml0ZXJhdG9yIGl0ID0gbV9saXZlRm9ybWVyV2luZG93cy5i ZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCiAgICAgICAgICgqaXQpLT5kaXNjb25uZWN0RnJhbWUo KTsKQEAgLTY5OCwxMSArNjg2LDYgQEAgdm9pZCBGcmFtZTo6cGFnZURlc3Ryb3llZCgpCiAgICAg ICAgIG1fZG9tV2luZG93LT5wYWdlRGVzdHJveWVkKCk7CiAgICAgfQogCi0jaWYgRU5BQkxFKE1F RElBX1NUUkVBTSkKLSAgICBpZiAobV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcikKLSAgICAg ICAgbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci0+ZGlzY29ubmVjdFBhZ2UoKTsKLSNlbmRp ZgotCiAgICAgLy8gRklYTUU6IEl0J3MgdW5jbGVhciBhcyB0byB3aHkgdGhpcyBpcyBjYWxsZWQg bW9yZSB0aGFuIG9uY2UsIGJ1dCBpdCBpcywKICAgICAvLyBzbyBwYWdlKCkgY291bGQgYmUgTlVM TC4KICAgICBpZiAocGFnZSgpICYmIHBhZ2UoKS0+Zm9jdXNDb250cm9sbGVyKCktPmZvY3VzZWRG cmFtZSgpID09IHRoaXMpCkBAIC03NTYsMTAgKzczOSw2IEBAIHZvaWQgRnJhbWU6OnRyYW5zZmVy Q2hpbGRGcmFtZVRvTmV3RG9jdW1lbnQoKQogI2VuZGlmCiAgICAgICAgIH0KIAotI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCi0gICAgICAgIGlmIChtX21lZGlhU3RyZWFtRnJhbWVDb250cm9sbGVy KQotICAgICAgICAgICAgbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlci0+dHJhbnNmZXJUb05l d1BhZ2UobmV3UGFnZSk7Ci0jZW5kaWYKICAgICAgICAgbV9wYWdlID0gbmV3UGFnZTsKIAogICAg ICAgICBpZiAobmV3UGFnZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUu aCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWUuaAppbmRleCA5Y2UzYWVjLi5lNGY1ODg5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZS5oCkBAIC02NSw3ICs2NSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICBjbGFzcyBEb2N1bWVudDsKICAgICBjbGFzcyBGcmFtZVZpZXc7CiAgICAgY2xhc3MgSFRNTFRh YmxlQ2VsbEVsZW1lbnQ7Ci0gICAgY2xhc3MgTWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXI7CiAg ICAgY2xhc3MgUmVndWxhckV4cHJlc3Npb247CiAgICAgY2xhc3MgUmVuZGVyUGFydDsKICAgICBj bGFzcyBUaWxlZEJhY2tpbmdTdG9yZTsKQEAgLTIwMSwxMCArMjAwLDYgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICBOU0ltYWdlKiBpbWFnZUZyb21SZWN0KE5TUmVjdCkgY29uc3Q7CiAj ZW5kaWYKIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAgIE1lZGlhU3RyZWFtRnJh bWVDb250cm9sbGVyKiBtZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcigpIGNvbnN0IHsgcmV0dXJu IG1fbWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIuZ2V0KCk7IH0KLSNlbmRpZgotICAgICAgICAK ICAgICAgICAgLy8gU2hvdWxkIG9ubHkgYmUgY2FsbGVkIG9uIHRoZSBtYWluIGZyYW1lIG9mIGEg cGFnZS4KICAgICAgICAgdm9pZCBub3RpZnlDaHJvbWVDbGllbnRXaGVlbEV2ZW50SGFuZGxlckNv dW50Q2hhbmdlZCgpIGNvbnN0OwogCkBAIC0yNjYsOSArMjYxLDYgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogICAgICAgICBPd25QdHI8VGlsZWRCYWNraW5nU3RvcmU+IG1fdGlsZWRCYWNraW5nU3Rv cmU7CiAjZW5kaWYKIAotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAgIE93blB0cjxN ZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcj4gbV9tZWRpYVN0cmVhbUZyYW1lQ29udHJvbGxlcjsK LSNlbmRpZgogICAgIH07CiAKICAgICBpbmxpbmUgdm9pZCBGcmFtZTo6aW5pdCgpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w YWdlL05hdmlnYXRvci5jcHAKaW5kZXggY2NmYmZiOS4uMTA1MjA5OCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9OYXZpZ2F0b3IuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv TmF2aWdhdG9yLmNwcApAQCAtNDYsOSArNDYsOSBAQAogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRy YXMuaD4KIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1G cmFtZUNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxi YWNrLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCisj aW5jbHVkZSAiVXNlck1lZGlhUmVxdWVzdC5oIgogI2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKQEAgLTI4NCw4ICsyODQsMjMgQEAgdm9pZCBOYXZpZ2F0b3I6OnJlZ2lzdGVyUHJvdG9jb2xI YW5kbGVyKGNvbnN0IFN0cmluZyYgc2NoZW1lLCBjb25zdCBTdHJpbmcmIHVybCwKICNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQogdm9pZCBOYXZpZ2F0b3I6OndlYmtpdEdldFVzZXJNZWRpYShjb25z dCBTdHJpbmcmIG9wdGlvbnMsIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0Nh bGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJy b3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYg KG1fZnJhbWUgJiYgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKSkKLSAgICAg ICAgbV9mcmFtZS0+bWVkaWFTdHJlYW1GcmFtZUNvbnRyb2xsZXIoKS0+Z2VuZXJhdGVTdHJlYW0o b3B0aW9ucywgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNhbGxiYWNrLCBlYyk7CisgICAgaWYgKCFz dWNjZXNzQ2FsbGJhY2spCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9mcmFtZSkKKyAg ICAgICAgcmV0dXJuOworCisgICAgUGFnZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKTsKKyAgICBp ZiAoIXBhZ2UpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0 PiByZXF1ZXN0ID0gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKG1fZnJhbWUtPmRvY3VtZW50KCks IHBhZ2UtPnVzZXJNZWRpYUNsaWVudCgpLCBvcHRpb25zLCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9y Q2FsbGJhY2spOworICAgIGlmICghcmVxdWVzdCkgeworICAgICAgICBlYyA9IE5PVF9TVVBQT1JU RURfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgcmVxdWVzdC0+c3RhcnQoKTsK IH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL05hdmlnYXRvclVz ZXJNZWRpYUVycm9yQ2FsbGJhY2suaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yVXNl ck1lZGlhRXJyb3JDYWxsYmFjay5oCmluZGV4IDE1Mzk3MDkuLmRkM2M4YjMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjay5o CkBAIC0yNywxNCArMjcsMTIgQEAKIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCiAKLSNpbmNs dWRlICJDYWxsYmFja1Rhc2suaCIKICNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvci5o IgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot Y2xhc3MgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjayA6IHB1YmxpYyBSZWZDb3VudGVk PE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+LAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHB1YmxpYyBDYWxsYmFja1Rhc2sxPE5hdmlnYXRvclVzZXJNZWRp YUVycm9yQ2FsbGJhY2ssIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPjo6U2NoZWR1bGVyIHsKK2Ns YXNzIE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2sgOiBwdWJsaWMgUmVmQ291bnRlZDxO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrPiB7CiBwdWJsaWM6CiAgICAgdmlydHVhbCB+ TmF2aWdhdG9yVXNlck1lZGlhRXJyb3JDYWxsYmFjaygpIHsgfQogICAgIHZpcnR1YWwgYm9vbCBo YW5kbGVFdmVudChOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvciopID0gMDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3Bw CmluZGV4IDA5ZDdlMDUuLjVlNzc0Y2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv UGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcApAQCAtODEsOCArODEs NyBAQAogI2VuZGlmCiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFNKQotI2luY2x1ZGUgIk1lZGlh U3RyZWFtQ2xpZW50LmgiCi0jaW5jbHVkZSAiTWVkaWFTdHJlYW1Db250cm9sbGVyLmgiCisjaW5j bHVkZSAiVXNlck1lZGlhQ2xpZW50LmgiCiAjZW5kaWYKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpA QCAtMTM4LDEyICsxMzcsMTIgQEAgUGFnZTo6UGFnZShQYWdlQ2xpZW50cyYgcGFnZUNsaWVudHMp CiAgICAgLCBtX2RldmljZU1vdGlvbkNvbnRyb2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6 ZGV2aWNlTW90aW9uRW5hYmxlZCgpID8gYWRvcHRQdHIobmV3IERldmljZU1vdGlvbkNvbnRyb2xs ZXIocGFnZUNsaWVudHMuZGV2aWNlTW90aW9uQ2xpZW50KSkgOiBudWxscHRyKQogICAgICwgbV9k ZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXIoUnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZGV2aWNl T3JpZW50YXRpb25FbmFibGVkKCkgPyBhZG9wdFB0cihuZXcgRGV2aWNlT3JpZW50YXRpb25Db250 cm9sbGVyKHRoaXMsIHBhZ2VDbGllbnRzLmRldmljZU9yaWVudGF0aW9uQ2xpZW50KSkgOiBudWxs cHRyKQogI2VuZGlmCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAgICAsIG1fbWVkaWFTdHJl YW1Db250cm9sbGVyKFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6Om1lZGlhU3RyZWFtRW5hYmxlZCgp ID8gYWRvcHRQdHIobmV3IE1lZGlhU3RyZWFtQ29udHJvbGxlcihwYWdlQ2xpZW50cy5tZWRpYVN0 cmVhbUNsaWVudCkpIDogUGFzc093blB0cjxNZWRpYVN0cmVhbUNvbnRyb2xsZXI+KCkpCi0jZW5k aWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNIKQogICAgICwgbV9zcGVlY2hJbnB1dENsaWVudChw YWdlQ2xpZW50cy5zcGVlY2hJbnB1dENsaWVudCkKICNlbmRpZgorI2lmIEVOQUJMRShNRURJQV9T VFJFQU0pCisgICAgLCBtX3VzZXJNZWRpYUNsaWVudChwYWdlQ2xpZW50cy51c2VyTWVkaWFDbGll bnQpCisjZW5kaWYKICAgICAsIG1fc2V0dGluZ3MoYWRvcHRQdHIobmV3IFNldHRpbmdzKHRoaXMp KSkKICAgICAsIG1fcHJvZ3Jlc3MoYWRvcHRQdHIobmV3IFByb2dyZXNzVHJhY2tlcikpCiAgICAg LCBtX2JhY2tGb3J3YXJkQ29udHJvbGxlcihhZG9wdFB0cihuZXcgQmFja0ZvcndhcmRDb250cm9s bGVyKHRoaXMsIHBhZ2VDbGllbnRzLmJhY2tGb3J3YXJkQ2xpZW50KSkpCkBAIC0yMTEsNiArMjEw LDExIEBAIFBhZ2U6On5QYWdlKCkKICAgICBtX2luc3BlY3RvckNvbnRyb2xsZXItPmluc3BlY3Rl ZFBhZ2VEZXN0cm95ZWQoKTsKICNlbmRpZgogCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKyAg ICBpZiAobV91c2VyTWVkaWFDbGllbnQpCisgICAgICAgIG1fdXNlck1lZGlhQ2xpZW50LT5wYWdl RGVzdHJveWVkKCk7CisjZW5kaWYKKwogICAgIGJhY2tGb3J3YXJkKCktPmNsb3NlKCk7CiAKICNp Zm5kZWYgTkRFQlVHCkBAIC0xMDU5LDcgKzEwNjMsNyBAQCBQYWdlOjpQYWdlQ2xpZW50czo6UGFn ZUNsaWVudHMoKQogICAgICwgZGV2aWNlTW90aW9uQ2xpZW50KDApCiAgICAgLCBkZXZpY2VPcmll bnRhdGlvbkNsaWVudCgwKQogICAgICwgc3BlZWNoSW5wdXRDbGllbnQoMCkKLSAgICAsIG1lZGlh U3RyZWFtQ2xpZW50KDApCisgICAgLCB1c2VyTWVkaWFDbGllbnQoMCkKIHsKIH0KIApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bh Z2UuaAppbmRleCBmOWY4ZDcyLi5hODM0N2U4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL1BhZ2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaApAQCAtNzEsOCArNzEs NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgSW5zcGVjdG9yQ2xpZW50OwogICAg IGNsYXNzIEluc3BlY3RvckNvbnRyb2xsZXI7CiAgICAgY2xhc3MgTWVkaWFDYW5TdGFydExpc3Rl bmVyOwotICAgIGNsYXNzIE1lZGlhU3RyZWFtQ2xpZW50OwotICAgIGNsYXNzIE1lZGlhU3RyZWFt Q29udHJvbGxlcjsKICAgICBjbGFzcyBOb2RlOwogICAgIGNsYXNzIFBhZ2VHcm91cDsKICAgICBj bGFzcyBQbHVnaW5EYXRhOwpAQCAtODQsNiArODIsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgY2xhc3MgU2V0dGluZ3M7CiAgICAgY2xhc3MgU3BlZWNoSW5wdXQ7CiAgICAgY2xhc3MgU3Bl ZWNoSW5wdXRDbGllbnQ7CisgICAgY2xhc3MgVXNlck1lZGlhQ2xpZW50OwogICAgIGNsYXNzIFN0 b3JhZ2VOYW1lc3BhY2U7CiAjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAgICAgY2xhc3MgTm90 aWZpY2F0aW9uUHJlc2VudGVyOwpAQCAtMTE4LDcgKzExNyw3IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgICAgIERldmljZU9yaWVudGF0aW9uQ2xpZW50KiBkZXZpY2VPcmllbnRhdGlv bkNsaWVudDsKICAgICAgICAgICAgIFJlZlB0cjxCYWNrRm9yd2FyZExpc3Q+IGJhY2tGb3J3YXJk Q2xpZW50OwogICAgICAgICAgICAgU3BlZWNoSW5wdXRDbGllbnQqIHNwZWVjaElucHV0Q2xpZW50 OwotICAgICAgICAgICAgTWVkaWFTdHJlYW1DbGllbnQqIG1lZGlhU3RyZWFtQ2xpZW50OworICAg ICAgICAgICAgVXNlck1lZGlhQ2xpZW50KiB1c2VyTWVkaWFDbGllbnQ7CiAgICAgICAgIH07CiAK ICAgICAgICAgUGFnZShQYWdlQ2xpZW50cyYpOwpAQCAtMTg0LDEyICsxODMsMTIgQEAgbmFtZXNw YWNlIFdlYkNvcmUgewogICAgICAgICBEZXZpY2VNb3Rpb25Db250cm9sbGVyKiBkZXZpY2VNb3Rp b25Db250cm9sbGVyKCkgY29uc3QgeyByZXR1cm4gbV9kZXZpY2VNb3Rpb25Db250cm9sbGVyLmdl dCgpOyB9CiAgICAgICAgIERldmljZU9yaWVudGF0aW9uQ29udHJvbGxlciogZGV2aWNlT3JpZW50 YXRpb25Db250cm9sbGVyKCkgY29uc3QgeyByZXR1cm4gbV9kZXZpY2VPcmllbnRhdGlvbkNvbnRy b2xsZXIuZ2V0KCk7IH0KICNlbmRpZgotI2lmIEVOQUJMRShNRURJQV9TVFJFQU0pCi0gICAgICAg IE1lZGlhU3RyZWFtQ29udHJvbGxlciogbWVkaWFTdHJlYW1Db250cm9sbGVyKCkgY29uc3QgeyBy ZXR1cm4gbV9tZWRpYVN0cmVhbUNvbnRyb2xsZXIuZ2V0KCk7IH0KLSNlbmRpZgogI2lmIEVOQUJM RShJTlBVVF9TUEVFQ0gpCiAgICAgICAgIFNwZWVjaElucHV0KiBzcGVlY2hJbnB1dCgpOwogI2Vu ZGlmCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKyAgICAgICAgVXNlck1lZGlhQ2xpZW50KiB1 c2VyTWVkaWFDbGllbnQoKSBjb25zdCB7IHJldHVybiBtX3VzZXJNZWRpYUNsaWVudDsgfQorI2Vu ZGlmCiAgICAgICAgIFNldHRpbmdzKiBzZXR0aW5ncygpIGNvbnN0IHsgcmV0dXJuIG1fc2V0dGlu Z3MuZ2V0KCk7IH0KICAgICAgICAgUHJvZ3Jlc3NUcmFja2VyKiBwcm9ncmVzcygpIGNvbnN0IHsg cmV0dXJuIG1fcHJvZ3Jlc3MuZ2V0KCk7IH0KICAgICAgICAgQmFja0ZvcndhcmRDb250cm9sbGVy KiBiYWNrRm9yd2FyZCgpIGNvbnN0IHsgcmV0dXJuIG1fYmFja0ZvcndhcmRDb250cm9sbGVyLmdl dCgpOyB9CkBAIC0zNjYsMTMgKzM2NSwxMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAg IE93blB0cjxEZXZpY2VNb3Rpb25Db250cm9sbGVyPiBtX2RldmljZU1vdGlvbkNvbnRyb2xsZXI7 CiAgICAgICAgIE93blB0cjxEZXZpY2VPcmllbnRhdGlvbkNvbnRyb2xsZXI+IG1fZGV2aWNlT3Jp ZW50YXRpb25Db250cm9sbGVyOwogI2VuZGlmCi0jaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKLSAg ICAgICAgT3duUHRyPE1lZGlhU3RyZWFtQ29udHJvbGxlcj4gbV9tZWRpYVN0cmVhbUNvbnRyb2xs ZXI7Ci0jZW5kaWYKICNpZiBFTkFCTEUoSU5QVVRfU1BFRUNIKQogICAgICAgICBTcGVlY2hJbnB1 dENsaWVudCogbV9zcGVlY2hJbnB1dENsaWVudDsKICAgICAgICAgT3duUHRyPFNwZWVjaElucHV0 PiBtX3NwZWVjaElucHV0OwogI2VuZGlmCisjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKKyAgICAg ICAgVXNlck1lZGlhQ2xpZW50KiBtX3VzZXJNZWRpYUNsaWVudDsKKyNlbmRpZgogICAgICAgICBP d25QdHI8U2V0dGluZ3M+IG1fc2V0dGluZ3M7CiAgICAgICAgIE93blB0cjxQcm9ncmVzc1RyYWNr ZXI+IG1fcHJvZ3Jlc3M7CiAgICAgICAgIAo=