53188 2011-01-26 12:57:15 -0800 requestAnimationFrame callbacks should not fire within a modal dialog 2011-02-15 16:53:47 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 1 jamesr jamesr ap darin eric.carlson fishd mihaip mjs simon.fraser oldest_to_newest 340421 0 jamesr 2011-01-26 12:57:15 -0800 requestAnimationFrame callbacks should not fire within a modal dialog 340457 1 80234 jamesr 2011-01-26 14:08:15 -0800 Created attachment 80234 Patch 340560 2 jamesr 2011-01-26 16:22:27 -0800 Actually, it turns out that firefox does fire the callbacks under the modal dialog: https://bugzilla.mozilla.org/show_bug.cgi?id=629192, but that's a bug on their end. 341152 3 80234 mihaip 2011-01-27 17:15:59 -0800 Comment on attachment 80234 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=80234&action=review > Source/WebCore/dom/Document.h:1409 > + OwnPtr<RequestAnimationFrameController> m_requestAnimationFrameCallbacks; Shouldn't this be called m_requestAnimationFrameController? > Source/WebCore/dom/RequestAnimationFrameController.cpp:106 > + // them until nothing new becomes visible. Not sure I understand the "nothing new becomes visible" stopping condition. From reading the code, it looks like you keep going until you've fired all callbacks that weren't cancelled or attached to an invisible element. 341537 4 ap 2011-01-28 11:06:33 -0800 This is quite related to what happens for media elements, so CC'ing Eric Carlson. It's not really clear if the principle of "nothing observable from JS should happen asynchronously, and in particular below modal dialogs" is still sustainable. Media elements have to update things like current time asynchronously, and at this point, you've already violated the general principle, and can as well invoke event handlers. 341571 5 80234 simon.fraser 2011-01-28 11:33:29 -0800 Comment on attachment 80234 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=80234&action=review > Source/WebCore/dom/Document.cpp:4963 > + m_requestAnimationFrameCallbacks = new RequestAnimationFrameController(this); We avoid uses of bare 'new' now in favor of adoptPtr(). 341762 6 80234 jamesr 2011-01-28 14:55:52 -0800 Comment on attachment 80234 Patch Thanks for the feedback, I'll fix the issues raised and post a new patch. 341800 7 80510 jamesr 2011-01-28 15:32:12 -0800 Created attachment 80510 Patch 341803 8 jamesr 2011-01-28 15:34:00 -0800 Updated to address review feedback. There appears to still be debate about whether ActiveDOMObject is the ideal mechanism for this (see bugs 53202 and 24030), but resolving that seems mostly orthogonal to this bugfix. When/if ActiveDOMObject is adjusted this code can be migrated similarly. 341859 9 80510 ap 2011-01-28 16:53:20 -0800 Comment on attachment 80510 Patch As discussed on IRC, it's not at all obvious that this should be done at all. I suggest a webkit-dev discussion. 341862 10 ap 2011-01-28 16:54:11 -0800 On a technical side, I strongly disagree with further abusing ActiveDOMObject. 341878 11 jamesr 2011-01-28 16:59:33 -0800 (In reply to comment #9) > (From update of attachment 80510 [details]) > As discussed on IRC, it's not at all obvious that this should be done at all. I suggest a webkit-dev discussion. I disagree (as does mozilla) - the default for new APIs should definitely be not to violate run-to-completion. I don't think this is controversial, regardless of the desired behavior for legacy APIs that may have compatibility constraints. 341978 12 fishd 2011-01-28 21:00:18 -0800 (In reply to comment #11) > (In reply to comment #9) > > (From update of attachment 80510 [details] [details]) > > As discussed on IRC, it's not at all obvious that this should be done at all. I suggest a webkit-dev discussion. > > I disagree (as does mozilla) - the default for new APIs should definitely be not to violate run-to-completion. I don't think this is controversial, regardless of the desired behavior for legacy APIs that may have compatibility constraints. Ditto. It is very problematic to violate run-to-completion. Alexey, if your goal is to allow animations to work nicely while an alert() is showing, then I disagree with that goal. It is not worth the risk. Page authors shouldn't have to write re-entrant safe code just because some library decides to pop an alert! 341980 13 fishd 2011-01-28 21:03:30 -0800 (In reply to comment #4) > This is quite related to what happens for media elements, so CC'ing Eric Carlson. It's not really clear if the principle of "nothing observable from JS should happen asynchronously, and in particular below modal dialogs" is still sustainable. > > Media elements have to update things like current time asynchronously, and at this point, you've already violated the general principle, and can as well invoke event handlers. I think there is a difference between updating DOM object state while an alert is showing and allowing javascript to execute under an alert. The former can certainly be confusing but the latter requires unsuspecting code to be re-entrant! 342001 14 ap 2011-01-28 22:52:40 -0800 The theory that I heard from Mozilla folks was that state (including cookies!) also shouldn't change. What I see here is that a lot of effort is being poured into a theory that doesn't stand very well, including both implementation changes and spec ones (like the dreaded storage mutex). Some of the theory's requirements contradict common sense (like media elements' current time attribute behavior), or make user experience worse (what's wrong with animations playing nicely)? I think that changes in this area shouldn't be rushed, and may warrant a wider webkit-dev discussion. > Page authors shouldn't have to write re-entrant safe code just because some library decides to pop an alert! We can't fully avoid that - a library can call showModalDialog, whose code can dispatch events in the opener etc. It is also not clear whether we should disable some other events below modal alerts and dialogs. One example that came to my mind is orientation events - I expect a page displaying an alert to rotate when I rotate my iPhone, and orientation events by design are needed to properly rotate. Others may come up with more examples. There are contradicting arguments to make here. On one hand, making reentrancy less frequent makes problems less frequent. On the other hand, it makes such problem less known to us and web developers, leading to more instability and potentially exploitable crashes. 342417 15 jamesr 2011-01-30 18:41:21 -0800 (In reply to comment #14) > The theory that I heard from Mozilla folks was that state (including cookies!) also shouldn't change. > > What I see here is that a lot of effort is being poured into a theory that doesn't stand very well, including both implementation changes and spec ones (like the dreaded storage mutex). Some of the theory's requirements contradict common sense (like media elements' current time attribute behavior), or make user experience worse (what's wrong with animations playing nicely)? > > I think that changes in this area shouldn't be rushed, and may warrant a wider webkit-dev discussion. Are you saying that you disagree with run-to-completion? This behavior is clearly specced (see http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-alert and http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#pause) so if you think this is unwise I'd suggest raising it in the WHATWG. > > > Page authors shouldn't have to write re-entrant safe code just because some library decides to pop an alert! > > We can't fully avoid that - a library can call showModalDialog, whose code can dispatch events in the opener etc. > > It is also not clear whether we should disable some other events below modal alerts and dialogs. One example that came to my mind is orientation events - I expect a page displaying an alert to rotate when I rotate my iPhone, and orientation events by design are needed to properly rotate. Others may come up with more examples. Why would orientation events be treated differently from any other sort of event that may trigger a change to the UI? Authors who want a responsive UI should, obviously, minimize their use of modal dialogs. I don't see why this sort of event requires special treatment. > > There are contradicting arguments to make here. On one hand, making reentrancy less frequent makes problems less frequent. On the other hand, it makes such problem less known to us and web developers, leading to more instability and potentially exploitable crashes. In cases where it is easy and straightforward to avoid reentrancy (such as this one) I think it's best to avoid it. 342420 16 simon.fraser 2011-01-30 18:58:38 -0800 It seems like the real answer is a non-blocking dialog API. 342421 17 jamesr 2011-01-30 19:05:36 -0800 (In reply to comment #16) > It seems like the real answer is a non-blocking dialog API. Definitely, but we would still need to deal with legacy code even if we had a non-blocking dialog API. 342458 18 80618 jamesr 2011-01-30 21:47:32 -0800 Created attachment 80618 adds a test 342459 19 jamesr 2011-01-30 21:49:08 -0800 Adds a layout test. If you still object to the use of ActiveDOMObject, Alexey, please let me know what specifically you have a problem with so that I can address it and land this bugfix. I don't think the overhead should be a problem given that there will be at most one RequestAnimationFrameController per Document. 342469 20 80618 ap 2011-01-30 22:17:38 -0800 Comment on attachment 80618 adds a test ActiveDOMObject shouldn't be used with objects that don't have a JS wrapper. Darin mentioned that this fix breaks "nice animations". If so, just do this. We can revisit this after Firefox 5 comes out, and if it really has this fix. 342486 21 80622 jamesr 2011-01-31 00:12:02 -0800 Created attachment 80622 without ActiveDOMObject 342487 22 jamesr 2011-01-31 00:14:16 -0800 (In reply to comment #20) > (From update of attachment 80618 [details]) > ActiveDOMObject shouldn't be used with objects that don't have a JS wrapper. > I've posted a new patch that does not use ActiveDOMObject. If you prefer we can use this pattern for EventQueue as well. > Darin mentioned that this fix breaks "nice animations". If so, just do this. We can revisit this after Firefox 5 comes out, and if it really has this fix. I'm not sure exactly what you are referring to here. This patch makes animations driven by webkitRequestAnimationFrame() behave identically to those driven by setTimeout(). As webkitRequestAnimationFrame is intended to be a drop-in replacement for setTimeout() for imperative animations, this is exactly the behavior we want. 342500 23 80622 ap 2011-01-31 01:38:29 -0800 Comment on attachment 80622 without ActiveDOMObject View in context: https://bugs.webkit.org/attachment.cgi?id=80622&action=review It may be unfair to pick on a single patch to question run to completion, and maybe my comments sound out of context because of that. But I do think that these issues need to be discussed in the WebKit community, and this time is as good as any. There doesn't seem to be any rush - I can see no indication that Mozilla will be changing this behavior before Firefox 5. > Source/WebCore/dom/Document.cpp:4741 > +void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension reason) > +{ > + ScriptExecutionContext::suspendActiveDOMObjects(reason); > +#if ENABLE(REQUEST_ANIMATION_FRAME) > + if (m_requestAnimationFrameController) > + m_requestAnimationFrameController->suspend(); > +#endif > +} I think it should be obvious that this is a no-go. A function called suspendActiveDOMObjects() cannot be affecting things that aren't ActiveDOMObjects. 342507 24 80622 jamesr 2011-01-31 02:01:17 -0800 Comment on attachment 80622 without ActiveDOMObject I think it's unreasonable to block a bugfix because you want to debate the execution model of the web. Feel free to start such a discussion, but in the meantime I strongly believe that requestAnimationFrame callbacks should not fire while modal dialogs are up. 342592 25 80622 ap 2011-01-31 08:37:05 -0800 Comment on attachment 80622 without ActiveDOMObject This patch already has r-, please don't set it back to r? just because you disagree. 342647 26 fishd 2011-01-31 10:14:47 -0800 (In reply to comment #23) > (From update of attachment 80622 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=80622&action=review > > It may be unfair to pick on a single patch to question run to completion, and maybe my comments sound out of context because of that. But I do think that these issues need to be discussed in the WebKit community, and this time is as good as any. There doesn't seem to be any rush - I can see no indication that Mozilla will be changing this behavior before Firefox 5. Alexey, I think you are putting a bit too much emphasis on matching Firefox behavior. The Mozilla code is fairly inconsistent about enforcing run-to-completion. That's not because of any intentional desire by the coders. Instead, I think we should focus on making WebKit good instead of just defacto matching Firefox. There are real problems impacting WebKit and web applications if we allow JS code to run underneath an alert. (I can go on at length about some of the weird problems if you like.) We should prevent it as a means of making WebKit more sane and reducing complexity for ourselves. Moreover, we should not try so hard to make the web platform "awesome" when an alert dialog is showing because alert is a horrifically bad API that'll never work great. We should instead put our energy into making the web platform awesome when an alert dialog is NOT showing, and we should complement that by adding an API for an asynchronous alert dialogs. Enforcing run-to-completion consistently has been the status-quo for WebKit. I was always impressed to see how well this was implemented (again referring to how messy it is in Mozilla), and I think it makes sense for run-to-completion to remain the default behavior for WebKit. If we need to violate that in a particular scenario, then we should have a thoughtful discussion about why. 342693 27 jamesr 2011-01-31 11:16:34 -0800 I doubt many web authors (especially library authors) will be excited about adopting this API instead of setTimeout if it means they have to defend against arbitrary reentrancy in their animation systems. 342700 28 ap 2011-01-31 11:24:39 -0800 You may be right, or they could be excited that this API actually provides a benefit over setInterval in that the animation doesn't stop below modal dialogs. 342707 29 simon.fraser 2011-01-31 11:29:04 -0800 I don't think most users of this API will give a hoot about modal dialogs. 342722 30 jamesr 2011-01-31 11:56:45 -0800 (In reply to comment #29) > I don't think most users of this API will give a hoot about modal dialogs. Users who write animation libraries (like jquery, scriptaculus, etc) will have to worry about making their code robust. 342749 31 simon.fraser 2011-01-31 12:33:27 -0800 (In reply to comment #30) > (In reply to comment #29) > > I don't think most users of this API will give a hoot about modal dialogs. > > Users who write animation libraries (like jquery, scriptaculus, etc) will have to worry about making their code robust. Right, but I don't think they'll complain if the animation stops while an alert is up. They should be smart enough to not use modal alerts. 342756 32 jamesr 2011-01-31 12:40:50 -0800 (In reply to comment #31) > (In reply to comment #30) > > (In reply to comment #29) > > > I don't think most users of this API will give a hoot about modal dialogs. > > > > Users who write animation libraries (like jquery, scriptaculus, etc) will have to worry about making their code robust. > > Right, but I don't think they'll complain if the animation stops while an alert is up. They should be smart enough to not use modal alerts. Ah yes - I agree completely :) 347620 33 80622 simon.fraser 2011-02-08 13:05:19 -0800 Comment on attachment 80622 without ActiveDOMObject View in context: https://bugs.webkit.org/attachment.cgi?id=80622&action=review I think the patch is fine other than some naming issues. Leaving the r- so we can see another patch. If we need to reconsider allowing animations to run under modal dialogs, that should be another bug. >> Source/WebCore/dom/Document.cpp:4741 >> +} > > I think it should be obvious that this is a no-go. A function called suspendActiveDOMObjects() cannot be affecting things that aren't ActiveDOMObjects. Agreed. This method could be renamed, or you could create a wrapper method. > Source/WebCore/dom/Document.h:1413 > + OwnPtr<RequestAnimationFrameController> m_requestAnimationFrameController; I think this could be called m_animationFrameController, or m_scriptedAnimationController. > Source/WebCore/dom/RequestAnimationFrameController.cpp:53 > + m_suspended = true; Should you allow nesting? > Source/WebCore/dom/RequestAnimationFrameController.cpp:58 > + m_suspended = false; Is it OK if we're not suspended? > Source/WebCore/dom/RequestAnimationFrameController.h:42 > +class RequestAnimationFrameController { Maybe rename to AnimationFrameController, or ScriptedAnimationController? > Source/WebCore/dom/RequestAnimationFrameController.h:51 > + int registerCallback(PassRefPtr<RequestAnimationFrameCallback>, Element*); Consider a typedef for the return value? > Source/WebCore/dom/RequestAnimationFrameController.h:52 > + void cancelCallback(int id); No need for 'id' > Source/WebCore/dom/RequestAnimationFrameController.h:53 > + void serviceScriptedAnimations(DOMTimeStamp); Will there be kinds other than scripted? > Source/WebCore/dom/RequestAnimationFrameController.h:65 > + int m_nextCallbackId; > + bool m_suspended; > + Document* m_document; Put m_document first for better alignment. 347628 34 ap 2011-02-08 13:16:03 -0800 I still object to making changes like this without a webkit-dev discussion. 347630 35 jamesr 2011-02-08 13:18:03 -0800 (In reply to comment #34) > I still object to making changes like this without a webkit-dev discussion. Then please start the discussion on webkit-dev. 347657 36 jamesr 2011-02-08 13:54:47 -0800 (In reply to comment #33) > (From update of attachment 80622 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=80622&action=review > > I think the patch is fine other than some naming issues. Leaving the r- so we can see another patch. > > If we need to reconsider allowing animations to run under modal dialogs, that should be another bug. > > >> Source/WebCore/dom/Document.cpp:4741 > >> +} > > > > I think it should be obvious that this is a no-go. A function called suspendActiveDOMObjects() cannot be affecting things that aren't ActiveDOMObjects. > > Agreed. This method could be renamed, or you could create a wrapper method. I'll add a wrapper method to separate the ActiveDOMObject concerns from suspending callbacks that aren't ActiveDOMObjects. > > > Source/WebCore/dom/Document.h:1413 > > + OwnPtr<RequestAnimationFrameController> m_requestAnimationFrameController; > > I think this could be called m_animationFrameController, or m_scriptedAnimationController. > > > Source/WebCore/dom/RequestAnimationFrameController.h:42 > > +class RequestAnimationFrameController { > > Maybe rename to AnimationFrameController, or ScriptedAnimationController? > > > Source/WebCore/dom/RequestAnimationFrameController.h:53 > > + void serviceScriptedAnimations(DOMTimeStamp); > > Will there be kinds other than scripted? I like ScriptedAnimationController, I'll rename it to that. I do not anticipate that we'll use this mechanism for anything other than scripted animations. > > Source/WebCore/dom/RequestAnimationFrameController.cpp:53 > > + m_suspended = true; > > Should you allow nesting? > > > Source/WebCore/dom/RequestAnimationFrameController.cpp:58 > > + m_suspended = false; > > Is it OK if we're not suspended? I'll change this to a suspension count so it properly handles nesting (i.e. if there are multiple suspend() calls, wait until a matching number of resume() calls are made before firing callbacks again). 347665 37 81690 jamesr 2011-02-08 14:11:42 -0800 Created attachment 81690 Patch 347678 38 81690 ap 2011-02-08 14:23:22 -0800 Comment on attachment 81690 Patch Automatic r-. 347763 39 ap 2011-02-08 15:55:37 -0800 I thought that is was obvious from previous comments, but apparently it wasn't. The reasons for r- are all the same, as the patch still plugs into ActiveDOMObject code for something different. Per IRC discussion, I see two ways to proceed: (1) enumerate the use cases for "suspending", and then create a design for suspending things that agrees with reality. (2) hook this code into a different place, getting rid of a pretense that you're using some established generic mechanism that exists in WebCore (it doesn't exist). 347770 40 jamesr 2011-02-08 16:00:59 -0800 (In reply to comment #39) > I thought that is was obvious from previous comments, but apparently it wasn't. The reasons for r- are all the same, as the patch still plugs into ActiveDOMObject code for something different. Per IRC discussion, I see two ways to proceed: > > (1) enumerate the use cases for "suspending", and then create a design for suspending things that agrees with reality. > (2) hook this code into a different place, getting rid of a pretense that you're using some established generic mechanism that exists in WebCore (it doesn't exist). I don't see why either of these (are they supposed to be independent?) should block this patch. This patch integrates with the suspend/resume system we have today. If we come up with an alternate suspend/resume mechanism then so long as the interaction with the Document is the same, this patch will apply. I do think it's completely unreasonable to block this patch on creating a replacement suspend/resume mechanism. 347782 41 mjs 2011-02-08 16:18:35 -0800 Does this bug have an actual end-user symptom? James mentioned on IRC that this "breaks the js debugger", but that info is nowhere in the bug: <jamesr_> ap: currently i'm in a situation where this API breaks the js debugger, because it does not suspend as it should. Can someone please confirm whether there is debugger breakage, and more specifically what is broken (e.g. steps to reproduce)? 347787 42 jamesr 2011-02-08 16:20:56 -0800 (In reply to comment #41) > Does this bug have an actual end-user symptom? James mentioned on IRC that this "breaks the js debugger", but that info is nowhere in the bug: > > <jamesr_> ap: currently i'm in a situation where this API breaks the js debugger, because it does not suspend as it should. > > Can someone please confirm whether there is debugger breakage, and more specifically what is broken (e.g. steps to reproduce)? Without this patch anything that relies on the suspend/resume mechanism breaks. This means, in particular, if a page is using webkitRequestAnimationFrame and the page opens a modal dialog or someone attempts to pause execution using the Inspector's JS debugger, or an external JS debugger, the page breaks because the callbacks continue firing. Try setting a breakpoint within a requestAnimationFrame callback itself to see what happens (hint: it's not pretty). This makes it pretty much impossible to develop pages using the new API, which ap apparently does not think is valuable anyway. 347823 43 ap 2011-02-08 17:07:21 -0800 > This patch integrates with the suspend/resume system we have today. There is no real system to speak of. Adding things to it is unhelpful. You're saying that these ScriptExecutionContext suspend/resume calls are made at exactly the right times now, why not just make animation suspend/resume calls on the next line? That way, they won't be affected when ScriptExecutionContext calls change. 347826 44 fishd 2011-02-08 17:10:48 -0800 (In reply to comment #43) > > This patch integrates with the suspend/resume system we have today. > > There is no real system to speak of. Adding things to it is unhelpful. > > You're saying that these ScriptExecutionContext suspend/resume calls are made at exactly the right times now, why not just make animation suspend/resume calls on the next line? That way, they won't be affected when ScriptExecutionContext calls change. ^^^ This seems like a reasonable approach to me. One could generalize it so that at the callsite we only need a pair of suspend/resumeThingers methods, so as to create a common pinchpoint, but maybe that is not necessary. 347832 45 ap 2011-02-08 17:19:36 -0800 I'd feel uncomfortable about generalized suspend/resumeThingers without a design enumerating use cases and how they fit in the model. We almost never do this for WebKit, but the multiple year confusion in this area makes me feel that one is needed. 347848 46 mjs 2011-02-08 17:34:41 -0800 (In reply to comment #45) > I'd feel uncomfortable about generalized suspend/resumeThingers without a design enumerating use cases and how they fit in the model. We almost never do this for WebKit, but the multiple year confusion in this area makes me feel that one is needed. Since James clarified that there is a real and urgent end-user symptom to this issue, I think it is reasonable to do a stopgap fix and then have that wider discussion. If there wasn't a concrete symptom (something I didn't know until today), then I'd agree that we should get the design straight first. One thought: in the long run, perhaps the debugger should stall/suspend more things than a modal dialog would, since in that case, there truly is an expectation of freezing the world. Even CSS transitions, CSS animations and media should stop when you are at a debugger breakpoint, I would presume. 351574 47 jamesr 2011-02-15 14:31:34 -0800 (In reply to comment #46) > (In reply to comment #45) > > I'd feel uncomfortable about generalized suspend/resumeThingers without a design enumerating use cases and how they fit in the model. We almost never do this for WebKit, but the multiple year confusion in this area makes me feel that one is needed. > > Since James clarified that there is a real and urgent end-user symptom to this issue, I think it is reasonable to do a stopgap fix and then have that wider discussion. Would you mind reviewing the patch as it is now, or suggesting other measures that should be taken at this point rather than later? I'd still like to land something ASAP. > > If there wasn't a concrete symptom (something I didn't know until today), then I'd agree that we should get the design straight first. > > One thought: in the long run, perhaps the debugger should stall/suspend more things than a modal dialog would, since in that case, there truly is an expectation of freezing the world. Even CSS transitions, CSS animations and media should stop when you are at a debugger breakpoint, I would presume. 351585 48 ap 2011-02-15 14:37:51 -0800 I talked to Darin Fisher, and he agreed that (2) is the way to go as a stopgap fix. Please don't override the r-. 351613 49 82528 jamesr 2011-02-15 14:57:39 -0800 Created attachment 82528 with explicit extra suspend/resume calls 351619 50 jamesr 2011-02-15 14:59:31 -0800 This implements what I believe you suggested. In effect, every* call to (suspend|resume)ActiveDOMObjects() now makes an additional call to (suspend|resume)Callbacks(). *qt appears to expose qt_suspendActiveDOMObjects() and qt_resumeActiveDOMObjects(). As far as I can tell these functions are uncalled - there are no in-tree callers and google code search can't find any references to these outside the WebKit project - but I'll leave the implementation along until someone with familiarity with the Qt port can comment on what these functions are supposed to do. 351625 51 82528 ap 2011-02-15 15:02:23 -0800 Comment on attachment 82528 with explicit extra suspend/resume calls +void Document::suspendCallbacks() +{ +#if ENABLE(REQUEST_ANIMATION_FRAME) + if (m_scriptedAnimationController) + m_scriptedAnimationController->suspend(); +#endif +} What is the meaning of this function? Why isn't it called suspendScriptedAnimationControllerCallbacks? I think that it should be. 351629 52 jamesr 2011-02-15 15:05:03 -0800 (In reply to comment #51) > (From update of attachment 82528 [details]) > +void Document::suspendCallbacks() > +{ > +#if ENABLE(REQUEST_ANIMATION_FRAME) > + if (m_scriptedAnimationController) > + m_scriptedAnimationController->suspend(); > +#endif > +} > > What is the meaning of this function? Why isn't it called suspendScriptedAnimationControllerCallbacks? I think that it should be. That's a good description of what this function does today. I think as far as the ScriptExecutionContext interface is concerned, the important part for callers to know is that invoking the suspendCallbacks() function prevents callbacks of any sort from running on the context and the resumeCallbacks() does the inverse, and it shouldn't be a concern of the caller what the nature of the callbacks is. I'd be happy to rename the function if it will unblock landing this. 351643 53 82534 jamesr 2011-02-15 15:18:36 -0800 Created attachment 82534 with rename 351652 54 ap 2011-02-15 15:27:29 -0800 Thank you for renaming the functions. "Callback" can mean a lot of things in different contexts, so looking at a "suspendCallbacks" function doesn't really tell one anything about what it does or when it should be called. For example, currently there are suspendPostAttachCallbacks(), unregisterForDocumentActivationCallbacks(), unregisterForMediaVolumeCallbacks(), and argument callbacks in processArguments() - and that's in Document alone. + virtual void suspendCallbacks() {} + virtual void resumeCallbacks() {} There should be spaces between braces. + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY Pelase use a correct license block. +#include "config.h" + +#include "ScriptedAnimationController.h" There shouldn't be a space between these lines. + m_suspendCount++; There is no reason to use post increment here, so stylistically it's slightly nicer to use pre-increment. + m_suspendCount--; Ditto. + if (FrameView* fv = m_document->view()) Please don't abbreviate frameView. I don't understand how this gets away with only implementing suspend/resume and not stop, but OK. + if (FrameView* v = m_document->view()) Please don't abbreviate. +} // namespace WebCore As discussed on webkit-dev, it's best to avoid these comments for whole file namespaces. The only time they can useful, you are not going to trust them anyway, and normally it's just noise. + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY Please use a correct license block. + static PassOwnPtr<ScriptedAnimationController> create(Document* d) Please don't a. I couldn't find what protects RequestAnimationFrameCallback from garbage collection. I expected to see that code in JSDocumentCustom.cpp. 351659 55 jamesr 2011-02-15 15:34:16 -0800 (In reply to comment #54) > Thank you for renaming the functions. "Callback" can mean a lot of things in different contexts, so looking at a "suspendCallbacks" function doesn't really tell one anything about what it does or when it should be called. > > For example, currently there are suspendPostAttachCallbacks(), unregisterForDocumentActivationCallbacks(), unregisterForMediaVolumeCallbacks(), and argument callbacks in processArguments() - and that's in Document alone. > > + virtual void suspendCallbacks() {} > + virtual void resumeCallbacks() {} > > There should be spaces between braces. > > + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY > > Pelase use a correct license block. I believe I am using the correct license block. Which part is incorrect? > I couldn't find what protects RequestAnimationFrameCallback from garbage collection. I expected to see that code in JSDocumentCustom.cpp. The RequestAnimationFrameCallback item is held by a reference count held by the ScriptedAnimationController, which is owned (via an OwnPtr<>) by the Document object. The javascript wrapper for the RequestAnimationFrameCallback is not currently protected from GC. I plan to address that issue ASAP (as a separate patch). I'll address the rest of the comments and post a new patch. 351663 56 82535 jamesr 2011-02-15 15:37:59 -0800 Created attachment 82535 Patch 351683 57 82535 ap 2011-02-15 15:54:42 -0800 Comment on attachment 82535 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=82535&action=review > I believe I am using the correct license block. Which part is incorrect? Apple Computer, Inc. has been renamed to Apple, Inc. some time ago. We have the canonical text of the license at <http://www.webkit.org/coding/bsd-license.html>, although I think that most Google contributors use a slightly different one. I'd like to know where it comes from, so that I could point that out in review more specifically than "please ask your manager". > I plan to address that issue ASAP (as a separate patch). Yes, the GC issue is certainly for a separate patch. > Source/WebCore/dom/Document.cpp:4917 > + return m_scriptedAnimationController->registerCallback(callback, e); Missed this one - please don't abbreviate "element". This could actually use a name that explains what element it is (targetElement? animationElement? rootElement?) > Source/WebCore/dom/ScriptedAnimationController.cpp:29 > +#include "config.h" > + > +#include "ScriptedAnimationController.h" This still has an extra newline. > Source/WebCore/dom/ScriptedAnimationController.cpp:60 > +ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(PassRefPtr<RequestAnimationFrameCallback> callback, Element* e) Please don't abbreviate "element" > Source/WebCore/dom/ScriptedAnimationController.h:69 > +} // namespace WebCore This still has the comment. Not a big deal - I think that many people missed the webkit-dev discussion, and still land new code with these comments. 351686 58 darin 2011-02-15 15:56:33 -0800 (In reply to comment #57) > Apple Computer, Inc. has been renamed to Apple, Inc. some time ago. Not important but: Apple Inc. without a comma. 351696 59 jamesr 2011-02-15 16:06:41 -0800 (In reply to comment #57) > (From update of attachment 82535 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=82535&action=review > > > I believe I am using the correct license block. Which part is incorrect? > > Apple Computer, Inc. has been renamed to Apple, Inc. some time ago. We have the canonical text of the license at <http://www.webkit.org/coding/bsd-license.html>, although I think that most Google contributors use a slightly different one. I'd like to know where it comes from, so that I could point that out in review more specifically than "please ask your manager". Gotcha. I was using an internal reference which predates http://trac.webkit.org/changeset/50154. I'll make sure to update the reference for future Googlers. > > Source/WebCore/dom/Document.cpp:4917 > > + return m_scriptedAnimationController->registerCallback(callback, e); > > Missed this one - please don't abbreviate "element". This could actually use a name that explains what element it is (targetElement? animationElement? rootElement?) > > > Source/WebCore/dom/ScriptedAnimationController.cpp:29 > > +#include "config.h" > > + > > +#include "ScriptedAnimationController.h" > > This still has an extra newline. > > > Source/WebCore/dom/ScriptedAnimationController.cpp:60 > > +ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(PassRefPtr<RequestAnimationFrameCallback> callback, Element* e) > > Please don't abbreviate "element" > > > Source/WebCore/dom/ScriptedAnimationController.h:69 > > +} // namespace WebCore > > This still has the comment. Not a big deal - I think that many people missed the webkit-dev discussion, and still land new code with these comments. I'll fix all of these prior to landing. Thanks. 351735 60 jamesr 2011-02-15 16:53:47 -0800 Committed r78648: <http://trac.webkit.org/changeset/78648> 80234 2011-01-26 14:08:15 -0800 2011-01-28 14:55:52 -0800 Patch bug-53188-20110126140814.patch text/plain 16210 jamesr ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhNzM1MzRlN2E3MjU3NDAwMmY1MWRhZDlmMWFlOGQxMTI3OWJiNjBlLi5j N2MxYTA1YmIyNGI2NjIzYWYwODZmMDJmNzc2ZWVmZDRjZjAwZDgyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzMgQEAKKzIwMTEtMDEtMjYgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBy ZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3aXRoaW4gYSBt b2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTUzMTg4CisKKyAgICAgICAgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBzaG91 bGRuJ3QgZmlyZSB3aGlsZSBhIG1vZGFsIGRpYWxvZyBpcyB1cCAobGlrZSBhIHdpbmRvdy5hbGVy dCgpKS4KKyAgICAgICAgVGhpcyBtYXRjaGVzIEZpcmVmb3ggYW5kIG90aGVyIGFzeW5jIEFQSXMu ICBUaGlzIHBhdGNoIG1vdmVzIHRoZSBjYWxsYmFjayBzZXJ2aWNpbmcgaW50byBpdHMgb3duCisg ICAgICAgIGNvbnRyb2xsZXIgY2xhc3Mgd2hpY2ggc3ViY2xhc3NlcyBBY3RpdmVET01PYmplY3Qg dG8gZ2V0IG5vdGlmaWNhdGlvbnMgb24gc3VzcGVuZC9yZXN1bWUuCisKKyAgICAgICAgVGVzdGVk IG1hbnVhbGx5IHNpbmNlIHRoZXJlJ3Mgbm8gd2F5IHRvIHRlc3Qgd2luZG93LmFsZXJ0KCkgaW4g YSBsYXlvdXQgdGVzdC4KKworICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBkb20v RG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAg ICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOgor ICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OndlYmtpdENhbmNlbFJlcXVlc3RBbmltYXRpb25G cmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6c2VydmljZVNjcmlwdGVkQW5pbWF0 aW9ucyk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogZG9tL1JlcXVlc3RB bmltYXRpb25GcmFtZUNvbnRyb2xsZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlJl cXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxl cjo6flJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6 UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6c3VzcGVuZCk6CisgICAgICAgIChXZWJD b3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpyZXN1bWUpOgorICAgICAgICAo V2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6cmVnaXN0ZXJDYWxsYmFj ayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpj YW5jZWxDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVD b250cm9sbGVyOjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKToKKyAgICAgICAgKiBkb20vUmVx dWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5oOiBBZGRlZC4KKwogMjAxMS0wMS0yNSAgQ3Jp cyBOZWNrYXIgIDxjZG5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0g QmFydGguCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggYmYwMjkzYWY3MzMwMTFlNDA4OTI4MjAxNzEzYmJl M2RlYmYyMjQ0Mi4uNTAxZDVlNTdiMmNiMjQ4NjBhNjdmZjAyZTg3MDE4YmI4OWZhMzk5MyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaQpAQCAtMTMyMCw2ICsxMzIwLDggQEAKICAgICAgICAgICAgICdkb20vUmFu Z2VCb3VuZGFyeVBvaW50LmgnLAogICAgICAgICAgICAgJ2RvbS9SYW5nZUV4Y2VwdGlvbi5oJywK ICAgICAgICAgICAgICdkb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaCcsCisgICAg ICAgICAgICAnZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIuY3BwJywKKyAgICAg ICAgICAgICdkb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5oJywKICAgICAgICAg ICAgICdkb20vUmF3RGF0YURvY3VtZW50UGFyc2VyLmgnLAogICAgICAgICAgICAgJ2RvbS9SZWdp c3RlcmVkRXZlbnRMaXN0ZW5lci5jcHAnLAogICAgICAgICAgICAgJ2RvbS9SZWdpc3RlcmVkRXZl bnRMaXN0ZW5lci5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IDUzYzcxNWM3NThkZDc1 MjQwMTFmY2I5OTk3ZjE2ZDY3MzU1NWJlMGYuLmVjNmI2Y2Q1NDhmNjkyOWIwZjk1MzMyZWY2ODU1 NjVmM2Q5YTFkNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMjA5LDYgKzIwOSw3IEBA CiAKICNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiAjaW5jbHVkZSAiUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaCIKKyNpbmNsdWRlICJSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDb250cm9sbGVyLmgiCiAjZW5kaWYKIAogdXNpbmcgbmFtZXNwYWNlIHN0ZDsKQEAgLTQyOSw5 ICs0MzAsNiBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBjb25zdCBLVVJMJiB1 cmwsIGJvb2wgaXNYSFRNTCwgYm9vbCBpc0hUTUwsIGNvbgogICAgICwgbV9sb2FkRXZlbnREZWxh eVRpbWVyKHRoaXMsICZEb2N1bWVudDo6bG9hZEV2ZW50RGVsYXlUaW1lckZpcmVkKQogICAgICwg bV9kaXJlY3Rpb25TZXRPbkRvY3VtZW50RWxlbWVudChmYWxzZSkKICAgICAsIG1fd3JpdGluZ01v ZGVTZXRPbkRvY3VtZW50RWxlbWVudChmYWxzZSkKLSNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJ T05fRlJBTUUpCi0gICAgLCBtX25leHRSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0lkKDAp Ci0jZW5kaWYKIHsKICAgICBtX2RvY3VtZW50ID0gdGhpczsKIApAQCAtNDk2Miw3OSArNDk2MCwy MyBAQCB2b2lkIERvY3VtZW50Ojpsb2FkRXZlbnREZWxheVRpbWVyRmlyZWQoVGltZXI8RG9jdW1l bnQ+KikKIGludCBEb2N1bWVudDo6d2Via2l0UmVxdWVzdEFuaW1hdGlvbkZyYW1lKFBhc3NSZWZQ dHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNhbGxiYWNrLCBFbGVtZW50KiBlKQog ewogICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MpCi0gICAgICAgIG1f cmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzID0gbmV3IFJlcXVlc3RBbmltYXRpb25GcmFt ZUNhbGxiYWNrTGlzdDsKLSAgICBpbnQgaWQgPSBtX25leHRSZXF1ZXN0QW5pbWF0aW9uRnJhbWVD YWxsYmFja0lkKys7Ci0gICAgY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCA9IGZhbHNlOwot ICAgIGNhbGxiYWNrLT5tX2lkID0gaWQ7Ci0gICAgY2FsbGJhY2stPm1fZWxlbWVudCA9IGU7Ci0g ICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmFwcGVuZChjYWxsYmFjayk7Ci0g ICAgaWYgKEZyYW1lVmlldyogdiA9IHZpZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRp b24oKTsKLSAgICByZXR1cm4gaWQ7CisgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2tzID0gbmV3IFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIodGhpcyk7CisKKyAg ICByZXR1cm4gbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPnJlZ2lzdGVyQ2FsbGJh Y2soY2FsbGJhY2ssIGUpOwogfQogCiB2b2lkIERvY3VtZW50Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0 QW5pbWF0aW9uRnJhbWUoaW50IGlkKQogewogICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFja3MpCiAgICAgICAgIHJldHVybjsKLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8 IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7ICsraSkgewotICAgICAg ICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmF0KGkpLT5tX2lkID09IGlk KSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSkt Pm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAg ICB9Ci0gICAgfQorICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5jYW5jZWxD YWxsYmFjayhpZCk7CiB9CiAKIHZvaWQgRG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlv bnMoKQogewogICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MpCiAgICAg ICAgIHJldHVybjsKLSAgICAvLyBXZSB3YW50IHRvIHJ1biB0aGUgY2FsbGJhY2sgZm9yIGFsbCBl bGVtZW50cyBpbiB0aGUgZG9jdW1lbnQgdGhhdCBoYXZlIHJlZ2lzdGVyZWQKLSAgICAvLyBmb3Ig YSBjYWxsYmFjayBhbmQgdGhhdCBhcmUgdmlzaWJsZS4gIFJ1bm5pbmcgdGhlIGNhbGxiYWNrcyBj YW4gY2F1c2UgbmV3IGNhbGxiYWNrcwotICAgIC8vIHRvIGJlIHJlZ2lzdGVyZWQsIGV4aXN0aW5n IGNhbGxiYWNrcyB0byBiZSBjYW5jZWxsZWQsIGFuZCBlbGVtZW50cyB0byBnYWluIG9yIGxvc2UK LSAgICAvLyB2aXNpYmlsaXR5IHNvIHRoaXMgY29kZSBoYXMgdG8gaXRlcmF0ZSBjYXJlZnVsbHku Ci0KLSAgICAvLyBGSVhNRTogQ3VycmVudGx5LCB0aGlzIGNvZGUgZG9lc24ndCBkbyBhbnkgdmlz aWJpbGl0eSB0ZXN0cyBiZXlvbmQgY2hlY2tpbmcgZGlzcGxheToKLQotICAgIC8vIEZpcnN0LCBn ZW5lcmF0ZSBhIGxpc3Qgb2YgY2FsbGJhY2tzIHRvIGNvbnNpZGVyLiAgQ2FsbGJhY2tzIHJlZ2lz dGVyZWQgZnJvbSB0aGlzIHBvaW50Ci0gICAgLy8gb24gYXJlIGNvbnNpZGVyZWQgb25seSBmb3Ig dGhlICJuZXh0IiBmcmFtZSwgbm90IHRoaXMgb25lLgotICAgIFJlcXVlc3RBbmltYXRpb25GcmFt ZUNhbGxiYWNrTGlzdCBjYWxsYmFja3MoKm1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz KTsKLQotICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNlIHRoZSB2aXNpYmlsaXR5 IG9mIG90aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCi0gICAgLy8gbWlzc2luZyBh bnkgY2FsbGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRoZSBsaXN0IG9mIGNhbmRp YXRlIGNhbGxiYWNrcyBhbmQgZmlyaW5nCi0gICAgLy8gdGhlbSB1bnRpbCBub3RoaW5nIG5ldyBi ZWNvbWVzIHZpc2libGUuCi0gICAgYm9vbCBmaXJlZENhbGxiYWNrOwotICAgIGRvIHsKLSAgICAg ICAgZmlyZWRDYWxsYmFjayA9IGZhbHNlOwotICAgICAgICAvLyBBIHByZXZpb3VzIGl0ZXJhdGlv biBtYXkgaGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4gIFVwZGF0ZSBzdHlsZXMg Zm9yIGVhY2ggaXRlcmF0aW9uCi0gICAgICAgIC8vIGZvciBub3cgc2luY2UgYWxsIHdlIGNoZWNr IGlzIHRoZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KLSAgICAgICAgdXBkYXRlU3R5bGVJZk5l ZWRlZCgpOwotICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGNhbGxiYWNrcy5zaXplKCk7 ICsraSkgewotICAgICAgICAgICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2sqIGNhbGxi YWNrID0gY2FsbGJhY2tzW2ldLmdldCgpOwotICAgICAgICAgICAgaWYgKCFjYWxsYmFjay0+bV9m aXJlZE9yQ2FuY2VsbGVkICYmICghY2FsbGJhY2stPm1fZWxlbWVudCB8fCBjYWxsYmFjay0+bV9l bGVtZW50LT5yZW5kZXJlcigpKSkgewotICAgICAgICAgICAgICAgIGNhbGxiYWNrLT5tX2ZpcmVk T3JDYW5jZWxsZWQgPSB0cnVlOwotICAgICAgICAgICAgICAgIGNhbGxiYWNrLT5oYW5kbGVFdmVu dCgpOwotICAgICAgICAgICAgICAgIGZpcmVkQ2FsbGJhY2sgPSB0cnVlOwotICAgICAgICAgICAg ICAgIGNhbGxiYWNrcy5yZW1vdmUoaSk7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAg ICAgICB9Ci0gICAgICAgIH0KLSAgICB9IHdoaWxlIChmaXJlZENhbGxiYWNrKTsKLQotICAgIC8v IFJlbW92ZSBhbnkgY2FsbGJhY2tzIHdlIGZpcmVkIGZyb20gdGhlIGxpc3Qgb2YgcGVuZGluZyBj YWxsYmFja3MuCi0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX3JlcXVlc3RBbmltYXRpb25G cmFtZUNhbGxiYWNrcy0+c2l6ZSgpOykgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFja3MtPmF0KGkpLT5tX2ZpcmVkT3JDYW5jZWxsZWQpCi0gICAgICAgICAgICBt X3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICBlbHNl Ci0gICAgICAgICAgICArK2k7Ci0gICAgfQotCi0gICAgLy8gSW4gbW9zdCBjYXNlcyB3ZSBleHBl Y3QgdGhpcyBsaXN0IHRvIGJlIGVtcHR5LCBzbyBubyBuZWVkIHRvIGtlZXAgYXJvdW5kIHRoZSB2 ZWN0b3IncyBpbmxpbmUgYnVmZmVyLgotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVD YWxsYmFja3MtPnNpemUoKSkKLSAgICAgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFj a3MuY2xlYXIoKTsKLSAgICBlbHNlIGlmIChGcmFtZVZpZXcqIHYgPSB2aWV3KCkpCi0gICAgICAg IHYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7CisgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFja3MtPnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoKTsKIH0KICNlbmRpZgogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5oCmluZGV4IGY2YmNkYzk4Y2Y3OTIzYTNjNDM1MzFhYTAxOTlkYTU5ZTE0ZmIyMzUu LmRkMDNmZmJiMjljMzVkNjkyNmMxNTU1MzY4ZGEwZDAwYzhiYmM4NmIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5oCkBAIC0xNDgsNiArMTQ4LDcgQEAgY2xhc3MgVG91Y2hMaXN0OwogCiAjaWYgRU5BQkxF KFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xhc3MgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2s7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOwogI2VuZGlmCiAK IHR5cGVkZWYgaW50IEV4Y2VwdGlvbkNvZGU7CkBAIC0xNDA1LDkgKzE0MDYsNyBAQCBwcml2YXRl OgogICAgIFJlZlB0cjxNZWRpYVF1ZXJ5TWF0Y2hlcj4gbV9tZWRpYVF1ZXJ5TWF0Y2hlcjsKIAog I2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKLSAgICB0eXBlZGVmIFZlY3RvcjxS ZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+ID4gUmVxdWVzdEFuaW1hdGlvbkZy YW1lQ2FsbGJhY2tMaXN0OwotICAgIE93blB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFj a0xpc3Q+IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzOwotICAgIGludCBtX25leHRS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0lkOworICAgIE93blB0cjxSZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDb250cm9sbGVyPiBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrczsKICNl bmRpZgogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNmYjg2MWU1NzZkYTU4MjJmZjJkZDU2 NjdmMjEzYjMzODYxNDE0YzIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20v UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5jcHAKQEAgLTAsMCArMSwxNDEgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBV VEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisg KiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVU RVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S CisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiUmVxdWVzdEFuaW1h dGlvbkZyYW1lQ29udHJvbGxlci5oIgorCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZS QU1FKQorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJFbGVtZW50LmgiCisjaW5j bHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJh Y2suaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250 cm9sbGVyOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKERvY3VtZW50KiBkb2N1bWVu dCkKKyAgICA6IEFjdGl2ZURPTU9iamVjdChkb2N1bWVudCwgdGhpcykKKyAgICAsIG1fbmV4dENh bGxiYWNrSWQoMCkKKyAgICAsIG1fc3VzcGVuZGVkKGZhbHNlKQorICAgICwgbV9kb2N1bWVudChk b2N1bWVudCkKK3sKK30KKworUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6flJlcXVl c3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIoKQoreworfQorCit2b2lkIFJlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXI6OnN1c3BlbmQoUmVhc29uRm9yU3VzcGVuc2lvbikKK3sKKyAgICBt X3N1c3BlbmRlZCA9IHRydWU7Cit9CisKK3ZvaWQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJv bGxlcjo6cmVzdW1lKCkKK3sKKyAgICBtX3N1c3BlbmRlZCA9IGZhbHNlOworICAgIGlmIChtX2Nh bGxiYWNrcy5zaXplKCkpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+ dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cit9CisKK2ludCBS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpyZWdpc3RlckNhbGxiYWNrKFBhc3NSZWZQ dHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNhbGxiYWNrLCBFbGVtZW50KiBlKQor eworICAgIGludCBpZCA9IG1fbmV4dENhbGxiYWNrSWQrKzsKKyAgICBjYWxsYmFjay0+bV9maXJl ZE9yQ2FuY2VsbGVkID0gZmFsc2U7CisgICAgY2FsbGJhY2stPm1faWQgPSBpZDsKKyAgICBjYWxs YmFjay0+bV9lbGVtZW50ID0gZTsKKyAgICBtX2NhbGxiYWNrcy5hcHBlbmQoY2FsbGJhY2spOwor ICAgIGlmICghbV9zdXNwZW5kZWQpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1 bWVudC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7CisgICAg cmV0dXJuIGlkOworfQorCit2b2lkIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OmNh bmNlbENhbGxiYWNrKGludCBpZCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2Fs bGJhY2tzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+bV9pZCA9 PSBpZCkgeworICAgICAgICAgICAgbV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNhbmNlbGxlZCA9 IHRydWU7CisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgUmVxdWVzdEFuaW1hdGlvbkZyYW1l Q29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucygpCit7CisgICAgaWYgKCFtX2Nh bGxiYWNrcy5zaXplKCkgfHwgbV9zdXNwZW5kZWQpCisgICAgICAgIHJldHVybjsKKyAgICAvLyBX ZSB3YW50IHRvIHJ1biB0aGUgY2FsbGJhY2sgZm9yIGFsbCBlbGVtZW50cyBpbiB0aGUgZG9jdW1l bnQgdGhhdCBoYXZlIHJlZ2lzdGVyZWQKKyAgICAvLyBmb3IgYSBjYWxsYmFjayBhbmQgdGhhdCBh cmUgdmlzaWJsZS4gIFJ1bm5pbmcgdGhlIGNhbGxiYWNrcyBjYW4gY2F1c2UgbmV3IGNhbGxiYWNr cworICAgIC8vIHRvIGJlIHJlZ2lzdGVyZWQsIGV4aXN0aW5nIGNhbGxiYWNrcyB0byBiZSBjYW5j ZWxsZWQsIGFuZCBlbGVtZW50cyB0byBnYWluIG9yIGxvc2UKKyAgICAvLyB2aXNpYmlsaXR5IHNv IHRoaXMgY29kZSBoYXMgdG8gaXRlcmF0ZSBjYXJlZnVsbHkuCisKKyAgICAvLyBGSVhNRTogQ3Vy cmVudGx5LCB0aGlzIGNvZGUgZG9lc24ndCBkbyBhbnkgdmlzaWJpbGl0eSB0ZXN0cyBiZXlvbmQg Y2hlY2tpbmcgZGlzcGxheToKKworICAgIC8vIEZpcnN0LCBnZW5lcmF0ZSBhIGxpc3Qgb2YgY2Fs bGJhY2tzIHRvIGNvbnNpZGVyLiAgQ2FsbGJhY2tzIHJlZ2lzdGVyZWQgZnJvbSB0aGlzIHBvaW50 CisgICAgLy8gb24gYXJlIGNvbnNpZGVyZWQgb25seSBmb3IgdGhlICJuZXh0IiBmcmFtZSwgbm90 IHRoaXMgb25lLgorICAgIENhbGxiYWNrTGlzdCBjYWxsYmFja3MobV9jYWxsYmFja3MpOworCisg ICAgLy8gRmlyaW5nIHRoZSBjYWxsYmFjayBtYXkgY2F1c2UgdGhlIHZpc2liaWxpdHkgb2Ygb3Ro ZXIgZWxlbWVudHMgdG8gY2hhbmdlLiAgVG8gYXZvaWQKKyAgICAvLyBtaXNzaW5nIGFueSBjYWxs YmFja3MsIHdlIGtlZXAgaXRlcmF0aW5nIHRocm91Z2ggdGhlIGxpc3Qgb2YgY2FuZGlhdGUgY2Fs bGJhY2tzIGFuZCBmaXJpbmcKKyAgICAvLyB0aGVtIHVudGlsIG5vdGhpbmcgbmV3IGJlY29tZXMg dmlzaWJsZS4KKyAgICBib29sIGZpcmVkQ2FsbGJhY2s7CisgICAgZG8geworICAgICAgICBmaXJl ZENhbGxiYWNrID0gZmFsc2U7CisgICAgICAgIC8vIEEgcHJldmlvdXMgaXRlcmF0aW9uIG1heSBo YXZlIGludmFsaWRhdGVkIHN0eWxlIChvciBsYXlvdXQpLiAgVXBkYXRlIHN0eWxlcyBmb3IgZWFj aCBpdGVyYXRpb24KKyAgICAgICAgLy8gZm9yIG5vdyBzaW5jZSBhbGwgd2UgY2hlY2sgaXMgdGhl IGV4aXN0ZW5jZSBvZiBhIHJlbmRlcmVyLgorICAgICAgICBtX2RvY3VtZW50LT51cGRhdGVTdHls ZUlmTmVlZGVkKCk7CisgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY2FsbGJhY2tzLnNp emUoKTsgKytpKSB7CisgICAgICAgICAgICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjayog Y2FsbGJhY2sgPSBjYWxsYmFja3NbaV0uZ2V0KCk7CisgICAgICAgICAgICBpZiAoIWNhbGxiYWNr LT5tX2ZpcmVkT3JDYW5jZWxsZWQgJiYgKCFjYWxsYmFjay0+bV9lbGVtZW50IHx8IGNhbGxiYWNr LT5tX2VsZW1lbnQtPnJlbmRlcmVyKCkpKSB7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPm1f ZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPmhhbmRs ZUV2ZW50KCk7CisgICAgICAgICAgICAgICAgZmlyZWRDYWxsYmFjayA9IHRydWU7CisgICAgICAg ICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0gd2hpbGUgKGZpcmVkQ2FsbGJhY2spOworCisg ICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2UgZmlyZWQgZnJvbSB0aGUgbGlzdCBvZiBwZW5k aW5nIGNhbGxiYWNrcy4KKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tzLnNp emUoKTspIHsKKyAgICAgICAgaWYgKG1fY2FsbGJhY2tzW2ldLT5tX2ZpcmVkT3JDYW5jZWxsZWQp CisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICsraTsKKyAgICB9CisKKyAgICBpZiAobV9jYWxsYmFja3Muc2l6ZSgpKQorICAgICAg ICBpZiAoRnJhbWVWaWV3KiB2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgdi0+ c2NoZWR1bGVBbmltYXRpb24oKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVD b250cm9sbGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMmJjMTFhMjRkYzE4OGY5ZDU0YjhkY2ViMmYwOWFlMTVm ZjcyODg1YwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyLmgKQEAgLTAsMCArMSw2NiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBB UyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgor ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICoKKyAqLworCisj aWZuZGVmIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXJfaAorI2RlZmluZSBSZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyX2gKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5o IgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4K KyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg RG9jdW1lbnQ7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjazsKKworY2xhc3Mg UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlciA6IHB1YmxpYyBBY3RpdmVET01PYmplY3Qg eworV1RGX01BS0VfTk9OQ09QWUFCTEUoUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcik7 CitwdWJsaWM6CisgICAgZXhwbGljaXQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcihE b2N1bWVudCopOworICAgIHZpcnR1YWwgflJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIo KTsKKworICAgIGludCByZWdpc3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlv bkZyYW1lQ2FsbGJhY2s+LCBFbGVtZW50Kik7CisgICAgdm9pZCBjYW5jZWxDYWxsYmFjayhpbnQg aWQpOworICAgIHZvaWQgc2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucygpOworCisgICAgLy8gQWN0 aXZlRE9NT2JqZWN0CisgICAgdmlydHVhbCB2b2lkIHN1c3BlbmQoUmVhc29uRm9yU3VzcGVuc2lv bik7CisgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpOworCitwcml2YXRlOgorICAgIHR5cGVkZWYg VmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBDYWxsYmFja0xp c3Q7CisgICAgQ2FsbGJhY2tMaXN0IG1fY2FsbGJhY2tzOworCisgICAgaW50IG1fbmV4dENhbGxi YWNrSWQ7CisgICAgYm9vbCBtX3N1c3BlbmRlZDsKKyAgICBEb2N1bWVudCogbV9kb2N1bWVudDsK K307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFJlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXJfaAorCg== 80510 2011-01-28 15:32:12 -0800 2011-01-30 21:47:28 -0800 Patch bug-53188-20110128153211.patch text/plain 16815 jamesr ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAzODYzMDY4ZjZlYjFjODEzMjA4MDgxOTYxNzFiNTExMDAwMDA0NGUyLi4w YmIyYWQyNDFhMWQwMmViY2Y3ZWQ0MDEzODliMmI4MzhmZTRjOTMwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzMgQEAKKzIwMTEtMDEtMjYgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBy ZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3aXRoaW4gYSBt b2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTUzMTg4CisKKyAgICAgICAgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBzaG91 bGRuJ3QgZmlyZSB3aGlsZSBhIG1vZGFsIGRpYWxvZyBpcyB1cCAobGlrZSBhIHdpbmRvdy5hbGVy dCgpKS4KKyAgICAgICAgVGhpcyBtYXRjaGVzIEZpcmVmb3ggYW5kIG90aGVyIGFzeW5jIEFQSXMu ICBUaGlzIHBhdGNoIG1vdmVzIHRoZSBjYWxsYmFjayBzZXJ2aWNpbmcgaW50byBpdHMgb3duCisg ICAgICAgIGNvbnRyb2xsZXIgY2xhc3Mgd2hpY2ggc3ViY2xhc3NlcyBBY3RpdmVET01PYmplY3Qg dG8gZ2V0IG5vdGlmaWNhdGlvbnMgb24gc3VzcGVuZC9yZXN1bWUuCisKKyAgICAgICAgVGVzdGVk IG1hbnVhbGx5IHNpbmNlIHRoZXJlJ3Mgbm8gd2F5IHRvIHRlc3Qgd2luZG93LmFsZXJ0KCkgaW4g YSBsYXlvdXQgdGVzdC4KKworICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBkb20v RG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAg ICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOgor ICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OndlYmtpdENhbmNlbFJlcXVlc3RBbmltYXRpb25G cmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6c2VydmljZVNjcmlwdGVkQW5pbWF0 aW9ucyk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogZG9tL1JlcXVlc3RB bmltYXRpb25GcmFtZUNvbnRyb2xsZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlJl cXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxl cjo6flJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6 UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6c3VzcGVuZCk6CisgICAgICAgIChXZWJD b3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpyZXN1bWUpOgorICAgICAgICAo V2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6cmVnaXN0ZXJDYWxsYmFj ayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpj YW5jZWxDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVD b250cm9sbGVyOjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKToKKyAgICAgICAgKiBkb20vUmVx dWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5oOiBBZGRlZC4KKwogMjAxMS0wMS0yNiAgTWFy aW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgTWFydGluIFJvYmluc29uLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDRhNGUwNGM5ZTBiNDIz ZjdmZjI0ZTIzOWU4MjhkYzYwZjNkNjMwMTQuLmIwNGIzNDdiNGZjYjEwMzg1ZmFjYzNhMDM3ZTA5 N2Y2MDQxNmRiYmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysg Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTEzMjAsNiArMTMyMCw4IEBACiAgICAg ICAgICAgICAnZG9tL1JhbmdlQm91bmRhcnlQb2ludC5oJywKICAgICAgICAgICAgICdkb20vUmFu Z2VFeGNlcHRpb24uaCcsCiAgICAgICAgICAgICAnZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNh bGxiYWNrLmgnLAorICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9s bGVyLmNwcCcsCisgICAgICAgICAgICAnZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xs ZXIuaCcsCiAgICAgICAgICAgICAnZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oJywKICAgICAg ICAgICAgICdkb20vUmVnaXN0ZXJlZEV2ZW50TGlzdGVuZXIuY3BwJywKICAgICAgICAgICAgICdk b20vUmVnaXN0ZXJlZEV2ZW50TGlzdGVuZXIuaCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRl eCBlYTE3NzYzNjQ3YzlhODc4MDU2NTM2NjlhZTJhNjI5MjdhNGEwNzNmLi4xZTkzYjM3ODBmMjk2 NWM1ODg1NzE5NDI0ZmEwZDI2YzdjYWQ3ODAzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9k b20vRG9jdW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKQEAg LTIwOSw2ICsyMDksNyBAQAogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQog I2luY2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgiCisjaW5jbHVkZSAiUmVx dWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5oIgogI2VuZGlmCiAKIHVzaW5nIG5hbWVzcGFj ZSBzdGQ7CkBAIC00MjksOSArNDMwLDYgQEAgRG9jdW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFt ZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhUTUwsIGJvb2wgaXNIVE1MLCBjb24KICAgICAs IG1fbG9hZEV2ZW50RGVsYXlUaW1lcih0aGlzLCAmRG9jdW1lbnQ6OmxvYWRFdmVudERlbGF5VGlt ZXJGaXJlZCkKICAgICAsIG1fZGlyZWN0aW9uU2V0T25Eb2N1bWVudEVsZW1lbnQoZmFsc2UpCiAg ICAgLCBtX3dyaXRpbmdNb2RlU2V0T25Eb2N1bWVudEVsZW1lbnQoZmFsc2UpCi0jaWYgRU5BQkxF KFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQotICAgICwgbV9uZXh0UmVxdWVzdEFuaW1hdGlvbkZy YW1lQ2FsbGJhY2tJZCgwKQotI2VuZGlmCiB7CiAgICAgbV9kb2N1bWVudCA9IHRoaXM7CiAKQEAg LTQ5NjUsODAgKzQ5NjMsMjQgQEAgdm9pZCBEb2N1bWVudDo6bG9hZEV2ZW50RGVsYXlUaW1lckZp cmVkKFRpbWVyPERvY3VtZW50PiopCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1F KQogaW50IERvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoUGFzc1JlZlB0cjxS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQqIGUpCiB7Ci0g ICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKLSAgICAgICAgbV9yZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MgPSBuZXcgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2tMaXN0OwotICAgIGludCBpZCA9IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrSWQrKzsKLSAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFsc2U7Ci0gICAg Y2FsbGJhY2stPm1faWQgPSBpZDsKLSAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0gZTsKLSAgICBt X3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXBwZW5kKGNhbGxiYWNrKTsKLSAgICBp ZiAoRnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigp OwotICAgIHJldHVybiBpZDsKKyAgICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJv bGxlcikKKyAgICAgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyID0gUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6Y3JlYXRlKHRoaXMpOworCisgICAgcmV0dXJuIG1f cmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci0+cmVnaXN0ZXJDYWxsYmFjayhjYWxsYmFj aywgZSk7CiB9CiAKIHZvaWQgRG9jdW1lbnQ6OndlYmtpdENhbmNlbFJlcXVlc3RBbmltYXRpb25G cmFtZShpbnQgaWQpCiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr cykKKyAgICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcikKICAgICAgICAg cmV0dXJuOwotICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9yZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFja3MtPnNpemUoKTsgKytpKSB7Ci0gICAgICAgIGlmIChtX3JlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1faWQgPT0gaWQpIHsKLSAgICAgICAgICAgIG1fcmVx dWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5hdChpKS0+bV9maXJlZE9yQ2FuY2VsbGVkID0g dHJ1ZTsKLSAgICAgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5yZW1v dmUoaSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAgICB9CisgICAgbV9yZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLT5jYW5jZWxDYWxsYmFjayhpZCk7CiB9CiAKIHZv aWQgRG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUp CiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKKyAgICBpZiAo IW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcikKICAgICAgICAgcmV0dXJuOwotICAg IC8vIFdlIHdhbnQgdG8gcnVuIHRoZSBjYWxsYmFjayBmb3IgYWxsIGVsZW1lbnRzIGluIHRoZSBk b2N1bWVudCB0aGF0IGhhdmUgcmVnaXN0ZXJlZAotICAgIC8vIGZvciBhIGNhbGxiYWNrIGFuZCB0 aGF0IGFyZSB2aXNpYmxlLiAgUnVubmluZyB0aGUgY2FsbGJhY2tzIGNhbiBjYXVzZSBuZXcgY2Fs bGJhY2tzCi0gICAgLy8gdG8gYmUgcmVnaXN0ZXJlZCwgZXhpc3RpbmcgY2FsbGJhY2tzIHRvIGJl IGNhbmNlbGxlZCwgYW5kIGVsZW1lbnRzIHRvIGdhaW4gb3IgbG9zZQotICAgIC8vIHZpc2liaWxp dHkgc28gdGhpcyBjb2RlIGhhcyB0byBpdGVyYXRlIGNhcmVmdWxseS4KLQotICAgIC8vIEZJWE1F OiBDdXJyZW50bHksIHRoaXMgY29kZSBkb2Vzbid0IGRvIGFueSB2aXNpYmlsaXR5IHRlc3RzIGJl eW9uZCBjaGVja2luZyBkaXNwbGF5OgotCi0gICAgLy8gRmlyc3QsIGdlbmVyYXRlIGEgbGlzdCBv ZiBjYWxsYmFja3MgdG8gY29uc2lkZXIuICBDYWxsYmFja3MgcmVnaXN0ZXJlZCBmcm9tIHRoaXMg cG9pbnQKLSAgICAvLyBvbiBhcmUgY29uc2lkZXJlZCBvbmx5IGZvciB0aGUgIm5leHQiIGZyYW1l LCBub3QgdGhpcyBvbmUuCi0gICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tMaXN0IGNh bGxiYWNrcygqbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MpOwotCi0gICAgLy8gRmly aW5nIHRoZSBjYWxsYmFjayBtYXkgY2F1c2UgdGhlIHZpc2liaWxpdHkgb2Ygb3RoZXIgZWxlbWVu dHMgdG8gY2hhbmdlLiAgVG8gYXZvaWQKLSAgICAvLyBtaXNzaW5nIGFueSBjYWxsYmFja3MsIHdl IGtlZXAgaXRlcmF0aW5nIHRocm91Z2ggdGhlIGxpc3Qgb2YgY2FuZGlhdGUgY2FsbGJhY2tzIGFu ZCBmaXJpbmcKLSAgICAvLyB0aGVtIHVudGlsIG5vdGhpbmcgbmV3IGJlY29tZXMgdmlzaWJsZS4K LSAgICBib29sIGZpcmVkQ2FsbGJhY2s7Ci0gICAgZG8gewotICAgICAgICBmaXJlZENhbGxiYWNr ID0gZmFsc2U7Ci0gICAgICAgIC8vIEEgcHJldmlvdXMgaXRlcmF0aW9uIG1heSBoYXZlIGludmFs aWRhdGVkIHN0eWxlIChvciBsYXlvdXQpLiAgVXBkYXRlIHN0eWxlcyBmb3IgZWFjaCBpdGVyYXRp b24KLSAgICAgICAgLy8gZm9yIG5vdyBzaW5jZSBhbGwgd2UgY2hlY2sgaXMgdGhlIGV4aXN0ZW5j ZSBvZiBhIHJlbmRlcmVyLgotICAgICAgICB1cGRhdGVTdHlsZUlmTmVlZGVkKCk7Ci0gICAgICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY2FsbGJhY2tzLnNpemUoKTsgKytpKSB7Ci0gICAgICAg ICAgICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjayogY2FsbGJhY2sgPSBjYWxsYmFja3Nb aV0uZ2V0KCk7Ci0gICAgICAgICAgICBpZiAoIWNhbGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQg JiYgKCFjYWxsYmFjay0+bV9lbGVtZW50IHx8IGNhbGxiYWNrLT5tX2VsZW1lbnQtPnJlbmRlcmVy KCkpKSB7Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRy dWU7Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2stPmhhbmRsZUV2ZW50KHRpbWUpOwotICAgICAg ICAgICAgICAgIGZpcmVkQ2FsbGJhY2sgPSB0cnVlOwotICAgICAgICAgICAgICAgIGNhbGxiYWNr cy5yZW1vdmUoaSk7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICB9Ci0gICAg ICAgIH0KLSAgICB9IHdoaWxlIChmaXJlZENhbGxiYWNrKTsKLQotICAgIC8vIFJlbW92ZSBhbnkg Y2FsbGJhY2tzIHdlIGZpcmVkIGZyb20gdGhlIGxpc3Qgb2YgcGVuZGluZyBjYWxsYmFja3MuCi0g ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr cy0+c2l6ZSgpOykgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFj a3MtPmF0KGkpLT5tX2ZpcmVkT3JDYW5jZWxsZWQpCi0gICAgICAgICAgICBtX3JlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAg ICArK2k7Ci0gICAgfQotCi0gICAgLy8gSW4gbW9zdCBjYXNlcyB3ZSBleHBlY3QgdGhpcyBsaXN0 IHRvIGJlIGVtcHR5LCBzbyBubyBuZWVkIHRvIGtlZXAgYXJvdW5kIHRoZSB2ZWN0b3IncyBpbmxp bmUgYnVmZmVyLgotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPnNp emUoKSkKLSAgICAgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MuY2xlYXIoKTsK LSAgICBlbHNlIGlmIChGcmFtZVZpZXcqIHYgPSB2aWV3KCkpCi0gICAgICAgIHYtPnNjaGVkdWxl QW5pbWF0aW9uKCk7CisgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLT5zZXJ2 aWNlU2NyaXB0ZWRBbmltYXRpb25zKHRpbWUpOwogfQogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmgKaW5kZXggZjNkOGU3N2U5YTE4ZDlhZTI3MWM0MDM2OGU3ZDdmZjQ3MTgzZGFlMC4uYWMxNjBm ODhmMzE1MWIyYTkwZWI3MDg2YWI1NzdmYjRjODRkYTk1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZG9tL0RvY3VtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmgK QEAgLTE0OSw2ICsxNDksNyBAQCBjbGFzcyBUb3VjaExpc3Q7CiAKICNpZiBFTkFCTEUoUkVRVUVT VF9BTklNQVRJT05fRlJBTUUpCiBjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjazsK K2NsYXNzIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI7CiAjZW5kaWYKIAogdHlwZWRl ZiBpbnQgRXhjZXB0aW9uQ29kZTsKQEAgLTE0MDYsOSArMTQwNyw3IEBAIHByaXZhdGU6CiAgICAg UmVmUHRyPE1lZGlhUXVlcnlNYXRjaGVyPiBtX21lZGlhUXVlcnlNYXRjaGVyOwogCiAjaWYgRU5B QkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQotICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFja0xpc3Q7Ci0gICAgT3duUHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrTGlzdD4g bV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3M7Ci0gICAgaW50IG1fbmV4dFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrSWQ7CisgICAgT3duUHRyPFJlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXI+IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjsKICNlbmRpZgog fTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQwOGQzYTJmODM5MGRkYjY3N2ViMDkyOTg5ODI5 MTlmNWFlYTNjMzUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5jcHAKQEAgLTAsMCArMSwxNDYgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJ TkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElO Qy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiUmVxdWVzdEFuaW1hdGlvbkZy YW1lQ29udHJvbGxlci5oIgorCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQor CisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJFbGVtZW50LmgiCisjaW5jbHVkZSAi RnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaCIK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVy OjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKERvY3VtZW50KiBkb2N1bWVudCkKKyAg ICA6IEFjdGl2ZURPTU9iamVjdChkb2N1bWVudCwgdGhpcykKKyAgICAsIG1fbmV4dENhbGxiYWNr SWQoMCkKKyAgICAsIG1fc3VzcGVuZGVkKGZhbHNlKQorICAgICwgbV9kb2N1bWVudChkb2N1bWVu dCkKK3sKK30KKworUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6flJlcXVlc3RBbmlt YXRpb25GcmFtZUNvbnRyb2xsZXIoKQoreworfQorCitib29sIFJlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXI6OmNhblN1c3BlbmQoKSBjb25zdAoreworICAgIHJldHVybiB0cnVlOworfQor Cit2b2lkIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OnN1c3BlbmQoUmVhc29uRm9y U3VzcGVuc2lvbikKK3sKKyAgICBtX3N1c3BlbmRlZCA9IHRydWU7Cit9CisKK3ZvaWQgUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6cmVzdW1lKCkKK3sKKyAgICBtX3N1c3BlbmRlZCA9 IGZhbHNlOworICAgIGlmIChtX2NhbGxiYWNrcy5zaXplKCkpCisgICAgICAgIGlmIChGcmFtZVZp ZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5p bWF0aW9uKCk7Cit9CisKK2ludCBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpyZWdp c3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNh bGxiYWNrLCBFbGVtZW50KiBlKQoreworICAgIGludCBpZCA9IG1fbmV4dENhbGxiYWNrSWQrKzsK KyAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFsc2U7CisgICAgY2FsbGJhY2st Pm1faWQgPSBpZDsKKyAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0gZTsKKyAgICBtX2NhbGxiYWNr cy5hcHBlbmQoY2FsbGJhY2spOworICAgIGlmICghbV9zdXNwZW5kZWQpCisgICAgICAgIGlmIChG cmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVk dWxlQW5pbWF0aW9uKCk7CisgICAgcmV0dXJuIGlkOworfQorCit2b2lkIFJlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXI6OmNhbmNlbENhbGxiYWNrKGludCBpZCkKK3sKKyAgICBmb3IgKHNp emVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmICht X2NhbGxiYWNrc1tpXS0+bV9pZCA9PSBpZCkgeworICAgICAgICAgICAgbV9jYWxsYmFja3NbaV0t Pm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7CisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1v dmUoaSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQg UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9u cyhET01UaW1lU3RhbXAgdGltZSkKK3sKKyAgICBpZiAoIW1fY2FsbGJhY2tzLnNpemUoKSB8fCBt X3N1c3BlbmRlZCkKKyAgICAgICAgcmV0dXJuOworICAgIC8vIFdlIHdhbnQgdG8gcnVuIHRoZSBj YWxsYmFjayBmb3IgYWxsIGVsZW1lbnRzIGluIHRoZSBkb2N1bWVudCB0aGF0IGhhdmUgcmVnaXN0 ZXJlZAorICAgIC8vIGZvciBhIGNhbGxiYWNrIGFuZCB0aGF0IGFyZSB2aXNpYmxlLiAgUnVubmlu ZyB0aGUgY2FsbGJhY2tzIGNhbiBjYXVzZSBuZXcgY2FsbGJhY2tzCisgICAgLy8gdG8gYmUgcmVn aXN0ZXJlZCwgZXhpc3RpbmcgY2FsbGJhY2tzIHRvIGJlIGNhbmNlbGxlZCwgYW5kIGVsZW1lbnRz IHRvIGdhaW4gb3IgbG9zZQorICAgIC8vIHZpc2liaWxpdHkgc28gdGhpcyBjb2RlIGhhcyB0byBp dGVyYXRlIGNhcmVmdWxseS4KKworICAgIC8vIEZJWE1FOiBDdXJyZW50bHksIHRoaXMgY29kZSBk b2Vzbid0IGRvIGFueSB2aXNpYmlsaXR5IHRlc3RzIGJleW9uZCBjaGVja2luZyBkaXNwbGF5Ogor CisgICAgLy8gRmlyc3QsIGdlbmVyYXRlIGEgbGlzdCBvZiBjYWxsYmFja3MgdG8gY29uc2lkZXIu ICBDYWxsYmFja3MgcmVnaXN0ZXJlZCBmcm9tIHRoaXMgcG9pbnQKKyAgICAvLyBvbiBhcmUgY29u c2lkZXJlZCBvbmx5IGZvciB0aGUgIm5leHQiIGZyYW1lLCBub3QgdGhpcyBvbmUuCisgICAgQ2Fs bGJhY2tMaXN0IGNhbGxiYWNrcyhtX2NhbGxiYWNrcyk7CisKKyAgICAvLyBGaXJpbmcgdGhlIGNh bGxiYWNrIG1heSBjYXVzZSB0aGUgdmlzaWJpbGl0eSBvZiBvdGhlciBlbGVtZW50cyB0byBjaGFu Z2UuICBUbyBhdm9pZAorICAgIC8vIG1pc3NpbmcgYW55IGNhbGxiYWNrcywgd2Uga2VlcCBpdGVy YXRpbmcgdGhyb3VnaCB0aGUgbGlzdCBvZiBjYW5kaWF0ZSBjYWxsYmFja3MgYW5kIGZpcmluZwor ICAgIC8vIHRoZW0gdW50aWwgbm90aGluZyBuZXcgYmVjb21lcyB2aXNpYmxlLgorICAgIGJvb2wg ZmlyZWRDYWxsYmFjazsKKyAgICBkbyB7CisgICAgICAgIGZpcmVkQ2FsbGJhY2sgPSBmYWxzZTsK KyAgICAgICAgLy8gQSBwcmV2aW91cyBpdGVyYXRpb24gbWF5IGhhdmUgaW52YWxpZGF0ZWQgc3R5 bGUgKG9yIGxheW91dCkuICBVcGRhdGUgc3R5bGVzIGZvciBlYWNoIGl0ZXJhdGlvbgorICAgICAg ICAvLyBmb3Igbm93IHNpbmNlIGFsbCB3ZSBjaGVjayBpcyB0aGUgZXhpc3RlbmNlIG9mIGEgcmVu ZGVyZXIuCisgICAgICAgIG1fZG9jdW1lbnQtPnVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKKyAgICAg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjYWxsYmFja3Muc2l6ZSgpOyArK2kpIHsKKyAgICAg ICAgICAgIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrKiBjYWxsYmFjayA9IGNhbGxiYWNr c1tpXS5nZXQoKTsKKyAgICAgICAgICAgIGlmICghY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxl ZCAmJiAoIWNhbGxiYWNrLT5tX2VsZW1lbnQgfHwgY2FsbGJhY2stPm1fZWxlbWVudC0+cmVuZGVy ZXIoKSkpIHsKKyAgICAgICAgICAgICAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBjYWxsYmFjay0+aGFuZGxlRXZlbnQodGltZSk7CisgICAg ICAgICAgICAgICAgZmlyZWRDYWxsYmFjayA9IHRydWU7CisgICAgICAgICAgICAgICAgY2FsbGJh Y2tzLnJlbW92ZShpKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorICAgIH0gd2hpbGUgKGZpcmVkQ2FsbGJhY2spOworCisgICAgLy8gUmVtb3ZlIGFu eSBjYWxsYmFja3Mgd2UgZmlyZWQgZnJvbSB0aGUgbGlzdCBvZiBwZW5kaW5nIGNhbGxiYWNrcy4K KyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tzLnNpemUoKTspIHsKKyAgICAg ICAgaWYgKG1fY2FsbGJhY2tzW2ldLT5tX2ZpcmVkT3JDYW5jZWxsZWQpCisgICAgICAgICAgICBt X2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgICsraTsKKyAg ICB9CisKKyAgICBpZiAobV9jYWxsYmFja3Muc2l6ZSgpKQorICAgICAgICBpZiAoRnJhbWVWaWV3 KiB2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRp b24oKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYKKwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIuaCBi L1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uODUyNWYwM2RmYTZmNGY0ZGQwYTc1ZDAxZjQwZWY1OWUxOTk3NmMwZgotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250 cm9sbGVyLmgKQEAgLTAsMCArMSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29n bGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkK KyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUws CisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICoKKyAqLworCisjaWZuZGVmIFJlcXVlc3RB bmltYXRpb25GcmFtZUNvbnRyb2xsZXJfaAorI2RlZmluZSBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVD b250cm9sbGVyX2gKKworI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIkRP TVRpbWVTdGFtcC5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0 Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9W ZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBEb2N1bWVudDsKK2NsYXNz IEVsZW1lbnQ7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjazsKKworY2xhc3Mg UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlciA6IHB1YmxpYyBBY3RpdmVET01PYmplY3Qg eworV1RGX01BS0VfTk9OQ09QWUFCTEUoUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcik7 CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29u dHJvbGxlcj4gY3JlYXRlKERvY3VtZW50KiBkKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UHRyKG5ldyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKGQpKTsKKyAgICB9CisgICAg dmlydHVhbCB+UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcigpOworCisgICAgaW50IHJl Z2lzdGVyQ2FsbGJhY2soUGFzc1JlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4s IEVsZW1lbnQqKTsKKyAgICB2b2lkIGNhbmNlbENhbGxiYWNrKGludCBpZCk7CisgICAgdm9pZCBz ZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCk7CisKKyAgICAvLyBBY3RpdmVE T01PYmplY3QKKyAgICB2aXJ0dWFsIGJvb2wgY2FuU3VzcGVuZCgpIGNvbnN0OworICAgIHZpcnR1 YWwgdm9pZCBzdXNwZW5kKFJlYXNvbkZvclN1c3BlbnNpb24pOworICAgIHZpcnR1YWwgdm9pZCBy ZXN1bWUoKTsKKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVD b250cm9sbGVyKERvY3VtZW50Kik7CisgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrPiA+IENhbGxiYWNrTGlzdDsKKyAgICBDYWxsYmFja0xpc3Qg bV9jYWxsYmFja3M7CisKKyAgICBpbnQgbV9uZXh0Q2FsbGJhY2tJZDsKKyAgICBib29sIG1fc3Vz cGVuZGVkOworICAgIERvY3VtZW50KiBtX2RvY3VtZW50OworfTsKKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorCisjZW5kaWYgLy8gUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcl9oCisK 80618 2011-01-30 21:47:32 -0800 2011-01-31 00:11:59 -0800 adds a test bug-53188-20110130214730.patch text/plain 20074 jamesr ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkODExMjc0MzNmMjc3Y2YzMjE2Njg0OWU2NjRmMDlmYmQzMjIyNWNhLi5lNjAwYWI1 NjVlOWM1NTQ1NWYzOWU2OWE4ZjUzZjJjYTMzN2EyNmQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDEtMzAgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0 aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisK KyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBz dXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAgICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAg ICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5odG1sOiBBZGRlZC4KKwogMjAxMS0wMS0yOSAg R3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXSBS RUdSRVNTSU9OOiAgaHR0cC90ZXN0cy9tZWRpYS92aWRlby17Y29va2llLHJlZmVyZXJ9Lmh0bWwg ZmFpbGluZwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1h bmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjI3ODc3NTU4NzAyOWYzYWNiZjA4ODE1Y2Y4YWJmMWFjMDg3OTA3 MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBA QAorVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBub3QgaW52 b2tlZCB3aGlsZSBtb2RhbCBkaWFsb2dzIGFyZSBkaXNwbGF5ZWQuCisKK09uIHN1Y2Nlc3MsIHlv dSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNU IENPTVBMRVRFIi4KKworCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1Qg Q09NUExFVEUKK1NldHRpbmcgY2FsbGJhY2sKK1Nob3dpbmcgbW9kYWwgZGlhbG9nCitSZXR1cm5l ZCBmcm9tIG1vZGFsIGRpYWxvZworQ2FsbGJhY2sgZmlyZWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFs Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFt ZS1kdXJpbmctbW9kYWwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xZGU2N2NmNThmMmMwYTg2M2E2YjM3MDE3 NTlmOTExYWU4Y2E0NDEyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmlt YXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKQEAgLTAsMCAr MSwzOSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIg aHJlZj0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHk+IAorPHAgaWQ9 ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0 eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1Rlc3RzIHRoYXQgcmVxdWVzdEFu aW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBhcmUgbm90IGludm9rZWQgd2hpbGUgbW9kYWwgZGlhbG9n cyBhcmUgZGlzcGxheWVkLicpOworIAordmFyIHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciA9IGZh bHNlOwordmFyIHRyaWdnZXJlZEJ1YmJsZUxpc3RlbmVyID0gZmFsc2U7CisKKworb25sb2FkID0g ZnVuY3Rpb24oKQoreworICAgIGRlYnVnKCdTZXR0aW5nIGNhbGxiYWNrJyk7CisgICAgd2luZG93 LndlYmtpdFJlcXVlc3RBbmltYXRpb25GcmFtZShmdW5jdGlvbigpIHsgZGVidWcoJ0NhbGxiYWNr IGZpcmVkJyk7IH0sIGRvY3VtZW50LmJvZHkpOworICAgIGRlYnVnKCdTaG93aW5nIG1vZGFsIGRp YWxvZycpOworICAgIHZhciBzcmMgPSAnaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg eycgKworICAgICAgICAgICAgICAnICAgIGxheW91dFRlc3RDb250cm9sbGVyLmRpc3BsYXkoKTsn ICsKKyAgICAgICAgICAgICAgJyAgICB3aW5kb3cuY2xvc2UoKTsnICsKKyAgICAgICAgICAgICAg J30gZWxzZSB7JysKKyAgICAgICAgICAgICAgJyAgICB3aW5kb3cuc2V0VGltZW91dCh3aW5kb3cu Y2xvc2UsIDEwKTsnKworICAgICAgICAgICAgICAnfSc7CisgICAgc2hvd01vZGFsRGlhbG9nKCdk YXRhOnRleHQvaHRtbCw8c2NyaXB0PicgKyBzcmMgKyAnPC8nICsgJ3NjcmlwdD4nKTsKKyAgICBk ZWJ1ZygnUmV0dXJuZWQgZnJvbSBtb2RhbCBkaWFsb2cnKTsKKyAgICBpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKSB7OworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kaXNwbGF5 KCk7CisgICAgfQorfQorCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTNjZmM5YmQyZWQ5NjNiYWY5ZWZj ZWQ0YTI5OTllNTRkMmJlZWRkNS4uODQ5MWNmMTRmM2VkMjE0YWUxMGRhY2Y4NTEzMGE3NDEzZmZk YjJmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDExLTAxLTMwICBKYW1lcyBSb2Jp bnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBzaG91 bGQgbm90IGZpcmUgd2l0aGluIGEgbW9kYWwgZGlhbG9nCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE4OAorCisgICAgICAgIHJlcXVlc3RBbmltYXRp b25GcmFtZSBjYWxsYmFja3Mgc2hvdWxkbid0IGZpcmUgd2hpbGUgYSBtb2RhbCBkaWFsb2cgaXMg dXAgKGxpa2UgYSB3aW5kb3cuYWxlcnQoKSkuCisgICAgICAgIFRoaXMgbWF0Y2hlcyBGaXJlZm94 IGFuZCBvdGhlciBhc3luYyBBUElzLiAgVGhpcyBwYXRjaCBtb3ZlcyB0aGUgY2FsbGJhY2sgc2Vy dmljaW5nIGludG8gaXRzIG93bgorICAgICAgICBjb250cm9sbGVyIGNsYXNzIHdoaWNoIHN1YmNs YXNzZXMgQWN0aXZlRE9NT2JqZWN0IHRvIGdldCBub3RpZmljYXRpb25zIG9uIHN1c3BlbmQvcmVz dW1lLgorCisgICAgICAgIFRlc3Q6IGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZy YW1lLWR1cmluZy1tb2RhbC5odG1sCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAg ICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpEb2N1bWVu dCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVxdWVzdEFuaW1hdGlvbkZy YW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0QW5p bWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9S ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJD b3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNv bnRyb2xsZXI6On5SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKToKKyAgICAgICAgKFdl YkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OmNhblN1c3BlbmQpOgorICAg ICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6c3VzcGVuZCk6 CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpyZXN1 bWUpOgorICAgICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6 cmVnaXN0ZXJDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDb250cm9sbGVyOjpjYW5jZWxDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKToKKyAg ICAgICAgKiBkb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5oOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OmNyZWF0ZSk6 CisKIDIwMTEtMDEtMjggIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBhYjcy YmNlODk1NjEyZDBjYWRiMzVmODVhMjMzNDM0MDA1ZTZjODg5Li4xMTM1MTJhOGY4OGE4M2VmMGU2 MGYxYTJlNzg0Mjg0OGFiNmYxMTA2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzIwLDYgKzEzMjAs OCBAQAogICAgICAgICAgICAgJ2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCcsCiAgICAgICAgICAg ICAnZG9tL1JhbmdlRXhjZXB0aW9uLmgnLAogICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdkb20vUmVxdWVzdEFuaW1hdGlvbkZy YW1lQ29udHJvbGxlci5jcHAnLAorICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJh bWVDb250cm9sbGVyLmgnLAogICAgICAgICAgICAgJ2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIu aCcsCiAgICAgICAgICAgICAnZG9tL1JlZ2lzdGVyZWRFdmVudExpc3RlbmVyLmNwcCcsCiAgICAg ICAgICAgICAnZG9tL1JlZ2lzdGVyZWRFdmVudExpc3RlbmVyLmgnLApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAKaW5kZXggNmFkZWYyNjkzMGNmZTg3OTdiYTRiY2ZhODEyOTQ4NGE2OWEyODRkZS4uNDg3 MmZmYzQ2ZDVkMDA3YTIwMmZmMDNmMzFiZTAxMWZhZmZjMDVkZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwCkBAIC0yMDksNiArMjA5LDcgQEAKIAogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElP Tl9GUkFNRSkKICNpbmNsdWRlICJSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oIgorI2lu Y2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIuaCIKICNlbmRpZgogCiB1c2lu ZyBuYW1lc3BhY2Ugc3RkOwpAQCAtNDI5LDkgKzQzMCw2IEBAIERvY3VtZW50OjpEb2N1bWVudChG cmFtZSogZnJhbWUsIGNvbnN0IEtVUkwmIHVybCwgYm9vbCBpc1hIVE1MLCBib29sIGlzSFRNTCwg Y29uCiAgICAgLCBtX2xvYWRFdmVudERlbGF5VGltZXIodGhpcywgJkRvY3VtZW50Ojpsb2FkRXZl bnREZWxheVRpbWVyRmlyZWQpCiAgICAgLCBtX2RpcmVjdGlvblNldE9uRG9jdW1lbnRFbGVtZW50 KGZhbHNlKQogICAgICwgbV93cml0aW5nTW9kZVNldE9uRG9jdW1lbnRFbGVtZW50KGZhbHNlKQot I2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKLSAgICAsIG1fbmV4dFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrSWQoMCkKLSNlbmRpZgogewogICAgIG1fZG9jdW1lbnQgPSB0 aGlzOwogCkBAIC00OTY1LDgwICs0OTYzLDI0IEBAIHZvaWQgRG9jdW1lbnQ6OmxvYWRFdmVudERl bGF5VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1B VElPTl9GUkFNRSkKIGludCBEb2N1bWVudDo6d2Via2l0UmVxdWVzdEFuaW1hdGlvbkZyYW1lKFBh c3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNhbGxiYWNrLCBFbGVtZW50 KiBlKQogewotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MpCi0gICAg ICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzID0gbmV3IFJlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrTGlzdDsKLSAgICBpbnQgaWQgPSBtX25leHRSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFja0lkKys7Ci0gICAgY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCA9IGZh bHNlOwotICAgIGNhbGxiYWNrLT5tX2lkID0gaWQ7Ci0gICAgY2FsbGJhY2stPm1fZWxlbWVudCA9 IGU7Ci0gICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmFwcGVuZChjYWxsYmFj ayk7Ci0gICAgaWYgKEZyYW1lVmlldyogdiA9IHZpZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVB bmltYXRpb24oKTsKLSAgICByZXR1cm4gaWQ7CisgICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25G cmFtZUNvbnRyb2xsZXIpCisgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxl ciA9IFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OmNyZWF0ZSh0aGlzKTsKKworICAg IHJldHVybiBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXItPnJlZ2lzdGVyQ2FsbGJh Y2soY2FsbGJhY2ssIGUpOwogfQogCiB2b2lkIERvY3VtZW50Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0 QW5pbWF0aW9uRnJhbWUoaW50IGlkKQogewotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFja3MpCisgICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIp CiAgICAgICAgIHJldHVybjsKLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fcmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7ICsraSkgewotICAgICAgICBpZiAobV9yZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmF0KGkpLT5tX2lkID09IGlkKSB7Ci0gICAgICAg ICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRPckNh bmNlbGxlZCA9IHRydWU7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgfQor ICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci0+Y2FuY2VsQ2FsbGJhY2soaWQp OwogfQogCiB2b2lkIERvY3VtZW50OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVT dGFtcCB0aW1lKQogewotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3Mp CisgICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIpCiAgICAgICAgIHJl dHVybjsKLSAgICAvLyBXZSB3YW50IHRvIHJ1biB0aGUgY2FsbGJhY2sgZm9yIGFsbCBlbGVtZW50 cyBpbiB0aGUgZG9jdW1lbnQgdGhhdCBoYXZlIHJlZ2lzdGVyZWQKLSAgICAvLyBmb3IgYSBjYWxs YmFjayBhbmQgdGhhdCBhcmUgdmlzaWJsZS4gIFJ1bm5pbmcgdGhlIGNhbGxiYWNrcyBjYW4gY2F1 c2UgbmV3IGNhbGxiYWNrcwotICAgIC8vIHRvIGJlIHJlZ2lzdGVyZWQsIGV4aXN0aW5nIGNhbGxi YWNrcyB0byBiZSBjYW5jZWxsZWQsIGFuZCBlbGVtZW50cyB0byBnYWluIG9yIGxvc2UKLSAgICAv LyB2aXNpYmlsaXR5IHNvIHRoaXMgY29kZSBoYXMgdG8gaXRlcmF0ZSBjYXJlZnVsbHkuCi0KLSAg ICAvLyBGSVhNRTogQ3VycmVudGx5LCB0aGlzIGNvZGUgZG9lc24ndCBkbyBhbnkgdmlzaWJpbGl0 eSB0ZXN0cyBiZXlvbmQgY2hlY2tpbmcgZGlzcGxheToKLQotICAgIC8vIEZpcnN0LCBnZW5lcmF0 ZSBhIGxpc3Qgb2YgY2FsbGJhY2tzIHRvIGNvbnNpZGVyLiAgQ2FsbGJhY2tzIHJlZ2lzdGVyZWQg ZnJvbSB0aGlzIHBvaW50Ci0gICAgLy8gb24gYXJlIGNvbnNpZGVyZWQgb25seSBmb3IgdGhlICJu ZXh0IiBmcmFtZSwgbm90IHRoaXMgb25lLgotICAgIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrTGlzdCBjYWxsYmFja3MoKm1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzKTsKLQot ICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNlIHRoZSB2aXNpYmlsaXR5IG9mIG90 aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCi0gICAgLy8gbWlzc2luZyBhbnkgY2Fs bGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRoZSBsaXN0IG9mIGNhbmRpYXRlIGNh bGxiYWNrcyBhbmQgZmlyaW5nCi0gICAgLy8gdGhlbSB1bnRpbCBub3RoaW5nIG5ldyBiZWNvbWVz IHZpc2libGUuCi0gICAgYm9vbCBmaXJlZENhbGxiYWNrOwotICAgIGRvIHsKLSAgICAgICAgZmly ZWRDYWxsYmFjayA9IGZhbHNlOwotICAgICAgICAvLyBBIHByZXZpb3VzIGl0ZXJhdGlvbiBtYXkg aGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4gIFVwZGF0ZSBzdHlsZXMgZm9yIGVh Y2ggaXRlcmF0aW9uCi0gICAgICAgIC8vIGZvciBub3cgc2luY2UgYWxsIHdlIGNoZWNrIGlzIHRo ZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KLSAgICAgICAgdXBkYXRlU3R5bGVJZk5lZWRlZCgp OwotICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGNhbGxiYWNrcy5zaXplKCk7ICsraSkg ewotICAgICAgICAgICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2sqIGNhbGxiYWNrID0g Y2FsbGJhY2tzW2ldLmdldCgpOwotICAgICAgICAgICAgaWYgKCFjYWxsYmFjay0+bV9maXJlZE9y Q2FuY2VsbGVkICYmICghY2FsbGJhY2stPm1fZWxlbWVudCB8fCBjYWxsYmFjay0+bV9lbGVtZW50 LT5yZW5kZXJlcigpKSkgewotICAgICAgICAgICAgICAgIGNhbGxiYWNrLT5tX2ZpcmVkT3JDYW5j ZWxsZWQgPSB0cnVlOwotICAgICAgICAgICAgICAgIGNhbGxiYWNrLT5oYW5kbGVFdmVudCh0aW1l KTsKLSAgICAgICAgICAgICAgICBmaXJlZENhbGxiYWNrID0gdHJ1ZTsKLSAgICAgICAgICAgICAg ICBjYWxsYmFja3MucmVtb3ZlKGkpOwotICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAg ICAgfQotICAgICAgICB9Ci0gICAgfSB3aGlsZSAoZmlyZWRDYWxsYmFjayk7Ci0KLSAgICAvLyBS ZW1vdmUgYW55IGNhbGxiYWNrcyB3ZSBmaXJlZCBmcm9tIHRoZSBsaXN0IG9mIHBlbmRpbmcgY2Fs bGJhY2tzLgotICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9yZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFja3MtPnNpemUoKTspIHsKLSAgICAgICAgaWYgKG1fcmVxdWVzdEFuaW1hdGlvbkZy YW1lQ2FsbGJhY2tzLT5hdChpKS0+bV9maXJlZE9yQ2FuY2VsbGVkKQotICAgICAgICAgICAgbV9y ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPnJlbW92ZShpKTsKLSAgICAgICAgZWxzZQot ICAgICAgICAgICAgKytpOwotICAgIH0KLQotICAgIC8vIEluIG1vc3QgY2FzZXMgd2UgZXhwZWN0 IHRoaXMgbGlzdCB0byBiZSBlbXB0eSwgc28gbm8gbmVlZCB0byBrZWVwIGFyb3VuZCB0aGUgdmVj dG9yJ3MgaW5saW5lIGJ1ZmZlci4KLSAgICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2tzLT5zaXplKCkpCi0gICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz LmNsZWFyKCk7Ci0gICAgZWxzZSBpZiAoRnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2 LT5zY2hlZHVsZUFuaW1hdGlvbigpOworICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJv bGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyh0aW1lKTsKIH0KICNlbmRpZgogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5oCmluZGV4IGYzZDhlNzdlOWExOGQ5YWUyNzFjNDAzNjhlN2Q3ZmY0NzE4M2Rh ZTAuLmFjMTYwZjg4ZjMxNTFiMmE5MGViNzA4NmFiNTc3ZmI0Yzg0ZGE5NWMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5oCkBAIC0xNDksNiArMTQ5LDcgQEAgY2xhc3MgVG91Y2hMaXN0OwogCiAjaWYgRU5B QkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xhc3MgUmVxdWVzdEFuaW1hdGlvbkZyYW1l Q2FsbGJhY2s7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOwogI2VuZGlm CiAKIHR5cGVkZWYgaW50IEV4Y2VwdGlvbkNvZGU7CkBAIC0xNDA2LDkgKzE0MDcsNyBAQCBwcml2 YXRlOgogICAgIFJlZlB0cjxNZWRpYVF1ZXJ5TWF0Y2hlcj4gbV9tZWRpYVF1ZXJ5TWF0Y2hlcjsK IAogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKLSAgICB0eXBlZGVmIFZlY3Rv cjxSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+ID4gUmVxdWVzdEFuaW1hdGlv bkZyYW1lQ2FsbGJhY2tMaXN0OwotICAgIE93blB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFja0xpc3Q+IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzOwotICAgIGludCBtX25l eHRSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0lkOworICAgIE93blB0cjxSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyPiBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI7 CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MDhkM2EyZjgzOTBkZGI2Nzdl YjA5Mjk4OTgyOTE5ZjVhZWEzYzM1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv ZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIuY3BwCkBAIC0wLDAgKzEsMTQ2IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBD T01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENP TVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlJlcXVlc3RB bmltYXRpb25GcmFtZUNvbnRyb2xsZXIuaCIKKworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElP Tl9GUkFNRSkKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRWxlbWVudC5oIgor I2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNh bGxiYWNrLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUmVxdWVzdEFuaW1hdGlvbkZyYW1l Q29udHJvbGxlcjo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcihEb2N1bWVudCogZG9j dW1lbnQpCisgICAgOiBBY3RpdmVET01PYmplY3QoZG9jdW1lbnQsIHRoaXMpCisgICAgLCBtX25l eHRDYWxsYmFja0lkKDApCisgICAgLCBtX3N1c3BlbmRlZChmYWxzZSkKKyAgICAsIG1fZG9jdW1l bnQoZG9jdW1lbnQpCit7Cit9CisKK1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6On5S ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKCkKK3sKK30KKworYm9vbCBSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyOjpjYW5TdXNwZW5kKCkgY29uc3QKK3sKKyAgICByZXR1cm4g dHJ1ZTsKK30KKwordm9pZCBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpzdXNwZW5k KFJlYXNvbkZvclN1c3BlbnNpb24pCit7CisgICAgbV9zdXNwZW5kZWQgPSB0cnVlOworfQorCit2 b2lkIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OnJlc3VtZSgpCit7CisgICAgbV9z dXNwZW5kZWQgPSBmYWxzZTsKKyAgICBpZiAobV9jYWxsYmFja3Muc2l6ZSgpKQorICAgICAgICBp ZiAoRnJhbWVWaWV3KiBmdiA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAgICAgICAgICAgIGZ2LT5z Y2hlZHVsZUFuaW1hdGlvbigpOworfQorCitpbnQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJv bGxlcjo6cmVnaXN0ZXJDYWxsYmFjayhQYXNzUmVmUHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNh bGxiYWNrPiBjYWxsYmFjaywgRWxlbWVudCogZSkKK3sKKyAgICBpbnQgaWQgPSBtX25leHRDYWxs YmFja0lkKys7CisgICAgY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCA9IGZhbHNlOworICAg IGNhbGxiYWNrLT5tX2lkID0gaWQ7CisgICAgY2FsbGJhY2stPm1fZWxlbWVudCA9IGU7CisgICAg bV9jYWxsYmFja3MuYXBwZW5kKGNhbGxiYWNrKTsKKyAgICBpZiAoIW1fc3VzcGVuZGVkKQorICAg ICAgICBpZiAoRnJhbWVWaWV3KiBmdiA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAgICAgICAgICAg IGZ2LT5zY2hlZHVsZUFuaW1hdGlvbigpOworICAgIHJldHVybiBpZDsKK30KKwordm9pZCBSZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpjYW5jZWxDYWxsYmFjayhpbnQgaWQpCit7Cisg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NhbGxiYWNrcy5zaXplKCk7ICsraSkgeworICAg ICAgICBpZiAobV9jYWxsYmFja3NbaV0tPm1faWQgPT0gaWQpIHsKKyAgICAgICAgICAgIG1fY2Fs bGJhY2tzW2ldLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSB0cnVlOworICAgICAgICAgICAgbV9jYWxs YmFja3MucmVtb3ZlKGkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQor fQorCit2b2lkIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OnNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCit7CisgICAgaWYgKCFtX2NhbGxiYWNrcy5z aXplKCkgfHwgbV9zdXNwZW5kZWQpCisgICAgICAgIHJldHVybjsKKyAgICAvLyBXZSB3YW50IHRv IHJ1biB0aGUgY2FsbGJhY2sgZm9yIGFsbCBlbGVtZW50cyBpbiB0aGUgZG9jdW1lbnQgdGhhdCBo YXZlIHJlZ2lzdGVyZWQKKyAgICAvLyBmb3IgYSBjYWxsYmFjayBhbmQgdGhhdCBhcmUgdmlzaWJs ZS4gIFJ1bm5pbmcgdGhlIGNhbGxiYWNrcyBjYW4gY2F1c2UgbmV3IGNhbGxiYWNrcworICAgIC8v IHRvIGJlIHJlZ2lzdGVyZWQsIGV4aXN0aW5nIGNhbGxiYWNrcyB0byBiZSBjYW5jZWxsZWQsIGFu ZCBlbGVtZW50cyB0byBnYWluIG9yIGxvc2UKKyAgICAvLyB2aXNpYmlsaXR5IHNvIHRoaXMgY29k ZSBoYXMgdG8gaXRlcmF0ZSBjYXJlZnVsbHkuCisKKyAgICAvLyBGSVhNRTogQ3VycmVudGx5LCB0 aGlzIGNvZGUgZG9lc24ndCBkbyBhbnkgdmlzaWJpbGl0eSB0ZXN0cyBiZXlvbmQgY2hlY2tpbmcg ZGlzcGxheToKKworICAgIC8vIEZpcnN0LCBnZW5lcmF0ZSBhIGxpc3Qgb2YgY2FsbGJhY2tzIHRv IGNvbnNpZGVyLiAgQ2FsbGJhY2tzIHJlZ2lzdGVyZWQgZnJvbSB0aGlzIHBvaW50CisgICAgLy8g b24gYXJlIGNvbnNpZGVyZWQgb25seSBmb3IgdGhlICJuZXh0IiBmcmFtZSwgbm90IHRoaXMgb25l LgorICAgIENhbGxiYWNrTGlzdCBjYWxsYmFja3MobV9jYWxsYmFja3MpOworCisgICAgLy8gRmly aW5nIHRoZSBjYWxsYmFjayBtYXkgY2F1c2UgdGhlIHZpc2liaWxpdHkgb2Ygb3RoZXIgZWxlbWVu dHMgdG8gY2hhbmdlLiAgVG8gYXZvaWQKKyAgICAvLyBtaXNzaW5nIGFueSBjYWxsYmFja3MsIHdl IGtlZXAgaXRlcmF0aW5nIHRocm91Z2ggdGhlIGxpc3Qgb2YgY2FuZGlhdGUgY2FsbGJhY2tzIGFu ZCBmaXJpbmcKKyAgICAvLyB0aGVtIHVudGlsIG5vdGhpbmcgbmV3IGJlY29tZXMgdmlzaWJsZS4K KyAgICBib29sIGZpcmVkQ2FsbGJhY2s7CisgICAgZG8geworICAgICAgICBmaXJlZENhbGxiYWNr ID0gZmFsc2U7CisgICAgICAgIC8vIEEgcHJldmlvdXMgaXRlcmF0aW9uIG1heSBoYXZlIGludmFs aWRhdGVkIHN0eWxlIChvciBsYXlvdXQpLiAgVXBkYXRlIHN0eWxlcyBmb3IgZWFjaCBpdGVyYXRp b24KKyAgICAgICAgLy8gZm9yIG5vdyBzaW5jZSBhbGwgd2UgY2hlY2sgaXMgdGhlIGV4aXN0ZW5j ZSBvZiBhIHJlbmRlcmVyLgorICAgICAgICBtX2RvY3VtZW50LT51cGRhdGVTdHlsZUlmTmVlZGVk KCk7CisgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY2FsbGJhY2tzLnNpemUoKTsgKytp KSB7CisgICAgICAgICAgICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjayogY2FsbGJhY2sg PSBjYWxsYmFja3NbaV0uZ2V0KCk7CisgICAgICAgICAgICBpZiAoIWNhbGxiYWNrLT5tX2ZpcmVk T3JDYW5jZWxsZWQgJiYgKCFjYWxsYmFjay0+bV9lbGVtZW50IHx8IGNhbGxiYWNrLT5tX2VsZW1l bnQtPnJlbmRlcmVyKCkpKSB7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPm1fZmlyZWRPckNh bmNlbGxlZCA9IHRydWU7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPmhhbmRsZUV2ZW50KHRp bWUpOworICAgICAgICAgICAgICAgIGZpcmVkQ2FsbGJhY2sgPSB0cnVlOworICAgICAgICAgICAg ICAgIGNhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAg ICAgICB9CisgICAgICAgIH0KKyAgICB9IHdoaWxlIChmaXJlZENhbGxiYWNrKTsKKworICAgIC8v IFJlbW92ZSBhbnkgY2FsbGJhY2tzIHdlIGZpcmVkIGZyb20gdGhlIGxpc3Qgb2YgcGVuZGluZyBj YWxsYmFja3MuCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NhbGxiYWNrcy5zaXplKCk7 KSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+bV9maXJlZE9yQ2FuY2VsbGVkKQorICAg ICAgICAgICAgbV9jYWxsYmFja3MucmVtb3ZlKGkpOworICAgICAgICBlbHNlCisgICAgICAgICAg ICArK2k7CisgICAgfQorCisgICAgaWYgKG1fY2FsbGJhY2tzLnNpemUoKSkKKyAgICAgICAgaWYg KEZyYW1lVmlldyogdiA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAgICAgICAgICAgIHYtPnNjaGVk dWxlQW5pbWF0aW9uKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmCisK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250 cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJv bGxlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjg1MjVmMDNkZmE2ZjRmNGRkMGE3NWQwMWY0MGVmNTllMTk5NzZj MGYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVzdEFuaW1hdGlv bkZyYW1lQ29udHJvbGxlci5oCkBAIC0wLDAgKzEsNzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTEgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMn JyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisg KiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqCisgKi8KKworI2lmbmRl ZiBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyX2gKKyNkZWZpbmUgUmVxdWVzdEFuaW1h dGlvbkZyYW1lQ29udHJvbGxlcl9oCisKKyNpbmNsdWRlICJBY3RpdmVET01PYmplY3QuaCIKKyNp bmNsdWRlICJET01UaW1lU3RhbXAuaCIKKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNs dWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgRG9jdW1l bnQ7CitjbGFzcyBFbGVtZW50OworY2xhc3MgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s7 CisKK2NsYXNzIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIgOiBwdWJsaWMgQWN0aXZl RE9NT2JqZWN0IHsKK1dURl9NQUtFX05PTkNPUFlBQkxFKFJlcXVlc3RBbmltYXRpb25GcmFtZUNv bnRyb2xsZXIpOworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPFJlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXI+IGNyZWF0ZShEb2N1bWVudCogZCkKKyAgICB7CisgICAgICAgIHJl dHVybiBhZG9wdFB0cihuZXcgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcihkKSk7Cisg ICAgfQorICAgIHZpcnR1YWwgflJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIoKTsKKwor ICAgIGludCByZWdpc3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1l Q2FsbGJhY2s+LCBFbGVtZW50Kik7CisgICAgdm9pZCBjYW5jZWxDYWxsYmFjayhpbnQgaWQpOwor ICAgIHZvaWQgc2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXApOworCisgICAg Ly8gQWN0aXZlRE9NT2JqZWN0CisgICAgdmlydHVhbCBib29sIGNhblN1c3BlbmQoKSBjb25zdDsK KyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZChSZWFzb25Gb3JTdXNwZW5zaW9uKTsKKyAgICB2aXJ0 dWFsIHZvaWQgcmVzdW1lKCk7CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgUmVxdWVzdEFuaW1h dGlvbkZyYW1lQ29udHJvbGxlcihEb2N1bWVudCopOworICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0 cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBDYWxsYmFja0xpc3Q7CisgICAgQ2Fs bGJhY2tMaXN0IG1fY2FsbGJhY2tzOworCisgICAgaW50IG1fbmV4dENhbGxiYWNrSWQ7CisgICAg Ym9vbCBtX3N1c3BlbmRlZDsKKyAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKK307CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXJfaAorCg== 80622 2011-01-31 00:12:02 -0800 2011-02-08 14:11:39 -0800 without ActiveDOMObject bug-53188-20110131001201.patch text/plain 22094 jamesr ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkODExMjc0MzNmMjc3Y2YzMjE2Njg0OWU2NjRmMDlmYmQzMjIyNWNhLi5lNjAwYWI1 NjVlOWM1NTQ1NWYzOWU2OWE4ZjUzZjJjYTMzN2EyNmQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDEtMzAgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0 aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisK KyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBz dXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAgICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAg ICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5odG1sOiBBZGRlZC4KKwogMjAxMS0wMS0yOSAg R3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXSBS RUdSRVNTSU9OOiAgaHR0cC90ZXN0cy9tZWRpYS92aWRlby17Y29va2llLHJlZmVyZXJ9Lmh0bWwg ZmFpbGluZwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1h bmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjI3ODc3NTU4NzAyOWYzYWNiZjA4ODE1Y2Y4YWJmMWFjMDg3OTA3 MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBA QAorVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBub3QgaW52 b2tlZCB3aGlsZSBtb2RhbCBkaWFsb2dzIGFyZSBkaXNwbGF5ZWQuCisKK09uIHN1Y2Nlc3MsIHlv dSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNU IENPTVBMRVRFIi4KKworCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1Qg Q09NUExFVEUKK1NldHRpbmcgY2FsbGJhY2sKK1Nob3dpbmcgbW9kYWwgZGlhbG9nCitSZXR1cm5l ZCBmcm9tIG1vZGFsIGRpYWxvZworQ2FsbGJhY2sgZmlyZWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFs Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFt ZS1kdXJpbmctbW9kYWwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42MmQ3NzBhNGY2ZGViZTgyYzdkOTEzY2Q3 NDJmZDI2ZGI0Nzk4MGJkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmlt YXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKQEAgLTAsMCAr MSwzNSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIg aHJlZj0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHk+IAorPHAgaWQ9 ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0 eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1Rlc3RzIHRoYXQgcmVxdWVzdEFu aW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBhcmUgbm90IGludm9rZWQgd2hpbGUgbW9kYWwgZGlhbG9n cyBhcmUgZGlzcGxheWVkLicpOworIAorb25sb2FkID0gZnVuY3Rpb24oKQoreworICAgIGRlYnVn KCdTZXR0aW5nIGNhbGxiYWNrJyk7CisgICAgd2luZG93LndlYmtpdFJlcXVlc3RBbmltYXRpb25G cmFtZShmdW5jdGlvbigpIHsgZGVidWcoJ0NhbGxiYWNrIGZpcmVkJyk7IH0sIGRvY3VtZW50LmJv ZHkpOworICAgIGRlYnVnKCdTaG93aW5nIG1vZGFsIGRpYWxvZycpOworICAgIHZhciBzcmMgPSAn aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeycgKworICAgICAgICAgICAgICAnICAg IGxheW91dFRlc3RDb250cm9sbGVyLmRpc3BsYXkoKTsnICsKKyAgICAgICAgICAgICAgJyAgICB3 aW5kb3cuY2xvc2UoKTsnICsKKyAgICAgICAgICAgICAgJ30gZWxzZSB7JysKKyAgICAgICAgICAg ICAgJyAgICB3aW5kb3cuc2V0VGltZW91dCh3aW5kb3cuY2xvc2UsIDEwKTsnKworICAgICAgICAg ICAgICAnfSc7CisgICAgc2hvd01vZGFsRGlhbG9nKCdkYXRhOnRleHQvaHRtbCw8c2NyaXB0Picg KyBzcmMgKyAnPC8nICsgJ3NjcmlwdD4nKTsKKyAgICBkZWJ1ZygnUmV0dXJuZWQgZnJvbSBtb2Rh bCBkaWFsb2cnKTsKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7OworICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kaXNwbGF5KCk7CisgICAgfQorfQorCit2YXIgc3Vj Y2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgorCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKaW5kZXggMTNjZmM5YmQyZWQ5NjNiYWY5ZWZjZWQ0YTI5OTllNTRkMmJlZWRkNS4uNDM3 MDliZmU1M2I5NDFkNzNmZjM0NDAxMDE5NmYyZTQyMDQ1YWFhYiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDM3IEBACisyMDExLTAxLTMwICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgcmVx dWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBzaG91bGQgbm90IGZpcmUgd2l0aGluIGEgbW9k YWwgZGlhbG9nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MzE4OAorCisgICAgICAgIHJlcXVlc3RBbmltYXRpb25GcmFtZSBjYWxsYmFja3Mgc2hvdWxk bid0IGZpcmUgd2hpbGUgYSBtb2RhbCBkaWFsb2cgaXMgdXAgKGxpa2UgYSB3aW5kb3cuYWxlcnQo KSkuCisgICAgICAgIFRoaXMgbWF0Y2hlcyBGaXJlZm94IGFuZCBvdGhlciBhc3luYyBBUElzLiAg VGhpcyBwYXRjaCBtb3ZlcyB0aGUgY2FsbGJhY2sgc2VydmljaW5nIGludG8gaXRzIG93bgorICAg ICAgICBjb250cm9sbGVyIGNsYXNzIHdoaWNoIHJlY2VpdmVzIG5vdGlmaWNhdGlvbnMgb24gc3Vz cGVuZC9yZXN1bWUuCisKKyAgICAgICAgVGVzdDogZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmlt YXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUuZ3lwaToK KyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpzdXNwZW5kQWN0aXZlRE9N T2JqZWN0cyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6cmVzdW1lQWN0aXZlRE9NT2Jq ZWN0cyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVxdWVzdEFuaW1hdGlv bkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0 QW5pbWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNlcnZpY2VTY3Jp cHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRv bS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLmNwcDogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFt ZUNvbnRyb2xsZXI6On5SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKToKKyAgICAgICAg KFdlYkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OnN1c3BlbmQpOgorICAg ICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6cmVzdW1lKToK KyAgICAgICAgKFdlYkNvcmU6OlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OnJlZ2lz dGVyQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29u dHJvbGxlcjo6Y2FuY2VsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6UmVxdWVzdEFuaW1h dGlvbkZyYW1lQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyk6CisgICAgICAg ICogZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyOjpjcmVhdGUpOgorICAg ICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisKIDIwMTEtMDEtMjggIFNpbW9u IEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg QWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBhYjcyYmNlODk1NjEyZDBjYWRiMzVmODVh MjMzNDM0MDA1ZTZjODg5Li4xMTM1MTJhOGY4OGE4M2VmMGU2MGYxYTJlNzg0Mjg0OGFiNmYxMTA2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dl YkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzIwLDYgKzEzMjAsOCBAQAogICAgICAgICAgICAgJ2Rv bS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCcsCiAgICAgICAgICAgICAnZG9tL1JhbmdlRXhjZXB0aW9u LmgnLAogICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oJywK KyAgICAgICAgICAgICdkb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci5jcHAnLAor ICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLmgnLAogICAg ICAgICAgICAgJ2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaCcsCiAgICAgICAgICAgICAnZG9t L1JlZ2lzdGVyZWRFdmVudExpc3RlbmVyLmNwcCcsCiAgICAgICAgICAgICAnZG9tL1JlZ2lzdGVy ZWRFdmVudExpc3RlbmVyLmgnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggNmFkZWYyNjkz MGNmZTg3OTdiYTRiY2ZhODEyOTQ4NGE2OWEyODRkZS4uYjRiOWI0NmRjZWZmYmI3Y2NiMWQzMGI0 MWY0OTM4OTI2ZmM3YmUzMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0yMDksNiArMjA5 LDcgQEAKIAogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKICNpbmNsdWRlICJS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oIgorI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXIuaCIKICNlbmRpZgogCiB1c2luZyBuYW1lc3BhY2Ugc3RkOwpAQCAt NDI5LDkgKzQzMCw2IEBAIERvY3VtZW50OjpEb2N1bWVudChGcmFtZSogZnJhbWUsIGNvbnN0IEtV UkwmIHVybCwgYm9vbCBpc1hIVE1MLCBib29sIGlzSFRNTCwgY29uCiAgICAgLCBtX2xvYWRFdmVu dERlbGF5VGltZXIodGhpcywgJkRvY3VtZW50Ojpsb2FkRXZlbnREZWxheVRpbWVyRmlyZWQpCiAg ICAgLCBtX2RpcmVjdGlvblNldE9uRG9jdW1lbnRFbGVtZW50KGZhbHNlKQogICAgICwgbV93cml0 aW5nTW9kZVNldE9uRG9jdW1lbnRFbGVtZW50KGZhbHNlKQotI2lmIEVOQUJMRShSRVFVRVNUX0FO SU1BVElPTl9GUkFNRSkKLSAgICAsIG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr SWQoMCkKLSNlbmRpZgogewogICAgIG1fZG9jdW1lbnQgPSB0aGlzOwogCkBAIC00NzMzLDYgKzQ3 MzEsMjQgQEAgdm9pZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0YXNrKQog ICAgIGNhbGxPbk1haW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRleHQo bV93ZWFrUmVmZXJlbmNlLCB0YXNrKSk7CiB9CiAKK3ZvaWQgRG9jdW1lbnQ6OnN1c3BlbmRBY3Rp dmVET01PYmplY3RzKEFjdGl2ZURPTU9iamVjdDo6UmVhc29uRm9yU3VzcGVuc2lvbiByZWFzb24p Cit7CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMo cmVhc29uKTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgaWYgKG1f cmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcikKKyAgICAgICAgbV9yZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDb250cm9sbGVyLT5zdXNwZW5kKCk7CisjZW5kaWYKK30KKwordm9pZCBEb2N1bWVu dDo6cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpCit7CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4 dDo6cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpOworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElP Tl9GUkFNRSkKKyAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKQorICAg ICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXItPnJlc3VtZSgpOworI2VuZGlm Cit9CisKIEVsZW1lbnQqIERvY3VtZW50OjpmaW5kQW5jaG9yKGNvbnN0IFN0cmluZyYgbmFtZSkK IHsKICAgICBpZiAobmFtZS5pc0VtcHR5KCkpCkBAIC00OTY1LDgwICs0OTgxLDI0IEBAIHZvaWQg RG9jdW1lbnQ6OmxvYWRFdmVudERlbGF5VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQogI2lm IEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKIGludCBEb2N1bWVudDo6d2Via2l0UmVx dWVzdEFuaW1hdGlvbkZyYW1lKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJh Y2s+IGNhbGxiYWNrLCBFbGVtZW50KiBlKQogewotICAgIGlmICghbV9yZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFja3MpCi0gICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz ID0gbmV3IFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrTGlzdDsKLSAgICBpbnQgaWQgPSBt X25leHRSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0lkKys7Ci0gICAgY2FsbGJhY2stPm1f ZmlyZWRPckNhbmNlbGxlZCA9IGZhbHNlOwotICAgIGNhbGxiYWNrLT5tX2lkID0gaWQ7Ci0gICAg Y2FsbGJhY2stPm1fZWxlbWVudCA9IGU7Ci0gICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFja3MtPmFwcGVuZChjYWxsYmFjayk7Ci0gICAgaWYgKEZyYW1lVmlldyogdiA9IHZpZXcoKSkK LSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsKLSAgICByZXR1cm4gaWQ7CisgICAgaWYg KCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXIpCisgICAgICAgIG1fcmVxdWVzdEFu aW1hdGlvbkZyYW1lQ29udHJvbGxlciA9IFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6 OmNyZWF0ZSh0aGlzKTsKKworICAgIHJldHVybiBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXItPnJlZ2lzdGVyQ2FsbGJhY2soY2FsbGJhY2ssIGUpOwogfQogCiB2b2lkIERvY3VtZW50 Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoaW50IGlkKQogewotICAgIGlmICgh bV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MpCisgICAgaWYgKCFtX3JlcXVlc3RBbmlt YXRpb25GcmFtZUNvbnRyb2xsZXIpCiAgICAgICAgIHJldHVybjsKLSAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7ICsraSkg ewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmF0KGkpLT5t X2lkID09IGlkKSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr cy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7Ci0gICAgICAgICAgICBtX3JlcXVl c3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICAgICAgcmV0dXJu OwotICAgICAgICB9Ci0gICAgfQorICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxl ci0+Y2FuY2VsQ2FsbGJhY2soaWQpOwogfQogCiB2b2lkIERvY3VtZW50OjpzZXJ2aWNlU2NyaXB0 ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCB0aW1lKQogewotICAgIGlmICghbV9yZXF1ZXN0QW5p bWF0aW9uRnJhbWVDYWxsYmFja3MpCisgICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNv bnRyb2xsZXIpCiAgICAgICAgIHJldHVybjsKLSAgICAvLyBXZSB3YW50IHRvIHJ1biB0aGUgY2Fs bGJhY2sgZm9yIGFsbCBlbGVtZW50cyBpbiB0aGUgZG9jdW1lbnQgdGhhdCBoYXZlIHJlZ2lzdGVy ZWQKLSAgICAvLyBmb3IgYSBjYWxsYmFjayBhbmQgdGhhdCBhcmUgdmlzaWJsZS4gIFJ1bm5pbmcg dGhlIGNhbGxiYWNrcyBjYW4gY2F1c2UgbmV3IGNhbGxiYWNrcwotICAgIC8vIHRvIGJlIHJlZ2lz dGVyZWQsIGV4aXN0aW5nIGNhbGxiYWNrcyB0byBiZSBjYW5jZWxsZWQsIGFuZCBlbGVtZW50cyB0 byBnYWluIG9yIGxvc2UKLSAgICAvLyB2aXNpYmlsaXR5IHNvIHRoaXMgY29kZSBoYXMgdG8gaXRl cmF0ZSBjYXJlZnVsbHkuCi0KLSAgICAvLyBGSVhNRTogQ3VycmVudGx5LCB0aGlzIGNvZGUgZG9l c24ndCBkbyBhbnkgdmlzaWJpbGl0eSB0ZXN0cyBiZXlvbmQgY2hlY2tpbmcgZGlzcGxheToKLQot ICAgIC8vIEZpcnN0LCBnZW5lcmF0ZSBhIGxpc3Qgb2YgY2FsbGJhY2tzIHRvIGNvbnNpZGVyLiAg Q2FsbGJhY2tzIHJlZ2lzdGVyZWQgZnJvbSB0aGlzIHBvaW50Ci0gICAgLy8gb24gYXJlIGNvbnNp ZGVyZWQgb25seSBmb3IgdGhlICJuZXh0IiBmcmFtZSwgbm90IHRoaXMgb25lLgotICAgIFJlcXVl c3RBbmltYXRpb25GcmFtZUNhbGxiYWNrTGlzdCBjYWxsYmFja3MoKm1fcmVxdWVzdEFuaW1hdGlv bkZyYW1lQ2FsbGJhY2tzKTsKLQotICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNl IHRoZSB2aXNpYmlsaXR5IG9mIG90aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCi0g ICAgLy8gbWlzc2luZyBhbnkgY2FsbGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRo ZSBsaXN0IG9mIGNhbmRpYXRlIGNhbGxiYWNrcyBhbmQgZmlyaW5nCi0gICAgLy8gdGhlbSB1bnRp bCBub3RoaW5nIG5ldyBiZWNvbWVzIHZpc2libGUuCi0gICAgYm9vbCBmaXJlZENhbGxiYWNrOwot ICAgIGRvIHsKLSAgICAgICAgZmlyZWRDYWxsYmFjayA9IGZhbHNlOwotICAgICAgICAvLyBBIHBy ZXZpb3VzIGl0ZXJhdGlvbiBtYXkgaGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4g IFVwZGF0ZSBzdHlsZXMgZm9yIGVhY2ggaXRlcmF0aW9uCi0gICAgICAgIC8vIGZvciBub3cgc2lu Y2UgYWxsIHdlIGNoZWNrIGlzIHRoZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KLSAgICAgICAg dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwotICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGNh bGxiYWNrcy5zaXplKCk7ICsraSkgewotICAgICAgICAgICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1l Q2FsbGJhY2sqIGNhbGxiYWNrID0gY2FsbGJhY2tzW2ldLmdldCgpOwotICAgICAgICAgICAgaWYg KCFjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkICYmICghY2FsbGJhY2stPm1fZWxlbWVudCB8 fCBjYWxsYmFjay0+bV9lbGVtZW50LT5yZW5kZXJlcigpKSkgewotICAgICAgICAgICAgICAgIGNh bGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSB0cnVlOwotICAgICAgICAgICAgICAgIGNhbGxi YWNrLT5oYW5kbGVFdmVudCh0aW1lKTsKLSAgICAgICAgICAgICAgICBmaXJlZENhbGxiYWNrID0g dHJ1ZTsKLSAgICAgICAgICAgICAgICBjYWxsYmFja3MucmVtb3ZlKGkpOwotICAgICAgICAgICAg ICAgIGJyZWFrOwotICAgICAgICAgICAgfQotICAgICAgICB9Ci0gICAgfSB3aGlsZSAoZmlyZWRD YWxsYmFjayk7Ci0KLSAgICAvLyBSZW1vdmUgYW55IGNhbGxiYWNrcyB3ZSBmaXJlZCBmcm9tIHRo ZSBsaXN0IG9mIHBlbmRpbmcgY2FsbGJhY2tzLgotICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwg bV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPnNpemUoKTspIHsKLSAgICAgICAgaWYg KG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5hdChpKS0+bV9maXJlZE9yQ2FuY2Vs bGVkKQotICAgICAgICAgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPnJlbW92 ZShpKTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgKytpOwotICAgIH0KLQotICAgIC8vIElu IG1vc3QgY2FzZXMgd2UgZXhwZWN0IHRoaXMgbGlzdCB0byBiZSBlbXB0eSwgc28gbm8gbmVlZCB0 byBrZWVwIGFyb3VuZCB0aGUgdmVjdG9yJ3MgaW5saW5lIGJ1ZmZlci4KLSAgICBpZiAoIW1fcmVx dWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCkpCi0gICAgICAgIG1fcmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2tzLmNsZWFyKCk7Ci0gICAgZWxzZSBpZiAoRnJhbWVWaWV3KiB2 ID0gdmlldygpKQotICAgICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigpOworICAgIG1fcmVxdWVz dEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyh0aW1l KTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQu aCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGYzZDhlNzdlOWExOGQ5YWUy NzFjNDAzNjhlN2Q3ZmY0NzE4M2RhZTAuLmQ3YTdhNDM1NGI5OGVkM2Q3MTUzYmRlYTQ5NmE2MzY3 M2I0ZWY0ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xNDksNiArMTQ5LDcgQEAgY2xhc3Mg VG91Y2hMaXN0OwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xhc3Mg UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDb250cm9sbGVyOwogI2VuZGlmCiAKIHR5cGVkZWYgaW50IEV4Y2VwdGlvbkNvZGU7CkBAIC05 MzksNiArOTQwLDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhZGRNZXNzYWdlKE1lc3Nh Z2VTb3VyY2UsIE1lc3NhZ2VUeXBlLCBNZXNzYWdlTGV2ZWwsIGNvbnN0IFN0cmluZyYgbWVzc2Fn ZSwgdW5zaWduZWQgbGluZU51bWJlciwgY29uc3QgU3RyaW5nJiBzb3VyY2VVUkwsIFBhc3NSZWZQ dHI8U2NyaXB0Q2FsbFN0YWNrPik7CiAgICAgdmlydHVhbCB2b2lkIHBvc3RUYXNrKFBhc3NPd25Q dHI8VGFzaz4pOyAvLyBFeGVjdXRlcyB0aGUgdGFzayBvbiBjb250ZXh0J3MgdGhyZWFkIGFzeW5j aHJvbm91c2x5LgogCisgICAgdmlydHVhbCB2b2lkIHN1c3BlbmRBY3RpdmVET01PYmplY3RzKEFj dGl2ZURPTU9iamVjdDo6UmVhc29uRm9yU3VzcGVuc2lvbik7CisgICAgdmlydHVhbCB2b2lkIHJl c3VtZUFjdGl2ZURPTU9iamVjdHMoKTsKKwogI2lmIFVTRShKU0MpCiAgICAgdHlwZWRlZiBKU0M6 OldlYWtHQ01hcDxXZWJDb3JlOjpOb2RlKiwgSlNOb2RlKj4gSlNXcmFwcGVyQ2FjaGU7CiAgICAg dHlwZWRlZiBIYXNoTWFwPERPTVdyYXBwZXJXb3JsZCosIEpTV3JhcHBlckNhY2hlKj4gSlNXcmFw cGVyQ2FjaGVNYXA7CkBAIC0xNDA2LDkgKzE0MTAsNyBAQCBwcml2YXRlOgogICAgIFJlZlB0cjxN ZWRpYVF1ZXJ5TWF0Y2hlcj4gbV9tZWRpYVF1ZXJ5TWF0Y2hlcjsKIAogI2lmIEVOQUJMRShSRVFV RVNUX0FOSU1BVElPTl9GUkFNRSkKLSAgICB0eXBlZGVmIFZlY3RvcjxSZWZQdHI8UmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2s+ID4gUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tMaXN0 OwotICAgIE93blB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3Q+IG1fcmVxdWVz dEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzOwotICAgIGludCBtX25leHRSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFja0lkOworICAgIE93blB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9s bGVyPiBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI7CiAjZW5kaWYKIH07CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9s bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9s bGVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4yMmQ4N2NjMGI1ODhhMDgwMDIyNjNhOWM2ZDQ5YzY4OTc5YjI0 YTRlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXIuY3BwCkBAIC0wLDAgKzEsMTQwIEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFT IElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisg KiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXIuaCIKKworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKworI2luY2x1 ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUgIkZyYW1lVmll dy5oIgorI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6UmVxdWVz dEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcihEb2N1bWVudCogZG9jdW1lbnQpCisgICAgOiBtX25l eHRDYWxsYmFja0lkKDApCisgICAgLCBtX3N1c3BlbmRlZChmYWxzZSkKKyAgICAsIG1fZG9jdW1l bnQoZG9jdW1lbnQpCit7Cit9CisKK1JlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6On5S ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyKCkKK3sKK30KKwordm9pZCBSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyOjpzdXNwZW5kKCkKK3sKKyAgICBtX3N1c3BlbmRlZCA9IHRy dWU7Cit9CisKK3ZvaWQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6cmVzdW1lKCkK K3sKKyAgICBtX3N1c3BlbmRlZCA9IGZhbHNlOworICAgIGlmIChtX2NhbGxiYWNrcy5zaXplKCkp CisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAg ICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cit9CisKK2ludCBSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDb250cm9sbGVyOjpyZWdpc3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1h dGlvbkZyYW1lQ2FsbGJhY2s+IGNhbGxiYWNrLCBFbGVtZW50KiBlKQoreworICAgIGludCBpZCA9 IG1fbmV4dENhbGxiYWNrSWQrKzsKKyAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0g ZmFsc2U7CisgICAgY2FsbGJhY2stPm1faWQgPSBpZDsKKyAgICBjYWxsYmFjay0+bV9lbGVtZW50 ID0gZTsKKyAgICBtX2NhbGxiYWNrcy5hcHBlbmQoY2FsbGJhY2spOworICAgIGlmICghbV9zdXNw ZW5kZWQpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQor ICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7CisgICAgcmV0dXJuIGlkOworfQor Cit2b2lkIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXI6OmNhbmNlbENhbGxiYWNrKGlu dCBpZCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tzLnNpemUoKTsg KytpKSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+bV9pZCA9PSBpZCkgeworICAgICAg ICAgICAgbV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7CisgICAgICAg ICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAg IH0KKyAgICB9Cit9CisKK3ZvaWQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcjo6c2Vy dmljZVNjcmlwdGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkKK3sKKyAgICBpZiAoIW1f Y2FsbGJhY2tzLnNpemUoKSB8fCBtX3N1c3BlbmRlZCkKKyAgICAgICAgcmV0dXJuOworICAgIC8v IFdlIHdhbnQgdG8gcnVuIHRoZSBjYWxsYmFjayBmb3IgYWxsIGVsZW1lbnRzIGluIHRoZSBkb2N1 bWVudCB0aGF0IGhhdmUgcmVnaXN0ZXJlZAorICAgIC8vIGZvciBhIGNhbGxiYWNrIGFuZCB0aGF0 IGFyZSB2aXNpYmxlLiAgUnVubmluZyB0aGUgY2FsbGJhY2tzIGNhbiBjYXVzZSBuZXcgY2FsbGJh Y2tzCisgICAgLy8gdG8gYmUgcmVnaXN0ZXJlZCwgZXhpc3RpbmcgY2FsbGJhY2tzIHRvIGJlIGNh bmNlbGxlZCwgYW5kIGVsZW1lbnRzIHRvIGdhaW4gb3IgbG9zZQorICAgIC8vIHZpc2liaWxpdHkg c28gdGhpcyBjb2RlIGhhcyB0byBpdGVyYXRlIGNhcmVmdWxseS4KKworICAgIC8vIEZJWE1FOiBD dXJyZW50bHksIHRoaXMgY29kZSBkb2Vzbid0IGRvIGFueSB2aXNpYmlsaXR5IHRlc3RzIGJleW9u ZCBjaGVja2luZyBkaXNwbGF5OgorCisgICAgLy8gRmlyc3QsIGdlbmVyYXRlIGEgbGlzdCBvZiBj YWxsYmFja3MgdG8gY29uc2lkZXIuICBDYWxsYmFja3MgcmVnaXN0ZXJlZCBmcm9tIHRoaXMgcG9p bnQKKyAgICAvLyBvbiBhcmUgY29uc2lkZXJlZCBvbmx5IGZvciB0aGUgIm5leHQiIGZyYW1lLCBu b3QgdGhpcyBvbmUuCisgICAgQ2FsbGJhY2tMaXN0IGNhbGxiYWNrcyhtX2NhbGxiYWNrcyk7CisK KyAgICAvLyBGaXJpbmcgdGhlIGNhbGxiYWNrIG1heSBjYXVzZSB0aGUgdmlzaWJpbGl0eSBvZiBv dGhlciBlbGVtZW50cyB0byBjaGFuZ2UuICBUbyBhdm9pZAorICAgIC8vIG1pc3NpbmcgYW55IGNh bGxiYWNrcywgd2Uga2VlcCBpdGVyYXRpbmcgdGhyb3VnaCB0aGUgbGlzdCBvZiBjYW5kaWF0ZSBj YWxsYmFja3MgYW5kIGZpcmluZworICAgIC8vIHRoZW0gdW50aWwgbm90aGluZyBuZXcgYmVjb21l cyB2aXNpYmxlLgorICAgIGJvb2wgZmlyZWRDYWxsYmFjazsKKyAgICBkbyB7CisgICAgICAgIGZp cmVkQ2FsbGJhY2sgPSBmYWxzZTsKKyAgICAgICAgLy8gQSBwcmV2aW91cyBpdGVyYXRpb24gbWF5 IGhhdmUgaW52YWxpZGF0ZWQgc3R5bGUgKG9yIGxheW91dCkuICBVcGRhdGUgc3R5bGVzIGZvciBl YWNoIGl0ZXJhdGlvbgorICAgICAgICAvLyBmb3Igbm93IHNpbmNlIGFsbCB3ZSBjaGVjayBpcyB0 aGUgZXhpc3RlbmNlIG9mIGEgcmVuZGVyZXIuCisgICAgICAgIG1fZG9jdW1lbnQtPnVwZGF0ZVN0 eWxlSWZOZWVkZWQoKTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjYWxsYmFja3Mu c2l6ZSgpOyArK2kpIHsKKyAgICAgICAgICAgIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr KiBjYWxsYmFjayA9IGNhbGxiYWNrc1tpXS5nZXQoKTsKKyAgICAgICAgICAgIGlmICghY2FsbGJh Y2stPm1fZmlyZWRPckNhbmNlbGxlZCAmJiAoIWNhbGxiYWNrLT5tX2VsZW1lbnQgfHwgY2FsbGJh Y2stPm1fZWxlbWVudC0+cmVuZGVyZXIoKSkpIHsKKyAgICAgICAgICAgICAgICBjYWxsYmFjay0+ bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBjYWxsYmFjay0+aGFu ZGxlRXZlbnQodGltZSk7CisgICAgICAgICAgICAgICAgZmlyZWRDYWxsYmFjayA9IHRydWU7Cisg ICAgICAgICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsKKyAgICAgICAgICAgICAgICBicmVh azsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0gd2hpbGUgKGZpcmVkQ2FsbGJhY2sp OworCisgICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2UgZmlyZWQgZnJvbSB0aGUgbGlzdCBv ZiBwZW5kaW5nIGNhbGxiYWNrcy4KKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJh Y2tzLnNpemUoKTspIHsKKyAgICAgICAgaWYgKG1fY2FsbGJhY2tzW2ldLT5tX2ZpcmVkT3JDYW5j ZWxsZWQpCisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgIGVsc2UK KyAgICAgICAgICAgICsraTsKKyAgICB9CisKKyAgICBpZiAobV9jYWxsYmFja3Muc2l6ZSgpKQor ICAgICAgICBpZiAoRnJhbWVWaWV3KiB2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAg ICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRp b25GcmFtZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9u RnJhbWVDb250cm9sbGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTQ4YzkxOGUyMjExMjc2YjAzMWQ0NTlmOTNm NDkxOGUwNGI2M2NlNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyLmgKQEAgLTAsMCArMSw3MSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElO Qy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5D LiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkg QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICoKKyAq LworCisjaWZuZGVmIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXJfaAorI2RlZmluZSBS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyX2gKKworI2luY2x1ZGUgIkRPTVRpbWVTdGFt cC5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3du UHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4K KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBEb2N1bWVudDsKK2NsYXNzIEVsZW1lbnQ7 CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjazsKKworY2xhc3MgUmVxdWVzdEFu aW1hdGlvbkZyYW1lQ29udHJvbGxlciB7CitXVEZfTUFLRV9OT05DT1BZQUJMRShSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDb250cm9sbGVyKTsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250cm9sbGVyPiBjcmVhdGUoRG9jdW1lbnQqIGQpCisgICAg eworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRy b2xsZXIoZCkpOworICAgIH0KKyAgICB2aXJ0dWFsIH5SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDb250 cm9sbGVyKCk7CisKKyAgICBpbnQgcmVnaXN0ZXJDYWxsYmFjayhQYXNzUmVmUHRyPFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrPiwgRWxlbWVudCopOworICAgIHZvaWQgY2FuY2VsQ2FsbGJh Y2soaW50IGlkKTsKKyAgICB2b2lkIHNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0 YW1wKTsKKworICAgIHZvaWQgc3VzcGVuZCgpOworICAgIHZvaWQgcmVzdW1lKCk7CisKK3ByaXZh dGU6CisgICAgZXhwbGljaXQgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ29udHJvbGxlcihEb2N1bWVu dCopOworICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFjaz4gPiBDYWxsYmFja0xpc3Q7CisgICAgQ2FsbGJhY2tMaXN0IG1fY2FsbGJhY2tzOworCisg ICAgaW50IG1fbmV4dENhbGxiYWNrSWQ7CisgICAgYm9vbCBtX3N1c3BlbmRlZDsKKyAgICBEb2N1 bWVudCogbV9kb2N1bWVudDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIFJlcXVlc3RBbmltYXRpb25GcmFtZUNvbnRyb2xsZXJfaAorCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUv ZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAppbmRleCAxMDM1NjFhYTVkODI1OTYxMzFjNWUx ZGQ4M2JlNDFhNWY2MmM5ZDhiLi5hZWE3YTA2YTJiYjU0ZTY4NzkxNDQyZmQzNGFiZDU5ZTIxMzkw NGQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4 dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKQEAg LTk4LDggKzk4LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIGNhblN1c3Bl bmRBY3RpdmVET01PYmplY3RzKCk7CiAgICAgICAgIC8vIEFjdGl2ZSBvYmplY3RzIGNhbiBiZSBh c2tlZCB0byBzdXNwZW5kIGV2ZW4gaWYgY2FuU3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoKSByZXR1 cm5zICdmYWxzZScgLQogICAgICAgICAvLyBzdGVwLWJ5LXN0ZXAgSlMgZGVidWdnaW5nIGlzIG9u ZSBleGFtcGxlLgotICAgICAgICB2b2lkIHN1c3BlbmRBY3RpdmVET01PYmplY3RzKEFjdGl2ZURP TU9iamVjdDo6UmVhc29uRm9yU3VzcGVuc2lvbik7Ci0gICAgICAgIHZvaWQgcmVzdW1lQWN0aXZl RE9NT2JqZWN0cygpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZEFjdGl2ZURPTU9iamVj dHMoQWN0aXZlRE9NT2JqZWN0OjpSZWFzb25Gb3JTdXNwZW5zaW9uKTsKKyAgICAgICAgdmlydHVh bCB2b2lkIHJlc3VtZUFjdGl2ZURPTU9iamVjdHMoKTsKICAgICAgICAgdm9pZCBzdG9wQWN0aXZl RE9NT2JqZWN0cygpOwogICAgICAgICB2b2lkIGNyZWF0ZWRBY3RpdmVET01PYmplY3QoQWN0aXZl RE9NT2JqZWN0Kiwgdm9pZCogdXBjYXN0UG9pbnRlcik7CiAgICAgICAgIHZvaWQgZGVzdHJveWVk QWN0aXZlRE9NT2JqZWN0KEFjdGl2ZURPTU9iamVjdCopOwo= 81690 2011-02-08 14:11:42 -0800 2011-02-15 14:57:36 -0800 Patch bug-53188-20110208141141.patch text/plain 22547 jamesr ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAyMmRhNjk3NmVlNTA5MDIzNDViODQ1NTVmYjc4OTE4MjMyMThjYTU2Li5lNDk3Yjhj MjE3MGI2NmI5OGNmYjZmN2QwZWNmMDk3Mjg2ZTVhOTZmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDItMDggIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0 aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisK KyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBz dXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAgICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAg ICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5odG1sOiBBZGRlZC4KKwogMjAxMS0wMi0wNyAg WmhlbnlhbyBNbyAgPHptb0Bnb29nbGUuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHRlc3Qg ZXhwZWN0YXRpb25zIHVwZGF0ZS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0 aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmct bW9kYWwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYyNzg3NzU1ODcwMjlmM2FjYmYwODgxNWNm OGFiZjFhYzA4NzkwNzIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2FuaW1h dGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmctbW9kYWwtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsMTMgQEAKK1Rlc3RzIHRoYXQgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNr cyBhcmUgbm90IGludm9rZWQgd2hpbGUgbW9kYWwgZGlhbG9ncyBhcmUgZGlzcGxheWVkLgorCitP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCitTZXR0aW5nIGNhbGxiYWNrCitTaG93aW5nIG1vZGFsIGRp YWxvZworUmV0dXJuZWQgZnJvbSBtb2RhbCBkaWFsb2cKK0NhbGxiYWNrIGZpcmVkCisKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1l LWR1cmluZy1tb2RhbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1h bmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZTkwM2Q3M2E4ZDZj NWFjZDY3ZTBmY2YxM2EwODljZTg5ZjI2ZjFkZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5o dG1sCkBAIC0wLDAgKzEsMzUgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8bGluayByZWw9 InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8 c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxi b2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4K KworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1Rlc3RzIHRo YXQgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyBhcmUgbm90IGludm9rZWQgd2hpbGUg bW9kYWwgZGlhbG9ncyBhcmUgZGlzcGxheWVkLicpOworCitvbmxvYWQgPSBmdW5jdGlvbigpCit7 CisgICAgZGVidWcoJ1NldHRpbmcgY2FsbGJhY2snKTsKKyAgICB3aW5kb3cud2Via2l0UmVxdWVz dEFuaW1hdGlvbkZyYW1lKGZ1bmN0aW9uKCkgeyBkZWJ1ZygnQ2FsbGJhY2sgZmlyZWQnKTsgfSwg ZG9jdW1lbnQuYm9keSk7CisgICAgZGVidWcoJ1Nob3dpbmcgbW9kYWwgZGlhbG9nJyk7CisgICAg dmFyIHNyYyA9ICdpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7JyArCisgICAgICAg ICAgICAgICcgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZGlzcGxheSgpOycgKworICAgICAgICAg ICAgICAnICAgIHdpbmRvdy5jbG9zZSgpOycgKworICAgICAgICAgICAgICAnfSBlbHNlIHsnKwor ICAgICAgICAgICAgICAnICAgIHdpbmRvdy5zZXRUaW1lb3V0KHdpbmRvdy5jbG9zZSwgMTApOycr CisgICAgICAgICAgICAgICd9JzsKKyAgICBzaG93TW9kYWxEaWFsb2coJ2RhdGE6dGV4dC9odG1s LDxzY3JpcHQ+JyArIHNyYyArICc8LycgKyAnc2NyaXB0PicpOworICAgIGRlYnVnKCdSZXR1cm5l ZCBmcm9tIG1vZGFsIGRpYWxvZycpOworICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpIHs7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmRpc3BsYXkoKTsKKyAgICB9Cit9 CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNy Yz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8 L2h0bWw+CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyYjJjZjhlM2Y3NTJhMDRjMjNmOWY1MDY4ZDA0NjA0YTRm ZWJkOWJmLi40YzU4NmM2YzY2NWEyMTM2YTMzZmQ2ZjY4YjQ2MDUxMjhmMTcxYzQxIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsNDEgQEAKKzIwMTEtMDItMDggIEphbWVzIFJvYmluc29uICA8amFtZXNy QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3QgZmlyZSB3 aXRoaW4gYSBtb2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTUzMTg4CisKKyAgICAgICAgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIGNhbGxi YWNrcyBzaG91bGRuJ3QgZmlyZSB3aGlsZSBhIG1vZGFsIGRpYWxvZyBpcyB1cCAobGlrZSBhIHdp bmRvdy5hbGVydCgpKS4KKyAgICAgICAgVGhpcyBtYXRjaGVzIEZpcmVmb3ggYW5kIG90aGVyIGFz eW5jIEFQSXMuICBUaGlzIHBhdGNoIG1vdmVzIHRoZSBjYWxsYmFjayBzZXJ2aWNpbmcgaW50byBp dHMgb3duCisgICAgICAgIGNvbnRyb2xsZXIgY2xhc3Mgd2hpY2ggcmVjZWl2ZXMgbm90aWZpY2F0 aW9ucyBvbiBzdXNwZW5kL3Jlc3VtZS4KKworICAgICAgICBUZXN0OiBmYXN0L2FuaW1hdGlvbi9y ZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmctbW9kYWwuaHRtbAorCisgICAgICAgICogV2Vi Q29yZS5neXBpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnN1c3Bl bmRDYWxsYmFja3MpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnJlc3VtZUNhbGxiYWNr cyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVxdWVzdEFuaW1hdGlvbkZy YW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRDYW5jZWxSZXF1ZXN0QW5p bWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9T Y3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ6OnN1c3BlbmRBY3RpdmVET01PYmplY3RzKToKKyAgICAgICAgKFdlYkNvcmU6 OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlc3VtZUFjdGl2ZURPTU9iamVjdHMpOgorICAgICAg ICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpzdXNwZW5kQ2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6 OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlc3VtZUNhbGxiYWNrcyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpzdXNw ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVz dW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVn aXN0ZXJDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXI6OmNhbmNlbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKToKKwogMjAxMS0wMi0wNyAgTHVj YXMgRm9yc2NobGVyICA8bGZvcnNjaGxlckBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgR2VvZmYgR2FyZW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkg Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggMzc0MTFlMGE0MWE5MGUxMmI2MzJj YmMyNTA1ZDYxYzliNWFiZjE4YS4uZjc2YjNmNDVkNjRhZWQwYjhkMjQ0NjhhYzUyMDRkOTFiN2Qy NGRhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTMyMyw2ICsxMzIzLDggQEAKICAgICAgICAgICAg ICdkb20vUmFuZ2VCb3VuZGFyeVBvaW50LmgnLAogICAgICAgICAgICAgJ2RvbS9SYW5nZUV4Y2Vw dGlvbi5oJywKICAgICAgICAgICAgICdkb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2su aCcsCisgICAgICAgICAgICAnZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAnLAor ICAgICAgICAgICAgJ2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuaCcsCiAgICAgICAg ICAgICAnZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oJywKICAgICAgICAgICAgICdkb20vUmVn aXN0ZXJlZEV2ZW50TGlzdGVuZXIuY3BwJywKICAgICAgICAgICAgICdkb20vUmVnaXN0ZXJlZEV2 ZW50TGlzdGVuZXIuaCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQu Y3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRleCAxMDc5MmZjZjZiNGUy M2M2OWY2NjkyMTBiYzk2ODM0ZmViMDIzMWI3Li44MDE4MDcxNzczNTFjYTFmMGZjZDA2NzcxNmE3 OTI3OGI1MWM0N2NlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKQEAgLTIwOSw2ICsyMDksNyBA QAogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogI2luY2x1ZGUgIlJlcXVl c3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgiCisjaW5jbHVkZSAiU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyLmgiCiAjZW5kaWYKIAogdXNpbmcgbmFtZXNwYWNlIHN0ZDsKQEAgLTQyOCw5ICs0 MjksNiBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBjb25zdCBLVVJMJiB1cmws IGJvb2wgaXNYSFRNTCwgYm9vbCBpc0hUTUwsIGNvbgogICAgICwgbV93cml0aW5nTW9kZVNldE9u RG9jdW1lbnRFbGVtZW50KGZhbHNlKQogICAgICwgbV93cml0ZVJlY3Vyc2lvbklzVG9vRGVlcChm YWxzZSkKICAgICAsIG1fd3JpdGVSZWN1cnNpb25EZXB0aCgwKQotI2lmIEVOQUJMRShSRVFVRVNU X0FOSU1BVElPTl9GUkFNRSkKLSAgICAsIG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrSWQoMCkKLSNlbmRpZgogewogICAgIG1fZG9jdW1lbnQgPSB0aGlzOwogCkBAIC00NjQ3LDYg KzQ2NDUsMjIgQEAgdm9pZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0YXNr KQogICAgIGNhbGxPbk1haW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRl eHQobV93ZWFrUmVmZXJlbmNlLCB0YXNrKSk7CiB9CiAKK3ZvaWQgRG9jdW1lbnQ6OnN1c3BlbmRD YWxsYmFja3MoKQoreworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICBp ZiAobV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCisgICAgICAgIG1fc2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyLT5zdXNwZW5kKCk7CisjZW5kaWYKK30KKwordm9pZCBEb2N1bWVudDo6 cmVzdW1lQ2FsbGJhY2tzKCkKK3sKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUp CisgICAgaWYgKG1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKQorICAgICAgICBtX3Njcmlw dGVkQW5pbWF0aW9uQ29udHJvbGxlci0+cmVzdW1lKCk7CisjZW5kaWYKK30KKwogRWxlbWVudCog RG9jdW1lbnQ6OmZpbmRBbmNob3IoY29uc3QgU3RyaW5nJiBuYW1lKQogewogICAgIGlmIChuYW1l LmlzRW1wdHkoKSkKQEAgLTQ4NzksODAgKzQ4OTMsMjQgQEAgdm9pZCBEb2N1bWVudDo6bG9hZEV2 ZW50RGVsYXlUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopCiAjaWYgRU5BQkxFKFJFUVVFU1Rf QU5JTUFUSU9OX0ZSQU1FKQogaW50IERvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJh bWUoUGFzc1JlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVs ZW1lbnQqIGUpCiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykK LSAgICAgICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MgPSBuZXcgUmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2tMaXN0OwotICAgIGludCBpZCA9IG1fbmV4dFJlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrSWQrKzsKLSAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVk ID0gZmFsc2U7Ci0gICAgY2FsbGJhY2stPm1faWQgPSBpZDsKLSAgICBjYWxsYmFjay0+bV9lbGVt ZW50ID0gZTsKLSAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXBwZW5kKGNh bGxiYWNrKTsKLSAgICBpZiAoRnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2LT5zY2hl ZHVsZUFuaW1hdGlvbigpOwotICAgIHJldHVybiBpZDsKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyKQorICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlciA9 IFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKHRoaXMpOworCisgICAgcmV0dXJu IG1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLT5yZWdpc3RlckNhbGxiYWNrKGNhbGxiYWNr LCBlKTsKIH0KIAogdm9pZCBEb2N1bWVudDo6d2Via2l0Q2FuY2VsUmVxdWVzdEFuaW1hdGlvbkZy YW1lKGludCBpZCkKIHsKLSAgICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz KQorICAgIGlmICghbV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCiAgICAgICAgIHJldHVy bjsKLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2tzLT5zaXplKCk7ICsraSkgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFja3MtPmF0KGkpLT5tX2lkID09IGlkKSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7 Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkp OwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgfQorICAgIG1fc2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyLT5jYW5jZWxDYWxsYmFjayhpZCk7CiB9CiAKIHZvaWQgRG9jdW1l bnQ6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAg aWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKKyAgICBpZiAoIW1fc2NyaXB0 ZWRBbmltYXRpb25Db250cm9sbGVyKQogICAgICAgICByZXR1cm47Ci0gICAgLy8gV2Ugd2FudCB0 byBydW4gdGhlIGNhbGxiYWNrIGZvciBhbGwgZWxlbWVudHMgaW4gdGhlIGRvY3VtZW50IHRoYXQg aGF2ZSByZWdpc3RlcmVkCi0gICAgLy8gZm9yIGEgY2FsbGJhY2sgYW5kIHRoYXQgYXJlIHZpc2li bGUuICBSdW5uaW5nIHRoZSBjYWxsYmFja3MgY2FuIGNhdXNlIG5ldyBjYWxsYmFja3MKLSAgICAv LyB0byBiZSByZWdpc3RlcmVkLCBleGlzdGluZyBjYWxsYmFja3MgdG8gYmUgY2FuY2VsbGVkLCBh bmQgZWxlbWVudHMgdG8gZ2FpbiBvciBsb3NlCi0gICAgLy8gdmlzaWJpbGl0eSBzbyB0aGlzIGNv ZGUgaGFzIHRvIGl0ZXJhdGUgY2FyZWZ1bGx5LgotCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSwg dGhpcyBjb2RlIGRvZXNuJ3QgZG8gYW55IHZpc2liaWxpdHkgdGVzdHMgYmV5b25kIGNoZWNraW5n IGRpc3BsYXk6Ci0KLSAgICAvLyBGaXJzdCwgZ2VuZXJhdGUgYSBsaXN0IG9mIGNhbGxiYWNrcyB0 byBjb25zaWRlci4gIENhbGxiYWNrcyByZWdpc3RlcmVkIGZyb20gdGhpcyBwb2ludAotICAgIC8v IG9uIGFyZSBjb25zaWRlcmVkIG9ubHkgZm9yIHRoZSAibmV4dCIgZnJhbWUsIG5vdCB0aGlzIG9u ZS4KLSAgICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3QgY2FsbGJhY2tzKCptX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcyk7Ci0KLSAgICAvLyBGaXJpbmcgdGhlIGNhbGxi YWNrIG1heSBjYXVzZSB0aGUgdmlzaWJpbGl0eSBvZiBvdGhlciBlbGVtZW50cyB0byBjaGFuZ2Uu ICBUbyBhdm9pZAotICAgIC8vIG1pc3NpbmcgYW55IGNhbGxiYWNrcywgd2Uga2VlcCBpdGVyYXRp bmcgdGhyb3VnaCB0aGUgbGlzdCBvZiBjYW5kaWF0ZSBjYWxsYmFja3MgYW5kIGZpcmluZwotICAg IC8vIHRoZW0gdW50aWwgbm90aGluZyBuZXcgYmVjb21lcyB2aXNpYmxlLgotICAgIGJvb2wgZmly ZWRDYWxsYmFjazsKLSAgICBkbyB7Ci0gICAgICAgIGZpcmVkQ2FsbGJhY2sgPSBmYWxzZTsKLSAg ICAgICAgLy8gQSBwcmV2aW91cyBpdGVyYXRpb24gbWF5IGhhdmUgaW52YWxpZGF0ZWQgc3R5bGUg KG9yIGxheW91dCkuICBVcGRhdGUgc3R5bGVzIGZvciBlYWNoIGl0ZXJhdGlvbgotICAgICAgICAv LyBmb3Igbm93IHNpbmNlIGFsbCB3ZSBjaGVjayBpcyB0aGUgZXhpc3RlbmNlIG9mIGEgcmVuZGVy ZXIuCi0gICAgICAgIHVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAgICAgZm9yIChzaXplX3Qg aSA9IDA7IGkgPCBjYWxsYmFja3Muc2l6ZSgpOyArK2kpIHsKLSAgICAgICAgICAgIFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrKiBjYWxsYmFjayA9IGNhbGxiYWNrc1tpXS5nZXQoKTsKLSAg ICAgICAgICAgIGlmICghY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCAmJiAoIWNhbGxiYWNr LT5tX2VsZW1lbnQgfHwgY2FsbGJhY2stPm1fZWxlbWVudC0+cmVuZGVyZXIoKSkpIHsKLSAgICAg ICAgICAgICAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKLSAgICAgICAg ICAgICAgICBjYWxsYmFjay0+aGFuZGxlRXZlbnQodGltZSk7Ci0gICAgICAgICAgICAgICAgZmly ZWRDYWxsYmFjayA9IHRydWU7Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsK LSAgICAgICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgIH0g d2hpbGUgKGZpcmVkQ2FsbGJhY2spOwotCi0gICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2Ug ZmlyZWQgZnJvbSB0aGUgbGlzdCBvZiBwZW5kaW5nIGNhbGxiYWNrcy4KLSAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7KSB7 Ci0gICAgICAgIGlmIChtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1f ZmlyZWRPckNhbmNlbGxlZCkKLSAgICAgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2Fs bGJhY2tzLT5yZW1vdmUoaSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICsraTsKLSAgICB9 Ci0KLSAgICAvLyBJbiBtb3N0IGNhc2VzIHdlIGV4cGVjdCB0aGlzIGxpc3QgdG8gYmUgZW1wdHks IHNvIG5vIG5lZWQgdG8ga2VlcCBhcm91bmQgdGhlIHZlY3RvcidzIGlubGluZSBidWZmZXIuCi0g ICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+c2l6ZSgpKQotICAgICAg ICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy5jbGVhcigpOwotICAgIGVsc2UgaWYg KEZyYW1lVmlldyogdiA9IHZpZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsK KyAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0 aW9ucyh0aW1lKTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IDk0NmU1N2Fm MmI2ZjhmMWMwZjc2NzkyOTAzMWM4ZGI2MGExM2Q4OTYuLjI2NTJmNTg0MjQ3M2IzYzU4ZDRlNjUz MTNlZjc5NjBhMzQzMjI2MTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xNTEsNiArMTUxLDcg QEAgY2xhc3MgVG91Y2hMaXN0OwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1F KQogY2xhc3MgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s7CitjbGFzcyBTY3JpcHRlZEFu aW1hdGlvbkNvbnRyb2xsZXI7CiAjZW5kaWYKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsK QEAgLTk0MCw2ICs5NDEsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZE1lc3NhZ2Uo TWVzc2FnZVNvdXJjZSwgTWVzc2FnZVR5cGUsIE1lc3NhZ2VMZXZlbCwgY29uc3QgU3RyaW5nJiBt ZXNzYWdlLCB1bnNpZ25lZCBsaW5lTnVtYmVyLCBjb25zdCBTdHJpbmcmIHNvdXJjZVVSTCwgUGFz c1JlZlB0cjxTY3JpcHRDYWxsU3RhY2s+KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFz c093blB0cjxUYXNrPik7IC8vIEV4ZWN1dGVzIHRoZSB0YXNrIG9uIGNvbnRleHQncyB0aHJlYWQg YXN5bmNocm9ub3VzbHkuCiAKKyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZENhbGxiYWNrcygpOwor ICAgIHZpcnR1YWwgdm9pZCByZXN1bWVDYWxsYmFja3MoKTsKKwogI2lmIFVTRShKU0MpCiAgICAg dHlwZWRlZiBKU0M6OldlYWtHQ01hcDxXZWJDb3JlOjpOb2RlKiwgSlNOb2RlPiBKU1dyYXBwZXJD YWNoZTsKICAgICB0eXBlZGVmIEhhc2hNYXA8RE9NV3JhcHBlcldvcmxkKiwgSlNXcmFwcGVyQ2Fj aGUqPiBKU1dyYXBwZXJDYWNoZU1hcDsKQEAgLTEzODksOSArMTM5Myw3IEBAIHByaXZhdGU6CiAg ICAgdW5zaWduZWQgbV93cml0ZVJlY3Vyc2lvbkRlcHRoOwogCiAjaWYgRU5BQkxFKFJFUVVFU1Rf QU5JTUFUSU9OX0ZSQU1FKQotICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDYWxsYmFjaz4gPiBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3Q7Ci0g ICAgT3duUHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrTGlzdD4gbV9yZXF1ZXN0QW5p bWF0aW9uRnJhbWVDYWxsYmFja3M7Ci0gICAgaW50IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFt ZUNhbGxiYWNrSWQ7CisgICAgT3duUHRyPFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcj4gbV9z Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI7CiAjZW5kaWYKIAogICAgIENvbnRlbnRTZWN1cml0 eVBvbGljeSBtX2NvbnRlbnRTZWN1cml0eVBvbGljeTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9T Y3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAppbmRleCAxOTI2N2M2M2Q3OGMzMDc5NWViNjdjZjNj NjNjN2VkNDYxMGFmNmYxLi4zZjU2NDEzYWUzZTk5ZDBkZmFkYzdiM2NkNjBiZTdlN2VlZjNmNTgw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCkBA IC0yMzcsNiArMjM3LDcgQEAgYm9vbCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpjYW5TdXNwZW5k QWN0aXZlRE9NT2JqZWN0cygpCiAKIHZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c3VzcGVu ZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZlRE9NT2JqZWN0OjpSZWFzb25Gb3JTdXNwZW5zaW9uIHdo eSkKIHsKKyAgICBzdXNwZW5kQ2FsbGJhY2tzKCk7CiAgICAgLy8gTm8gcHJvdGVjdGlvbiBhZ2Fp bnN0IG1fYWN0aXZlRE9NT2JqZWN0cyBjaGFuZ2luZyBkdXJpbmcgaXRlcmF0aW9uOiBzdXNwZW5k KCkgc2hvdWxkbid0IGV4ZWN1dGUgYXJiaXRyYXJ5IEpTLgogICAgIG1faXRlcmF0aW5nQWN0aXZl RE9NT2JqZWN0cyA9IHRydWU7CiAgICAgSGFzaE1hcDxBY3RpdmVET01PYmplY3QqLCB2b2lkKj46 Oml0ZXJhdG9yIGFjdGl2ZU9iamVjdHNFbmQgPSBtX2FjdGl2ZURPTU9iamVjdHMuZW5kKCk7CkBA IC0yNTcsNiArMjU4LDcgQEAgdm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpyZXN1bWVBY3Rp dmVET01PYmplY3RzKCkKICAgICAgICAgaXRlci0+Zmlyc3QtPnJlc3VtZSgpOwogICAgIH0KICAg ICBtX2l0ZXJhdGluZ0FjdGl2ZURPTU9iamVjdHMgPSBmYWxzZTsKKyAgICByZXN1bWVDYWxsYmFj a3MoKTsKIH0KIAogdm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wQWN0aXZlRE9NT2Jq ZWN0cygpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29u dGV4dC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAppbmRl eCA2NDI5MDZjNDA4MmUwNWFlYzZiMzI5M2YwZjZhNTk0YjI0MmRmMGNiLi44MjZkYTQ1N2IyMTI3 NTUwYzkxNTgwOTNjZTZiMWRmMDM1ZjQwMjA5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9k b20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgKQEAgLTE1OCw2ICsxNTgsOSBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIC8vICAgICAgIHRoYXQgYWxyZWFkeSBjb250YWlucyBjb250ZW50LgogICAg ICAgICB2b2lkIHNldFNlY3VyaXR5T3JpZ2luKFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+KTsK IAorICAgICAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZENhbGxiYWNrcygpIHt9CisgICAgICAgIHZp cnR1YWwgdm9pZCByZXN1bWVDYWxsYmFja3MoKSB7fQorCiAgICAgcHJpdmF0ZToKICAgICAgICAg dmlydHVhbCBjb25zdCBLVVJMJiB2aXJ0dWFsVVJMKCkgY29uc3QgPSAwOwogICAgICAgICB2aXJ0 dWFsIEtVUkwgdmlydHVhbENvbXBsZXRlVVJMKGNvbnN0IFN0cmluZyYpIGNvbnN0ID0gMDsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIu Y3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZWExY2RmNTE5ZDUyYTFkZDg2NTFmMzI5Y2MwYmEwNTMwODE3YjIyNwotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXIuY3BwCkBAIC0wLDAgKzEsMTM2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEdv b2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKworI2luY2x1ZGUgIlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oIgorCisjaWYg RU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIK KyNpbmNsdWRlICJFbGVtZW50LmgiCisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAi UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxl cihEb2N1bWVudCogZG9jdW1lbnQpCisgICAgOiBtX2RvY3VtZW50KGRvY3VtZW50KQorICAgICwg bV9uZXh0Q2FsbGJhY2tJZCgwKQorICAgICwgbV9zdXNwZW5kQ291bnQoMCkKK3sKK30KKwordm9p ZCBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OnN1c3BlbmQoKQoreworICAgIG1fc3VzcGVu ZENvdW50Kys7Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpyZXN1bWUo KQoreworICAgIG1fc3VzcGVuZENvdW50LS07CisgICAgaWYgKCFtX3N1c3BlbmRDb3VudCAmJiBt X2NhbGxiYWNrcy5zaXplKCkpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVu dC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cit9CisKK1Nj cmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Q2FsbGJhY2tJZCBTY3JpcHRlZEFuaW1hdGlvbkNv bnRyb2xsZXI6OnJlZ2lzdGVyQ2FsbGJhY2soUGFzc1JlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQqIGUpCit7CisgICAgU2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyOjpDYWxsYmFja0lkIGlkID0gbV9uZXh0Q2FsbGJhY2tJZCsrOworICAgIGNh bGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSBmYWxzZTsKKyAgICBjYWxsYmFjay0+bV9pZCA9 IGlkOworICAgIGNhbGxiYWNrLT5tX2VsZW1lbnQgPSBlOworICAgIG1fY2FsbGJhY2tzLmFwcGVu ZChjYWxsYmFjayk7CisgICAgaWYgKCFtX3N1c3BlbmRDb3VudCkKKyAgICAgICAgaWYgKEZyYW1l VmlldyogZnYgPSBtX2RvY3VtZW50LT52aWV3KCkpCisgICAgICAgICAgICBmdi0+c2NoZWR1bGVB bmltYXRpb24oKTsKKyAgICByZXR1cm4gaWQ7Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyOjpjYW5jZWxDYWxsYmFjayhDYWxsYmFja0lkIGlkKQoreworICAgIGZvciAoc2l6 ZV90IGkgPSAwOyBpIDwgbV9jYWxsYmFja3Muc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgaWYgKG1f Y2FsbGJhY2tzW2ldLT5tX2lkID09IGlkKSB7CisgICAgICAgICAgICBtX2NhbGxiYWNrc1tpXS0+ bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKKyAgICAgICAgICAgIG1fY2FsbGJhY2tzLnJlbW92 ZShpKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0KK30KKwordm9pZCBT Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9N VGltZVN0YW1wIHRpbWUpCit7CisgICAgaWYgKCFtX2NhbGxiYWNrcy5zaXplKCkgfHwgbV9zdXNw ZW5kQ291bnQpCisgICAgICAgIHJldHVybjsKKyAgICAvLyBXZSB3YW50IHRvIHJ1biB0aGUgY2Fs bGJhY2sgZm9yIGFsbCBlbGVtZW50cyBpbiB0aGUgZG9jdW1lbnQgdGhhdCBoYXZlIHJlZ2lzdGVy ZWQKKyAgICAvLyBmb3IgYSBjYWxsYmFjayBhbmQgdGhhdCBhcmUgdmlzaWJsZS4gIFJ1bm5pbmcg dGhlIGNhbGxiYWNrcyBjYW4gY2F1c2UgbmV3IGNhbGxiYWNrcworICAgIC8vIHRvIGJlIHJlZ2lz dGVyZWQsIGV4aXN0aW5nIGNhbGxiYWNrcyB0byBiZSBjYW5jZWxsZWQsIGFuZCBlbGVtZW50cyB0 byBnYWluIG9yIGxvc2UKKyAgICAvLyB2aXNpYmlsaXR5IHNvIHRoaXMgY29kZSBoYXMgdG8gaXRl cmF0ZSBjYXJlZnVsbHkuCisKKyAgICAvLyBGSVhNRTogQ3VycmVudGx5LCB0aGlzIGNvZGUgZG9l c24ndCBkbyBhbnkgdmlzaWJpbGl0eSB0ZXN0cyBiZXlvbmQgY2hlY2tpbmcgZGlzcGxheToKKwor ICAgIC8vIEZpcnN0LCBnZW5lcmF0ZSBhIGxpc3Qgb2YgY2FsbGJhY2tzIHRvIGNvbnNpZGVyLiAg Q2FsbGJhY2tzIHJlZ2lzdGVyZWQgZnJvbSB0aGlzIHBvaW50CisgICAgLy8gb24gYXJlIGNvbnNp ZGVyZWQgb25seSBmb3IgdGhlICJuZXh0IiBmcmFtZSwgbm90IHRoaXMgb25lLgorICAgIENhbGxi YWNrTGlzdCBjYWxsYmFja3MobV9jYWxsYmFja3MpOworCisgICAgLy8gRmlyaW5nIHRoZSBjYWxs YmFjayBtYXkgY2F1c2UgdGhlIHZpc2liaWxpdHkgb2Ygb3RoZXIgZWxlbWVudHMgdG8gY2hhbmdl LiAgVG8gYXZvaWQKKyAgICAvLyBtaXNzaW5nIGFueSBjYWxsYmFja3MsIHdlIGtlZXAgaXRlcmF0 aW5nIHRocm91Z2ggdGhlIGxpc3Qgb2YgY2FuZGlhdGUgY2FsbGJhY2tzIGFuZCBmaXJpbmcKKyAg ICAvLyB0aGVtIHVudGlsIG5vdGhpbmcgbmV3IGJlY29tZXMgdmlzaWJsZS4KKyAgICBib29sIGZp cmVkQ2FsbGJhY2s7CisgICAgZG8geworICAgICAgICBmaXJlZENhbGxiYWNrID0gZmFsc2U7Cisg ICAgICAgIC8vIEEgcHJldmlvdXMgaXRlcmF0aW9uIG1heSBoYXZlIGludmFsaWRhdGVkIHN0eWxl IChvciBsYXlvdXQpLiAgVXBkYXRlIHN0eWxlcyBmb3IgZWFjaCBpdGVyYXRpb24KKyAgICAgICAg Ly8gZm9yIG5vdyBzaW5jZSBhbGwgd2UgY2hlY2sgaXMgdGhlIGV4aXN0ZW5jZSBvZiBhIHJlbmRl cmVyLgorICAgICAgICBtX2RvY3VtZW50LT51cGRhdGVTdHlsZUlmTmVlZGVkKCk7CisgICAgICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY2FsbGJhY2tzLnNpemUoKTsgKytpKSB7CisgICAgICAg ICAgICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjayogY2FsbGJhY2sgPSBjYWxsYmFja3Nb aV0uZ2V0KCk7CisgICAgICAgICAgICBpZiAoIWNhbGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQg JiYgKCFjYWxsYmFjay0+bV9lbGVtZW50IHx8IGNhbGxiYWNrLT5tX2VsZW1lbnQtPnJlbmRlcmVy KCkpKSB7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRy dWU7CisgICAgICAgICAgICAgICAgY2FsbGJhY2stPmhhbmRsZUV2ZW50KHRpbWUpOworICAgICAg ICAgICAgICAgIGZpcmVkQ2FsbGJhY2sgPSB0cnVlOworICAgICAgICAgICAgICAgIGNhbGxiYWNr cy5yZW1vdmUoaSk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAg ICAgIH0KKyAgICB9IHdoaWxlIChmaXJlZENhbGxiYWNrKTsKKworICAgIC8vIFJlbW92ZSBhbnkg Y2FsbGJhY2tzIHdlIGZpcmVkIGZyb20gdGhlIGxpc3Qgb2YgcGVuZGluZyBjYWxsYmFja3MuCisg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NhbGxiYWNrcy5zaXplKCk7KSB7CisgICAgICAg IGlmIChtX2NhbGxiYWNrc1tpXS0+bV9maXJlZE9yQ2FuY2VsbGVkKQorICAgICAgICAgICAgbV9j YWxsYmFja3MucmVtb3ZlKGkpOworICAgICAgICBlbHNlCisgICAgICAgICAgICArK2k7CisgICAg fQorCisgICAgaWYgKG1fY2FsbGJhY2tzLnNpemUoKSkKKyAgICAgICAgaWYgKEZyYW1lVmlldyog diA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAgICAgICAgICAgIHYtPnNjaGVkdWxlQW5pbWF0aW9u KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmCisKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuaCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40 YjM0YjZhYWVhZWFiYjhhMmE3YmUxYzA5NWYzNDUxYjM5ZDRiNTA4Ci0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oCkBAIC0w LDAgKzEsNzIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIFJp Z2h0cyBSZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQor ICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQor ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqCisgKi8KKworI2lmbmRlZiBTY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXJfaAorI2RlZmluZSBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJfaAorCisjaW5jbHVk ZSAiRE9NVGltZVN0YW1wLmgiCisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVk ZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8 d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIERvY3VtZW50Owor Y2xhc3MgRWxlbWVudDsKK2NsYXNzIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrOworCitj bGFzcyBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIgeworV1RGX01BS0VfTk9OQ09QWUFCTEUo U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKTsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093 blB0cjxTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI+IGNyZWF0ZShEb2N1bWVudCogZCkKKyAg ICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgU2NyaXB0ZWRBbmltYXRpb25Db250cm9s bGVyKGQpKTsKKyAgICB9CisKKyAgICB0eXBlZGVmIGludCBDYWxsYmFja0lkOworCisgICAgQ2Fs bGJhY2tJZCByZWdpc3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1l Q2FsbGJhY2s+LCBFbGVtZW50Kik7CisgICAgdm9pZCBjYW5jZWxDYWxsYmFjayhDYWxsYmFja0lk KTsKKyAgICB2b2lkIHNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wKTsKKwor ICAgIHZvaWQgc3VzcGVuZCgpOworICAgIHZvaWQgcmVzdW1lKCk7CisKK3ByaXZhdGU6CisgICAg ZXhwbGljaXQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKERvY3VtZW50Kik7CisgICAgdHlw ZWRlZiBWZWN0b3I8UmVmUHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrPiA+IENhbGxi YWNrTGlzdDsKKyAgICBDYWxsYmFja0xpc3QgbV9jYWxsYmFja3M7CisKKyAgICBEb2N1bWVudCog bV9kb2N1bWVudDsKKyAgICBDYWxsYmFja0lkIG1fbmV4dENhbGxiYWNrSWQ7CisgICAgaW50IG1f c3VzcGVuZENvdW50OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8g U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyX2gKKwo= 82528 2011-02-15 14:57:39 -0800 2011-02-15 15:18:33 -0800 with explicit extra suspend/resume calls bug-53188-20110215145738.patch text/plain 25443 jamesr U3VidmVyc2lvbiBSZXZpc2lvbjogNzg2MTQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4YmVlZWU4OGEyOWMyNTEyNjZjNWY3 MDQzOTg0ZjJkZjUwYzU1YjFlLi40NDkyYTlkMzkyYWJkZDQ3NmE2Nzk5YTBhN2E3YzcxMDVhOWM3 OTQyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMTUgIEphbWVzIFJvYmluc29uICA8 amFtZXNyQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3Qg ZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisKKyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5p bWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBzdXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAg ICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5o dG1sOiBBZGRlZC4KKwogMjAxMS0wMi0xNSAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGln YWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6LgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5n LW1vZGFsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjI3 ODc3NTU4NzAyOWYzYWNiZjA4ODE1Y2Y4YWJmMWFjMDg3OTA3MgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmlu Zy1tb2RhbC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBAQAorVGVzdHMgdGhhdCByZXF1ZXN0 QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFs b2dzIGFyZSBkaXNwbGF5ZWQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBv ZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNT IHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKK1NldHRpbmcgY2Fs bGJhY2sKK1Nob3dpbmcgbW9kYWwgZGlhbG9nCitSZXR1cm5lZCBmcm9tIG1vZGFsIGRpYWxvZwor Q2FsbGJhY2sgZmlyZWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24v cmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmctbW9kYWwuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lOTAzZDczYThkNmM1YWNkNjdlMGZjZjEzYTA4OWNlODlmMjZmMWRlCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRp b24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ CitkZXNjcmlwdGlvbignVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tz IGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFsb2dzIGFyZSBkaXNwbGF5ZWQuJyk7CisK K29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICBkZWJ1ZygnU2V0dGluZyBjYWxsYmFjaycpOwor ICAgIHdpbmRvdy53ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoZnVuY3Rpb24oKSB7IGRlYnVn KCdDYWxsYmFjayBmaXJlZCcpOyB9LCBkb2N1bWVudC5ib2R5KTsKKyAgICBkZWJ1ZygnU2hvd2lu ZyBtb2RhbCBkaWFsb2cnKTsKKyAgICB2YXIgc3JjID0gJ2lmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsnICsKKyAgICAgICAgICAgICAgJyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k aXNwbGF5KCk7JyArCisgICAgICAgICAgICAgICcgICAgd2luZG93LmNsb3NlKCk7JyArCisgICAg ICAgICAgICAgICd9IGVsc2UgeycrCisgICAgICAgICAgICAgICcgICAgd2luZG93LnNldFRpbWVv dXQod2luZG93LmNsb3NlLCAxMCk7JysKKyAgICAgICAgICAgICAgJ30nOworICAgIHNob3dNb2Rh bERpYWxvZygnZGF0YTp0ZXh0L2h0bWwsPHNjcmlwdD4nICsgc3JjICsgJzwvJyArICdzY3JpcHQ+ Jyk7CisgICAgZGVidWcoJ1JldHVybmVkIGZyb20gbW9kYWwgZGlhbG9nJyk7CisgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgezsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZGlzcGxheSgpOworICAgIH0KK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7 Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0Lmpz Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGNhNDMwNTc0M2Iy MWFlMWE2OTA4MTE5ZmRhZmZiYjk0Y2YwYmYwNzQuLjA3ZTI2OGYyMDRlZjhkOGZlYjk3MDRmNDA1 ZTRmYzMzM2JiNzRkYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NiBAQAorMjAxMS0wMi0xNSAg SmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIHJlcXVlc3RBbmltYXRpb25GcmFtZSBjYWxs YmFja3Mgc2hvdWxkIG5vdCBmaXJlIHdpdGhpbiBhIG1vZGFsIGRpYWxvZworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxODgKKworICAgICAgICByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZG4ndCBmaXJlIHdoaWxlIGEgbW9kYWwg ZGlhbG9nIGlzIHVwIChsaWtlIGEgd2luZG93LmFsZXJ0KCkpLgorICAgICAgICBUaGlzIG1hdGNo ZXMgRmlyZWZveCBhbmQgb3RoZXIgYXN5bmMgQVBJcy4gIFRoaXMgcGF0Y2ggbW92ZXMgdGhlIGNh bGxiYWNrIHNlcnZpY2luZyBpbnRvIGl0cyBvd24KKyAgICAgICAgY29udHJvbGxlciBjbGFzcyB3 aGljaCByZWNlaXZlcyBub3RpZmljYXRpb25zIG9uIHN1c3BlbmQvcmVzdW1lLgorCisgICAgICAg IFRlc3Q6IGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC5odG1sCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogYmluZGluZ3MvanMv U2NyaXB0RGVidWdTZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RGVidWdTZXJ2 ZXI6OnNldEphdmFTY3JpcHRQYXVzZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnQ6OnN1c3BlbmRDYWxsYmFja3MpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OnJlc3VtZUNhbGxiYWNrcyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVx dWVzdEFuaW1hdGlvbkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRD YW5jZWxSZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgor ICAgICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdXNwZW5kQ2FsbGJhY2tzKToKKyAgICAgICAgKFdl YkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlc3VtZUNhbGxiYWNrcyk6CisgICAgICAg ICogZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpTY3JpcHRlZEFuaW1hdGlvbkNv bnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy OjpzdXNwZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxl cjo6cmVzdW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxl cjo6cmVnaXN0ZXJDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRlZEFuaW1hdGlv bkNvbnRyb2xsZXI6OmNhbmNlbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVk QW5pbWF0aW9uQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyk6CisgICAgICAg ICogZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKToKKyAgICAgICAgKiBo aXN0b3J5L0NhY2hlZEZyYW1lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZEZyYW1lQmFz ZTo6cmVzdG9yZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRGcmFtZTo6Q2FjaGVkRnJhbWUp OgorICAgICAgICAqIHBhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6UGFnZUdyb3VwTG9hZERlZmVycmVyKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6flBhZ2VHcm91cExvYWREZWZl cnJlcik6CisKIDIwMTEtMDItMTUgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRl eCA3YTg2OGYwZjZhNjVmOGU2MGUwMWVkNzg1NjI3NGU5MmEwNzRmMTIxLi4xMDZiZTVjZGEzN2M0 ZDExYjY2MTcwY2YxNzhmMGFkYmEwNGRlOGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzIxLDYg KzEzMjEsOCBAQAogICAgICAgICAgICAgJ2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCcsCiAgICAg ICAgICAgICAnZG9tL1JhbmdlRXhjZXB0aW9uLmgnLAogICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdkb20vU2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyLmNwcCcsCisgICAgICAgICAgICAnZG9tL1NjcmlwdGVkQW5pbWF0aW9u Q29udHJvbGxlci5oJywKICAgICAgICAgICAgICdkb20vUmF3RGF0YURvY3VtZW50UGFyc2VyLmgn LAogICAgICAgICAgICAgJ2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5jcHAnLAogICAgICAg ICAgICAgJ2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5oJywKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcCBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcAppbmRleCA1YzUyZGQ3ZTdlN2I2 OWNiYTk2YzFjYjM5MTI0ODRiYzhkNTY2MDZlLi5jNTUxYWFjMGI0NzgwMTRhYWYzN2IzNzc2ZGRk YTc5OTRjYTM4Nzc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9TY3Jp cHREZWJ1Z1NlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvU2NyaXB0 RGVidWdTZXJ2ZXIuY3BwCkBAIC00MDgsMTAgKzQwOCwxMyBAQCB2b2lkIFNjcmlwdERlYnVnU2Vy dmVyOjpzZXRKYXZhU2NyaXB0UGF1c2VkKEZyYW1lKiBmcmFtZSwgYm9vbCBwYXVzZWQpCiAgICAg ZnJhbWUtPnNjcmlwdCgpLT5zZXRQYXVzZWQocGF1c2VkKTsKIAogICAgIERvY3VtZW50KiBkb2N1 bWVudCA9IGZyYW1lLT5kb2N1bWVudCgpOwotICAgIGlmIChwYXVzZWQpCisgICAgaWYgKHBhdXNl ZCkgeworICAgICAgICBkb2N1bWVudC0+c3VzcGVuZENhbGxiYWNrcygpOwogICAgICAgICBkb2N1 bWVudC0+c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZlRE9NT2JqZWN0OjpKYXZhU2NyaXB0 RGVidWdnZXJQYXVzZWQpOwotICAgIGVsc2UKKyAgICB9IGVsc2UgewogICAgICAgICBkb2N1bWVu dC0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpOworICAgICAgICBkb2N1bWVudC0+cmVzdW1lQ2Fs bGJhY2tzKCk7CisgICAgfQogCiAgICAgc2V0SmF2YVNjcmlwdFBhdXNlZChmcmFtZS0+dmlldygp LCBwYXVzZWQpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNw cCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggYjM2ZmZmMDY0OTIwMGYw MjI3YmI1YmNlNzI4ZWJmY2E1OWM3ZTZlNS4uMzUwMWY1Mjk1NTViZDJjOWI1MDI4Mjk5ZDBlYzg3 MDYxNTQ5OThkMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0yMTAsNiArMjEwLDcgQEAK IAogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKICNpbmNsdWRlICJSZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oIgorI2luY2x1ZGUgIlNjcmlwdGVkQW5pbWF0aW9uQ29u dHJvbGxlci5oIgogI2VuZGlmCiAKIHVzaW5nIG5hbWVzcGFjZSBzdGQ7CkBAIC00MjksOSArNDMw LDYgQEAgRG9jdW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBi b29sIGlzWEhUTUwsIGJvb2wgaXNIVE1MKQogICAgICwgbV93cml0aW5nTW9kZVNldE9uRG9jdW1l bnRFbGVtZW50KGZhbHNlKQogICAgICwgbV93cml0ZVJlY3Vyc2lvbklzVG9vRGVlcChmYWxzZSkK ICAgICAsIG1fd3JpdGVSZWN1cnNpb25EZXB0aCgwKQotI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1B VElPTl9GUkFNRSkKLSAgICAsIG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrSWQo MCkKLSNlbmRpZgogewogICAgIG1fZG9jdW1lbnQgPSB0aGlzOwogCkBAIC00NjY1LDYgKzQ2NjMs MjIgQEAgdm9pZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0YXNrKQogICAg IGNhbGxPbk1haW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRleHQobV93 ZWFrUmVmZXJlbmNlLCB0YXNrKSk7CiB9CiAKK3ZvaWQgRG9jdW1lbnQ6OnN1c3BlbmRDYWxsYmFj a3MoKQoreworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICBpZiAobV9z Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCisgICAgICAgIG1fc2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyLT5zdXNwZW5kKCk7CisjZW5kaWYKK30KKwordm9pZCBEb2N1bWVudDo6cmVzdW1l Q2FsbGJhY2tzKCkKK3sKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAg aWYgKG1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKQorICAgICAgICBtX3NjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlci0+cmVzdW1lKCk7CisjZW5kaWYKK30KKwogRWxlbWVudCogRG9jdW1l bnQ6OmZpbmRBbmNob3IoY29uc3QgU3RyaW5nJiBuYW1lKQogewogICAgIGlmIChuYW1lLmlzRW1w dHkoKSkKQEAgLTQ4OTcsODAgKzQ5MTEsMjQgQEAgdm9pZCBEb2N1bWVudDo6bG9hZEV2ZW50RGVs YXlUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFU SU9OX0ZSQU1FKQogaW50IERvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoUGFz c1JlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQq IGUpCiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKLSAgICAg ICAgbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MgPSBuZXcgUmVxdWVzdEFuaW1hdGlv bkZyYW1lQ2FsbGJhY2tMaXN0OwotICAgIGludCBpZCA9IG1fbmV4dFJlcXVlc3RBbmltYXRpb25G cmFtZUNhbGxiYWNrSWQrKzsKLSAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFs c2U7Ci0gICAgY2FsbGJhY2stPm1faWQgPSBpZDsKLSAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0g ZTsKLSAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXBwZW5kKGNhbGxiYWNr KTsKLSAgICBpZiAoRnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2LT5zY2hlZHVsZUFu aW1hdGlvbigpOwotICAgIHJldHVybiBpZDsKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyKQorICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlciA9IFNjcmlw dGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKHRoaXMpOworCisgICAgcmV0dXJuIG1fc2Ny aXB0ZWRBbmltYXRpb25Db250cm9sbGVyLT5yZWdpc3RlckNhbGxiYWNrKGNhbGxiYWNrLCBlKTsK IH0KIAogdm9pZCBEb2N1bWVudDo6d2Via2l0Q2FuY2VsUmVxdWVzdEFuaW1hdGlvbkZyYW1lKGlu dCBpZCkKIHsKLSAgICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzKQorICAg IGlmICghbV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCiAgICAgICAgIHJldHVybjsKLSAg ICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz LT5zaXplKCk7ICsraSkgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxs YmFja3MtPmF0KGkpLT5tX2lkID09IGlkKSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7Ci0gICAg ICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgfQorICAgIG1fc2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyLT5jYW5jZWxDYWxsYmFjayhpZCk7CiB9CiAKIHZvaWQgRG9jdW1lbnQ6OnNl cnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAgaWYgKCFt X3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyKQogICAgICAgICByZXR1cm47Ci0gICAgLy8gV2Ugd2FudCB0byBydW4g dGhlIGNhbGxiYWNrIGZvciBhbGwgZWxlbWVudHMgaW4gdGhlIGRvY3VtZW50IHRoYXQgaGF2ZSBy ZWdpc3RlcmVkCi0gICAgLy8gZm9yIGEgY2FsbGJhY2sgYW5kIHRoYXQgYXJlIHZpc2libGUuICBS dW5uaW5nIHRoZSBjYWxsYmFja3MgY2FuIGNhdXNlIG5ldyBjYWxsYmFja3MKLSAgICAvLyB0byBi ZSByZWdpc3RlcmVkLCBleGlzdGluZyBjYWxsYmFja3MgdG8gYmUgY2FuY2VsbGVkLCBhbmQgZWxl bWVudHMgdG8gZ2FpbiBvciBsb3NlCi0gICAgLy8gdmlzaWJpbGl0eSBzbyB0aGlzIGNvZGUgaGFz IHRvIGl0ZXJhdGUgY2FyZWZ1bGx5LgotCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSwgdGhpcyBj b2RlIGRvZXNuJ3QgZG8gYW55IHZpc2liaWxpdHkgdGVzdHMgYmV5b25kIGNoZWNraW5nIGRpc3Bs YXk6Ci0KLSAgICAvLyBGaXJzdCwgZ2VuZXJhdGUgYSBsaXN0IG9mIGNhbGxiYWNrcyB0byBjb25z aWRlci4gIENhbGxiYWNrcyByZWdpc3RlcmVkIGZyb20gdGhpcyBwb2ludAotICAgIC8vIG9uIGFy ZSBjb25zaWRlcmVkIG9ubHkgZm9yIHRoZSAibmV4dCIgZnJhbWUsIG5vdCB0aGlzIG9uZS4KLSAg ICBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3QgY2FsbGJhY2tzKCptX3JlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrcyk7Ci0KLSAgICAvLyBGaXJpbmcgdGhlIGNhbGxiYWNrIG1h eSBjYXVzZSB0aGUgdmlzaWJpbGl0eSBvZiBvdGhlciBlbGVtZW50cyB0byBjaGFuZ2UuICBUbyBh dm9pZAotICAgIC8vIG1pc3NpbmcgYW55IGNhbGxiYWNrcywgd2Uga2VlcCBpdGVyYXRpbmcgdGhy b3VnaCB0aGUgbGlzdCBvZiBjYW5kaWF0ZSBjYWxsYmFja3MgYW5kIGZpcmluZwotICAgIC8vIHRo ZW0gdW50aWwgbm90aGluZyBuZXcgYmVjb21lcyB2aXNpYmxlLgotICAgIGJvb2wgZmlyZWRDYWxs YmFjazsKLSAgICBkbyB7Ci0gICAgICAgIGZpcmVkQ2FsbGJhY2sgPSBmYWxzZTsKLSAgICAgICAg Ly8gQSBwcmV2aW91cyBpdGVyYXRpb24gbWF5IGhhdmUgaW52YWxpZGF0ZWQgc3R5bGUgKG9yIGxh eW91dCkuICBVcGRhdGUgc3R5bGVzIGZvciBlYWNoIGl0ZXJhdGlvbgotICAgICAgICAvLyBmb3Ig bm93IHNpbmNlIGFsbCB3ZSBjaGVjayBpcyB0aGUgZXhpc3RlbmNlIG9mIGEgcmVuZGVyZXIuCi0g ICAgICAgIHVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7 IGkgPCBjYWxsYmFja3Muc2l6ZSgpOyArK2kpIHsKLSAgICAgICAgICAgIFJlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrKiBjYWxsYmFjayA9IGNhbGxiYWNrc1tpXS5nZXQoKTsKLSAgICAgICAg ICAgIGlmICghY2FsbGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCAmJiAoIWNhbGxiYWNrLT5tX2Vs ZW1lbnQgfHwgY2FsbGJhY2stPm1fZWxlbWVudC0+cmVuZGVyZXIoKSkpIHsKLSAgICAgICAgICAg ICAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKLSAgICAgICAgICAgICAg ICBjYWxsYmFjay0+aGFuZGxlRXZlbnQodGltZSk7Ci0gICAgICAgICAgICAgICAgZmlyZWRDYWxs YmFjayA9IHRydWU7Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsKLSAgICAg ICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgIH0gd2hpbGUg KGZpcmVkQ2FsbGJhY2spOwotCi0gICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2UgZmlyZWQg ZnJvbSB0aGUgbGlzdCBvZiBwZW5kaW5nIGNhbGxiYWNrcy4KLSAgICBmb3IgKHNpemVfdCBpID0g MDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7KSB7Ci0gICAg ICAgIGlmIChtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRP ckNhbmNlbGxlZCkKLSAgICAgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tz LT5yZW1vdmUoaSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICsraTsKLSAgICB9Ci0KLSAg ICAvLyBJbiBtb3N0IGNhc2VzIHdlIGV4cGVjdCB0aGlzIGxpc3QgdG8gYmUgZW1wdHksIHNvIG5v IG5lZWQgdG8ga2VlcCBhcm91bmQgdGhlIHZlY3RvcidzIGlubGluZSBidWZmZXIuCi0gICAgaWYg KCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+c2l6ZSgpKQotICAgICAgICBtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy5jbGVhcigpOwotICAgIGVsc2UgaWYgKEZyYW1l VmlldyogdiA9IHZpZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyAgICBt X3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyh0 aW1lKTsKIH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IDM5ODViNTMyODdiMWRi NDc3YmUyYjBmNDJiYjY1MjZhNTg1ZjFjMTQuLjc2MGI3YmMwY2JiYjM4NTU1NzIxYzViZTZmNTI4 NTZlYzliOTI2MmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xNTIsNiArMTUyLDcgQEAgY2xh c3MgVG91Y2hMaXN0OwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xh c3MgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s7CitjbGFzcyBTY3JpcHRlZEFuaW1hdGlv bkNvbnRyb2xsZXI7CiAjZW5kaWYKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKQEAgLTk1 Myw2ICs5NTQsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZE1lc3NhZ2UoTWVzc2Fn ZVNvdXJjZSwgTWVzc2FnZVR5cGUsIE1lc3NhZ2VMZXZlbCwgY29uc3QgU3RyaW5nJiBtZXNzYWdl LCB1bnNpZ25lZCBsaW5lTnVtYmVyLCBjb25zdCBTdHJpbmcmIHNvdXJjZVVSTCwgUGFzc1JlZlB0 cjxTY3JpcHRDYWxsU3RhY2s+KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFzc093blB0 cjxUYXNrPik7IC8vIEV4ZWN1dGVzIHRoZSB0YXNrIG9uIGNvbnRleHQncyB0aHJlYWQgYXN5bmNo cm9ub3VzbHkuCiAKKyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZENhbGxiYWNrcygpOworICAgIHZp cnR1YWwgdm9pZCByZXN1bWVDYWxsYmFja3MoKTsKKwogI2lmIFVTRShKU0MpCiAgICAgdHlwZWRl ZiBKU0M6OldlYWtHQ01hcDxXZWJDb3JlOjpOb2RlKiwgSlNOb2RlPiBKU1dyYXBwZXJDYWNoZTsK ICAgICB0eXBlZGVmIEhhc2hNYXA8RE9NV3JhcHBlcldvcmxkKiwgSlNXcmFwcGVyQ2FjaGUqPiBK U1dyYXBwZXJDYWNoZU1hcDsKQEAgLTE0MDQsOSArMTQwOCw3IEBAIHByaXZhdGU6CiAgICAgdW5z aWduZWQgbV93cml0ZVJlY3Vyc2lvbkRlcHRoOwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFU SU9OX0ZSQU1FKQotICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFjaz4gPiBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3Q7Ci0gICAgT3du UHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrTGlzdD4gbV9yZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFja3M7Ci0gICAgaW50IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrSWQ7CisgICAgT3duUHRyPFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcj4gbV9zY3JpcHRl ZEFuaW1hdGlvbkNvbnRyb2xsZXI7CiAjZW5kaWYKIAogICAgIENvbnRlbnRTZWN1cml0eVBvbGlj eSBtX2NvbnRlbnRTZWN1cml0eVBvbGljeTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5oCmluZGV4IDY0MjkwNmM0MDgyZTA1YWVjNmIzMjkzZjBmNmE1OTRiMjQy ZGYwY2IuLjQ3NTI3YmM4ZDFiYjhkNzk0NmEwMjA3ZWUyZjgwMjIyMGE1ZDZhNGUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaApAQCAtMTA3LDYgKzEwNyw5 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdHlwZWRlZiBjb25zdCBIYXNoTWFwPEFj dGl2ZURPTU9iamVjdCosIHZvaWQqPiBBY3RpdmVET01PYmplY3RzTWFwOwogICAgICAgICBBY3Rp dmVET01PYmplY3RzTWFwJiBhY3RpdmVET01PYmplY3RzKCkgY29uc3QgeyByZXR1cm4gbV9hY3Rp dmVET01PYmplY3RzOyB9CiAKKyAgICAgICAgdmlydHVhbCB2b2lkIHN1c3BlbmRDYWxsYmFja3Mo KSB7fQorICAgICAgICB2aXJ0dWFsIHZvaWQgcmVzdW1lQ2FsbGJhY2tzKCkge30KKwogICAgICAg ICAvLyBNZXNzYWdlUG9ydCBpcyBjb25jZXB0dWFsbHkgYSBraW5kIG9mIEFjdGl2ZURPTU9iamVj dCwgYnV0IGl0IG5lZWRzIHRvIGJlIHRyYWNrZWQgc2VwYXJhdGVseSBmb3IgbWVzc2FnZSBkaXNw YXRjaC4KICAgICAgICAgdm9pZCBwcm9jZXNzTWVzc2FnZVBvcnRNZXNzYWdlc1Nvb24oKTsKICAg ICAgICAgdm9pZCBkaXNwYXRjaE1lc3NhZ2VQb3J0RXZlbnRzKCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVh MWNkZjUxOWQ1MmExZGQ4NjUxZjMyOWNjMGJhMDUzMDgxN2IyMjcKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmNwcApAQCAt MCwwICsxLDEzNiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwg UmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF CisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNs dWRlICJTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuaCIKKworI2lmIEVOQUJMRShSRVFVRVNU X0FOSU1BVElPTl9GUkFNRSkKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRWxl bWVudC5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworU2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIoRG9jdW1lbnQqIGRv Y3VtZW50KQorICAgIDogbV9kb2N1bWVudChkb2N1bWVudCkKKyAgICAsIG1fbmV4dENhbGxiYWNr SWQoMCkKKyAgICAsIG1fc3VzcGVuZENvdW50KDApCit7Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyOjpzdXNwZW5kKCkKK3sKKyAgICBtX3N1c3BlbmRDb3VudCsrOworfQor Cit2b2lkIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVzdW1lKCkKK3sKKyAgICBtX3N1 c3BlbmRDb3VudC0tOworICAgIGlmICghbV9zdXNwZW5kQ291bnQgJiYgbV9jYWxsYmFja3Muc2l6 ZSgpKQorICAgICAgICBpZiAoRnJhbWVWaWV3KiBmdiA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAg ICAgICAgICAgIGZ2LT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorCitTY3JpcHRlZEFuaW1hdGlv bkNvbnRyb2xsZXI6OkNhbGxiYWNrSWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpyZWdp c3RlckNhbGxiYWNrKFBhc3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNh bGxiYWNrLCBFbGVtZW50KiBlKQoreworICAgIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6 Q2FsbGJhY2tJZCBpZCA9IG1fbmV4dENhbGxiYWNrSWQrKzsKKyAgICBjYWxsYmFjay0+bV9maXJl ZE9yQ2FuY2VsbGVkID0gZmFsc2U7CisgICAgY2FsbGJhY2stPm1faWQgPSBpZDsKKyAgICBjYWxs YmFjay0+bV9lbGVtZW50ID0gZTsKKyAgICBtX2NhbGxiYWNrcy5hcHBlbmQoY2FsbGJhY2spOwor ICAgIGlmICghbV9zdXNwZW5kQ291bnQpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9k b2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cisg ICAgcmV0dXJuIGlkOworfQorCit2b2lkIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y2Fu Y2VsQ2FsbGJhY2soQ2FsbGJhY2tJZCBpZCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8 IG1fY2FsbGJhY2tzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+ bV9pZCA9PSBpZCkgeworICAgICAgICAgICAgbV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNhbmNl bGxlZCA9IHRydWU7CisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAg ICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyOjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCB0aW1l KQoreworICAgIGlmICghbV9jYWxsYmFja3Muc2l6ZSgpIHx8IG1fc3VzcGVuZENvdW50KQorICAg ICAgICByZXR1cm47CisgICAgLy8gV2Ugd2FudCB0byBydW4gdGhlIGNhbGxiYWNrIGZvciBhbGwg ZWxlbWVudHMgaW4gdGhlIGRvY3VtZW50IHRoYXQgaGF2ZSByZWdpc3RlcmVkCisgICAgLy8gZm9y IGEgY2FsbGJhY2sgYW5kIHRoYXQgYXJlIHZpc2libGUuICBSdW5uaW5nIHRoZSBjYWxsYmFja3Mg Y2FuIGNhdXNlIG5ldyBjYWxsYmFja3MKKyAgICAvLyB0byBiZSByZWdpc3RlcmVkLCBleGlzdGlu ZyBjYWxsYmFja3MgdG8gYmUgY2FuY2VsbGVkLCBhbmQgZWxlbWVudHMgdG8gZ2FpbiBvciBsb3Nl CisgICAgLy8gdmlzaWJpbGl0eSBzbyB0aGlzIGNvZGUgaGFzIHRvIGl0ZXJhdGUgY2FyZWZ1bGx5 LgorCisgICAgLy8gRklYTUU6IEN1cnJlbnRseSwgdGhpcyBjb2RlIGRvZXNuJ3QgZG8gYW55IHZp c2liaWxpdHkgdGVzdHMgYmV5b25kIGNoZWNraW5nIGRpc3BsYXk6CisKKyAgICAvLyBGaXJzdCwg Z2VuZXJhdGUgYSBsaXN0IG9mIGNhbGxiYWNrcyB0byBjb25zaWRlci4gIENhbGxiYWNrcyByZWdp c3RlcmVkIGZyb20gdGhpcyBwb2ludAorICAgIC8vIG9uIGFyZSBjb25zaWRlcmVkIG9ubHkgZm9y IHRoZSAibmV4dCIgZnJhbWUsIG5vdCB0aGlzIG9uZS4KKyAgICBDYWxsYmFja0xpc3QgY2FsbGJh Y2tzKG1fY2FsbGJhY2tzKTsKKworICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNl IHRoZSB2aXNpYmlsaXR5IG9mIG90aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCisg ICAgLy8gbWlzc2luZyBhbnkgY2FsbGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRo ZSBsaXN0IG9mIGNhbmRpYXRlIGNhbGxiYWNrcyBhbmQgZmlyaW5nCisgICAgLy8gdGhlbSB1bnRp bCBub3RoaW5nIG5ldyBiZWNvbWVzIHZpc2libGUuCisgICAgYm9vbCBmaXJlZENhbGxiYWNrOwor ICAgIGRvIHsKKyAgICAgICAgZmlyZWRDYWxsYmFjayA9IGZhbHNlOworICAgICAgICAvLyBBIHBy ZXZpb3VzIGl0ZXJhdGlvbiBtYXkgaGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4g IFVwZGF0ZSBzdHlsZXMgZm9yIGVhY2ggaXRlcmF0aW9uCisgICAgICAgIC8vIGZvciBub3cgc2lu Y2UgYWxsIHdlIGNoZWNrIGlzIHRoZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KKyAgICAgICAg bV9kb2N1bWVudC0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOworICAgICAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IGNhbGxiYWNrcy5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgUmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2sqIGNhbGxiYWNrID0gY2FsbGJhY2tzW2ldLmdldCgpOworICAg ICAgICAgICAgaWYgKCFjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkICYmICghY2FsbGJhY2st Pm1fZWxlbWVudCB8fCBjYWxsYmFjay0+bV9lbGVtZW50LT5yZW5kZXJlcigpKSkgeworICAgICAg ICAgICAgICAgIGNhbGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSB0cnVlOworICAgICAgICAg ICAgICAgIGNhbGxiYWNrLT5oYW5kbGVFdmVudCh0aW1lKTsKKyAgICAgICAgICAgICAgICBmaXJl ZENhbGxiYWNrID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBjYWxsYmFja3MucmVtb3ZlKGkpOwor ICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfSB3 aGlsZSAoZmlyZWRDYWxsYmFjayk7CisKKyAgICAvLyBSZW1vdmUgYW55IGNhbGxiYWNrcyB3ZSBm aXJlZCBmcm9tIHRoZSBsaXN0IG9mIHBlbmRpbmcgY2FsbGJhY2tzLgorICAgIGZvciAoc2l6ZV90 IGkgPSAwOyBpIDwgbV9jYWxsYmFja3Muc2l6ZSgpOykgeworICAgICAgICBpZiAobV9jYWxsYmFj a3NbaV0tPm1fZmlyZWRPckNhbmNlbGxlZCkKKyAgICAgICAgICAgIG1fY2FsbGJhY2tzLnJlbW92 ZShpKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgKytpOworICAgIH0KKworICAgIGlmICht X2NhbGxiYWNrcy5zaXplKCkpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIHYgPSBtX2RvY3VtZW50 LT52aWV3KCkpCisgICAgICAgICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9kb20vU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20v U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGIzNGI2YWFlYWVhYmI4 YTJhN2JlMWMwOTVmMzQ1MWIzOWQ0YjUwOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJD b3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuaApAQCAtMCwwICsxLDcyIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01Q VVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgor ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBV VEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKgorICovCisKKyNpZm5kZWYgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyX2gKKyNkZWZp bmUgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyX2gKKworI2luY2x1ZGUgIkRPTVRpbWVTdGFt cC5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3du UHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4K KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBEb2N1bWVudDsKK2NsYXNzIEVsZW1lbnQ7 CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjazsKKworY2xhc3MgU2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyIHsKK1dURl9NQUtFX05PTkNPUFlBQkxFKFNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcik7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8U2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyPiBjcmVhdGUoRG9jdW1lbnQqIGQpCisgICAgeworICAgICAgICBy ZXR1cm4gYWRvcHRQdHIobmV3IFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcihkKSk7CisgICAg fQorCisgICAgdHlwZWRlZiBpbnQgQ2FsbGJhY2tJZDsKKworICAgIENhbGxiYWNrSWQgcmVnaXN0 ZXJDYWxsYmFjayhQYXNzUmVmUHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrPiwgRWxl bWVudCopOworICAgIHZvaWQgY2FuY2VsQ2FsbGJhY2soQ2FsbGJhY2tJZCk7CisgICAgdm9pZCBz ZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCk7CisKKyAgICB2b2lkIHN1c3Bl bmQoKTsKKyAgICB2b2lkIHJlc3VtZSgpOworCitwcml2YXRlOgorICAgIGV4cGxpY2l0IFNjcmlw dGVkQW5pbWF0aW9uQ29udHJvbGxlcihEb2N1bWVudCopOworICAgIHR5cGVkZWYgVmVjdG9yPFJl ZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBDYWxsYmFja0xpc3Q7CisgICAg Q2FsbGJhY2tMaXN0IG1fY2FsbGJhY2tzOworCisgICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7Cisg ICAgQ2FsbGJhY2tJZCBtX25leHRDYWxsYmFja0lkOworICAgIGludCBtX3N1c3BlbmRDb3VudDsK K307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcl9oCisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2hpc3RvcnkvQ2Fj aGVkRnJhbWUuY3BwIGIvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAKaW5k ZXggMDA1OTY5MTM0MDA0NWQzOWVjMDIwNGFhOTEyMjUxNjg2MzE3MmUwOS4uMzRjMzBlZWIzMDg1 MmFhNGE4MTgyYzVmYjkxNjhlZmRkODUyNDBiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv aGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNo ZWRGcmFtZS5jcHAKQEAgLTk0LDYgKzk0LDcgQEAgdm9pZCBDYWNoZWRGcmFtZUJhc2U6OnJlc3Rv cmUoKQogICAgIGZyYW1lLT5hbmltYXRpb24oKS0+cmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50 KG1fZG9jdW1lbnQuZ2V0KCkpOwogICAgIGZyYW1lLT5ldmVudEhhbmRsZXIoKS0+c2V0TW91c2VQ cmVzc05vZGUobV9tb3VzZVByZXNzTm9kZS5nZXQoKSk7CiAgICAgbV9kb2N1bWVudC0+cmVzdW1l QWN0aXZlRE9NT2JqZWN0cygpOworICAgIG1fZG9jdW1lbnQtPnJlc3VtZUNhbGxiYWNrcygpOwog CiAgICAgLy8gSXQgaXMgbmVjZXNzYXJ5IHRvIHVwZGF0ZSBhbnkgcGxhdGZvcm0gc2NyaXB0IG9i amVjdHMgYWZ0ZXIgcmVzdG9yaW5nIHRoZQogICAgIC8vIGNhY2hlZCBwYWdlLgpAQCAtMTUyLDYg KzE1Myw3IEBAIENhY2hlZEZyYW1lOjpDYWNoZWRGcmFtZShGcmFtZSogZnJhbWUpCiAgICAgLy8g U3VzcGVuZGluZyBtdXN0IGFsc28gaGFwcGVuIGFmdGVyIHdlJ3ZlIHJlY3Vyc2VkIG92ZXIgY2hp bGQgZnJhbWVzLCBpbiBjYXNlCiAgICAgLy8gdGhvc2UgY3JlYXRlIG1vcmUgb2JqZWN0cy4KICAg ICAvLyBGSVhNRTogSXQncyBzdGlsbCBwb3NzaWJsZSB0byBoYXZlIG9iamVjdHMgY3JlYXRlZCBh ZnRlciBzdXNwZW5kaW5nIGluIHNvbWUgY2FzZXMsIHNlZSBodHRwOi8vd2Via2l0Lm9yZy9iLzUz NzMzIGZvciBtb3JlIGRldGFpbHMuCisgICAgbV9kb2N1bWVudC0+c3VzcGVuZENhbGxiYWNrcygp OwogICAgIG1fZG9jdW1lbnQtPnN1c3BlbmRBY3RpdmVET01PYmplY3RzKEFjdGl2ZURPTU9iamVj dDo6RG9jdW1lbnRXaWxsQmVjb21lSW5hY3RpdmUpOwogICAgIG1fY2FjaGVkRnJhbWVTY3JpcHRE YXRhID0gYWRvcHRQdHIobmV3IFNjcmlwdENhY2hlZEZyYW1lRGF0YShmcmFtZSkpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAKaW5kZXggNzgxYmMz NDQzM2RiZDY2N2ZiZTVmZWRiMTZmMzVkMGRmMTcyYzAwNS4uNGYxNTdjMGQ4Mjk3ZGNiY2Q2NDVh MDk0ZDFhYWE1NjlkYThiODU4ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdl R3JvdXBMb2FkRGVmZXJyZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZUdyb3Vw TG9hZERlZmVycmVyLmNwcApAQCAtNDgsNiArNDgsNyBAQCBQYWdlR3JvdXBMb2FkRGVmZXJyZXI6 OlBhZ2VHcm91cExvYWREZWZlcnJlcihQYWdlKiBwYWdlLCBib29sIGRlZmVyU2VsZikKICAgICAg ICAgICAgICAgICAvLyBOT1RFOiBpZiBQYWdlR3JvdXBMb2FkRGVmZXJyZXIgaXMgZXZlciB1c2Vk IGZvciB0YXNrcyBvdGhlciB0aGFuIHNob3dpbmcgYSBtb2RhbCB3aW5kb3cgb3Igc2hlZXQsCiAg ICAgICAgICAgICAgICAgLy8gdGhlIGNvbnN0cnVjdG9yIHdpbGwgbmVlZCB0byB0YWtlIGEgQWN0 aXZlRE9NT2JqZWN0OjpSZWFzb25Gb3JTdXNwZW5zaW9uLgogICAgICAgICAgICAgICAgIGZvciAo RnJhbWUqIGZyYW1lID0gb3RoZXJQYWdlLT5tYWluRnJhbWUoKTsgZnJhbWU7IGZyYW1lID0gZnJh bWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgZnJhbWUt PmRvY3VtZW50KCktPnN1c3BlbmRDYWxsYmFja3MoKTsKICAgICAgICAgICAgICAgICAgICAgZnJh bWUtPmRvY3VtZW50KCktPnN1c3BlbmRBY3RpdmVET01PYmplY3RzKEFjdGl2ZURPTU9iamVjdDo6 V2lsbFNob3dEaWFsb2cpOwogICAgICAgICAgICAgICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+ YXN5bmNTY3JpcHRSdW5uZXIoKS0+c3VzcGVuZCgpOwogICAgICAgICAgICAgICAgICAgICBpZiAo RG9jdW1lbnRQYXJzZXIqIHBhcnNlciA9IGZyYW1lLT5kb2N1bWVudCgpLT5wYXJzZXIoKSkKQEAg LTcxLDYgKzcyLDcgQEAgUGFnZUdyb3VwTG9hZERlZmVycmVyOjp+UGFnZUdyb3VwTG9hZERlZmVy cmVyKCkKIAogICAgICAgICAgICAgZm9yIChGcmFtZSogZnJhbWUgPSBwYWdlLT5tYWluRnJhbWUo KTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpIHsKICAgICAg ICAgICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpOwor ICAgICAgICAgICAgICAgIGZyYW1lLT5kb2N1bWVudCgpLT5yZXN1bWVDYWxsYmFja3MoKTsKICAg ICAgICAgICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+YXN5bmNTY3JpcHRSdW5uZXIoKS0+cmVz dW1lKCk7CiAgICAgICAgICAgICAgICAgaWYgKERvY3VtZW50UGFyc2VyKiBwYXJzZXIgPSBmcmFt ZS0+ZG9jdW1lbnQoKS0+cGFyc2VyKCkpCiAgICAgICAgICAgICAgICAgICAgIHBhcnNlci0+cmVz dW1lU2NoZWR1bGVkVGFza3MoKTsK 82534 2011-02-15 15:18:36 -0800 2011-02-15 15:37:56 -0800 with rename bug-53188-20110215151835.patch text/plain 25875 jamesr U3VidmVyc2lvbiBSZXZpc2lvbjogNzg2MTQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4YmVlZWU4OGEyOWMyNTEyNjZjNWY3 MDQzOTg0ZjJkZjUwYzU1YjFlLi40NDkyYTlkMzkyYWJkZDQ3NmE2Nzk5YTBhN2E3YzcxMDVhOWM3 OTQyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMTUgIEphbWVzIFJvYmluc29uICA8 amFtZXNyQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3Qg ZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisKKyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5p bWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBzdXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAg ICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5o dG1sOiBBZGRlZC4KKwogMjAxMS0wMi0xNSAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGln YWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6LgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5n LW1vZGFsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjI3 ODc3NTU4NzAyOWYzYWNiZjA4ODE1Y2Y4YWJmMWFjMDg3OTA3MgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmlu Zy1tb2RhbC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBAQAorVGVzdHMgdGhhdCByZXF1ZXN0 QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFs b2dzIGFyZSBkaXNwbGF5ZWQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBv ZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNT IHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKK1NldHRpbmcgY2Fs bGJhY2sKK1Nob3dpbmcgbW9kYWwgZGlhbG9nCitSZXR1cm5lZCBmcm9tIG1vZGFsIGRpYWxvZwor Q2FsbGJhY2sgZmlyZWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24v cmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmctbW9kYWwuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lOTAzZDczYThkNmM1YWNkNjdlMGZjZjEzYTA4OWNlODlmMjZmMWRlCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRp b24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ CitkZXNjcmlwdGlvbignVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tz IGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFsb2dzIGFyZSBkaXNwbGF5ZWQuJyk7CisK K29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICBkZWJ1ZygnU2V0dGluZyBjYWxsYmFjaycpOwor ICAgIHdpbmRvdy53ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoZnVuY3Rpb24oKSB7IGRlYnVn KCdDYWxsYmFjayBmaXJlZCcpOyB9LCBkb2N1bWVudC5ib2R5KTsKKyAgICBkZWJ1ZygnU2hvd2lu ZyBtb2RhbCBkaWFsb2cnKTsKKyAgICB2YXIgc3JjID0gJ2lmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsnICsKKyAgICAgICAgICAgICAgJyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k aXNwbGF5KCk7JyArCisgICAgICAgICAgICAgICcgICAgd2luZG93LmNsb3NlKCk7JyArCisgICAg ICAgICAgICAgICd9IGVsc2UgeycrCisgICAgICAgICAgICAgICcgICAgd2luZG93LnNldFRpbWVv dXQod2luZG93LmNsb3NlLCAxMCk7JysKKyAgICAgICAgICAgICAgJ30nOworICAgIHNob3dNb2Rh bERpYWxvZygnZGF0YTp0ZXh0L2h0bWwsPHNjcmlwdD4nICsgc3JjICsgJzwvJyArICdzY3JpcHQ+ Jyk7CisgICAgZGVidWcoJ1JldHVybmVkIGZyb20gbW9kYWwgZGlhbG9nJyk7CisgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgezsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZGlzcGxheSgpOworICAgIH0KK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7 Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0Lmpz Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGNhNDMwNTc0M2Iy MWFlMWE2OTA4MTE5ZmRhZmZiYjk0Y2YwYmYwNzQuLmI0YmRjMmYzYjQzZWM4NTc2YzZhZjdmYmFh NDhiOTJlY2Q4YzFiZWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NiBAQAorMjAxMS0wMi0xNSAg SmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIHJlcXVlc3RBbmltYXRpb25GcmFtZSBjYWxs YmFja3Mgc2hvdWxkIG5vdCBmaXJlIHdpdGhpbiBhIG1vZGFsIGRpYWxvZworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxODgKKworICAgICAgICByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZG4ndCBmaXJlIHdoaWxlIGEgbW9kYWwg ZGlhbG9nIGlzIHVwIChsaWtlIGEgd2luZG93LmFsZXJ0KCkpLgorICAgICAgICBUaGlzIG1hdGNo ZXMgRmlyZWZveCBhbmQgb3RoZXIgYXN5bmMgQVBJcy4gIFRoaXMgcGF0Y2ggbW92ZXMgdGhlIGNh bGxiYWNrIHNlcnZpY2luZyBpbnRvIGl0cyBvd24KKyAgICAgICAgY29udHJvbGxlciBjbGFzcyB3 aGljaCByZWNlaXZlcyBub3RpZmljYXRpb25zIG9uIHN1c3BlbmQvcmVzdW1lLgorCisgICAgICAg IFRlc3Q6IGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC5odG1sCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogYmluZGluZ3MvanMv U2NyaXB0RGVidWdTZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RGVidWdTZXJ2 ZXI6OnNldEphdmFTY3JpcHRQYXVzZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnQ6OnN1c3BlbmRTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJDYWxsYmFja3MpOgor ICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnJlc3VtZVNjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlckNhbGxiYWNrcyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVxdWVz dEFuaW1hdGlvbkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRDYW5j ZWxSZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNl cnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAg ICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdXNwZW5kU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy Q2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJl c3VtZVNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpzdXNw ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVz dW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVn aXN0ZXJDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXI6OmNhbmNlbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKToKKyAgICAgICAgKiBoaXN0b3J5 L0NhY2hlZEZyYW1lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZEZyYW1lQmFzZTo6cmVz dG9yZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRGcmFtZTo6Q2FjaGVkRnJhbWUpOgorICAg ICAgICAqIHBhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6UGFnZUdyb3VwTG9hZERlZmVycmVyKToKKyAgICAgICAg KFdlYkNvcmU6OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6flBhZ2VHcm91cExvYWREZWZlcnJlcik6 CisKIDIwMTEtMDItMTUgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA3YTg2 OGYwZjZhNjVmOGU2MGUwMWVkNzg1NjI3NGU5MmEwNzRmMTIxLi4xMDZiZTVjZGEzN2M0ZDExYjY2 MTcwY2YxNzhmMGFkYmEwNGRlOGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzIxLDYgKzEzMjEs OCBAQAogICAgICAgICAgICAgJ2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCcsCiAgICAgICAgICAg ICAnZG9tL1JhbmdlRXhjZXB0aW9uLmgnLAogICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdkb20vU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyLmNwcCcsCisgICAgICAgICAgICAnZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlci5oJywKICAgICAgICAgICAgICdkb20vUmF3RGF0YURvY3VtZW50UGFyc2VyLmgnLAogICAg ICAgICAgICAgJ2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5jcHAnLAogICAgICAgICAgICAg J2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcAppbmRleCA1YzUyZGQ3ZTdlN2I2OWNiYTk2 YzFjYjM5MTI0ODRiYzhkNTY2MDZlLi4zMmEzYjJkZjM1ZTg0MmExODQwYjlkMzlkZGQ4Nzk2YTJi ZDZiYmYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9TY3JpcHREZWJ1 Z1NlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvU2NyaXB0RGVidWdT ZXJ2ZXIuY3BwCkBAIC00MDgsMTAgKzQwOCwxMyBAQCB2b2lkIFNjcmlwdERlYnVnU2VydmVyOjpz ZXRKYXZhU2NyaXB0UGF1c2VkKEZyYW1lKiBmcmFtZSwgYm9vbCBwYXVzZWQpCiAgICAgZnJhbWUt PnNjcmlwdCgpLT5zZXRQYXVzZWQocGF1c2VkKTsKIAogICAgIERvY3VtZW50KiBkb2N1bWVudCA9 IGZyYW1lLT5kb2N1bWVudCgpOwotICAgIGlmIChwYXVzZWQpCisgICAgaWYgKHBhdXNlZCkgewor ICAgICAgICBkb2N1bWVudC0+c3VzcGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxi YWNrcygpOwogICAgICAgICBkb2N1bWVudC0+c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZl RE9NT2JqZWN0OjpKYXZhU2NyaXB0RGVidWdnZXJQYXVzZWQpOwotICAgIGVsc2UKKyAgICB9IGVs c2UgewogICAgICAgICBkb2N1bWVudC0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpOworICAgICAg ICBkb2N1bWVudC0+cmVzdW1lU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCk7 CisgICAgfQogCiAgICAgc2V0SmF2YVNjcmlwdFBhdXNlZChmcmFtZS0+dmlldygpLCBwYXVzZWQp OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggYjM2ZmZmMDY0OTIwMGYwMjI3YmI1YmNl NzI4ZWJmY2E1OWM3ZTZlNS4uM2Q2Y2VkNTRhMmZmZTkzZDc0NTFmOTZiODlhNDE0YTEyZjUzZjQ0 OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0yMTAsNiArMjEwLDcgQEAKIAogI2lmIEVO QUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKICNpbmNsdWRlICJSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFjay5oIgorI2luY2x1ZGUgIlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5o IgogI2VuZGlmCiAKIHVzaW5nIG5hbWVzcGFjZSBzdGQ7CkBAIC00MjksOSArNDMwLDYgQEAgRG9j dW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhU TUwsIGJvb2wgaXNIVE1MKQogICAgICwgbV93cml0aW5nTW9kZVNldE9uRG9jdW1lbnRFbGVtZW50 KGZhbHNlKQogICAgICwgbV93cml0ZVJlY3Vyc2lvbklzVG9vRGVlcChmYWxzZSkKICAgICAsIG1f d3JpdGVSZWN1cnNpb25EZXB0aCgwKQotI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFN RSkKLSAgICAsIG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrSWQoMCkKLSNlbmRp ZgogewogICAgIG1fZG9jdW1lbnQgPSB0aGlzOwogCkBAIC00NjY1LDYgKzQ2NjMsMjIgQEAgdm9p ZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0YXNrKQogICAgIGNhbGxPbk1h aW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRleHQobV93ZWFrUmVmZXJl bmNlLCB0YXNrKSk7CiB9CiAKK3ZvaWQgRG9jdW1lbnQ6OnN1c3BlbmRTY3JpcHRlZEFuaW1hdGlv bkNvbnRyb2xsZXJDYWxsYmFja3MoKQoreworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9G UkFNRSkKKyAgICBpZiAobV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCisgICAgICAgIG1f c2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLT5zdXNwZW5kKCk7CisjZW5kaWYKK30KKwordm9p ZCBEb2N1bWVudDo6cmVzdW1lU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCkK K3sKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgaWYgKG1fc2NyaXB0 ZWRBbmltYXRpb25Db250cm9sbGVyKQorICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlci0+cmVzdW1lKCk7CisjZW5kaWYKK30KKwogRWxlbWVudCogRG9jdW1lbnQ6OmZpbmRBbmNo b3IoY29uc3QgU3RyaW5nJiBuYW1lKQogewogICAgIGlmIChuYW1lLmlzRW1wdHkoKSkKQEAgLTQ4 OTcsODAgKzQ5MTEsMjQgQEAgdm9pZCBEb2N1bWVudDo6bG9hZEV2ZW50RGVsYXlUaW1lckZpcmVk KFRpbWVyPERvY3VtZW50PiopCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQog aW50IERvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoUGFzc1JlZlB0cjxSZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQqIGUpCiB7Ci0gICAg aWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKLSAgICAgICAgbV9yZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MgPSBuZXcgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJh Y2tMaXN0OwotICAgIGludCBpZCA9IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr SWQrKzsKLSAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFsc2U7Ci0gICAgY2Fs bGJhY2stPm1faWQgPSBpZDsKLSAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0gZTsKLSAgICBtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXBwZW5kKGNhbGxiYWNrKTsKLSAgICBpZiAo RnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigpOwot ICAgIHJldHVybiBpZDsKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKQor ICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlciA9IFNjcmlwdGVkQW5pbWF0aW9u Q29udHJvbGxlcjo6Y3JlYXRlKHRoaXMpOworCisgICAgcmV0dXJuIG1fc2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyLT5yZWdpc3RlckNhbGxiYWNrKGNhbGxiYWNrLCBlKTsKIH0KIAogdm9pZCBE b2N1bWVudDo6d2Via2l0Q2FuY2VsUmVxdWVzdEFuaW1hdGlvbkZyYW1lKGludCBpZCkKIHsKLSAg ICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzKQorICAgIGlmICghbV9zY3Jp cHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCiAgICAgICAgIHJldHVybjsKLSAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7ICsr aSkgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmF0KGkp LT5tX2lkID09IGlkKSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7Ci0gICAgICAgICAgICBtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICAgICAgcmV0 dXJuOwotICAgICAgICB9Ci0gICAgfQorICAgIG1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy LT5jYW5jZWxDYWxsYmFjayhpZCk7CiB9CiAKIHZvaWQgRG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrcykKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9s bGVyKQogICAgICAgICByZXR1cm47Ci0gICAgLy8gV2Ugd2FudCB0byBydW4gdGhlIGNhbGxiYWNr IGZvciBhbGwgZWxlbWVudHMgaW4gdGhlIGRvY3VtZW50IHRoYXQgaGF2ZSByZWdpc3RlcmVkCi0g ICAgLy8gZm9yIGEgY2FsbGJhY2sgYW5kIHRoYXQgYXJlIHZpc2libGUuICBSdW5uaW5nIHRoZSBj YWxsYmFja3MgY2FuIGNhdXNlIG5ldyBjYWxsYmFja3MKLSAgICAvLyB0byBiZSByZWdpc3RlcmVk LCBleGlzdGluZyBjYWxsYmFja3MgdG8gYmUgY2FuY2VsbGVkLCBhbmQgZWxlbWVudHMgdG8gZ2Fp biBvciBsb3NlCi0gICAgLy8gdmlzaWJpbGl0eSBzbyB0aGlzIGNvZGUgaGFzIHRvIGl0ZXJhdGUg Y2FyZWZ1bGx5LgotCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSwgdGhpcyBjb2RlIGRvZXNuJ3Qg ZG8gYW55IHZpc2liaWxpdHkgdGVzdHMgYmV5b25kIGNoZWNraW5nIGRpc3BsYXk6Ci0KLSAgICAv LyBGaXJzdCwgZ2VuZXJhdGUgYSBsaXN0IG9mIGNhbGxiYWNrcyB0byBjb25zaWRlci4gIENhbGxi YWNrcyByZWdpc3RlcmVkIGZyb20gdGhpcyBwb2ludAotICAgIC8vIG9uIGFyZSBjb25zaWRlcmVk IG9ubHkgZm9yIHRoZSAibmV4dCIgZnJhbWUsIG5vdCB0aGlzIG9uZS4KLSAgICBSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDYWxsYmFja0xpc3QgY2FsbGJhY2tzKCptX3JlcXVlc3RBbmltYXRpb25GcmFt ZUNhbGxiYWNrcyk7Ci0KLSAgICAvLyBGaXJpbmcgdGhlIGNhbGxiYWNrIG1heSBjYXVzZSB0aGUg dmlzaWJpbGl0eSBvZiBvdGhlciBlbGVtZW50cyB0byBjaGFuZ2UuICBUbyBhdm9pZAotICAgIC8v IG1pc3NpbmcgYW55IGNhbGxiYWNrcywgd2Uga2VlcCBpdGVyYXRpbmcgdGhyb3VnaCB0aGUgbGlz dCBvZiBjYW5kaWF0ZSBjYWxsYmFja3MgYW5kIGZpcmluZwotICAgIC8vIHRoZW0gdW50aWwgbm90 aGluZyBuZXcgYmVjb21lcyB2aXNpYmxlLgotICAgIGJvb2wgZmlyZWRDYWxsYmFjazsKLSAgICBk byB7Ci0gICAgICAgIGZpcmVkQ2FsbGJhY2sgPSBmYWxzZTsKLSAgICAgICAgLy8gQSBwcmV2aW91 cyBpdGVyYXRpb24gbWF5IGhhdmUgaW52YWxpZGF0ZWQgc3R5bGUgKG9yIGxheW91dCkuICBVcGRh dGUgc3R5bGVzIGZvciBlYWNoIGl0ZXJhdGlvbgotICAgICAgICAvLyBmb3Igbm93IHNpbmNlIGFs bCB3ZSBjaGVjayBpcyB0aGUgZXhpc3RlbmNlIG9mIGEgcmVuZGVyZXIuCi0gICAgICAgIHVwZGF0 ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjYWxsYmFj a3Muc2l6ZSgpOyArK2kpIHsKLSAgICAgICAgICAgIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrKiBjYWxsYmFjayA9IGNhbGxiYWNrc1tpXS5nZXQoKTsKLSAgICAgICAgICAgIGlmICghY2Fs bGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCAmJiAoIWNhbGxiYWNrLT5tX2VsZW1lbnQgfHwgY2Fs bGJhY2stPm1fZWxlbWVudC0+cmVuZGVyZXIoKSkpIHsKLSAgICAgICAgICAgICAgICBjYWxsYmFj ay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICBjYWxsYmFjay0+ aGFuZGxlRXZlbnQodGltZSk7Ci0gICAgICAgICAgICAgICAgZmlyZWRDYWxsYmFjayA9IHRydWU7 Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsKLSAgICAgICAgICAgICAgICBi cmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgIH0gd2hpbGUgKGZpcmVkQ2FsbGJh Y2spOwotCi0gICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2UgZmlyZWQgZnJvbSB0aGUgbGlz dCBvZiBwZW5kaW5nIGNhbGxiYWNrcy4KLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fcmVx dWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7KSB7Ci0gICAgICAgIGlmIChtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCkK LSAgICAgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5yZW1vdmUoaSk7 Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICsraTsKLSAgICB9Ci0KLSAgICAvLyBJbiBtb3N0 IGNhc2VzIHdlIGV4cGVjdCB0aGlzIGxpc3QgdG8gYmUgZW1wdHksIHNvIG5vIG5lZWQgdG8ga2Vl cCBhcm91bmQgdGhlIHZlY3RvcidzIGlubGluZSBidWZmZXIuCi0gICAgaWYgKCFtX3JlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrcy0+c2l6ZSgpKQotICAgICAgICBtX3JlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrcy5jbGVhcigpOwotICAgIGVsc2UgaWYgKEZyYW1lVmlldyogdiA9IHZp ZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyAgICBtX3NjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyh0aW1lKTsKIH0KICNl bmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IDM5ODViNTMyODdiMWRiNDc3YmUyYjBmNDJi YjY1MjZhNTg1ZjFjMTQuLmIyYmY3N2YyMjllMjlkOTc0YThmMWFmZDA0NWMxNjlmODE1YmJlMGEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xNTIsNiArMTUyLDcgQEAgY2xhc3MgVG91Y2hMaXN0 OwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xhc3MgUmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2s7CitjbGFzcyBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI7 CiAjZW5kaWYKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKQEAgLTk1Myw2ICs5NTQsOSBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZE1lc3NhZ2UoTWVzc2FnZVNvdXJjZSwgTWVz c2FnZVR5cGUsIE1lc3NhZ2VMZXZlbCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlLCB1bnNpZ25lZCBs aW5lTnVtYmVyLCBjb25zdCBTdHJpbmcmIHNvdXJjZVVSTCwgUGFzc1JlZlB0cjxTY3JpcHRDYWxs U3RhY2s+KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFzc093blB0cjxUYXNrPik7IC8v IEV4ZWN1dGVzIHRoZSB0YXNrIG9uIGNvbnRleHQncyB0aHJlYWQgYXN5bmNocm9ub3VzbHkuCiAK KyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxi YWNrcygpOworICAgIHZpcnR1YWwgdm9pZCByZXN1bWVTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXJDYWxsYmFja3MoKTsKKwogI2lmIFVTRShKU0MpCiAgICAgdHlwZWRlZiBKU0M6OldlYWtHQ01h cDxXZWJDb3JlOjpOb2RlKiwgSlNOb2RlPiBKU1dyYXBwZXJDYWNoZTsKICAgICB0eXBlZGVmIEhh c2hNYXA8RE9NV3JhcHBlcldvcmxkKiwgSlNXcmFwcGVyQ2FjaGUqPiBKU1dyYXBwZXJDYWNoZU1h cDsKQEAgLTE0MDQsOSArMTQwOCw3IEBAIHByaXZhdGU6CiAgICAgdW5zaWduZWQgbV93cml0ZVJl Y3Vyc2lvbkRlcHRoOwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQotICAg IHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3Q7Ci0gICAgT3duUHRyPFJlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrTGlzdD4gbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3M7 Ci0gICAgaW50IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrSWQ7CisgICAgT3du UHRyPFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcj4gbV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXI7CiAjZW5kaWYKIAogICAgIENvbnRlbnRTZWN1cml0eVBvbGljeSBtX2NvbnRlbnRTZWN1 cml0eVBvbGljeTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRp b25Db250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5o CmluZGV4IDY0MjkwNmM0MDgyZTA1YWVjNmIzMjkzZjBmNmE1OTRiMjQyZGYwY2IuLmU3ZTdkNGEy YTNkNWYxZjI2YjZmZjdhNGM3ZGE1NDk0NzI5ZmU4OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaApAQCAtMTA3LDYgKzEwNyw5IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgdHlwZWRlZiBjb25zdCBIYXNoTWFwPEFjdGl2ZURPTU9iamVjdCos IHZvaWQqPiBBY3RpdmVET01PYmplY3RzTWFwOwogICAgICAgICBBY3RpdmVET01PYmplY3RzTWFw JiBhY3RpdmVET01PYmplY3RzKCkgY29uc3QgeyByZXR1cm4gbV9hY3RpdmVET01PYmplY3RzOyB9 CiAKKyAgICAgICAgdmlydHVhbCB2b2lkIHN1c3BlbmRTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXJDYWxsYmFja3MoKSB7fQorICAgICAgICB2aXJ0dWFsIHZvaWQgcmVzdW1lU2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCkge30KKwogICAgICAgICAvLyBNZXNzYWdlUG9ydCBp cyBjb25jZXB0dWFsbHkgYSBraW5kIG9mIEFjdGl2ZURPTU9iamVjdCwgYnV0IGl0IG5lZWRzIHRv IGJlIHRyYWNrZWQgc2VwYXJhdGVseSBmb3IgbWVzc2FnZSBkaXNwYXRjaC4KICAgICAgICAgdm9p ZCBwcm9jZXNzTWVzc2FnZVBvcnRNZXNzYWdlc1Nvb24oKTsKICAgICAgICAgdm9pZCBkaXNwYXRj aE1lc3NhZ2VQb3J0RXZlbnRzKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2Ny aXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRl ZEFuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVhMWNkZjUxOWQ1MmExZGQ4NjUx ZjMyOWNjMGJhMDUzMDgxN2IyMjcKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9k b20vU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLmNwcApAQCAtMCwwICsxLDEzNiBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVU RVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRF UiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IK KyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJTY3JpcHRlZEFuaW1h dGlvbkNvbnRyb2xsZXIuaCIKKworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkK KworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUg IkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIlJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpT Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIoRG9jdW1lbnQqIGRvY3VtZW50KQorICAgIDogbV9k b2N1bWVudChkb2N1bWVudCkKKyAgICAsIG1fbmV4dENhbGxiYWNrSWQoMCkKKyAgICAsIG1fc3Vz cGVuZENvdW50KDApCit7Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpz dXNwZW5kKCkKK3sKKyAgICBtX3N1c3BlbmRDb3VudCsrOworfQorCit2b2lkIFNjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlcjo6cmVzdW1lKCkKK3sKKyAgICBtX3N1c3BlbmRDb3VudC0tOworICAg IGlmICghbV9zdXNwZW5kQ291bnQgJiYgbV9jYWxsYmFja3Muc2l6ZSgpKQorICAgICAgICBpZiAo RnJhbWVWaWV3KiBmdiA9IG1fZG9jdW1lbnQtPnZpZXcoKSkKKyAgICAgICAgICAgIGZ2LT5zY2hl ZHVsZUFuaW1hdGlvbigpOworfQorCitTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OkNhbGxi YWNrSWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpyZWdpc3RlckNhbGxiYWNrKFBhc3NS ZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+IGNhbGxiYWNrLCBFbGVtZW50KiBl KQoreworICAgIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Q2FsbGJhY2tJZCBpZCA9IG1f bmV4dENhbGxiYWNrSWQrKzsKKyAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFs c2U7CisgICAgY2FsbGJhY2stPm1faWQgPSBpZDsKKyAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0g ZTsKKyAgICBtX2NhbGxiYWNrcy5hcHBlbmQoY2FsbGJhY2spOworICAgIGlmICghbV9zdXNwZW5k Q291bnQpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQor ICAgICAgICAgICAgZnYtPnNjaGVkdWxlQW5pbWF0aW9uKCk7CisgICAgcmV0dXJuIGlkOworfQor Cit2b2lkIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y2FuY2VsQ2FsbGJhY2soQ2FsbGJh Y2tJZCBpZCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tzLnNpemUo KTsgKytpKSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+bV9pZCA9PSBpZCkgeworICAg ICAgICAgICAgbV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7CisgICAg ICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2 aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCB0aW1lKQoreworICAgIGlmICghbV9j YWxsYmFja3Muc2l6ZSgpIHx8IG1fc3VzcGVuZENvdW50KQorICAgICAgICByZXR1cm47CisgICAg Ly8gV2Ugd2FudCB0byBydW4gdGhlIGNhbGxiYWNrIGZvciBhbGwgZWxlbWVudHMgaW4gdGhlIGRv Y3VtZW50IHRoYXQgaGF2ZSByZWdpc3RlcmVkCisgICAgLy8gZm9yIGEgY2FsbGJhY2sgYW5kIHRo YXQgYXJlIHZpc2libGUuICBSdW5uaW5nIHRoZSBjYWxsYmFja3MgY2FuIGNhdXNlIG5ldyBjYWxs YmFja3MKKyAgICAvLyB0byBiZSByZWdpc3RlcmVkLCBleGlzdGluZyBjYWxsYmFja3MgdG8gYmUg Y2FuY2VsbGVkLCBhbmQgZWxlbWVudHMgdG8gZ2FpbiBvciBsb3NlCisgICAgLy8gdmlzaWJpbGl0 eSBzbyB0aGlzIGNvZGUgaGFzIHRvIGl0ZXJhdGUgY2FyZWZ1bGx5LgorCisgICAgLy8gRklYTUU6 IEN1cnJlbnRseSwgdGhpcyBjb2RlIGRvZXNuJ3QgZG8gYW55IHZpc2liaWxpdHkgdGVzdHMgYmV5 b25kIGNoZWNraW5nIGRpc3BsYXk6CisKKyAgICAvLyBGaXJzdCwgZ2VuZXJhdGUgYSBsaXN0IG9m IGNhbGxiYWNrcyB0byBjb25zaWRlci4gIENhbGxiYWNrcyByZWdpc3RlcmVkIGZyb20gdGhpcyBw b2ludAorICAgIC8vIG9uIGFyZSBjb25zaWRlcmVkIG9ubHkgZm9yIHRoZSAibmV4dCIgZnJhbWUs IG5vdCB0aGlzIG9uZS4KKyAgICBDYWxsYmFja0xpc3QgY2FsbGJhY2tzKG1fY2FsbGJhY2tzKTsK KworICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNlIHRoZSB2aXNpYmlsaXR5IG9m IG90aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCisgICAgLy8gbWlzc2luZyBhbnkg Y2FsbGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRoZSBsaXN0IG9mIGNhbmRpYXRl IGNhbGxiYWNrcyBhbmQgZmlyaW5nCisgICAgLy8gdGhlbSB1bnRpbCBub3RoaW5nIG5ldyBiZWNv bWVzIHZpc2libGUuCisgICAgYm9vbCBmaXJlZENhbGxiYWNrOworICAgIGRvIHsKKyAgICAgICAg ZmlyZWRDYWxsYmFjayA9IGZhbHNlOworICAgICAgICAvLyBBIHByZXZpb3VzIGl0ZXJhdGlvbiBt YXkgaGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4gIFVwZGF0ZSBzdHlsZXMgZm9y IGVhY2ggaXRlcmF0aW9uCisgICAgICAgIC8vIGZvciBub3cgc2luY2UgYWxsIHdlIGNoZWNrIGlz IHRoZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KKyAgICAgICAgbV9kb2N1bWVudC0+dXBkYXRl U3R5bGVJZk5lZWRlZCgpOworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGNhbGxiYWNr cy5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJh Y2sqIGNhbGxiYWNrID0gY2FsbGJhY2tzW2ldLmdldCgpOworICAgICAgICAgICAgaWYgKCFjYWxs YmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkICYmICghY2FsbGJhY2stPm1fZWxlbWVudCB8fCBjYWxs YmFjay0+bV9lbGVtZW50LT5yZW5kZXJlcigpKSkgeworICAgICAgICAgICAgICAgIGNhbGxiYWNr LT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIGNhbGxiYWNrLT5o YW5kbGVFdmVudCh0aW1lKTsKKyAgICAgICAgICAgICAgICBmaXJlZENhbGxiYWNrID0gdHJ1ZTsK KyAgICAgICAgICAgICAgICBjYWxsYmFja3MucmVtb3ZlKGkpOworICAgICAgICAgICAgICAgIGJy ZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfSB3aGlsZSAoZmlyZWRDYWxsYmFj ayk7CisKKyAgICAvLyBSZW1vdmUgYW55IGNhbGxiYWNrcyB3ZSBmaXJlZCBmcm9tIHRoZSBsaXN0 IG9mIHBlbmRpbmcgY2FsbGJhY2tzLgorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9jYWxs YmFja3Muc2l6ZSgpOykgeworICAgICAgICBpZiAobV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNh bmNlbGxlZCkKKyAgICAgICAgICAgIG1fY2FsbGJhY2tzLnJlbW92ZShpKTsKKyAgICAgICAgZWxz ZQorICAgICAgICAgICAgKytpOworICAgIH0KKworICAgIGlmIChtX2NhbGxiYWNrcy5zaXplKCkp CisgICAgICAgIGlmIChGcmFtZVZpZXcqIHYgPSBtX2RvY3VtZW50LT52aWV3KCkpCisgICAgICAg ICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmlt YXRpb25Db250cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGIzNGI2YWFlYWVhYmI4YTJhN2JlMWMwOTVmMzQ1MWIz OWQ0YjUwOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFu aW1hdGlvbkNvbnRyb2xsZXIuaApAQCAtMCwwICsxLDcyIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDExIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQor ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKgorICovCisKKyNpZm5k ZWYgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyX2gKKyNkZWZpbmUgU2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyX2gKKworI2luY2x1ZGUgIkRPTVRpbWVTdGFtcC5oIgorI2luY2x1ZGUgPHd0 Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8 d3RmL1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitjbGFzcyBEb2N1bWVudDsKK2NsYXNzIEVsZW1lbnQ7CitjbGFzcyBSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDYWxsYmFjazsKKworY2xhc3MgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy IHsKK1dURl9NQUtFX05PTkNPUFlBQkxFKFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcik7Citw dWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy PiBjcmVhdGUoRG9jdW1lbnQqIGQpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3 IFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcihkKSk7CisgICAgfQorCisgICAgdHlwZWRlZiBp bnQgQ2FsbGJhY2tJZDsKKworICAgIENhbGxiYWNrSWQgcmVnaXN0ZXJDYWxsYmFjayhQYXNzUmVm UHRyPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrPiwgRWxlbWVudCopOworICAgIHZvaWQg Y2FuY2VsQ2FsbGJhY2soQ2FsbGJhY2tJZCk7CisgICAgdm9pZCBzZXJ2aWNlU2NyaXB0ZWRBbmlt YXRpb25zKERPTVRpbWVTdGFtcCk7CisKKyAgICB2b2lkIHN1c3BlbmQoKTsKKyAgICB2b2lkIHJl c3VtZSgpOworCitwcml2YXRlOgorICAgIGV4cGxpY2l0IFNjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlcihEb2N1bWVudCopOworICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDYWxsYmFjaz4gPiBDYWxsYmFja0xpc3Q7CisgICAgQ2FsbGJhY2tMaXN0IG1fY2Fs bGJhY2tzOworCisgICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CisgICAgQ2FsbGJhY2tJZCBtX25l eHRDYWxsYmFja0lkOworICAgIGludCBtX3N1c3BlbmRDb3VudDsKK307CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcl9oCisK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2hpc3RvcnkvQ2FjaGVkRnJhbWUuY3BwIGIvU291 cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAKaW5kZXggMDA1OTY5MTM0MDA0NWQz OWVjMDIwNGFhOTEyMjUxNjg2MzE3MmUwOS4uOTI1NTdiNzgzYjllZTZkNjQwNzQ4ZjBkMWY3M2Mx ZjM3ZDUwZjQ5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFt ZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAKQEAgLTk0 LDYgKzk0LDcgQEAgdm9pZCBDYWNoZWRGcmFtZUJhc2U6OnJlc3RvcmUoKQogICAgIGZyYW1lLT5h bmltYXRpb24oKS0+cmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50KG1fZG9jdW1lbnQuZ2V0KCkp OwogICAgIGZyYW1lLT5ldmVudEhhbmRsZXIoKS0+c2V0TW91c2VQcmVzc05vZGUobV9tb3VzZVBy ZXNzTm9kZS5nZXQoKSk7CiAgICAgbV9kb2N1bWVudC0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygp OworICAgIG1fZG9jdW1lbnQtPnJlc3VtZVNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxi YWNrcygpOwogCiAgICAgLy8gSXQgaXMgbmVjZXNzYXJ5IHRvIHVwZGF0ZSBhbnkgcGxhdGZvcm0g c2NyaXB0IG9iamVjdHMgYWZ0ZXIgcmVzdG9yaW5nIHRoZQogICAgIC8vIGNhY2hlZCBwYWdlLgpA QCAtMTUyLDYgKzE1Myw3IEBAIENhY2hlZEZyYW1lOjpDYWNoZWRGcmFtZShGcmFtZSogZnJhbWUp CiAgICAgLy8gU3VzcGVuZGluZyBtdXN0IGFsc28gaGFwcGVuIGFmdGVyIHdlJ3ZlIHJlY3Vyc2Vk IG92ZXIgY2hpbGQgZnJhbWVzLCBpbiBjYXNlCiAgICAgLy8gdGhvc2UgY3JlYXRlIG1vcmUgb2Jq ZWN0cy4KICAgICAvLyBGSVhNRTogSXQncyBzdGlsbCBwb3NzaWJsZSB0byBoYXZlIG9iamVjdHMg Y3JlYXRlZCBhZnRlciBzdXNwZW5kaW5nIGluIHNvbWUgY2FzZXMsIHNlZSBodHRwOi8vd2Via2l0 Lm9yZy9iLzUzNzMzIGZvciBtb3JlIGRldGFpbHMuCisgICAgbV9kb2N1bWVudC0+c3VzcGVuZFNj cmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcygpOwogICAgIG1fZG9jdW1lbnQtPnN1 c3BlbmRBY3RpdmVET01PYmplY3RzKEFjdGl2ZURPTU9iamVjdDo6RG9jdW1lbnRXaWxsQmVjb21l SW5hY3RpdmUpOwogICAgIG1fY2FjaGVkRnJhbWVTY3JpcHREYXRhID0gYWRvcHRQdHIobmV3IFNj cmlwdENhY2hlZEZyYW1lRGF0YShmcmFtZSkpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL1BhZ2VHcm91cExvYWREZWZlcnJlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bh Z2VHcm91cExvYWREZWZlcnJlci5jcHAKaW5kZXggNzgxYmMzNDQzM2RiZDY2N2ZiZTVmZWRiMTZm MzVkMGRmMTcyYzAwNS4uZGVhMmNkNzc3NWZmMzZjZWM2YTU0NjAxNmUyOTZmNmJlYWJkNmJlYyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlR3JvdXBMb2FkRGVmZXJyZXIuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcApAQCAt NDgsNiArNDgsNyBAQCBQYWdlR3JvdXBMb2FkRGVmZXJyZXI6OlBhZ2VHcm91cExvYWREZWZlcnJl cihQYWdlKiBwYWdlLCBib29sIGRlZmVyU2VsZikKICAgICAgICAgICAgICAgICAvLyBOT1RFOiBp ZiBQYWdlR3JvdXBMb2FkRGVmZXJyZXIgaXMgZXZlciB1c2VkIGZvciB0YXNrcyBvdGhlciB0aGFu IHNob3dpbmcgYSBtb2RhbCB3aW5kb3cgb3Igc2hlZXQsCiAgICAgICAgICAgICAgICAgLy8gdGhl IGNvbnN0cnVjdG9yIHdpbGwgbmVlZCB0byB0YWtlIGEgQWN0aXZlRE9NT2JqZWN0OjpSZWFzb25G b3JTdXNwZW5zaW9uLgogICAgICAgICAgICAgICAgIGZvciAoRnJhbWUqIGZyYW1lID0gb3RoZXJQ YWdlLT5tYWluRnJhbWUoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VO ZXh0KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgZnJhbWUtPmRvY3VtZW50KCktPnN1c3BlbmRT Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJDYWxsYmFja3MoKTsKICAgICAgICAgICAgICAgICAg ICAgZnJhbWUtPmRvY3VtZW50KCktPnN1c3BlbmRBY3RpdmVET01PYmplY3RzKEFjdGl2ZURPTU9i amVjdDo6V2lsbFNob3dEaWFsb2cpOwogICAgICAgICAgICAgICAgICAgICBmcmFtZS0+ZG9jdW1l bnQoKS0+YXN5bmNTY3JpcHRSdW5uZXIoKS0+c3VzcGVuZCgpOwogICAgICAgICAgICAgICAgICAg ICBpZiAoRG9jdW1lbnRQYXJzZXIqIHBhcnNlciA9IGZyYW1lLT5kb2N1bWVudCgpLT5wYXJzZXIo KSkKQEAgLTcxLDYgKzcyLDcgQEAgUGFnZUdyb3VwTG9hZERlZmVycmVyOjp+UGFnZUdyb3VwTG9h ZERlZmVycmVyKCkKIAogICAgICAgICAgICAgZm9yIChGcmFtZSogZnJhbWUgPSBwYWdlLT5tYWlu RnJhbWUoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpIHsK ICAgICAgICAgICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0 cygpOworICAgICAgICAgICAgICAgIGZyYW1lLT5kb2N1bWVudCgpLT5yZXN1bWVTY3JpcHRlZEFu aW1hdGlvbkNvbnRyb2xsZXJDYWxsYmFja3MoKTsKICAgICAgICAgICAgICAgICBmcmFtZS0+ZG9j dW1lbnQoKS0+YXN5bmNTY3JpcHRSdW5uZXIoKS0+cmVzdW1lKCk7CiAgICAgICAgICAgICAgICAg aWYgKERvY3VtZW50UGFyc2VyKiBwYXJzZXIgPSBmcmFtZS0+ZG9jdW1lbnQoKS0+cGFyc2VyKCkp CiAgICAgICAgICAgICAgICAgICAgIHBhcnNlci0+cmVzdW1lU2NoZWR1bGVkVGFza3MoKTsK 82535 2011-02-15 15:37:59 -0800 2011-02-15 15:54:42 -0800 Patch bug-53188-20110215153758.patch text/plain 25880 jamesr U3VidmVyc2lvbiBSZXZpc2lvbjogNzg2MTQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4YmVlZWU4OGEyOWMyNTEyNjZjNWY3 MDQzOTg0ZjJkZjUwYzU1YjFlLi40NDkyYTlkMzkyYWJkZDQ3NmE2Nzk5YTBhN2E3YzcxMDVhOWM3 OTQyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMTUgIEphbWVzIFJvYmluc29uICA8 amFtZXNyQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZCBub3Qg ZmlyZSB3aXRoaW4gYSBtb2RhbCBkaWFsb2cKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUzMTg4CisKKyAgICAgICAgVGVzdHMgdGhhdCByZXF1ZXN0QW5p bWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBzdXNwZW5kZWQgd2hpbGUgYSBtb2RhbAorICAgICAg ICBkaWFsb2cgaXMgc2hvd2luZy4KKworICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC5o dG1sOiBBZGRlZC4KKwogMjAxMS0wMi0xNSAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGln YWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6LgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5n LW1vZGFsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3Qt YW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2RhbC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjI3 ODc3NTU4NzAyOWYzYWNiZjA4ODE1Y2Y4YWJmMWFjMDg3OTA3MgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmlu Zy1tb2RhbC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBAQAorVGVzdHMgdGhhdCByZXF1ZXN0 QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFs b2dzIGFyZSBkaXNwbGF5ZWQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBv ZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNT IHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKK1NldHRpbmcgY2Fs bGJhY2sKK1Nob3dpbmcgbW9kYWwgZGlhbG9nCitSZXR1cm5lZCBmcm9tIG1vZGFsIGRpYWxvZwor Q2FsbGJhY2sgZmlyZWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24v cmVxdWVzdC1hbmltYXRpb24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS1kdXJpbmctbW9kYWwuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lOTAzZDczYThkNmM1YWNkNjdlMGZjZjEzYTA4OWNlODlmMjZmMWRlCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRp b24tZnJhbWUtZHVyaW5nLW1vZGFsLmh0bWwKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ CitkZXNjcmlwdGlvbignVGVzdHMgdGhhdCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tz IGFyZSBub3QgaW52b2tlZCB3aGlsZSBtb2RhbCBkaWFsb2dzIGFyZSBkaXNwbGF5ZWQuJyk7CisK K29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICBkZWJ1ZygnU2V0dGluZyBjYWxsYmFjaycpOwor ICAgIHdpbmRvdy53ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoZnVuY3Rpb24oKSB7IGRlYnVn KCdDYWxsYmFjayBmaXJlZCcpOyB9LCBkb2N1bWVudC5ib2R5KTsKKyAgICBkZWJ1ZygnU2hvd2lu ZyBtb2RhbCBkaWFsb2cnKTsKKyAgICB2YXIgc3JjID0gJ2lmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsnICsKKyAgICAgICAgICAgICAgJyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k aXNwbGF5KCk7JyArCisgICAgICAgICAgICAgICcgICAgd2luZG93LmNsb3NlKCk7JyArCisgICAg ICAgICAgICAgICd9IGVsc2UgeycrCisgICAgICAgICAgICAgICcgICAgd2luZG93LnNldFRpbWVv dXQod2luZG93LmNsb3NlLCAxMCk7JysKKyAgICAgICAgICAgICAgJ30nOworICAgIHNob3dNb2Rh bERpYWxvZygnZGF0YTp0ZXh0L2h0bWwsPHNjcmlwdD4nICsgc3JjICsgJzwvJyArICdzY3JpcHQ+ Jyk7CisgICAgZGVidWcoJ1JldHVybmVkIGZyb20gbW9kYWwgZGlhbG9nJyk7CisgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgezsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZGlzcGxheSgpOworICAgIH0KK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7 Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0Lmpz Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGNhNDMwNTc0M2Iy MWFlMWE2OTA4MTE5ZmRhZmZiYjk0Y2YwYmYwNzQuLmI0YmRjMmYzYjQzZWM4NTc2YzZhZjdmYmFh NDhiOTJlY2Q4YzFiZWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NiBAQAorMjAxMS0wMi0xNSAg SmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIHJlcXVlc3RBbmltYXRpb25GcmFtZSBjYWxs YmFja3Mgc2hvdWxkIG5vdCBmaXJlIHdpdGhpbiBhIG1vZGFsIGRpYWxvZworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxODgKKworICAgICAgICByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUgY2FsbGJhY2tzIHNob3VsZG4ndCBmaXJlIHdoaWxlIGEgbW9kYWwg ZGlhbG9nIGlzIHVwIChsaWtlIGEgd2luZG93LmFsZXJ0KCkpLgorICAgICAgICBUaGlzIG1hdGNo ZXMgRmlyZWZveCBhbmQgb3RoZXIgYXN5bmMgQVBJcy4gIFRoaXMgcGF0Y2ggbW92ZXMgdGhlIGNh bGxiYWNrIHNlcnZpY2luZyBpbnRvIGl0cyBvd24KKyAgICAgICAgY29udHJvbGxlciBjbGFzcyB3 aGljaCByZWNlaXZlcyBub3RpZmljYXRpb25zIG9uIHN1c3BlbmQvcmVzdW1lLgorCisgICAgICAg IFRlc3Q6IGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLWR1cmluZy1tb2Rh bC5odG1sCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogYmluZGluZ3MvanMv U2NyaXB0RGVidWdTZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RGVidWdTZXJ2 ZXI6OnNldEphdmFTY3JpcHRQYXVzZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnQ6OnN1c3BlbmRTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJDYWxsYmFja3MpOgor ICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnJlc3VtZVNjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlckNhbGxiYWNrcyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6d2Via2l0UmVxdWVz dEFuaW1hdGlvbkZyYW1lKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojp3ZWJraXRDYW5j ZWxSZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNl cnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAg ICAgICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdXNwZW5kU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy Q2FsbGJhY2tzKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJl c3VtZVNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpzdXNw ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVz dW1lKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVn aXN0ZXJDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXI6OmNhbmNlbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcjo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyk6CisgICAgICAgICogZG9t L1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y3JlYXRlKToKKyAgICAgICAgKiBoaXN0b3J5 L0NhY2hlZEZyYW1lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhY2hlZEZyYW1lQmFzZTo6cmVz dG9yZSk6CisgICAgICAgIChXZWJDb3JlOjpDYWNoZWRGcmFtZTo6Q2FjaGVkRnJhbWUpOgorICAg ICAgICAqIHBhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6UGFnZUdyb3VwTG9hZERlZmVycmVyKToKKyAgICAgICAg KFdlYkNvcmU6OlBhZ2VHcm91cExvYWREZWZlcnJlcjo6flBhZ2VHcm91cExvYWREZWZlcnJlcik6 CisKIDIwMTEtMDItMTUgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA3YTg2 OGYwZjZhNjVmOGU2MGUwMWVkNzg1NjI3NGU5MmEwNzRmMTIxLi4xMDZiZTVjZGEzN2M0ZDExYjY2 MTcwY2YxNzhmMGFkYmEwNGRlOGRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzIxLDYgKzEzMjEs OCBAQAogICAgICAgICAgICAgJ2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCcsCiAgICAgICAgICAg ICAnZG9tL1JhbmdlRXhjZXB0aW9uLmgnLAogICAgICAgICAgICAgJ2RvbS9SZXF1ZXN0QW5pbWF0 aW9uRnJhbWVDYWxsYmFjay5oJywKKyAgICAgICAgICAgICdkb20vU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyLmNwcCcsCisgICAgICAgICAgICAnZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlci5oJywKICAgICAgICAgICAgICdkb20vUmF3RGF0YURvY3VtZW50UGFyc2VyLmgnLAogICAg ICAgICAgICAgJ2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5jcHAnLAogICAgICAgICAgICAg J2RvbS9SZWdpc3RlcmVkRXZlbnRMaXN0ZW5lci5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL1NjcmlwdERlYnVnU2VydmVyLmNwcAppbmRleCA1YzUyZGQ3ZTdlN2I2OWNiYTk2 YzFjYjM5MTI0ODRiYzhkNTY2MDZlLi4zMmEzYjJkZjM1ZTg0MmExODQwYjlkMzlkZGQ4Nzk2YTJi ZDZiYmYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9TY3JpcHREZWJ1 Z1NlcnZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvU2NyaXB0RGVidWdT ZXJ2ZXIuY3BwCkBAIC00MDgsMTAgKzQwOCwxMyBAQCB2b2lkIFNjcmlwdERlYnVnU2VydmVyOjpz ZXRKYXZhU2NyaXB0UGF1c2VkKEZyYW1lKiBmcmFtZSwgYm9vbCBwYXVzZWQpCiAgICAgZnJhbWUt PnNjcmlwdCgpLT5zZXRQYXVzZWQocGF1c2VkKTsKIAogICAgIERvY3VtZW50KiBkb2N1bWVudCA9 IGZyYW1lLT5kb2N1bWVudCgpOwotICAgIGlmIChwYXVzZWQpCisgICAgaWYgKHBhdXNlZCkgewor ICAgICAgICBkb2N1bWVudC0+c3VzcGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxi YWNrcygpOwogICAgICAgICBkb2N1bWVudC0+c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZl RE9NT2JqZWN0OjpKYXZhU2NyaXB0RGVidWdnZXJQYXVzZWQpOwotICAgIGVsc2UKKyAgICB9IGVs c2UgewogICAgICAgICBkb2N1bWVudC0+cmVzdW1lQWN0aXZlRE9NT2JqZWN0cygpOworICAgICAg ICBkb2N1bWVudC0+cmVzdW1lU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCk7 CisgICAgfQogCiAgICAgc2V0SmF2YVNjcmlwdFBhdXNlZChmcmFtZS0+dmlldygpLCBwYXVzZWQp OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggYjM2ZmZmMDY0OTIwMGYwMjI3YmI1YmNl NzI4ZWJmY2E1OWM3ZTZlNS4uM2Q2Y2VkNTRhMmZmZTkzZDc0NTFmOTZiODlhNDE0YTEyZjUzZjQ0 OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0yMTAsNiArMjEwLDcgQEAKIAogI2lmIEVO QUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKICNpbmNsdWRlICJSZXF1ZXN0QW5pbWF0aW9u RnJhbWVDYWxsYmFjay5oIgorI2luY2x1ZGUgIlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5o IgogI2VuZGlmCiAKIHVzaW5nIG5hbWVzcGFjZSBzdGQ7CkBAIC00MjksOSArNDMwLDYgQEAgRG9j dW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhU TUwsIGJvb2wgaXNIVE1MKQogICAgICwgbV93cml0aW5nTW9kZVNldE9uRG9jdW1lbnRFbGVtZW50 KGZhbHNlKQogICAgICwgbV93cml0ZVJlY3Vyc2lvbklzVG9vRGVlcChmYWxzZSkKICAgICAsIG1f d3JpdGVSZWN1cnNpb25EZXB0aCgwKQotI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFN RSkKLSAgICAsIG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrSWQoMCkKLSNlbmRp ZgogewogICAgIG1fZG9jdW1lbnQgPSB0aGlzOwogCkBAIC00NjY1LDYgKzQ2NjMsMjIgQEAgdm9p ZCBEb2N1bWVudDo6cG9zdFRhc2soUGFzc093blB0cjxUYXNrPiB0YXNrKQogICAgIGNhbGxPbk1h aW5UaHJlYWQocGVyZm9ybVRhc2ssIG5ldyBQZXJmb3JtVGFza0NvbnRleHQobV93ZWFrUmVmZXJl bmNlLCB0YXNrKSk7CiB9CiAKK3ZvaWQgRG9jdW1lbnQ6OnN1c3BlbmRTY3JpcHRlZEFuaW1hdGlv bkNvbnRyb2xsZXJDYWxsYmFja3MoKQoreworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9G UkFNRSkKKyAgICBpZiAobV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCisgICAgICAgIG1f c2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyLT5zdXNwZW5kKCk7CisjZW5kaWYKK30KKwordm9p ZCBEb2N1bWVudDo6cmVzdW1lU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCkK K3sKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgaWYgKG1fc2NyaXB0 ZWRBbmltYXRpb25Db250cm9sbGVyKQorICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlci0+cmVzdW1lKCk7CisjZW5kaWYKK30KKwogRWxlbWVudCogRG9jdW1lbnQ6OmZpbmRBbmNo b3IoY29uc3QgU3RyaW5nJiBuYW1lKQogewogICAgIGlmIChuYW1lLmlzRW1wdHkoKSkKQEAgLTQ4 OTcsODAgKzQ5MTEsMjQgQEAgdm9pZCBEb2N1bWVudDo6bG9hZEV2ZW50RGVsYXlUaW1lckZpcmVk KFRpbWVyPERvY3VtZW50PiopCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQog aW50IERvY3VtZW50Ojp3ZWJraXRSZXF1ZXN0QW5pbWF0aW9uRnJhbWUoUGFzc1JlZlB0cjxSZXF1 ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQqIGUpCiB7Ci0gICAg aWYgKCFtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcykKLSAgICAgICAgbV9yZXF1ZXN0 QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MgPSBuZXcgUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJh Y2tMaXN0OwotICAgIGludCBpZCA9IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr SWQrKzsKLSAgICBjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gZmFsc2U7Ci0gICAgY2Fs bGJhY2stPm1faWQgPSBpZDsKLSAgICBjYWxsYmFjay0+bV9lbGVtZW50ID0gZTsKLSAgICBtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXBwZW5kKGNhbGxiYWNrKTsKLSAgICBpZiAo RnJhbWVWaWV3KiB2ID0gdmlldygpKQotICAgICAgICB2LT5zY2hlZHVsZUFuaW1hdGlvbigpOwot ICAgIHJldHVybiBpZDsKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyKQor ICAgICAgICBtX3NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlciA9IFNjcmlwdGVkQW5pbWF0aW9u Q29udHJvbGxlcjo6Y3JlYXRlKHRoaXMpOworCisgICAgcmV0dXJuIG1fc2NyaXB0ZWRBbmltYXRp b25Db250cm9sbGVyLT5yZWdpc3RlckNhbGxiYWNrKGNhbGxiYWNrLCBlKTsKIH0KIAogdm9pZCBE b2N1bWVudDo6d2Via2l0Q2FuY2VsUmVxdWVzdEFuaW1hdGlvbkZyYW1lKGludCBpZCkKIHsKLSAg ICBpZiAoIW1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzKQorICAgIGlmICghbV9zY3Jp cHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIpCiAgICAgICAgIHJldHVybjsKLSAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8IG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7ICsr aSkgewotICAgICAgICBpZiAobV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3MtPmF0KGkp LT5tX2lkID09IGlkKSB7Ci0gICAgICAgICAgICBtX3JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7Ci0gICAgICAgICAgICBtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+cmVtb3ZlKGkpOwotICAgICAgICAgICAgcmV0 dXJuOwotICAgICAgICB9Ci0gICAgfQorICAgIG1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy LT5jYW5jZWxDYWxsYmFjayhpZCk7CiB9CiAKIHZvaWQgRG9jdW1lbnQ6OnNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAgaWYgKCFtX3JlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrcykKKyAgICBpZiAoIW1fc2NyaXB0ZWRBbmltYXRpb25Db250cm9s bGVyKQogICAgICAgICByZXR1cm47Ci0gICAgLy8gV2Ugd2FudCB0byBydW4gdGhlIGNhbGxiYWNr IGZvciBhbGwgZWxlbWVudHMgaW4gdGhlIGRvY3VtZW50IHRoYXQgaGF2ZSByZWdpc3RlcmVkCi0g ICAgLy8gZm9yIGEgY2FsbGJhY2sgYW5kIHRoYXQgYXJlIHZpc2libGUuICBSdW5uaW5nIHRoZSBj YWxsYmFja3MgY2FuIGNhdXNlIG5ldyBjYWxsYmFja3MKLSAgICAvLyB0byBiZSByZWdpc3RlcmVk LCBleGlzdGluZyBjYWxsYmFja3MgdG8gYmUgY2FuY2VsbGVkLCBhbmQgZWxlbWVudHMgdG8gZ2Fp biBvciBsb3NlCi0gICAgLy8gdmlzaWJpbGl0eSBzbyB0aGlzIGNvZGUgaGFzIHRvIGl0ZXJhdGUg Y2FyZWZ1bGx5LgotCi0gICAgLy8gRklYTUU6IEN1cnJlbnRseSwgdGhpcyBjb2RlIGRvZXNuJ3Qg ZG8gYW55IHZpc2liaWxpdHkgdGVzdHMgYmV5b25kIGNoZWNraW5nIGRpc3BsYXk6Ci0KLSAgICAv LyBGaXJzdCwgZ2VuZXJhdGUgYSBsaXN0IG9mIGNhbGxiYWNrcyB0byBjb25zaWRlci4gIENhbGxi YWNrcyByZWdpc3RlcmVkIGZyb20gdGhpcyBwb2ludAotICAgIC8vIG9uIGFyZSBjb25zaWRlcmVk IG9ubHkgZm9yIHRoZSAibmV4dCIgZnJhbWUsIG5vdCB0aGlzIG9uZS4KLSAgICBSZXF1ZXN0QW5p bWF0aW9uRnJhbWVDYWxsYmFja0xpc3QgY2FsbGJhY2tzKCptX3JlcXVlc3RBbmltYXRpb25GcmFt ZUNhbGxiYWNrcyk7Ci0KLSAgICAvLyBGaXJpbmcgdGhlIGNhbGxiYWNrIG1heSBjYXVzZSB0aGUg dmlzaWJpbGl0eSBvZiBvdGhlciBlbGVtZW50cyB0byBjaGFuZ2UuICBUbyBhdm9pZAotICAgIC8v IG1pc3NpbmcgYW55IGNhbGxiYWNrcywgd2Uga2VlcCBpdGVyYXRpbmcgdGhyb3VnaCB0aGUgbGlz dCBvZiBjYW5kaWF0ZSBjYWxsYmFja3MgYW5kIGZpcmluZwotICAgIC8vIHRoZW0gdW50aWwgbm90 aGluZyBuZXcgYmVjb21lcyB2aXNpYmxlLgotICAgIGJvb2wgZmlyZWRDYWxsYmFjazsKLSAgICBk byB7Ci0gICAgICAgIGZpcmVkQ2FsbGJhY2sgPSBmYWxzZTsKLSAgICAgICAgLy8gQSBwcmV2aW91 cyBpdGVyYXRpb24gbWF5IGhhdmUgaW52YWxpZGF0ZWQgc3R5bGUgKG9yIGxheW91dCkuICBVcGRh dGUgc3R5bGVzIGZvciBlYWNoIGl0ZXJhdGlvbgotICAgICAgICAvLyBmb3Igbm93IHNpbmNlIGFs bCB3ZSBjaGVjayBpcyB0aGUgZXhpc3RlbmNlIG9mIGEgcmVuZGVyZXIuCi0gICAgICAgIHVwZGF0 ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjYWxsYmFj a3Muc2l6ZSgpOyArK2kpIHsKLSAgICAgICAgICAgIFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrKiBjYWxsYmFjayA9IGNhbGxiYWNrc1tpXS5nZXQoKTsKLSAgICAgICAgICAgIGlmICghY2Fs bGJhY2stPm1fZmlyZWRPckNhbmNlbGxlZCAmJiAoIWNhbGxiYWNrLT5tX2VsZW1lbnQgfHwgY2Fs bGJhY2stPm1fZWxlbWVudC0+cmVuZGVyZXIoKSkpIHsKLSAgICAgICAgICAgICAgICBjYWxsYmFj ay0+bV9maXJlZE9yQ2FuY2VsbGVkID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICBjYWxsYmFjay0+ aGFuZGxlRXZlbnQodGltZSk7Ci0gICAgICAgICAgICAgICAgZmlyZWRDYWxsYmFjayA9IHRydWU7 Ci0gICAgICAgICAgICAgICAgY2FsbGJhY2tzLnJlbW92ZShpKTsKLSAgICAgICAgICAgICAgICBi cmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgIH0gd2hpbGUgKGZpcmVkQ2FsbGJh Y2spOwotCi0gICAgLy8gUmVtb3ZlIGFueSBjYWxsYmFja3Mgd2UgZmlyZWQgZnJvbSB0aGUgbGlz dCBvZiBwZW5kaW5nIGNhbGxiYWNrcy4KLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fcmVx dWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5zaXplKCk7KSB7Ci0gICAgICAgIGlmIChtX3Jl cXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrcy0+YXQoaSktPm1fZmlyZWRPckNhbmNlbGxlZCkK LSAgICAgICAgICAgIG1fcmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tzLT5yZW1vdmUoaSk7 Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICsraTsKLSAgICB9Ci0KLSAgICAvLyBJbiBtb3N0 IGNhc2VzIHdlIGV4cGVjdCB0aGlzIGxpc3QgdG8gYmUgZW1wdHksIHNvIG5vIG5lZWQgdG8ga2Vl cCBhcm91bmQgdGhlIHZlY3RvcidzIGlubGluZSBidWZmZXIuCi0gICAgaWYgKCFtX3JlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrcy0+c2l6ZSgpKQotICAgICAgICBtX3JlcXVlc3RBbmltYXRp b25GcmFtZUNhbGxiYWNrcy5jbGVhcigpOwotICAgIGVsc2UgaWYgKEZyYW1lVmlldyogdiA9IHZp ZXcoKSkKLSAgICAgICAgdi0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyAgICBtX3NjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlci0+c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyh0aW1lKTsKIH0KICNl bmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IDM5ODViNTMyODdiMWRiNDc3YmUyYjBmNDJi YjY1MjZhNTg1ZjFjMTQuLmIyYmY3N2YyMjllMjlkOTc0YThmMWFmZDA0NWMxNjlmODE1YmJlMGEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xNTIsNiArMTUyLDcgQEAgY2xhc3MgVG91Y2hMaXN0 OwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogY2xhc3MgUmVxdWVzdEFu aW1hdGlvbkZyYW1lQ2FsbGJhY2s7CitjbGFzcyBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI7 CiAjZW5kaWYKIAogdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKQEAgLTk1Myw2ICs5NTQsOSBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZE1lc3NhZ2UoTWVzc2FnZVNvdXJjZSwgTWVz c2FnZVR5cGUsIE1lc3NhZ2VMZXZlbCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlLCB1bnNpZ25lZCBs aW5lTnVtYmVyLCBjb25zdCBTdHJpbmcmIHNvdXJjZVVSTCwgUGFzc1JlZlB0cjxTY3JpcHRDYWxs U3RhY2s+KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFzc093blB0cjxUYXNrPik7IC8v IEV4ZWN1dGVzIHRoZSB0YXNrIG9uIGNvbnRleHQncyB0aHJlYWQgYXN5bmNocm9ub3VzbHkuCiAK KyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxi YWNrcygpOworICAgIHZpcnR1YWwgdm9pZCByZXN1bWVTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXJDYWxsYmFja3MoKTsKKwogI2lmIFVTRShKU0MpCiAgICAgdHlwZWRlZiBKU0M6OldlYWtHQ01h cDxXZWJDb3JlOjpOb2RlKiwgSlNOb2RlPiBKU1dyYXBwZXJDYWNoZTsKICAgICB0eXBlZGVmIEhh c2hNYXA8RE9NV3JhcHBlcldvcmxkKiwgSlNXcmFwcGVyQ2FjaGUqPiBKU1dyYXBwZXJDYWNoZU1h cDsKQEAgLTE0MDQsOSArMTQwOCw3IEBAIHByaXZhdGU6CiAgICAgdW5zaWduZWQgbV93cml0ZVJl Y3Vyc2lvbkRlcHRoOwogCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQotICAg IHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gPiBS ZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0xpc3Q7Ci0gICAgT3duUHRyPFJlcXVlc3RBbmlt YXRpb25GcmFtZUNhbGxiYWNrTGlzdD4gbV9yZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja3M7 Ci0gICAgaW50IG1fbmV4dFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrSWQ7CisgICAgT3du UHRyPFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcj4gbV9zY3JpcHRlZEFuaW1hdGlvbkNvbnRy b2xsZXI7CiAjZW5kaWYKIAogICAgIENvbnRlbnRTZWN1cml0eVBvbGljeSBtX2NvbnRlbnRTZWN1 cml0eVBvbGljeTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRp b25Db250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5o CmluZGV4IDY0MjkwNmM0MDgyZTA1YWVjNmIzMjkzZjBmNmE1OTRiMjQyZGYwY2IuLmQ2ZmNmOTIz ZWQ4ZmFkN2RlNThlMTkyNWU2OTRjNWJjYzIxNzQ5NWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaApAQCAtMTA3LDYgKzEwNyw5IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgdHlwZWRlZiBjb25zdCBIYXNoTWFwPEFjdGl2ZURPTU9iamVjdCos IHZvaWQqPiBBY3RpdmVET01PYmplY3RzTWFwOwogICAgICAgICBBY3RpdmVET01PYmplY3RzTWFw JiBhY3RpdmVET01PYmplY3RzKCkgY29uc3QgeyByZXR1cm4gbV9hY3RpdmVET01PYmplY3RzOyB9 CiAKKyAgICAgICAgdmlydHVhbCB2b2lkIHN1c3BlbmRTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xs ZXJDYWxsYmFja3MoKSB7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIHJlc3VtZVNjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcygpIHsgfQorCiAgICAgICAgIC8vIE1lc3NhZ2VQb3J0 IGlzIGNvbmNlcHR1YWxseSBhIGtpbmQgb2YgQWN0aXZlRE9NT2JqZWN0LCBidXQgaXQgbmVlZHMg dG8gYmUgdHJhY2tlZCBzZXBhcmF0ZWx5IGZvciBtZXNzYWdlIGRpc3BhdGNoLgogICAgICAgICB2 b2lkIHByb2Nlc3NNZXNzYWdlUG9ydE1lc3NhZ2VzU29vbigpOwogICAgICAgICB2b2lkIGRpc3Bh dGNoTWVzc2FnZVBvcnRFdmVudHMoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9T Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1Njcmlw dGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDRlZTY4NTc2NWM2OTQ4YjQx YTIwMTIyYmIzZmI0Mjg1NWI3ZDkwMAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0wLDAgKzEsMTM2IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01Q VVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgor ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBV VEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlNjcmlwdGVkQW5p bWF0aW9uQ29udHJvbGxlci5oIgorCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1F KQorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJFbGVtZW50LmgiCisjaW5jbHVk ZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2su aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6 OlNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcihEb2N1bWVudCogZG9jdW1lbnQpCisgICAgOiBt X2RvY3VtZW50KGRvY3VtZW50KQorICAgICwgbV9uZXh0Q2FsbGJhY2tJZCgwKQorICAgICwgbV9z dXNwZW5kQ291bnQoMCkKK3sKK30KKwordm9pZCBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6 OnN1c3BlbmQoKQoreworICAgICsrbV9zdXNwZW5kQ291bnQ7Cit9CisKK3ZvaWQgU2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyOjpyZXN1bWUoKQoreworICAgIC0tbV9zdXNwZW5kQ291bnQ7Cisg ICAgaWYgKCFtX3N1c3BlbmRDb3VudCAmJiBtX2NhbGxiYWNrcy5zaXplKCkpCisgICAgICAgIGlm IChGcmFtZVZpZXcqIGZ2ID0gbV9kb2N1bWVudC0+dmlldygpKQorICAgICAgICAgICAgZnYtPnNj aGVkdWxlQW5pbWF0aW9uKCk7Cit9CisKK1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Q2Fs bGJhY2tJZCBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OnJlZ2lzdGVyQ2FsbGJhY2soUGFz c1JlZlB0cjxSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjaz4gY2FsbGJhY2ssIEVsZW1lbnQq IGUpCit7CisgICAgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyOjpDYWxsYmFja0lkIGlkID0g bV9uZXh0Q2FsbGJhY2tJZCsrOworICAgIGNhbGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSBm YWxzZTsKKyAgICBjYWxsYmFjay0+bV9pZCA9IGlkOworICAgIGNhbGxiYWNrLT5tX2VsZW1lbnQg PSBlOworICAgIG1fY2FsbGJhY2tzLmFwcGVuZChjYWxsYmFjayk7CisgICAgaWYgKCFtX3N1c3Bl bmRDb3VudCkKKyAgICAgICAgaWYgKEZyYW1lVmlldyogdmlldyA9IG1fZG9jdW1lbnQtPnZpZXco KSkKKyAgICAgICAgICAgIHZpZXctPnNjaGVkdWxlQW5pbWF0aW9uKCk7CisgICAgcmV0dXJuIGlk OworfQorCit2b2lkIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Y2FuY2VsQ2FsbGJhY2so Q2FsbGJhY2tJZCBpZCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2FsbGJhY2tz LnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmIChtX2NhbGxiYWNrc1tpXS0+bV9pZCA9PSBpZCkg eworICAgICAgICAgICAgbV9jYWxsYmFja3NbaV0tPm1fZmlyZWRPckNhbmNlbGxlZCA9IHRydWU7 CisgICAgICAgICAgICBtX2NhbGxiYWNrcy5yZW1vdmUoaSk7CisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCB0aW1lKQoreworICAgIGlm ICghbV9jYWxsYmFja3Muc2l6ZSgpIHx8IG1fc3VzcGVuZENvdW50KQorICAgICAgICByZXR1cm47 CisgICAgLy8gV2Ugd2FudCB0byBydW4gdGhlIGNhbGxiYWNrIGZvciBhbGwgZWxlbWVudHMgaW4g dGhlIGRvY3VtZW50IHRoYXQgaGF2ZSByZWdpc3RlcmVkCisgICAgLy8gZm9yIGEgY2FsbGJhY2sg YW5kIHRoYXQgYXJlIHZpc2libGUuICBSdW5uaW5nIHRoZSBjYWxsYmFja3MgY2FuIGNhdXNlIG5l dyBjYWxsYmFja3MKKyAgICAvLyB0byBiZSByZWdpc3RlcmVkLCBleGlzdGluZyBjYWxsYmFja3Mg dG8gYmUgY2FuY2VsbGVkLCBhbmQgZWxlbWVudHMgdG8gZ2FpbiBvciBsb3NlCisgICAgLy8gdmlz aWJpbGl0eSBzbyB0aGlzIGNvZGUgaGFzIHRvIGl0ZXJhdGUgY2FyZWZ1bGx5LgorCisgICAgLy8g RklYTUU6IEN1cnJlbnRseSwgdGhpcyBjb2RlIGRvZXNuJ3QgZG8gYW55IHZpc2liaWxpdHkgdGVz dHMgYmV5b25kIGNoZWNraW5nIGRpc3BsYXk6CisKKyAgICAvLyBGaXJzdCwgZ2VuZXJhdGUgYSBs aXN0IG9mIGNhbGxiYWNrcyB0byBjb25zaWRlci4gIENhbGxiYWNrcyByZWdpc3RlcmVkIGZyb20g dGhpcyBwb2ludAorICAgIC8vIG9uIGFyZSBjb25zaWRlcmVkIG9ubHkgZm9yIHRoZSAibmV4dCIg ZnJhbWUsIG5vdCB0aGlzIG9uZS4KKyAgICBDYWxsYmFja0xpc3QgY2FsbGJhY2tzKG1fY2FsbGJh Y2tzKTsKKworICAgIC8vIEZpcmluZyB0aGUgY2FsbGJhY2sgbWF5IGNhdXNlIHRoZSB2aXNpYmls aXR5IG9mIG90aGVyIGVsZW1lbnRzIHRvIGNoYW5nZS4gIFRvIGF2b2lkCisgICAgLy8gbWlzc2lu ZyBhbnkgY2FsbGJhY2tzLCB3ZSBrZWVwIGl0ZXJhdGluZyB0aHJvdWdoIHRoZSBsaXN0IG9mIGNh bmRpYXRlIGNhbGxiYWNrcyBhbmQgZmlyaW5nCisgICAgLy8gdGhlbSB1bnRpbCBub3RoaW5nIG5l dyBiZWNvbWVzIHZpc2libGUuCisgICAgYm9vbCBmaXJlZENhbGxiYWNrOworICAgIGRvIHsKKyAg ICAgICAgZmlyZWRDYWxsYmFjayA9IGZhbHNlOworICAgICAgICAvLyBBIHByZXZpb3VzIGl0ZXJh dGlvbiBtYXkgaGF2ZSBpbnZhbGlkYXRlZCBzdHlsZSAob3IgbGF5b3V0KS4gIFVwZGF0ZSBzdHls ZXMgZm9yIGVhY2ggaXRlcmF0aW9uCisgICAgICAgIC8vIGZvciBub3cgc2luY2UgYWxsIHdlIGNo ZWNrIGlzIHRoZSBleGlzdGVuY2Ugb2YgYSByZW5kZXJlci4KKyAgICAgICAgbV9kb2N1bWVudC0+ dXBkYXRlU3R5bGVJZk5lZWRlZCgpOworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGNh bGxiYWNrcy5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgUmVxdWVzdEFuaW1hdGlvbkZyYW1l Q2FsbGJhY2sqIGNhbGxiYWNrID0gY2FsbGJhY2tzW2ldLmdldCgpOworICAgICAgICAgICAgaWYg KCFjYWxsYmFjay0+bV9maXJlZE9yQ2FuY2VsbGVkICYmICghY2FsbGJhY2stPm1fZWxlbWVudCB8 fCBjYWxsYmFjay0+bV9lbGVtZW50LT5yZW5kZXJlcigpKSkgeworICAgICAgICAgICAgICAgIGNh bGxiYWNrLT5tX2ZpcmVkT3JDYW5jZWxsZWQgPSB0cnVlOworICAgICAgICAgICAgICAgIGNhbGxi YWNrLT5oYW5kbGVFdmVudCh0aW1lKTsKKyAgICAgICAgICAgICAgICBmaXJlZENhbGxiYWNrID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICBjYWxsYmFja3MucmVtb3ZlKGkpOworICAgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfSB3aGlsZSAoZmlyZWRD YWxsYmFjayk7CisKKyAgICAvLyBSZW1vdmUgYW55IGNhbGxiYWNrcyB3ZSBmaXJlZCBmcm9tIHRo ZSBsaXN0IG9mIHBlbmRpbmcgY2FsbGJhY2tzLgorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwg bV9jYWxsYmFja3Muc2l6ZSgpOykgeworICAgICAgICBpZiAobV9jYWxsYmFja3NbaV0tPm1fZmly ZWRPckNhbmNlbGxlZCkKKyAgICAgICAgICAgIG1fY2FsbGJhY2tzLnJlbW92ZShpKTsKKyAgICAg ICAgZWxzZQorICAgICAgICAgICAgKytpOworICAgIH0KKworICAgIGlmIChtX2NhbGxiYWNrcy5z aXplKCkpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIHZpZXcgPSBtX2RvY3VtZW50LT52aWV3KCkp CisgICAgICAgICAgICB2aWV3LT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorCit9CisKKyNlbmRp ZgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmltYXRpb25Db250 cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMDY0ZDk4YTY5MTQzOTQ5N2VjOWY5ZWZlOTA1MWMyOGM4MmJmNGZiYwot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1hdGlvbkNv bnRyb2xsZXIuaApAQCAtMCwwICsxLDcyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEdv b2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKgorICovCisKKyNpZm5kZWYgU2NyaXB0 ZWRBbmltYXRpb25Db250cm9sbGVyX2gKKyNkZWZpbmUgU2NyaXB0ZWRBbmltYXRpb25Db250cm9s bGVyX2gKKworI2luY2x1ZGUgIkRPTVRpbWVTdGFtcC5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5 YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitj bGFzcyBEb2N1bWVudDsKK2NsYXNzIEVsZW1lbnQ7CitjbGFzcyBSZXF1ZXN0QW5pbWF0aW9uRnJh bWVDYWxsYmFjazsKKworY2xhc3MgU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyIHsKK1dURl9N QUtFX05PTkNPUFlBQkxFKFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcik7CitwdWJsaWM6Cisg ICAgc3RhdGljIFBhc3NPd25QdHI8U2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyPiBjcmVhdGUo RG9jdW1lbnQqIGRvY3VtZW50KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBT Y3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXIoZG9jdW1lbnQpKTsKKyAgICB9CisKKyAgICB0eXBl ZGVmIGludCBDYWxsYmFja0lkOworCisgICAgQ2FsbGJhY2tJZCByZWdpc3RlckNhbGxiYWNrKFBh c3NSZWZQdHI8UmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2s+LCBFbGVtZW50Kik7CisgICAg dm9pZCBjYW5jZWxDYWxsYmFjayhDYWxsYmFja0lkKTsKKyAgICB2b2lkIHNlcnZpY2VTY3JpcHRl ZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wKTsKKworICAgIHZvaWQgc3VzcGVuZCgpOworICAgIHZv aWQgcmVzdW1lKCk7CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgU2NyaXB0ZWRBbmltYXRpb25D b250cm9sbGVyKERvY3VtZW50Kik7CisgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPFJlcXVlc3RB bmltYXRpb25GcmFtZUNhbGxiYWNrPiA+IENhbGxiYWNrTGlzdDsKKyAgICBDYWxsYmFja0xpc3Qg bV9jYWxsYmFja3M7CisKKyAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKKyAgICBDYWxsYmFja0lk IG1fbmV4dENhbGxiYWNrSWQ7CisgICAgaW50IG1fc3VzcGVuZENvdW50OworfTsKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy X2gKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9oaXN0b3J5L0NhY2hlZEZyYW1lLmNwcAppbmRleCAwMDU5NjkxMzQw MDQ1ZDM5ZWMwMjA0YWE5MTIyNTE2ODYzMTcyZTA5Li45MjU1N2I3ODNiOWVlNmQ2NDA3NDhmMGQx ZjczYzFmMzdkNTBmNDlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9oaXN0b3J5L0NhY2hl ZEZyYW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9oaXN0b3J5L0NhY2hlZEZyYW1lLmNwcApA QCAtOTQsNiArOTQsNyBAQCB2b2lkIENhY2hlZEZyYW1lQmFzZTo6cmVzdG9yZSgpCiAgICAgZnJh bWUtPmFuaW1hdGlvbigpLT5yZXN1bWVBbmltYXRpb25zRm9yRG9jdW1lbnQobV9kb2N1bWVudC5n ZXQoKSk7CiAgICAgZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5zZXRNb3VzZVByZXNzTm9kZShtX21v dXNlUHJlc3NOb2RlLmdldCgpKTsKICAgICBtX2RvY3VtZW50LT5yZXN1bWVBY3RpdmVET01PYmpl Y3RzKCk7CisgICAgbV9kb2N1bWVudC0+cmVzdW1lU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVy Q2FsbGJhY2tzKCk7CiAKICAgICAvLyBJdCBpcyBuZWNlc3NhcnkgdG8gdXBkYXRlIGFueSBwbGF0 Zm9ybSBzY3JpcHQgb2JqZWN0cyBhZnRlciByZXN0b3JpbmcgdGhlCiAgICAgLy8gY2FjaGVkIHBh Z2UuCkBAIC0xNTIsNiArMTUzLDcgQEAgQ2FjaGVkRnJhbWU6OkNhY2hlZEZyYW1lKEZyYW1lKiBm cmFtZSkKICAgICAvLyBTdXNwZW5kaW5nIG11c3QgYWxzbyBoYXBwZW4gYWZ0ZXIgd2UndmUgcmVj dXJzZWQgb3ZlciBjaGlsZCBmcmFtZXMsIGluIGNhc2UKICAgICAvLyB0aG9zZSBjcmVhdGUgbW9y ZSBvYmplY3RzLgogICAgIC8vIEZJWE1FOiBJdCdzIHN0aWxsIHBvc3NpYmxlIHRvIGhhdmUgb2Jq ZWN0cyBjcmVhdGVkIGFmdGVyIHN1c3BlbmRpbmcgaW4gc29tZSBjYXNlcywgc2VlIGh0dHA6Ly93 ZWJraXQub3JnL2IvNTM3MzMgZm9yIG1vcmUgZGV0YWlscy4KKyAgICBtX2RvY3VtZW50LT5zdXNw ZW5kU2NyaXB0ZWRBbmltYXRpb25Db250cm9sbGVyQ2FsbGJhY2tzKCk7CiAgICAgbV9kb2N1bWVu dC0+c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZlRE9NT2JqZWN0OjpEb2N1bWVudFdpbGxC ZWNvbWVJbmFjdGl2ZSk7CiAgICAgbV9jYWNoZWRGcmFtZVNjcmlwdERhdGEgPSBhZG9wdFB0cihu ZXcgU2NyaXB0Q2FjaGVkRnJhbWVEYXRhKGZyYW1lKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGFnZUdyb3VwTG9hZERlZmVycmVyLmNwcAppbmRleCA3ODFiYzM0NDMzZGJkNjY3ZmJlNWZl ZGIxNmYzNWQwZGYxNzJjMDA1Li5kZWEyY2Q3Nzc1ZmYzNmNlYzZhNTQ2MDE2ZTI5NmY2YmVhYmQ2 YmVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2VHcm91cExvYWREZWZlcnJl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlR3JvdXBMb2FkRGVmZXJyZXIuY3Bw CkBAIC00OCw2ICs0OCw3IEBAIFBhZ2VHcm91cExvYWREZWZlcnJlcjo6UGFnZUdyb3VwTG9hZERl ZmVycmVyKFBhZ2UqIHBhZ2UsIGJvb2wgZGVmZXJTZWxmKQogICAgICAgICAgICAgICAgIC8vIE5P VEU6IGlmIFBhZ2VHcm91cExvYWREZWZlcnJlciBpcyBldmVyIHVzZWQgZm9yIHRhc2tzIG90aGVy IHRoYW4gc2hvd2luZyBhIG1vZGFsIHdpbmRvdyBvciBzaGVldCwKICAgICAgICAgICAgICAgICAv LyB0aGUgY29uc3RydWN0b3Igd2lsbCBuZWVkIHRvIHRha2UgYSBBY3RpdmVET01PYmplY3Q6OlJl YXNvbkZvclN1c3BlbnNpb24uCiAgICAgICAgICAgICAgICAgZm9yIChGcmFtZSogZnJhbWUgPSBv dGhlclBhZ2UtPm1haW5GcmFtZSgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2 ZXJzZU5leHQoKSkgeworICAgICAgICAgICAgICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+c3Vz cGVuZFNjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcygpOwogICAgICAgICAgICAg ICAgICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+c3VzcGVuZEFjdGl2ZURPTU9iamVjdHMoQWN0aXZl RE9NT2JqZWN0OjpXaWxsU2hvd0RpYWxvZyk7CiAgICAgICAgICAgICAgICAgICAgIGZyYW1lLT5k b2N1bWVudCgpLT5hc3luY1NjcmlwdFJ1bm5lcigpLT5zdXNwZW5kKCk7CiAgICAgICAgICAgICAg ICAgICAgIGlmIChEb2N1bWVudFBhcnNlciogcGFyc2VyID0gZnJhbWUtPmRvY3VtZW50KCktPnBh cnNlcigpKQpAQCAtNzEsNiArNzIsNyBAQCBQYWdlR3JvdXBMb2FkRGVmZXJyZXI6On5QYWdlR3Jv dXBMb2FkRGVmZXJyZXIoKQogCiAgICAgICAgICAgICBmb3IgKEZyYW1lKiBmcmFtZSA9IHBhZ2Ut Pm1haW5GcmFtZSgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5leHQo KSkgewogICAgICAgICAgICAgICAgIGZyYW1lLT5kb2N1bWVudCgpLT5yZXN1bWVBY3RpdmVET01P YmplY3RzKCk7CisgICAgICAgICAgICAgICAgZnJhbWUtPmRvY3VtZW50KCktPnJlc3VtZVNjcmlw dGVkQW5pbWF0aW9uQ29udHJvbGxlckNhbGxiYWNrcygpOwogICAgICAgICAgICAgICAgIGZyYW1l LT5kb2N1bWVudCgpLT5hc3luY1NjcmlwdFJ1bm5lcigpLT5yZXN1bWUoKTsKICAgICAgICAgICAg ICAgICBpZiAoRG9jdW1lbnRQYXJzZXIqIHBhcnNlciA9IGZyYW1lLT5kb2N1bWVudCgpLT5wYXJz ZXIoKSkKICAgICAgICAgICAgICAgICAgICAgcGFyc2VyLT5yZXN1bWVTY2hlZHVsZWRUYXNrcygp Owo=