45631 2010-09-12 21:29:07 -0700 Scroll event should be fired asynchronously 2011-06-15 14:26:20 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) PC Windows 7 RESOLVED FIXED http://trac.webkit.org/export/67358/trunk/LayoutTests/fast/events/scroll-event-does-not-bubble.html P2 Normal --- 49785 1 mikelawther mihaip ap commit-queue darin dglazkov fishd hyatt ojan pkasting simon.fraser webkit.review.bot oldest_to_newest 277962 0 67356 mikelawther 2010-09-12 21:29:07 -0700 Created attachment 67356 test for behaviour change 2) Patch http://trac.webkit.org/changeset/67001/ introduced smooth scrolling on Windows, which changes two behaviours: 1) the scroll event triggered by scrollByLines() is no longer fired synchronously; 2) the value of scrollTop is not synchronously set to the target value It's 1) that causes fast/events/scroll-event-does-not-bubble.html to break on Windows. Attached are two tests for these changed behaviours. 277963 1 67357 mikelawther 2010-09-12 21:29:44 -0700 Created attachment 67357 test for behaviour change 1) 277974 2 ojan 2010-09-12 22:24:49 -0700 It's not clear to me whether it's OK to make this method async, but we should at least be consistent across platforms. Looks like Firefox is the only other browser to implement scrollByLines and it only implements it on Window (where WebKit only implements it on Element). So, if there are regressions from making this async, they'd be in WebKit-only code paths. Alternately, maybe when scrollByLines is called from JS, it shouldn't smooth scroll? It seems we don't smooth scroll if you set scrollTop. 278239 3 pkasting 2010-09-13 09:11:22 -0700 We should make this method scroll synchronously and without smooth scrolling, like it used to. It should be easy enough to do; the underlying implementation needs to call something like setValue() instead of scroll(). I can look into this in a week when I'm back from vacation, if no one else can get it sooner. 283897 4 pkasting 2010-09-23 13:20:55 -0700 Possibly separately, Darin Fisher tells me that scroll DOM events should be async per the HTML5 spec. I'm not sure how that interacts with this. Maybe internally we need to scroll synchronously when asked but use queues for events we fire back to the page. Darin, feel free to enlighten me. 283980 5 fishd 2010-09-23 14:50:25 -0700 (In reply to comment #0) > Created an attachment (id=67356) [details] > test for behaviour change 2) > > Patch http://trac.webkit.org/changeset/67001/ introduced smooth scrolling on Windows, which changes two behaviours: > 1) the scroll event triggered by scrollByLines() is no longer fired synchronously; > 2) the value of scrollTop is not synchronously set to the target value 3) a single scroll action may result in multiple scroll events i wonder if this third artifact isn't the cause of bugs like: http://code.google.com/p/chromium/issues/detail?id=55218 The HTML5 spec does not document the behavior of the 'scroll' event. I recall a whatwg (or public-webapps) thread where it was asserted that the 'scroll' event should be dispatch asynchronously. 283982 6 pkasting 2010-09-23 14:54:18 -0700 It seems to me that we shouldn't be sending scroll events as a side effect of doing the final low-level scrolls on the ScrollbarClient. Instead we should be sending them in the course of generating the scroll request in the first place. This way, I'd get a single "scroll" event for a single wheel click, regardless of how the ScrollAnimator breaks it apart. Or am I misguided? I don't have a good sense here. At least the event isn't cancelable! 287819 7 pkasting 2010-09-30 14:22:32 -0700 Testing other browsers makes it clear that smooth scrolls generally dispatch several scroll events per high-level scroll, and do so asynchronously. Right now, everything should be synchronous since Darin (Fisher) turned off smooth scrolling at compile time. So the test is actually passing again. But we should change the event to be async and then also change the test. Mihai is going to work on this stuff, I think. I'll check in a change that unmarks this test as "failing". 305342 8 mihaip 2010-11-05 10:20:00 -0700 I've put up some test cases at http://persistent.info/webkit/test-cases/onscroll-async/ document.html (scrolling of the whole document) Chrome: sync WebKit: sync Firefox: async Opera: async IE: sync div.html (scrolling of a div with overflow: auto) Chrome: sync WebKit: sync Firefox: async Opera: async IE: async history.html (scrolling induced by navigating to fragments and going back) Chrome: sync for fragment change, async for back* WebKit: sync for fragment change, async for back* Firefox: async Opera: async IE: sync for fragment change, doesn't restore scroll for back * going back is async because history.back() is async, presumably the scroll event itself is still dispatched synchronously, like in all other cases Chrome is 9.0.572.0/Mac WebKit is r71367/Mac Firefix is 4.0b6/Mac Opera is 10.62/Mac IE is IE8/Win7 The spec for this is in the CSSOM (http://dev.w3.org/csswg/cssom-view/), and says "queue a task to fire a simple event named scroll that bubbles at the Document object, unless a task to fire that event at the Document object was already queued." (and the same thing for elements). That makes it pretty clear that scroll should be async (though it doesn't clarify the smooth scrolling issues that Peter brought up). 305476 9 ojan 2010-11-05 13:14:15 -0700 I certainly support making this event async if we can without breaking existing content. Is there any history to this in WebKit code? Has it always been sync? 305535 10 mihaip 2010-11-05 14:39:07 -0700 (In reply to comment #9) > I certainly support making this event async if we can without breaking existing content. Is there any history to this in WebKit code? Has it always been sync? I went back ~5 years, and it's always been sync: http://trac.webkit.org/browser/trunk/WebCore/kwq/KWQKHTMLPart.mm?rev=11945#L1757 That ends up in: http://trac.webkit.org/browser/trunk/WebCore/khtml/xml/dom_nodeimpl.cpp?rev=11945#L549 Given that it's already async in Firefox, I'm not as concerned about compatibility issues. 306540 11 73328 mihaip 2010-11-08 18:21:38 -0800 Created attachment 73328 Patch 306541 12 mihaip 2010-11-08 18:23:25 -0800 Darin, Dimitri said you might have opinions about this approach (the EventQueue class, and attaching it to Node via NodeRareData). Ojan, is any of this helpful for your plan to make editing events async? 309419 13 73927 mihaip 2010-11-15 13:30:39 -0800 Created attachment 73927 Patch 309420 14 mihaip 2010-11-15 13:32:03 -0800 OK, this is now ready for review (only difference from the patch from last week is that I added the EventQueue.cpp/h files to the various port build systems). 309422 15 73927 darin 2010-11-15 13:33:32 -0800 Comment on attachment 73927 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=73927&action=review I don’t think there’s a need to have a separate queue for each node. A single queue per document should suffice. > WebCore/dom/NodeRareData.h:120 > + m_eventQueue.set(new EventQueue(target)); This creates a circular reference and hence leaks any node that ever has an event queue. The node owns the rare data, the rare data owns the event queue, and the event queue refs the node. 309427 16 mihaip 2010-11-15 13:40:56 -0800 (In reply to comment #15) > (From update of attachment 73927 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=73927&action=review > > I don’t think there’s a need to have a separate queue for each node. A single queue per document should suffice. OK. Since multiple scroll position changes are supposed to be coalesced into one event, I wasn't sure if it'd be inefficient to have to do a linear scan through the queued events for a document, but I'm guessing the queue will be empty the vast majority of the time. Do you have a preference about keeping the EventQueue class, or moving things back into the Document class? > > WebCore/dom/NodeRareData.h:120 > > + m_eventQueue.set(new EventQueue(target)); > > This creates a circular reference and hence leaks any node that ever has an event queue. The node owns the rare data, the rare data owns the event queue, and the event queue refs the node. Oops, thanks for pointing this out. 309430 17 darin 2010-11-15 13:46:51 -0800 (In reply to comment #16) > Since multiple scroll position changes are supposed to be coalesced into one event, I wasn't sure if it'd be inefficient to have to do a linear scan through the queued events for a document, but I'm guessing the queue will be empty the vast majority of the time. We should consider including an efficient mechanism for finding already-outstanding events that are supposed to be coalesced. For example, in addition to the vector, we could keep a map of events in the vector using the target and type of the event as a key. This would guarantee we could efficiently find an existing event to coalesce with even if something pathological is going on. > Do you have a preference about keeping the EventQueue class, or moving things back into the Document class? Having this in a class seems OK, good factoring. The Document class is big it’s good not to add things to it. The real issue is the functions in the interface, not whether those functions are grouped in a class or not. We need that set of functions to be tight and clear. 309463 18 73934 mihaip 2010-11-15 15:08:26 -0800 Created attachment 73934 Patch 309464 19 mihaip 2010-11-15 15:13:21 -0800 (In reply to comment #17) > (In reply to comment #16) > > Since multiple scroll position changes are supposed to be coalesced into one event, I wasn't sure if it'd be inefficient to have to do a linear scan through the queued events for a document, but I'm guessing the queue will be empty the vast majority of the time. > > We should consider including an efficient mechanism for finding already-outstanding events that are supposed to be coalesced. For example, in addition to the vector, we could keep a map of events in the vector using the target and type of the event as a key. This would guarantee we could efficiently find an existing event to coalesce with even if something pathological is going on. Now that I think about it, how necessary do you think this is? The overhead of the map seems like it would hurt more in the common case with an empty queue. To generate O(N^2) behavior the attacker would have to create O(N) unique nodes and generate scroll events for each one, I think the overhead from having that many nodes (which we can't avoid) would outweigh the O(N^2) behavior from enqueueEventIfNotAlreadyEnqueued. > The real issue is the functions in the interface, not whether those functions are grouped in a class or not. We need that set of functions to be tight and clear. For now I've kept Node::enqueueEvent(IfNotAlreadyEnqueued) which are convenience versions that call those functions in Document with the node as the target. Exposing the EventQueue in Document didn't seem like a good idea. 309469 20 73934 darin 2010-11-15 15:22:46 -0800 Comment on attachment 73934 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=73934&action=review > WebCore/dom/Document.h:1021 > + void enqueueEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget); I suggest having the caller call setTarget on the event before calling enqueueEvent. Then there would be no need to pass the target separately. I don’t think it’s a good idea to have functions with two different purposes on the same object. Having enqueueEvent in Node isn’t really all that helpful, and creates ambiguity. The argument name “event” should not be written here since the type already makes it clear. > WebCore/dom/Document.h:1023 > + void enqueueEventIfNotAlreadyEnqueued(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget); This long awkward name is not even accurate. This enqueues an event if another of the same type targeted at the same target is not already enqueued. That’s not the same as *this* event already being enqueued. I don’t think that creating an event and then later discovering that it is already enqueued is a suitable API. Instead, I suggest that the function pass only the type of the event and the target and actual event creation be done inside the function if it’s needed. The only tricky part is making sure we pass the right values for canBubble and cancelable, but I think we can start with those hardcoded at first, and add arguments if needed later. And we can come up with a more accurate name. Maybe enqueueCoalescedEvent(const String& type, PassRefPtr<EventTarget>). > WebCore/dom/EventQueue.cpp:36 > +struct EnqueuedEvent : Noncopyable { Why Noncopyable? > WebCore/dom/EventQueue.cpp:38 > + RefPtr<Event> m_event; > + RefPtr<Node> m_eventTarget; Normally we do not use the "m_" prefix for the members of a struct. > WebCore/dom/EventQueue.cpp:55 > +void EventQueue::enqueueEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget) The targets should be stored in the events, not separately. We don’t need the EnqueuedEvent struct at all. > WebCore/dom/EventQueue.cpp:96 > + Node* eventTarget = event->m_eventTarget.get(); > + if (!eventTarget->inDocument()) > + return; What about if the entire document is no longer being displayed, say if you navigated away from it or destroyed it. We need to test that case. > WebCore/page/EventHandler.cpp:2760 > - m_frame->document()->dispatchEvent(Event::create(eventNames().scrollEvent, true, false)); > + m_frame->document()->enqueueEventIfNotAlreadyEnqueued(Event::create(eventNames().scrollEvent, true, false)); I noticed that the multiple places emitting scrollEvent don’t agree on the setting of canBubble. This call site passes true. > WebCore/rendering/RenderLayer.cpp:1401 > - if (view) { > - if (FrameView* frameView = view->frameView()) > - frameView->scheduleEvent(Event::create(eventNames().scrollEvent, false, false), renderer()->node()); > - } > + if (view && view->frameView()) > + renderer()->node()->enqueueEventIfNotAlreadyEnqueued(Event::create(eventNames().scrollEvent, false, false)); This call site passes false for canBubble. It does not make sense to check view and view->frameView() for 0 any more here. That was only done so we could call the scheduleEvent function. The pauseScheduledEvents and resumeScheduledEvents function will no longer affect the dispatching of this event. Why is that OK? > WebCore/rendering/RenderListBox.cpp:543 > - node()->dispatchEvent(Event::create(eventNames().scrollEvent, false, false)); > + node()->enqueueEventIfNotAlreadyEnqueued(Event::create(eventNames().scrollEvent, false, false)); This call site passes false for canBubble. 309470 21 darin 2010-11-15 15:24:48 -0800 (In reply to comment #19) > (In reply to comment #17) > > (In reply to comment #16) > > > Since multiple scroll position changes are supposed to be coalesced into one event, I wasn't sure if it'd be inefficient to have to do a linear scan through the queued events for a document, but I'm guessing the queue will be empty the vast majority of the time. > > > > We should consider including an efficient mechanism for finding already-outstanding events that are supposed to be coalesced. For example, in addition to the vector, we could keep a map of events in the vector using the target and type of the event as a key. This would guarantee we could efficiently find an existing event to coalesce with even if something pathological is going on. > > Now that I think about it, how necessary do you think this is? The overhead of the map seems like it would hurt more in the common case with an empty queue. To generate O(N^2) behavior the attacker would have to create O(N) unique nodes and generate scroll events for each one, I think the overhead from having that many nodes (which we can't avoid) would outweigh the O(N^2) behavior from enqueueEventIfNotAlreadyEnqueued. You can just build a test case and see. No need to guess. > Exposing the EventQueue in Document didn't seem like a good idea. I think it probably is a good idea. But for now with only two functions, we might be OK. 309493 22 mihaip 2010-11-15 15:58:15 -0800 I'll upload a new patch as soon as we can decide on the questions below. (In reply to comment #20) > I suggest having the caller call setTarget on the event before calling enqueueEvent. Then there would be no need to pass the target separately. Unfortunately Event::target() returns the target as an EventTarget pointer, and I need it as a Node to have access to the isDocumentNode() and document()->dispatchWindowEvent() methods. This (having a struct with the event and the target as a Node) is the same pattern as used by ScheduledEvent in FrameView.cpp. > > + void enqueueEventIfNotAlreadyEnqueued(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget); > > This long awkward name is not even accurate. This enqueues an event if another of the same type targeted at the same target is not already enqueued. That’s not the same as *this* event already being enqueued. > > I don’t think that creating an event and then later discovering that it is already enqueued is a suitable API. Instead, I suggest that the function pass only the type of the event and the target and actual event creation be done inside the function if it’s needed. The only tricky part is making sure we pass the right values for canBubble and cancelable, but I think we can start with those hardcoded at first, and add arguments if needed later. > > And we can come up with a more accurate name. Maybe enqueueCoalescedEvent(const String& type, PassRefPtr<EventTarget>). Unfortunately, it looks like the scroll event only bubbles if the target is the document, so we can't hardcoded it one way or the other that easily. Here are the bits from the CSSOM spec that talk about firing of scroll events: - If the aligning caused content to move queue a task to fire a simple event named scroll that bubbles at the Document object, unless a task to fire that event at the Document object was already queued. - Queue a task to fire a simple event named scroll at the element associated with the scrolling box, unless a task to fire that event at that element was already queued. - Queue a task to fire a simple event named scroll that bubbles at the Document object associated with the viewport, unless a task to fire that event at that Document object was already queued. - If the aligning caused content to move queue a task to fire a simple event named scroll at the element, unless a task to fire that event at that element was already queued. So it'd have to be enqueueCoalescedEvent(const String& type, PassRefPtr<EventTarget>, bool bubbles). Alternatively, rather that having this much flexibility in the API at this early stage, we could have something more specialized: 1. EventQueue:enqueueScrollEvent(PassRefPtr<Node> target, bool canBubble): does the check for other scroll events with that target being in enqueued 1. Node::enqueueScrollEvent(): calls document->eventQueue()->enqueueScrollEvent(this, false) 2. Document::enqueueScrollEvent(): calls m_eventQueue->enqueueScrollEvent(this, true) > > WebCore/dom/EventQueue.cpp:36 > > +struct EnqueuedEvent : Noncopyable { > > Why Noncopyable? It seemed like the default was to make things Noncopyable, unless there was a reason why things should be copied. I can remove it if you'd like. > > WebCore/dom/EventQueue.cpp:96 > > + Node* eventTarget = event->m_eventTarget.get(); > > + if (!eventTarget->inDocument()) > > + return; > > What about if the entire document is no longer being displayed, say if you navigated away from it or destroyed it. We need to test that case. How do I check for these things? > The pauseScheduledEvents and resumeScheduledEvents function will no longer affect the dispatching of this event. Why is that OK? They would just delay scroll event dispatching until layout was complete, but still run them sychronously. Now that they're async, they're guaranteed to run after layout is done. > > Exposing the EventQueue in Document didn't seem like a good idea. > > I think it probably is a good idea. But for now with only two functions, we might be OK. I'll proably expose it if we go with the enqueueScrollEvent approach described above. 309499 23 darin 2010-11-15 16:20:23 -0800 (In reply to comment #22) > Unfortunately Event::target() returns the target as an EventTarget pointer, and I need it as a Node You can assert that it’s a node, and cast using static_cast. 309523 24 73948 mihaip 2010-11-15 17:13:37 -0800 Created attachment 73948 Patch 309524 25 mihaip 2010-11-15 17:15:57 -0800 (In reply to comment #23) > (In reply to comment #22) > > Unfortunately Event::target() returns the target as an EventTarget pointer, and I need it as a Node > > You can assert that it’s a node, and cast using static_cast. Actually, there's an EventTarget::toNode that does exactly what I want. The latest version of the patch uses the target in the event, and adds an enqueueScrolleEvent method that does the right thing for Document vs. Node (as far as bubbling) and implements the coalescing logic with a HashSet. If we need similar coalescing behavior later (e.g. for bug 36334 or bug 36202), it can be generalized, but I saw no need for that now. 309529 26 73948 darin 2010-11-15 17:29:40 -0800 Comment on attachment 73948 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=73948&action=review Better, but still needs some work. > WebCore/dom/Document.cpp:403 > + , m_eventQueue(new EventQueue) This should have an adoptPtr. > WebCore/dom/Document.cpp:3443 > + event->setTarget(this); It’s unclear that this function can only queue events that are intended for the document. Is there some way to make this more clear? I worry that if you meant to write document()->eventQueue()->enqueueEvent() but instead just wrote document()->enqueueEvent() you’d end up incorrectly changing the event target to the document. > WebCore/dom/Document.cpp:3449 > + m_eventQueue->enqueueScrollEvent(this, true); In WebKit code we frown on boolean arguments that get boolean constants passed to them. Either you can define the function so it doesn’t need the argument or you can use an enum instead of true/false. There’s no way for someone reading “true” here to know what the “true” means. > WebCore/dom/EventQueue.cpp:33 > +#include "Node.h" No need to include Node.h if we are also including Document.h. > WebCore/dom/EventQueue.cpp:46 > + m_enqueuedEvents.clear(); No reason to do this. > WebCore/dom/EventQueue.cpp:63 > + if (m_nodesWithEnqueuedScrollEvents.contains(target.get())) > + return; > + > + m_nodesWithEnqueuedScrollEvents.add(target.get()); This does two hash lookups, and you only need to do one. Like this: if (!m_nodesWithEnqueuedScrollEvents.add(target.get()).second) return; That does the same thing with just one hash lookup. > WebCore/dom/EventQueue.cpp:66 > + enqueueEvent(scrollEvent); Should be scrollEvent.release(). > WebCore/dom/EventQueue.cpp:77 > + EventIterator end = enqueuedEvents.end(); > + for (EventIterator it = enqueuedEvents.begin(); it != end; ++it) > + dispatchEvent(*it); There’s no need to use iterators to walk through a vector. A for look using size_t and indices works just fine and reads more clearly. Iterators are fine if it’s an abstract algorithm, but no need for an iterator just for a vector. Instead of *it this would be better if it was it->release() or if you fix the iteration enqueuedEvents[i].release(). > WebCore/dom/EventQueue.cpp:85 > + if (eventNames().scrollEvent == event->type()) > + m_nodesWithEnqueuedScrollEvents.remove(eventTarget); No need to check the type. We could just always call this remove function. > WebCore/dom/EventQueue.cpp:91 > + if (eventTarget->isDocumentNode()) > + eventTarget->document()->dispatchWindowEvent(event); Why? Are all event targeted at the document window events? Can’t a document ever get a non-window event? > WebCore/dom/EventQueue.h:39 > +struct EnqueuedEvent; This doesn’t belong here. > WebCore/dom/EventQueue.h:47 > + void enqueueScrollEvent(PassRefPtr<Node> target, bool canBubble); Your patch always passes false for canBubble, so you should remove the argument from this function. It’s always false. You also need a test case to show that it’s correct to have the scroll event not bubble in the one case you’re changing, the event queued in EventHandler::sendScrollEvent. > WebCore/dom/EventQueue.h:54 > + Vector<RefPtr<Event> > m_enqueuedEvents; This should be named m_queuedEvents, not m_enqueuedEvents. > WebCore/dom/EventQueue.h:55 > + HashSet<Node*> m_nodesWithEnqueuedScrollEvents; This should be named m_nodesWithQueuedScrollEvents, not m_nodesWithEnqueuedScrollEvents. > WebCore/dom/Node.h:520 > + void enqueueScrollEvent(); Do we really need this helper? Can’t the client callers with the event queue directly? I’d prefer not to touch the Node class at all; it’s not good to build the scroll event in like this. 309546 27 73952 mihaip 2010-11-15 19:13:50 -0800 Created attachment 73952 Patch 309547 28 mihaip 2010-11-15 19:14:16 -0800 Just one question below. (In reply to comment #26) > > WebCore/dom/Document.cpp:403 > > + , m_eventQueue(new EventQueue) > > This should have an adoptPtr. Fixed. > > WebCore/dom/Document.cpp:3443 > > + event->setTarget(this); > > It’s unclear that this function can only queue events that are intended for the document. Is there some way to make this more clear? I worry that if you meant to write document()->eventQueue()->enqueueEvent() but instead just wrote document()->enqueueEvent() you’d end up incorrectly changing the event target to the document. That was the case before this patch (since pendingEventTimerFired called dispatchWindowEvent). Should I rename it to enqueueWindowEvent? > > WebCore/dom/Document.cpp:3449 > > + m_eventQueue->enqueueScrollEvent(this, true); > > In WebKit code we frown on boolean arguments that get boolean constants passed to them. Either you can define the function so it doesn’t need the argument or you can use an enum instead of true/false. There’s no way for someone reading “true” here to know what the “true” means. Removed the boolean parameter altogether. > > WebCore/dom/EventQueue.cpp:33 > > +#include "Node.h" > > No need to include Node.h if we are also including Document.h. Removed. > > WebCore/dom/EventQueue.cpp:46 > > + m_enqueuedEvents.clear(); > > No reason to do this. Removed. > > WebCore/dom/EventQueue.cpp:63 > > + if (m_nodesWithEnqueuedScrollEvents.contains(target.get())) > > + return; > > + > > + m_nodesWithEnqueuedScrollEvents.add(target.get()); > > This does two hash lookups, and you only need to do one. Like this: > > if (!m_nodesWithEnqueuedScrollEvents.add(target.get()).second) > return; > > That does the same thing with just one hash lookup. Changed. > > WebCore/dom/EventQueue.cpp:66 > > + enqueueEvent(scrollEvent); > > Should be scrollEvent.release(). Changed. > > WebCore/dom/EventQueue.cpp:77 > > + EventIterator end = enqueuedEvents.end(); > > + for (EventIterator it = enqueuedEvents.begin(); it != end; ++it) > > + dispatchEvent(*it); > > There’s no need to use iterators to walk through a vector. A for look using size_t and indices works just fine and reads more clearly. Iterators are fine if it’s an abstract algorithm, but no need for an iterator just for a vector. > > Instead of *it this would be better if it was it->release() or if you fix the iteration enqueuedEvents[i].release(). Switched to using indices for the loop. > > WebCore/dom/EventQueue.cpp:85 > > + if (eventNames().scrollEvent == event->type()) > > + m_nodesWithEnqueuedScrollEvents.remove(eventTarget); > > No need to check the type. We could just always call this remove function. I switched to a m_nodesWithEnqueuedScrollEvents.clear() call in pendingEventTimerFired. > > WebCore/dom/EventQueue.cpp:91 > > + if (eventTarget->isDocumentNode()) > > + eventTarget->document()->dispatchWindowEvent(event); > > Why? Are all event targeted at the document window events? Can’t a document ever get a non-window event? Document::pendingEventTimerFired used to call dispatchWindowEvent, I was just replicating that logic. > > WebCore/dom/EventQueue.h:39 > > +struct EnqueuedEvent; > > This doesn’t belong here. Leftover from past versions of the patch, removed. > > WebCore/dom/EventQueue.h:47 > > + void enqueueScrollEvent(PassRefPtr<Node> target, bool canBubble); > > Your patch always passes false for canBubble, so you should remove the argument from this function. It’s always false. You also need a test case to show that it’s correct to have the scroll event not bubble in the one case you’re changing, the event queued in EventHandler::sendScrollEvent. I added fast/events/scroll-event-phase.html, which checks that it doesn't matter which type of event handler is used (which seems like the only thing that could conceivably be affected by this change). > > WebCore/dom/EventQueue.h:54 > > + Vector<RefPtr<Event> > m_enqueuedEvents; > > This should be named m_queuedEvents, not m_enqueuedEvents. Renamed. > > WebCore/dom/EventQueue.h:55 > > + HashSet<Node*> m_nodesWithEnqueuedScrollEvents; > > This should be named m_nodesWithQueuedScrollEvents, not m_nodesWithEnqueuedScrollEvents. Renamed. > > WebCore/dom/Node.h:520 > > + void enqueueScrollEvent(); > > Do we really need this helper? Can’t the client callers with the event queue directly? I’d prefer not to touch the Node class at all; it’s not good to build the scroll event in like this. Removed now that we no longer need the bool param. 309783 29 darin 2010-11-16 09:54:25 -0800 (In reply to comment #28) > That was the case before this patch (since pendingEventTimerFired called dispatchWindowEvent). Should I rename it to enqueueWindowEvent? Sure, I think that’s a clearer name. > > > WebCore/dom/EventQueue.cpp:91 > > > + if (eventTarget->isDocumentNode()) > > > + eventTarget->document()->dispatchWindowEvent(event); > > > > Why? Are all event targeted at the document window events? Can’t a document ever get a non-window event? > > Document::pendingEventTimerFired used to call dispatchWindowEvent, I was just replicating that logic. Sure, but I’m concerned about the factoring. If we can enqueue an event for an arbitrary node, that includes document nodes. Having the underlying machinery assume that any event targeted at the document is a window event is not necessarily correct. I think the function to enqueue a window event should have a different name; if we are going to recognize window events by the fact that their target is the document, then the non-window event queuing needs to be illegal for documents. It needs both documentation and and assertion that the target node is not a document. Later we may find that some events can be queued for the document that are not window events. If that happens we’ll need to figure out some way to accommodate both types in the queue, maybe by storing something in the event or maybe by making the queue store a boolean along with the event in the vector. In the mean time, we need a design and perhaps assertions to catch this in case it happens by mistake. We don’t want a generic event that can go to any node such as a mutation event to turn into a window event because of a programming mistake. > I added fast/events/scroll-event-phase.html, which checks that it doesn't matter which type of event handler is used (which seems like the only thing that could conceivably be affected by this change). Good point. With no ancestors, then it’s not all that visible if canBubble was true or false, since it’s the AT_TARGET phase. But we can also just check the bubbles property of the event inside the handler function. That will show us whether other browsers agree about whether this should have bubbles true. The HTML5 specification or some other specification may also explicitly state how this should work. 309815 30 mihaip 2010-11-16 10:47:43 -0800 (In reply to comment #29) > But we can also just check the bubbles property of the event inside the handler function. That will show us whether other browsers agree about whether this should have bubbles true. The HTML5 specification or some other specification may also explicitly state how this should work. Actually, it's the CSSOM Views spec that covers this (and says that document scroll events should bubble and element ones shouldn't, see comment 22). I added logging of the bubbles property to the test cases at: http://persistent.info/webkit/test-cases/onscroll-async/document.html http://persistent.info/webkit/test-cases/onscroll-async/div.html Gecko and ToT WebKit and Chrome follow the spec (first one bubbles, second one doesn't). Opera doesn't (neither bubbles). IE 8 doesn't implement the W3C event system, so it doesn't have this property, but in IE 9 neither bubbles. For the sake of correctness, I'm going to change the patch to follow the spec. 309854 31 74018 mihaip 2010-11-16 11:51:52 -0800 Created attachment 74018 Patch 309855 32 mihaip 2010-11-16 11:54:41 -0800 (In reply to comment #29) > (In reply to comment #28) > > That was the case before this patch (since pendingEventTimerFired called dispatchWindowEvent). Should I rename it to enqueueWindowEvent? > > Sure, I think that’s a clearer name. Renamed. > > Document::pendingEventTimerFired used to call dispatchWindowEvent, I was just replicating that logic. > > Sure, but I’m concerned about the factoring. > > If we can enqueue an event for an arbitrary node, that includes document nodes. Having the underlying machinery assume that any event targeted at the document is a window event is not necessarily correct. <snip> I changed Document::enqueueWindowEvent to just set the target to domWindow(), since that is its intention. EventQueue::dispatchEvent then checks for this and uses the overloaded DOMWindow::dispatchEvent method (the one that takes a target parameter) that has special behavior. > But we can also just check the bubbles property of the event inside the handler function. That will show us whether other browsers agree about whether this should have bubbles true. The HTML5 specification or some other specification may also explicitly state how this should work. As mentioned above, I added the bubble behavior back, to be compliant with the CSSOM spec. There's now a ScrollEventTargetType enum parameter to EventQueue, which should hopefully be cleaner than a bool parameter. 309871 33 webkit.review.bot 2010-11-16 12:27:42 -0800 Attachment 74018 did not build on chromium: Build output: http://queues.webkit.org/results/6031102 309886 34 74027 mihaip 2010-11-16 12:55:13 -0800 Created attachment 74027 Patch Patch should build on Chromium now 311037 35 74027 rniwa 2010-11-18 12:28:30 -0800 Comment on attachment 74027 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=74027&action=review I'm asking Mihai to separate EventQueue implementation so that I can use it for selectionchange event and async DOM mutation events. > WebCore/dom/EventQueue.cpp:61 > +void EventQueue::enqueueScrollEvent(PassRefPtr<Node> target, ScrollEventTargetType targetType) > +{ > + if (!m_nodesWithQueuedScrollEvents.add(target.get()).second) > + return; > + > + // Per the W3C CSSOM View Module, scroll events fired at the document should bubble, others should not. > + bool canBubble = targetType == ScrollEventDocumentTarget ? true : false; > + RefPtr<Event> scrollEvent = Event::create(eventNames().scrollEvent, canBubble, false /* non cancelleable */); > + scrollEvent->setTarget(target); > + enqueueEvent(scrollEvent.release()); > +} I'm not happy about the fact this very general class (or seemingly so) has a specific function for scroll event. Can we move it to somewhere else? If we didn't have this particular function, we can deploy this class in other nodes where we fire async events such as HTMLMediaElement and get rid of redundantly implemented event queues. 311055 36 darin 2010-11-18 13:14:29 -0800 (In reply to comment #35) > If we didn't have this particular function, we can deploy this class in other nodes where we fire async events such as HTMLMediaElement and get rid of redundantly implemented event queues. This class should not be used per-node. We either want a global queue, or a per-document queue. I don’t think we have a reason to have a separate queue for each node. 311282 37 mihaip 2010-11-18 21:14:57 -0800 (In reply to comment #36) > (In reply to comment #35) > > If we didn't have this particular function, we can deploy this class in other nodes where we fire async events such as HTMLMediaElement and get rid of redundantly implemented event queues. > > This class should not be used per-node. We either want a global queue, or a per-document queue. I don’t think we have a reason to have a separate queue for each node. Right, if we keep the per-document queue then then enqueueScrollEvent (and other simialar convenience methods that may be needed from multiple call sites) can stay on EventQueue. HTMLMediaElement can use enqueueEvent directly. 311447 38 ojan 2010-11-19 07:19:21 -0800 (In reply to comment #37) > (In reply to comment #36) > > This class should not be used per-node. We either want a global queue, or a per-document queue. I don’t think we have a reason to have a separate queue for each node. > > Right, if we keep the per-document queue then then enqueueScrollEvent (and other simialar convenience methods that may be needed from multiple call sites) can stay on EventQueue. HTMLMediaElement can use enqueueEvent directly. Is there a problem with using a global queue? A global queue has the advantage that it will preserve order across documents, which could be a compatibility problem when we try to make mutationevents async. 311535 39 darin 2010-11-19 09:59:57 -0800 (In reply to comment #38) > Is there a problem with using a global queue? A global queue has the advantage that it will preserve order across documents, which could be a compatibility problem when we try to make mutationevents async. The “problem” with any of these queues is that there are times when a queued event is no longer appropriate to deliver because the object it was going to be sent to is no longer in a position to receive events. We have not figured out exactly what those times are yet, which leaves me unable to be sure a patch is correct. Once we figure out the issues with the lifetime of the events, we can figure out how to structure the queue. Having a single global ordering is one thing we probably want; we may have other requirements, like a way to efficiently remove all events associated with a given node or with all nodes in a document. Once we understand those requirements we can choose the right data structure. 322291 40 76581 mihaip 2010-12-14 15:30:40 -0800 Created attachment 76581 Patch 322293 41 mihaip 2010-12-14 15:32:41 -0800 Updated the patch now that the EventQueue class has landed separately with r74062. Regarding concerns from comments 38 and 39, mutation events ended up using a scoping object to delay dispatch (but still did it synchronously), so that should no longer be a concern. 330280 42 mihaip 2011-01-06 12:05:16 -0800 Darin (or Ryosuke, now that you're a reviewer), mind looking at this again? 332066 43 78475 mihaip 2011-01-10 17:10:38 -0800 Created attachment 78475 Patch 332067 44 mihaip 2011-01-10 17:11:22 -0800 (rebaselined patch for the Source/WebCore move) 332507 45 78475 fishd 2011-01-11 11:53:43 -0800 Comment on attachment 78475 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=78475&action=review > LayoutTests/fast/events/fire-scroll-event.html:34 > + testFailed('Scroll event fired synchronously'); nit: indent by 4 spaces > LayoutTests/fast/events/remove-child-onscroll.html:19 > + this.removeChild(this.firstChild) nit: indent by 4 spaces > Source/WebCore/dom/EventQueue.cpp:57 > + bool canBubble = targetType == ScrollEventDocumentTarget ? true : false; nit: can be written without the ?: operator. bool canBubble = targetType == ScrollEventDocumentTarget; 332568 46 mihaip 2011-01-11 12:41:20 -0800 (In reply to comment #45) > > LayoutTests/fast/events/fire-scroll-event.html:34 > > + testFailed('Scroll event fired synchronously'); > > nit: indent by 4 spaces Fixed. > > LayoutTests/fast/events/remove-child-onscroll.html:19 > > + this.removeChild(this.firstChild) > > nit: indent by 4 spaces Fixed. > > Source/WebCore/dom/EventQueue.cpp:57 > > + bool canBubble = targetType == ScrollEventDocumentTarget ? true : false; > > nit: can be written without the ?: operator. Fixed. 332570 47 78582 mihaip 2011-01-11 12:41:38 -0800 Created attachment 78582 Patch for landing 332681 48 78582 commit-queue 2011-01-11 14:47:30 -0800 Comment on attachment 78582 Patch for landing Clearing flags on attachment: 78582 Committed r75555: <http://trac.webkit.org/changeset/75555> 332682 49 commit-queue 2011-01-11 14:47:41 -0800 All reviewed patches have been landed. Closing bug. 421572 50 simon.fraser 2011-06-15 14:26:20 -0700 This changed fast/events/remove-child-onscroll.html to assume that scroll events are async; it does the scroll before the listener gets registered. 67356 2010-09-12 21:29:07 -0700 2010-09-12 21:29:07 -0700 test for behaviour change 2) scrolltop-synchronicity.html text/html 1620 mikelawther 77u/PGh0bWw+IA0KPHNjcmlwdD4gDQpmdW5jdGlvbiBydW5UZXN0KCkgew0KICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQogICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKTsNCiAgICANCiAgICB2YXIgZGl2ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo J2NvbnRhaW5lcicpOw0KDQogICAgZGl2LnNjcm9sbEJ5TGluZXMoMSk7DQogICAgaWYgKGRpdi5z Y3JvbGxUb3AgIT0gMCkgDQogICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQn KS5pbm5lckhUTUwgPSAiU1VDQ0VTUyI7DQogICAgZWxzZQ0KICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gIkZBSUwiOw0KICAgICAgDQogICAgLy8g RG9uJ3QgcG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25zZW5zZS4gICAgDQogICAgZGl2 LmlubmVySFRNTCA9ICcnOyAgICANCn0NCg0KPC9zY3JpcHQ+IA0KPGJvZHk+DQo8ZGl2PiANCiAg ICBUaGlzIHRlc3RzIHRoZSBzeW5jaHJvbmljaXR5IG9mIHNjcm9sbEJ5TGluZXMuDQo8L2Rpdj4g DQo8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJ3aWR0aDoxMDBweDsgaGVpZ2h0OjIwMHB4O292 ZXJmbG93OnNjcm9sbCI+IA0KICAgIFF1aXNxdWUgcmhvbmN1cywgbmliaCBxdWlzIGNvbmRpbWVu dHVtIG1hbGVzdWFkYSwgdG9ydG9yIGRvbG9yIGNvbnNlcXVhdCB0dXJwaXMsIHNpdCBhbWV0IGxh Y2luaWEgbGFjdXMgbWFzc2EgZXQgbnVsbGEuIEluIHZvbHV0cGF0LCBtZXR1cyBzZWQgaW50ZXJk dW0gdGVtcHVzLCBkaWFtIG1pIHNjZWxlcmlzcXVlIGFudGUsIGEgaW1wZXJkaWV0IG51bmMgcHVy dXMgc2l0IGFtZXQgc2FwaWVuLiBOYW0gYWMgbmlzbCBub24gaXBzdW0gaGVuZHJlcml0IG9ybmFy ZS4gTWF1cmlzIHZlc3RpYnVsdW0uIEV0aWFtIHV0IHNhcGllbi4gTnVuYyBpbiBuZXF1ZS4gTWFl Y2VuYXMgZGljdHVtIGN1cnN1cyBpcHN1bS4gRnVzY2UgZWxpdCBlc3QsIGZldWdpYXQgaW4sIGFj Y3Vtc2FuIGFsaXF1ZXQsIGdyYXZpZGEgZXUsIHR1cnBpcy4gQ3VyYWJpdHVyIHNpdCBhbWV0IHR1 cnBpcyB2aXRhZSBlcmF0IGZhY2lsaXNpcyBoZW5kcmVyaXQuIEZ1c2NlIHF1YW0gbWF1cmlzLCBv cm5hcmUgbm9uLCB1bHRyaWNlcyB1dCwgc29kYWxlcyBhLCBwZWRlLiBOdW5jIGJsYW5kaXQgdGVt cHVzIHBlZGUuIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ZXIgYWRpcGlz Y2luZyBlbGl0LiBTZWQgYXJjdSBwZWRlLCB0aW5jaWR1bnQgdXQsIGxhY2luaWEgaWQsIGlhY3Vs aXMgcGVsbGVudGVzcXVlLCBsZWN0dXMuIEZ1c2NlIHNhcGllbiBuaXNsLCBkYXBpYnVzIGFjLCB2 ZW5lbmF0aXMgYXQsIGFjY3Vtc2FuIGV1LCBtaS4gRHVpcyB2ZWhpY3VsYSB0aW5jaWR1bnQgcXVh bS4gTnVsbGFtIGVsZWlmZW5kLiBEb25lYyBuZWMgZGlhbS4gRXRpYW0gc2FwaWVuIG1hdXJpcywg YmliZW5kdW0gbm9uLCBwb3J0dGl0b3IgZXUsIHZhcml1cyBpbnRlcmR1bSwgdGVsbHVzLg0KPC9k aXY+IA0KIA0KPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4gDQo8L2JvZHk+DQo8c2NyaXB0PnJ1blRl c3QoKTs8L3NjcmlwdD4NCjwvaHRtbD4g 67357 2010-09-12 21:29:44 -0700 2010-09-12 21:29:44 -0700 test for behaviour change 1) scroll-event-synchronicity.html text/html 1584 mikelawther 77u/PGh0bWw+IA0KPHNjcmlwdD4gDQpmdW5jdGlvbiBkaXZTY3JvbGxlZCgpIHsNCiAgICBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1MnOyANCn0N CiANCmZ1bmN0aW9uIHJ1blRlc3QoKSB7DQogICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikgew0KICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQogICAg fQ0KICAgIA0KICAgIHZhciBkaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVy Jyk7DQogIA0KICAgIGRpdi5vbnNjcm9sbCA9IGRpdlNjcm9sbGVkOw0KICAgIGRpdi5zY3JvbGxC eUxpbmVzKDEpOw0KICAgIA0KICAgIC8vIERvbid0IHBvbGx1dGUgdGhlIHRlc3QgcmVzdWx0IHdp dGggbm9uc2Vuc2UuDQogICAgZGl2LmlubmVySFRNTCA9ICcnOyAgICANCn0NCiANCjwvc2NyaXB0 PiANCjxib2R5IG9ubG9hZD0icnVuVGVzdCgpIj4gDQo8ZGl2PiANCiAgICBUaGlzIHRlc3RzIHRo YXQgdGhlIHNjcm9sbCBldmVudCBpcyBmaXJlZCBzeW5jaHJvbm91c2x5Lg0KPC9kaXY+IA0KPGRp diBpZD0iY29udGFpbmVyIiBzdHlsZT0id2lkdGg6MTAwcHg7IGhlaWdodDoyMDBweDtvdmVyZmxv dzpzY3JvbGwiPiANCiAgICBRdWlzcXVlIHJob25jdXMsIG5pYmggcXVpcyBjb25kaW1lbnR1bSBt YWxlc3VhZGEsIHRvcnRvciBkb2xvciBjb25zZXF1YXQgdHVycGlzLCBzaXQgYW1ldCBsYWNpbmlh IGxhY3VzIG1hc3NhIGV0IG51bGxhLiBJbiB2b2x1dHBhdCwgbWV0dXMgc2VkIGludGVyZHVtIHRl bXB1cywgZGlhbSBtaSBzY2VsZXJpc3F1ZSBhbnRlLCBhIGltcGVyZGlldCBudW5jIHB1cnVzIHNp dCBhbWV0IHNhcGllbi4gTmFtIGFjIG5pc2wgbm9uIGlwc3VtIGhlbmRyZXJpdCBvcm5hcmUuIE1h dXJpcyB2ZXN0aWJ1bHVtLiBFdGlhbSB1dCBzYXBpZW4uIE51bmMgaW4gbmVxdWUuIE1hZWNlbmFz IGRpY3R1bSBjdXJzdXMgaXBzdW0uIEZ1c2NlIGVsaXQgZXN0LCBmZXVnaWF0IGluLCBhY2N1bXNh biBhbGlxdWV0LCBncmF2aWRhIGV1LCB0dXJwaXMuIEN1cmFiaXR1ciBzaXQgYW1ldCB0dXJwaXMg dml0YWUgZXJhdCBmYWNpbGlzaXMgaGVuZHJlcml0LiBGdXNjZSBxdWFtIG1hdXJpcywgb3JuYXJl IG5vbiwgdWx0cmljZXMgdXQsIHNvZGFsZXMgYSwgcGVkZS4gTnVuYyBibGFuZGl0IHRlbXB1cyBw ZWRlLiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dWVyIGFkaXBpc2Npbmcg ZWxpdC4gU2VkIGFyY3UgcGVkZSwgdGluY2lkdW50IHV0LCBsYWNpbmlhIGlkLCBpYWN1bGlzIHBl bGxlbnRlc3F1ZSwgbGVjdHVzLiBGdXNjZSBzYXBpZW4gbmlzbCwgZGFwaWJ1cyBhYywgdmVuZW5h dGlzIGF0LCBhY2N1bXNhbiBldSwgbWkuIER1aXMgdmVoaWN1bGEgdGluY2lkdW50IHF1YW0uIE51 bGxhbSBlbGVpZmVuZC4gRG9uZWMgbmVjIGRpYW0uIEV0aWFtIHNhcGllbiBtYXVyaXMsIGJpYmVu ZHVtIG5vbiwgcG9ydHRpdG9yIGV1LCB2YXJpdXMgaW50ZXJkdW0sIHRlbGx1cy4NCjwvZGl2PiAN CiANCjxkaXYgaWQ9InJlc3VsdCI+RkFJTFVSRTwvZGl2PiANCjwvaHRtbD4g 73328 2010-11-08 18:21:38 -0800 2010-11-15 13:30:35 -0800 Patch bug-45631-20101108182136.patch text/plain 38574 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3MjJkNGMwODkwZTY2MzQwMGE3YjA0YTU0YTQwYTAxNTUxOWE5N2YzLi41MjRkOTVm MTUzMjQ5NjdlZTRhZjYwNjdhMjE5YmZkMDRmY2I1YjI4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAK KzIwMTAtMTEtMDggIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuIEFkZGl0aW9uYWxseSwgZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbCBub3cgCisgICAgICAgIGV4cGxpY2l0bHkgdGVzdHMgZm9yIHN5bmNocm9ub3Vz IGJlaGF2aW9yIHdoZW4gc2Nyb2xsaW5nIHRoZSBkb2N1bWVudCwKKyAgICAgICAgYW5kIHRoYXQg d2UgZG9uJ3QgZmlyZSB0aGUgZXZlbnQgbW9yZSB0aGFuIG9uY2UuCisgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBkb2VzIHRoZSBzYW1lIGZvciBzY3Jv bGwKKyAgICAgICAgZXZlbnRzIG9uIHNjcm9sbGFibGUgZWxlbWVudHMuCisKKyAgICAgICAgKiBl ZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFz dC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBm cm9tIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sOgorICAg ICAgICAqIGZhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sOgorICAgICAgICAq IGZhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbDoKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWw6CisgICAgICAgICog ZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sOgorICAgICAgICAqIGZh c3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sOgorICAgICAgICAq IGZhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbDoKKwogMjAxMC0xMS0wNSAg TWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5w dXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQKaW5kZXggMjRkZWU0ZDg4 OGRiMWRhYjQ2ODBjMzA2ZjgyYjY0YmY2MjYzZDY2NC4uYjViMGNmMGY1NDZjMmU0MWVlMWM3ODRj MDVjYWIyMzcwNGFiOTZiNSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9w YWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGlu Zy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQKQEAgLTEsNCArMSw0IEBA CiB4eAotVGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBv bmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Ny b2xsIGV2ZW50LiBUaGlzIHRlc3QgcmVxdWlyZXMgRFJUIHRvIHBhc3MuCitUaGlzIHRlc3Qgc2lt dWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlw cmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIElmIHJ1bm5p bmcgbWFudWFsbHksIHByZXNzIHRoZSBrZXlzIG5vdy4KIFBBU1MKIChqdXN0IGhlcmUgdG8gZm9y Y2Ugc2Nyb2xsYmFycykKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFn ZS11cC1kb3duLXNjcm9sbHMuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11 cC1kb3duLXNjcm9sbHMuaHRtbAppbmRleCBmYzgzYjE0ODIzZDJlZDcwZGIzMjUwMDg5NWIxNGNj YjNiYTk3MWU3Li5lNWJhYmM3ZGIwY2JiMGRhMjI3YzFjOTM4NmZkOWY0OWI0NmJhMjVkIDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0 bWwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5o dG1sCkBAIC0yLDM4ICsyLDQxIEBACiA8aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KLWlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KSB7CiAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIGxheW91dFRl c3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK30KIAotZnVuY3Rpb24gc2NyKCkKLXsKK3Zh ciBzdGVwID0gMDsKKworb25zY3JvbGwgPSBmdW5jdGlvbigpIHsKICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnbG9nJykuaW5uZXJUZXh0ICs9ICd4JzsKKworICAgIHN3aXRjaCAoc3RlcCkg eworICAgIGNhc2UgMDoKKyAgICAgICAgaWYgKHdpbmRvdy5ldmVudFNlbmRlcikKKyAgICAgICAg ICAgIGV2ZW50U2VuZGVyLmtleURvd24oJ3BhZ2VVcCcpOworICAgICAgICAgICAgYnJlYWs7Cisg ICAgY2FzZSAxOgorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0cycpLmlu bmVyVGV4dCA9ICdQQVNTJzsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAg ICAgYnJlYWs7CisgICAgfQorICAgIAorICAgIHN0ZXArKzsKIH0KIAogZnVuY3Rpb24gcnVuVGVz dCgpCiB7Ci0gICAgaWYgKCF3aW5kb3cuZXZlbnRTZW5kZXIpCi0gICAgICAgIHJldHVybjsKLQot ICAgIHdpbmRvdy5hZGRFdmVudExpc3RlbmVyKCdzY3JvbGwnLCBzY3IsIGZhbHNlKTsKLQotICAg IGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIik7Ci0gICAgdmFyIHRleHQgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnbG9nJykuaW5uZXJUZXh0OwotICAgIGlmICh0ZXh0ICE9ICJ4IikK LSAgICAgICAgdGhyb3cgImxvZyBzaG91bGQgY29udGFpbiB4LCBub3QgIiArIHRleHQ7Ci0KLSAg ICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlVXAiKTsKLSAgICB2YXIgdGV4dCA9IGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQ7Ci0gICAgaWYgKHRleHQgIT0gInh4IikK LSAgICAgICAgdGhyb3cgImxvZyBzaG91bGQgY29udGFpbiB4eCwgbm90ICIgKyB0ZXh0OwotCi0g ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7 CisgICAgaWYgKHdpbmRvdy5ldmVudFNlbmRlcikKKyAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93 bigncGFnZURvd24nKTsKIH0KIDwvc2NyaXB0PgogPC9oZWFkPgogPGJvZHkgb25sb2FkPSJydW5U ZXN0KCkiPiAKIDxzcGFuIGlkPSJsb2ciIHN0eWxlPSJwb3NpdGlvbjpmaXhlZCI+PC9zcGFuPiAK LTxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBv bmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Ny b2xsIGV2ZW50LiBUaGlzIHRlc3QgcmVxdWlyZXMgRFJUIHRvIHBhc3MuPC9kaXY+Cis8ZGl2PlRo aXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25jZSBlYWNo LiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9sbCBldmVu dC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMgbm93LjwvZGl2PgogPGRpdiBp ZD0icmVzdWx0cyI+RkFJTDwvZGl2PgogPGRpdiBzdHlsZT0iaGVpZ2h0OjUwMDAwcHgiPihqdXN0 IGhlcmUgdG8gZm9yY2Ugc2Nyb2xsYmFycyk8L2Rpdj4gCiA8c2NyaXB0PiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVu dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTFhMmUyMmY2OTBiNWZiMjdkYTkzM2EwODU0NGRj Y2U5ZjIwZWVhOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2Zp cmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorUEFT U0VELCBzY3JvbGwgcG9zaXRpb246ICgwLCAyMDApCitJZiB0aGUgd29yZCAnUEFTU0VEJyBkb2Vz IG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3Qg ZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLCBmaXJlZCBz eW5jaHJvbm91c2x5LCBvciBmaXJlZCBtb3JlIHRoYW4gb25jZS4KKworCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uYWNkNjZlMTRkNjRlYjgxZWQ1MjVkYzk5YTdlNTQ0MzU4MGFlM2I4YQotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVs ZW1lbnQuaHRtbApAQCAtMCwwICsxLDUyIEBACis8aHRtbD4KKzxzY3JpcHQ+Cit2YXIgZXZlbnRD b3VudCA9IDA7Cit2YXIgZG9uZVRpbWVvdXQ7CisKK2Z1bmN0aW9uIHNjcm9sbEhhbmRsZXIoKQor eworICAgIGV2ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAg IHZhciBjb250YWluZXIgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVyJyk7Cisg ICAgICAgIHZhciBzY3JvbGxYID0gY29udGFpbmVyLnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBz Y3JvbGxZID0gY29udGFpbmVyLnNjcm9sbFRvcDsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoJ3Jlc3VsdCcpLnRleHRDb250ZW50ID0gJ1BBU1NFRCwgc2Nyb2xsIHBvc2l0aW9uOiAo JyArIHNjcm9sbFggKyAnLCAnICsgc2Nyb2xsWSArICcpJzsKKyAgICAgICAgLy8gRG9uJ3QgY2Fs bCBub3RpZnlEb25lIHN0cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9s bCBldmVudCBjb21pbmcuCisgICAgICAgIGRvbmVUaW1lb3V0ID0gc2V0VGltZW91dChmdW5jdGlv bigpIHsKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAg ICAgfSwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBjbGVhclRpbWVvdXQoZG9uZVRpbWVv dXQpOworICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRl bnQgPSAnRkFJTCwgc2Nyb2xsIGhhbmRsZXIgd2FzIGludm9rZWQgJyArIGV2ZW50Q291bnQgKyAn IHRpbWVzJzsKKyAgICB9Cit9CisKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB2YXIgY29u dGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAgIGNvbnRh aW5lci5hZGRFdmVudExpc3RlbmVyKCdzY3JvbGwnLCBzY3JvbGxIYW5kbGVyLCBmYWxzZSk7Cisg ICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsKKyAgICB9CisgICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDEwMDsKKyAg ICBpZiAoZXZlbnRDb3VudCA+IDApIHsKKyAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdy ZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTEVELCBldmVudCBmaXJlZCBzeW5jaHJvbm91c2x5Lic7 ICAgICAgCisgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAg IGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsgICAgICAKKyAgICB9CisgICAgY29u dGFpbmVyLnNjcm9sbFRvcCA9IDIwMDsKK30KKworPC9zY3JpcHQ+Cis8Ym9keT4KKzxkaXYgaWQ9 InJlc3VsdCI+RkFJTCwgZXZlbnQgZGlkIG5vdCBmaXJlPC9kaXY+CisKKzxwPklmIHRoZSB3b3Jk ICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVk LiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90 IGZpcmUsIGZpcmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLjwvcD4K KworPGRpdiBpZD0iY29udGFpbmVyIiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiA1MDBw eDsgaGVpZ2h0OiA1MDBweCI+CisgIDxkaXYgc3R5bGU9ImhlaWdodDogNTAwMHB4OyB3aWR0aDog NTAwMHB4OyI+PC9kaXY+Cis8L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0 IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1leHBlY3RlZC50eHQKaW5kZXggMTY4NmNlZDM5YWUyYmUyZDU5YjYzZTlkM2Zk YWU0YjFlMmM4ODY1Ni4uMTBmOGU0MzkwMmJkMTg0NmFkZDIyNWRlNmMyZTgwMGFmYTUxMmU2MyAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhw ZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWV4cGVjdGVkLnR4dApAQCAtMSw1OSArMSw0IEBACi1QQVNTRUQKK1BBU1NFRCwgc2Nyb2xsIHBv c2l0aW9uOiAoMjAwLCAyMDApCitJZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIg YWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1l YW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLCBmaXJlZCBzeW5jaHJvbm91c2x5 LCBvciBmaXJlZCBtb3JlIHRoYW4gb25jZS4KIAotSWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBu b3QgYXBwZWFyIGFib3ZlLCB0aGVuIHRoZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZh aWxzLCBpdCBtZWFucyB0aGF0IGEgc2Nyb2xsIGV2ZW50IGRpZCBub3QgZmlyZS4KLQotYQotYQot YQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQot YQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQot YQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQogCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbAppbmRleCBhMDU2YzA2N2JkOWYy N2M0YjM0NjVjODRhMTZlMjFhOWZhM2U3MTRjLi43Y2QwYTU2ZDBhODQwMzUxYTI0ODdkZTgzZGU3 NDI4ZTI4YTAwMDE0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xs LWV2ZW50Lmh0bWwKQEAgLTEsMzAgKzEsNDcgQEAKIDxodG1sPgogPHNjcmlwdD4KLXZhciBldmVu dEZpcmVkID0gZmFsc2U7Cit2YXIgZXZlbnRDb3VudCA9IDA7Cit2YXIgZG9uZVRpbWVvdXQ7CiAK LWZ1bmN0aW9uIHNjcm9sbGVyKCkgewotICAgIGlmICghZXZlbnRGaXJlZCkgewotICAgICAgICBl dmVudEZpcmVkID0gdHJ1ZTsKLSAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhc3Nl ZCIpLmlubmVySFRNTCA9ICI8cCBzdHlsZT0nY29sb3I6cmVkJz5QQVNTRUQ8L3A+IjsKK29uc2Ny b2xsID0gZnVuY3Rpb24oKQoreworICAgIGV2ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3Vu dCA9PSAxKSB7CisgICAgICAgIHZhciBzY3JvbGxYID0gZG9jdW1lbnQuYm9keS5zY3JvbGxMZWZ0 OworICAgICAgICB2YXIgc2Nyb2xsWSA9IGRvY3VtZW50LmJvZHkuc2Nyb2xsVG9wOworICAgICAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnUEFTU0VE LCBzY3JvbGwgcG9zaXRpb246ICgnICsgc2Nyb2xsWCArICcsICcgKyBzY3JvbGxZICsgJyknOwor ICAgICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0 aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQg PSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3Rp ZnlEb25lKCk7CisgICAgICAgICAgICB9LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNs ZWFyVGltZW91dChkb25lVGltZW91dCk7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdyZXN1bHQnKS50ZXh0Q29udGVudCA9ICdGQUlMLCBzY3JvbGwgaGFuZGxlciB3YXMgaW52b2tl ZCAnICsgZXZlbnRDb3VudCArICcgdGltZXMnOwogICAgIH0KIH0KIAotd2luZG93Lm9ubG9hZCA9 IGZ1bmN0aW9uKCkgewotICAgIHdpbmRvdy5hZGRFdmVudExpc3RlbmVyKCdzY3JvbGwnLCBzY3Jv bGxlciwgZmFsc2UpOwotICAgIHdpbmRvdy5zY3JvbGxUbyg1MDAsIDUwMCk7CitvbmxvYWQgPSBm dW5jdGlvbigpCit7CiAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKICAgICB9CisgICAgd2luZG93LnNjcm9sbFRv KDEwMCwgMTAwKTsKKyAgICBpZiAoZXZlbnRDb3VudCA+IDApIHsKKyAgICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTEVELCBldmVudCBmaXJlZCBz eW5jaHJvbm91c2x5Lic7ICAgICAgCisgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKQorICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsgICAgICAK KyAgICB9CisgICAgd2luZG93LnNjcm9sbFRvKDIwMCwgMjAwKTsKIH0KIAogPC9zY3JpcHQ+CiA8 Ym9keT4KLTxkaXYgaWQ9InBhc3NlZCI+PC9kaXY+Cis8ZGl2IGlkPSJyZXN1bHQiPkZBSUwsIGV2 ZW50IGRpZCBub3QgZmlyZTwvZGl2PgogCi08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5v dCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFp bHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KKzxwPklm IHRoZSB3b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBo YXMgZmFpbGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVu dCBkaWQgbm90IGZpcmUsIGZpcmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBv bmNlLjwvcD4KIAotYTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PgorPGRpdiBzdHlsZT0iaGVpZ2h0OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KIDwv Ym9keT4KIDwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9yZW1vdmUtY2hpbGQtb25zY3JvbGwuaHRtbCBiL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sCmluZGV4IDI1MmNm ZWEzMzBmZTUwMjI3OGQzNmVmMThlMDcxZmNiMzY1NGNjMzUuLmVhYmIwNzllYWNhYTc5Yjg4ZTBm MGFhZGE3MDE5NWRlMzhiMzYzYjggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sCkBAIC05LDE3ICs5LDI4IEBACiAgICAgICAgICAg ICBmdW5jdGlvbiBkaXNwYXRjaFNjcm9sbEV2ZW50cygpCiAgICAgICAgICAgICB7CiAgICAgICAg ICAgICAgICAgaWYgKHdpbmRvdy5ldmVudFNlbmRlciAmJiB3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVu dGlsRG9uZSgpOwogICAgICAgICAgICAgICAgICAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbygx MDAsIDEwMCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnko MCwgLTEpOwotICAgICAgICAgICAgICAgICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0x LCAtMSk7Ci0gICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKKyAgICAgICAgICAgICAgICAgICAgdmFyIHNjcm9sbENvdW50ID0gMDsKKyAgICAgICAg ICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2R2JykuYWRkRXZlbnRMaXN0ZW5l cigKKyAgICAgICAgICAgICAgICAgICAgICAgICdzY3JvbGwnLAorICAgICAgICAgICAgICAgICAg ICAgICAgZnVuY3Rpb24oZXZlbnQpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5y ZW1vdmVDaGlsZCh0aGlzLmZpcnN0Q2hpbGQpCisgICAgICAgICAgICAgICAgICAgICAgICAgIHNj cm9sbENvdW50Kys7CisgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChzY3JvbGxDb3VudCA9 PSAxKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5kZXIubW91c2VTY3Jv bGxCeSgtMSwgLTEpOworICAgICAgICAgICAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cisg ICAgICAgICAgICAgICAgICAgICAgICB9LAorICAgICAgICAgICAgICAgICAgICAgICAgZmFsc2Up OwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH0KICAgICAgICAgPC9zY3JpcHQ+CiAg ICAgPC9oZWFkPgogICAgIDxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgnZGlzcGF0Y2hTY3JvbGxF dmVudHMoKTsnLCAxKTsiPgogICAgICAgICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBjaGlsZHJl biBjYW4gYmUgcmVtb3ZlZCBieSB0aGVpciBwYXJlbnQgZWxlbWVudCdzIG9uc2Nyb2xsIGV2ZW50 IGhhbmRsZXIuICBUaGUgdGVzdCBzdWNjZWVkcyBpZiB0aGlzIGlzIHRoZSBvbmx5IHRleHQgcmVt YWluaW5nIGFmdGVyIHRoZSB0d28gc2Nyb2xsIGV2ZW50cyBhcmUgZGlzcGF0Y2hlZC4gIFRoZSB0 ZXN0IGZhaWxzIGlmIHRoZSBpbm5lciBkaXYgcmVtYWlucyBpbiB0aGUgb3V0cHV0IG9yIGlmIFdl YktpdCBjcmFzaGVzLjxicj48YnI+Ci0gICAgICAgIDxkaXYgaWQ9ImR2IiBzdHlsZT0ib3ZlcmZs b3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAyMDBweDsgd2hpdGVzcGFjZTogbm93cmFw OyIgb25zY3JvbGw9InRoaXMucmVtb3ZlQ2hpbGQodGhpcy5maXJzdENoaWxkKSI+CisgICAgICAg IDxkaXYgaWQ9ImR2IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0 OiAyMDBweDsgd2hpdGVzcGFjZTogbm93cmFwOyI+CiAgICAgICAgIDxkaXYgc3R5bGU9IndpZHRo OjMwMHB4OyBoZWlnaHQ6MzAwcHgiPkxvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0 ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1 dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4gVXQgZW5pbSBhZCBtaW5pbSB2ZW5pYW0s IHF1aXMgbm9zdHJ1ZCBleGVyY2l0YXRpb24gdWxsYW1jbyBsYWJvcmlzIG5pc2kgdXQgYWxpcXVp cCBleCBlYSBjb21tb2RvIGNvbnNlcXVhdC4gRHVpcyBhdXRlIGlydXJlIGRvbG9yIGluIHJlcHJl aGVuZGVyaXQgaW4gdm9sdXB0YXRlIHZlbGl0IGVzc2UgY2lsbHVtIGRvbG9yZSBldSBmdWdpYXQg bnVsbGEgcGFyaWF0dXIuIEV4Y2VwdGV1ciBzaW50IG9jY2FlY2F0IGN1cGlkYXRhdCBub24gcHJv aWRlbnQsIHN1bnQgaW4gY3VscGEgcXVpIG9mZmljaWEgZGVzZXJ1bnQgbW9sbGl0IGFuaW0gaWQg ZXN0IGxhYm9ydW0KICAgICAgICAgPC9kaXY+CiAgICAgICAgIDwvZGl2PgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sCmlu ZGV4IDRmYzE1Mjg0ZGVmMWY1OGQ5MzczNWZhY2FkZTRhNTZkNzEwZDUxZmUuLmFlMTJhNzllNTNi ZjY4NDBmODI1MzNhY2IwNDQyYTkyY2U3MjcxZmYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwKQEAgLTE2LDYgKzE2 LDkgQEAKICAgICBmdW5jdGlvbiBzY3JvbGxlZChldmVudCkKICAgICB7CiAgICAgICAgIGV2ZW50 LnRhcmdldC5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKGV2ZW50LnRhcmdldCk7CisgICAgICAgIGlm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIGZ1bmN0aW9u IHRlc3QoKQpAQCAtMjcsNyArMzAsOSBAQAogICAgICAgICBkb2N1bWVudC5ib2R5LnN0eWxlLnpv b20gPSAyOwogICAgIH0KIAotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisg ICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndh aXRVbnRpbERvbmUoKTsKKyAgICB9CiAgICAgdGVzdCgpOwogPC9zY3JpcHQ+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxl Lmh0bWwKaW5kZXggMjIyYWRhODA1ZGE1MzA2MjJlNGY4MWY1YmRjZWYzYTcxYWMzNjAwMC4uMWU4 NTExM2Y3NzQzM2RlOGFiZWU2ZjM2NzE1MWU1MjAzZTJlZWQ0MCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRt bApAQCAtMSwxMSArMSwyMiBAQAogPGh0bWw+CiA8c2NyaXB0PgordmFyIHdpbmRvd1dhc1Njcm9s bGVkID0gZmFsc2U7Cit2YXIgZG9uZVRpbWVvdXQ7CisKIGZ1bmN0aW9uIHdpbmRvd1Njcm9sbGVk KCkgeworICAgIHdpbmRvd1dhc1Njcm9sbGVkID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ0ZBSUxVUkU6IHdpbmRvdy5vbnNjcm9sbCB3 YXMgY2FsbGVkLic7IAorICAgIGNsZWFyVGltZW91dChkb25lVGltZW91dCk7ICAgIAogfQogCiBm dW5jdGlvbiBkaXZTY3JvbGxlZCgpIHsKLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVz dWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQg d2luZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgaWYgKCF3aW5kb3dXYXNTY3JvbGxlZCkK KyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdT VUNDRVNTOiBkaXYub25zY3JvbGwgd2FzIGNhbGxlZCwgYnV0IHdpbmRvdy5vbnNjcm9sbCB3YXMg bm90Lic7IAorICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBj YXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29taW5nL2J1YmJsaW5nLgorICAgIGRv bmVUaW1lb3V0ID0gc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5v dGlmeURvbmUoKTsKKyAgICAgICAgfSwgMTAwKTsgICAgCiB9CiAKIGZ1bmN0aW9uIHJ1blRlc3Qo KSB7CkBAIC0yNCwxMCArMzUsNiBAQCBmdW5jdGlvbiBydW5UZXN0KCkgewogICAgIAogICAgIC8v IERvbid0IHBvbGx1dGUgdGhlIHRlc3QgcmVzdWx0IHdpdGggbm9uc2Vuc2UuCiAgICAgZGl2Lmlu bmVySFRNTCA9ICcnOwotICAgIAotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIp IAotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ci0gICAgCiB9CiAK IDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1i eS1zY3JvbGwtaGFuZGxlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1i eS1zY3JvbGwtaGFuZGxlci5odG1sCmluZGV4IGJhMWEzNTE2NGM1NmIyYzQxZWEzODBiZWE3NjNl N2U0YTFlNTlmOTguLmQyZjlhYzY0NWU3ZDYxYjQ1MDFiMWIyYjhmNTBmYjY2OTU3N2E1NjIgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRs ZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1o YW5kbGVyLmh0bWwKQEAgLTExLDI5ICsxMSwzMyBAQAogPHA+CiAgICAgUmVzdWx0OiA8c3BhbiBp ZD0icmVzdWx0Ij50ZXN0IGRpZCBub3QgY29tcGxldGUuPC9zcGFuPgogPC9wPgotPGRpdiBpZD0i dCIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBv bnNjcm9sbD0iaWYgKG92ZXJmbG93UmVtb3ZlKSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQo dGhpcyk7Ij4KKzxkaXYgaWQ9InQiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4 OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0 aGlzKTtoYW5kbGVTY3JvbGwoMCk7Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+ PC9kaXY+CiA8L2Rpdj4KIAotPGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBw eDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAoc2Vjb25kT3ZlcmZsb3dSZW1vdmUpIHRo aXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBzdHlsZT0ib3ZlcmZsb3c6 IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBhcmVu dE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7aGFuZGxlU2Nyb2xsKDEpOyI+CiAgICAgPGRpdiBzdHls ZT0iaGVpZ2h0OiAyMDBweDsiPjwvZGl2PgogICAgIDxkaXYgaWQ9ImQiPjwvZGl2PgogPC9kaXY+ CiAKIDxzY3JpcHQ+Ci0gICAgdmFyIG92ZXJmbG93UmVtb3ZlID0gZmFsc2U7Ci0gICAgdmFyIHNl Y29uZE92ZXJmbG93UmVtb3ZlID0gZmFsc2U7CisgICAgdmFyIHNjcm9sbGVkRmlyc3RDb250YWlu ZXIgPSBmYWxzZTsKKyAgICB2YXIgc2Nyb2xsZWRTZWNvbmRDb250YWluZXIgPSBmYWxzZTsKIAog ICAgIGRvY3VtZW50LmJvZHkub2Zmc2V0VG9wOyB0LnNjcm9sbFRvcCA9IDIwOwogCi0gICAgb3Zl cmZsb3dSZW1vdmUgPSB0cnVlOwotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0JykuaW5u ZXJIVE1MID0gJyc7Ci0KLSAgICBzZWNvbmRPdmVyZmxvd1JlbW92ZSA9IHRydWU7CiAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2QnKS5zY3JvbGxJbnRvVmlldygpOwogICAgIAotICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7Ci0K LSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZnVuY3Rpb24gaGFuZGxlU2Nyb2xsKGluZGV4 KQorICAgIHsKKyAgICAgICAgaWYgKGluZGV4ID09IDApIHNjcm9sbGVkRmlyc3RDb250YWluZXIg PSB0cnVlOworICAgICAgICBlbHNlIGlmIChpbmRleCA9PSAxKSBzY3JvbGxlZFNlY29uZENvbnRh aW5lciA9IHRydWU7CisgICAgICAgIAorICAgICAgICBpZiAoc2Nyb2xsZWRGaXJzdENvbnRhaW5l ciAmJiBzY3JvbGxlZFNlY29uZENvbnRhaW5lcikgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4dCA9ICJTVUNDRVNTIjsKKyAgICAgICAgCisg ICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQorICAgIH0K IDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNjcm9s bC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29u c2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAppbmRleCA2NGIyMGFjNGFlZmRjZDU2MTRk MmM0OGMwM2U2Y2QyYTMyMmJkNGRlLi4zNTc0MTJmZTIzZmI2NmM1ZGVjMWRhMDU4YWVhNzUyYmUz NjEwNzhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxh eWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29u c2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbApAQCAtMSwxNCArMSwxNiBAQAogPGhlYWQ+ CiA8c2NyaXB0PgogZnVuY3Rpb24gdGVzdCgpIHsKLSAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfQogICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJpdCIpLnNjcm9sbFRvcCA9IDEwMDsKIH0KIDwvc2NyaXB0PgogPGJvZHkgb25sb2Fk PSJ0ZXN0KCkiPgogPHA+VGhpcyB0ZXN0IGludm9sdmVzIGEgbGF5ZXIgdGhhdCBzZWxmLWRlc3Ry dWN0cyB3aGVuIHNjcm9sbGVkLiBJZiB0aGVyZSdzIG5vIGNyYXNoLCB0aGVuIHRoZSB0ZXN0IHN1 Y2NlZWRlZC48L3A+Ci08ZGl2IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6 IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlzcGxheSA9ICdub25lJyI+Cis8ZGl2IGlkPSJpdCIg c3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlz cGxheSA9ICdub25lJztpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ij4KIDxkaXYgc3R5bGU9ImhlaWdodDogMjAwMHB4OyI+ PC9kaXY+CiA8L2Rpdj4KIDwvYm9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcmVw YWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvcmVwYWlu dC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAppbmRleCBlM2YwYWM0NGMxOWJjYTVkYmRlMTRk MTM4NzNhMGNkNWYwZWU3MjBjLi5kYzY5NzEyMjE2ZjdiNTE2NjBhZTMyMjRiMmNlZWFlNDYxYjE0 NGFhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmct c2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5n LXNjcm9sbC5odG1sCkBAIC0zLDYgKzMsOCBAQAogICAgIDxzY3JpcHQ+CiAgICAgICAgIGZ1bmN0 aW9uIHJlcGFpbnRUZXN0KCkKICAgICAgICAgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53 YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgc2Nyb2xsQnkoMCwgMTAwKTsKICAgICAg ICAgfQpAQCAtMTEsNiArMTMsOCBAQAogICAgICAgICB7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0 ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgdGFyZ2V0 LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICJncmVlbiI7CisgICAgICAgICAgICBpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLm5vdGlmeURvbmUoKTsKICAgICAgICAgfQogICAgIDwvc2NyaXB0PgogPC9oZWFkPgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0ZjJl Yjc3OTYwYzUyMzY2N2QzM2EyNjE2MGZkODhlMzgwMGMxYzQzLi43ZjI2YzUwZmZkMGVkNDIzMTAy N2YzZWEyNTUwMzA4MjNiNzhhOTczIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ0IEBACisyMDEwLTExLTA4ICBNaWhhaSBQ YXJwYXJpdGEgIDxtaWhhaXBAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFNjcm9sbCBldmVudCBzaG91bGQgYmUgZmlyZWQgYXN5 bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTQ1NjMxCisKKyAgICAgICAgVGVzdDogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQt ZWxlbWVudC5odG1sCisgICAgICAgIAorICAgICAgICBNYWtlcyBzY3JvbGwgZXZlbnRzIGZpcmUg YXN5bmNocm9ub3VzbHkgdG8gYmUgaW4gY29tcGxpYW5jZSB3aXRoIHRoZQorICAgICAgICBDU1NP TSBWaWV3IE1vZHVsZSBhbmQgY29uc2lzdGVudCB3aXRoIEdlY2tvLCBPcGVyYSBhbmQgKHRvIHNv bWUgZGVncmVlKQorICAgICAgICBJRS4KKyAgICAgICAgCisgICAgICAgIFRoaXMgaXMgYWNjb21w bGlzaGVkIGJ5IG1vdmluZyB0aGUgRG9jdW1lbnQ6OmVucXVldWVFdmVudCBhbmQgc3VwcG9ydGlu ZworICAgICAgICBjb2RlIHRvIGEgc3RhbmRhbG9uZSBFdmVudFF1ZXVlIGNsYXNzLCBhbiBpbnN0 YW5jZSBvZiB3aGljaCBjYW4gYmUgCisgICAgICAgIGF0dGFjaGVkIHRvIE5vZGUgaW5zdGFuY2Vz IHZpYSBOb2RlUmFyZURhdGEuCisKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2o6CisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkRvY3VtZW50OjpEb2N1bWVudCk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAg ICogZG9tL0V2ZW50UXVldWUuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50UXVl dWU6OkV2ZW50UXVldWUpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2 ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50UXVldWU6OmVucXVldWVFdmVudElmTm90QWxy ZWFkeUVucXVldWVkKToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50UXVldWU6OnBlbmRpbmdFdmVu dFRpbWVyRmlyZWQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRRdWV1ZTo6ZGlzcGF0Y2hFdmVu dCk6CisgICAgICAgICogZG9tL0V2ZW50UXVldWUuaDogQWRkZWQuCisgICAgICAgICogZG9tL05v ZGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6ZW5xdWV1ZUV2ZW50KToKKyAgICAgICAg KFdlYkNvcmU6Ok5vZGU6OmVucXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKToKKyAgICAg ICAgKiBkb20vTm9kZS5oOgorICAgICAgICAqIGRvbS9Ob2RlUmFyZURhdGEuaDoKKyAgICAgICAg KFdlYkNvcmU6Ok5vZGVSYXJlRGF0YTo6ZW5zdXJlRXZlbnRRdWV1ZSk6CisgICAgICAgICogcGFn ZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpzZW5k U2Nyb2xsRXZlbnQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6c2Nyb2xsVG9PZmZzZXQpOgorICAgICAgICAqIHJl bmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckxpc3RC b3g6OnZhbHVlQ2hhbmdlZCk6CisKIDIwMTAtMTEtMDUgIENocmlzIE1hcnJpbiAgPGNtYXJyaW5A YXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEZyYXNlci4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViQ29yZS9X ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZDczNzMxYzBiZDFhZjI3ZDBj YWI3Yzg1ZDVhODhlOGM2Mjk2MzZjZC4uNmFhMzY0MGRkMTE3NjE4OWFhOWE4OTc1MGJkN2JjNGQ1 NWNjYWQ2ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAg LTI2NDAsNiArMjY0MCw4IEBACiAJCThBRjRFNTVDMTFEQzVBNjMwMDBFRDNERSAvKiBUaW1pbmcu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBRjRFNTU5 MTFEQzVBNjMwMDBFRDNERSAvKiBUaW1pbmcuaCAqLzsgfTsKIAkJOEM2RUE2MTkxMUVGN0UwNDAw RkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEM2RUE2MTcxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwICovOyB9OwogCQk4QzZFQTYxQTExRUY3RTA0MDBGRDhF RTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOEM2RUE2MTgxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRpbWVF bmFibGVkRmVhdHVyZXMuaCAqLzsgfTsKKwkJOEY2NzU2MUIxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2 ZW50UXVldWUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDhGNjc1NjE5MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmggKi87IH07CisJCThGNjc1 NjFDMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhGNjc1NjFBMTI4OEIxN0IwMDQ3QUNBMyAvKiBF dmVudFF1ZXVlLmNwcCAqLzsgfTsKIAkJOEZBQzc3NEQxMTk4NzJDQjAwMTVBRTk0IC8qIEpTTWFp blRocmVhZEV4ZWNTdGF0ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA4RjkzNEQ4NDExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0 YXRlLmNwcCAqLzsgfTsKIAkJOTMwMkIwQkQwRDc5RjgyOTAwQzdFRTgzIC8qIFBhZ2VHcm91cC5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzAyQjBC QzBENzlGODI5MDBDN0VFODMgLyogUGFnZUdyb3VwLmNwcCAqLzsgfTsKIAkJOTMwMkIwQkYwRDc5 RjgyQzAwQzdFRTgzIC8qIFBhZ2VHcm91cC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gOTMwMkIwQkUwRDc5RjgyQzAwQzdFRTgzIC8qIFBhZ2VHcm91cC5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC04NzUz LDYgKzg3NTUsOCBAQAogCQk4QUY0RTU1QTExREM1QTYzMDAwRUQzREUgLyogVGltaW5nLmlkbCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQ7IHBhdGggPSBUaW1pbmcuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk4QzZFQTYxNzExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJl cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzLmNwcDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThDNkVBNjE4MTFFRjdFMDQwMEZEOEVFMyAv KiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFt ZSA9IFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJs ZWRGZWF0dXJlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4RjY3NTYxOTEyODhC MTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBFdmVudFF1ZXVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCThGNjc1NjFB MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEV2ZW50UXVldWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk4RjkzNEQ4MzExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4NDExODlGMUVFMDA1MDhENUQg LyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGFnZUdyb3VwLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE4Mzg3LDYgKzE4MzkxLDggQEAKIAkJCQk1NEM1MEY3QTBF ODAxREYzMDA5ODMyQTAgLyogWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCAqLywKIAkJCQk1 RDE1RTNBOTBGOUU2QUMxMDA5RTBFM0YgLyogWE1MRG9jdW1lbnRQYXJzZXJTY29wZS5jcHAgKi8s CiAJCQkJNUQxNUUzQUEwRjlFNkFDMTAwOUUwRTNGIC8qIFhNTERvY3VtZW50UGFyc2VyU2NvcGUu aCAqLywKKwkJCQk4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovLAor CQkJCThGNjc1NjFBMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLywKIAkJCSk7 CiAJCQlwYXRoID0gZG9tOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTIxMzEzLDYg KzIxMzE5LDcgQEAKIAkJCQk2RTY3RDJBOTEyODBFOEJEMDA4NzU4RjcgLyogRXh0ZW5zaW9uczNE LmggaW4gSGVhZGVycyAqLywKIAkJCQk5M0Y2RjFFRTEyN0Y3MEIxMDA1NUNCMDYgLyogV2ViR0xD b250ZXh0RXZlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUI4QTZBNkQ1MTI3QjMzOEQwMDg2NzNC QSAvKiBDb3JyZWN0aW9uUGFuZWxJbmZvLmggaW4gSGVhZGVycyAqLywKKwkJCQk4RjY3NTYxQjEy ODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJ cnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0yMzg4MCw2 ICsyMzg4Nyw3IEBACiAJCQkJOTdERDREODYwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3Iu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNkU2N0QyQTYxMjgwRThBNDAwODc1OEY3IC8qIEV4dGVu c2lvbnMzRE9wZW5HTC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk5M0Y2RjFFRDEyN0Y3MEIxMDA1 NUNCMDYgLyogV2ViR0xDb250ZXh0RXZlbnQuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOEY2NzU2 MUMxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkp OwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0y MzkyMCw2ICsyMzkyOCw3IEBACiAJCQlpc2EgPSBYQ0J1aWxkQ29uZmlndXJhdGlvbjsKIAkJCWJh c2VDb25maWd1cmF0aW9uUmVmZXJlbmNlID0gMUNERDQ1RTUwQkE5Qzg0NjAwRjkwMTQ3IC8qIFdl YkNvcmUueGNjb25maWcgKi87CiAJCQlidWlsZFNldHRpbmdzID0geworCQkJCUVOQUJMRV9TVkcg PSBFTkFCTEVfU1ZHOwogCQkJCUlOU1RBTExfUEFUSCA9ICIkKEJVSUxUX1BST0RVQ1RTX0RJUiki OwogCQkJfTsKIAkJCW5hbWUgPSBEZWJ1ZzsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRleCBhNDBhODhiZGE4ZWJiYjgy NDJkZWYwMGU1ZjdmODljNTU5MjBiYTBhLi4wMmQyMTlkODJlZDUzNjRlZGVkZjEzNjY0ZTc1ZWZj NmIxNGE4MGZkIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvV2Vi Q29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0zOTcsNyArMzk3LDYgQEAgRG9jdW1lbnQ6OkRvY3Vt ZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhUTUwsIGJvb2wgaXNI VE1MLCBjb24KICAgICAsIG1fbm9ybWFsV29ybGRXcmFwcGVyQ2FjaGUoMCkKICNlbmRpZgogICAg ICwgbV91c2luZ0dlb2xvY2F0aW9uKGZhbHNlKQotICAgICwgbV9wZW5kaW5nRXZlbnRUaW1lcih0 aGlzLCAmRG9jdW1lbnQ6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCiAjaWYgRU5BQkxFKFdNTCkK ICAgICAsIG1fY29udGFpbnNXTUxDb250ZW50KGZhbHNlKQogI2VuZGlmCkBAIC0zNDA2LDI1ICsz NDA1LDYgQEAgdm9pZCBEb2N1bWVudDo6ZGlzcGF0Y2hXaW5kb3dMb2FkRXZlbnQoKQogICAgIGRv bVdpbmRvdy0+ZGlzcGF0Y2hMb2FkRXZlbnQoKTsKIH0KIAotdm9pZCBEb2N1bWVudDo6ZW5xdWV1 ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQotewotICAgIG1fcGVuZGluZ0V2ZW50UXVl dWUuYXBwZW5kKGV2ZW50KTsKLSAgICBpZiAoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUo KSkKLSAgICAgICAgbV9wZW5kaW5nRXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZv aWQgRG9jdW1lbnQ6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RG9jdW1lbnQ+KikKLXsK LSAgICBBU1NFUlQoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUoKSk7Ci0gICAgVmVjdG9y PFJlZlB0cjxFdmVudD4gPiBldmVudFF1ZXVlOwotICAgIGV2ZW50UXVldWUuc3dhcChtX3BlbmRp bmdFdmVudFF1ZXVlKTsKLQotICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxFdmVudD4gPjo6Y29u c3RfaXRlcmF0b3IgSXRlcmF0b3I7Ci0gICAgSXRlcmF0b3IgZW5kID0gZXZlbnRRdWV1ZS5lbmQo KTsKLSAgICBmb3IgKEl0ZXJhdG9yIGl0ID0gZXZlbnRRdWV1ZS5iZWdpbigpOyBpdCAhPSBlbmQ7 ICsraXQpCi0gICAgICAgIGRpc3BhdGNoV2luZG93RXZlbnQoKml0KTsKLX0KLQogUGFzc1JlZlB0 cjxFdmVudD4gRG9jdW1lbnQ6OmNyZWF0ZUV2ZW50KGNvbnN0IFN0cmluZyYgZXZlbnRUeXBlLCBF eGNlcHRpb25Db2RlJiBlYykKIHsKICAgICBSZWZQdHI8RXZlbnQ+IGV2ZW50OwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50LmgKaW5kZXgg YzllM2I0NzVlNTE1OGY0YzkwYzdjMjU4N2JhN2YxMzEzZDY0MTE2Ni4uMDBlZDAxMDU1NTVlMjJm NGNkMTNkMzAzNjU0MWE0ZTFhYzI3ZTAzOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1l bnQuaAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC0xMDEyLDcgKzEwMTIsNiBAQCBw dWJsaWM6CiAgICAgYm9vbCBjb250YWluc1ZhbGlkaXR5U3R5bGVSdWxlcygpIGNvbnN0IHsgcmV0 dXJuIG1fY29udGFpbnNWYWxpZGl0eVN0eWxlUnVsZXM7IH0KICAgICB2b2lkIHNldENvbnRhaW5z VmFsaWRpdHlTdHlsZVJ1bGVzKCkgeyBtX2NvbnRhaW5zVmFsaWRpdHlTdHlsZVJ1bGVzID0gdHJ1 ZTsgfQogCi0gICAgdm9pZCBlbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOwogICAgIHZv aWQgZW5xdWV1ZVBhZ2VzaG93RXZlbnQoUGFnZXNob3dFdmVudFBlcnNpc3RlbmNlKTsKICAgICB2 b2lkIGVucXVldWVIYXNoY2hhbmdlRXZlbnQoY29uc3QgU3RyaW5nJiBvbGRVUkwsIGNvbnN0IFN0 cmluZyYgbmV3VVJMKTsKICAgICB2b2lkIGVucXVldWVQb3BzdGF0ZUV2ZW50KFBhc3NSZWZQdHI8 U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBzdGF0ZU9iamVjdCk7CkBAIC0xMDkwLDggKzEwODksNiBA QCBwcml2YXRlOgogCiAgICAgdm9pZCBjcmVhdGVTdHlsZVNlbGVjdG9yKCk7CiAKLSAgICB2b2lk IHBlbmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RG9jdW1lbnQ+Kik7Ci0KICAgICBQYXNzUmVm UHRyPE5vZGVMaXN0PiBoYW5kbGVaZXJvUGFkZGluZyhjb25zdCBIaXRUZXN0UmVxdWVzdCYsIEhp dFRlc3RSZXN1bHQmKSBjb25zdDsKIAogICAgIHZvaWQgbG9hZEV2ZW50RGVsYXlUaW1lckZpcmVk KFRpbWVyPERvY3VtZW50PiopOwpAQCAtMTMxOCw5ICsxMzE1LDYgQEAgcHJpdmF0ZToKIAogICAg IGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwogCi0gICAgVGltZXI8RG9jdW1lbnQ+IG1fcGVuZGlu Z0V2ZW50VGltZXI7Ci0gICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3BlbmRpbmdFdmVudFF1 ZXVlOwotCiAjaWYgRU5BQkxFKFdNTCkKICAgICBib29sIG1fY29udGFpbnNXTUxDb250ZW50Owog I2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBiL1dlYkNvcmUv ZG9tL0V2ZW50UXVldWUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNiZmM1MjI5ZGE3Y2EyMzNlOGJiMDI3Mjdm MTJhN2FjZGQ4M2RmNTUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVl LmNwcApAQCAtMCwwICsxLDg1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJ bmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiRXZlbnRRdWV1ZS5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNs dWRlICJFdmVudC5oIgorI2luY2x1ZGUgIk5vZGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitFdmVudFF1ZXVlOjpFdmVudFF1ZXVlKFBhc3NSZWZQdHI8Tm9kZT4gdGFyZ2V0KQorICAgIDog bV90YXJnZXQodGFyZ2V0KQorICAgICwgbV9wZW5kaW5nRXZlbnRUaW1lcih0aGlzLCAmRXZlbnRR dWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZCkKK3sKK30KKwordm9pZCBFdmVudFF1ZXVlOjpl bnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCit7CisgICAgbV9wZW5kaW5nRXZl bnRRdWV1ZS5hcHBlbmQoZXZlbnQpOworICAgIGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0Fj dGl2ZSgpKQorICAgICAgICBtX3BlbmRpbmdFdmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30K Kwordm9pZCBFdmVudFF1ZXVlOjplbnF1ZXVlRXZlbnRJZk5vdEFscmVhZHlFbnF1ZXVlZChQYXNz UmVmUHRyPEV2ZW50PiBwcnBFdmVudCkKK3sKKyAgICBSZWZQdHI8RXZlbnQ+IGV2ZW50ID0gcHJw RXZlbnQ7CisgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+Ojpjb25zdF9pdGVyYXRv ciBJdGVyYXRvcjsKKyAgICBJdGVyYXRvciBlbmQgPSBtX3BlbmRpbmdFdmVudFF1ZXVlLmVuZCgp OworICAgIGZvciAoSXRlcmF0b3IgaXQgPSBtX3BlbmRpbmdFdmVudFF1ZXVlLmJlZ2luKCk7IGl0 ICE9IGVuZDsgKytpdCkgeworICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gKCppdCktPnR5cGUo KSkKKyAgICAgICAgICByZXR1cm47CisgICAgfQorICAgIAorICAgIGVucXVldWVFdmVudChldmVu dCk7Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxF dmVudFF1ZXVlPiopCit7CisgICAgQVNTRVJUKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZl KCkpOworICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID4gZXZlbnRRdWV1ZTsKKyAgICBldmVudFF1 ZXVlLnN3YXAobV9wZW5kaW5nRXZlbnRRdWV1ZSk7CisgICAgCisgICAgaWYgKCFtX3RhcmdldC0+ aW5Eb2N1bWVudCgpKQorICAgICAgICByZXR1cm47CisKKyAgICB0eXBlZGVmIFZlY3RvcjxSZWZQ dHI8RXZlbnQ+ID46OmNvbnN0X2l0ZXJhdG9yIEl0ZXJhdG9yOworICAgIEl0ZXJhdG9yIGVuZCA9 IGV2ZW50UXVldWUuZW5kKCk7CisgICAgZm9yIChJdGVyYXRvciBpdCA9IGV2ZW50UXVldWUuYmVn aW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICBkaXNwYXRjaEV2ZW50KCppdCk7Cit9CisK K3ZvaWQgRXZlbnRRdWV1ZTo6ZGlzcGF0Y2hFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCkK K3sKKyAgICBpZiAobV90YXJnZXQtPmRvY3VtZW50KCkgPT0gbV90YXJnZXQuZ2V0KCkpCisgICAg ICAgIG1fdGFyZ2V0LT5kb2N1bWVudCgpLT5kaXNwYXRjaFdpbmRvd0V2ZW50KGV2ZW50KTsKKyAg ICBlbHNlCisgICAgICAgIG1fdGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50KTsKK30KKworfQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oIGIvV2ViQ29yZS9kb20vRXZlbnRR dWV1ZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjY4ZDkzOWJkN2M5NDNiZDVlMjlkZjMwYzgxZDM2YjQ3N2Q3MjI4 OWEKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmgKQEAgLTAsMCAr MSw1NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgUmlnaHRz IFJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBB UFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLiAKKyAqCisgKi8KKworI2lmbmRlZiBFdmVudFF1ZXVlX2gKKyNkZWZpbmUgRXZl bnRRdWV1ZV9oCisKKyNpbmNsdWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4K KyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg RXZlbnQ7CitjbGFzcyBOb2RlOworCitjbGFzcyBFdmVudFF1ZXVlIHsKK3B1YmxpYzoKKyAgICBF dmVudFF1ZXVlKFBhc3NSZWZQdHI8Tm9kZT4gdGFyZ2V0KTsKKworICAgIHZvaWQgZW5xdWV1ZUV2 ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KTsKKyAgICB2b2lkIGVucXVldWVFdmVudElmTm90 QWxyZWFkeUVucXVldWVkKFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KTsKKworcHJpdmF0ZToKKyAg ICB2b2lkIHBlbmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RXZlbnRRdWV1ZT4qKTsKKyAgICB2 b2lkIGRpc3BhdGNoRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpOworCisgICAgUmVmUHRy PE5vZGU+IG1fdGFyZ2V0OworICAgIFRpbWVyPEV2ZW50UXVldWU+IG1fcGVuZGluZ0V2ZW50VGlt ZXI7CisgICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3BlbmRpbmdFdmVudFF1ZXVlOworfTsK KworfQorCisjZW5kaWYgLy8gRXZlbnRRdWV1ZV9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9O b2RlLmNwcCBiL1dlYkNvcmUvZG9tL05vZGUuY3BwCmluZGV4IGU0NWJhYTQ5NTcwMzUwMDc0YTRm ZTE4MDA3MjAwNGRhYjgxYjYwZjMuLmZjMjM5ZTUyNDM3ZmQzNmJjMDM2NTg0YWNkMDFkNTYxM2Nh Mjg4NTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGUuY3BwCisrKyBiL1dlYkNvcmUvZG9t L05vZGUuY3BwCkBAIC0yNTQ3LDYgKzI1NDcsMTYgQEAgYm9vbCBOb2RlOjpkaXNwYXRjaEV2ZW50 KFBhc3NSZWZQdHI8RXZlbnQ+IHBycEV2ZW50KQogICAgIHJldHVybiBkaXNwYXRjaEdlbmVyaWNF dmVudChldmVudC5yZWxlYXNlKCkpOwogfQogCit2b2lkIE5vZGU6OmVucXVldWVFdmVudChQYXNz UmVmUHRyPEV2ZW50PiBldmVudCkKK3sKKyAgICBlbnN1cmVSYXJlRGF0YSgpLT5lbnN1cmVFdmVu dFF1ZXVlKHRoaXMpLT5lbnF1ZXVlRXZlbnQoZXZlbnQpOworfQorCit2b2lkIE5vZGU6OmVucXVl dWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQorewor ICAgIGVuc3VyZVJhcmVEYXRhKCktPmVuc3VyZUV2ZW50UXVldWUodGhpcyktPmVucXVldWVFdmVu dElmTm90QWxyZWFkeUVucXVldWVkKGV2ZW50KTsKK30KKwogYm9vbCBOb2RlOjpkaXNwYXRjaEdl bmVyaWNFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBwcnBFdmVudCkKIHsKICAgICBSZWZQdHI8RXZl bnQ+IGV2ZW50KHBycEV2ZW50KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL05vZGUuaCBiL1dl YkNvcmUvZG9tL05vZGUuaAppbmRleCAzYzZjMTk5NzExYjM0ZTFhMDBhOWRhODAxMWFmNWE1YWU0 ZGM2NGQ1Li42M2RhZmZhYjU2NDA0NWUzYTQxNTNlM2YyMjZkMmM1MzJiZDg4OTU2IDEwMDY0NAot LS0gYS9XZWJDb3JlL2RvbS9Ob2RlLmgKKysrIGIvV2ViQ29yZS9kb20vTm9kZS5oCkBAIC01MTMs NiArNTEzLDggQEAgcHVibGljOgogCiAgICAgdXNpbmcgRXZlbnRUYXJnZXQ6OmRpc3BhdGNoRXZl bnQ7CiAgICAgdmlydHVhbCBib29sIGRpc3BhdGNoRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOwor ICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+KTsKKyAgICB2b2lkIGVucXVl dWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKFBhc3NSZWZQdHI8RXZlbnQ+KTsKIAogICAgIGJv b2wgZGlzcGF0Y2hHZW5lcmljRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOwogICAgIHZpcnR1YWwg dm9pZCBoYW5kbGVMb2NhbEV2ZW50cyhFdmVudCopOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20v Tm9kZVJhcmVEYXRhLmggYi9XZWJDb3JlL2RvbS9Ob2RlUmFyZURhdGEuaAppbmRleCBhYjIwOGQy MmFmOGQwYzhjN2FkMzE1ZGU0ODdhNzNhODA3NGZiYzVjLi45NDExNzM0NWQxYTY1ZGIxNzBkZWFk YTY3OWE1MzliZTMxMjg3NWU3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Ob2RlUmFyZURhdGEu aAorKysgYi9XZWJDb3JlL2RvbS9Ob2RlUmFyZURhdGEuaApAQCAtMjQsNiArMjQsNyBAQAogCiAj aW5jbHVkZSAiQ2xhc3NOb2RlTGlzdC5oIgogI2luY2x1ZGUgIkR5bmFtaWNOb2RlTGlzdC5oIgor I2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJOYW1lTm9kZUxpc3QuaCIKICNpbmNs dWRlICJRdWFsaWZpZWROYW1lLmgiCiAjaW5jbHVkZSAiVGFnTm9kZUxpc3QuaCIKQEAgLTExMiw2 ICsxMTMsMTMgQEAgcHVibGljOgogCiAgICAgYm9vbCBpc0ZvY3VzZWQoKSBjb25zdCB7IHJldHVy biBtX2lzRm9jdXNlZDsgfQogICAgIHZvaWQgc2V0Rm9jdXNlZChib29sIGZvY3VzZWQpIHsgbV9p c0ZvY3VzZWQgPSBmb2N1c2VkOyB9CisgICAgCisgICAgRXZlbnRRdWV1ZSogZW5zdXJlRXZlbnRR dWV1ZShQYXNzUmVmUHRyPE5vZGU+IHRhcmdldCkKKyAgICB7CisgICAgICAgIGlmICghbV9ldmVu dFF1ZXVlKQorICAgICAgICAgICAgbV9ldmVudFF1ZXVlLnNldChuZXcgRXZlbnRRdWV1ZSh0YXJn ZXQpKTsKKyAgICAgICAgcmV0dXJuIG1fZXZlbnRRdWV1ZS5nZXQoKTsKKyAgICB9CiAKIHByb3Rl Y3RlZDoKICAgICAvLyBmb3IgRWxlbWVudFJhcmVEYXRhCkBAIC0xMjEsNiArMTI5LDcgQEAgcHJv dGVjdGVkOgogcHJpdmF0ZToKICAgICBPd25QdHI8Tm9kZUxpc3RzTm9kZURhdGE+IG1fbm9kZUxp c3RzOwogICAgIE93blB0cjxFdmVudFRhcmdldERhdGE+IG1fZXZlbnRUYXJnZXREYXRhOworICAg IE93blB0cjxFdmVudFF1ZXVlPiBtX2V2ZW50UXVldWU7CiAgICAgc2hvcnQgbV90YWJJbmRleDsK ICAgICBib29sIG1fdGFiSW5kZXhXYXNTZXRFeHBsaWNpdGx5IDogMTsKICAgICBib29sIG1faXNG b2N1c2VkIDogMTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggMjk3MDI1OTFlZWJmZDMxOWNhNGY5 ZWEyMDg4YTUzZjE3MDU4MjBjOC4uZmNmMTc0M2Q1MWE1MTEzNDAyYzU4YzY3ZWI2YTVkMTI5MDJm N2I1OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKKysrIGIvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTI3NTksNyArMjc1OSw3IEBAIHZvaWQgRXZl bnRIYW5kbGVyOjpzZW5kU2Nyb2xsRXZlbnQoKQogewogICAgIHNldEZyYW1lV2FzU2Nyb2xsZWRC eVVzZXIoKTsKICAgICBpZiAobV9mcmFtZS0+dmlldygpICYmIG1fZnJhbWUtPmRvY3VtZW50KCkp Ci0gICAgICAgIG1fZnJhbWUtPmRvY3VtZW50KCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0 ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQsIHRydWUsIGZhbHNlKSk7CisgICAgICAgIG1fZnJh bWUtPmRvY3VtZW50KCktPmVucXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKEV2ZW50Ojpj cmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCB0cnVlLCBmYWxzZSkpOwogfQogCiB2b2lk IEV2ZW50SGFuZGxlcjo6c2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJMYXllci5jcHAKaW5kZXggNGU4Y2VlYzg5OTc4NTYzOTE5ZjEyYTUzNzYyN2RhMjM5YTEyZWMw Zi4uZjkxZWFjNTA4Y2YwNDI4ZTFjMTU1ZWQ3YmE1NjBhMGZkMDY0ZWFiYyAxMDA2NDQKLS0tIGEv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckxheWVyLmNwcApAQCAtMTM5NywxMCArMTM5Nyw4IEBAIHZvaWQgUmVuZGVyTGF5ZXI6 OnNjcm9sbFRvT2Zmc2V0KGludCB4LCBpbnQgeSwgYm9vbCB1cGRhdGVTY3JvbGxiYXJzLCBib29s IHJlcGFpCiAgICAgfQogCiAgICAgLy8gU2NoZWR1bGUgdGhlIHNjcm9sbCBET00gZXZlbnQuCi0g ICAgaWYgKHZpZXcpIHsKLSAgICAgICAgaWYgKEZyYW1lVmlldyogZnJhbWVWaWV3ID0gdmlldy0+ ZnJhbWVWaWV3KCkpCi0gICAgICAgICAgICBmcmFtZVZpZXctPnNjaGVkdWxlRXZlbnQoRXZlbnQ6 OmNyZWF0ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGZhbHNlLCBmYWxzZSksIHJlbmRlcmVy KCktPm5vZGUoKSk7Ci0gICAgfQorICAgIGlmICh2aWV3ICYmIHZpZXctPmZyYW1lVmlldygpKQor ICAgICAgICByZW5kZXJlcigpLT5ub2RlKCktPmVucXVldWVFdmVudElmTm90QWxyZWFkeUVucXVl dWVkKEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2Up KTsKIH0KIAogdm9pZCBSZW5kZXJMYXllcjo6c2Nyb2xsUmVjdFRvVmlzaWJsZShjb25zdCBJbnRS ZWN0JiByZWN0LCBib29sIHNjcm9sbFRvQW5jaG9yLCBjb25zdCBTY3JvbGxBbGlnbm1lbnQmIGFs aWduWCwgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnblkpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxp c3RCb3guY3BwCmluZGV4IDUzMmM1NTEyZDc4YjQ5NWY3MmVmMzM5YjBmZjZkNzhmNDdkNTI0ZTEu LjA0MGY5ZDI2OGRkYTJmY2RjZGMyYWU5ODI1Y2MzNzc2YjdkMDUxYWMgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckxpc3RCb3guY3BwCkBAIC01NDAsNyArNTQwLDcgQEAgdm9pZCBSZW5kZXJMaXN0Qm94 Ojp2YWx1ZUNoYW5nZWQoU2Nyb2xsYmFyKikKICAgICBpZiAobmV3T2Zmc2V0ICE9IG1faW5kZXhP ZmZzZXQpIHsKICAgICAgICAgbV9pbmRleE9mZnNldCA9IG5ld09mZnNldDsKICAgICAgICAgcmVw YWludCgpOwotICAgICAgICBub2RlKCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVu dE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGZhbHNlLCBmYWxzZSkpOworICAgICAgICBub2RlKCktPmVu cXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygp LnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKICAgICB9CiB9CiAK 73927 2010-11-15 13:30:39 -0800 2010-11-15 15:08:22 -0800 Patch bug-45631-20101115133038.patch text/plain 42662 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNDkwNTVlYWI4MTJkMjRjODk3YzdiNGRmNjUxODBlMGVkMmMzN2M1Li5iYWMwODMz ODlhYTM3MDdmYjU1YmE5ZWQ5ZTU4ZTFkY2IzYjE3YjFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuIEFkZGl0aW9uYWxseSwgZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbCBub3cgCisgICAgICAgIGV4cGxpY2l0bHkgdGVzdHMgZm9yIHN5bmNocm9ub3Vz IGJlaGF2aW9yIHdoZW4gc2Nyb2xsaW5nIHRoZSBkb2N1bWVudCwKKyAgICAgICAgYW5kIHRoYXQg d2UgZG9uJ3QgZmlyZSB0aGUgZXZlbnQgbW9yZSB0aGFuIG9uY2UuCisgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBkb2VzIHRoZSBzYW1lIGZvciBzY3Jv bGwKKyAgICAgICAgZXZlbnRzIG9uIHNjcm9sbGFibGUgZWxlbWVudHMuCisKKyAgICAgICAgKiBl ZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFz dC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBm cm9tIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sOgorICAg ICAgICAqIGZhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sOgorICAgICAgICAq IGZhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbDoKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWw6CisgICAgICAgICog ZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sOgorICAgICAgICAqIGZh c3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sOgorICAgICAgICAq IGZhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbDoKKwogMjAxMC0xMS0xNSAg TWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10g TmF2aWdhdGlvbiBwb2xpY3kgZGVjaXNpb24gQVBJIG5lZWRzIHRvIGluY2x1ZGUgdGhlIERPTSBu b2RlIHRoYXQgdGhlIGRlY2lzaW9uIG9yaWdpbmF0ZWQgZnJvbQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dAppbmRleCAyNGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNkNjY0Li5iNWIwY2Yw ZjU0NmMyZTQxZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dApAQCAtMSw0ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy4KK1RoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25j ZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9s bCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMgbm93LgogUEFTUwog KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZjODNiMTQ4MjNkMmVk NzBkYjMyNTAwODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEyMjdjMWM5Mzg2ZmQ5 ZjQ5YjQ2YmEyNWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11 cC1kb3duLXNjcm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2Ut dXAtZG93bi1zY3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1sPgogPGhlYWQ+CiA8 c2NyaXB0PgotaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQogCi1mdW5j dGlvbiBzY3IoKQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKCkgewog ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQgKz0gJ3gnOworCisg ICAgc3dpdGNoIChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAod2luZG93LmV2ZW50 U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFnZVVwJyk7CisgICAg ICAgICAgICBicmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdyZXN1bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgc3RlcCsrOwogfQog CiBmdW5jdGlvbiBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikKLSAg ICAgICAgcmV0dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNj ciwgZmFsc2UpOwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iKTsKLSAgICB2 YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQ7Ci0gICAg aWYgKHRleHQgIT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHgsIG5v dCAiICsgdGV4dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIpOwotICAgIHZh ciB0ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBp ZiAodGV4dCAhPSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHh4LCBu b3QgIiArIHRleHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlu bmVyVGV4dCA9ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICBl dmVudFNlbmRlci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+CiA8L2hlYWQ+CiA8 Ym9keSBvbmxvYWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5bGU9InBvc2l0aW9u OmZpeGVkIj48L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy48L2Rpdj4KKzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBh Z2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3Rs eSBvbmUgc2Nyb2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBu b3cuPC9kaXY+CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2IHN0eWxlPSJoZWln aHQ6NTAwMDBweCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwvZGl2PiAKIDxzY3Jp cHQ+IApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xMWEyZTIyZjY5MGI1 ZmIyN2RhOTMzYTA4NTQ0ZGNjZTlmMjBlZWE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0IEBACitQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKDAsIDIwMCkKK0lmIHRoZSB3 b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFp bGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQg bm90IGZpcmUsIGZpcmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgor CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hY2Q2NmUxNGQ2NGViODFlZDUyNWRjOTlhN2U1NDQz NTgwYWUzYjhhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmly ZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNTIgQEAKKzxodG1sPgorPHNj cmlwdD4KK3ZhciBldmVudENvdW50ID0gMDsKK3ZhciBkb25lVGltZW91dDsKKworZnVuY3Rpb24g c2Nyb2xsSGFuZGxlcigpCit7CisgICAgZXZlbnRDb3VudCsrOworICAgIGlmIChldmVudENvdW50 ID09IDEpIHsKKyAgICAgICAgdmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdjb250YWluZXInKTsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBjb250YWluZXIuc2Nyb2xsTGVm dDsKKyAgICAgICAgdmFyIHNjcm9sbFkgPSBjb250YWluZXIuc2Nyb2xsVG9wOworICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnUEFTU0VELCBz Y3JvbGwgcG9zaXRpb246ICgnICsgc2Nyb2xsWCArICcsICcgKyBzY3JvbGxZICsgJyknOworICAg ICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVy ZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBz ZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgICAgICAgICB9LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFy VGltZW91dChkb25lVGltZW91dCk7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdy ZXN1bHQnKS50ZXh0Q29udGVudCA9ICdGQUlMLCBzY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAn ICsgZXZlbnRDb3VudCArICcgdGltZXMnOworICAgIH0KK30KKworb25sb2FkID0gZnVuY3Rpb24o KQoreworICAgIHZhciBjb250YWluZXIgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFp bmVyJyk7CisgICAgY29udGFpbmVyLmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbEhh bmRsZXIsIGZhbHNlKTsKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIH0KKyAgICBjb250YWluZXIuc2Ny b2xsVG9wID0gMTAwOworICAgIGlmIChldmVudENvdW50ID4gMCkgeworICAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlMRUQsIGV2ZW50IGZpcmVk IHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOyAgICAg IAorICAgIH0KKyAgICBjb250YWluZXIuc2Nyb2xsVG9wID0gMjAwOworfQorCis8L3NjcmlwdD4K Kzxib2R5PgorPGRpdiBpZD0icmVzdWx0Ij5GQUlMLCBldmVudCBkaWQgbm90IGZpcmU8L2Rpdj4K KworPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3ZlLCB0aGVuIHRo ZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0aGF0IGEgc2Ny b2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3IgZmlyZWQgbW9y ZSB0aGFuIG9uY2UuPC9wPgorCis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0iaGVpZ2h0 OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPC9ib2R5PgorPC9odG1s PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dAppbmRleCAxNjg2Y2VkMzlh ZTJiZTJkNTliNjNlOWQzZmRhZTRiMWUyYzg4NjU2Li4xMGY4ZTQzOTAyYmQxODQ2YWRkMjI1ZGU2 YzJlODAwYWZhNTEyZTYzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJl LXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv ZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CkBAIC0xLDU5ICsxLDQgQEAKLVBBU1NFRAor UEFTU0VELCBzY3JvbGwgcG9zaXRpb246ICgyMDAsIDIwMCkKK0lmIHRoZSB3b3JkICdQQVNTRUQn IGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUg dGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUsIGZp cmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgogCi1JZiB0aGUgd29y ZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxl ZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5v dCBmaXJlLgotCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCmlu ZGV4IGEwNTZjMDY3YmQ5ZjI3YzRiMzQ2NWM4NGExNmUyMWE5ZmEzZTcxNGMuLjdjZDBhNTZkMGE4 NDAzNTFhMjQ4N2RlODNkZTc0MjhlMjhhMDAwMTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbApAQCAtMSwzMCArMSw0NyBAQAogPGh0bWw+CiA8 c2NyaXB0PgotdmFyIGV2ZW50RmlyZWQgPSBmYWxzZTsKK3ZhciBldmVudENvdW50ID0gMDsKK3Zh ciBkb25lVGltZW91dDsKIAotZnVuY3Rpb24gc2Nyb2xsZXIoKSB7Ci0gICAgaWYgKCFldmVudEZp cmVkKSB7Ci0gICAgICAgIGV2ZW50RmlyZWQgPSB0cnVlOwotICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFzc2VkIikuaW5uZXJIVE1MID0gIjxwIHN0eWxlPSdjb2xvcjpyZWQnPlBB U1NFRDwvcD4iOworb25zY3JvbGwgPSBmdW5jdGlvbigpCit7CisgICAgZXZlbnRDb3VudCsrOwor ICAgIGlmIChldmVudENvdW50ID09IDEpIHsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBkb2N1bWVu dC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gZG9jdW1lbnQuYm9keS5z Y3JvbGxUb3A7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS50ZXh0 Q29udGVudCA9ICdQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyAr IHNjcm9sbFkgKyAnKSc7CisgICAgICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdo dCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29taW5nLgorICAg ICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0sIDEwMCk7CisgICAgfSBl bHNlIHsKKyAgICAgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1lb3V0KTsKKyAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLnRleHRDb250ZW50ID0gJ0ZBSUwsIHNjcm9sbCBo YW5kbGVyIHdhcyBpbnZva2VkICcgKyBldmVudENvdW50ICsgJyB0aW1lcyc7CiAgICAgfQogfQog Ci13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVu ZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7Ci0gICAgd2luZG93LnNjcm9sbFRvKDUwMCwg NTAwKTsKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUo KTsKICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwogICAgIH0KKyAg ICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDApOworICAgIGlmIChldmVudENvdW50ID4gMCkgewor ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlM RUQsIGV2ZW50IGZpcmVkIHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOyAgICAgIAorICAgIH0KKyAgICB3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOwog fQogCiA8L3NjcmlwdD4KIDxib2R5PgotPGRpdiBpZD0icGFzc2VkIj48L2Rpdj4KKzxkaXYgaWQ9 InJlc3VsdCI+RkFJTCwgZXZlbnQgZGlkIG5vdCBmaXJlPC9kaXY+CiAKLTxwPklmIHRoZSB3b3Jk ICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVk LiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90 IGZpcmUuPC9wPgorPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3Zl LCB0aGVuIHRoZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0 aGF0IGEgc2Nyb2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3Ig ZmlyZWQgbW9yZSB0aGFuIG9uY2UuPC9wPgogCi1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxi cj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgotYTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+Cis8ZGl2IHN0eWxlPSJoZWlnaHQ6IDUwMDBweDsgd2lkdGg6IDUw MDBweDsiPjwvZGl2PgogPC9ib2R5PgogPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZp bGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNj cm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xs Lmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZlNTAyMjc4ZDM2ZWYxOGUwNzFmY2IzNjU0Y2MzNS4uZWFi YjA3OWVhY2FhNzliODhlMGYwYWFkYTcwMTk1ZGUzOGIzNjNiOCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKQEAgLTksMTcgKzks MjggQEAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRpc3BhdGNoU2Nyb2xsRXZlbnRzKCkKICAgICAg ICAgICAgIHsKICAgICAgICAgICAgICAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyICYmIHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2Vu ZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAwKTsKICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5k ZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7Ci0gICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVy Lm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKLSAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgICAgICAgICB2YXIgc2Nyb2xsQ291 bnQgPSAwOworICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHYn KS5hZGRFdmVudExpc3RlbmVyKAorICAgICAgICAgICAgICAgICAgICAgICAgJ3Njcm9sbCcsCisg ICAgICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbihldmVudCkgeworICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzLnJlbW92ZUNoaWxkKHRoaXMuZmlyc3RDaGlsZCkKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgc2Nyb2xsQ291bnQrKzsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg aWYgKHNjcm9sbENvdW50ID09IDEpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVu dFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAtMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy Lm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0sCisgICAgICAgICAgICAg ICAgICAgICAgICBmYWxzZSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAg ICAgICA8L3NjcmlwdD4KICAgICA8L2hlYWQ+CiAgICAgPGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0 KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygpOycsIDEpOyI+CiAgICAgICAgIFRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBiZSByZW1vdmVkIGJ5IHRoZWlyIHBhcmVudCBlbGVtZW50 J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxlci4gIFRoZSB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgaXMg dGhlIG9ubHkgdGV4dCByZW1haW5pbmcgYWZ0ZXIgdGhlIHR3byBzY3JvbGwgZXZlbnRzIGFyZSBk aXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFpbHMgaWYgdGhlIGlubmVyIGRpdiByZW1haW5zIGluIHRo ZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNyYXNoZXMuPGJyPjxicj4KLSAgICAgICAgPGRpdiBpZD0i ZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3 aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNjcm9sbD0idGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0 Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lk dGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7Ij4KICAgICAgICAg PGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7IGhlaWdodDozMDBweCI+TG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmlt IGFkIG1pbmltIHZlbmlhbSwgcXVpcyBub3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9y aXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVhIGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1 cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJpdCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0g ZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBwYXJpYXR1ci4gRXhjZXB0ZXVyIHNpbnQgb2NjYWVjYXQg Y3VwaWRhdGF0IG5vbiBwcm9pZGVudCwgc3VudCBpbiBjdWxwYSBxdWkgb2ZmaWNpYSBkZXNlcnVu dCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFib3J1bQogICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9k aXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwKaW5kZXggNGZjMTUyODRkZWYxZjU4ZDkzNzM1ZmFjYWRlNGE1NmQ3MTBk NTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4MjUzM2FjYjA0NDJhOTJjZTcyNzFmZiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1s CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2Uu aHRtbApAQCAtMTYsNiArMTYsOSBAQAogICAgIGZ1bmN0aW9uIHNjcm9sbGVkKGV2ZW50KQogICAg IHsKICAgICAgICAgZXZlbnQudGFyZ2V0LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZXZlbnQudGFy Z2V0KTsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CiAgICAg fQogCiAgICAgZnVuY3Rpb24gdGVzdCgpCkBAIC0yNyw3ICszMCw5IEBACiAgICAgICAgIGRvY3Vt ZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7CiAgICAgfQogCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgIH0KICAgICB0ZXN0KCk7CiA8L3Nj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1k b2VzLW5vdC1idWJibGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVu dC1kb2VzLW5vdC1idWJibGUuaHRtbAppbmRleCAyMjJhZGE4MDVkYTUzMDYyMmU0ZjgxZjViZGNl ZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3NDMzZGU4YWJlZTZmMzY3MTUxZTUyMDNlMmVlZDQwIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3Qt YnViYmxlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0xLDExICsxLDIyIEBACiA8aHRtbD4KIDxzY3JpcHQ+Cit2 YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBmYWxzZTsKK3ZhciBkb25lVGltZW91dDsKKwogZnVuY3Rp b24gd2luZG93U2Nyb2xsZWQoKSB7CisgICAgd2luZG93V2FzU2Nyb2xsZWQgPSB0cnVlOwogICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTFVSRTog d2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxsZWQuJzsgCisgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1l b3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9uIGRpdlNjcm9sbGVkKCkgewotICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xs IHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cub25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICBpZiAoIXdp bmRvd1dhc1Njcm9sbGVkKQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0 JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2lu ZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0 cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcv YnViYmxpbmcuCisgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9LCAxMDApOyAgICAKIH0KIAog ZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAgLTI0LDEwICszNSw2IEBAIGZ1bmN0aW9uIHJ1blRlc3Qo KSB7CiAgICAgCiAgICAgLy8gRG9uJ3QgcG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25z ZW5zZS4KICAgICBkaXYuaW5uZXJIVE1MID0gJyc7Ci0gICAgCi0gICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgCi0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKLSAgICAKIH0KIAogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwKaW5kZXggYmExYTM1MTY0YzU2 YjJjNDFlYTM4MGJlYTc2M2U3ZTRhMWU1OWY5OC4uZDJmOWFjNjQ1ZTdkNjFiNDUwMWIxYjJiOGY1 MGZiNjY5NTc3YTU2MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3Jl bW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbApAQCAtMTEsMjkgKzExLDMzIEBACiA8cD4KICAg ICBSZXN1bHQ6IDxzcGFuIGlkPSJyZXN1bHQiPnRlc3QgZGlkIG5vdCBjb21wbGV0ZS48L3NwYW4+ CiA8L3A+Ci08ZGl2IGlkPSJ0IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsg aGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAob3ZlcmZsb3dSZW1vdmUpIHRoaXMucGFyZW50 Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBpZD0idCIgc3R5bGU9Im92ZXJmbG93OiBh dXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0idGhpcy5wYXJlbnRO b2RlLnJlbW92ZUNoaWxkKHRoaXMpO2hhbmRsZVNjcm9sbCgwKTsiPgogICAgIDxkaXYgc3R5bGU9 ImhlaWdodDogMjAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogCi08ZGl2IHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9ImlmIChzZWNvbmRP dmVyZmxvd1JlbW92ZSkgdGhpcy5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHRoaXMpOyI+Cis8ZGl2 IHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25z Y3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTtoYW5kbGVTY3JvbGwoMSk7 Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+PC9kaXY+CiAgICAgPGRpdiBpZD0i ZCI+PC9kaXY+CiA8L2Rpdj4KIAogPHNjcmlwdD4KLSAgICB2YXIgb3ZlcmZsb3dSZW1vdmUgPSBm YWxzZTsKLSAgICB2YXIgc2Vjb25kT3ZlcmZsb3dSZW1vdmUgPSBmYWxzZTsKKyAgICB2YXIgc2Ny b2xsZWRGaXJzdENvbnRhaW5lciA9IGZhbHNlOworICAgIHZhciBzY3JvbGxlZFNlY29uZENvbnRh aW5lciA9IGZhbHNlOwogCiAgICAgZG9jdW1lbnQuYm9keS5vZmZzZXRUb3A7IHQuc2Nyb2xsVG9w ID0gMjA7CiAKLSAgICBvdmVyZmxvd1JlbW92ZSA9IHRydWU7Ci0gICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3QnKS5pbm5lckhUTUwgPSAnJzsKLQotICAgIHNlY29uZE92ZXJmbG93UmVtb3Zl ID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZCcpLnNjcm9sbEludG9WaWV3 KCk7CiAgICAgCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4 dCA9ICJTVUNDRVNTIjsKLQotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCi0g ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICBmdW5jdGlvbiBo YW5kbGVTY3JvbGwoaW5kZXgpCisgICAgeworICAgICAgICBpZiAoaW5kZXggPT0gMCkgc2Nyb2xs ZWRGaXJzdENvbnRhaW5lciA9IHRydWU7CisgICAgICAgIGVsc2UgaWYgKGluZGV4ID09IDEpIHNj cm9sbGVkU2Vjb25kQ29udGFpbmVyID0gdHJ1ZTsKKyAgICAgICAgCisgICAgICAgIGlmIChzY3Jv bGxlZEZpcnN0Q29udGFpbmVyICYmIHNjcm9sbGVkU2Vjb25kQ29udGFpbmVyKSB7CisgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJUZXh0ID0gIlNVQ0NF U1MiOworICAgICAgICAKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgICAgICB9CisgICAgfQogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCmluZGV4IDY0 YjIwYWM0YWVmZGNkNTYxNGQyYzQ4YzAzZTZjZDJhMzIyYmQ0ZGUuLjM1NzQxMmZlMjNmYjY2YzVk ZWMxZGEwNThhZWE3NTJiZTM2MTA3OGIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3Qvb3Zl cmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCisrKyBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCkBAIC0xLDE0 ICsxLDE2IEBACiA8aGVhZD4KIDxzY3JpcHQ+CiBmdW5jdGlvbiB0ZXN0KCkgewotICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICB9CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIml0Iikuc2Nyb2xsVG9wID0gMTAwOwogfQogPC9zY3Jp cHQ+CiA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CiA8cD5UaGlzIHRlc3QgaW52b2x2ZXMgYSBsYXll ciB0aGF0IHNlbGYtZGVzdHJ1Y3RzIHdoZW4gc2Nyb2xsZWQuIElmIHRoZXJlJ3Mgbm8gY3Jhc2gs IHRoZW4gdGhlIHRlc3Qgc3VjY2VlZGVkLjwvcD4KLTxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0 OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9uc2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUn Ij4KKzxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9u c2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUnO2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsiPgogPGRpdiBzdHlsZT0i aGVpZ2h0OiAyMDAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogPC9ib2R5PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sCmluZGV4IGUzZjBh YzQ0YzE5YmNhNWRiZGUxNGQxMzg3M2EwY2Q1ZjBlZTcyMGMuLmRjNjk3MTIyMTZmN2I1MTY2MGFl MzIyNGIyY2VlYWU0NjFiMTQ0YWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvcmVwYWlu dC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3JlcGFp bnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKQEAgLTMsNiArMyw4IEBACiAgICAgPHNjcmlw dD4KICAgICAgICAgZnVuY3Rpb24gcmVwYWludFRlc3QoKQogICAgICAgICB7CisgICAgICAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAgICAgICAgICAgIHZhciB0YXJnZXQg PSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAgICAgICAgICAgICBzY3JvbGxC eSgwLCAxMDApOwogICAgICAgICB9CkBAIC0xMSw2ICsxMyw4IEBACiAgICAgICAgIHsKICAgICAg ICAgICAgIHZhciB0YXJnZXQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAg ICAgICAgICAgICB0YXJnZXQuc3R5bGUuYmFja2dyb3VuZENvbG9yID0gImdyZWVuIjsKKyAgICAg ICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwogICAgICAgICB9CiAgICAgPC9zY3Jp cHQ+CiA8L2hlYWQ+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0FuZHJvaWQubWsgYi9XZWJDb3JlL0Fu ZHJvaWQubWsKaW5kZXggYjY0ZTMyYjZkODVmNGFjNjJmNzUyYzAyM2I3YTdlZTFjYTA2YTQ0NC4u Y2EwNzRlY2RmZWRkYWJlZGQ3NGEwYzQwNTljZDk1Y2NjMmM4ZmIxOSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9BbmRyb2lkLm1rCisrKyBiL1dlYkNvcmUvQW5kcm9pZC5tawpAQCAtMTM1LDYgKzEzNSw3 IEBAIExPQ0FMX1NSQ19GSUxFUyA6PSAkKExPQ0FMX1NSQ19GSUxFUykgXAogCWRvbS9FdmVudENv bnRleHQuY3BwIFwKIAlkb20vRXZlbnROYW1lcy5jcHAgXAogCWRvbS9FdmVudFRhcmdldC5jcHAg XAorCWRvbS9FdmVudFF1ZXVlLmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkJhc2UuY3BwIFwKIAlkb20v RXhjZXB0aW9uQ29kZS5jcHAgXAogCWRvbS9JbnB1dEVsZW1lbnQuY3BwIFwKZGlmZiAtLWdpdCBh L1dlYkNvcmUvQ01ha2VMaXN0cy50eHQgYi9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDkz MTc2ODdkZGJmYjA4MmE2NDRkNWFmM2MwMDllODU1ZThmM2ViMTIuLmZhMjZkNDg4ZDgwZjEyNGFh NGFhM2YxMjk0Y2M3OTg1NmNlYjQxODkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ01ha2VMaXN0cy50 eHQKKysrIGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtODI2LDYgKzgyNiw3IEBAIFNFVChX ZWJDb3JlX1NPVVJDRVMKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcAogICAgIGRvbS9FdmVudE5h bWVzLmNwcAogICAgIGRvbS9FdmVudFRhcmdldC5jcHAKKyAgICBkb20vRXZlbnRRdWV1ZS5jcHAK ICAgICBkb20vRXhjZXB0aW9uQmFzZS5jcHAKICAgICBkb20vRXhjZXB0aW9uQ29kZS5jcHAKICAg ICBkb20vSW5wdXRFbGVtZW50LmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhZGQzZWM2ZTIyZTc4YTYyYzVmZjJiNDhlZmUyYWUwYTI0 YzI1NjVmLi5lOGNlMTE3ZDcwNmFlODFjNjdjZjgyZDE5OTFlMzEzNGJiMTc0NDFhIDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDUxIEBACisyMDEwLTExLTE1ICBNaWhhaSBQYXJwYXJpdGEgIDxtaWhhaXBAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNjcm9s bCBldmVudCBzaG91bGQgYmUgZmlyZWQgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NjMxCisKKyAgICAgICAgVGVzdHM6IGZh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtCisKKyAgICAgICAgTWFrZXMgc2Nyb2xs IGV2ZW50cyBmaXJlIGFzeW5jaHJvbm91c2x5IHRvIGJlIGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUK KyAgICAgICAgQ1NTT00gVmlldyBNb2R1bGUgYW5kIGNvbnNpc3RlbnQgd2l0aCBHZWNrbywgT3Bl cmEgYW5kICh0byBzb21lIGRlZ3JlZSkKKyAgICAgICAgSUUuCisKKyAgICAgICAgVGhpcyBpcyBh Y2NvbXBsaXNoZWQgYnkgbW92aW5nIHRoZSBEb2N1bWVudDo6ZW5xdWV1ZUV2ZW50IGFuZCBzdXBw b3J0aW5nCisgICAgICAgIGNvZGUgdG8gYSBzdGFuZGFsb25lIEV2ZW50UXVldWUgY2xhc3MsIGFu IGluc3RhbmNlIG9mIHdoaWNoIGNhbiBiZSAKKyAgICAgICAgYXR0YWNoZWQgdG8gTm9kZSBpbnN0 YW5jZXMgdmlhIE5vZGVSYXJlRGF0YS4KKworICAgICAgICAqIEFuZHJvaWQubWs6CisgICAgICAg ICogQ01ha2VMaXN0cy50eHQ6CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICog V2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUu dmNwcm9qL1dlYkNvcmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvajoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuaDoKKyAgICAg ICAgKiBkb20vRXZlbnRRdWV1ZS5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRR dWV1ZTo6RXZlbnRRdWV1ZSk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFF1ZXVlOjplbnF1ZXVl RXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50SWZOb3RB bHJlYWR5RW5xdWV1ZWQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRRdWV1ZTo6cGVuZGluZ0V2 ZW50VGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFF1ZXVlOjpkaXNwYXRjaEV2 ZW50KToKKyAgICAgICAgKiBkb20vRXZlbnRRdWV1ZS5oOiBBZGRlZC4KKyAgICAgICAgKiBkb20v Tm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb2RlOjplbnF1ZXVlRXZlbnQpOgorICAgICAg ICAoV2ViQ29yZTo6Tm9kZTo6ZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQpOgorICAg ICAgICAqIGRvbS9Ob2RlLmg6CisgICAgICAgICogZG9tL05vZGVSYXJlRGF0YS5oOgorICAgICAg ICAoV2ViQ29yZTo6Tm9kZVJhcmVEYXRhOjplbnN1cmVFdmVudFF1ZXVlKToKKyAgICAgICAgKiBw YWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnNl bmRTY3JvbGxFdmVudCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlJlbmRlckxheWVyOjpzY3JvbGxUb09mZnNldCk6CisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGlz dEJveDo6dmFsdWVDaGFuZ2VkKToKKwogMjAxMC0xMS0xMiAgSmVyIE5vYmxlICA8amVyLm5vYmxl QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBCcmFkeSBFaWRzb24uCmRpZmYgLS1n aXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRl eCBjODcxNGJiMTc0NjI5ZTRlNDRiYWRjYTI4ZWFhMGM2MWI0NDZjNWQ2Li41NTQ2MDY0ZTdlMzdm MzhhNGNmOWNlOTczYWMzZGFkZjMzODQ4NDQ5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2Vm aWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTExNDQsNiArMTE0NCw4IEBA IHdlYmNvcmVfc291cmNlcyArPSBcCiAJV2ViQ29yZS9kb20vRXZlbnROYW1lcy5oIFwKIAlXZWJD b3JlL2RvbS9FdmVudFRhcmdldC5jcHAgXAogCVdlYkNvcmUvZG9tL0V2ZW50VGFyZ2V0LmggXAor CVdlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3BwIFwKKwlXZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmgg XAogCVdlYkNvcmUvZG9tL0V4Y2VwdGlvbkJhc2UuY3BwIFwKIAlXZWJDb3JlL2RvbS9FeGNlcHRp b25CYXNlLmggXAogCVdlYkNvcmUvZG9tL0V4Y2VwdGlvbkNvZGUuY3BwIFwKZGlmZiAtLWdpdCBh L1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggNzU0NTVl ZDcyMjQxODQ1OGMxNjc2NjU1NDc0ZWEzYzc3YTVhZTEwNC4uNWE0ZmMzODQwM2Q5MjU5MzM3MzFh ZDc0YjIzMTgzMTVkN2FhMTk3NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysr IGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTEyMTAsNiArMTIxMCw4IEBACiAgICAgICAgICAg ICAnZG9tL0V2ZW50TmFtZXMuaCcsCiAgICAgICAgICAgICAnZG9tL0V2ZW50VGFyZ2V0LmNwcCcs CiAgICAgICAgICAgICAnZG9tL0V2ZW50VGFyZ2V0LmgnLAorICAgICAgICAgICAgJ2RvbS9FdmVu dFF1ZXVlLmNwcCcsCisgICAgICAgICAgICAnZG9tL0V2ZW50UXVldWUuaCcsCiAgICAgICAgICAg ICAnZG9tL0V4Y2VwdGlvbkJhc2UuY3BwJywKICAgICAgICAgICAgICdkb20vRXhjZXB0aW9uQmFz ZS5oJywKICAgICAgICAgICAgICdkb20vRXhjZXB0aW9uQ29kZS5jcHAnLApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODRlMmYyZTQ2 MmY2ZGMwMGE4NGFkMzkwNjNlMzZjMjNhNDIzOWZkNC4uZGMxNmEyZWZkNzc1Y2FjNjNiMWM2YTBl ZThhNGQxYjBhOTkwM2MzNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9X ZWJDb3JlL1dlYkNvcmUucHJvCkBAIC03MTYsNiArNzE2LDcgQEAgU09VUkNFUyArPSBcCiAgICAg ZG9tL0V2ZW50Q29udGV4dC5jcHAgXAogICAgIGRvbS9FdmVudE5hbWVzLmNwcCBcCiAgICAgZG9t L0V2ZW50VGFyZ2V0LmNwcCBcCisgICAgZG9tL0V2ZW50UXVldWUuY3BwIFwKICAgICBkb20vRXhj ZXB0aW9uQmFzZS5jcHAgXAogICAgIGRvbS9FeGNlcHRpb25Db2RlLmNwcCBcCiAgICAgZG9tL0lu cHV0RWxlbWVudC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJD b3JlLnZjcHJvaiBiL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXgg OGY1MzIzYmVhOTJmZjhiMWI4NTIyYjk2NWRjYzkzOTI1MTY4OGYxZi4uNzg5MjUwYWYzZTg5NDhk MGEyYTBmMzNiMmRmZjU5M2ZiZDgxYmEwNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZj cHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUu dmNwcm9qCkBAIC00MjU2Myw2ICs0MjU2Myw2MiBAQAogCQkJCVJlbGF0aXZlUGF0aD0iLi5cZG9t XEV2ZW50VGFyZ2V0LmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQorCQkgIDxGaWxlDQorCQkJCVJl bGF0aXZlUGF0aD0iLi5cZG9tXEV2ZW50UXVldWUuY3BwIg0KKwkJCQk+DQorCQkJCTxGaWxlQ29u ZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWd8V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21C dWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBp bGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJCTxGaWxl Q29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iUmVsZWFzZXxXaW4zMiINCisJCQkJCUV4Y2x1ZGVk RnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0KKwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NM Q29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJCQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQkJ PEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1lPSJEZWJ1Z19JbnRlcm5hbHxXaW4zMiINCisJ CQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0KKwkJCQkJPFRvb2wNCisJCQkJ CQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJCQkJPC9GaWxlQ29uZmlndXJh dGlvbj4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1lPSJEZWJ1Z19DYWlyb3xX aW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0KKwkJCQkJPFRv b2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJCQkJPC9GaWxl Q29uZmlndXJhdGlvbj4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1lPSJSZWxl YXNlX0NhaXJvfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+ DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0K KwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJ CU5hbWU9IkRlYnVnX0FsbHxXaW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0K KwkJCQkJPg0KKwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJ CQkJLz4NCisJCQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUN CisJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZlbnRRdWV1ZS5oIg0KKwkJCQk+DQorCQkJPC9G aWxlPg0KIAkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5cZG9tXEV4Y2VwdGlvbkJhc2Uu Y3BwIg0KIAkJCQk+DQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2ogYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpp bmRleCA3OGE5YTkwMWYyY2MxODI4Njc0YzRhZTAzZmZjOGE0Y2ZlYTdlZDcxLi45M2M0NTFjMTk2 ZTA1OWMwODllZTMyMzYyYTcwNjM3YTNiYTI3NDU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMjY1NCw2ICsyNjU0LDggQEAKIAkJOEFGNEU1NUMxMURD NUE2MzAwMEVEM0RFIC8qIFBlcmZvcm1hbmNlVGltaW5nLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QUY0RTU1OTExREM1QTYzMDAwRUQzREUgLyogUGVy Zm9ybWFuY2VUaW1pbmcuaCAqLzsgfTsKIAkJOEM2RUE2MTkxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gOEM2RUE2MTcxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVk RmVhdHVyZXMuY3BwICovOyB9OwogCQk4QzZFQTYxQTExRUY3RTA0MDBGRDhFRTMgLyogUnVudGlt ZUVuYWJsZWRGZWF0dXJlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gOEM2RUE2MTgxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVkRmVhdHVy ZXMuaCAqLzsgfTsKKwkJOEY2NzU2MUIxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhGNjc1NjE5MTI4 OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmggKi87IH07CisJCThGNjc1NjFDMTI4OEIxN0Iw MDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDhGNjc1NjFBMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNw cCAqLzsgfTsKIAkJOEZBQzc3NEQxMTk4NzJDQjAwMTVBRTk0IC8qIEpTTWFpblRocmVhZEV4ZWNT dGF0ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4 RjkzNEQ4NDExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcCAqLzsg fTsKIAkJOTMwMkIwQkQwRDc5RjgyOTAwQzdFRTgzIC8qIFBhZ2VHcm91cC5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzAyQjBCQzBENzlGODI5MDBD N0VFODMgLyogUGFnZUdyb3VwLmNwcCAqLzsgfTsKIAkJOTMwMkIwQkYwRDc5RjgyQzAwQzdFRTgz IC8qIFBhZ2VHcm91cC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gOTMwMkIwQkUwRDc5RjgyQzAwQzdFRTgzIC8qIFBhZ2VHcm91cC5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC04NzgzLDYgKzg3ODUsOCBA QAogCQk4QUY0RTU1QTExREM1QTYzMDAwRUQzREUgLyogUGVyZm9ybWFuY2VUaW1pbmcuaWRsICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gdGV4dDsgcGF0aCA9IFBlcmZvcm1hbmNlVGltaW5nLmlkbDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJOEM2RUE2MTcxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRpbWVFbmFi bGVkRmVhdHVyZXMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5jcHA7IHBhdGggPSBnZW5lcmljL1J1bnRpbWVFbmFibGVkRmVh dHVyZXMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QzZFQTYxODExRUY3RTA0 MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IG5hbWUgPSBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg7IHBhdGggPSBnZW5lcmljL1J1 bnRpbWVFbmFibGVkRmVhdHVyZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOEY2 NzU2MTkxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gRXZlbnRRdWV1ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owor CQk4RjY3NTYxQTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBFdmVudFF1ZXVlLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJOEY5MzREODMxMTg5RjFFRTAwNTA4RDVEIC8qIEpTTWFpblRocmVhZEV4 ZWNTdGF0ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU01haW5UaHJlYWRF eGVjU3RhdGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEY5MzREODQxMTg5RjFF RTAwNTA4RDVEIC8qIEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk5MzAyQjBCQzBENzlGODI5MDBDN0VFODMgLyogUGFnZUdyb3Vw LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFBhZ2VHcm91cC5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xODQ0NSw2ICsxODQ0OSw4IEBACiAJCQkJ NTRDNTBGN0EwRTgwMURGMzAwOTgzMkEwIC8qIFhNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAg Ki8sCiAJCQkJNUQxNUUzQTkwRjlFNkFDMTAwOUUwRTNGIC8qIFhNTERvY3VtZW50UGFyc2VyU2Nv cGUuY3BwICovLAogCQkJCTVEMTVFM0FBMEY5RTZBQzEwMDlFMEUzRiAvKiBYTUxEb2N1bWVudFBh cnNlclNjb3BlLmggKi8sCisJCQkJOEY2NzU2MTkxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVl dWUuaCAqLywKKwkJCQk4RjY3NTYxQTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAg Ki8sCiAJCQkpOwogCQkJcGF0aCA9IGRvbTsKIAkJCXNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7CkBA IC0yMTM4Myw2ICsyMTM4OSw3IEBACiAJCQkJNDk5QjNDNTkxMjhDNjQxRTAwRTcyNkMyIC8qIEdy YXBoaWNzTGF5ZXJNYWMuaCBpbiBIZWFkZXJzICovLAogCQkJCTA4MjUwOTM5MTI4QkQ0RDgwMEUy RUQ4RSAvKiBTVkdBbmltYXRlZFRyYW5zZm9ybUxpc3QuaCBpbiBIZWFkZXJzICovLAogCQkJCTM4 ODhGNkVGMTI4Qzk4ODkwMDBDQThFMCAvKiBJbnNwZWN0b3JGaWxlU3lzdGVtQWdlbnQuaCBpbiBI ZWFkZXJzICovLAorCQkJCThGNjc1NjFCMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmgg aW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNz aW5nID0gMDsKIAkJfTsKQEAgLTIzOTU2LDYgKzIzOTYzLDcgQEAKIAkJCQk5N0RENEQ4NjBGREY0 RDZFMDBFQ0Y5QTQgLyogWFNTQXVkaXRvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk0OTlCM0M1 QTEyOEM2NDFFMDBFNzI2QzIgLyogR3JhcGhpY3NMYXllck1hYy5tbSBpbiBTb3VyY2VzICovLAog CQkJCTM4ODhGNkVFMTI4Qzk4ODkwMDBDQThFMCAvKiBJbnNwZWN0b3JGaWxlU3lzdGVtQWdlbnQu Y3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOEY2NzU2MUMxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50 UXVldWUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQ b3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggNGMzNDI1YTczZGZkOGJmYjhk NTA1YzA4OTM0MmVkODU5NmUyZDgzMy4uMDUzMGU5MzNjNzU1NWU4NTc5ZTJhMzM4YmIzMDJlYjBi ZWRhNmE1OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNv cmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMzk5LDcgKzM5OSw2IEBAIERvY3VtZW50OjpEb2N1bWVu dChGcmFtZSogZnJhbWUsIGNvbnN0IEtVUkwmIHVybCwgYm9vbCBpc1hIVE1MLCBib29sIGlzSFRN TCwgY29uCiAgICAgLCBtX25vcm1hbFdvcmxkV3JhcHBlckNhY2hlKDApCiAjZW5kaWYKICAgICAs IG1fdXNpbmdHZW9sb2NhdGlvbihmYWxzZSkKLSAgICAsIG1fcGVuZGluZ0V2ZW50VGltZXIodGhp cywgJkRvY3VtZW50OjpwZW5kaW5nRXZlbnRUaW1lckZpcmVkKQogI2lmIEVOQUJMRShXTUwpCiAg ICAgLCBtX2NvbnRhaW5zV01MQ29udGVudChmYWxzZSkKICNlbmRpZgpAQCAtMzQzNywyNSArMzQz Niw2IEBAIHZvaWQgRG9jdW1lbnQ6OmRpc3BhdGNoV2luZG93TG9hZEV2ZW50KCkKICAgICBkb21X aW5kb3ctPmRpc3BhdGNoTG9hZEV2ZW50KCk7CiB9CiAKLXZvaWQgRG9jdW1lbnQ6OmVucXVldWVF dmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCkKLXsKLSAgICBtX3BlbmRpbmdFdmVudFF1ZXVl LmFwcGVuZChldmVudCk7Ci0gICAgaWYgKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkp Ci0gICAgICAgIG1fcGVuZGluZ0V2ZW50VGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lk IERvY3VtZW50OjpwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopCi17Ci0g ICAgQVNTRVJUKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpOwotICAgIFZlY3RvcjxS ZWZQdHI8RXZlbnQ+ID4gZXZlbnRRdWV1ZTsKLSAgICBldmVudFF1ZXVlLnN3YXAobV9wZW5kaW5n RXZlbnRRdWV1ZSk7Ci0KLSAgICB0eXBlZGVmIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID46OmNvbnN0 X2l0ZXJhdG9yIEl0ZXJhdG9yOwotICAgIEl0ZXJhdG9yIGVuZCA9IGV2ZW50UXVldWUuZW5kKCk7 Ci0gICAgZm9yIChJdGVyYXRvciBpdCA9IGV2ZW50UXVldWUuYmVnaW4oKTsgaXQgIT0gZW5kOyAr K2l0KQotICAgICAgICBkaXNwYXRjaFdpbmRvd0V2ZW50KCppdCk7Ci19Ci0KIFBhc3NSZWZQdHI8 RXZlbnQ+IERvY3VtZW50OjpjcmVhdGVFdmVudChjb25zdCBTdHJpbmcmIGV2ZW50VHlwZSwgRXhj ZXB0aW9uQ29kZSYgZWMpCiB7CiAgICAgUmVmUHRyPEV2ZW50PiBldmVudDsKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZG9tL0RvY3VtZW50LmggYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGJh NDhkNmY4MmVjYjQwOGJkYmQxNDdmNjIzZTllNmM5Y2JmMjIxNjkuLjgzNmE2MzAxYmVlOWFiZTRk NmI2MTgzNzc1ZjBjYzJjZmRlZWRlZWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmgKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuaApAQCAtMTAxNiw3ICsxMDE2LDYgQEAgcHVi bGljOgogICAgIGJvb2wgY29udGFpbnNWYWxpZGl0eVN0eWxlUnVsZXMoKSBjb25zdCB7IHJldHVy biBtX2NvbnRhaW5zVmFsaWRpdHlTdHlsZVJ1bGVzOyB9CiAgICAgdm9pZCBzZXRDb250YWluc1Zh bGlkaXR5U3R5bGVSdWxlcygpIHsgbV9jb250YWluc1ZhbGlkaXR5U3R5bGVSdWxlcyA9IHRydWU7 IH0KIAotICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+KTsKICAgICB2b2lk IGVucXVldWVQYWdlc2hvd0V2ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0ZW5jZSk7CiAgICAgdm9p ZCBlbnF1ZXVlSGFzaGNoYW5nZUV2ZW50KGNvbnN0IFN0cmluZyYgb2xkVVJMLCBjb25zdCBTdHJp bmcmIG5ld1VSTCk7CiAgICAgdm9pZCBlbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gc3RhdGVPYmplY3QpOwpAQCAtMTExNiw4ICsxMTE1LDYgQEAg cHJpdmF0ZToKIAogICAgIHZvaWQgY3JlYXRlU3R5bGVTZWxlY3RvcigpOwogCi0gICAgdm9pZCBw ZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopOwotCiAgICAgUGFzc1JlZlB0 cjxOb2RlTGlzdD4gaGFuZGxlWmVyb1BhZGRpbmcoY29uc3QgSGl0VGVzdFJlcXVlc3QmLCBIaXRU ZXN0UmVzdWx0JikgY29uc3Q7CiAKICAgICB2b2lkIGxvYWRFdmVudERlbGF5VGltZXJGaXJlZChU aW1lcjxEb2N1bWVudD4qKTsKQEAgLTEzNDAsOSArMTMzNyw2IEBAIHByaXZhdGU6CiAKICAgICBi b29sIG1fdXNpbmdHZW9sb2NhdGlvbjsKIAotICAgIFRpbWVyPERvY3VtZW50PiBtX3BlbmRpbmdF dmVudFRpbWVyOwotICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID4gbV9wZW5kaW5nRXZlbnRRdWV1 ZTsKLQogI2lmIEVOQUJMRShXTUwpCiAgICAgYm9vbCBtX2NvbnRhaW5zV01MQ29udGVudDsKICNl bmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAgYi9XZWJDb3JlL2Rv bS9FdmVudFF1ZXVlLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jYmZjNTIyOWRhN2NhMjMzZThiYjAyNzI3ZjEy YTdhY2RkODNkZjU1Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5j cHAKQEAgLTAsMCArMSw4NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5j LiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKKworI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVk ZSAiRXZlbnQuaCIKKyNpbmNsdWRlICJOb2RlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor RXZlbnRRdWV1ZTo6RXZlbnRRdWV1ZShQYXNzUmVmUHRyPE5vZGU+IHRhcmdldCkKKyAgICA6IG1f dGFyZ2V0KHRhcmdldCkKKyAgICAsIG1fcGVuZGluZ0V2ZW50VGltZXIodGhpcywgJkV2ZW50UXVl dWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCit7Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5x dWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQoreworICAgIG1fcGVuZGluZ0V2ZW50 UXVldWUuYXBwZW5kKGV2ZW50KTsKKyAgICBpZiAoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3Rp dmUoKSkKKyAgICAgICAgbV9wZW5kaW5nRXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisK K3ZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQoUGFzc1Jl ZlB0cjxFdmVudD4gcHJwRXZlbnQpCit7CisgICAgUmVmUHRyPEV2ZW50PiBldmVudCA9IHBycEV2 ZW50OworICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxFdmVudD4gPjo6Y29uc3RfaXRlcmF0b3Ig SXRlcmF0b3I7CisgICAgSXRlcmF0b3IgZW5kID0gbV9wZW5kaW5nRXZlbnRRdWV1ZS5lbmQoKTsK KyAgICBmb3IgKEl0ZXJhdG9yIGl0ID0gbV9wZW5kaW5nRXZlbnRRdWV1ZS5iZWdpbigpOyBpdCAh PSBlbmQ7ICsraXQpIHsKKyAgICAgIGlmIChldmVudC0+dHlwZSgpID09ICgqaXQpLT50eXBlKCkp CisgICAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICAKKyAgICBlbnF1ZXVlRXZlbnQoZXZlbnQp OworfQorCit2b2lkIEV2ZW50UXVldWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RXZl bnRRdWV1ZT4qKQoreworICAgIEFTU0VSVCghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgp KTsKKyAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IGV2ZW50UXVldWU7CisgICAgZXZlbnRRdWV1 ZS5zd2FwKG1fcGVuZGluZ0V2ZW50UXVldWUpOworICAgIAorICAgIGlmICghbV90YXJnZXQtPmlu RG9jdW1lbnQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRy PEV2ZW50PiA+Ojpjb25zdF9pdGVyYXRvciBJdGVyYXRvcjsKKyAgICBJdGVyYXRvciBlbmQgPSBl dmVudFF1ZXVlLmVuZCgpOworICAgIGZvciAoSXRlcmF0b3IgaXQgPSBldmVudFF1ZXVlLmJlZ2lu KCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAgZGlzcGF0Y2hFdmVudCgqaXQpOworfQorCit2 b2lkIEV2ZW50UXVldWU6OmRpc3BhdGNoRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCit7 CisgICAgaWYgKG1fdGFyZ2V0LT5kb2N1bWVudCgpID09IG1fdGFyZ2V0LmdldCgpKQorICAgICAg ICBtX3RhcmdldC0+ZG9jdW1lbnQoKS0+ZGlzcGF0Y2hXaW5kb3dFdmVudChldmVudCk7CisgICAg ZWxzZQorICAgICAgICBtX3RhcmdldC0+ZGlzcGF0Y2hFdmVudChldmVudCk7Cit9CisKK30KZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVl dWUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi42OGQ5MzliZDdjOTQzYmQ1ZTI5ZGYzMGM4MWQzNmI0NzdkNzIyODlh Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCkBAIC0wLDAgKzEs NTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBS ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICog UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us IERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4gCisgKgorICovCisKKyNpZm5kZWYgRXZlbnRRdWV1ZV9oCisjZGVmaW5lIEV2ZW50 UXVldWVfaAorCisjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+Cisj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEV2 ZW50OworY2xhc3MgTm9kZTsKKworY2xhc3MgRXZlbnRRdWV1ZSB7CitwdWJsaWM6CisgICAgRXZl bnRRdWV1ZShQYXNzUmVmUHRyPE5vZGU+IHRhcmdldCk7CisKKyAgICB2b2lkIGVucXVldWVFdmVu dChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCk7CisgICAgdm9pZCBlbnF1ZXVlRXZlbnRJZk5vdEFs cmVhZHlFbnF1ZXVlZChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCk7CisKK3ByaXZhdGU6CisgICAg dm9pZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPEV2ZW50UXVldWU+Kik7CisgICAgdm9p ZCBkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KTsKKworICAgIFJlZlB0cjxO b2RlPiBtX3RhcmdldDsKKyAgICBUaW1lcjxFdmVudFF1ZXVlPiBtX3BlbmRpbmdFdmVudFRpbWVy OworICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID4gbV9wZW5kaW5nRXZlbnRRdWV1ZTsKK307CisK K30KKworI2VuZGlmIC8vIEV2ZW50UXVldWVfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vTm9k ZS5jcHAgYi9XZWJDb3JlL2RvbS9Ob2RlLmNwcAppbmRleCBlNzFjNGJkZmUwOWYxNzdiM2U2NWRl ZmViNGI3OTU2MzM5NjE0NzdiLi40Njk5NDk2OTk2ZGRjZTc5YjdlY2VmMmI1MTFjZDg4ZDgxZGNj YjIzIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAorKysgYi9XZWJDb3JlL2RvbS9O b2RlLmNwcApAQCAtMjU1MCw2ICsyNTUwLDE2IEBAIGJvb2wgTm9kZTo6ZGlzcGF0Y2hFdmVudChQ YXNzUmVmUHRyPEV2ZW50PiBwcnBFdmVudCkKICAgICByZXR1cm4gZGlzcGF0Y2hHZW5lcmljRXZl bnQoZXZlbnQucmVsZWFzZSgpKTsKIH0KIAordm9pZCBOb2RlOjplbnF1ZXVlRXZlbnQoUGFzc1Jl ZlB0cjxFdmVudD4gZXZlbnQpCit7CisgICAgZW5zdXJlUmFyZURhdGEoKS0+ZW5zdXJlRXZlbnRR dWV1ZSh0aGlzKS0+ZW5xdWV1ZUV2ZW50KGV2ZW50KTsKK30KKwordm9pZCBOb2RlOjplbnF1ZXVl RXZlbnRJZk5vdEFscmVhZHlFbnF1ZXVlZChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCkKK3sKKyAg ICBlbnN1cmVSYXJlRGF0YSgpLT5lbnN1cmVFdmVudFF1ZXVlKHRoaXMpLT5lbnF1ZXVlRXZlbnRJ Zk5vdEFscmVhZHlFbnF1ZXVlZChldmVudCk7Cit9CisKIHN0YXRpYyBjb25zdCBFdmVudENvbnRl eHQqIHRvcEV2ZW50Q29udGV4dChjb25zdCBWZWN0b3I8RXZlbnRDb250ZXh0PiYgYW5jZXN0b3Jz KQogewogICAgIHJldHVybiBhbmNlc3RvcnMuaXNFbXB0eSgpID8gMCA6ICZhbmNlc3RvcnMubGFz dCgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vTm9kZS5oIGIvV2ViQ29yZS9kb20vTm9kZS5o CmluZGV4IDY3NWRlMDRkMTlhYWIxYzU1MGE4MzRiNzkxMzliZTA4ZmY2NDk0MDUuLjFhZjBmN2I5 NGNhZTY5ZmNhNjA3Yzk0NzM2NDYwZWMyN2QwNGVkYzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9t L05vZGUuaAorKysgYi9XZWJDb3JlL2RvbS9Ob2RlLmgKQEAgLTUxNyw2ICs1MTcsOCBAQCBwdWJs aWM6CiAKICAgICB1c2luZyBFdmVudFRhcmdldDo6ZGlzcGF0Y2hFdmVudDsKICAgICB2aXJ0dWFs IGJvb2wgZGlzcGF0Y2hFdmVudChQYXNzUmVmUHRyPEV2ZW50Pik7CisgICAgdm9pZCBlbnF1ZXVl RXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQgZW5xdWV1ZUV2ZW50SWZOb3RBbHJl YWR5RW5xdWV1ZWQoUGFzc1JlZlB0cjxFdmVudD4pOwogCiAgICAgYm9vbCBkaXNwYXRjaEdlbmVy aWNFdmVudChQYXNzUmVmUHRyPEV2ZW50Pik7CiAgICAgdmlydHVhbCB2b2lkIGhhbmRsZUxvY2Fs RXZlbnRzKEV2ZW50Kik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Ob2RlUmFyZURhdGEuaCBi L1dlYkNvcmUvZG9tL05vZGVSYXJlRGF0YS5oCmluZGV4IGFiMjA4ZDIyYWY4ZDBjOGM3YWQzMTVk ZTQ4N2E3M2E4MDc0ZmJjNWMuLjk0MTE3MzQ1ZDFhNjVkYjE3MGRlYWRhNjc5YTUzOWJlMzEyODc1 ZTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGVSYXJlRGF0YS5oCisrKyBiL1dlYkNvcmUv ZG9tL05vZGVSYXJlRGF0YS5oCkBAIC0yNCw2ICsyNCw3IEBACiAKICNpbmNsdWRlICJDbGFzc05v ZGVMaXN0LmgiCiAjaW5jbHVkZSAiRHluYW1pY05vZGVMaXN0LmgiCisjaW5jbHVkZSAiRXZlbnRR dWV1ZS5oIgogI2luY2x1ZGUgIk5hbWVOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlF1YWxpZmllZE5h bWUuaCIKICNpbmNsdWRlICJUYWdOb2RlTGlzdC5oIgpAQCAtMTEyLDYgKzExMywxMyBAQCBwdWJs aWM6CiAKICAgICBib29sIGlzRm9jdXNlZCgpIGNvbnN0IHsgcmV0dXJuIG1faXNGb2N1c2VkOyB9 CiAgICAgdm9pZCBzZXRGb2N1c2VkKGJvb2wgZm9jdXNlZCkgeyBtX2lzRm9jdXNlZCA9IGZvY3Vz ZWQ7IH0KKyAgICAKKyAgICBFdmVudFF1ZXVlKiBlbnN1cmVFdmVudFF1ZXVlKFBhc3NSZWZQdHI8 Tm9kZT4gdGFyZ2V0KQorICAgIHsKKyAgICAgICAgaWYgKCFtX2V2ZW50UXVldWUpCisgICAgICAg ICAgICBtX2V2ZW50UXVldWUuc2V0KG5ldyBFdmVudFF1ZXVlKHRhcmdldCkpOworICAgICAgICBy ZXR1cm4gbV9ldmVudFF1ZXVlLmdldCgpOworICAgIH0KIAogcHJvdGVjdGVkOgogICAgIC8vIGZv ciBFbGVtZW50UmFyZURhdGEKQEAgLTEyMSw2ICsxMjksNyBAQCBwcm90ZWN0ZWQ6CiBwcml2YXRl OgogICAgIE93blB0cjxOb2RlTGlzdHNOb2RlRGF0YT4gbV9ub2RlTGlzdHM7CiAgICAgT3duUHRy PEV2ZW50VGFyZ2V0RGF0YT4gbV9ldmVudFRhcmdldERhdGE7CisgICAgT3duUHRyPEV2ZW50UXVl dWU+IG1fZXZlbnRRdWV1ZTsKICAgICBzaG9ydCBtX3RhYkluZGV4OwogICAgIGJvb2wgbV90YWJJ bmRleFdhc1NldEV4cGxpY2l0bHkgOiAxOwogICAgIGJvb2wgbV9pc0ZvY3VzZWQgOiAxOwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9XZWJDb3JlL3BhZ2UvRXZl bnRIYW5kbGVyLmNwcAppbmRleCBmNmEyMzUzODE1ZjYxYWRiZDFkYzQxODEwMDVlMjVjYTA3NmJh YmExLi4zYWYxY2VmNzEzN2JiYjQxOTc0MTlhNDk4YzY3NTIzZDkzYWVhYTM4IDEwMDY0NAotLS0g YS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRXZlbnRI YW5kbGVyLmNwcApAQCAtMjc1Nyw3ICsyNzU3LDcgQEAgdm9pZCBFdmVudEhhbmRsZXI6OnNlbmRT Y3JvbGxFdmVudCgpCiB7CiAgICAgc2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpOwogICAgIGlm IChtX2ZyYW1lLT52aWV3KCkgJiYgbV9mcmFtZS0+ZG9jdW1lbnQoKSkKLSAgICAgICAgbV9mcmFt ZS0+ZG9jdW1lbnQoKS0+ZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5z Y3JvbGxFdmVudCwgdHJ1ZSwgZmFsc2UpKTsKKyAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+ ZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQoRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkuc2Nyb2xsRXZlbnQsIHRydWUsIGZhbHNlKSk7CiB9CiAKIHZvaWQgRXZlbnRIYW5kbGVyOjpz ZXRGcmFtZVdhc1Njcm9sbGVkQnlVc2VyKCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckxheWVyLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAppbmRl eCA3YjkwMDBjNjU1M2EyNDYyNWEwMGI2NjY2MWI4ODQzZDAyNzYxZjhiLi45ZDJmODMzNDJlNDRk YzU0ZDg3NmQ2Njg5MzhhOThhY2FlODQyMGI5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMYXllci5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3Bw CkBAIC0xMzk3LDEwICsxMzk3LDggQEAgdm9pZCBSZW5kZXJMYXllcjo6c2Nyb2xsVG9PZmZzZXQo aW50IHgsIGludCB5LCBib29sIHVwZGF0ZVNjcm9sbGJhcnMsIGJvb2wgcmVwYWkKICAgICB9CiAK ICAgICAvLyBTY2hlZHVsZSB0aGUgc2Nyb2xsIERPTSBldmVudC4KLSAgICBpZiAodmlldykgewot ICAgICAgICBpZiAoRnJhbWVWaWV3KiBmcmFtZVZpZXcgPSB2aWV3LT5mcmFtZVZpZXcoKSkKLSAg ICAgICAgICAgIGZyYW1lVmlldy0+c2NoZWR1bGVFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFt ZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZhbHNlKSwgcmVuZGVyZXIoKS0+bm9kZSgpKTsKLSAg ICB9CisgICAgaWYgKHZpZXcgJiYgdmlldy0+ZnJhbWVWaWV3KCkpCisgICAgICAgIHJlbmRlcmVy KCktPm5vZGUoKS0+ZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQoRXZlbnQ6OmNyZWF0 ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGZhbHNlLCBmYWxzZSkpOwogfQogCiB2b2lkIFJl bmRlckxheWVyOjpzY3JvbGxSZWN0VG9WaXNpYmxlKGNvbnN0IEludFJlY3QmIHJlY3QsIGJvb2wg c2Nyb2xsVG9BbmNob3IsIGNvbnN0IFNjcm9sbEFsaWdubWVudCYgYWxpZ25YLCBjb25zdCBTY3Jv bGxBbGlnbm1lbnQmIGFsaWduWSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxpc3RCb3guY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAKaW5kZXgg NTMyYzU1MTJkNzhiNDk1ZjcyZWYzMzliMGZmNmQ3OGY0N2Q1MjRlMS4uMDQwZjlkMjY4ZGRhMmZj ZGNkYzJhZTk4MjVjYzM3NzZiN2QwNTFhYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyTGlzdEJveC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5j cHAKQEAgLTU0MCw3ICs1NDAsNyBAQCB2b2lkIFJlbmRlckxpc3RCb3g6OnZhbHVlQ2hhbmdlZChT Y3JvbGxiYXIqKQogICAgIGlmIChuZXdPZmZzZXQgIT0gbV9pbmRleE9mZnNldCkgewogICAgICAg ICBtX2luZGV4T2Zmc2V0ID0gbmV3T2Zmc2V0OwogICAgICAgICByZXBhaW50KCk7Ci0gICAgICAg IG5vZGUoKS0+ZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxF dmVudCwgZmFsc2UsIGZhbHNlKSk7CisgICAgICAgIG5vZGUoKS0+ZW5xdWV1ZUV2ZW50SWZOb3RB bHJlYWR5RW5xdWV1ZWQoRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGZh bHNlLCBmYWxzZSkpOwogICAgIH0KIH0KIAo= 73934 2010-11-15 15:08:26 -0800 2010-11-15 17:13:33 -0800 Patch bug-45631-20101115150825.patch text/plain 43144 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNDkwNTVlYWI4MTJkMjRjODk3YzdiNGRmNjUxODBlMGVkMmMzN2M1Li5iYWMwODMz ODlhYTM3MDdmYjU1YmE5ZWQ5ZTU4ZTFkY2IzYjE3YjFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuIEFkZGl0aW9uYWxseSwgZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbCBub3cgCisgICAgICAgIGV4cGxpY2l0bHkgdGVzdHMgZm9yIHN5bmNocm9ub3Vz IGJlaGF2aW9yIHdoZW4gc2Nyb2xsaW5nIHRoZSBkb2N1bWVudCwKKyAgICAgICAgYW5kIHRoYXQg d2UgZG9uJ3QgZmlyZSB0aGUgZXZlbnQgbW9yZSB0aGFuIG9uY2UuCisgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBkb2VzIHRoZSBzYW1lIGZvciBzY3Jv bGwKKyAgICAgICAgZXZlbnRzIG9uIHNjcm9sbGFibGUgZWxlbWVudHMuCisKKyAgICAgICAgKiBl ZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFz dC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBm cm9tIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sOgorICAg ICAgICAqIGZhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sOgorICAgICAgICAq IGZhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbDoKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWw6CisgICAgICAgICog ZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sOgorICAgICAgICAqIGZh c3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sOgorICAgICAgICAq IGZhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbDoKKwogMjAxMC0xMS0xNSAg TWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10g TmF2aWdhdGlvbiBwb2xpY3kgZGVjaXNpb24gQVBJIG5lZWRzIHRvIGluY2x1ZGUgdGhlIERPTSBu b2RlIHRoYXQgdGhlIGRlY2lzaW9uIG9yaWdpbmF0ZWQgZnJvbQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dAppbmRleCAyNGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNkNjY0Li5iNWIwY2Yw ZjU0NmMyZTQxZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dApAQCAtMSw0ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy4KK1RoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25j ZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9s bCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMgbm93LgogUEFTUwog KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZjODNiMTQ4MjNkMmVk NzBkYjMyNTAwODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEyMjdjMWM5Mzg2ZmQ5 ZjQ5YjQ2YmEyNWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11 cC1kb3duLXNjcm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2Ut dXAtZG93bi1zY3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1sPgogPGhlYWQ+CiA8 c2NyaXB0PgotaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQogCi1mdW5j dGlvbiBzY3IoKQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKCkgewog ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQgKz0gJ3gnOworCisg ICAgc3dpdGNoIChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAod2luZG93LmV2ZW50 U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFnZVVwJyk7CisgICAg ICAgICAgICBicmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdyZXN1bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgc3RlcCsrOwogfQog CiBmdW5jdGlvbiBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikKLSAg ICAgICAgcmV0dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNj ciwgZmFsc2UpOwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iKTsKLSAgICB2 YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQ7Ci0gICAg aWYgKHRleHQgIT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHgsIG5v dCAiICsgdGV4dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIpOwotICAgIHZh ciB0ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBp ZiAodGV4dCAhPSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHh4LCBu b3QgIiArIHRleHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlu bmVyVGV4dCA9ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICBl dmVudFNlbmRlci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+CiA8L2hlYWQ+CiA8 Ym9keSBvbmxvYWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5bGU9InBvc2l0aW9u OmZpeGVkIj48L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy48L2Rpdj4KKzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBh Z2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3Rs eSBvbmUgc2Nyb2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBu b3cuPC9kaXY+CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2IHN0eWxlPSJoZWln aHQ6NTAwMDBweCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwvZGl2PiAKIDxzY3Jp cHQ+IApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xMWEyZTIyZjY5MGI1 ZmIyN2RhOTMzYTA4NTQ0ZGNjZTlmMjBlZWE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0IEBACitQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKDAsIDIwMCkKK0lmIHRoZSB3 b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFp bGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQg bm90IGZpcmUsIGZpcmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgor CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hY2Q2NmUxNGQ2NGViODFlZDUyNWRjOTlhN2U1NDQz NTgwYWUzYjhhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmly ZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNTIgQEAKKzxodG1sPgorPHNj cmlwdD4KK3ZhciBldmVudENvdW50ID0gMDsKK3ZhciBkb25lVGltZW91dDsKKworZnVuY3Rpb24g c2Nyb2xsSGFuZGxlcigpCit7CisgICAgZXZlbnRDb3VudCsrOworICAgIGlmIChldmVudENvdW50 ID09IDEpIHsKKyAgICAgICAgdmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdjb250YWluZXInKTsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBjb250YWluZXIuc2Nyb2xsTGVm dDsKKyAgICAgICAgdmFyIHNjcm9sbFkgPSBjb250YWluZXIuc2Nyb2xsVG9wOworICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnUEFTU0VELCBz Y3JvbGwgcG9zaXRpb246ICgnICsgc2Nyb2xsWCArICcsICcgKyBzY3JvbGxZICsgJyknOworICAg ICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVy ZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBz ZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgICAgICAgICB9LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFy VGltZW91dChkb25lVGltZW91dCk7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdy ZXN1bHQnKS50ZXh0Q29udGVudCA9ICdGQUlMLCBzY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAn ICsgZXZlbnRDb3VudCArICcgdGltZXMnOworICAgIH0KK30KKworb25sb2FkID0gZnVuY3Rpb24o KQoreworICAgIHZhciBjb250YWluZXIgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFp bmVyJyk7CisgICAgY29udGFpbmVyLmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbEhh bmRsZXIsIGZhbHNlKTsKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIH0KKyAgICBjb250YWluZXIuc2Ny b2xsVG9wID0gMTAwOworICAgIGlmIChldmVudENvdW50ID4gMCkgeworICAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlMRUQsIGV2ZW50IGZpcmVk IHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOyAgICAg IAorICAgIH0KKyAgICBjb250YWluZXIuc2Nyb2xsVG9wID0gMjAwOworfQorCis8L3NjcmlwdD4K Kzxib2R5PgorPGRpdiBpZD0icmVzdWx0Ij5GQUlMLCBldmVudCBkaWQgbm90IGZpcmU8L2Rpdj4K KworPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3ZlLCB0aGVuIHRo ZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0aGF0IGEgc2Ny b2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3IgZmlyZWQgbW9y ZSB0aGFuIG9uY2UuPC9wPgorCis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0iaGVpZ2h0 OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPC9ib2R5PgorPC9odG1s PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dAppbmRleCAxNjg2Y2VkMzlh ZTJiZTJkNTliNjNlOWQzZmRhZTRiMWUyYzg4NjU2Li4xMGY4ZTQzOTAyYmQxODQ2YWRkMjI1ZGU2 YzJlODAwYWZhNTEyZTYzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJl LXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv ZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CkBAIC0xLDU5ICsxLDQgQEAKLVBBU1NFRAor UEFTU0VELCBzY3JvbGwgcG9zaXRpb246ICgyMDAsIDIwMCkKK0lmIHRoZSB3b3JkICdQQVNTRUQn IGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUg dGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUsIGZp cmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgogCi1JZiB0aGUgd29y ZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxl ZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5v dCBmaXJlLgotCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCmlu ZGV4IGEwNTZjMDY3YmQ5ZjI3YzRiMzQ2NWM4NGExNmUyMWE5ZmEzZTcxNGMuLjdjZDBhNTZkMGE4 NDAzNTFhMjQ4N2RlODNkZTc0MjhlMjhhMDAwMTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbApAQCAtMSwzMCArMSw0NyBAQAogPGh0bWw+CiA8 c2NyaXB0PgotdmFyIGV2ZW50RmlyZWQgPSBmYWxzZTsKK3ZhciBldmVudENvdW50ID0gMDsKK3Zh ciBkb25lVGltZW91dDsKIAotZnVuY3Rpb24gc2Nyb2xsZXIoKSB7Ci0gICAgaWYgKCFldmVudEZp cmVkKSB7Ci0gICAgICAgIGV2ZW50RmlyZWQgPSB0cnVlOwotICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFzc2VkIikuaW5uZXJIVE1MID0gIjxwIHN0eWxlPSdjb2xvcjpyZWQnPlBB U1NFRDwvcD4iOworb25zY3JvbGwgPSBmdW5jdGlvbigpCit7CisgICAgZXZlbnRDb3VudCsrOwor ICAgIGlmIChldmVudENvdW50ID09IDEpIHsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBkb2N1bWVu dC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gZG9jdW1lbnQuYm9keS5z Y3JvbGxUb3A7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS50ZXh0 Q29udGVudCA9ICdQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyAr IHNjcm9sbFkgKyAnKSc7CisgICAgICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdo dCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29taW5nLgorICAg ICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0sIDEwMCk7CisgICAgfSBl bHNlIHsKKyAgICAgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1lb3V0KTsKKyAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLnRleHRDb250ZW50ID0gJ0ZBSUwsIHNjcm9sbCBo YW5kbGVyIHdhcyBpbnZva2VkICcgKyBldmVudENvdW50ICsgJyB0aW1lcyc7CiAgICAgfQogfQog Ci13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVu ZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7Ci0gICAgd2luZG93LnNjcm9sbFRvKDUwMCwg NTAwKTsKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUo KTsKICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwogICAgIH0KKyAg ICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDApOworICAgIGlmIChldmVudENvdW50ID4gMCkgewor ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlM RUQsIGV2ZW50IGZpcmVkIHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOyAgICAgIAorICAgIH0KKyAgICB3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOwog fQogCiA8L3NjcmlwdD4KIDxib2R5PgotPGRpdiBpZD0icGFzc2VkIj48L2Rpdj4KKzxkaXYgaWQ9 InJlc3VsdCI+RkFJTCwgZXZlbnQgZGlkIG5vdCBmaXJlPC9kaXY+CiAKLTxwPklmIHRoZSB3b3Jk ICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVk LiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90 IGZpcmUuPC9wPgorPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3Zl LCB0aGVuIHRoZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0 aGF0IGEgc2Nyb2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3Ig ZmlyZWQgbW9yZSB0aGFuIG9uY2UuPC9wPgogCi1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxi cj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgotYTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+Cis8ZGl2IHN0eWxlPSJoZWlnaHQ6IDUwMDBweDsgd2lkdGg6IDUw MDBweDsiPjwvZGl2PgogPC9ib2R5PgogPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZp bGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNj cm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xs Lmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZlNTAyMjc4ZDM2ZWYxOGUwNzFmY2IzNjU0Y2MzNS4uZWFi YjA3OWVhY2FhNzliODhlMGYwYWFkYTcwMTk1ZGUzOGIzNjNiOCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKQEAgLTksMTcgKzks MjggQEAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRpc3BhdGNoU2Nyb2xsRXZlbnRzKCkKICAgICAg ICAgICAgIHsKICAgICAgICAgICAgICAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyICYmIHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2Vu ZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAwKTsKICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5k ZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7Ci0gICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVy Lm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKLSAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgICAgICAgICB2YXIgc2Nyb2xsQ291 bnQgPSAwOworICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHYn KS5hZGRFdmVudExpc3RlbmVyKAorICAgICAgICAgICAgICAgICAgICAgICAgJ3Njcm9sbCcsCisg ICAgICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbihldmVudCkgeworICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzLnJlbW92ZUNoaWxkKHRoaXMuZmlyc3RDaGlsZCkKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgc2Nyb2xsQ291bnQrKzsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg aWYgKHNjcm9sbENvdW50ID09IDEpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVu dFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAtMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy Lm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0sCisgICAgICAgICAgICAg ICAgICAgICAgICBmYWxzZSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAg ICAgICA8L3NjcmlwdD4KICAgICA8L2hlYWQ+CiAgICAgPGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0 KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygpOycsIDEpOyI+CiAgICAgICAgIFRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBiZSByZW1vdmVkIGJ5IHRoZWlyIHBhcmVudCBlbGVtZW50 J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxlci4gIFRoZSB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgaXMg dGhlIG9ubHkgdGV4dCByZW1haW5pbmcgYWZ0ZXIgdGhlIHR3byBzY3JvbGwgZXZlbnRzIGFyZSBk aXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFpbHMgaWYgdGhlIGlubmVyIGRpdiByZW1haW5zIGluIHRo ZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNyYXNoZXMuPGJyPjxicj4KLSAgICAgICAgPGRpdiBpZD0i ZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3 aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNjcm9sbD0idGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0 Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lk dGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7Ij4KICAgICAgICAg PGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7IGhlaWdodDozMDBweCI+TG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmlt IGFkIG1pbmltIHZlbmlhbSwgcXVpcyBub3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9y aXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVhIGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1 cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJpdCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0g ZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBwYXJpYXR1ci4gRXhjZXB0ZXVyIHNpbnQgb2NjYWVjYXQg Y3VwaWRhdGF0IG5vbiBwcm9pZGVudCwgc3VudCBpbiBjdWxwYSBxdWkgb2ZmaWNpYSBkZXNlcnVu dCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFib3J1bQogICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9k aXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwKaW5kZXggNGZjMTUyODRkZWYxZjU4ZDkzNzM1ZmFjYWRlNGE1NmQ3MTBk NTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4MjUzM2FjYjA0NDJhOTJjZTcyNzFmZiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1s CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2Uu aHRtbApAQCAtMTYsNiArMTYsOSBAQAogICAgIGZ1bmN0aW9uIHNjcm9sbGVkKGV2ZW50KQogICAg IHsKICAgICAgICAgZXZlbnQudGFyZ2V0LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZXZlbnQudGFy Z2V0KTsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CiAgICAg fQogCiAgICAgZnVuY3Rpb24gdGVzdCgpCkBAIC0yNyw3ICszMCw5IEBACiAgICAgICAgIGRvY3Vt ZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7CiAgICAgfQogCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgIH0KICAgICB0ZXN0KCk7CiA8L3Nj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1k b2VzLW5vdC1idWJibGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVu dC1kb2VzLW5vdC1idWJibGUuaHRtbAppbmRleCAyMjJhZGE4MDVkYTUzMDYyMmU0ZjgxZjViZGNl ZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3NDMzZGU4YWJlZTZmMzY3MTUxZTUyMDNlMmVlZDQwIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3Qt YnViYmxlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0xLDExICsxLDIyIEBACiA8aHRtbD4KIDxzY3JpcHQ+Cit2 YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBmYWxzZTsKK3ZhciBkb25lVGltZW91dDsKKwogZnVuY3Rp b24gd2luZG93U2Nyb2xsZWQoKSB7CisgICAgd2luZG93V2FzU2Nyb2xsZWQgPSB0cnVlOwogICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTFVSRTog d2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxsZWQuJzsgCisgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1l b3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9uIGRpdlNjcm9sbGVkKCkgewotICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xs IHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cub25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICBpZiAoIXdp bmRvd1dhc1Njcm9sbGVkKQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0 JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2lu ZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0 cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcv YnViYmxpbmcuCisgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9LCAxMDApOyAgICAKIH0KIAog ZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAgLTI0LDEwICszNSw2IEBAIGZ1bmN0aW9uIHJ1blRlc3Qo KSB7CiAgICAgCiAgICAgLy8gRG9uJ3QgcG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25z ZW5zZS4KICAgICBkaXYuaW5uZXJIVE1MID0gJyc7Ci0gICAgCi0gICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgCi0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKLSAgICAKIH0KIAogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwKaW5kZXggYmExYTM1MTY0YzU2 YjJjNDFlYTM4MGJlYTc2M2U3ZTRhMWU1OWY5OC4uZDJmOWFjNjQ1ZTdkNjFiNDUwMWIxYjJiOGY1 MGZiNjY5NTc3YTU2MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3Jl bW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbApAQCAtMTEsMjkgKzExLDMzIEBACiA8cD4KICAg ICBSZXN1bHQ6IDxzcGFuIGlkPSJyZXN1bHQiPnRlc3QgZGlkIG5vdCBjb21wbGV0ZS48L3NwYW4+ CiA8L3A+Ci08ZGl2IGlkPSJ0IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsg aGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAob3ZlcmZsb3dSZW1vdmUpIHRoaXMucGFyZW50 Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBpZD0idCIgc3R5bGU9Im92ZXJmbG93OiBh dXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0idGhpcy5wYXJlbnRO b2RlLnJlbW92ZUNoaWxkKHRoaXMpO2hhbmRsZVNjcm9sbCgwKTsiPgogICAgIDxkaXYgc3R5bGU9 ImhlaWdodDogMjAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogCi08ZGl2IHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9ImlmIChzZWNvbmRP dmVyZmxvd1JlbW92ZSkgdGhpcy5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHRoaXMpOyI+Cis8ZGl2 IHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25z Y3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTtoYW5kbGVTY3JvbGwoMSk7 Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+PC9kaXY+CiAgICAgPGRpdiBpZD0i ZCI+PC9kaXY+CiA8L2Rpdj4KIAogPHNjcmlwdD4KLSAgICB2YXIgb3ZlcmZsb3dSZW1vdmUgPSBm YWxzZTsKLSAgICB2YXIgc2Vjb25kT3ZlcmZsb3dSZW1vdmUgPSBmYWxzZTsKKyAgICB2YXIgc2Ny b2xsZWRGaXJzdENvbnRhaW5lciA9IGZhbHNlOworICAgIHZhciBzY3JvbGxlZFNlY29uZENvbnRh aW5lciA9IGZhbHNlOwogCiAgICAgZG9jdW1lbnQuYm9keS5vZmZzZXRUb3A7IHQuc2Nyb2xsVG9w ID0gMjA7CiAKLSAgICBvdmVyZmxvd1JlbW92ZSA9IHRydWU7Ci0gICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3QnKS5pbm5lckhUTUwgPSAnJzsKLQotICAgIHNlY29uZE92ZXJmbG93UmVtb3Zl ID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZCcpLnNjcm9sbEludG9WaWV3 KCk7CiAgICAgCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4 dCA9ICJTVUNDRVNTIjsKLQotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCi0g ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICBmdW5jdGlvbiBo YW5kbGVTY3JvbGwoaW5kZXgpCisgICAgeworICAgICAgICBpZiAoaW5kZXggPT0gMCkgc2Nyb2xs ZWRGaXJzdENvbnRhaW5lciA9IHRydWU7CisgICAgICAgIGVsc2UgaWYgKGluZGV4ID09IDEpIHNj cm9sbGVkU2Vjb25kQ29udGFpbmVyID0gdHJ1ZTsKKyAgICAgICAgCisgICAgICAgIGlmIChzY3Jv bGxlZEZpcnN0Q29udGFpbmVyICYmIHNjcm9sbGVkU2Vjb25kQ29udGFpbmVyKSB7CisgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJUZXh0ID0gIlNVQ0NF U1MiOworICAgICAgICAKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgICAgICB9CisgICAgfQogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCmluZGV4IDY0 YjIwYWM0YWVmZGNkNTYxNGQyYzQ4YzAzZTZjZDJhMzIyYmQ0ZGUuLjM1NzQxMmZlMjNmYjY2YzVk ZWMxZGEwNThhZWE3NTJiZTM2MTA3OGIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3Qvb3Zl cmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCisrKyBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCkBAIC0xLDE0 ICsxLDE2IEBACiA8aGVhZD4KIDxzY3JpcHQ+CiBmdW5jdGlvbiB0ZXN0KCkgewotICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICB9CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIml0Iikuc2Nyb2xsVG9wID0gMTAwOwogfQogPC9zY3Jp cHQ+CiA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CiA8cD5UaGlzIHRlc3QgaW52b2x2ZXMgYSBsYXll ciB0aGF0IHNlbGYtZGVzdHJ1Y3RzIHdoZW4gc2Nyb2xsZWQuIElmIHRoZXJlJ3Mgbm8gY3Jhc2gs IHRoZW4gdGhlIHRlc3Qgc3VjY2VlZGVkLjwvcD4KLTxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0 OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9uc2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUn Ij4KKzxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9u c2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUnO2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsiPgogPGRpdiBzdHlsZT0i aGVpZ2h0OiAyMDAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogPC9ib2R5PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sCmluZGV4IGUzZjBh YzQ0YzE5YmNhNWRiZGUxNGQxMzg3M2EwY2Q1ZjBlZTcyMGMuLmRjNjk3MTIyMTZmN2I1MTY2MGFl MzIyNGIyY2VlYWU0NjFiMTQ0YWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvcmVwYWlu dC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3JlcGFp bnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKQEAgLTMsNiArMyw4IEBACiAgICAgPHNjcmlw dD4KICAgICAgICAgZnVuY3Rpb24gcmVwYWludFRlc3QoKQogICAgICAgICB7CisgICAgICAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAgICAgICAgICAgIHZhciB0YXJnZXQg PSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAgICAgICAgICAgICBzY3JvbGxC eSgwLCAxMDApOwogICAgICAgICB9CkBAIC0xMSw2ICsxMyw4IEBACiAgICAgICAgIHsKICAgICAg ICAgICAgIHZhciB0YXJnZXQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAg ICAgICAgICAgICB0YXJnZXQuc3R5bGUuYmFja2dyb3VuZENvbG9yID0gImdyZWVuIjsKKyAgICAg ICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwogICAgICAgICB9CiAgICAgPC9zY3Jp cHQ+CiA8L2hlYWQ+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0FuZHJvaWQubWsgYi9XZWJDb3JlL0Fu ZHJvaWQubWsKaW5kZXggYjY0ZTMyYjZkODVmNGFjNjJmNzUyYzAyM2I3YTdlZTFjYTA2YTQ0NC4u Y2EwNzRlY2RmZWRkYWJlZGQ3NGEwYzQwNTljZDk1Y2NjMmM4ZmIxOSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9BbmRyb2lkLm1rCisrKyBiL1dlYkNvcmUvQW5kcm9pZC5tawpAQCAtMTM1LDYgKzEzNSw3 IEBAIExPQ0FMX1NSQ19GSUxFUyA6PSAkKExPQ0FMX1NSQ19GSUxFUykgXAogCWRvbS9FdmVudENv bnRleHQuY3BwIFwKIAlkb20vRXZlbnROYW1lcy5jcHAgXAogCWRvbS9FdmVudFRhcmdldC5jcHAg XAorCWRvbS9FdmVudFF1ZXVlLmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkJhc2UuY3BwIFwKIAlkb20v RXhjZXB0aW9uQ29kZS5jcHAgXAogCWRvbS9JbnB1dEVsZW1lbnQuY3BwIFwKZGlmZiAtLWdpdCBh L1dlYkNvcmUvQ01ha2VMaXN0cy50eHQgYi9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDkz MTc2ODdkZGJmYjA4MmE2NDRkNWFmM2MwMDllODU1ZThmM2ViMTIuLmZhMjZkNDg4ZDgwZjEyNGFh NGFhM2YxMjk0Y2M3OTg1NmNlYjQxODkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ01ha2VMaXN0cy50 eHQKKysrIGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtODI2LDYgKzgyNiw3IEBAIFNFVChX ZWJDb3JlX1NPVVJDRVMKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcAogICAgIGRvbS9FdmVudE5h bWVzLmNwcAogICAgIGRvbS9FdmVudFRhcmdldC5jcHAKKyAgICBkb20vRXZlbnRRdWV1ZS5jcHAK ICAgICBkb20vRXhjZXB0aW9uQmFzZS5jcHAKICAgICBkb20vRXhjZXB0aW9uQ29kZS5jcHAKICAg ICBkb20vSW5wdXRFbGVtZW50LmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhZGQzZWM2ZTIyZTc4YTYyYzVmZjJiNDhlZmUyYWUwYTI0 YzI1NjVmLi5lMGQ5NzljYmEzZWVmMjg1MjU2ZWU2ZGFhY2I2NmY5YWM3ZDEyMmZmIDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDQ3IEBACisyMDEwLTExLTE1ICBNaWhhaSBQYXJwYXJpdGEgIDxtaWhhaXBAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNjcm9s bCBldmVudCBzaG91bGQgYmUgZmlyZWQgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NjMxCisKKyAgICAgICAgVGVzdHM6IGZh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbAorCisgICAgICAgIE1ha2VzIHNjcm9s bCBldmVudHMgZmlyZSBhc3luY2hyb25vdXNseSB0byBiZSBpbiBjb21wbGlhbmNlIHdpdGggdGhl CisgICAgICAgIENTU09NIFZpZXcgTW9kdWxlIGFuZCBjb25zaXN0ZW50IHdpdGggR2Vja28sIE9w ZXJhIGFuZCAodG8gc29tZSBkZWdyZWUpCisgICAgICAgIElFLgorCisgICAgICAgIFRoaXMgaXMg YWNjb21wbGlzaGVkIGJ5IG1vdmluZyB0aGUgRG9jdW1lbnQ6OmVucXVldWVFdmVudCBhbmQgc3Vw cG9ydGluZworICAgICAgICBjb2RlIHRvIGEgc3RhbmRhbG9uZSBFdmVudFF1ZXVlIGNsYXNzLiBO b2RlIGFsc28gZ2V0cyBjb252ZW5pZW5jZQorICAgICAgICBlbnF1ZXVlRXZlbnQoSWZOb3RBbHJl YWR5RW5xdWV1ZWQpIG1ldGhkb2RzIHRoYXQgZW5xdWV1ZSBpbiB0aGUgbm9kZSdzCisgICAgICAg IGRvY3VtZW50J3MgZXZlbnQgcXVldWUuCisgICAgICAgIAorICAgICAgICAqIEFuZHJvaWQubWs6 CisgICAgICAgICogQ01ha2VMaXN0cy50eHQ6CisgICAgICAgICogR05VbWFrZWZpbGUuYW06Cisg ICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAq IFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3Vt ZW50OjplbnF1ZXVlRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmVucXVldWVF dmVudElmTm90QWxyZWFkeUVucXVldWVkKTogICAgICAgIAorICAgICAgICAqIGRvbS9Eb2N1bWVu dC5oOgorICAgICAgICAqIGRvbS9FdmVudFF1ZXVlLmNwcDogQWRkZWQuCisgICAgICAgICogZG9t L0V2ZW50UXVldWUuaDogQWRkZWQuCisgICAgICAgICogZG9tL05vZGUuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Tm9kZTo6ZW5xdWV1ZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6Ok5vZGU6OmVu cXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKToKKyAgICAgICAgKiBkb20vTm9kZS5oOgor ICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50 SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGF5 ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0KToK KyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJMaXN0Qm94Ojp2YWx1ZUNoYW5nZWQpOgorCiAyMDEwLTExLTEyICBKZXIgTm9ibGUg IDxqZXIubm9ibGVAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEJyYWR5IEVpZHNv bi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2Vm aWxlLmFtCmluZGV4IGM4NzE0YmIxNzQ2MjllNGU0NGJhZGNhMjhlYWEwYzYxYjQ0NmM1ZDYuLjU1 NDYwNjRlN2UzN2YzOGE0Y2Y5Y2U5NzNhYzNkYWRmMzM4NDg0NDkgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTE0NCw2 ICsxMTQ0LDggQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlXZWJDb3JlL2RvbS9FdmVudE5hbWVz LmggXAogCVdlYkNvcmUvZG9tL0V2ZW50VGFyZ2V0LmNwcCBcCiAJV2ViQ29yZS9kb20vRXZlbnRU YXJnZXQuaCBcCisJV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAgXAorCVdlYkNvcmUvZG9tL0V2 ZW50UXVldWUuaCBcCiAJV2ViQ29yZS9kb20vRXhjZXB0aW9uQmFzZS5jcHAgXAogCVdlYkNvcmUv ZG9tL0V4Y2VwdGlvbkJhc2UuaCBcCiAJV2ViQ29yZS9kb20vRXhjZXB0aW9uQ29kZS5jcHAgXApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpp bmRleCA3NTQ1NWVkNzIyNDE4NDU4YzE2NzY2NTU0NzRlYTNjNzdhNWFlMTA0Li41YTRmYzM4NDAz ZDkyNTkzMzczMWFkNzRiMjMxODMxNWQ3YWExOTc0IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNv cmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTIxMCw2ICsxMjEwLDggQEAK ICAgICAgICAgICAgICdkb20vRXZlbnROYW1lcy5oJywKICAgICAgICAgICAgICdkb20vRXZlbnRU YXJnZXQuY3BwJywKICAgICAgICAgICAgICdkb20vRXZlbnRUYXJnZXQuaCcsCisgICAgICAgICAg ICAnZG9tL0V2ZW50UXVldWUuY3BwJywKKyAgICAgICAgICAgICdkb20vRXZlbnRRdWV1ZS5oJywK ICAgICAgICAgICAgICdkb20vRXhjZXB0aW9uQmFzZS5jcHAnLAogICAgICAgICAgICAgJ2RvbS9F eGNlcHRpb25CYXNlLmgnLAogICAgICAgICAgICAgJ2RvbS9FeGNlcHRpb25Db2RlLmNwcCcsCmRp ZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRl eCA4NGUyZjJlNDYyZjZkYzAwYTg0YWQzOTA2M2UzNmMyM2E0MjM5ZmQ0Li5kYzE2YTJlZmQ3NzVj YWM2M2IxYzZhMGVlOGE0ZDFiMGE5OTAzYzM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUu cHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTcxNiw2ICs3MTYsNyBAQCBTT1VSQ0VT ICs9IFwKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcCBcCiAgICAgZG9tL0V2ZW50TmFtZXMuY3Bw IFwKICAgICBkb20vRXZlbnRUYXJnZXQuY3BwIFwKKyAgICBkb20vRXZlbnRRdWV1ZS5jcHAgXAog ICAgIGRvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAgICAgZG9tL0V4Y2VwdGlvbkNvZGUuY3BwIFwK ICAgICBkb20vSW5wdXRFbGVtZW50LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUu dmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZj cHJvagppbmRleCA4ZjUzMjNiZWE5MmZmOGIxYjg1MjJiOTY1ZGNjOTM5MjUxNjg4ZjFmLi43ODky NTBhZjNlODk0OGQwYTJhMGYzM2IyZGZmNTkzZmJkODFiYTA3IDEwMDY0NAotLS0gYS9XZWJDb3Jl L1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS52Y3By b2ovV2ViQ29yZS52Y3Byb2oKQEAgLTQyNTYzLDYgKzQyNTYzLDYyIEBACiAJCQkJUmVsYXRpdmVQ YXRoPSIuLlxkb21cRXZlbnRUYXJnZXQuaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCisJCSAgPEZp bGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZlbnRRdWV1ZS5jcHAiDQorCQkJCT4NCisJ CQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1lPSJEZWJ1Z3xXaW4zMiINCisJCQkJCUV4 Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0KKwkJCQkJPFRvb2wNCisJCQkJCQlOYW1l PSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJCQkJPC9GaWxlQ29uZmlndXJhdGlvbj4N CisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1lPSJSZWxlYXNlfFdpbjMyIg0KKwkJ CQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJ CU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0 aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IkRlYnVnX0ludGVybmFs fFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8 VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0Zp bGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IkRl YnVnX0NhaXJvfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+ DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0K KwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJ CU5hbWU9IlJlbGVhc2VfQ2Fpcm98V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1 ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCIN CisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJh dGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfQWxsfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVp bGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxl clRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCTwvRmlsZT4N CisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRvbVxFdmVudFF1ZXVlLmgiDQorCQkJ CT4NCisJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXhj ZXB0aW9uQmFzZS5jcHAiDQogCQkJCT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCmluZGV4IDc4YTlhOTAxZjJjYzE4Mjg2NzRjNGFlMDNmZmM4YTRjZmVhN2VkNzEu LjkzYzQ1MWMxOTZlMDU5YzA4OWVlMzIzNjJhNzA2MzdhM2JhMjc0NTYgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yNjU0LDYgKzI2NTQsOCBAQAogCQk4 QUY0RTU1QzExREM1QTYzMDAwRUQzREUgLyogUGVyZm9ybWFuY2VUaW1pbmcuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBRjRFNTU5MTFEQzVBNjMwMDBF RDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5oICovOyB9OwogCQk4QzZFQTYxOTExRUY3RTA0MDBG RDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYxNzExRUY3RTA0MDBGRDhFRTMgLyogUnVu dGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi87IH07CiAJCThDNkVBNjFBMTFFRjdFMDQwMEZEOEVF MyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYxODExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVu YWJsZWRGZWF0dXJlcy5oICovOyB9OworCQk4RjY3NTYxQjEyODhCMTdCMDA0N0FDQTMgLyogRXZl bnRRdWV1ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g OEY2NzU2MTkxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuaCAqLzsgfTsKKwkJOEY2NzU2 MUMxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEY2NzU2MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2 ZW50UXVldWUuY3BwICovOyB9OwogCQk4RkFDNzc0RDExOTg3MkNCMDAxNUFFOTQgLyogSlNNYWlu VGhyZWFkRXhlY1N0YXRlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDhGOTM0RDg0MTE4OUYxRUUwMDUwOEQ1RCAvKiBKU01haW5UaHJlYWRFeGVjU3Rh dGUuY3BwICovOyB9OwogCQk5MzAyQjBCRDBENzlGODI5MDBDN0VFODMgLyogUGFnZUdyb3VwLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzMDJCMEJD MEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwICovOyB9OwogCQk5MzAyQjBCRjBENzlG ODJDMDBDN0VFODMgLyogUGFnZUdyb3VwLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA5MzAyQjBCRTBENzlGODJDMDBDN0VFODMgLyogUGFnZUdyb3VwLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTg3ODMs NiArODc4NSw4IEBACiAJCThBRjRFNTVBMTFEQzVBNjMwMDBFRDNERSAvKiBQZXJmb3JtYW5jZVRp bWluZy5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gUGVyZm9ybWFuY2VUaW1pbmcuaWRsOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QzZFQTYxNzExRUY3RTA0MDBGRDhFRTMgLyog UnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IG5hbWUgPSBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcDsgcGF0aCA9IGdlbmVyaWMvUnVudGlt ZUVuYWJsZWRGZWF0dXJlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThDNkVB NjE4MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuaDsgcGF0aCA9 IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQk4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFdmVudFF1ZXVlLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCThGNjc1NjFBMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEV2ZW50UXVldWUuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4MzExODlGMUVFMDA1MDhENUQgLyogSlNN YWluVGhyZWFkRXhlY1N0YXRlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpT TWFpblRocmVhZEV4ZWNTdGF0ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4Rjkz NEQ4NDExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAv KiBQYWdlR3JvdXAuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGFn ZUdyb3VwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE4NDQ1LDYgKzE4NDQ5 LDggQEAKIAkJCQk1NEM1MEY3QTBFODAxREYzMDA5ODMyQTAgLyogWE1MRG9jdW1lbnRQYXJzZXJM aWJ4bWwyLmNwcCAqLywKIAkJCQk1RDE1RTNBOTBGOUU2QUMxMDA5RTBFM0YgLyogWE1MRG9jdW1l bnRQYXJzZXJTY29wZS5jcHAgKi8sCiAJCQkJNUQxNUUzQUEwRjlFNkFDMTAwOUUwRTNGIC8qIFhN TERvY3VtZW50UGFyc2VyU2NvcGUuaCAqLywKKwkJCQk4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMg LyogRXZlbnRRdWV1ZS5oICovLAorCQkJCThGNjc1NjFBMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVu dFF1ZXVlLmNwcCAqLywKIAkJCSk7CiAJCQlwYXRoID0gZG9tOwogCQkJc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsKQEAgLTIxMzgzLDYgKzIxMzg5LDcgQEAKIAkJCQk0OTlCM0M1OTEyOEM2NDFFMDBF NzI2QzIgLyogR3JhcGhpY3NMYXllck1hYy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMDgyNTA5Mzkx MjhCRDREODAwRTJFRDhFIC8qIFNWR0FuaW1hdGVkVHJhbnNmb3JtTGlzdC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJMzg4OEY2RUYxMjhDOTg4OTAwMENBOEUwIC8qIEluc3BlY3RvckZpbGVTeXN0ZW1B Z2VudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJOEY2NzU2MUIxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2 ZW50UXVldWUuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50 UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMjM5NTYsNiArMjM5NjMsNyBAQAogCQkJCTk3 REQ0RDg2MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRpdG9yLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTQ5OUIzQzVBMTI4QzY0MUUwMEU3MjZDMiAvKiBHcmFwaGljc0xheWVyTWFjLm1tIGluIFNv dXJjZXMgKi8sCiAJCQkJMzg4OEY2RUUxMjhDOTg4OTAwMENBOEUwIC8qIEluc3BlY3RvckZpbGVT eXN0ZW1BZ2VudC5jcHAgaW4gU291cmNlcyAqLywKKwkJCQk4RjY3NTYxQzEyODhCMTdCMDA0N0FD QTMgLyogRXZlbnRRdWV1ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZG9tL0RvY3VtZW50LmNwcCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRleCA0YzM0MjVh NzNkZmQ4YmZiOGQ1MDVjMDg5MzQyZWQ4NTk2ZTJkODMzLi4yODJhNmJjNDc0N2YzZTQ0M2RhYmUx MmM0NjA3YWZjODUxZGNmNjBhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAK KysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC01OCw2ICs1OCw3IEBACiAjaW5jbHVk ZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUg IkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0 aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZyYW1l LmgiCkBAIC0zOTksNyArNDAwLDcgQEAgRG9jdW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwg Y29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhUTUwsIGJvb2wgaXNIVE1MLCBjb24KICAgICAsIG1f bm9ybWFsV29ybGRXcmFwcGVyQ2FjaGUoMCkKICNlbmRpZgogICAgICwgbV91c2luZ0dlb2xvY2F0 aW9uKGZhbHNlKQotICAgICwgbV9wZW5kaW5nRXZlbnRUaW1lcih0aGlzLCAmRG9jdW1lbnQ6OnBl bmRpbmdFdmVudFRpbWVyRmlyZWQpCisgICAgLCBtX2V2ZW50UXVldWUobmV3IEV2ZW50UXVldWUp CiAjaWYgRU5BQkxFKFdNTCkKICAgICAsIG1fY29udGFpbnNXTUxDb250ZW50KGZhbHNlKQogI2Vu ZGlmCkBAIC0zNDM3LDIzICszNDM4LDE0IEBAIHZvaWQgRG9jdW1lbnQ6OmRpc3BhdGNoV2luZG93 TG9hZEV2ZW50KCkKICAgICBkb21XaW5kb3ctPmRpc3BhdGNoTG9hZEV2ZW50KCk7CiB9CiAKLXZv aWQgRG9jdW1lbnQ6OmVucXVldWVFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCkKK3ZvaWQg RG9jdW1lbnQ6OmVucXVldWVFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCwgUGFzc1JlZlB0 cjxOb2RlPiBldmVudFRhcmdldCkKIHsKLSAgICBtX3BlbmRpbmdFdmVudFF1ZXVlLmFwcGVuZChl dmVudCk7Ci0gICAgaWYgKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAg IG1fcGVuZGluZ0V2ZW50VGltZXIuc3RhcnRPbmVTaG90KDApOworICAgIG1fZXZlbnRRdWV1ZS0+ ZW5xdWV1ZUV2ZW50KGV2ZW50LCBldmVudFRhcmdldCk7CiB9CiAKLXZvaWQgRG9jdW1lbnQ6OnBl bmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RG9jdW1lbnQ+KikKK3ZvaWQgRG9jdW1lbnQ6OmVu cXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVkKFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50LCBQ YXNzUmVmUHRyPE5vZGU+IGV2ZW50VGFyZ2V0KQogewotICAgIEFTU0VSVCghbV9wZW5kaW5nRXZl bnRUaW1lci5pc0FjdGl2ZSgpKTsKLSAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IGV2ZW50UXVl dWU7Ci0gICAgZXZlbnRRdWV1ZS5zd2FwKG1fcGVuZGluZ0V2ZW50UXVldWUpOwotCi0gICAgdHlw ZWRlZiBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+Ojpjb25zdF9pdGVyYXRvciBJdGVyYXRvcjsKLSAg ICBJdGVyYXRvciBlbmQgPSBldmVudFF1ZXVlLmVuZCgpOwotICAgIGZvciAoSXRlcmF0b3IgaXQg PSBldmVudFF1ZXVlLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKLSAgICAgICAgZGlzcGF0Y2hX aW5kb3dFdmVudCgqaXQpOworICAgIG1fZXZlbnRRdWV1ZS0+ZW5xdWV1ZUV2ZW50SWZOb3RBbHJl YWR5RW5xdWV1ZWQoZXZlbnQsIGV2ZW50VGFyZ2V0KTsKIH0KIAogUGFzc1JlZlB0cjxFdmVudD4g RG9jdW1lbnQ6OmNyZWF0ZUV2ZW50KGNvbnN0IFN0cmluZyYgZXZlbnRUeXBlLCBFeGNlcHRpb25D b2RlJiBlYykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmggYi9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5oCmluZGV4IGJhNDhkNmY4MmVjYjQwOGJkYmQxNDdmNjIzZTllNmM5Y2JmMjIx NjkuLjM3MzQwNzhkNmE3ZDNkNzYzYzA3YzU5YzA4NGEwZjQ1Y2UxMGRhODMgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZG9tL0RvY3VtZW50LmgKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuaApAQCAt NzUsNiArNzUsNyBAQCBjbGFzcyBFbGVtZW50OwogY2xhc3MgRW50aXR5UmVmZXJlbmNlOwogY2xh c3MgRXZlbnQ7CiBjbGFzcyBFdmVudExpc3RlbmVyOworY2xhc3MgRXZlbnRRdWV1ZTsKIGNsYXNz IEZyYW1lOwogY2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgSFRNTENhbnZhc0VsZW1lbnQ7CkBAIC0x MDE2LDcgKzEwMTcsMTAgQEAgcHVibGljOgogICAgIGJvb2wgY29udGFpbnNWYWxpZGl0eVN0eWxl UnVsZXMoKSBjb25zdCB7IHJldHVybiBtX2NvbnRhaW5zVmFsaWRpdHlTdHlsZVJ1bGVzOyB9CiAg ICAgdm9pZCBzZXRDb250YWluc1ZhbGlkaXR5U3R5bGVSdWxlcygpIHsgbV9jb250YWluc1ZhbGlk aXR5U3R5bGVSdWxlcyA9IHRydWU7IH0KIAotICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NSZWZQ dHI8RXZlbnQ+KTsKKyAgICB1c2luZyBOb2RlOjplbnF1ZXVlRXZlbnQ7CisgICAgdm9pZCBlbnF1 ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQsIFBhc3NSZWZQdHI8Tm9kZT4gZXZlbnRU YXJnZXQpOworICAgIHVzaW5nIE5vZGU6OmVucXVldWVFdmVudElmTm90QWxyZWFkeUVucXVldWVk OworICAgIHZvaWQgZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQoUGFzc1JlZlB0cjxF dmVudD4gZXZlbnQsIFBhc3NSZWZQdHI8Tm9kZT4gZXZlbnRUYXJnZXQpOwogICAgIHZvaWQgZW5x dWV1ZVBhZ2VzaG93RXZlbnQoUGFnZXNob3dFdmVudFBlcnNpc3RlbmNlKTsKICAgICB2b2lkIGVu cXVldWVIYXNoY2hhbmdlRXZlbnQoY29uc3QgU3RyaW5nJiBvbGRVUkwsIGNvbnN0IFN0cmluZyYg bmV3VVJMKTsKICAgICB2b2lkIGVucXVldWVQb3BzdGF0ZUV2ZW50KFBhc3NSZWZQdHI8U2VyaWFs aXplZFNjcmlwdFZhbHVlPiBzdGF0ZU9iamVjdCk7CkBAIC0xMTE2LDggKzExMjAsNiBAQCBwcml2 YXRlOgogCiAgICAgdm9pZCBjcmVhdGVTdHlsZVNlbGVjdG9yKCk7CiAKLSAgICB2b2lkIHBlbmRp bmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RG9jdW1lbnQ+Kik7Ci0KICAgICBQYXNzUmVmUHRyPE5v ZGVMaXN0PiBoYW5kbGVaZXJvUGFkZGluZyhjb25zdCBIaXRUZXN0UmVxdWVzdCYsIEhpdFRlc3RS ZXN1bHQmKSBjb25zdDsKIAogICAgIHZvaWQgbG9hZEV2ZW50RGVsYXlUaW1lckZpcmVkKFRpbWVy PERvY3VtZW50PiopOwpAQCAtMTMzOSw5ICsxMzQxLDggQEAgcHJpdmF0ZToKICNlbmRpZgogCiAg ICAgYm9vbCBtX3VzaW5nR2VvbG9jYXRpb247Ci0KLSAgICBUaW1lcjxEb2N1bWVudD4gbV9wZW5k aW5nRXZlbnRUaW1lcjsKLSAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IG1fcGVuZGluZ0V2ZW50 UXVldWU7CisgICAgCisgICAgT3duUHRyPEV2ZW50UXVldWU+IG1fZXZlbnRRdWV1ZTsKIAogI2lm IEVOQUJMRShXTUwpCiAgICAgYm9vbCBtX2NvbnRhaW5zV01MQ29udGVudDsKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3BwIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uN2JhNmRlNGVmM2FjOTQ4ZGE2NGEyOWJmYWY5MmY5OTQ5M2ZkZGJhZgotLS0g L2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3BwCkBAIC0wLDAgKzEsMTA0 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRXZlbnRR dWV1ZS5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJFdmVudC5oIgorI2lu Y2x1ZGUgIk5vZGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdHJ1Y3QgRW5xdWV1ZWRF dmVudCA6IE5vbmNvcHlhYmxlIHsKKyAgICBSZWZQdHI8RXZlbnQ+IG1fZXZlbnQ7CisgICAgUmVm UHRyPE5vZGU+IG1fZXZlbnRUYXJnZXQ7Cit9OwordHlwZWRlZiBWZWN0b3I8RW5xdWV1ZWRFdmVu dCo+Ojpjb25zdF9pdGVyYXRvciBFbnF1ZXVlZEV2ZW50SXRlcmF0b3I7CisKK0V2ZW50UXVldWU6 OkV2ZW50UXVldWUoKQorICAgIDogbV9wZW5kaW5nRXZlbnRUaW1lcih0aGlzLCAmRXZlbnRRdWV1 ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZCkKK3sKK30KKworRXZlbnRRdWV1ZTo6fkV2ZW50UXVl dWUoKQoreworICAgIEVucXVldWVkRXZlbnRJdGVyYXRvciBlbmQgPSBtX2VucXVldWVkRXZlbnRz LmVuZCgpOworICAgIGZvciAoRW5xdWV1ZWRFdmVudEl0ZXJhdG9yIGl0ID0gbV9lbnF1ZXVlZEV2 ZW50cy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgIGRlbGV0ZSAqaXQ7CisgICAg bV9lbnF1ZXVlZEV2ZW50cy5jbGVhcigpOworfQorCit2b2lkIEV2ZW50UXVldWU6OmVucXVldWVF dmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCwgUGFzc1JlZlB0cjxOb2RlPiBldmVudFRhcmdl dCkKK3sKKyAgICBFbnF1ZXVlZEV2ZW50KiBlbnF1ZXVlZEV2ZW50ID0gbmV3IEVucXVldWVkRXZl bnQ7CisgICAgZW5xdWV1ZWRFdmVudC0+bV9ldmVudCA9IGV2ZW50OworICAgIGVucXVldWVkRXZl bnQtPm1fZXZlbnRUYXJnZXQgPSBldmVudFRhcmdldDsKKyAgICBtX2VucXVldWVkRXZlbnRzLmFw cGVuZChlbnF1ZXVlZEV2ZW50KTsKKyAgICAKKyAgICBpZiAoIW1fcGVuZGluZ0V2ZW50VGltZXIu aXNBY3RpdmUoKSkKKyAgICAgICAgbV9wZW5kaW5nRXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7 Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50SWZOb3RBbHJlYWR5RW5xdWV1ZWQo UGFzc1JlZlB0cjxFdmVudD4gcHJwRXZlbnQsIFBhc3NSZWZQdHI8Tm9kZT4gZXZlbnRUYXJnZXQp Cit7CisgICAgUmVmUHRyPEV2ZW50PiBldmVudCA9IHBycEV2ZW50OworICAgIEVucXVldWVkRXZl bnRJdGVyYXRvciBlbmQgPSBtX2VucXVldWVkRXZlbnRzLmVuZCgpOworICAgIGZvciAoRW5xdWV1 ZWRFdmVudEl0ZXJhdG9yIGl0ID0gbV9lbnF1ZXVlZEV2ZW50cy5iZWdpbigpOyBpdCAhPSBlbmQ7 ICsraXQpIHsKKyAgICAgIEVucXVldWVkRXZlbnQqIHF1ZXVlZEV2ZW50ID0gKCppdCk7CisgICAg ICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBxdWV1ZWRFdmVudC0+bV9ldmVudC0+dHlwZSgpICYmIGV2 ZW50VGFyZ2V0ID09IHF1ZXVlZEV2ZW50LT5tX2V2ZW50VGFyZ2V0KQorICAgICAgICAgIHJldHVy bjsKKyAgICB9CisgICAgCisgICAgZW5xdWV1ZUV2ZW50KGV2ZW50LCBldmVudFRhcmdldCk7Cit9 CisKK3ZvaWQgRXZlbnRRdWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1 ZXVlPiopCit7CisgICAgQVNTRVJUKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpOwor ICAgIFZlY3RvcjxFbnF1ZXVlZEV2ZW50Kj4gZW5xdWV1ZWRFdmVudHM7CisgICAgZW5xdWV1ZWRF dmVudHMuc3dhcChtX2VucXVldWVkRXZlbnRzKTsKKyAgICAKKyAgICBFbnF1ZXVlZEV2ZW50SXRl cmF0b3IgZW5kID0gZW5xdWV1ZWRFdmVudHMuZW5kKCk7CisgICAgZm9yIChFbnF1ZXVlZEV2ZW50 SXRlcmF0b3IgaXQgPSBlbnF1ZXVlZEV2ZW50cy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsK KyAgICAgICAgZGlzcGF0Y2hFdmVudCgqaXQpOworICAgICAgICBkZWxldGUgKml0OworICAgIH0K K30KKwordm9pZCBFdmVudFF1ZXVlOjpkaXNwYXRjaEV2ZW50KEVucXVldWVkRXZlbnQqIGV2ZW50 KQoreworICAgIE5vZGUqIGV2ZW50VGFyZ2V0ID0gZXZlbnQtPm1fZXZlbnRUYXJnZXQuZ2V0KCk7 CisgICAgaWYgKCFldmVudFRhcmdldC0+aW5Eb2N1bWVudCgpKQorICAgICAgICByZXR1cm47CisK KyAgICBpZiAoZXZlbnRUYXJnZXQtPmlzRG9jdW1lbnROb2RlKCkpCisgICAgICAgIGV2ZW50VGFy Z2V0LT5kb2N1bWVudCgpLT5kaXNwYXRjaFdpbmRvd0V2ZW50KGV2ZW50LT5tX2V2ZW50KTsKKyAg ICBlbHNlCisgICAgICAgIGV2ZW50VGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50LT5tX2V2ZW50 KTsKK30KKworfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oIGIvV2ViQ29y ZS9kb20vRXZlbnRRdWV1ZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY0NDA1YjIwNzQyNDIwNTNjOGVhOTc3NmZm ZGI5YjMxOWY4NmFlOTYKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVl LmgKQEAgLTAsMCArMSw1OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5j LiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqCisgKi8KKworI2lmbmRlZiBFdmVudFF1ZXVlX2gK KyNkZWZpbmUgRXZlbnRRdWV1ZV9oCisKKyNpbmNsdWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworY2xhc3MgRXZlbnQ7CitjbGFzcyBOb2RlOworc3RydWN0IEVucXVldWVkRXZlbnQ7CisK K2NsYXNzIEV2ZW50UXVldWUgeworcHVibGljOgorICAgIEV2ZW50UXVldWUoKTsKKyAgICB+RXZl bnRRdWV1ZSgpOworCisgICAgdm9pZCBlbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZl bnQsIFBhc3NSZWZQdHI8Tm9kZT4gZXZlbnRUYXJnZXQpOworICAgIHZvaWQgZW5xdWV1ZUV2ZW50 SWZOb3RBbHJlYWR5RW5xdWV1ZWQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQsIFBhc3NSZWZQdHI8 Tm9kZT4gZXZlbnRUYXJnZXQpOworCitwcml2YXRlOgorICAgIHZvaWQgcGVuZGluZ0V2ZW50VGlt ZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopOworICAgIHZvaWQgZGlzcGF0Y2hFdmVudChFbnF1 ZXVlZEV2ZW50Kik7CisKKyAgICBUaW1lcjxFdmVudFF1ZXVlPiBtX3BlbmRpbmdFdmVudFRpbWVy OworICAgIFZlY3RvcjxFbnF1ZXVlZEV2ZW50Kj4gbV9lbnF1ZXVlZEV2ZW50czsKK307CisKK30K KworI2VuZGlmIC8vIEV2ZW50UXVldWVfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vTm9kZS5j cHAgYi9XZWJDb3JlL2RvbS9Ob2RlLmNwcAppbmRleCBlNzFjNGJkZmUwOWYxNzdiM2U2NWRlZmVi NGI3OTU2MzM5NjE0NzdiLi4wNWI1YmQ1MWRjNDhmOGQxMDA1ZjI5YjVkMzdmYWYwNzkzNDVmODhj IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAorKysgYi9XZWJDb3JlL2RvbS9Ob2Rl LmNwcApAQCAtMjU1MCw2ICsyNTUwLDE2IEBAIGJvb2wgTm9kZTo6ZGlzcGF0Y2hFdmVudChQYXNz UmVmUHRyPEV2ZW50PiBwcnBFdmVudCkKICAgICByZXR1cm4gZGlzcGF0Y2hHZW5lcmljRXZlbnQo ZXZlbnQucmVsZWFzZSgpKTsKIH0KIAordm9pZCBOb2RlOjplbnF1ZXVlRXZlbnQoUGFzc1JlZlB0 cjxFdmVudD4gZXZlbnQpCit7CisgICAgZG9jdW1lbnQoKS0+ZW5xdWV1ZUV2ZW50KGV2ZW50LCB0 aGlzKTsKK30KKwordm9pZCBOb2RlOjplbnF1ZXVlRXZlbnRJZk5vdEFscmVhZHlFbnF1ZXVlZChQ YXNzUmVmUHRyPEV2ZW50PiBldmVudCkKK3sKKyAgICBkb2N1bWVudCgpLT5lbnF1ZXVlRXZlbnRJ Zk5vdEFscmVhZHlFbnF1ZXVlZChldmVudCwgdGhpcyk7Cit9CisKIHN0YXRpYyBjb25zdCBFdmVu dENvbnRleHQqIHRvcEV2ZW50Q29udGV4dChjb25zdCBWZWN0b3I8RXZlbnRDb250ZXh0PiYgYW5j ZXN0b3JzKQogewogICAgIHJldHVybiBhbmNlc3RvcnMuaXNFbXB0eSgpID8gMCA6ICZhbmNlc3Rv cnMubGFzdCgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vTm9kZS5oIGIvV2ViQ29yZS9kb20v Tm9kZS5oCmluZGV4IDY3NWRlMDRkMTlhYWIxYzU1MGE4MzRiNzkxMzliZTA4ZmY2NDk0MDUuLjFh ZjBmN2I5NGNhZTY5ZmNhNjA3Yzk0NzM2NDYwZWMyN2QwNGVkYzAgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvZG9tL05vZGUuaAorKysgYi9XZWJDb3JlL2RvbS9Ob2RlLmgKQEAgLTUxNyw2ICs1MTcsOCBA QCBwdWJsaWM6CiAKICAgICB1c2luZyBFdmVudFRhcmdldDo6ZGlzcGF0Y2hFdmVudDsKICAgICB2 aXJ0dWFsIGJvb2wgZGlzcGF0Y2hFdmVudChQYXNzUmVmUHRyPEV2ZW50Pik7CisgICAgdm9pZCBl bnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQgZW5xdWV1ZUV2ZW50SWZO b3RBbHJlYWR5RW5xdWV1ZWQoUGFzc1JlZlB0cjxFdmVudD4pOwogCiAgICAgYm9vbCBkaXNwYXRj aEdlbmVyaWNFdmVudChQYXNzUmVmUHRyPEV2ZW50Pik7CiAgICAgdmlydHVhbCB2b2lkIGhhbmRs ZUxvY2FsRXZlbnRzKEV2ZW50Kik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5k bGVyLmNwcCBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IGY2YTIzNTM4MTVm NjFhZGJkMWRjNDE4MTAwNWUyNWNhMDc2YmFiYTEuLjNhZjFjZWY3MTM3YmJiNDE5NzQxOWE0OThj Njc1MjNkOTNhZWFhMzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3Bw CisrKyBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0yNzU3LDcgKzI3NTcsNyBA QCB2b2lkIEV2ZW50SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50KCkKIHsKICAgICBzZXRGcmFtZVdh c1Njcm9sbGVkQnlVc2VyKCk7CiAgICAgaWYgKG1fZnJhbWUtPnZpZXcoKSAmJiBtX2ZyYW1lLT5k b2N1bWVudCgpKQotICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5kaXNwYXRjaEV2ZW50KEV2 ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCB0cnVlLCBmYWxzZSkpOworICAg ICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5lbnF1ZXVlRXZlbnRJZk5vdEFscmVhZHlFbnF1ZXVl ZChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgdHJ1ZSwgZmFsc2UpKTsK IH0KIAogdm9pZCBFdmVudEhhbmRsZXI6OnNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIoKQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCmluZGV4IDdiOTAwMGM2NTUzYTI0NjI1YTAwYjY2NjYxYjg4 NDNkMDI3NjFmOGIuLjlkMmY4MzM0MmU0NGRjNTRkODc2ZDY2ODkzOGE5OGFjYWU4NDIwYjkgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAorKysgYi9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKQEAgLTEzOTcsMTAgKzEzOTcsOCBAQCB2b2lkIFJl bmRlckxheWVyOjpzY3JvbGxUb09mZnNldChpbnQgeCwgaW50IHksIGJvb2wgdXBkYXRlU2Nyb2xs YmFycywgYm9vbCByZXBhaQogICAgIH0KIAogICAgIC8vIFNjaGVkdWxlIHRoZSBzY3JvbGwgRE9N IGV2ZW50LgotICAgIGlmICh2aWV3KSB7Ci0gICAgICAgIGlmIChGcmFtZVZpZXcqIGZyYW1lVmll dyA9IHZpZXctPmZyYW1lVmlldygpKQotICAgICAgICAgICAgZnJhbWVWaWV3LT5zY2hlZHVsZUV2 ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2Up LCByZW5kZXJlcigpLT5ub2RlKCkpOwotICAgIH0KKyAgICBpZiAodmlldyAmJiB2aWV3LT5mcmFt ZVZpZXcoKSkKKyAgICAgICAgcmVuZGVyZXIoKS0+bm9kZSgpLT5lbnF1ZXVlRXZlbnRJZk5vdEFs cmVhZHlFbnF1ZXVlZChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFs c2UsIGZhbHNlKSk7CiB9CiAKIHZvaWQgUmVuZGVyTGF5ZXI6OnNjcm9sbFJlY3RUb1Zpc2libGUo Y29uc3QgSW50UmVjdCYgcmVjdCwgYm9vbCBzY3JvbGxUb0FuY2hvciwgY29uc3QgU2Nyb2xsQWxp Z25tZW50JiBhbGlnblgsIGNvbnN0IFNjcm9sbEFsaWdubWVudCYgYWxpZ25ZKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMaXN0Qm94LmNwcAppbmRleCA1MzJjNTUxMmQ3OGI0OTVmNzJlZjMzOWIwZmY2ZDc4 ZjQ3ZDUyNGUxLi4wNDBmOWQyNjhkZGEyZmNkY2RjMmFlOTgyNWNjMzc3NmI3ZDA1MWFjIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcAorKysgYi9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcApAQCAtNTQwLDcgKzU0MCw3IEBAIHZvaWQgUmVu ZGVyTGlzdEJveDo6dmFsdWVDaGFuZ2VkKFNjcm9sbGJhciopCiAgICAgaWYgKG5ld09mZnNldCAh PSBtX2luZGV4T2Zmc2V0KSB7CiAgICAgICAgIG1faW5kZXhPZmZzZXQgPSBuZXdPZmZzZXQ7CiAg ICAgICAgIHJlcGFpbnQoKTsKLSAgICAgICAgbm9kZSgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50Ojpj cmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKKyAgICAgICAg bm9kZSgpLT5lbnF1ZXVlRXZlbnRJZk5vdEFscmVhZHlFbnF1ZXVlZChFdmVudDo6Y3JlYXRlKGV2 ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZhbHNlKSk7CiAgICAgfQogfQogCg== 73948 2010-11-15 17:13:37 -0800 2010-11-15 19:13:45 -0800 Patch bug-45631-20101115171336.patch text/plain 42261 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNDkwNTVlYWI4MTJkMjRjODk3YzdiNGRmNjUxODBlMGVkMmMzN2M1Li5iYWMwODMz ODlhYTM3MDdmYjU1YmE5ZWQ5ZTU4ZTFkY2IzYjE3YjFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuIEFkZGl0aW9uYWxseSwgZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbCBub3cgCisgICAgICAgIGV4cGxpY2l0bHkgdGVzdHMgZm9yIHN5bmNocm9ub3Vz IGJlaGF2aW9yIHdoZW4gc2Nyb2xsaW5nIHRoZSBkb2N1bWVudCwKKyAgICAgICAgYW5kIHRoYXQg d2UgZG9uJ3QgZmlyZSB0aGUgZXZlbnQgbW9yZSB0aGFuIG9uY2UuCisgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBkb2VzIHRoZSBzYW1lIGZvciBzY3Jv bGwKKyAgICAgICAgZXZlbnRzIG9uIHNjcm9sbGFibGUgZWxlbWVudHMuCisKKyAgICAgICAgKiBl ZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFz dC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBm cm9tIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sOgorICAg ICAgICAqIGZhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sOgorICAgICAgICAq IGZhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbDoKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWw6CisgICAgICAgICog ZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sOgorICAgICAgICAqIGZh c3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sOgorICAgICAgICAq IGZhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbDoKKwogMjAxMC0xMS0xNSAg TWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10g TmF2aWdhdGlvbiBwb2xpY3kgZGVjaXNpb24gQVBJIG5lZWRzIHRvIGluY2x1ZGUgdGhlIERPTSBu b2RlIHRoYXQgdGhlIGRlY2lzaW9uIG9yaWdpbmF0ZWQgZnJvbQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dAppbmRleCAyNGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNkNjY0Li5iNWIwY2Yw ZjU0NmMyZTQxZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4 dApAQCAtMSw0ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy4KK1RoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25j ZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9s bCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMgbm93LgogUEFTUwog KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZjODNiMTQ4MjNkMmVk NzBkYjMyNTAwODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEyMjdjMWM5Mzg2ZmQ5 ZjQ5YjQ2YmEyNWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11 cC1kb3duLXNjcm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2Ut dXAtZG93bi1zY3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1sPgogPGhlYWQ+CiA8 c2NyaXB0PgotaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQogCi1mdW5j dGlvbiBzY3IoKQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKCkgewog ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQgKz0gJ3gnOworCisg ICAgc3dpdGNoIChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAod2luZG93LmV2ZW50 U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFnZVVwJyk7CisgICAg ICAgICAgICBicmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdyZXN1bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgc3RlcCsrOwogfQog CiBmdW5jdGlvbiBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikKLSAg ICAgICAgcmV0dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNj ciwgZmFsc2UpOwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iKTsKLSAgICB2 YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQ7Ci0gICAg aWYgKHRleHQgIT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHgsIG5v dCAiICsgdGV4dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIpOwotICAgIHZh ciB0ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBp ZiAodGV4dCAhPSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHh4LCBu b3QgIiArIHRleHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlu bmVyVGV4dCA9ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICBl dmVudFNlbmRlci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+CiA8L2hlYWQ+CiA8 Ym9keSBvbmxvYWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5bGU9InBvc2l0aW9u OmZpeGVkIj48L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1 cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0 ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFz cy48L2Rpdj4KKzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBh Z2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3Rs eSBvbmUgc2Nyb2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBu b3cuPC9kaXY+CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2IHN0eWxlPSJoZWln aHQ6NTAwMDBweCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwvZGl2PiAKIDxzY3Jp cHQ+IApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xMWEyZTIyZjY5MGI1 ZmIyN2RhOTMzYTA4NTQ0ZGNjZTlmMjBlZWE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw0IEBACitQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKDAsIDIwMCkKK0lmIHRoZSB3 b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFp bGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQg bm90IGZpcmUsIGZpcmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgor CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hY2Q2NmUxNGQ2NGViODFlZDUyNWRjOTlhN2U1NDQz NTgwYWUzYjhhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmly ZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNTIgQEAKKzxodG1sPgorPHNj cmlwdD4KK3ZhciBldmVudENvdW50ID0gMDsKK3ZhciBkb25lVGltZW91dDsKKworZnVuY3Rpb24g c2Nyb2xsSGFuZGxlcigpCit7CisgICAgZXZlbnRDb3VudCsrOworICAgIGlmIChldmVudENvdW50 ID09IDEpIHsKKyAgICAgICAgdmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdjb250YWluZXInKTsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBjb250YWluZXIuc2Nyb2xsTGVm dDsKKyAgICAgICAgdmFyIHNjcm9sbFkgPSBjb250YWluZXIuc2Nyb2xsVG9wOworICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnUEFTU0VELCBz Y3JvbGwgcG9zaXRpb246ICgnICsgc2Nyb2xsWCArICcsICcgKyBzY3JvbGxZICsgJyknOworICAg ICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVy ZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBz ZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgICAgICAgICB9LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFy VGltZW91dChkb25lVGltZW91dCk7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdy ZXN1bHQnKS50ZXh0Q29udGVudCA9ICdGQUlMLCBzY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAn ICsgZXZlbnRDb3VudCArICcgdGltZXMnOworICAgIH0KK30KKworb25sb2FkID0gZnVuY3Rpb24o KQoreworICAgIHZhciBjb250YWluZXIgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFp bmVyJyk7CisgICAgY29udGFpbmVyLmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbEhh bmRsZXIsIGZhbHNlKTsKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIH0KKyAgICBjb250YWluZXIuc2Ny b2xsVG9wID0gMTAwOworICAgIGlmIChldmVudENvdW50ID4gMCkgeworICAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlMRUQsIGV2ZW50IGZpcmVk IHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOyAgICAg IAorICAgIH0KKyAgICBjb250YWluZXIuc2Nyb2xsVG9wID0gMjAwOworfQorCis8L3NjcmlwdD4K Kzxib2R5PgorPGRpdiBpZD0icmVzdWx0Ij5GQUlMLCBldmVudCBkaWQgbm90IGZpcmU8L2Rpdj4K KworPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3ZlLCB0aGVuIHRo ZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0aGF0IGEgc2Ny b2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3IgZmlyZWQgbW9y ZSB0aGFuIG9uY2UuPC9wPgorCis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0iaGVpZ2h0 OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPC9ib2R5PgorPC9odG1s PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dAppbmRleCAxNjg2Y2VkMzlh ZTJiZTJkNTliNjNlOWQzZmRhZTRiMWUyYzg4NjU2Li4xMGY4ZTQzOTAyYmQxODQ2YWRkMjI1ZGU2 YzJlODAwYWZhNTEyZTYzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJl LXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv ZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CkBAIC0xLDU5ICsxLDQgQEAKLVBBU1NFRAor UEFTU0VELCBzY3JvbGwgcG9zaXRpb246ICgyMDAsIDIwMCkKK0lmIHRoZSB3b3JkICdQQVNTRUQn IGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUg dGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUsIGZp cmVkIHN5bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLgogCi1JZiB0aGUgd29y ZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxl ZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5v dCBmaXJlLgotCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCmlu ZGV4IGEwNTZjMDY3YmQ5ZjI3YzRiMzQ2NWM4NGExNmUyMWE5ZmEzZTcxNGMuLjdjZDBhNTZkMGE4 NDAzNTFhMjQ4N2RlODNkZTc0MjhlMjhhMDAwMTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbApAQCAtMSwzMCArMSw0NyBAQAogPGh0bWw+CiA8 c2NyaXB0PgotdmFyIGV2ZW50RmlyZWQgPSBmYWxzZTsKK3ZhciBldmVudENvdW50ID0gMDsKK3Zh ciBkb25lVGltZW91dDsKIAotZnVuY3Rpb24gc2Nyb2xsZXIoKSB7Ci0gICAgaWYgKCFldmVudEZp cmVkKSB7Ci0gICAgICAgIGV2ZW50RmlyZWQgPSB0cnVlOwotICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicGFzc2VkIikuaW5uZXJIVE1MID0gIjxwIHN0eWxlPSdjb2xvcjpyZWQnPlBB U1NFRDwvcD4iOworb25zY3JvbGwgPSBmdW5jdGlvbigpCit7CisgICAgZXZlbnRDb3VudCsrOwor ICAgIGlmIChldmVudENvdW50ID09IDEpIHsKKyAgICAgICAgdmFyIHNjcm9sbFggPSBkb2N1bWVu dC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gZG9jdW1lbnQuYm9keS5z Y3JvbGxUb3A7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS50ZXh0 Q29udGVudCA9ICdQQVNTRUQsIHNjcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyAr IHNjcm9sbFkgKyAnKSc7CisgICAgICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdo dCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29taW5nLgorICAg ICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0sIDEwMCk7CisgICAgfSBl bHNlIHsKKyAgICAgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1lb3V0KTsKKyAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLnRleHRDb250ZW50ID0gJ0ZBSUwsIHNjcm9sbCBo YW5kbGVyIHdhcyBpbnZva2VkICcgKyBldmVudENvdW50ICsgJyB0aW1lcyc7CiAgICAgfQogfQog Ci13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVu ZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7Ci0gICAgd2luZG93LnNjcm9sbFRvKDUwMCwg NTAwKTsKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUo KTsKICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwogICAgIH0KKyAg ICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDApOworICAgIGlmIChldmVudENvdW50ID4gMCkgewor ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdGQUlM RUQsIGV2ZW50IGZpcmVkIHN5bmNocm9ub3VzbHkuJzsgICAgICAKKyAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOyAgICAgIAorICAgIH0KKyAgICB3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOwog fQogCiA8L3NjcmlwdD4KIDxib2R5PgotPGRpdiBpZD0icGFzc2VkIj48L2Rpdj4KKzxkaXYgaWQ9 InJlc3VsdCI+RkFJTCwgZXZlbnQgZGlkIG5vdCBmaXJlPC9kaXY+CiAKLTxwPklmIHRoZSB3b3Jk ICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVk LiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90 IGZpcmUuPC9wPgorPHA+SWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3Zl LCB0aGVuIHRoZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0 aGF0IGEgc2Nyb2xsIGV2ZW50IGRpZCBub3QgZmlyZSwgZmlyZWQgc3luY2hyb25vdXNseSwgb3Ig ZmlyZWQgbW9yZSB0aGFuIG9uY2UuPC9wPgogCi1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxi cj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgotYTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+Cis8ZGl2IHN0eWxlPSJoZWlnaHQ6IDUwMDBweDsgd2lkdGg6IDUw MDBweDsiPjwvZGl2PgogPC9ib2R5PgogPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZp bGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNj cm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xs Lmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZlNTAyMjc4ZDM2ZWYxOGUwNzFmY2IzNjU0Y2MzNS4uZWFi YjA3OWVhY2FhNzliODhlMGYwYWFkYTcwMTk1ZGUzOGIzNjNiOCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKQEAgLTksMTcgKzks MjggQEAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRpc3BhdGNoU2Nyb2xsRXZlbnRzKCkKICAgICAg ICAgICAgIHsKICAgICAgICAgICAgICAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyICYmIHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2Vu ZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAwKTsKICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5k ZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7Ci0gICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVy Lm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKLSAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgICAgICAgICB2YXIgc2Nyb2xsQ291 bnQgPSAwOworICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHYn KS5hZGRFdmVudExpc3RlbmVyKAorICAgICAgICAgICAgICAgICAgICAgICAgJ3Njcm9sbCcsCisg ICAgICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbihldmVudCkgeworICAgICAgICAgICAgICAg ICAgICAgICAgICB0aGlzLnJlbW92ZUNoaWxkKHRoaXMuZmlyc3RDaGlsZCkKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgc2Nyb2xsQ291bnQrKzsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg aWYgKHNjcm9sbENvdW50ID09IDEpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVu dFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAtMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy Lm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0sCisgICAgICAgICAgICAg ICAgICAgICAgICBmYWxzZSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAg ICAgICA8L3NjcmlwdD4KICAgICA8L2hlYWQ+CiAgICAgPGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0 KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygpOycsIDEpOyI+CiAgICAgICAgIFRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBiZSByZW1vdmVkIGJ5IHRoZWlyIHBhcmVudCBlbGVtZW50 J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxlci4gIFRoZSB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgaXMg dGhlIG9ubHkgdGV4dCByZW1haW5pbmcgYWZ0ZXIgdGhlIHR3byBzY3JvbGwgZXZlbnRzIGFyZSBk aXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFpbHMgaWYgdGhlIGlubmVyIGRpdiByZW1haW5zIGluIHRo ZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNyYXNoZXMuPGJyPjxicj4KLSAgICAgICAgPGRpdiBpZD0i ZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3 aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNjcm9sbD0idGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0 Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lk dGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7Ij4KICAgICAgICAg PGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7IGhlaWdodDozMDBweCI+TG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmlt IGFkIG1pbmltIHZlbmlhbSwgcXVpcyBub3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9y aXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVhIGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1 cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJpdCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0g ZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBwYXJpYXR1ci4gRXhjZXB0ZXVyIHNpbnQgb2NjYWVjYXQg Y3VwaWRhdGF0IG5vbiBwcm9pZGVudCwgc3VudCBpbiBjdWxwYSBxdWkgb2ZmaWNpYSBkZXNlcnVu dCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFib3J1bQogICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9k aXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpv b20tY2hhbmdlLmh0bWwKaW5kZXggNGZjMTUyODRkZWYxZjU4ZDkzNzM1ZmFjYWRlNGE1NmQ3MTBk NTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4MjUzM2FjYjA0NDJhOTJjZTcyNzFmZiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1s CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2Uu aHRtbApAQCAtMTYsNiArMTYsOSBAQAogICAgIGZ1bmN0aW9uIHNjcm9sbGVkKGV2ZW50KQogICAg IHsKICAgICAgICAgZXZlbnQudGFyZ2V0LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZXZlbnQudGFy Z2V0KTsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CiAgICAg fQogCiAgICAgZnVuY3Rpb24gdGVzdCgpCkBAIC0yNyw3ICszMCw5IEBACiAgICAgICAgIGRvY3Vt ZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7CiAgICAgfQogCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgIH0KICAgICB0ZXN0KCk7CiA8L3Nj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1k b2VzLW5vdC1idWJibGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVu dC1kb2VzLW5vdC1idWJibGUuaHRtbAppbmRleCAyMjJhZGE4MDVkYTUzMDYyMmU0ZjgxZjViZGNl ZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3NDMzZGU4YWJlZTZmMzY3MTUxZTUyMDNlMmVlZDQwIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3Qt YnViYmxlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0xLDExICsxLDIyIEBACiA8aHRtbD4KIDxzY3JpcHQ+Cit2 YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBmYWxzZTsKK3ZhciBkb25lVGltZW91dDsKKwogZnVuY3Rp b24gd2luZG93U2Nyb2xsZWQoKSB7CisgICAgd2luZG93V2FzU2Nyb2xsZWQgPSB0cnVlOwogICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTFVSRTog d2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxsZWQuJzsgCisgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1l b3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9uIGRpdlNjcm9sbGVkKCkgewotICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xs IHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cub25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICBpZiAoIXdp bmRvd1dhc1Njcm9sbGVkKQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0 JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2lu ZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0 cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcv YnViYmxpbmcuCisgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9LCAxMDApOyAgICAKIH0KIAog ZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAgLTI0LDEwICszNSw2IEBAIGZ1bmN0aW9uIHJ1blRlc3Qo KSB7CiAgICAgCiAgICAgLy8gRG9uJ3QgcG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25z ZW5zZS4KICAgICBkaXYuaW5uZXJIVE1MID0gJyc7Ci0gICAgCi0gICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgCi0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKLSAgICAKIH0KIAogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwKaW5kZXggYmExYTM1MTY0YzU2 YjJjNDFlYTM4MGJlYTc2M2U3ZTRhMWU1OWY5OC4uZDJmOWFjNjQ1ZTdkNjFiNDUwMWIxYjJiOGY1 MGZiNjY5NTc3YTU2MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3Jl bW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbApAQCAtMTEsMjkgKzExLDMzIEBACiA8cD4KICAg ICBSZXN1bHQ6IDxzcGFuIGlkPSJyZXN1bHQiPnRlc3QgZGlkIG5vdCBjb21wbGV0ZS48L3NwYW4+ CiA8L3A+Ci08ZGl2IGlkPSJ0IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsg aGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAob3ZlcmZsb3dSZW1vdmUpIHRoaXMucGFyZW50 Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBpZD0idCIgc3R5bGU9Im92ZXJmbG93OiBh dXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0idGhpcy5wYXJlbnRO b2RlLnJlbW92ZUNoaWxkKHRoaXMpO2hhbmRsZVNjcm9sbCgwKTsiPgogICAgIDxkaXYgc3R5bGU9 ImhlaWdodDogMjAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogCi08ZGl2IHN0eWxlPSJvdmVyZmxvdzog YXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9ImlmIChzZWNvbmRP dmVyZmxvd1JlbW92ZSkgdGhpcy5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHRoaXMpOyI+Cis8ZGl2 IHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25z Y3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTtoYW5kbGVTY3JvbGwoMSk7 Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+PC9kaXY+CiAgICAgPGRpdiBpZD0i ZCI+PC9kaXY+CiA8L2Rpdj4KIAogPHNjcmlwdD4KLSAgICB2YXIgb3ZlcmZsb3dSZW1vdmUgPSBm YWxzZTsKLSAgICB2YXIgc2Vjb25kT3ZlcmZsb3dSZW1vdmUgPSBmYWxzZTsKKyAgICB2YXIgc2Ny b2xsZWRGaXJzdENvbnRhaW5lciA9IGZhbHNlOworICAgIHZhciBzY3JvbGxlZFNlY29uZENvbnRh aW5lciA9IGZhbHNlOwogCiAgICAgZG9jdW1lbnQuYm9keS5vZmZzZXRUb3A7IHQuc2Nyb2xsVG9w ID0gMjA7CiAKLSAgICBvdmVyZmxvd1JlbW92ZSA9IHRydWU7Ci0gICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3QnKS5pbm5lckhUTUwgPSAnJzsKLQotICAgIHNlY29uZE92ZXJmbG93UmVtb3Zl ID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZCcpLnNjcm9sbEludG9WaWV3 KCk7CiAgICAgCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4 dCA9ICJTVUNDRVNTIjsKLQotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCi0g ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICBmdW5jdGlvbiBo YW5kbGVTY3JvbGwoaW5kZXgpCisgICAgeworICAgICAgICBpZiAoaW5kZXggPT0gMCkgc2Nyb2xs ZWRGaXJzdENvbnRhaW5lciA9IHRydWU7CisgICAgICAgIGVsc2UgaWYgKGluZGV4ID09IDEpIHNj cm9sbGVkU2Vjb25kQ29udGFpbmVyID0gdHJ1ZTsKKyAgICAgICAgCisgICAgICAgIGlmIChzY3Jv bGxlZEZpcnN0Q29udGFpbmVyICYmIHNjcm9sbGVkU2Vjb25kQ29udGFpbmVyKSB7CisgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJUZXh0ID0gIlNVQ0NF U1MiOworICAgICAgICAKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgICAgICB9CisgICAgfQogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCmluZGV4IDY0 YjIwYWM0YWVmZGNkNTYxNGQyYzQ4YzAzZTZjZDJhMzIyYmQ0ZGUuLjM1NzQxMmZlMjNmYjY2YzVk ZWMxZGEwNThhZWE3NTJiZTM2MTA3OGIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3Qvb3Zl cmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCisrKyBiL0xheW91dFRlc3Rz L2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sCkBAIC0xLDE0 ICsxLDE2IEBACiA8aGVhZD4KIDxzY3JpcHQ+CiBmdW5jdGlvbiB0ZXN0KCkgewotICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICB9CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIml0Iikuc2Nyb2xsVG9wID0gMTAwOwogfQogPC9zY3Jp cHQ+CiA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CiA8cD5UaGlzIHRlc3QgaW52b2x2ZXMgYSBsYXll ciB0aGF0IHNlbGYtZGVzdHJ1Y3RzIHdoZW4gc2Nyb2xsZWQuIElmIHRoZXJlJ3Mgbm8gY3Jhc2gs IHRoZW4gdGhlIHRlc3Qgc3VjY2VlZGVkLjwvcD4KLTxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0 OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9uc2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUn Ij4KKzxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9u c2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUnO2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsiPgogPGRpdiBzdHlsZT0i aGVpZ2h0OiAyMDAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogPC9ib2R5PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sCmluZGV4IGUzZjBh YzQ0YzE5YmNhNWRiZGUxNGQxMzg3M2EwY2Q1ZjBlZTcyMGMuLmRjNjk3MTIyMTZmN2I1MTY2MGFl MzIyNGIyY2VlYWU0NjFiMTQ0YWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvcmVwYWlu dC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3JlcGFp bnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKQEAgLTMsNiArMyw4IEBACiAgICAgPHNjcmlw dD4KICAgICAgICAgZnVuY3Rpb24gcmVwYWludFRlc3QoKQogICAgICAgICB7CisgICAgICAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAgICAgICAgICAgIHZhciB0YXJnZXQg PSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAgICAgICAgICAgICBzY3JvbGxC eSgwLCAxMDApOwogICAgICAgICB9CkBAIC0xMSw2ICsxMyw4IEBACiAgICAgICAgIHsKICAgICAg ICAgICAgIHZhciB0YXJnZXQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CiAg ICAgICAgICAgICB0YXJnZXQuc3R5bGUuYmFja2dyb3VuZENvbG9yID0gImdyZWVuIjsKKyAgICAg ICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwogICAgICAgICB9CiAgICAgPC9zY3Jp cHQ+CiA8L2hlYWQ+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0FuZHJvaWQubWsgYi9XZWJDb3JlL0Fu ZHJvaWQubWsKaW5kZXggYjY0ZTMyYjZkODVmNGFjNjJmNzUyYzAyM2I3YTdlZTFjYTA2YTQ0NC4u Y2EwNzRlY2RmZWRkYWJlZGQ3NGEwYzQwNTljZDk1Y2NjMmM4ZmIxOSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9BbmRyb2lkLm1rCisrKyBiL1dlYkNvcmUvQW5kcm9pZC5tawpAQCAtMTM1LDYgKzEzNSw3 IEBAIExPQ0FMX1NSQ19GSUxFUyA6PSAkKExPQ0FMX1NSQ19GSUxFUykgXAogCWRvbS9FdmVudENv bnRleHQuY3BwIFwKIAlkb20vRXZlbnROYW1lcy5jcHAgXAogCWRvbS9FdmVudFRhcmdldC5jcHAg XAorCWRvbS9FdmVudFF1ZXVlLmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkJhc2UuY3BwIFwKIAlkb20v RXhjZXB0aW9uQ29kZS5jcHAgXAogCWRvbS9JbnB1dEVsZW1lbnQuY3BwIFwKZGlmZiAtLWdpdCBh L1dlYkNvcmUvQ01ha2VMaXN0cy50eHQgYi9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDkz MTc2ODdkZGJmYjA4MmE2NDRkNWFmM2MwMDllODU1ZThmM2ViMTIuLmZhMjZkNDg4ZDgwZjEyNGFh NGFhM2YxMjk0Y2M3OTg1NmNlYjQxODkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ01ha2VMaXN0cy50 eHQKKysrIGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtODI2LDYgKzgyNiw3IEBAIFNFVChX ZWJDb3JlX1NPVVJDRVMKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcAogICAgIGRvbS9FdmVudE5h bWVzLmNwcAogICAgIGRvbS9FdmVudFRhcmdldC5jcHAKKyAgICBkb20vRXZlbnRRdWV1ZS5jcHAK ICAgICBkb20vRXhjZXB0aW9uQmFzZS5jcHAKICAgICBkb20vRXhjZXB0aW9uQ29kZS5jcHAKICAg ICBkb20vSW5wdXRFbGVtZW50LmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhZGQzZWM2ZTIyZTc4YTYyYzVmZjJiNDhlZmUyYWUwYTI0 YzI1NjVmLi4yZDFiNzhmMDhkNjVlMTJhNTNlZGU1OGNjNGQ3MjNkNTI0OGI1YjZhIDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDQ5IEBACisyMDEwLTExLTE1ICBNaWhhaSBQYXJwYXJpdGEgIDxtaWhhaXBAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNjcm9s bCBldmVudCBzaG91bGQgYmUgZmlyZWQgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NjMxCisKKyAgICAgICAgVGVzdHM6IGZh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbAorCisgICAgICAgIE1ha2VzIHNjcm9s bCBldmVudHMgZmlyZSBhc3luY2hyb25vdXNseSB0byBiZSBpbiBjb21wbGlhbmNlIHdpdGggdGhl CisgICAgICAgIENTU09NIFZpZXcgTW9kdWxlIGFuZCBjb25zaXN0ZW50IHdpdGggR2Vja28sIE9w ZXJhIGFuZCAodG8gc29tZSBkZWdyZWUpCisgICAgICAgIElFLgorCisgICAgICAgIFRoaXMgaXMg YWNjb21wbGlzaGVkIGJ5IG1vdmluZyB0aGUgRG9jdW1lbnQ6OmVucXVldWVFdmVudCBhbmQgc3Vw cG9ydGluZworICAgICAgICBjb2RlIHRvIGEgc3RhbmRhbG9uZSBFdmVudFF1ZXVlIGNsYXNzLiBB ZGRpdGlvbmFsbHksIHRoZXJlIGlzIGFuCisgICAgICAgIGVucXVldWVTY3JvbGxFdmVudCBtZXRo b2Qgb24gRG9jdW1lbnQsIE5vZGUsIGFuZCBFdmVudFF1ZXVlIHRoYXQgaGFuZGxlcworICAgICAg ICBzY3JvbGwgZXZlbnQtc3BlY2lmaWMgYmVoYXZpb3IgKGRvbid0IGVucXVldWUgYW5vdGhlciBl dmVudCBpZiB0aGVyZSdzCisgICAgICAgIGFscmVhZHkgb25lIGVucXVldWVkIGZvciB0aGUgZWxl bWVudCwgZG9jdW1lbnQgc2Nyb2xscyBidWJibGUgYnV0CisgICAgICAgIGVsZW1lbnQgb25lcyBk b24ndCkuCisgICAgICAgIAorICAgICAgICAqIEFuZHJvaWQubWs6CisgICAgICAgICogQ01ha2VM aXN0cy50eHQ6CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5n eXBpOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dl YkNvcmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv ajoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1l bnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjplbnF1ZXVlRXZlbnQp OgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmVucXVldWVTY3JvbGxFdmVudCk6CisgICAg ICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZXZlbnRR dWV1ZSk6CisgICAgICAgICogZG9tL0V2ZW50UXVldWUuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBk b20vRXZlbnRRdWV1ZS5oOiBBZGRlZC4KKyAgICAgICAgKiBkb20vTm9kZS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpOb2RlOjplbnF1ZXVlU2Nyb2xsRXZlbnQpOgorICAgICAgICAqIGRvbS9Ob2Rl Lmg6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RXZlbnRIYW5kbGVyOjpzZW5kU2Nyb2xsRXZlbnQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJMYXllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6c2Nyb2xsVG9PZmZz ZXQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlJlbmRlckxpc3RCb3g6OnZhbHVlQ2hhbmdlZCk6CisKIDIwMTAtMTEtMTIgIEplciBO b2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQnJhZHkg RWlkc29uLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05V bWFrZWZpbGUuYW0KaW5kZXggYzg3MTRiYjE3NDYyOWU0ZTQ0YmFkY2EyOGVhYTBjNjFiNDQ2YzVk Ni4uNTU0NjA2NGU3ZTM3ZjM4YTRjZjljZTk3M2FjM2RhZGYzMzg0ODQ0OSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0x MTQ0LDYgKzExNDQsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZG9tL0V2ZW50 TmFtZXMuaCBcCiAJV2ViQ29yZS9kb20vRXZlbnRUYXJnZXQuY3BwIFwKIAlXZWJDb3JlL2RvbS9F dmVudFRhcmdldC5oIFwKKwlXZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBcCisJV2ViQ29yZS9k b20vRXZlbnRRdWV1ZS5oIFwKIAlXZWJDb3JlL2RvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAJV2Vi Q29yZS9kb20vRXhjZXB0aW9uQmFzZS5oIFwKIAlXZWJDb3JlL2RvbS9FeGNlcHRpb25Db2RlLmNw cCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5n eXBpCmluZGV4IDc1NDU1ZWQ3MjI0MTg0NThjMTY3NjY1NTQ3NGVhM2M3N2E1YWUxMDQuLjVhNGZj Mzg0MDNkOTI1OTMzNzMxYWQ3NGIyMzE4MzE1ZDdhYTE5NzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv V2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMjEwLDYgKzEyMTAs OCBAQAogICAgICAgICAgICAgJ2RvbS9FdmVudE5hbWVzLmgnLAogICAgICAgICAgICAgJ2RvbS9F dmVudFRhcmdldC5jcHAnLAogICAgICAgICAgICAgJ2RvbS9FdmVudFRhcmdldC5oJywKKyAgICAg ICAgICAgICdkb20vRXZlbnRRdWV1ZS5jcHAnLAorICAgICAgICAgICAgJ2RvbS9FdmVudFF1ZXVl LmgnLAogICAgICAgICAgICAgJ2RvbS9FeGNlcHRpb25CYXNlLmNwcCcsCiAgICAgICAgICAgICAn ZG9tL0V4Y2VwdGlvbkJhc2UuaCcsCiAgICAgICAgICAgICAnZG9tL0V4Y2VwdGlvbkNvZGUuY3Bw JywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJv CmluZGV4IDg0ZTJmMmU0NjJmNmRjMDBhODRhZDM5MDYzZTM2YzIzYTQyMzlmZDQuLmRjMTZhMmVm ZDc3NWNhYzYzYjFjNmEwZWU4YTRkMWIwYTk5MDNjMzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2Vi Q29yZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtNzE2LDYgKzcxNiw3IEBAIFNP VVJDRVMgKz0gXAogICAgIGRvbS9FdmVudENvbnRleHQuY3BwIFwKICAgICBkb20vRXZlbnROYW1l cy5jcHAgXAogICAgIGRvbS9FdmVudFRhcmdldC5jcHAgXAorICAgIGRvbS9FdmVudFF1ZXVlLmNw cCBcCiAgICAgZG9tL0V4Y2VwdGlvbkJhc2UuY3BwIFwKICAgICBkb20vRXhjZXB0aW9uQ29kZS5j cHAgXAogICAgIGRvbS9JbnB1dEVsZW1lbnQuY3BwIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qCmluZGV4IDhmNTMyM2JlYTkyZmY4YjFiODUyMmI5NjVkY2M5MzkyNTE2ODhmMWYu Ljc4OTI1MGFmM2U4OTQ4ZDBhMmEwZjMzYjJkZmY1OTNmYmQ4MWJhMDcgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3Jl LnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtNDI1NjMsNiArNDI1NjMsNjIgQEAKIAkJCQlSZWxh dGl2ZVBhdGg9Ii4uXGRvbVxFdmVudFRhcmdldC5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KKwkJ ICA8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRvbVxFdmVudFF1ZXVlLmNwcCINCisJCQkJ Pg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IkRlYnVnfFdpbjMyIg0KKwkJ CQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJ CU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0 aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IlJlbGVhc2V8V2luMzIi DQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQor CQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZp Z3VyYXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfSW50 ZXJuYWx8V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJ CQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJ CTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFt ZT0iRGVidWdfQ2Fpcm98V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJ CQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJ CS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0K KwkJCQkJTmFtZT0iUmVsZWFzZV9DYWlyb3xXaW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxk PSJ0cnVlIg0KKwkJCQkJPg0KKwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJU b29sIg0KKwkJCQkJLz4NCisJCQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQkJPEZpbGVDb25m aWd1cmF0aW9uDQorCQkJCQlOYW1lPSJEZWJ1Z19BbGx8V2luMzIiDQorCQkJCQlFeGNsdWRlZEZy b21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENv bXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJPC9G aWxlPg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZG9tXEV2ZW50UXVldWUuaCIN CisJCQkJPg0KKwkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRv bVxFeGNlcHRpb25CYXNlLmNwcCINCiAJCQkJPg0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKaW5kZXggNzhhOWE5MDFmMmNjMTgyODY3NGM0YWUwM2ZmYzhhNGNmZWE3 ZWQ3MS4uOTNjNDUxYzE5NmUwNTljMDg5ZWUzMjM2MmE3MDYzN2EzYmEyNzQ1NiAxMDA2NDQKLS0t IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViQ29y ZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTI2NTQsNiArMjY1NCw4IEBA CiAJCThBRjRFNTVDMTFEQzVBNjMwMDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEFGNEU1NTkxMURDNUE2 MzAwMEVEM0RFIC8qIFBlcmZvcm1hbmNlVGltaW5nLmggKi87IH07CiAJCThDNkVBNjE5MTFFRjdF MDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhDNkVBNjE3MTFFRjdFMDQwMEZEOEVFMyAv KiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcCAqLzsgfTsKIAkJOEM2RUE2MUExMUVGN0UwNDAw RkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhDNkVBNjE4MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50 aW1lRW5hYmxlZEZlYXR1cmVzLmggKi87IH07CisJCThGNjc1NjFCMTI4OEIxN0IwMDQ3QUNBMyAv KiBFdmVudFF1ZXVlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovOyB9OworCQk4 RjY3NTYxQzEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4RjY3NTYxQTEyODhCMTdCMDA0N0FDQTMg LyogRXZlbnRRdWV1ZS5jcHAgKi87IH07CiAJCThGQUM3NzREMTE5ODcyQ0IwMDE1QUU5NCAvKiBK U01haW5UaHJlYWRFeGVjU3RhdGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gOEY5MzREODQxMTg5RjFFRTAwNTA4RDVEIC8qIEpTTWFpblRocmVhZEV4 ZWNTdGF0ZS5jcHAgKi87IH07CiAJCTkzMDJCMEJEMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3Jv dXAuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTMw MkIwQkMwRDc5RjgyOTAwQzdFRTgzIC8qIFBhZ2VHcm91cC5jcHAgKi87IH07CiAJCTkzMDJCMEJG MEQ3OUY4MkMwMEM3RUU4MyAvKiBQYWdlR3JvdXAuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzMDJCMEJFMEQ3OUY4MkMwMEM3RUU4MyAvKiBQYWdlR3Jv dXAuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAt ODc4Myw2ICs4Nzg1LDggQEAKIAkJOEFGNEU1NUExMURDNUE2MzAwMEVEM0RFIC8qIFBlcmZvcm1h bmNlVGltaW5nLmlkbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBQZXJmb3JtYW5jZVRpbWluZy5p ZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThDNkVBNjE3MTFFRjdFMDQwMEZEOEVF MyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwOyBwYXRoID0gZ2VuZXJpYy9S dW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ OEM2RUE2MTgxMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOyBw YXRoID0gZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZlYXR1cmVzLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCThGNjc1NjE5MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEV2ZW50UXVldWUuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJOEY2NzU2MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRXZlbnRRdWV1ZS5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThGOTM0RDgzMTE4OUYxRUUwMDUwOEQ1RCAv KiBKU01haW5UaHJlYWRFeGVjU3RhdGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gSlNNYWluVGhyZWFkRXhlY1N0YXRlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CThGOTM0RDg0MTE4OUYxRUUwMDUwOEQ1RCAvKiBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSlNNYWluVGhyZWFkRXhlY1N0YXRl LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTMwMkIwQkMwRDc5RjgyOTAwQzdF RTgzIC8qIFBhZ2VHcm91cC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBQYWdlR3JvdXAuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTg0NDUsNiAr MTg0NDksOCBAQAogCQkJCTU0QzUwRjdBMEU4MDFERjMwMDk4MzJBMCAvKiBYTUxEb2N1bWVudFBh cnNlckxpYnhtbDIuY3BwICovLAogCQkJCTVEMTVFM0E5MEY5RTZBQzEwMDlFMEUzRiAvKiBYTUxE b2N1bWVudFBhcnNlclNjb3BlLmNwcCAqLywKIAkJCQk1RDE1RTNBQTBGOUU2QUMxMDA5RTBFM0Yg LyogWE1MRG9jdW1lbnRQYXJzZXJTY29wZS5oICovLAorCQkJCThGNjc1NjE5MTI4OEIxN0IwMDQ3 QUNBMyAvKiBFdmVudFF1ZXVlLmggKi8sCisJCQkJOEY2NzU2MUExMjg4QjE3QjAwNDdBQ0EzIC8q IEV2ZW50UXVldWUuY3BwICovLAogCQkJKTsKIAkJCXBhdGggPSBkb207CiAJCQlzb3VyY2VUcmVl ID0gIjxncm91cD4iOwpAQCAtMjEzODMsNiArMjEzODksNyBAQAogCQkJCTQ5OUIzQzU5MTI4QzY0 MUUwMEU3MjZDMiAvKiBHcmFwaGljc0xheWVyTWFjLmggaW4gSGVhZGVycyAqLywKIAkJCQkwODI1 MDkzOTEyOEJENEQ4MDBFMkVEOEUgLyogU1ZHQW5pbWF0ZWRUcmFuc2Zvcm1MaXN0LmggaW4gSGVh ZGVycyAqLywKIAkJCQkzODg4RjZFRjEyOEM5ODg5MDAwQ0E4RTAgLyogSW5zcGVjdG9yRmlsZVN5 c3RlbUFnZW50LmggaW4gSGVhZGVycyAqLywKKwkJCQk4RjY3NTYxQjEyODhCMTdCMDA0N0FDQTMg LyogRXZlbnRRdWV1ZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxv eW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0yMzk1Niw2ICsyMzk2Myw3IEBACiAJ CQkJOTdERDREODYwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJNDk5QjNDNUExMjhDNjQxRTAwRTcyNkMyIC8qIEdyYXBoaWNzTGF5ZXJNYWMubW0g aW4gU291cmNlcyAqLywKIAkJCQkzODg4RjZFRTEyOEM5ODg5MDAwQ0E4RTAgLyogSW5zcGVjdG9y RmlsZVN5c3RlbUFnZW50LmNwcCBpbiBTb3VyY2VzICovLAorCQkJCThGNjc1NjFDMTI4OEIxN0Iw MDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9u bHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9kb20vRG9jdW1lbnQuY3BwIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IDRj MzQyNWE3M2RmZDhiZmI4ZDUwNWMwODkzNDJlZDg1OTZlMmQ4MzMuLjEwYjQxMzUyOTdjMGVmNTc4 NDVlMGU2ZjFhMDVmOWYwNzE3NDE0YzUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmNwcAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKQEAgLTU4LDYgKzU4LDcgQEAKICNp bmNsdWRlICJFdmVudEhhbmRsZXIuaCIKICNpbmNsdWRlICJFdmVudExpc3RlbmVyLmgiCiAjaW5j bHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJF eGNlcHRpb25Db2RlLmgiCiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAi RnJhbWUuaCIKQEAgLTM5OSw3ICs0MDAsNyBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZy YW1lLCBjb25zdCBLVVJMJiB1cmwsIGJvb2wgaXNYSFRNTCwgYm9vbCBpc0hUTUwsIGNvbgogICAg ICwgbV9ub3JtYWxXb3JsZFdyYXBwZXJDYWNoZSgwKQogI2VuZGlmCiAgICAgLCBtX3VzaW5nR2Vv bG9jYXRpb24oZmFsc2UpCi0gICAgLCBtX3BlbmRpbmdFdmVudFRpbWVyKHRoaXMsICZEb2N1bWVu dDo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZCkKKyAgICAsIG1fZXZlbnRRdWV1ZShuZXcgRXZlbnRR dWV1ZSkKICNpZiBFTkFCTEUoV01MKQogICAgICwgbV9jb250YWluc1dNTENvbnRlbnQoZmFsc2Up CiAjZW5kaWYKQEAgLTM0MzksMjEgKzM0NDAsMTMgQEAgdm9pZCBEb2N1bWVudDo6ZGlzcGF0Y2hX aW5kb3dMb2FkRXZlbnQoKQogCiB2b2lkIERvY3VtZW50OjplbnF1ZXVlRXZlbnQoUGFzc1JlZlB0 cjxFdmVudD4gZXZlbnQpCiB7Ci0gICAgbV9wZW5kaW5nRXZlbnRRdWV1ZS5hcHBlbmQoZXZlbnQp OwotICAgIGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKQotICAgICAgICBtX3Bl bmRpbmdFdmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKKyAgICBldmVudC0+c2V0VGFyZ2V0KHRo aXMpOworICAgIG1fZXZlbnRRdWV1ZS0+ZW5xdWV1ZUV2ZW50KGV2ZW50KTsKIH0KIAotdm9pZCBE b2N1bWVudDo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQordm9pZCBE b2N1bWVudDo6ZW5xdWV1ZVNjcm9sbEV2ZW50KCkKIHsKLSAgICBBU1NFUlQoIW1fcGVuZGluZ0V2 ZW50VGltZXIuaXNBY3RpdmUoKSk7Ci0gICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBldmVudFF1 ZXVlOwotICAgIGV2ZW50UXVldWUuc3dhcChtX3BlbmRpbmdFdmVudFF1ZXVlKTsKLQotICAgIHR5 cGVkZWYgVmVjdG9yPFJlZlB0cjxFdmVudD4gPjo6Y29uc3RfaXRlcmF0b3IgSXRlcmF0b3I7Ci0g ICAgSXRlcmF0b3IgZW5kID0gZXZlbnRRdWV1ZS5lbmQoKTsKLSAgICBmb3IgKEl0ZXJhdG9yIGl0 ID0gZXZlbnRRdWV1ZS5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCi0gICAgICAgIGRpc3BhdGNo V2luZG93RXZlbnQoKml0KTsKKyAgICBtX2V2ZW50UXVldWUtPmVucXVldWVTY3JvbGxFdmVudCh0 aGlzLCB0cnVlKTsKIH0KIAogUGFzc1JlZlB0cjxFdmVudD4gRG9jdW1lbnQ6OmNyZWF0ZUV2ZW50 KGNvbnN0IFN0cmluZyYgZXZlbnRUeXBlLCBFeGNlcHRpb25Db2RlJiBlYykKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZG9tL0RvY3VtZW50LmggYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGJh NDhkNmY4MmVjYjQwOGJkYmQxNDdmNjIzZTllNmM5Y2JmMjIxNjkuLjJkNDMzNjcwY2MxNjE2ZjIw YjhhOGJkMmRiYmRiNWExMmYwODNhOTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmgKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuaApAQCAtNzUsNiArNzUsNyBAQCBjbGFzcyBF bGVtZW50OwogY2xhc3MgRW50aXR5UmVmZXJlbmNlOwogY2xhc3MgRXZlbnQ7CiBjbGFzcyBFdmVu dExpc3RlbmVyOworY2xhc3MgRXZlbnRRdWV1ZTsKIGNsYXNzIEZyYW1lOwogY2xhc3MgRnJhbWVW aWV3OwogY2xhc3MgSFRNTENhbnZhc0VsZW1lbnQ7CkBAIC0xMDE3LDkgKzEwMTgsMTEgQEAgcHVi bGljOgogICAgIHZvaWQgc2V0Q29udGFpbnNWYWxpZGl0eVN0eWxlUnVsZXMoKSB7IG1fY29udGFp bnNWYWxpZGl0eVN0eWxlUnVsZXMgPSB0cnVlOyB9CiAKICAgICB2b2lkIGVucXVldWVFdmVudChQ YXNzUmVmUHRyPEV2ZW50Pik7CisgICAgdm9pZCBlbnF1ZXVlU2Nyb2xsRXZlbnQoKTsKICAgICB2 b2lkIGVucXVldWVQYWdlc2hvd0V2ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0ZW5jZSk7CiAgICAg dm9pZCBlbnF1ZXVlSGFzaGNoYW5nZUV2ZW50KGNvbnN0IFN0cmluZyYgb2xkVVJMLCBjb25zdCBT dHJpbmcmIG5ld1VSTCk7CiAgICAgdm9pZCBlbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gc3RhdGVPYmplY3QpOworICAgIEV2ZW50UXVldWUqIGV2 ZW50UXVldWUoKSBjb25zdCB7IHJldHVybiBtX2V2ZW50UXVldWUuZ2V0KCk7IH0KIAogICAgIHZv aWQgYWRkTWVkaWFDYW5TdGFydExpc3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwogICAg IHZvaWQgcmVtb3ZlTWVkaWFDYW5TdGFydExpc3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciop OwpAQCAtMTExNiw4ICsxMTE5LDYgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgY3JlYXRlU3R5bGVT ZWxlY3RvcigpOwogCi0gICAgdm9pZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3Vt ZW50PiopOwotCiAgICAgUGFzc1JlZlB0cjxOb2RlTGlzdD4gaGFuZGxlWmVyb1BhZGRpbmcoY29u c3QgSGl0VGVzdFJlcXVlc3QmLCBIaXRUZXN0UmVzdWx0JikgY29uc3Q7CiAKICAgICB2b2lkIGxv YWRFdmVudERlbGF5VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKTsKQEAgLTEzMzksOSArMTM0 MCw4IEBAIHByaXZhdGU6CiAjZW5kaWYKIAogICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwot Ci0gICAgVGltZXI8RG9jdW1lbnQ+IG1fcGVuZGluZ0V2ZW50VGltZXI7Ci0gICAgVmVjdG9yPFJl ZlB0cjxFdmVudD4gPiBtX3BlbmRpbmdFdmVudFF1ZXVlOworICAgIAorICAgIE93blB0cjxFdmVu dFF1ZXVlPiBtX2V2ZW50UXVldWU7CiAKICNpZiBFTkFCTEUoV01MKQogICAgIGJvb2wgbV9jb250 YWluc1dNTENvbnRlbnQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBi L1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmIxZWM0NWM3OTg5OWYxODE5 MjU4Yzg3MmRlYzEzNzI3NjhjMDZiZDIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9F dmVudFF1ZXVlLmNwcApAQCAtMCwwICsxLDk2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5E IEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BF Q0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiRXZlbnRRdWV1ZS5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQu aCIKKyNpbmNsdWRlICJFdmVudC5oIgorI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRl ICJOb2RlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordHlwZWRlZiBWZWN0b3I8UmVmUHRy PEV2ZW50PiA+Ojpjb25zdF9pdGVyYXRvciBFdmVudEl0ZXJhdG9yOworCitFdmVudFF1ZXVlOjpF dmVudFF1ZXVlKCkKKyAgICA6IG1fcGVuZGluZ0V2ZW50VGltZXIodGhpcywgJkV2ZW50UXVldWU6 OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCit7Cit9CisKK0V2ZW50UXVldWU6On5FdmVudFF1ZXVl KCkKK3sKKyAgICBtX2VucXVldWVkRXZlbnRzLmNsZWFyKCk7Cit9CisKK3ZvaWQgRXZlbnRRdWV1 ZTo6ZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQoreworICAgIEFTU0VSVChl dmVudC0+dGFyZ2V0KCktPnRvTm9kZSgpKTsKKyAgICBtX2VucXVldWVkRXZlbnRzLmFwcGVuZChl dmVudCk7CisgICAgCisgICAgaWYgKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpCisg ICAgICAgIG1fcGVuZGluZ0V2ZW50VGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIEV2 ZW50UXVldWU6OmVucXVldWVTY3JvbGxFdmVudChQYXNzUmVmUHRyPE5vZGU+IHRhcmdldCwgYm9v bCBjYW5CdWJibGUpCit7CisgICAgaWYgKG1fbm9kZXNXaXRoRW5xdWV1ZWRTY3JvbGxFdmVudHMu Y29udGFpbnModGFyZ2V0LmdldCgpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9ub2Rlc1dp dGhFbnF1ZXVlZFNjcm9sbEV2ZW50cy5hZGQodGFyZ2V0LmdldCgpKTsKKyAgICBSZWZQdHI8RXZl bnQ+IHNjcm9sbEV2ZW50ID0gRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQs IGNhbkJ1YmJsZSwgZmFsc2UpOworICAgIHNjcm9sbEV2ZW50LT5zZXRUYXJnZXQodGFyZ2V0KTsK KyAgICBlbnF1ZXVlRXZlbnQoc2Nyb2xsRXZlbnQpOworfQorCit2b2lkIEV2ZW50UXVldWU6OnBl bmRpbmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RXZlbnRRdWV1ZT4qKQoreworICAgIEFTU0VSVCgh bV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKTsKKyAgICBWZWN0b3I8UmVmUHRyPEV2ZW50 PiA+IGVucXVldWVkRXZlbnRzOworICAgIGVucXVldWVkRXZlbnRzLnN3YXAobV9lbnF1ZXVlZEV2 ZW50cyk7CisgICAgCisgICAgRXZlbnRJdGVyYXRvciBlbmQgPSBlbnF1ZXVlZEV2ZW50cy5lbmQo KTsKKyAgICBmb3IgKEV2ZW50SXRlcmF0b3IgaXQgPSBlbnF1ZXVlZEV2ZW50cy5iZWdpbigpOyBp dCAhPSBlbmQ7ICsraXQpCisgICAgICAgIGRpc3BhdGNoRXZlbnQoKml0KTsKK30KKwordm9pZCBF dmVudFF1ZXVlOjpkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQoreworICAg IE5vZGUqIGV2ZW50VGFyZ2V0ID0gZXZlbnQtPnRhcmdldCgpLT50b05vZGUoKTsKKyAgICAKKyAg ICBpZiAoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50ID09IGV2ZW50LT50eXBlKCkpCisgICAgICAg IG1fbm9kZXNXaXRoRW5xdWV1ZWRTY3JvbGxFdmVudHMucmVtb3ZlKGV2ZW50VGFyZ2V0KTsKKyAg ICAKKyAgICBpZiAoIWV2ZW50VGFyZ2V0LT5pbkRvY3VtZW50KCkpCisgICAgICAgIHJldHVybjsK KworICAgIGlmIChldmVudFRhcmdldC0+aXNEb2N1bWVudE5vZGUoKSkKKyAgICAgICAgZXZlbnRU YXJnZXQtPmRvY3VtZW50KCktPmRpc3BhdGNoV2luZG93RXZlbnQoZXZlbnQpOworICAgIGVsc2UK KyAgICAgICAgZXZlbnRUYXJnZXQtPmRpc3BhdGNoRXZlbnQoZXZlbnQpOworfQorCit9CmRpZmYg LS1naXQgYS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmggYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVl LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMmVjZWJlZGZlZDc0NzUyNzVjNTQ0MjJhMzE2ZWY3ZmVkMjFiNjEwNQot LS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaApAQCAtMCwwICsxLDYw IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuIAorICoKKyAqLworCisjaWZuZGVmIEV2ZW50UXVldWVfaAorI2RlZmluZSBFdmVudFF1 ZXVlX2gKKworI2luY2x1ZGUgIlRpbWVyLmgiCisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KKyNp bmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK2NsYXNzIEV2ZW50OworY2xhc3MgTm9kZTsKK3N0cnVjdCBFbnF1ZXVl ZEV2ZW50OworCitjbGFzcyBFdmVudFF1ZXVlIHsKK3B1YmxpYzoKKyAgICBFdmVudFF1ZXVlKCk7 CisgICAgfkV2ZW50UXVldWUoKTsKKworICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8 RXZlbnQ+KTsKKyAgICB2b2lkIGVucXVldWVTY3JvbGxFdmVudChQYXNzUmVmUHRyPE5vZGU+IHRh cmdldCwgYm9vbCBjYW5CdWJibGUpOworCitwcml2YXRlOgorICAgIHZvaWQgcGVuZGluZ0V2ZW50 VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopOworICAgIHZvaWQgZGlzcGF0Y2hFdmVudChQ YXNzUmVmUHRyPEV2ZW50Pik7CisKKyAgICBUaW1lcjxFdmVudFF1ZXVlPiBtX3BlbmRpbmdFdmVu dFRpbWVyOworICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID4gbV9lbnF1ZXVlZEV2ZW50czsKKyAg ICBIYXNoU2V0PE5vZGUqPiBtX25vZGVzV2l0aEVucXVldWVkU2Nyb2xsRXZlbnRzOworfTsKKwor fQorCisjZW5kaWYgLy8gRXZlbnRRdWV1ZV9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Ob2Rl LmNwcCBiL1dlYkNvcmUvZG9tL05vZGUuY3BwCmluZGV4IGU3MWM0YmRmZTA5ZjE3N2IzZTY1ZGVm ZWI0Yjc5NTYzMzk2MTQ3N2IuLjJiMmM2NjIwZGYyYWI3NzIwMTg3NzA5NjI3YjRhZTlhNTE1N2Q4 MGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGUuY3BwCisrKyBiL1dlYkNvcmUvZG9tL05v ZGUuY3BwCkBAIC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5j bHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRl ICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCkBAIC0yNTUwLDYgKzI1NTEsMTEgQEAgYm9v bCBOb2RlOjpkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IHBycEV2ZW50KQogICAgIHJl dHVybiBkaXNwYXRjaEdlbmVyaWNFdmVudChldmVudC5yZWxlYXNlKCkpOwogfQogCit2b2lkIE5v ZGU6OmVucXVldWVTY3JvbGxFdmVudCgpCit7CisgICAgZG9jdW1lbnQoKS0+ZXZlbnRRdWV1ZSgp LT5lbnF1ZXVlU2Nyb2xsRXZlbnQodGhpcywgZmFsc2UpOworfQorCiBzdGF0aWMgY29uc3QgRXZl bnRDb250ZXh0KiB0b3BFdmVudENvbnRleHQoY29uc3QgVmVjdG9yPEV2ZW50Q29udGV4dD4mIGFu Y2VzdG9ycykKIHsKICAgICByZXR1cm4gYW5jZXN0b3JzLmlzRW1wdHkoKSA/IDAgOiAmYW5jZXN0 b3JzLmxhc3QoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL05vZGUuaCBiL1dlYkNvcmUvZG9t L05vZGUuaAppbmRleCA2NzVkZTA0ZDE5YWFiMWM1NTBhODM0Yjc5MTM5YmUwOGZmNjQ5NDA1Li5j OWY2N2I2M2M4Y2M3M2Q4MjIyODMxN2VkMjIxZDYyODliNWU0ZTQxIDEwMDY0NAotLS0gYS9XZWJD b3JlL2RvbS9Ob2RlLmgKKysrIGIvV2ViQ29yZS9kb20vTm9kZS5oCkBAIC01MTcsNiArNTE3LDcg QEAgcHVibGljOgogCiAgICAgdXNpbmcgRXZlbnRUYXJnZXQ6OmRpc3BhdGNoRXZlbnQ7CiAgICAg dmlydHVhbCBib29sIGRpc3BhdGNoRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQg ZW5xdWV1ZVNjcm9sbEV2ZW50KCk7CiAKICAgICBib29sIGRpc3BhdGNoR2VuZXJpY0V2ZW50KFBh c3NSZWZQdHI8RXZlbnQ+KTsKICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlTG9jYWxFdmVudHMoRXZl bnQqKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvV2ViQ29y ZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggZjZhMjM1MzgxNWY2MWFkYmQxZGM0MTgxMDA1 ZTI1Y2EwNzZiYWJhMS4uOWZlNGM3YWYyNzkzZThkZTQ3Mjc5Nzc2YzI1OGY4N2NiOTE3MDgzNSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKKysrIGIvV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTI3NTcsNyArMjc1Nyw3IEBAIHZvaWQgRXZlbnRIYW5k bGVyOjpzZW5kU2Nyb2xsRXZlbnQoKQogewogICAgIHNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIo KTsKICAgICBpZiAobV9mcmFtZS0+dmlldygpICYmIG1fZnJhbWUtPmRvY3VtZW50KCkpCi0gICAg ICAgIG1fZnJhbWUtPmRvY3VtZW50KCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVu dE5hbWVzKCkuc2Nyb2xsRXZlbnQsIHRydWUsIGZhbHNlKSk7CisgICAgICAgIG1fZnJhbWUtPmRv Y3VtZW50KCktPmVucXVldWVTY3JvbGxFdmVudCgpOwogfQogCiB2b2lkIEV2ZW50SGFuZGxlcjo6 c2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMYXllci5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKaW5k ZXggN2I5MDAwYzY1NTNhMjQ2MjVhMDBiNjY2NjFiODg0M2QwMjc2MWY4Yi4uZjhlOThmMDM2Y2Fm ODU5MWY1Y2Y3ZDc3ODMxNjBiMjBhMGJkNWY0YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNw cApAQCAtMTM5NywxMCArMTM5Nyw3IEBAIHZvaWQgUmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0 KGludCB4LCBpbnQgeSwgYm9vbCB1cGRhdGVTY3JvbGxiYXJzLCBib29sIHJlcGFpCiAgICAgfQog CiAgICAgLy8gU2NoZWR1bGUgdGhlIHNjcm9sbCBET00gZXZlbnQuCi0gICAgaWYgKHZpZXcpIHsK LSAgICAgICAgaWYgKEZyYW1lVmlldyogZnJhbWVWaWV3ID0gdmlldy0+ZnJhbWVWaWV3KCkpCi0g ICAgICAgICAgICBmcmFtZVZpZXctPnNjaGVkdWxlRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVudE5h bWVzKCkuc2Nyb2xsRXZlbnQsIGZhbHNlLCBmYWxzZSksIHJlbmRlcmVyKCktPm5vZGUoKSk7Ci0g ICAgfQorICAgIHJlbmRlcmVyKCktPm5vZGUoKS0+ZW5xdWV1ZVNjcm9sbEV2ZW50KCk7CiB9CiAK IHZvaWQgUmVuZGVyTGF5ZXI6OnNjcm9sbFJlY3RUb1Zpc2libGUoY29uc3QgSW50UmVjdCYgcmVj dCwgYm9vbCBzY3JvbGxUb0FuY2hvciwgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnblgsIGNv bnN0IFNjcm9sbEFsaWdubWVudCYgYWxpZ25ZKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyTGlzdEJveC5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNw cAppbmRleCA1MzJjNTUxMmQ3OGI0OTVmNzJlZjMzOWIwZmY2ZDc4ZjQ3ZDUyNGUxLi5hNWYzMGMy MWQxOTgyZjdlNThmNTY3OWI3ZDZmZWVmMjQ4NzcxMDExIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJM aXN0Qm94LmNwcApAQCAtNTQwLDcgKzU0MCw3IEBAIHZvaWQgUmVuZGVyTGlzdEJveDo6dmFsdWVD aGFuZ2VkKFNjcm9sbGJhciopCiAgICAgaWYgKG5ld09mZnNldCAhPSBtX2luZGV4T2Zmc2V0KSB7 CiAgICAgICAgIG1faW5kZXhPZmZzZXQgPSBuZXdPZmZzZXQ7CiAgICAgICAgIHJlcGFpbnQoKTsK LSAgICAgICAgbm9kZSgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygp LnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKKyAgICAgICAgbm9kZSgpLT5lbnF1ZXVlU2Ny b2xsRXZlbnQoKTsKICAgICB9CiB9CiAK 73952 2010-11-15 19:13:50 -0800 2010-11-16 11:51:47 -0800 Patch bug-45631-20101115191348.patch text/plain 43729 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNDkwNTVlYWI4MTJkMjRjODk3YzdiNGRmNjUxODBlMGVkMmMzN2M1Li4xYzM1MTdl ODY1MWJlM2Q0MjUwODg4YmM1MTgwYTk3MjA2OWY1Yjg4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuCisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93 bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAt ZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6IEFkZGVkLiBEb2VzIHRoZSBzYW1lCisg ICAgICAgICAgICB0ZXN0cyBhcyBmaXJlLXNjcm9sbC1ldmVudC5odG1sLCBidXQgb24gYW4gaW5k aXZpZHVhbCBlbGVtZW50IGluc3RlYWQKKyAgICAgICAgICAgIG9mIHRoZSB3aG9sZSBkb2N1bWVu dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQ6 CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbDogTm93IGV4cGxp Y2l0bHkgdGVzdHMgZm9yCisgICAgICAgICAgICBzeW5jaHJvbm91cyBiZWhhdmlvciB3aGVuIHNj cm9sbGluZyB0aGUgZG9jdW1lbnQsIGFuZCB0aGF0IHdlIGRvbid0CisgICAgICAgICAgICBmaXJl IHRoZSBldmVudCBtb3JlIHRoYW4gb25jZS4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9yZW1vdmUt Y2hpbGQtb25zY3JvbGwuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5n LXpvb20tY2hhbmdlLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sOiBBZGRlZC4gQ2hlY2tzIHRoYXQgd2UgY2FuIGxpc3RlbgorICAgICAg ICAgICAgZm9yIHNjcm9sbCBldmVudHMgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlLgorICAgICAgICAqIGZhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRt bDoKKyAgICAgICAgKiBmYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbDoKKyAgICAgICAgKiBmYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWw6 CisKIDIwMTAtMTEtMTUgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgog CiAgICAgICAgIFtHVEtdIE5hdmlnYXRpb24gcG9saWN5IGRlY2lzaW9uIEFQSSBuZWVkcyB0byBp bmNsdWRlIHRoZSBET00gbm9kZSB0aGF0IHRoZSBkZWNpc2lvbiBvcmlnaW5hdGVkIGZyb20KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Ny b2xscy1leHBlY3RlZC50eHQKaW5kZXggMjRkZWU0ZDg4OGRiMWRhYjQ2ODBjMzA2ZjgyYjY0YmY2 MjYzZDY2NC4uYjViMGNmMGY1NDZjMmU0MWVlMWM3ODRjMDVjYWIyMzcwNGFiOTZiNSAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBl Y3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Ny b2xscy1leHBlY3RlZC50eHQKQEAgLTEsNCArMSw0IEBACiB4eAotVGhpcyB0ZXN0IHNpbXVsYXRl cyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3Nl cyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2ZW50LiBUaGlzIHRlc3QgcmVx dWlyZXMgRFJUIHRvIHBhc3MuCitUaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBh bmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBl eGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIElmIHJ1bm5pbmcgbWFudWFsbHksIHByZXNzIHRoZSBr ZXlzIG5vdy4KIFBBU1MKIChqdXN0IGhlcmUgdG8gZm9yY2Ugc2Nyb2xsYmFycykKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMuaHRtbCBi L0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMuaHRtbAppbmRl eCBmYzgzYjE0ODIzZDJlZDcwZGIzMjUwMDg5NWIxNGNjYjNiYTk3MWU3Li5lNWJhYmM3ZGIwY2Ji MGRhMjI3YzFjOTM4NmZkOWY0OWI0NmJhMjVkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9lZGl0 aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCkBAIC0yLDM4ICsyLDQxIEBACiA8 aHRtbD4KIDxoZWFkPgogPHNjcmlwdD4KLWlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIp CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuZHVtcEFzVGV4dCgpOworICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERv bmUoKTsKK30KIAotZnVuY3Rpb24gc2NyKCkKLXsKK3ZhciBzdGVwID0gMDsKKworb25zY3JvbGwg PSBmdW5jdGlvbigpIHsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbG9nJykuaW5uZXJU ZXh0ICs9ICd4JzsKKworICAgIHN3aXRjaCAoc3RlcCkgeworICAgIGNhc2UgMDoKKyAgICAgICAg aWYgKHdpbmRvdy5ldmVudFNlbmRlcikKKyAgICAgICAgICAgIGV2ZW50U2VuZGVyLmtleURvd24o J3BhZ2VVcCcpOworICAgICAgICAgICAgYnJlYWs7CisgICAgY2FzZSAxOgorICAgICAgICBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0cycpLmlubmVyVGV4dCA9ICdQQVNTJzsKKyAgICAg ICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorICAgIAor ICAgIHN0ZXArKzsKIH0KIAogZnVuY3Rpb24gcnVuVGVzdCgpCiB7Ci0gICAgaWYgKCF3aW5kb3cu ZXZlbnRTZW5kZXIpCi0gICAgICAgIHJldHVybjsKLQotICAgIHdpbmRvdy5hZGRFdmVudExpc3Rl bmVyKCdzY3JvbGwnLCBzY3IsIGZhbHNlKTsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBh Z2VEb3duIik7Ci0gICAgdmFyIHRleHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbG9nJyku aW5uZXJUZXh0OwotICAgIGlmICh0ZXh0ICE9ICJ4IikKLSAgICAgICAgdGhyb3cgImxvZyBzaG91 bGQgY29udGFpbiB4LCBub3QgIiArIHRleHQ7Ci0KLSAgICBldmVudFNlbmRlci5rZXlEb3duKCJw YWdlVXAiKTsKLSAgICB2YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5p bm5lclRleHQ7Ci0gICAgaWYgKHRleHQgIT0gInh4IikKLSAgICAgICAgdGhyb3cgImxvZyBzaG91 bGQgY29udGFpbiB4eCwgbm90ICIgKyB0ZXh0OwotCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7CisgICAgaWYgKHdpbmRvdy5ldmVudFNl bmRlcikKKyAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFnZURvd24nKTsKIH0KIDwvc2Ny aXB0PgogPC9oZWFkPgogPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPiAKIDxzcGFuIGlkPSJsb2ci IHN0eWxlPSJwb3NpdGlvbjpmaXhlZCI+PC9zcGFuPiAKLTxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRl cyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3Nl cyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2ZW50LiBUaGlzIHRlc3QgcmVx dWlyZXMgRFJUIHRvIHBhc3MuPC9kaXY+Cis8ZGl2PlRoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGlu ZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxk IGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9sbCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwg cHJlc3MgdGhlIGtleXMgbm93LjwvZGl2PgogPGRpdiBpZD0icmVzdWx0cyI+RkFJTDwvZGl2Pgog PGRpdiBzdHlsZT0iaGVpZ2h0OjUwMDAwcHgiPihqdXN0IGhlcmUgdG8gZm9yY2Ugc2Nyb2xsYmFy cyk8L2Rpdj4gCiA8c2NyaXB0PiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFz dC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uMTFhMmUyMmY2OTBiNWZiMjdkYTkzM2EwODU0NGRjY2U5ZjIwZWVhOAotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorUEFTU0VELCBzY3JvbGwgcG9zaXRpb246ICgw LCAyMDApCitJZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4g dGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBz Y3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLCBmaXJlZCBzeW5jaHJvbm91c2x5LCBvciBmaXJlZCBt b3JlIHRoYW4gb25jZS4KKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9m aXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9m aXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWNkNjZlMTRkNjRlYjgx ZWQ1MjVkYzk5YTdlNTQ0MzU4MGFlM2I4YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbApAQCAtMCwwICsxLDUy IEBACis8aHRtbD4KKzxzY3JpcHQ+Cit2YXIgZXZlbnRDb3VudCA9IDA7Cit2YXIgZG9uZVRpbWVv dXQ7CisKK2Z1bmN0aW9uIHNjcm9sbEhhbmRsZXIoKQoreworICAgIGV2ZW50Q291bnQrKzsKKyAg ICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIHZhciBjb250YWluZXIgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVyJyk7CisgICAgICAgIHZhciBzY3JvbGxYID0gY29u dGFpbmVyLnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gY29udGFpbmVyLnNjcm9s bFRvcDsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLnRleHRDb250 ZW50ID0gJ1BBU1NFRCwgc2Nyb2xsIHBvc2l0aW9uOiAoJyArIHNjcm9sbFggKyAnLCAnICsgc2Ny b2xsWSArICcpJzsKKyAgICAgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0cmFpZ2h0IGF3 YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcuCisgICAgICAg IGRvbmVUaW1lb3V0ID0gc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgfSwgMTAwKTsKKyAgICB9IGVsc2Ug eworICAgICAgICBjbGVhclRpbWVvdXQoZG9uZVRpbWVvdXQpOworICAgICAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnRkFJTCwgc2Nyb2xsIGhhbmRs ZXIgd2FzIGludm9rZWQgJyArIGV2ZW50Q291bnQgKyAnIHRpbWVzJzsKKyAgICB9Cit9CisKK29u bG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB2YXIgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAgIGNvbnRhaW5lci5hZGRFdmVudExpc3RlbmVyKCdz Y3JvbGwnLCBzY3JvbGxIYW5kbGVyLCBmYWxzZSk7CisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25l KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICB9Cisg ICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDEwMDsKKyAgICBpZiAoZXZlbnRDb3VudCA+IDApIHsK KyAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJ TEVELCBldmVudCBmaXJlZCBzeW5jaHJvbm91c2x5Lic7ICAgICAgCisgICAgICBpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5v dGlmeURvbmUoKTsgICAgICAKKyAgICB9CisgICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDIwMDsK K30KKworPC9zY3JpcHQ+Cis8Ym9keT4KKzxkaXYgaWQ9InJlc3VsdCI+RkFJTCwgZXZlbnQgZGlk IG5vdCBmaXJlPC9kaXY+CisKKzxwPklmIHRoZSB3b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVh ciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQg bWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUsIGZpcmVkIHN5bmNocm9ub3Vz bHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLjwvcD4KKworPGRpdiBpZD0iY29udGFpbmVyIiBz dHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiA1MDBweDsgaGVpZ2h0OiA1MDBweCI+CisgIDxk aXYgc3R5bGU9ImhlaWdodDogNTAwMHB4OyB3aWR0aDogNTAwMHB4OyI+PC9kaXY+Cis8L2Rpdj4K KzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQK aW5kZXggMTY4NmNlZDM5YWUyYmUyZDU5YjYzZTlkM2ZkYWU0YjFlMmM4ODY1Ni4uMTBmOGU0Mzkw MmJkMTg0NmFkZDIyNWRlNmMyZTgwMGFmYTUxMmU2MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRl c3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dApAQCAtMSw1OSAr MSw0IEBACi1QQVNTRUQKK1BBU1NFRCwgc2Nyb2xsIHBvc2l0aW9uOiAoMjAwLCAyMDApCitJZiB0 aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFz IGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQg ZGlkIG5vdCBmaXJlLCBmaXJlZCBzeW5jaHJvbm91c2x5LCBvciBmaXJlZCBtb3JlIHRoYW4gb25j ZS4KIAotSWYgdGhlIHdvcmQgJ1BBU1NFRCcgZG9lcyBub3QgYXBwZWFyIGFib3ZlLCB0aGVuIHRo ZSB0ZXN0IGhhcyBmYWlsZWQuIElmIHRoZSB0ZXN0IGZhaWxzLCBpdCBtZWFucyB0aGF0IGEgc2Ny b2xsIGV2ZW50IGRpZCBub3QgZmlyZS4KLQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQot YQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQot YQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQotYQot YQotYQotYQotYQotYQotYQogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9m aXJlLXNjcm9sbC1ldmVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3Jv bGwtZXZlbnQuaHRtbAppbmRleCBhMDU2YzA2N2JkOWYyN2M0YjM0NjVjODRhMTZlMjFhOWZhM2U3 MTRjLi43Y2QwYTU2ZDBhODQwMzUxYTI0ODdkZTgzZGU3NDI4ZTI4YTAwMDE0IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKQEAgLTEsMzAgKzEs NDcgQEAKIDxodG1sPgogPHNjcmlwdD4KLXZhciBldmVudEZpcmVkID0gZmFsc2U7Cit2YXIgZXZl bnRDb3VudCA9IDA7Cit2YXIgZG9uZVRpbWVvdXQ7CiAKLWZ1bmN0aW9uIHNjcm9sbGVyKCkgewot ICAgIGlmICghZXZlbnRGaXJlZCkgewotICAgICAgICBldmVudEZpcmVkID0gdHJ1ZTsKLSAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhc3NlZCIpLmlubmVySFRNTCA9ICI8cCBzdHls ZT0nY29sb3I6cmVkJz5QQVNTRUQ8L3A+IjsKK29uc2Nyb2xsID0gZnVuY3Rpb24oKQoreworICAg IGV2ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIHZhciBz Y3JvbGxYID0gZG9jdW1lbnQuYm9keS5zY3JvbGxMZWZ0OworICAgICAgICB2YXIgc2Nyb2xsWSA9 IGRvY3VtZW50LmJvZHkuc2Nyb2xsVG9wOworICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgncmVzdWx0JykudGV4dENvbnRlbnQgPSAnUEFTU0VELCBzY3JvbGwgcG9zaXRpb246ICgnICsg c2Nyb2xsWCArICcsICcgKyBzY3JvbGxZICsgJyknOworICAgICAgICAvLyBEb24ndCBjYWxsIG5v dGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2 ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkg eworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAg ICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICB9 LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyVGltZW91dChkb25lVGltZW91dCk7 CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS50ZXh0Q29udGVudCA9 ICdGQUlMLCBzY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAnICsgZXZlbnRDb3VudCArICcgdGlt ZXMnOwogICAgIH0KIH0KIAotd2luZG93Lm9ubG9hZCA9IGZ1bmN0aW9uKCkgewotICAgIHdpbmRv dy5hZGRFdmVudExpc3RlbmVyKCdzY3JvbGwnLCBzY3JvbGxlciwgZmFsc2UpOwotICAgIHdpbmRv dy5zY3JvbGxUbyg1MDAsIDUwMCk7CitvbmxvYWQgPSBmdW5jdGlvbigpCit7CiAgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKICAgICB9CisgICAgd2luZG93LnNjcm9sbFRvKDEwMCwgMTAwKTsKKyAgICBpZiAoZXZl bnRDb3VudCA+IDApIHsKKyAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5p bm5lckhUTUwgPSAnRkFJTEVELCBldmVudCBmaXJlZCBzeW5jaHJvbm91c2x5Lic7ICAgICAgCisg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsgICAgICAKKyAgICB9CisgICAgd2luZG93LnNjcm9s bFRvKDIwMCwgMjAwKTsKIH0KIAogPC9zY3JpcHQ+CiA8Ym9keT4KLTxkaXYgaWQ9InBhc3NlZCI+ PC9kaXY+Cis8ZGl2IGlkPSJyZXN1bHQiPkZBSUwsIGV2ZW50IGRpZCBub3QgZmlyZTwvZGl2Pgog Ci08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhl IHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3Jv bGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KKzxwPklmIHRoZSB3b3JkICdQQVNTRUQnIGRvZXMg bm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUgdGVzdCBm YWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUsIGZpcmVkIHN5 bmNocm9ub3VzbHksIG9yIGZpcmVkIG1vcmUgdGhhbiBvbmNlLjwvcD4KIAotYTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj4K LWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5h PGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgorPGRpdiBzdHlsZT0iaGVpZ2h0OiA1 MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KIDwvYm9keT4KIDwvaHRtbD4KXCBObyBuZXds aW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9y ZW1vdmUtY2hpbGQtb25zY3JvbGwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92 ZS1jaGlsZC1vbnNjcm9sbC5odG1sCmluZGV4IDI1MmNmZWEzMzBmZTUwMjI3OGQzNmVmMThlMDcx ZmNiMzY1NGNjMzUuLmVhYmIwNzllYWNhYTc5Yjg4ZTBmMGFhZGE3MDE5NWRlMzhiMzYzYjggMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5o dG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5o dG1sCkBAIC05LDE3ICs5LDI4IEBACiAgICAgICAgICAgICBmdW5jdGlvbiBkaXNwYXRjaFNjcm9s bEV2ZW50cygpCiAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5ldmVu dFNlbmRlciAmJiB3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOwogICAgICAgICAgICAg ICAgICAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbygxMDAsIDEwMCk7CiAgICAgICAgICAgICAg ICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoMCwgLTEpOwotICAgICAgICAgICAgICAg ICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAtMSk7Ci0gICAgICAgICAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgICAgICAg ICAgdmFyIHNjcm9sbENvdW50ID0gMDsKKyAgICAgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2R2JykuYWRkRXZlbnRMaXN0ZW5lcigKKyAgICAgICAgICAgICAgICAgICAg ICAgICdzY3JvbGwnLAorICAgICAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb24oZXZlbnQpIHsK KyAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0Q2hp bGQpCisgICAgICAgICAgICAgICAgICAgICAgICAgIHNjcm9sbENvdW50Kys7CisgICAgICAgICAg ICAgICAgICAgICAgICAgIGlmIChzY3JvbGxDb3VudCA9PSAxKQorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgtMSwgLTEpOworICAgICAgICAg ICAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICAgICAgICAgICAgICB9 LAorICAgICAgICAgICAgICAgICAgICAgICAgZmFsc2UpOwogICAgICAgICAgICAgICAgIH0KICAg ICAgICAgICAgIH0KICAgICAgICAgPC9zY3JpcHQ+CiAgICAgPC9oZWFkPgogICAgIDxib2R5IG9u bG9hZD0ic2V0VGltZW91dCgnZGlzcGF0Y2hTY3JvbGxFdmVudHMoKTsnLCAxKTsiPgogICAgICAg ICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBjaGlsZHJlbiBjYW4gYmUgcmVtb3ZlZCBieSB0aGVp ciBwYXJlbnQgZWxlbWVudCdzIG9uc2Nyb2xsIGV2ZW50IGhhbmRsZXIuICBUaGUgdGVzdCBzdWNj ZWVkcyBpZiB0aGlzIGlzIHRoZSBvbmx5IHRleHQgcmVtYWluaW5nIGFmdGVyIHRoZSB0d28gc2Ny b2xsIGV2ZW50cyBhcmUgZGlzcGF0Y2hlZC4gIFRoZSB0ZXN0IGZhaWxzIGlmIHRoZSBpbm5lciBk aXYgcmVtYWlucyBpbiB0aGUgb3V0cHV0IG9yIGlmIFdlYktpdCBjcmFzaGVzLjxicj48YnI+Ci0g ICAgICAgIDxkaXYgaWQ9ImR2IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsg aGVpZ2h0OiAyMDBweDsgd2hpdGVzcGFjZTogbm93cmFwOyIgb25zY3JvbGw9InRoaXMucmVtb3Zl Q2hpbGQodGhpcy5maXJzdENoaWxkKSI+CisgICAgICAgIDxkaXYgaWQ9ImR2IiBzdHlsZT0ib3Zl cmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAyMDBweDsgd2hpdGVzcGFjZTogbm93 cmFwOyI+CiAgICAgICAgIDxkaXYgc3R5bGU9IndpZHRoOjMwMHB4OyBoZWlnaHQ6MzAwcHgiPkxv cmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBz ZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25h IGFsaXF1YS4gVXQgZW5pbSBhZCBtaW5pbSB2ZW5pYW0sIHF1aXMgbm9zdHJ1ZCBleGVyY2l0YXRp b24gdWxsYW1jbyBsYWJvcmlzIG5pc2kgdXQgYWxpcXVpcCBleCBlYSBjb21tb2RvIGNvbnNlcXVh dC4gRHVpcyBhdXRlIGlydXJlIGRvbG9yIGluIHJlcHJlaGVuZGVyaXQgaW4gdm9sdXB0YXRlIHZl bGl0IGVzc2UgY2lsbHVtIGRvbG9yZSBldSBmdWdpYXQgbnVsbGEgcGFyaWF0dXIuIEV4Y2VwdGV1 ciBzaW50IG9jY2FlY2F0IGN1cGlkYXRhdCBub24gcHJvaWRlbnQsIHN1bnQgaW4gY3VscGEgcXVp IG9mZmljaWEgZGVzZXJ1bnQgbW9sbGl0IGFuaW0gaWQgZXN0IGxhYm9ydW0KICAgICAgICAgPC9k aXY+CiAgICAgICAgIDwvZGl2PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv c2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv c2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sCmluZGV4IDRmYzE1Mjg0ZGVmMWY1OGQ5Mzcz NWZhY2FkZTRhNTZkNzEwZDUxZmUuLmFlMTJhNzllNTNiZjY4NDBmODI1MzNhY2IwNDQyYTkyY2U3 MjcxZmYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmct em9vbS1jaGFuZ2UuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVy aW5nLXpvb20tY2hhbmdlLmh0bWwKQEAgLTE2LDYgKzE2LDkgQEAKICAgICBmdW5jdGlvbiBzY3Jv bGxlZChldmVudCkKICAgICB7CiAgICAgICAgIGV2ZW50LnRhcmdldC5wYXJlbnROb2RlLnJlbW92 ZUNoaWxkKGV2ZW50LnRhcmdldCk7CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsK KyAgICAgICAgfQogICAgIH0KIAogICAgIGZ1bmN0aW9uIHRlc3QoKQpAQCAtMjcsNyArMzAsOSBA QAogICAgICAgICBkb2N1bWVudC5ib2R5LnN0eWxlLnpvb20gPSAyOwogICAgIH0KIAotICAgIGlm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7 CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICB9CiAg ICAgdGVzdCgpOwogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50 cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwKaW5kZXggMjIyYWRhODA1ZGE1 MzA2MjJlNGY4MWY1YmRjZWYzYTcxYWMzNjAwMC4uMWU4NTExM2Y3NzQzM2RlOGFiZWU2ZjM2NzE1 MWU1MjAzZTJlZWQ0MCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xs LWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbApAQCAtMSwxMSArMSwyMiBAQAogPGh0 bWw+CiA8c2NyaXB0PgordmFyIHdpbmRvd1dhc1Njcm9sbGVkID0gZmFsc2U7Cit2YXIgZG9uZVRp bWVvdXQ7CisKIGZ1bmN0aW9uIHdpbmRvd1Njcm9sbGVkKCkgeworICAgIHdpbmRvd1dhc1Njcm9s bGVkID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJI VE1MID0gJ0ZBSUxVUkU6IHdpbmRvdy5vbnNjcm9sbCB3YXMgY2FsbGVkLic7IAorICAgIGNsZWFy VGltZW91dChkb25lVGltZW91dCk7ICAgIAogfQogCiBmdW5jdGlvbiBkaXZTY3JvbGxlZCgpIHsK LSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NF U1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2luZG93Lm9uc2Nyb2xsIHdhcyBub3Qu JzsgCisgICAgaWYgKCF3aW5kb3dXYXNTY3JvbGxlZCkKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdTVUNDRVNTOiBkaXYub25zY3JvbGwgd2Fz IGNhbGxlZCwgYnV0IHdpbmRvdy5vbnNjcm9sbCB3YXMgbm90Lic7IAorICAgIC8vIERvbid0IGNh bGwgbm90aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3Jv bGwgZXZlbnQgY29taW5nL2J1YmJsaW5nLgorICAgIGRvbmVUaW1lb3V0ID0gc2V0VGltZW91dChm dW5jdGlvbigpIHsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAg ICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfSwg MTAwKTsgICAgCiB9CiAKIGZ1bmN0aW9uIHJ1blRlc3QoKSB7CkBAIC0yNCwxMCArMzUsNiBAQCBm dW5jdGlvbiBydW5UZXN0KCkgewogICAgIAogICAgIC8vIERvbid0IHBvbGx1dGUgdGhlIHRlc3Qg cmVzdWx0IHdpdGggbm9uc2Vuc2UuCiAgICAgZGl2LmlubmVySFRNTCA9ICcnOwotICAgIAotICAg IGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIAotICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5ub3RpZnlEb25lKCk7Ci0gICAgCiB9CiAKIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uM2U5NGEzMGQ3ZDg3NjgxNjdmODlhNzRhNTVlNWNiOWYxNjNmYzRlYgotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFz ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGVzdHMgdGhhdCB3ZSBjYW4gbGlzdGVu IGZvciBzY3JvbGwgZXZlbnRzIG9uIHRoZSBkb2N1bWVudCBpbiBib3RoIHRoZSBjYXB0dXJlIGFu ZCBidWJibGUgcGhhc2VzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2Yg IlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworQm90aCBj YXB0dXJlIGFuZCBidWJibGUgcGhhc2UgbGlzdGVuZXJzIHdlcmUgaW52b2tlZC4KK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UuaHRtbCBiL0xheW91dFRl c3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJjYWNh ZWYzMGJhMDUyOGYwMGI2M2JmZDliOThmZmI1NmZiMjNhMmQKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UuaHRtbApAQCAtMCwwICsx LDQ1IEBACis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHkgc3R5bGU9Im1pbi1oZWlnaHQ6IDIwMDBweCI+ IAorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKwor PHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1Rlc3RzIHRoYXQg d2UgY2FuIGxpc3RlbiBmb3Igc2Nyb2xsIGV2ZW50cyBvbiB0aGUgZG9jdW1lbnQgaW4gYm90aCB0 aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBoYXNlcy4nKTsKKwordmFyIHRyaWdnZXJlZENhcHR1cmVM aXN0ZW5lciA9IGZhbHNlOwordmFyIHRyaWdnZXJlZEJ1YmJsZUxpc3RlbmVyID0gZmFsc2U7CisK K3dpbmRvdy5hZGRFdmVudExpc3RlbmVyKAorICAgICdzY3JvbGwnLAorICAgIGZ1bmN0aW9uKCkg eworICAgICAgICB0cmlnZ2VyZWRDYXB0dXJlTGlzdGVuZXIgPSB0cnVlOworICAgICAgICBjaGVj a0NvbXBsZXRlKCk7CisgICAgfSwKKyAgICB0cnVlKTsKKword2luZG93LmFkZEV2ZW50TGlzdGVu ZXIoCisgICAgJ3Njcm9sbCcsCisgICAgZnVuY3Rpb24oKSB7CisgICAgICAgIHRyaWdnZXJlZEJ1 YmJsZUxpc3RlbmVyID0gdHJ1ZTsKKyAgICAgICAgY2hlY2tDb21wbGV0ZSgpOworICAgIH0sCisg ICAgZmFsc2UpOworCitmdW5jdGlvbiBjaGVja0NvbXBsZXRlKCkKK3sKKyAgaWYgKHRyaWdnZXJl ZENhcHR1cmVMaXN0ZW5lciAmJiB0cmlnZ2VyZWRCdWJibGVMaXN0ZW5lcikgeworICAgICAgZGVi dWcoJ0JvdGggY2FwdHVyZSBhbmQgYnViYmxlIHBoYXNlIGxpc3RlbmVycyB3ZXJlIGludm9rZWQu Jyk7CisgICAgICBmaW5pc2hKU1Rlc3QoKTsKKyAgfQorfQorCit3aW5kb3cuc2Nyb2xsVG8oMjAw LCAyMDApOworCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKK3ZhciBqc1Rlc3RJc0Fz eW5jID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10 ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCmluZGV4 IGJhMWEzNTE2NGM1NmIyYzQxZWEzODBiZWE3NjNlN2U0YTFlNTlmOTguLmQyZjlhYzY0NWU3ZDYx YjQ1MDFiMWIyYjhmNTBmYjY2OTU3N2E1NjIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3Qv bGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwKQEAgLTExLDI5ICsxMSwz MyBAQAogPHA+CiAgICAgUmVzdWx0OiA8c3BhbiBpZD0icmVzdWx0Ij50ZXN0IGRpZCBub3QgY29t cGxldGUuPC9zcGFuPgogPC9wPgotPGRpdiBpZD0idCIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3 aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0iaWYgKG92ZXJmbG93UmVtb3Zl KSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7Ij4KKzxkaXYgaWQ9InQiIHN0eWxl PSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9 InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTtoYW5kbGVTY3JvbGwoMCk7Ij4KICAg ICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+PC9kaXY+CiA8L2Rpdj4KIAotPGRpdiBzdHls ZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xs PSJpZiAoc2Vjb25kT3ZlcmZsb3dSZW1vdmUpIHRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0 aGlzKTsiPgorPGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0 OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7aGFu ZGxlU2Nyb2xsKDEpOyI+CiAgICAgPGRpdiBzdHlsZT0iaGVpZ2h0OiAyMDBweDsiPjwvZGl2Pgog ICAgIDxkaXYgaWQ9ImQiPjwvZGl2PgogPC9kaXY+CiAKIDxzY3JpcHQ+Ci0gICAgdmFyIG92ZXJm bG93UmVtb3ZlID0gZmFsc2U7Ci0gICAgdmFyIHNlY29uZE92ZXJmbG93UmVtb3ZlID0gZmFsc2U7 CisgICAgdmFyIHNjcm9sbGVkRmlyc3RDb250YWluZXIgPSBmYWxzZTsKKyAgICB2YXIgc2Nyb2xs ZWRTZWNvbmRDb250YWluZXIgPSBmYWxzZTsKIAogICAgIGRvY3VtZW50LmJvZHkub2Zmc2V0VG9w OyB0LnNjcm9sbFRvcCA9IDIwOwogCi0gICAgb3ZlcmZsb3dSZW1vdmUgPSB0cnVlOwotICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCd0JykuaW5uZXJIVE1MID0gJyc7Ci0KLSAgICBzZWNvbmRP dmVyZmxvd1JlbW92ZSA9IHRydWU7CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2QnKS5z Y3JvbGxJbnRvVmlldygpOwogICAgIAotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1 bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7Ci0KLSAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cisg ICAgZnVuY3Rpb24gaGFuZGxlU2Nyb2xsKGluZGV4KQorICAgIHsKKyAgICAgICAgaWYgKGluZGV4 ID09IDApIHNjcm9sbGVkRmlyc3RDb250YWluZXIgPSB0cnVlOworICAgICAgICBlbHNlIGlmIChp bmRleCA9PSAxKSBzY3JvbGxlZFNlY29uZENvbnRhaW5lciA9IHRydWU7CisgICAgICAgIAorICAg ICAgICBpZiAoc2Nyb2xsZWRGaXJzdENvbnRhaW5lciAmJiBzY3JvbGxlZFNlY29uZENvbnRhaW5l cikgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVy VGV4dCA9ICJTVUNDRVNTIjsKKyAgICAgICAgCisgICAgICAgICAgICBpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5v dGlmeURvbmUoKTsKKyAgICAgICAgfQorICAgIH0KIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNjcm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwg Yi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbAppbmRleCA2NGIyMGFjNGFlZmRjZDU2MTRkMmM0OGMwM2U2Y2QyYTMyMmJkNGRlLi4zNTc0 MTJmZTIzZmI2NmM1ZGVjMWRhMDU4YWVhNzUyYmUzNjEwNzhiIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbApAQCAtMSwxNCArMSwxNiBAQAogPGhlYWQ+CiA8c2NyaXB0PgogZnVuY3Rpb24gdGVzdCgp IHsKLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVt cEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7 CisgICAgfQogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJpdCIpLnNjcm9sbFRvcCA9IDEw MDsKIH0KIDwvc2NyaXB0PgogPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgogPHA+VGhpcyB0ZXN0IGlu dm9sdmVzIGEgbGF5ZXIgdGhhdCBzZWxmLWRlc3RydWN0cyB3aGVuIHNjcm9sbGVkLiBJZiB0aGVy ZSdzIG5vIGNyYXNoLCB0aGVuIHRoZSB0ZXN0IHN1Y2NlZWRlZC48L3A+Ci08ZGl2IGlkPSJpdCIg c3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlz cGxheSA9ICdub25lJyI+Cis8ZGl2IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZs b3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlzcGxheSA9ICdub25lJztpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ij4K IDxkaXYgc3R5bGU9ImhlaWdodDogMjAwMHB4OyI+PC9kaXY+CiA8L2Rpdj4KIDwvYm9keT4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRt bAppbmRleCBlM2YwYWM0NGMxOWJjYTVkYmRlMTRkMTM4NzNhMGNkNWYwZWU3MjBjLi5kYzY5NzEy MjE2ZjdiNTE2NjBhZTMyMjRiMmNlZWFlNDYxYjE0NGFhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sCkBAIC0zLDYgKzMsOCBA QAogICAgIDxzY3JpcHQ+CiAgICAgICAgIGZ1bmN0aW9uIHJlcGFpbnRUZXN0KCkKICAgICAgICAg eworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAg ICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAg ICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAg ICAgICAgc2Nyb2xsQnkoMCwgMTAwKTsKICAgICAgICAgfQpAQCAtMTEsNiArMTMsOCBAQAogICAg ICAgICB7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InRhcmdldCIpOwogICAgICAgICAgICAgdGFyZ2V0LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICJn cmVlbiI7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAg ICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKICAgICAgICAg fQogICAgIDwvc2NyaXB0PgogPC9oZWFkPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9BbmRyb2lkLm1r IGIvV2ViQ29yZS9BbmRyb2lkLm1rCmluZGV4IGI2NGUzMmI2ZDg1ZjRhYzYyZjc1MmMwMjNiN2E3 ZWUxY2EwNmE0NDQuLmNhMDc0ZWNkZmVkZGFiZWRkNzRhMGM0MDU5Y2Q5NWNjYzJjOGZiMTkgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvQW5kcm9pZC5taworKysgYi9XZWJDb3JlL0FuZHJvaWQubWsKQEAg LTEzNSw2ICsxMzUsNyBAQCBMT0NBTF9TUkNfRklMRVMgOj0gJChMT0NBTF9TUkNfRklMRVMpIFwK IAlkb20vRXZlbnRDb250ZXh0LmNwcCBcCiAJZG9tL0V2ZW50TmFtZXMuY3BwIFwKIAlkb20vRXZl bnRUYXJnZXQuY3BwIFwKKwlkb20vRXZlbnRRdWV1ZS5jcHAgXAogCWRvbS9FeGNlcHRpb25CYXNl LmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkNvZGUuY3BwIFwKIAlkb20vSW5wdXRFbGVtZW50LmNwcCBc CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0IGIvV2ViQ29yZS9DTWFrZUxpc3Rz LnR4dAppbmRleCA5MzE3Njg3ZGRiZmIwODJhNjQ0ZDVhZjNjMDA5ZTg1NWU4ZjNlYjEyLi5mYTI2 ZDQ4OGQ4MGYxMjRhYTRhYTNmMTI5NGNjNzk4NTZjZWI0MTg5IDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NNYWtlTGlzdHMudHh0CisrKyBiL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKQEAgLTgyNiw2ICs4 MjYsNyBAQCBTRVQoV2ViQ29yZV9TT1VSQ0VTCiAgICAgZG9tL0V2ZW50Q29udGV4dC5jcHAKICAg ICBkb20vRXZlbnROYW1lcy5jcHAKICAgICBkb20vRXZlbnRUYXJnZXQuY3BwCisgICAgZG9tL0V2 ZW50UXVldWUuY3BwCiAgICAgZG9tL0V4Y2VwdGlvbkJhc2UuY3BwCiAgICAgZG9tL0V4Y2VwdGlv bkNvZGUuY3BwCiAgICAgZG9tL0lucHV0RWxlbWVudC5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWRkM2VjNmUyMmU3OGE2MmM1ZmYy YjQ4ZWZlMmFlMGEyNGMyNTY1Zi4uZTYwNTlkY2ViZTc4NWI3ZTUzMmFkNjQwYjE1N2IzZTkzNDAy OGIxNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VM b2cKQEAgLTEsMyArMSw0OCBAQAorMjAxMC0xMS0xNSAgTWloYWkgUGFycGFyaXRhICA8bWloYWlw QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBTY3JvbGwgZXZlbnQgc2hvdWxkIGJlIGZpcmVkIGFzeW5jaHJvbm91c2x5CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTYzMQorCisgICAg ICAgIFRlc3RzOiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCisgICAgICAgICAg ICAgICBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS5odG1sCisKKyAgICAgICAgTWFr ZXMgc2Nyb2xsIGV2ZW50cyBmaXJlIGFzeW5jaHJvbm91c2x5IHRvIGJlIGluIGNvbXBsaWFuY2Ug d2l0aCB0aGUKKyAgICAgICAgQ1NTT00gVmlldyBNb2R1bGUgYW5kIGNvbnNpc3RlbnQgd2l0aCBH ZWNrbywgT3BlcmEgYW5kICh0byBzb21lIGRlZ3JlZSkKKyAgICAgICAgSUUuCisKKyAgICAgICAg VGhpcyBpcyBhY2NvbXBsaXNoZWQgYnkgbW92aW5nIHRoZSBEb2N1bWVudDo6ZW5xdWV1ZUV2ZW50 IGFuZCBzdXBwb3J0aW5nCisgICAgICAgIGNvZGUgdG8gYSBzdGFuZGFsb25lIEV2ZW50UXVldWUg Y2xhc3MuIEFkZGl0aW9uYWxseSwgdGhlcmUgaXMgbm93IGFuCisgICAgICAgIGVucXVldWVTY3Jv bGxFdmVudCBtZXRob2QgdGhhdCBoYW5kbGVzIHNjcm9sbCBldmVudC1zcGVjaWZpYyBiZWhhdmlv cgorICAgICAgICAoZG9uJ3QgZW5xdWV1ZSBhbm90aGVyIGV2ZW50IGlmIHRoZXJlJ3MgYWxyZWFk eSBvbmUgZW5xdWV1ZWQgZm9yIHRoZQorICAgICAgICBlbGVtZW50KS4KKyAgICAgICAgCisgICAg ICAgICogQW5kcm9pZC5tazoKKyAgICAgICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAgICAgICAgKiBH TlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogV2ViQ29y ZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2o6CisgICAgICAg ICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGRvbS9Eb2N1 bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmVucXVldWVFdmVudCk6CisgICAgICAgICogZG9tL0RvY3Vt ZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZXZlbnRRdWV1ZSk6CisgICAgICAg ICogZG9tL0V2ZW50UXVldWUuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBkb20vRXZlbnRRdWV1ZS5o OiBBZGRlZC4KKyAgICAgICAgKiBkb20vTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb2Rl OjplbnF1ZXVlU2Nyb2xsRXZlbnQpOgorICAgICAgICAqIGRvbS9Ob2RlLmg6CisgICAgICAgICog cGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpz ZW5kU2Nyb2xsRXZlbnQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6c2Nyb2xsVG9PZmZzZXQpOgorICAgICAgICAq IHJlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckxp c3RCb3g6OnZhbHVlQ2hhbmdlZCk6CisKIDIwMTAtMTEtMTIgIEplciBOb2JsZSAgPGplci5ub2Js ZUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQnJhZHkgRWlkc29uLgpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5k ZXggYzg3MTRiYjE3NDYyOWU0ZTQ0YmFkY2EyOGVhYTBjNjFiNDQ2YzVkNi4uNTU0NjA2NGU3ZTM3 ZjM4YTRjZjljZTk3M2FjM2RhZGYzMzg0ODQ0OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xMTQ0LDYgKzExNDQsOCBA QCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZG9tL0V2ZW50TmFtZXMuaCBcCiAJV2Vi Q29yZS9kb20vRXZlbnRUYXJnZXQuY3BwIFwKIAlXZWJDb3JlL2RvbS9FdmVudFRhcmdldC5oIFwK KwlXZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBcCisJV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5o IFwKIAlXZWJDb3JlL2RvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAJV2ViQ29yZS9kb20vRXhjZXB0 aW9uQmFzZS5oIFwKIAlXZWJDb3JlL2RvbS9FeGNlcHRpb25Db2RlLmNwcCBcCmRpZmYgLS1naXQg YS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDc1NDU1 ZWQ3MjI0MTg0NThjMTY3NjY1NTQ3NGVhM2M3N2E1YWUxMDQuLjVhNGZjMzg0MDNkOTI1OTMzNzMx YWQ3NGIyMzE4MzE1ZDdhYTE5NzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisr KyBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMjEwLDYgKzEyMTAsOCBAQAogICAgICAgICAg ICAgJ2RvbS9FdmVudE5hbWVzLmgnLAogICAgICAgICAgICAgJ2RvbS9FdmVudFRhcmdldC5jcHAn LAogICAgICAgICAgICAgJ2RvbS9FdmVudFRhcmdldC5oJywKKyAgICAgICAgICAgICdkb20vRXZl bnRRdWV1ZS5jcHAnLAorICAgICAgICAgICAgJ2RvbS9FdmVudFF1ZXVlLmgnLAogICAgICAgICAg ICAgJ2RvbS9FeGNlcHRpb25CYXNlLmNwcCcsCiAgICAgICAgICAgICAnZG9tL0V4Y2VwdGlvbkJh c2UuaCcsCiAgICAgICAgICAgICAnZG9tL0V4Y2VwdGlvbkNvZGUuY3BwJywKZGlmZiAtLWdpdCBh L1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IDg0ZTJmMmU0 NjJmNmRjMDBhODRhZDM5MDYzZTM2YzIzYTQyMzlmZDQuLmRjMTZhMmVmZDc3NWNhYzYzYjFjNmEw ZWU4YTRkMWIwYTk5MDNjMzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIv V2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtNzE2LDYgKzcxNiw3IEBAIFNPVVJDRVMgKz0gXAogICAg IGRvbS9FdmVudENvbnRleHQuY3BwIFwKICAgICBkb20vRXZlbnROYW1lcy5jcHAgXAogICAgIGRv bS9FdmVudFRhcmdldC5jcHAgXAorICAgIGRvbS9FdmVudFF1ZXVlLmNwcCBcCiAgICAgZG9tL0V4 Y2VwdGlvbkJhc2UuY3BwIFwKICAgICBkb20vRXhjZXB0aW9uQ29kZS5jcHAgXAogICAgIGRvbS9J bnB1dEVsZW1lbnQuY3BwIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4 IDhmNTMyM2JlYTkyZmY4YjFiODUyMmI5NjVkY2M5MzkyNTE2ODhmMWYuLjc4OTI1MGFmM2U4OTQ4 ZDBhMmEwZjMzYjJkZmY1OTNmYmQ4MWJhMDcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3Jl LnZjcHJvagpAQCAtNDI1NjMsNiArNDI1NjMsNjIgQEAKIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRv bVxFdmVudFRhcmdldC5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KKwkJICA8RmlsZQ0KKwkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXGRvbVxFdmVudFF1ZXVlLmNwcCINCisJCQkJPg0KKwkJCQk8RmlsZUNv bmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IkRlYnVnfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9t QnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21w aWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8Rmls ZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IlJlbGVhc2V8V2luMzIiDQorCQkJCQlFeGNsdWRl ZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkND TENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJ CTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfSW50ZXJuYWx8V2luMzIiDQor CQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJ CQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3Vy YXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfQ2Fpcm98 V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxU b29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmls ZUNvbmZpZ3VyYXRpb24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iUmVs ZWFzZV9DYWlyb3xXaW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJ Pg0KKwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4N CisJCQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJ CQlOYW1lPSJEZWJ1Z19BbGx8V2luMzIiDQorCQkJCQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSIN CisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJTmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJ CQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxl DQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZG9tXEV2ZW50UXVldWUuaCINCisJCQkJPg0KKwkJCTwv RmlsZT4NCiAJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRvbVxFeGNlcHRpb25CYXNl LmNwcCINCiAJCQkJPg0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oK aW5kZXggNzhhOWE5MDFmMmNjMTgyODY3NGM0YWUwM2ZmYzhhNGNmZWE3ZWQ3MS4uOTNjNDUxYzE5 NmUwNTljMDg5ZWUzMjM2MmE3MDYzN2EzYmEyNzQ1NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTI2NTQsNiArMjY1NCw4IEBACiAJCThBRjRFNTVDMTFE QzVBNjMwMDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEFGNEU1NTkxMURDNUE2MzAwMEVEM0RFIC8qIFBl cmZvcm1hbmNlVGltaW5nLmggKi87IH07CiAJCThDNkVBNjE5MTFFRjdFMDQwMEZEOEVFMyAvKiBS dW50aW1lRW5hYmxlZEZlYXR1cmVzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDhDNkVBNjE3MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxl ZEZlYXR1cmVzLmNwcCAqLzsgfTsKIAkJOEM2RUE2MUExMUVGN0UwNDAwRkQ4RUUzIC8qIFJ1bnRp bWVFbmFibGVkRmVhdHVyZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDhDNkVBNjE4MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1 cmVzLmggKi87IH07CisJCThGNjc1NjFCMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4RjY3NTYxOTEy ODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovOyB9OworCQk4RjY3NTYxQzEyODhCMTdC MDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA4RjY3NTYxQTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5j cHAgKi87IH07CiAJCThGQUM3NzREMTE5ODcyQ0IwMDE1QUU5NCAvKiBKU01haW5UaHJlYWRFeGVj U3RhdGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g OEY5MzREODQxMTg5RjFFRTAwNTA4RDVEIC8qIEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5jcHAgKi87 IH07CiAJCTkzMDJCMEJEMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTMwMkIwQkMwRDc5RjgyOTAw QzdFRTgzIC8qIFBhZ2VHcm91cC5jcHAgKi87IH07CiAJCTkzMDJCMEJGMEQ3OUY4MkMwMEM3RUU4 MyAvKiBQYWdlR3JvdXAuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzMDJCMEJFMEQ3OUY4MkMwMEM3RUU4MyAvKiBQYWdlR3JvdXAuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtODc4Myw2ICs4Nzg1LDgg QEAKIAkJOEFGNEU1NUExMURDNUE2MzAwMEVEM0RFIC8qIFBlcmZvcm1hbmNlVGltaW5nLmlkbCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQ7IHBhdGggPSBQZXJmb3JtYW5jZVRpbWluZy5pZGw7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCThDNkVBNjE3MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5h YmxlZEZlYXR1cmVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgbmFtZSA9IFJ1 bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwOyBwYXRoID0gZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEM2RUE2MTgxMUVGN0Uw NDAwRkQ4RUUzIC8qIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBuYW1lID0gUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oOyBwYXRoID0gZ2VuZXJpYy9S dW50aW1lRW5hYmxlZEZlYXR1cmVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCThG Njc1NjE5MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IEV2ZW50UXVldWUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK KwkJOEY2NzU2MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRXZlbnRRdWV1ZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCThGOTM0RDgzMTE4OUYxRUUwMDUwOEQ1RCAvKiBKU01haW5UaHJlYWRF eGVjU3RhdGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNNYWluVGhyZWFk RXhlY1N0YXRlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThGOTM0RDg0MTE4OUYx RUUwMDUwOEQ1RCAvKiBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTMwMkIwQkMwRDc5RjgyOTAwQzdFRTgzIC8qIFBhZ2VHcm91 cC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQYWdlR3JvdXAuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTg0NDUsNiArMTg0NDksOCBAQAogCQkJ CTU0QzUwRjdBMEU4MDFERjMwMDk4MzJBMCAvKiBYTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3Bw ICovLAogCQkJCTVEMTVFM0E5MEY5RTZBQzEwMDlFMEUzRiAvKiBYTUxEb2N1bWVudFBhcnNlclNj b3BlLmNwcCAqLywKIAkJCQk1RDE1RTNBQTBGOUU2QUMxMDA5RTBFM0YgLyogWE1MRG9jdW1lbnRQ YXJzZXJTY29wZS5oICovLAorCQkJCThGNjc1NjE5MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1 ZXVlLmggKi8sCisJCQkJOEY2NzU2MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3Bw ICovLAogCQkJKTsKIAkJCXBhdGggPSBkb207CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpA QCAtMjEzODMsNiArMjEzODksNyBAQAogCQkJCTQ5OUIzQzU5MTI4QzY0MUUwMEU3MjZDMiAvKiBH cmFwaGljc0xheWVyTWFjLmggaW4gSGVhZGVycyAqLywKIAkJCQkwODI1MDkzOTEyOEJENEQ4MDBF MkVEOEUgLyogU1ZHQW5pbWF0ZWRUcmFuc2Zvcm1MaXN0LmggaW4gSGVhZGVycyAqLywKIAkJCQkz ODg4RjZFRjEyOEM5ODg5MDAwQ0E4RTAgLyogSW5zcGVjdG9yRmlsZVN5c3RlbUFnZW50LmggaW4g SGVhZGVycyAqLywKKwkJCQk4RjY3NTYxQjEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5o IGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vz c2luZyA9IDA7CiAJCX07CkBAIC0yMzk1Niw2ICsyMzk2Myw3IEBACiAJCQkJOTdERDREODYwRkRG NEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNDk5QjND NUExMjhDNjQxRTAwRTcyNkMyIC8qIEdyYXBoaWNzTGF5ZXJNYWMubW0gaW4gU291cmNlcyAqLywK IAkJCQkzODg4RjZFRTEyOEM5ODg5MDAwQ0E4RTAgLyogSW5zcGVjdG9yRmlsZVN5c3RlbUFnZW50 LmNwcCBpbiBTb3VyY2VzICovLAorCQkJCThGNjc1NjFDMTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVu dFF1ZXVlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50 UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IDRjMzQyNWE3M2RmZDhiZmI4 ZDUwNWMwODkzNDJlZDg1OTZlMmQ4MzMuLmY4MTgwZmI4ZDQyYTgwNDIxZGYwMWI2NjY1NzY0ODEx YjI5Y2Y2MTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9XZWJD b3JlL2RvbS9Eb2N1bWVudC5jcHAKQEAgLTU4LDYgKzU4LDcgQEAKICNpbmNsdWRlICJFdmVudEhh bmRsZXIuaCIKICNpbmNsdWRlICJFdmVudExpc3RlbmVyLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1l cy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgi CiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKQEAgLTM5 OSw3ICs0MDAsNyBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBjb25zdCBLVVJM JiB1cmwsIGJvb2wgaXNYSFRNTCwgYm9vbCBpc0hUTUwsIGNvbgogICAgICwgbV9ub3JtYWxXb3Js ZFdyYXBwZXJDYWNoZSgwKQogI2VuZGlmCiAgICAgLCBtX3VzaW5nR2VvbG9jYXRpb24oZmFsc2Up Ci0gICAgLCBtX3BlbmRpbmdFdmVudFRpbWVyKHRoaXMsICZEb2N1bWVudDo6cGVuZGluZ0V2ZW50 VGltZXJGaXJlZCkKKyAgICAsIG1fZXZlbnRRdWV1ZShhZG9wdFB0cihuZXcgRXZlbnRRdWV1ZSkp CiAjaWYgRU5BQkxFKFdNTCkKICAgICAsIG1fY29udGFpbnNXTUxDb250ZW50KGZhbHNlKQogI2Vu ZGlmCkBAIC0zNDM5LDIxICszNDQwLDggQEAgdm9pZCBEb2N1bWVudDo6ZGlzcGF0Y2hXaW5kb3dM b2FkRXZlbnQoKQogCiB2b2lkIERvY3VtZW50OjplbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVu dD4gZXZlbnQpCiB7Ci0gICAgbV9wZW5kaW5nRXZlbnRRdWV1ZS5hcHBlbmQoZXZlbnQpOwotICAg IGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKQotICAgICAgICBtX3BlbmRpbmdF dmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBEb2N1bWVudDo6cGVuZGluZ0V2 ZW50VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQotewotICAgIEFTU0VSVCghbV9wZW5kaW5n RXZlbnRUaW1lci5pc0FjdGl2ZSgpKTsKLSAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IGV2ZW50 UXVldWU7Ci0gICAgZXZlbnRRdWV1ZS5zd2FwKG1fcGVuZGluZ0V2ZW50UXVldWUpOwotCi0gICAg dHlwZWRlZiBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+Ojpjb25zdF9pdGVyYXRvciBJdGVyYXRvcjsK LSAgICBJdGVyYXRvciBlbmQgPSBldmVudFF1ZXVlLmVuZCgpOwotICAgIGZvciAoSXRlcmF0b3Ig aXQgPSBldmVudFF1ZXVlLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKLSAgICAgICAgZGlzcGF0 Y2hXaW5kb3dFdmVudCgqaXQpOworICAgIGV2ZW50LT5zZXRUYXJnZXQodGhpcyk7CisgICAgbV9l dmVudFF1ZXVlLT5lbnF1ZXVlRXZlbnQoZXZlbnQpOwogfQogCiBQYXNzUmVmUHRyPEV2ZW50PiBE b2N1bWVudDo6Y3JlYXRlRXZlbnQoY29uc3QgU3RyaW5nJiBldmVudFR5cGUsIEV4Y2VwdGlvbkNv ZGUmIGVjKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1dlYkNvcmUvZG9t L0RvY3VtZW50LmgKaW5kZXggYmE0OGQ2ZjgyZWNiNDA4YmRiZDE0N2Y2MjNlOWU2YzljYmYyMjE2 OS4uYmY2MzIyNWQ4NDkyZmNiYzFiMjM1YTgxZjU3YTNmNjc4NDI5MGI1ZCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9kb20vRG9jdW1lbnQuaAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCkBAIC03 NSw2ICs3NSw3IEBAIGNsYXNzIEVsZW1lbnQ7CiBjbGFzcyBFbnRpdHlSZWZlcmVuY2U7CiBjbGFz cyBFdmVudDsKIGNsYXNzIEV2ZW50TGlzdGVuZXI7CitjbGFzcyBFdmVudFF1ZXVlOwogY2xhc3Mg RnJhbWU7CiBjbGFzcyBGcmFtZVZpZXc7CiBjbGFzcyBIVE1MQ2FudmFzRWxlbWVudDsKQEAgLTEw MjAsNiArMTAyMSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGVucXVldWVQYWdlc2hvd0V2ZW50KFBh Z2VzaG93RXZlbnRQZXJzaXN0ZW5jZSk7CiAgICAgdm9pZCBlbnF1ZXVlSGFzaGNoYW5nZUV2ZW50 KGNvbnN0IFN0cmluZyYgb2xkVVJMLCBjb25zdCBTdHJpbmcmIG5ld1VSTCk7CiAgICAgdm9pZCBl bnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gc3Rh dGVPYmplY3QpOworICAgIEV2ZW50UXVldWUqIGV2ZW50UXVldWUoKSBjb25zdCB7IHJldHVybiBt X2V2ZW50UXVldWUuZ2V0KCk7IH0KIAogICAgIHZvaWQgYWRkTWVkaWFDYW5TdGFydExpc3RlbmVy KE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwogICAgIHZvaWQgcmVtb3ZlTWVkaWFDYW5TdGFydExp c3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwpAQCAtMTExNiw4ICsxMTE4LDYgQEAgcHJp dmF0ZToKIAogICAgIHZvaWQgY3JlYXRlU3R5bGVTZWxlY3RvcigpOwogCi0gICAgdm9pZCBwZW5k aW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopOwotCiAgICAgUGFzc1JlZlB0cjxO b2RlTGlzdD4gaGFuZGxlWmVyb1BhZGRpbmcoY29uc3QgSGl0VGVzdFJlcXVlc3QmLCBIaXRUZXN0 UmVzdWx0JikgY29uc3Q7CiAKICAgICB2b2lkIGxvYWRFdmVudERlbGF5VGltZXJGaXJlZChUaW1l cjxEb2N1bWVudD4qKTsKQEAgLTEzMzksOSArMTMzOSw4IEBAIHByaXZhdGU6CiAjZW5kaWYKIAog ICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwotCi0gICAgVGltZXI8RG9jdW1lbnQ+IG1fcGVu ZGluZ0V2ZW50VGltZXI7Ci0gICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3BlbmRpbmdFdmVu dFF1ZXVlOworICAgIAorICAgIE93blB0cjxFdmVudFF1ZXVlPiBtX2V2ZW50UXVldWU7CiAKICNp ZiBFTkFCTEUoV01MKQogICAgIGJvb2wgbV9jb250YWluc1dNTENvbnRlbnQ7CmRpZmYgLS1naXQg YS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjcxNzUyMzMwNWZiMTE2ZGY0ZGRiNDA2ZTU0MjNiZTllMDJiMGE4NmMKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcApAQCAtMCwwICsxLDg2 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRXZlbnRR dWV1ZS5oIgorCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJFdmVudC5oIgorI2lu Y2x1ZGUgIkV2ZW50TmFtZXMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitFdmVudFF1ZXVl OjpFdmVudFF1ZXVlKCkKKyAgICA6IG1fcGVuZGluZ0V2ZW50VGltZXIodGhpcywgJkV2ZW50UXVl dWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCit7Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5x dWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQoreworICAgIEFTU0VSVChldmVudC0+ dGFyZ2V0KCktPnRvTm9kZSgpKTsKKyAgICBtX3F1ZXVlZEV2ZW50cy5hcHBlbmQoZXZlbnQpOwor ICAgIAorICAgIGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBt X3BlbmRpbmdFdmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBFdmVudFF1ZXVl OjplbnF1ZXVlU2Nyb2xsRXZlbnQoUGFzc1JlZlB0cjxOb2RlPiB0YXJnZXQpCit7CisgICAgaWYg KCFtX25vZGVzV2l0aFF1ZXVlZFNjcm9sbEV2ZW50cy5hZGQodGFyZ2V0LmdldCgpKS5zZWNvbmQp CisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxFdmVudD4gc2Nyb2xsRXZlbnQgPSBFdmVu dDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UgLyogZG9lc24ndCBidWJi bGUgKi8sIGZhbHNlIC8qIG5vbiBjYW5jZWxsZWFibGUgKi8pOworICAgIHNjcm9sbEV2ZW50LT5z ZXRUYXJnZXQodGFyZ2V0KTsKKyAgICBlbnF1ZXVlRXZlbnQoc2Nyb2xsRXZlbnQucmVsZWFzZSgp KTsKK30KKwordm9pZCBFdmVudFF1ZXVlOjpwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPEV2 ZW50UXVldWU+KikKK3sKKyAgICBBU1NFUlQoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUo KSk7CisKKyAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IHF1ZXVlZEV2ZW50czsKKyAgICBxdWV1 ZWRFdmVudHMuc3dhcChtX3F1ZXVlZEV2ZW50cyk7CisKKyAgICBtX25vZGVzV2l0aFF1ZXVlZFNj cm9sbEV2ZW50cy5jbGVhcigpOworICAgIAorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcXVl dWVkRXZlbnRzLnNpemUoKTsgaSsrKQorICAgICAgICBkaXNwYXRjaEV2ZW50KHF1ZXVlZEV2ZW50 c1tpXS5yZWxlYXNlKCkpOworfQorCit2b2lkIEV2ZW50UXVldWU6OmRpc3BhdGNoRXZlbnQoUGFz c1JlZlB0cjxFdmVudD4gZXZlbnQpCit7CisgICAgTm9kZSogZXZlbnRUYXJnZXQgPSBldmVudC0+ dGFyZ2V0KCktPnRvTm9kZSgpOworICAgIAorICAgIGlmICghZXZlbnRUYXJnZXQtPmluRG9jdW1l bnQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKGV2ZW50VGFyZ2V0LT5pc0RvY3VtZW50 Tm9kZSgpKQorICAgICAgICBldmVudFRhcmdldC0+ZG9jdW1lbnQoKS0+ZGlzcGF0Y2hXaW5kb3dF dmVudChldmVudCk7CisgICAgZWxzZQorICAgICAgICBldmVudFRhcmdldC0+ZGlzcGF0Y2hFdmVu dChldmVudCk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaCBi L1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44M2FiMTMwYWVlNzI0NDY4OGEw MTYzN2RhMzhjMjBlYTIxMDJiOTg0Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9kb20vRXZl bnRRdWV1ZS5oCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29v Z2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5Z CisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAg SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKgorICovCisKKyNpZm5kZWYgRXZlbnRR dWV1ZV9oCisjZGVmaW5lIEV2ZW50UXVldWVfaAorCisjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNs dWRlIDx3dGYvSGFzaFNldC5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgRXZlbnQ7CitjbGFz cyBOb2RlOworCitjbGFzcyBFdmVudFF1ZXVlIHsKK3B1YmxpYzoKKyAgICBFdmVudFF1ZXVlKCk7 CisKKyAgICB2b2lkIGVucXVldWVFdmVudChQYXNzUmVmUHRyPEV2ZW50Pik7CisgICAgdm9pZCBl bnF1ZXVlU2Nyb2xsRXZlbnQoUGFzc1JlZlB0cjxOb2RlPik7CisKK3ByaXZhdGU6CisgICAgdm9p ZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPEV2ZW50UXVldWU+Kik7CisgICAgdm9pZCBk aXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+KTsKKworICAgIFRpbWVyPEV2ZW50UXVldWU+ IG1fcGVuZGluZ0V2ZW50VGltZXI7CisgICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3F1ZXVl ZEV2ZW50czsKKyAgICBIYXNoU2V0PE5vZGUqPiBtX25vZGVzV2l0aFF1ZXVlZFNjcm9sbEV2ZW50 czsKK307CisKK30KKworI2VuZGlmIC8vIEV2ZW50UXVldWVfaApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9kb20vTm9kZS5jcHAgYi9XZWJDb3JlL2RvbS9Ob2RlLmNwcAppbmRleCBlNzFjNGJkZmUwOWYx NzdiM2U2NWRlZmViNGI3OTU2MzM5NjE0NzdiLi4wMDViMGVlYjNjNWExYTlmODVkOGNiN2UwZGJm OWM4ZTMxN2U0NGUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAorKysgYi9XZWJD b3JlL2RvbS9Ob2RlLmNwcApAQCAtNTAsNiArNTAsNyBAQAogI2luY2x1ZGUgIkV2ZW50SGFuZGxl ci5oIgogI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCIKICNpbmNsdWRlICJFdmVudE5hbWVzLmgi CisjaW5jbHVkZSAiRXZlbnRRdWV1ZS5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNp bmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cAppbmRleCBmNmEyMzUzODE1ZjYxYWRiZDFkYzQxODEwMDVlMjVjYTA3NmJhYmExLi4xODg1NWY3 NzQzODc0ZDNjMDYzMDI1ZjU3NGQ1NDgxMDU0YzlmYTkyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApA QCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIkRyYWdDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAi RWRpdG9yLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUu aCIKICNpbmNsdWRlICJGbG9hdFBvaW50LmgiCiAjaW5jbHVkZSAiRmxvYXRSZWN0LmgiCiAjaW5j bHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCkBAIC0yNzU3LDcgKzI3NTgsNyBAQCB2b2lkIEV2ZW50 SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50KCkKIHsKICAgICBzZXRGcmFtZVdhc1Njcm9sbGVkQnlV c2VyKCk7CiAgICAgaWYgKG1fZnJhbWUtPnZpZXcoKSAmJiBtX2ZyYW1lLT5kb2N1bWVudCgpKQot ICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUo ZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCB0cnVlLCBmYWxzZSkpOworICAgICAgICBtX2ZyYW1l LT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChtX2ZyYW1lLT5k b2N1bWVudCgpKTsKIH0KIAogdm9pZCBFdmVudEhhbmRsZXI6OnNldEZyYW1lV2FzU2Nyb2xsZWRC eVVzZXIoKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwIGIv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCmluZGV4IDdiOTAwMGM2NTUzYTI0NjI1 YTAwYjY2NjYxYjg4NDNkMDI3NjFmOGIuLjc3NjAzMDdmMTg2YWFmNTFjZDE2MGYwODAyMGFjNWNk ZjZkNmU0YjkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAor KysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKQEAgLTUxLDcgKzUxLDcgQEAK ICNpbmNsdWRlICJDaHJvbWUuaCIKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkV2 ZW50SGFuZGxlci5oIgotI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1 ZXVlLmgiCiAjaW5jbHVkZSAiRmxvYXRQb2ludDNELmgiCiAjaW5jbHVkZSAiRmxvYXRSZWN0Lmgi CiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCkBAIC0xMzk3LDEwICsxMzk3LDcgQEAgdm9p ZCBSZW5kZXJMYXllcjo6c2Nyb2xsVG9PZmZzZXQoaW50IHgsIGludCB5LCBib29sIHVwZGF0ZVNj cm9sbGJhcnMsIGJvb2wgcmVwYWkKICAgICB9CiAKICAgICAvLyBTY2hlZHVsZSB0aGUgc2Nyb2xs IERPTSBldmVudC4KLSAgICBpZiAodmlldykgewotICAgICAgICBpZiAoRnJhbWVWaWV3KiBmcmFt ZVZpZXcgPSB2aWV3LT5mcmFtZVZpZXcoKSkKLSAgICAgICAgICAgIGZyYW1lVmlldy0+c2NoZWR1 bGVFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZh bHNlKSwgcmVuZGVyZXIoKS0+bm9kZSgpKTsKLSAgICB9CisgICAgcmVuZGVyZXIoKS0+bm9kZSgp LT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChyZW5kZXJlcigp LT5ub2RlKCkpOwogfQogCiB2b2lkIFJlbmRlckxheWVyOjpzY3JvbGxSZWN0VG9WaXNpYmxlKGNv bnN0IEludFJlY3QmIHJlY3QsIGJvb2wgc2Nyb2xsVG9BbmNob3IsIGNvbnN0IFNjcm9sbEFsaWdu bWVudCYgYWxpZ25YLCBjb25zdCBTY3JvbGxBbGlnbm1lbnQmIGFsaWduWSkKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyTGlzdEJveC5jcHAKaW5kZXggNTMyYzU1MTJkNzhiNDk1ZjcyZWYzMzliMGZmNmQ3OGY0 N2Q1MjRlMS4uNjRlZGM0NGRhNzE0NDhkYjVkMDI4MjNmMDllYWI2NjBkODA3N2E3NSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAKKysrIGIvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAKQEAgLTM2LDcgKzM2LDcgQEAKICNpbmNsdWRlICJD U1NTdHlsZVNlbGVjdG9yLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFdmVu dEhhbmRsZXIuaCIKLSNpbmNsdWRlICJFdmVudE5hbWVzLmgiCisjaW5jbHVkZSAiRXZlbnRRdWV1 ZS5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAj aW5jbHVkZSAiRnJhbWVWaWV3LmgiCkBAIC01NDAsNyArNTQwLDcgQEAgdm9pZCBSZW5kZXJMaXN0 Qm94Ojp2YWx1ZUNoYW5nZWQoU2Nyb2xsYmFyKikKICAgICBpZiAobmV3T2Zmc2V0ICE9IG1faW5k ZXhPZmZzZXQpIHsKICAgICAgICAgbV9pbmRleE9mZnNldCA9IG5ld09mZnNldDsKICAgICAgICAg cmVwYWludCgpOwotICAgICAgICBub2RlKCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0ZShl dmVudE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGZhbHNlLCBmYWxzZSkpOworICAgICAgICBub2RlKCkt PmRvY3VtZW50KCktPmV2ZW50UXVldWUoKS0+ZW5xdWV1ZVNjcm9sbEV2ZW50KG5vZGUoKSk7CiAg ICAgfQogfQogCg== 74018 2010-11-16 11:51:52 -0800 2010-11-16 12:55:08 -0800 Patch bug-45631-20101116115151.patch text/plain 46561 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4MjYzMzU1YzcxMzg0NmExOTcxZjFkZGFmNTE4YWE1NTIxNWFiYTkwLi4yYTk5MzY0 ZWE2NTE3MWNjZDhjZDFjMDA5MTMyM2ZjNDU2OGFkYjY5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuCisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93 bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAt ZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6IEFkZGVkLiBEb2VzIHRoZSBzYW1lCisg ICAgICAgICAgICB0ZXN0cyBhcyBmaXJlLXNjcm9sbC1ldmVudC5odG1sLCBidXQgb24gYW4gaW5k aXZpZHVhbCBlbGVtZW50IGluc3RlYWQKKyAgICAgICAgICAgIG9mIHRoZSB3aG9sZSBkb2N1bWVu dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQ6 CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbDogTm93IGV4cGxp Y2l0bHkgdGVzdHMgZm9yCisgICAgICAgICAgICBzeW5jaHJvbm91cyBiZWhhdmlvciB3aGVuIHNj cm9sbGluZyB0aGUgZG9jdW1lbnQsIGFuZCB0aGF0IHdlIGRvbid0CisgICAgICAgICAgICBmaXJl IHRoZSBldmVudCBtb3JlIHRoYW4gb25jZS4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9yZW1vdmUt Y2hpbGQtb25zY3JvbGwuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5n LXpvb20tY2hhbmdlLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sOiBBZGRlZC4gQ2hlY2tzIHRoYXQgd2UgY2FuIGxpc3RlbgorICAgICAg ICAgICAgZm9yIHNjcm9sbCBldmVudHMgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlLgorICAgICAgICAqIGZhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRt bDoKKyAgICAgICAgKiBmYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbDoKKyAgICAgICAgKiBmYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWw6 CisKIDIwMTAtMTEtMTYgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgVW5yZXZpZXdlZCBDaHJvbWl1bSBleHBlY3RhdGlvbnMgdXBkYXRlLgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxz LWV4cGVjdGVkLnR4dAppbmRleCAyNGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNk NjY0Li5iNWIwY2YwZjU0NmMyZTQxZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVk LnR4dAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxz LWV4cGVjdGVkLnR4dApAQCAtMSw0ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhp dHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNo b3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJl cyBEUlQgdG8gcGFzcy4KK1RoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBw YWdlIGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0 bHkgb25lIHNjcm9sbCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMg bm93LgogUEFTUwogKGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZj ODNiMTQ4MjNkMmVkNzBkYjMyNTAwODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEy MjdjMWM5Mzg2ZmQ5ZjQ5YjQ2YmEyNWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1s PgogPGhlYWQ+CiA8c2NyaXB0PgotaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgp OworfQogCi1mdW5jdGlvbiBzY3IoKQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1 bmN0aW9uKCkgewogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQg Kz0gJ3gnOworCisgICAgc3dpdGNoIChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAo d2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFn ZVVwJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAg c3RlcCsrOwogfQogCiBmdW5jdGlvbiBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVu dFNlbmRlcikKLSAgICAgICAgcmV0dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIo J3Njcm9sbCcsIHNjciwgZmFsc2UpOwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURv d24iKTsKLSAgICB2YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5l clRleHQ7Ci0gICAgaWYgKHRleHQgIT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBj b250YWluIHgsIG5vdCAiICsgdGV4dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VV cCIpOwotICAgIHZhciB0ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVy VGV4dDsKLSAgICBpZiAodGV4dCAhPSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBj b250YWluIHh4LCBub3QgIiArIHRleHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi cmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVy KQorICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+ CiA8L2hlYWQ+CiA8Ym9keSBvbmxvYWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5 bGU9InBvc2l0aW9uOmZpeGVkIj48L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhp dHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNo b3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJl cyBEUlQgdG8gcGFzcy48L2Rpdj4KKzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBh Z2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2Vu ZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVz cyB0aGUga2V5cyBub3cuPC9kaXY+CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2 IHN0eWxlPSJoZWlnaHQ6NTAwMDBweCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwv ZGl2PiAKIDxzY3JpcHQ+IApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmly ZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5j ZmU2YTU2ZjkwMmEwZGFmY2M1ZmU5MTc3ZTYyOTZkMTM4ZjY0YjMzCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSwxMSBAQAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBldmVudCBm aXJlcyBvbiBlbGVtZW50cyBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworCitTY3JvbGwgZXZlbnQgYnViYmxlczogZmFsc2UKK1BBU1Mg U2Nyb2xsIHBvc2l0aW9uOiAoMCwgMjAwKQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1 ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43Yzk4YmFkNTM0OWU3 Y2Q2ZGMxZTA2MWIyYWYyZWU4YjQ4YmNjNjRmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEs NTEgQEAKKzxodG1sPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10 ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgor PGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVy ZmxvdzogYXV0bzsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0i aGVpZ2h0OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPHNjcmlwdD4K K2Rlc2NyaXB0aW9uKCdDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIGVsZW1l bnRzIGFzeWNocm9ub3VzbHkgYW5kIG9ubHkgb25jZS4nKTsKKwordmFyIGV2ZW50Q291bnQgPSAw OwordmFyIGRvbmVUaW1lb3V0OworCitmdW5jdGlvbiBzY3JvbGxIYW5kbGVyKGV2ZW50KQorewor ICAgIGV2ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIGRl YnVnKCdTY3JvbGwgZXZlbnQgYnViYmxlczogJyArIGV2ZW50LmJ1YmJsZXMpOworICAgICAgICB2 YXIgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAg ICAgICB2YXIgc2Nyb2xsWCA9IGNvbnRhaW5lci5zY3JvbGxMZWZ0OworICAgICAgICB2YXIgc2Ny b2xsWSA9IGNvbnRhaW5lci5zY3JvbGxUb3A7CisgICAgICAgIHRlc3RQYXNzZWQoJ1Njcm9sbCBw b3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyArIHNjcm9sbFkgKyAnKScpOworICAgICAgICAv LyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFu b3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1l b3V0KGZpbmlzaEpTVGVzdCwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBjbGVhclRpbWVv dXQoZG9uZVRpbWVvdXQpOworICAgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwgaGFuZGxlciB3YXMg aW52b2tlZCAnICsgZXZlbnRDb3VudCArICcgdGltZXMnKTsKKyAgICAgICAgZmluaXNoSlNUZXN0 KCk7CisgICAgfQorfQorCitvbmxvYWQgPSBmdW5jdGlvbigpCit7CisgICAgdmFyIGNvbnRhaW5l ciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb250YWluZXInKTsKKyAgICBjb250YWluZXIu YWRkRXZlbnRMaXN0ZW5lcignc2Nyb2xsJywgc2Nyb2xsSGFuZGxlciwgZmFsc2UpOworICAgIGNv bnRhaW5lci5zY3JvbGxUb3AgPSAxMDA7CisgICAgaWYgKGV2ZW50Q291bnQgPiAwKSB7CisgICAg ICB0ZXN0RmFpbGVkKCdTY3JvbGwgZXZlbnQgZmlyZWQgc3luY2hyb25vdXNseScpOworICAgICAg ZmluaXNoSlNUZXN0KCk7CisgICAgfQorICAgIGNvbnRhaW5lci5zY3JvbGxUb3AgPSAyMDA7Cit9 CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwordmFyIGpzVGVzdElzQXN5bmMgPSB0 cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2Yg ZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZXhwZWN0ZWQudHh0CmluZGV4IDE2ODZjZWQzOWFlMmJlMmQ1OWI2M2U5ZDNmZGFlNGIxZTJj ODg2NTYuLmU3NjY2Njk1YmM2MzBlMjUyOTk4MmExMzVmMTI5NzE0NzQwNjkyNDMgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3Rl ZC50eHQKQEAgLTEsNTkgKzEsMTEgQEAKLVBBU1NFRAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBl dmVudCBmaXJlcyBvbiB0aGUgZG9jdW1lbnQgYXN5Y2hyb25vdXNseSBhbmQgb25seSBvbmNlLgog Ci1JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRl c3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwg ZXZlbnQgZGlkIG5vdCBmaXJlLgorT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9m ICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCisKK1Njcm9sbCBldmVudCBi dWJibGVzOiB0cnVlCitQQVNTIFNjcm9sbCBwb3NpdGlvbjogKDIwMCwgMjAwKQorUEFTUyBzdWNj ZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwgYi9MYXlvdXRUZXN0 cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCmluZGV4IGEwNTZjMDY3YmQ5ZjI3 YzRiMzQ2NWM4NGExNmUyMWE5ZmEzZTcxNGMuLjkyMjQ3MGEyMzE0ZGU4Zjc5MzljNjFlMmE2YjAy OTA0ZDk5YWRkZWYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Ny b2xsLWV2ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbApAQCAtMSwzMCArMSw0NSBAQAogPGh0bWw+Cis8bGluayByZWw9InN0eWxlc2hl ZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNy Yz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxib2R5IHN0eWxl PSJtaW4td2lkdGg6IDUwMDBweDsgbWluLWhlaWdodDogNTAwMHB4Ij4KKzxwIGlkPSJkZXNjcmlw dGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CiA8c2NyaXB0PgotdmFyIGV2ZW50 RmlyZWQgPSBmYWxzZTsKK2Rlc2NyaXB0aW9uKCdDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50 IGZpcmVzIG9uIHRoZSBkb2N1bWVudCBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuJyk7CiAK LWZ1bmN0aW9uIHNjcm9sbGVyKCkgewotICAgIGlmICghZXZlbnRGaXJlZCkgewotICAgICAgICBl dmVudEZpcmVkID0gdHJ1ZTsKLSAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhc3Nl ZCIpLmlubmVySFRNTCA9ICI8cCBzdHlsZT0nY29sb3I6cmVkJz5QQVNTRUQ8L3A+IjsKK3ZhciBl dmVudENvdW50ID0gMDsKK3ZhciBkb25lVGltZW91dDsKKworb25zY3JvbGwgPSBmdW5jdGlvbihl dmVudCkKK3sKKyAgICBldmVudENvdW50Kys7CisgICAgaWYgKGV2ZW50Q291bnQgPT0gMSkgewor ICAgICAgICBkZWJ1ZygnU2Nyb2xsIGV2ZW50IGJ1YmJsZXM6ICcgKyBldmVudC5idWJibGVzKTsK KyAgICAgICAgdmFyIHNjcm9sbFggPSBkb2N1bWVudC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAg IHZhciBzY3JvbGxZID0gZG9jdW1lbnQuYm9keS5zY3JvbGxUb3A7CisgICAgICAgIHRlc3RQYXNz ZWQoJ1Njcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyArIHNjcm9sbFkgKyAnKScp OworICAgICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2Fz ZSB0aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVv dXQgPSBzZXRUaW1lb3V0KGZpbmlzaEpTVGVzdCwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAg ICBjbGVhclRpbWVvdXQoZG9uZVRpbWVvdXQpOworICAgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwg aGFuZGxlciB3YXMgaW52b2tlZCAnICsgZXZlbnRDb3VudCArICcgdGltZXMnKTsKKyAgICAgICAg ZmluaXNoSlNUZXN0KCk7CiAgICAgfQogfQogCi13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7 Ci0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7 Ci0gICAgd2luZG93LnNjcm9sbFRvKDUwMCwgNTAwKTsKLSAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKSB7Ci0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDAp OworICAgIGlmIChldmVudENvdW50ID4gMCkgeworICAgICAgdGVzdEZhaWxlZCgnU2Nyb2xsIGV2 ZW50IGZpcmVkIHN5bmNocm9ub3VzbHknKTsKKyAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0K KyAgICB3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOwogfQogCit2YXIgc3VjY2Vzc2Z1bGx5UGFy c2VkID0gdHJ1ZTsKK3ZhciBqc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKIDwvc2NyaXB0PgotPGJvZHk+ Ci08ZGl2IGlkPSJwYXNzZWQiPjwvZGl2PgotCi08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2Vz IG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3Qg ZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KLQot YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgorPHNjcmlwdCBz cmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5Pgog PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sIGIvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZl NTAyMjc4ZDM2ZWYxOGUwNzFmY2IzNjU0Y2MzNS4uZWFiYjA3OWVhY2FhNzliODhlMGYwYWFkYTcw MTk1ZGUzOGIzNjNiOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3Zl LWNoaWxkLW9uc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3Zl LWNoaWxkLW9uc2Nyb2xsLmh0bWwKQEAgLTksMTcgKzksMjggQEAKICAgICAgICAgICAgIGZ1bmN0 aW9uIGRpc3BhdGNoU2Nyb2xsRXZlbnRzKCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAg ICBpZiAod2luZG93LmV2ZW50U2VuZGVyICYmIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg eworICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25l KCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAw KTsKICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7 Ci0gICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsK LSAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgICAgICAgICAgICAgICAgICB2YXIgc2Nyb2xsQ291bnQgPSAwOworICAgICAgICAgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHYnKS5hZGRFdmVudExpc3RlbmVyKAorICAg ICAgICAgICAgICAgICAgICAgICAgJ3Njcm9sbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBm dW5jdGlvbihldmVudCkgeworICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzLnJlbW92ZUNo aWxkKHRoaXMuZmlyc3RDaGlsZCkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgc2Nyb2xsQ291 bnQrKzsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHNjcm9sbENvdW50ID09IDEpCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0x LCAtMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIH0sCisgICAgICAgICAgICAgICAgICAgICAgICBmYWxzZSk7CiAgICAg ICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICA8L3NjcmlwdD4KICAgICA8L2hl YWQ+CiAgICAgPGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygp OycsIDEpOyI+CiAgICAgICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBi ZSByZW1vdmVkIGJ5IHRoZWlyIHBhcmVudCBlbGVtZW50J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxl ci4gIFRoZSB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgaXMgdGhlIG9ubHkgdGV4dCByZW1haW5pbmcg YWZ0ZXIgdGhlIHR3byBzY3JvbGwgZXZlbnRzIGFyZSBkaXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFp bHMgaWYgdGhlIGlubmVyIGRpdiByZW1haW5zIGluIHRoZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNy YXNoZXMuPGJyPjxicj4KLSAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0 bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNj cm9sbD0idGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBp ZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4 OyB3aGl0ZXNwYWNlOiBub3dyYXA7Ij4KICAgICAgICAgPGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7 IGhlaWdodDozMDBweCI+TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFk aXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9y ZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmltIGFkIG1pbmltIHZlbmlhbSwgcXVpcyBu b3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9yaXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVh IGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJp dCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0gZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBw YXJpYXR1ci4gRXhjZXB0ZXVyIHNpbnQgb2NjYWVjYXQgY3VwaWRhdGF0IG5vbiBwcm9pZGVudCwg c3VudCBpbiBjdWxwYSBxdWkgb2ZmaWNpYSBkZXNlcnVudCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFi b3J1bQogICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwKaW5kZXggNGZj MTUyODRkZWYxZjU4ZDkzNzM1ZmFjYWRlNGE1NmQ3MTBkNTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4 MjUzM2FjYjA0NDJhOTJjZTcyNzFmZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVu dHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbApAQCAtMTYsNiArMTYsOSBAQAog ICAgIGZ1bmN0aW9uIHNjcm9sbGVkKGV2ZW50KQogICAgIHsKICAgICAgICAgZXZlbnQudGFyZ2V0 LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZXZlbnQudGFyZ2V0KTsKKyAgICAgICAgaWYgKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CiAgICAgfQogCiAgICAgZnVuY3Rpb24gdGVzdCgp CkBAIC0yNyw3ICszMCw5IEBACiAgICAgICAgIGRvY3VtZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7 CiAgICAgfQogCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOworICAgIH0KICAgICB0ZXN0KCk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbApp bmRleCAyMjJhZGE4MDVkYTUzMDYyMmU0ZjgxZjViZGNlZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3 NDMzZGU4YWJlZTZmMzY3MTUxZTUyMDNlMmVlZDQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0x LDExICsxLDIyIEBACiA8aHRtbD4KIDxzY3JpcHQ+Cit2YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBm YWxzZTsKK3ZhciBkb25lVGltZW91dDsKKwogZnVuY3Rpb24gd2luZG93U2Nyb2xsZWQoKSB7Cisg ICAgd2luZG93V2FzU2Nyb2xsZWQgPSB0cnVlOwogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTFVSRTogd2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxs ZWQuJzsgCisgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1lb3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9u IGRpdlNjcm9sbGVkKCkgewotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5p bm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xsIHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cu b25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICBpZiAoIXdpbmRvd1dhc1Njcm9sbGVkKQorICAgICAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6 IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2luZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsg CisgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhl cmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcvYnViYmxpbmcuCisgICAgZG9uZVRpbWVv dXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9u ZSgpOworICAgICAgICB9LCAxMDApOyAgICAKIH0KIAogZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAg LTI0LDEwICszNSw2IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKSB7CiAgICAgCiAgICAgLy8gRG9uJ3Qg cG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25zZW5zZS4KICAgICBkaXYuaW5uZXJIVE1M ID0gJyc7Ci0gICAgCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgCi0gICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKLSAgICAKIH0KIAogPC9zY3Jp cHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhh c2UtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBo YXNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zZTk0YTMwZDdkODc2ODE2N2Y4OWE3NGE1NWU1 Y2I5ZjE2M2ZjNGViCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv c2Nyb2xsLWV2ZW50LXBoYXNlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUZXN0cyB0 aGF0IHdlIGNhbiBsaXN0ZW4gZm9yIHNjcm9sbCBldmVudHMgb24gdGhlIGRvY3VtZW50IGluIGJv dGggdGhlIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFzZXMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCitCb3RoIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFzZSBsaXN0ZW5lcnMgd2VyZSBp bnZva2VkLgorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRF CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFz ZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uYzBjZTVjMDJlMmFlMWQxZjJlZTE3YmYwMmIzYTU5NWNlMWQwODM4MAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFz ZS5odG1sCkBAIC0wLDAgKzEsNDUgQEAKKzxodG1sPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBo cmVmPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8Ym9keSBzdHlsZT0ibWlu LWhlaWdodDogMjAwMHB4Ij4gCis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNv bnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CitkZXNjcmlw dGlvbignVGVzdHMgdGhhdCB3ZSBjYW4gbGlzdGVuIGZvciBzY3JvbGwgZXZlbnRzIG9uIHRoZSBk b2N1bWVudCBpbiBib3RoIHRoZSBjYXB0dXJlIGFuZCBidWJibGUgcGhhc2VzLicpOworCit2YXIg dHJpZ2dlcmVkQ2FwdHVyZUxpc3RlbmVyID0gZmFsc2U7Cit2YXIgdHJpZ2dlcmVkQnViYmxlTGlz dGVuZXIgPSBmYWxzZTsKKword2luZG93LmFkZEV2ZW50TGlzdGVuZXIoCisgICAgJ3Njcm9sbCcs CisgICAgZnVuY3Rpb24oKSB7CisgICAgICAgIHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciA9IHRy dWU7CisgICAgICAgIGNoZWNrQ29tcGxldGUoKTsKKyAgICB9LAorICAgIHRydWUpOworCit3aW5k b3cuYWRkRXZlbnRMaXN0ZW5lcigKKyAgICAnc2Nyb2xsJywKKyAgICBmdW5jdGlvbihldmVudCkg eworICAgICAgICB0cmlnZ2VyZWRCdWJibGVMaXN0ZW5lciA9IHRydWU7CisgICAgICAgIGNoZWNr Q29tcGxldGUoKTsKKyAgICB9LAorICAgIGZhbHNlKTsKKworZnVuY3Rpb24gY2hlY2tDb21wbGV0 ZSgpCit7CisgICAgaWYgKHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciAmJiB0cmlnZ2VyZWRCdWJi bGVMaXN0ZW5lcikgeworICAgICAgICBkZWJ1ZygnQm90aCBjYXB0dXJlIGFuZCBidWJibGUgcGhh c2UgbGlzdGVuZXJzIHdlcmUgaW52b2tlZC4nKTsKKyAgICAgICAgZmluaXNoSlNUZXN0KCk7Cisg ICAgfQorfQorCit3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOworCit2YXIgc3VjY2Vzc2Z1bGx5 UGFyc2VkID0gdHJ1ZTsKK3ZhciBqc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNj cmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCmluZGV4IGJhMWEzNTE2NGM1NmIyYzQxZWEzODBiZWE3 NjNlN2U0YTFlNTlmOTguLmQyZjlhYzY0NWU3ZDYxYjQ1MDFiMWIyYjhmNTBmYjY2OTU3N2E1NjIg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhh bmRsZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9s bC1oYW5kbGVyLmh0bWwKQEAgLTExLDI5ICsxMSwzMyBAQAogPHA+CiAgICAgUmVzdWx0OiA8c3Bh biBpZD0icmVzdWx0Ij50ZXN0IGRpZCBub3QgY29tcGxldGUuPC9zcGFuPgogPC9wPgotPGRpdiBp ZD0idCIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7 IiBvbnNjcm9sbD0iaWYgKG92ZXJmbG93UmVtb3ZlKSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hp bGQodGhpcyk7Ij4KKzxkaXYgaWQ9InQiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIw MHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGls ZCh0aGlzKTtoYW5kbGVTY3JvbGwoMCk7Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4 OyI+PC9kaXY+CiA8L2Rpdj4KIAotPGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAy MDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAoc2Vjb25kT3ZlcmZsb3dSZW1vdmUp IHRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBzdHlsZT0ib3ZlcmZs b3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBh cmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7aGFuZGxlU2Nyb2xsKDEpOyI+CiAgICAgPGRpdiBz dHlsZT0iaGVpZ2h0OiAyMDBweDsiPjwvZGl2PgogICAgIDxkaXYgaWQ9ImQiPjwvZGl2PgogPC9k aXY+CiAKIDxzY3JpcHQ+Ci0gICAgdmFyIG92ZXJmbG93UmVtb3ZlID0gZmFsc2U7Ci0gICAgdmFy IHNlY29uZE92ZXJmbG93UmVtb3ZlID0gZmFsc2U7CisgICAgdmFyIHNjcm9sbGVkRmlyc3RDb250 YWluZXIgPSBmYWxzZTsKKyAgICB2YXIgc2Nyb2xsZWRTZWNvbmRDb250YWluZXIgPSBmYWxzZTsK IAogICAgIGRvY3VtZW50LmJvZHkub2Zmc2V0VG9wOyB0LnNjcm9sbFRvcCA9IDIwOwogCi0gICAg b3ZlcmZsb3dSZW1vdmUgPSB0cnVlOwotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0Jyku aW5uZXJIVE1MID0gJyc7Ci0KLSAgICBzZWNvbmRPdmVyZmxvd1JlbW92ZSA9IHRydWU7CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2QnKS5zY3JvbGxJbnRvVmlldygpOwogICAgIAotICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7 Ci0KLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZnVuY3Rpb24gaGFuZGxlU2Nyb2xsKGlu ZGV4KQorICAgIHsKKyAgICAgICAgaWYgKGluZGV4ID09IDApIHNjcm9sbGVkRmlyc3RDb250YWlu ZXIgPSB0cnVlOworICAgICAgICBlbHNlIGlmIChpbmRleCA9PSAxKSBzY3JvbGxlZFNlY29uZENv bnRhaW5lciA9IHRydWU7CisgICAgICAgIAorICAgICAgICBpZiAoc2Nyb2xsZWRGaXJzdENvbnRh aW5lciAmJiBzY3JvbGxlZFNlY29uZENvbnRhaW5lcikgeworICAgICAgICAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4dCA9ICJTVUNDRVNTIjsKKyAgICAgICAg CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQorICAg IH0KIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNj cm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93 L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAppbmRleCA2NGIyMGFjNGFlZmRjZDU2 MTRkMmM0OGMwM2U2Y2QyYTMyMmJkNGRlLi4zNTc0MTJmZTIzZmI2NmM1ZGVjMWRhMDU4YWVhNzUy YmUzNjEwNzhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xs LWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93 L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbApAQCAtMSwxNCArMSwxNiBAQAogPGhl YWQ+CiA8c2NyaXB0PgogZnVuY3Rpb24gdGVzdCgpIHsKLSAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfQogICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJpdCIpLnNjcm9sbFRvcCA9IDEwMDsKIH0KIDwvc2NyaXB0PgogPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgogPHA+VGhpcyB0ZXN0IGludm9sdmVzIGEgbGF5ZXIgdGhhdCBzZWxmLWRl c3RydWN0cyB3aGVuIHNjcm9sbGVkLiBJZiB0aGVyZSdzIG5vIGNyYXNoLCB0aGVuIHRoZSB0ZXN0 IHN1Y2NlZWRlZC48L3A+Ci08ZGl2IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZs b3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlzcGxheSA9ICdub25lJyI+Cis8ZGl2IGlkPSJp dCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUu ZGlzcGxheSA9ICdub25lJztpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ij4KIDxkaXYgc3R5bGU9ImhlaWdodDogMjAwMHB4 OyI+PC9kaXY+CiA8L2Rpdj4KIDwvYm9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv cmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvcmVw YWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAppbmRleCBlM2YwYWM0NGMxOWJjYTVkYmRl MTRkMTM4NzNhMGNkNWYwZWU3MjBjLi5kYzY5NzEyMjE2ZjdiNTE2NjBhZTMyMjRiMmNlZWFlNDYx YjE0NGFhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJp bmctc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVy aW5nLXNjcm9sbC5odG1sCkBAIC0zLDYgKzMsOCBAQAogICAgIDxzY3JpcHQ+CiAgICAgICAgIGZ1 bmN0aW9uIHJlcGFpbnRUZXN0KCkKICAgICAgICAgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgc2Nyb2xsQnkoMCwgMTAwKTsKICAg ICAgICAgfQpAQCAtMTEsNiArMTMsOCBAQAogICAgICAgICB7CiAgICAgICAgICAgICB2YXIgdGFy Z2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgdGFy Z2V0LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICJncmVlbiI7CisgICAgICAgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm5vdGlmeURvbmUoKTsKICAgICAgICAgfQogICAgIDwvc2NyaXB0PgogPC9oZWFkPgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9BbmRyb2lkLm1rIGIvV2ViQ29yZS9BbmRyb2lkLm1rCmluZGV4 IGI2NGUzMmI2ZDg1ZjRhYzYyZjc1MmMwMjNiN2E3ZWUxY2EwNmE0NDQuLmNhMDc0ZWNkZmVkZGFi ZWRkNzRhMGM0MDU5Y2Q5NWNjYzJjOGZiMTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQW5kcm9pZC5t aworKysgYi9XZWJDb3JlL0FuZHJvaWQubWsKQEAgLTEzNSw2ICsxMzUsNyBAQCBMT0NBTF9TUkNf RklMRVMgOj0gJChMT0NBTF9TUkNfRklMRVMpIFwKIAlkb20vRXZlbnRDb250ZXh0LmNwcCBcCiAJ ZG9tL0V2ZW50TmFtZXMuY3BwIFwKIAlkb20vRXZlbnRUYXJnZXQuY3BwIFwKKwlkb20vRXZlbnRR dWV1ZS5jcHAgXAogCWRvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkNvZGUu Y3BwIFwKIAlkb20vSW5wdXRFbGVtZW50LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NNYWtl TGlzdHMudHh0IGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAppbmRleCA5MzE3Njg3ZGRiZmIwODJh NjQ0ZDVhZjNjMDA5ZTg1NWU4ZjNlYjEyLi5mYTI2ZDQ4OGQ4MGYxMjRhYTRhYTNmMTI5NGNjNzk4 NTZjZWI0MTg5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1dlYkNv cmUvQ01ha2VMaXN0cy50eHQKQEAgLTgyNiw2ICs4MjYsNyBAQCBTRVQoV2ViQ29yZV9TT1VSQ0VT CiAgICAgZG9tL0V2ZW50Q29udGV4dC5jcHAKICAgICBkb20vRXZlbnROYW1lcy5jcHAKICAgICBk b20vRXZlbnRUYXJnZXQuY3BwCisgICAgZG9tL0V2ZW50UXVldWUuY3BwCiAgICAgZG9tL0V4Y2Vw dGlvbkJhc2UuY3BwCiAgICAgZG9tL0V4Y2VwdGlvbkNvZGUuY3BwCiAgICAgZG9tL0lucHV0RWxl bWVudC5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggZWY0ZTQ3NjJjZTg2NmYwZTY4YzFiMzBmYjQ0NTk4MDgyNjVjMjIxNC4uY2Y3M2M3 N2E2NzRiMjM5N2RlMGVkNDY5YzI1NzI3MTE4M2M0OTNkZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9D aGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MSBAQAorMjAxMC0x MS0xNSAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTY3JvbGwgZXZlbnQgc2hvdWxk IGJlIGZpcmVkIGFzeW5jaHJvbm91c2x5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD00NTYzMQorCisgICAgICAgIFRlc3RzOiBmYXN0L2V2ZW50cy9maXJl LXNjcm9sbC1ldmVudC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2V2ZW50cy9maXJlLXNjcm9s bC1ldmVudC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sCisKKyAgICAgICAgTWFrZXMgc2Nyb2xsIGV2ZW50cyBmaXJlIGFzeW5j aHJvbm91c2x5IHRvIGJlIGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUKKyAgICAgICAgQ1NTT00gVmll dyBNb2R1bGUgYW5kIGNvbnNpc3RlbnQgd2l0aCBHZWNrbywgT3BlcmEgYW5kICh0byBzb21lIGRl Z3JlZSkKKyAgICAgICAgSUUuCisKKyAgICAgICAgVGhpcyBpcyBhY2NvbXBsaXNoZWQgYnkgbW92 aW5nIHRoZSBEb2N1bWVudDo6ZW5xdWV1ZUV2ZW50IGFuZCBzdXBwb3J0aW5nCisgICAgICAgIGNv ZGUgdG8gYSBzdGFuZGFsb25lIEV2ZW50UXVldWUgY2xhc3MuIEFkZGl0aW9uYWxseSwgdGhlcmUg aXMgbm93IGFuCisgICAgICAgIGVucXVldWVTY3JvbGxFdmVudCBtZXRob2QgdGhhdCBoYW5kbGVz IHNjcm9sbCBldmVudC1zcGVjaWZpYyBiZWhhdmlvcgorICAgICAgICAoZG9uJ3QgZW5xdWV1ZSBh bm90aGVyIGV2ZW50IGlmIHRoZXJlJ3MgYWxyZWFkeSBvbmUgZW5xdWV1ZWQgZm9yIHRoZQorICAg ICAgICBlbGVtZW50KS4gRG9jdW1lbnQ6OmVucXVldWVFdmVudCBoYXMgYmVlbiByZW5hbWVkIHRv IGVucXVldWVXaW5kb3dFdmVudAorICAgICAgICAoZm9yIGNsYXJpdHkpIHNpbmNlIHRoYXQncyB3 aGF0IGl0IGRpZCBhbGwgYWxvbmcuCisgICAgICAgIAorICAgICAgICAqIEFuZHJvaWQubWs6Cisg ICAgICAgICogQ01ha2VMaXN0cy50eHQ6CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAg ICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdl YkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50 OjplbnF1ZXVlV2luZG93RXZlbnQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmV2ZW50UXVldWUpOgorICAgICAgICAqIGRvbS9FdmVudFF1 ZXVlLmNwcDogQWRkZWQuCisgICAgICAgICogZG9tL0V2ZW50UXVldWUuaDogQWRkZWQuCisgICAg ICAgICogZG9tL05vZGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6ZW5xdWV1ZVNjcm9s bEV2ZW50KToKKyAgICAgICAgKiBkb20vTm9kZS5oOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50 KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGlzdEJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMaXN0Qm94Ojp2YWx1ZUNo YW5nZWQpOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpTdG9yYWdlRXZlbnREaXNwYXRjaGVyOjpkaXNwYXRjaCk6ICAgICAg ICAKKwogMjAxMC0xMS0xNSAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IDA5ODc1ZDViOWI5ZjBlOWQwNzRi NDBjMThhODM4M2ZmNTA4ZDlhODAuLjFiNjQyNTg3OWY4M2MwZDlkMjZhNzgzNDY0OTA5NWY0Y2Zk ZmI0ZmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9H TlVtYWtlZmlsZS5hbQpAQCAtMTE0NCw2ICsxMTQ0LDggQEAgd2ViY29yZV9zb3VyY2VzICs9IFwK IAlXZWJDb3JlL2RvbS9FdmVudE5hbWVzLmggXAogCVdlYkNvcmUvZG9tL0V2ZW50VGFyZ2V0LmNw cCBcCiAJV2ViQ29yZS9kb20vRXZlbnRUYXJnZXQuaCBcCisJV2ViQ29yZS9kb20vRXZlbnRRdWV1 ZS5jcHAgXAorCVdlYkNvcmUvZG9tL0V2ZW50UXVldWUuaCBcCiAJV2ViQ29yZS9kb20vRXhjZXB0 aW9uQmFzZS5jcHAgXAogCVdlYkNvcmUvZG9tL0V4Y2VwdGlvbkJhc2UuaCBcCiAJV2ViQ29yZS9k b20vRXhjZXB0aW9uQ29kZS5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkg Yi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCAyMTZiNTU3NTNiMjAyMGU0NmYyYmNmNGVkYzFj MzJkZjQ2NTgzY2NjLi40NjZlZTY2NzY5MzBjYjc4Yjc2ZTRmNjU2MDAxZGY3YzBiNWNiZTlhIDEw MDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lw aQpAQCAtMTIxMCw2ICsxMjEwLDggQEAKICAgICAgICAgICAgICdkb20vRXZlbnROYW1lcy5oJywK ICAgICAgICAgICAgICdkb20vRXZlbnRUYXJnZXQuY3BwJywKICAgICAgICAgICAgICdkb20vRXZl bnRUYXJnZXQuaCcsCisgICAgICAgICAgICAnZG9tL0V2ZW50UXVldWUuY3BwJywKKyAgICAgICAg ICAgICdkb20vRXZlbnRRdWV1ZS5oJywKICAgICAgICAgICAgICdkb20vRXhjZXB0aW9uQmFzZS5j cHAnLAogICAgICAgICAgICAgJ2RvbS9FeGNlcHRpb25CYXNlLmgnLAogICAgICAgICAgICAgJ2Rv bS9FeGNlcHRpb25Db2RlLmNwcCcsCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIv V2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCA3MzczMDRiN2E0OWJiYjIwNWM5MDU0M2UwYjk2NmI0 ZDlmYWFiMWZlLi45ODRiNTI2M2RiOTE5MWExNjg4YTU0NzA4NjhhZWE0ODQyYTA1Y2Q0IDEwMDY0 NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAg LTcxMiw2ICs3MTIsNyBAQCBTT1VSQ0VTICs9IFwKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcCBc CiAgICAgZG9tL0V2ZW50TmFtZXMuY3BwIFwKICAgICBkb20vRXZlbnRUYXJnZXQuY3BwIFwKKyAg ICBkb20vRXZlbnRRdWV1ZS5jcHAgXAogICAgIGRvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAgICAg ZG9tL0V4Y2VwdGlvbkNvZGUuY3BwIFwKICAgICBkb20vSW5wdXRFbGVtZW50LmNwcCBcCmRpZmYg LS1naXQgYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCA5ZjkwZDhlNjYwYzc4NTc2MDA5MmZi ZDMxY2EwYjE3MjQxZGI0MjljLi5lMTI2ZDA5NjY4OTk1ZjM3N2Q5OWQwYmNlZGVkNzU2YjAwOWYz MjQ4IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisr KyBiL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTQyNTYzLDYgKzQy NTYzLDYyIEBACiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZlbnRUYXJnZXQuaCINCiAJCQkJ Pg0KIAkJCTwvRmlsZT4NCisJCSAgPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZl bnRRdWV1ZS5jcHAiDQorCQkJCT4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1l PSJEZWJ1Z3xXaW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0K KwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJ CQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlO YW1lPSJSZWxlYXNlfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJ CQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkv Pg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJ CQkJCU5hbWU9IkRlYnVnX0ludGVybmFsfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9 InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRv b2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZp Z3VyYXRpb24NCisJCQkJCU5hbWU9IkRlYnVnX0NhaXJvfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRG cm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xD b21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8 RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IlJlbGVhc2VfQ2Fpcm98V2luMzIiDQorCQkJ CQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJ TmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRp b24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfQWxsfFdpbjMy Ig0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0K KwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25m aWd1cmF0aW9uPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4u XGRvbVxFdmVudFF1ZXVlLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCiAJCQkJ UmVsYXRpdmVQYXRoPSIuLlxkb21cRXhjZXB0aW9uQmFzZS5jcHAiDQogCQkJCT4NCmRpZmYgLS1n aXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDc4YTlhOTAxZjJjYzE4Mjg2 NzRjNGFlMDNmZmM4YTRjZmVhN2VkNzEuLjkzYzQ1MWMxOTZlMDU5YzA4OWVlMzIzNjJhNzA2Mzdh M2JhMjc0NTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBA IC0yNjU0LDYgKzI2NTQsOCBAQAogCQk4QUY0RTU1QzExREM1QTYzMDAwRUQzREUgLyogUGVyZm9y bWFuY2VUaW1pbmcuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDhBRjRFNTU5MTFEQzVBNjMwMDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5oICovOyB9 OwogCQk4QzZFQTYxOTExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYx NzExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi87IH07CiAJ CThDNkVBNjFBMTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYxODExRUY3 RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oICovOyB9OworCQk4RjY3NTYx QjEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEY2NzU2MTkxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50 UXVldWUuaCAqLzsgfTsKKwkJOEY2NzU2MUMxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEY2NzU2 MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3BwICovOyB9OwogCQk4RkFDNzc0RDEx OTg3MkNCMDAxNUFFOTQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhGOTM0RDg0MTE4OUYxRUUwMDUwOEQ1 RCAvKiBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwICovOyB9OwogCQk5MzAyQjBCRDBENzlGODI5 MDBDN0VFODMgLyogUGFnZUdyb3VwLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3Bw ICovOyB9OwogCQk5MzAyQjBCRjBENzlGODJDMDBDN0VFODMgLyogUGFnZUdyb3VwLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzAyQjBCRTBENzlGODJD MDBDN0VFODMgLyogUGFnZUdyb3VwLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKQEAgLTg3ODMsNiArODc4NSw4IEBACiAJCThBRjRFNTVBMTFEQzVBNjMw MDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0g UGVyZm9ybWFuY2VUaW1pbmcuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QzZF QTYxNzExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNw cDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCThDNkVBNjE4MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5h YmxlZEZlYXR1cmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFJ1bnRpbWVF bmFibGVkRmVhdHVyZXMuaDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMg LyogRXZlbnRRdWV1ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFdmVudFF1 ZXVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCThGNjc1NjFBMTI4OEIxN0IwMDQ3 QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IEV2ZW50UXVldWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4 MzExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4NDExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhy ZWFkRXhlY1N0YXRlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpT TWFpblRocmVhZEV4ZWNTdGF0ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkz MDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gUGFnZUdyb3VwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKQEAgLTE4NDQ1LDYgKzE4NDQ5LDggQEAKIAkJCQk1NEM1MEY3QTBFODAxREYzMDA5ODMy QTAgLyogWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCAqLywKIAkJCQk1RDE1RTNBOTBGOUU2 QUMxMDA5RTBFM0YgLyogWE1MRG9jdW1lbnRQYXJzZXJTY29wZS5jcHAgKi8sCiAJCQkJNUQxNUUz QUEwRjlFNkFDMTAwOUUwRTNGIC8qIFhNTERvY3VtZW50UGFyc2VyU2NvcGUuaCAqLywKKwkJCQk4 RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovLAorCQkJCThGNjc1NjFB MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLywKIAkJCSk7CiAJCQlwYXRoID0g ZG9tOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTIxMzgzLDYgKzIxMzg5LDcgQEAK IAkJCQk0OTlCM0M1OTEyOEM2NDFFMDBFNzI2QzIgLyogR3JhcGhpY3NMYXllck1hYy5oIGluIEhl YWRlcnMgKi8sCiAJCQkJMDgyNTA5MzkxMjhCRDREODAwRTJFRDhFIC8qIFNWR0FuaW1hdGVkVHJh bnNmb3JtTGlzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMzg4OEY2RUYxMjhDOTg4OTAwMENBOEUw IC8qIEluc3BlY3RvckZpbGVTeXN0ZW1BZ2VudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJOEY2NzU2 MUIxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuaCBpbiBIZWFkZXJzICovLAogCQkJKTsK IAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMjM5 NTYsNiArMjM5NjMsNyBAQAogCQkJCTk3REQ0RDg2MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRp dG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTQ5OUIzQzVBMTI4QzY0MUUwMEU3MjZDMiAvKiBH cmFwaGljc0xheWVyTWFjLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJMzg4OEY2RUUxMjhDOTg4OTAw MENBOEUwIC8qIEluc3BlY3RvckZpbGVTeXN0ZW1BZ2VudC5jcHAgaW4gU291cmNlcyAqLywKKwkJ CQk4RjY3NTYxQzEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAgaW4gU291cmNlcyAq LywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJ fTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1dlYkNvcmUvZG9tL0Rv Y3VtZW50LmNwcAppbmRleCA0YzM0MjVhNzNkZmQ4YmZiOGQ1MDVjMDg5MzQyZWQ4NTk2ZTJkODMz Li44NDRhYjNlMTgzMGY4ZDRjNmEzMTYwOWY0MzUzMjJmZGE2ZjExZWRiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBA IC01OCw2ICs1OCw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5jbHVkZSAiRXZl bnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1 ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJv bGxlci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCkBAIC0zOTksNyArNDAwLDcgQEAgRG9jdW1lbnQ6 OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhUTUwsIGJv b2wgaXNIVE1MLCBjb24KICAgICAsIG1fbm9ybWFsV29ybGRXcmFwcGVyQ2FjaGUoMCkKICNlbmRp ZgogICAgICwgbV91c2luZ0dlb2xvY2F0aW9uKGZhbHNlKQotICAgICwgbV9wZW5kaW5nRXZlbnRU aW1lcih0aGlzLCAmRG9jdW1lbnQ6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCisgICAgLCBtX2V2 ZW50UXVldWUoYWRvcHRQdHIobmV3IEV2ZW50UXVldWUpKQogI2lmIEVOQUJMRShXTUwpCiAgICAg LCBtX2NvbnRhaW5zV01MQ29udGVudChmYWxzZSkKICNlbmRpZgpAQCAtMzQzNywyMyArMzQzOCwx MCBAQCB2b2lkIERvY3VtZW50OjpkaXNwYXRjaFdpbmRvd0xvYWRFdmVudCgpCiAgICAgZG9tV2lu ZG93LT5kaXNwYXRjaExvYWRFdmVudCgpOwogfQogCi12b2lkIERvY3VtZW50OjplbnF1ZXVlRXZl bnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCit2b2lkIERvY3VtZW50OjplbnF1ZXVlV2luZG93 RXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCiB7Ci0gICAgbV9wZW5kaW5nRXZlbnRRdWV1 ZS5hcHBlbmQoZXZlbnQpOwotICAgIGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgp KQotICAgICAgICBtX3BlbmRpbmdFdmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9p ZCBEb2N1bWVudDo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQotewot ICAgIEFTU0VSVCghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKTsKLSAgICBWZWN0b3I8 UmVmUHRyPEV2ZW50PiA+IGV2ZW50UXVldWU7Ci0gICAgZXZlbnRRdWV1ZS5zd2FwKG1fcGVuZGlu Z0V2ZW50UXVldWUpOwotCi0gICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+Ojpjb25z dF9pdGVyYXRvciBJdGVyYXRvcjsKLSAgICBJdGVyYXRvciBlbmQgPSBldmVudFF1ZXVlLmVuZCgp OwotICAgIGZvciAoSXRlcmF0b3IgaXQgPSBldmVudFF1ZXVlLmJlZ2luKCk7IGl0ICE9IGVuZDsg KytpdCkKLSAgICAgICAgZGlzcGF0Y2hXaW5kb3dFdmVudCgqaXQpOworICAgIGV2ZW50LT5zZXRU YXJnZXQoZG9tV2luZG93KCkpOworICAgIG1fZXZlbnRRdWV1ZS0+ZW5xdWV1ZUV2ZW50KGV2ZW50 KTsKIH0KIAogUGFzc1JlZlB0cjxFdmVudD4gRG9jdW1lbnQ6OmNyZWF0ZUV2ZW50KGNvbnN0IFN0 cmluZyYgZXZlbnRUeXBlLCBFeGNlcHRpb25Db2RlJiBlYykKQEAgLTQ3MTUsNyArNDcwMyw3IEBA IHZvaWQgRG9jdW1lbnQ6OmVucXVldWVQYWdlc2hvd0V2ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0 ZW5jZSBwZXJzaXN0ZWQpCiAKIHZvaWQgRG9jdW1lbnQ6OmVucXVldWVIYXNoY2hhbmdlRXZlbnQo Y29uc3QgU3RyaW5nJiBvbGRVUkwsIGNvbnN0IFN0cmluZyYgbmV3VVJMKQogewotICAgIGVucXVl dWVFdmVudChIYXNoQ2hhbmdlRXZlbnQ6OmNyZWF0ZShvbGRVUkwsIG5ld1VSTCkpOworICAgIGVu cXVldWVXaW5kb3dFdmVudChIYXNoQ2hhbmdlRXZlbnQ6OmNyZWF0ZShvbGRVUkwsIG5ld1VSTCkp OwogfQogCiB2b2lkIERvY3VtZW50OjplbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gc3RhdGVPYmplY3QpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5oIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAppbmRleCBiYTQ4ZDZmODJlY2I0 MDhiZGJkMTQ3ZjYyM2U5ZTZjOWNiZjIyMTY5Li4zMWI3NWJmMDhiNTA1ZDEwMDRkNDYzYjNjYWE2 NTkxZDg0ODgxNjNjIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1dl YkNvcmUvZG9tL0RvY3VtZW50LmgKQEAgLTc1LDYgKzc1LDcgQEAgY2xhc3MgRWxlbWVudDsKIGNs YXNzIEVudGl0eVJlZmVyZW5jZTsKIGNsYXNzIEV2ZW50OwogY2xhc3MgRXZlbnRMaXN0ZW5lcjsK K2NsYXNzIEV2ZW50UXVldWU7CiBjbGFzcyBGcmFtZTsKIGNsYXNzIEZyYW1lVmlldzsKIGNsYXNz IEhUTUxDYW52YXNFbGVtZW50OwpAQCAtMTAxNiwxMCArMTAxNywxMSBAQCBwdWJsaWM6CiAgICAg Ym9vbCBjb250YWluc1ZhbGlkaXR5U3R5bGVSdWxlcygpIGNvbnN0IHsgcmV0dXJuIG1fY29udGFp bnNWYWxpZGl0eVN0eWxlUnVsZXM7IH0KICAgICB2b2lkIHNldENvbnRhaW5zVmFsaWRpdHlTdHls ZVJ1bGVzKCkgeyBtX2NvbnRhaW5zVmFsaWRpdHlTdHlsZVJ1bGVzID0gdHJ1ZTsgfQogCi0gICAg dm9pZCBlbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQgZW5xdWV1ZVdp bmRvd0V2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+KTsKICAgICB2b2lkIGVucXVldWVQYWdlc2hvd0V2 ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0ZW5jZSk7CiAgICAgdm9pZCBlbnF1ZXVlSGFzaGNoYW5n ZUV2ZW50KGNvbnN0IFN0cmluZyYgb2xkVVJMLCBjb25zdCBTdHJpbmcmIG5ld1VSTCk7CiAgICAg dm9pZCBlbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1 ZT4gc3RhdGVPYmplY3QpOworICAgIEV2ZW50UXVldWUqIGV2ZW50UXVldWUoKSBjb25zdCB7IHJl dHVybiBtX2V2ZW50UXVldWUuZ2V0KCk7IH0KIAogICAgIHZvaWQgYWRkTWVkaWFDYW5TdGFydExp c3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwogICAgIHZvaWQgcmVtb3ZlTWVkaWFDYW5T dGFydExpc3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwpAQCAtMTExNiw4ICsxMTE4LDYg QEAgcHJpdmF0ZToKIAogICAgIHZvaWQgY3JlYXRlU3R5bGVTZWxlY3RvcigpOwogCi0gICAgdm9p ZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopOwotCiAgICAgUGFzc1Jl ZlB0cjxOb2RlTGlzdD4gaGFuZGxlWmVyb1BhZGRpbmcoY29uc3QgSGl0VGVzdFJlcXVlc3QmLCBI aXRUZXN0UmVzdWx0JikgY29uc3Q7CiAKICAgICB2b2lkIGxvYWRFdmVudERlbGF5VGltZXJGaXJl ZChUaW1lcjxEb2N1bWVudD4qKTsKQEAgLTEzMzksOSArMTMzOSw4IEBAIHByaXZhdGU6CiAjZW5k aWYKIAogICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwotCi0gICAgVGltZXI8RG9jdW1lbnQ+ IG1fcGVuZGluZ0V2ZW50VGltZXI7Ci0gICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3BlbmRp bmdFdmVudFF1ZXVlOworICAgIAorICAgIE93blB0cjxFdmVudFF1ZXVlPiBtX2V2ZW50UXVldWU7 CiAKICNpZiBFTkFCTEUoV01MKQogICAgIGJvb2wgbV9jb250YWluc1dNTENvbnRlbnQ7CmRpZmYg LS1naXQgYS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVl dWUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjJjMTFhY2RjZmYzNzFjMzdkMDY5YzNhMzM3ZjdkYmMxZTAwYTk1 NjIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcApAQCAtMCww ICsxLDg5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBSaWdo dHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6 CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAq IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAi RXZlbnRRdWV1ZS5oIgorCisjaW5jbHVkZSAiRE9NV2luZG93LmgiCisjaW5jbHVkZSAiRG9jdW1l bnQuaCIKKyNpbmNsdWRlICJFdmVudC5oIgorI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitFdmVudFF1ZXVlOjpFdmVudFF1ZXVlKCkKKyAgICA6IG1fcGVu ZGluZ0V2ZW50VGltZXIodGhpcywgJkV2ZW50UXVldWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQp Cit7Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+ IGV2ZW50KQoreworICAgIEFTU0VSVChldmVudC0+dGFyZ2V0KCktPnRvTm9kZSgpIHx8IGV2ZW50 LT50YXJnZXQoKS0+dG9ET01XaW5kb3coKSk7CisgICAgbV9xdWV1ZWRFdmVudHMuYXBwZW5kKGV2 ZW50KTsKKyAgICAKKyAgICBpZiAoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUoKSkKKyAg ICAgICAgbV9wZW5kaW5nRXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgRXZl bnRRdWV1ZTo6ZW5xdWV1ZVNjcm9sbEV2ZW50KFBhc3NSZWZQdHI8Tm9kZT4gdGFyZ2V0LCBTY3Jv bGxFdmVudFRhcmdldFR5cGUgdGFyZ2V0VHlwZSkKK3sKKyAgICBpZiAoIW1fbm9kZXNXaXRoUXVl dWVkU2Nyb2xsRXZlbnRzLmFkZCh0YXJnZXQuZ2V0KCkpLnNlY29uZCkKKyAgICAgICAgcmV0dXJu OworCisgICAgLy8gUGVyIHRoZSBXM0MgQ1NTT00gVmlldyBNb2R1bGUsIHNjcm9sbCBldmVudHMg ZmlyZWQgYXQgdGhlIGRvY3VtZW50IHNob3VsZCBidWJibGUsIG90aGVycyBzaG91bGQgbm90Lgor ICAgIGJvb2wgY2FuQnViYmxlID0gdGFyZ2V0VHlwZSA9PSBTY3JvbGxFdmVudERvY3VtZW50VGFy Z2V0ID8gdHJ1ZSA6IGZhbHNlOworICAgIFJlZlB0cjxFdmVudD4gc2Nyb2xsRXZlbnQgPSBFdmVu dDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgY2FuQnViYmxlLCBmYWxzZSAvKiBu b24gY2FuY2VsbGVhYmxlICovKTsKKyAgICBzY3JvbGxFdmVudC0+c2V0VGFyZ2V0KHRhcmdldCk7 CisgICAgZW5xdWV1ZUV2ZW50KHNjcm9sbEV2ZW50LnJlbGVhc2UoKSk7Cit9CisKK3ZvaWQgRXZl bnRRdWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopCit7Cisg ICAgQVNTRVJUKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpOworCisgICAgVmVjdG9y PFJlZlB0cjxFdmVudD4gPiBxdWV1ZWRFdmVudHM7CisgICAgcXVldWVkRXZlbnRzLnN3YXAobV9x dWV1ZWRFdmVudHMpOworCisgICAgbV9ub2Rlc1dpdGhRdWV1ZWRTY3JvbGxFdmVudHMuY2xlYXIo KTsKKyAgICAKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHF1ZXVlZEV2ZW50cy5zaXplKCk7 IGkrKykKKyAgICAgICAgZGlzcGF0Y2hFdmVudChxdWV1ZWRFdmVudHNbaV0ucmVsZWFzZSgpKTsK K30KKwordm9pZCBFdmVudFF1ZXVlOjpkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2 ZW50KQoreworICAgIEV2ZW50VGFyZ2V0KiBldmVudFRhcmdldCA9IGV2ZW50LT50YXJnZXQoKTsK KyAgICBpZiAoZXZlbnRUYXJnZXQtPnRvTm9kZSgpKSB7CisgICAgICAgIGlmICghZXZlbnRUYXJn ZXQtPnRvTm9kZSgpLT5pbkRvY3VtZW50KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAg IGV2ZW50VGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50KTsKKyAgICB9CisgICAgCisgICAgaWYg KGV2ZW50VGFyZ2V0LT50b0RPTVdpbmRvdygpKQorICAgICAgICBldmVudFRhcmdldC0+dG9ET01X aW5kb3coKS0+ZGlzcGF0Y2hFdmVudChldmVudCwgMCk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1dl YkNvcmUvZG9tL0V2ZW50UXVldWUuaCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi4wNDY0ZTZhNDM0MzAwNDBlM2QwMzE4ZWMzMjZmODIyOGNlMzA0ZGY5Ci0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVS LCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIs IElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisg KiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisg KgorICovCisKKyNpZm5kZWYgRXZlbnRRdWV1ZV9oCisjZGVmaW5lIEV2ZW50UXVldWVfaAorCisj aW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgorI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworY2xhc3MgRXZlbnQ7CitjbGFzcyBOb2RlOworCitjbGFzcyBFdmVudFF1ZXVlIHsKK3B1 YmxpYzoKKyAgICBlbnVtIFNjcm9sbEV2ZW50VGFyZ2V0VHlwZSB7CisgICAgICAgIFNjcm9sbEV2 ZW50RG9jdW1lbnRUYXJnZXQsCisgICAgICAgIFNjcm9sbEV2ZW50RWxlbWVudFRhcmdldAorICAg IH07CisKKyAgICBFdmVudFF1ZXVlKCk7CisKKyAgICB2b2lkIGVucXVldWVFdmVudChQYXNzUmVm UHRyPEV2ZW50Pik7CisgICAgdm9pZCBlbnF1ZXVlU2Nyb2xsRXZlbnQoUGFzc1JlZlB0cjxOb2Rl PiwgU2Nyb2xsRXZlbnRUYXJnZXRUeXBlKTsKKworcHJpdmF0ZToKKyAgICB2b2lkIHBlbmRpbmdF dmVudFRpbWVyRmlyZWQoVGltZXI8RXZlbnRRdWV1ZT4qKTsKKyAgICB2b2lkIGRpc3BhdGNoRXZl bnQoUGFzc1JlZlB0cjxFdmVudD4pOworCisgICAgVGltZXI8RXZlbnRRdWV1ZT4gbV9wZW5kaW5n RXZlbnRUaW1lcjsKKyAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IG1fcXVldWVkRXZlbnRzOwor ICAgIEhhc2hTZXQ8Tm9kZSo+IG1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRzOworfTsKKwor fQorCisjZW5kaWYgLy8gRXZlbnRRdWV1ZV9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Ob2Rl LmNwcCBiL1dlYkNvcmUvZG9tL05vZGUuY3BwCmluZGV4IGU3MWM0YmRmZTA5ZjE3N2IzZTY1ZGVm ZWI0Yjc5NTYzMzk2MTQ3N2IuLjAwNWIwZWViM2M1YTFhOWY4NWQ4Y2I3ZTBkYmY5YzhlMzE3ZTQ0 ZTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGUuY3BwCisrKyBiL1dlYkNvcmUvZG9tL05v ZGUuY3BwCkBAIC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5j bHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRl ICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2Uv RXZlbnRIYW5kbGVyLmNwcCBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IGY2 YTIzNTM4MTVmNjFhZGJkMWRjNDE4MTAwNWUyNWNhMDc2YmFiYTEuLjgyYzdlN2U1OGNjYTcyMTZl NjE5ZWE1ZjZkY2M0Y2IwMzdkMjkxZTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9FdmVudEhh bmRsZXIuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0zNiw2ICsz Niw3IEBACiAjaW5jbHVkZSAiRHJhZ0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJFZGl0b3IuaCIK ICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCisjaW5jbHVkZSAiRXZlbnRRdWV1ZS5oIgogI2luY2x1 ZGUgIkZsb2F0UG9pbnQuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGb2N1 c0NvbnRyb2xsZXIuaCIKQEAgLTI3NTcsNyArMjc1OCw3IEBAIHZvaWQgRXZlbnRIYW5kbGVyOjpz ZW5kU2Nyb2xsRXZlbnQoKQogewogICAgIHNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIoKTsKICAg ICBpZiAobV9mcmFtZS0+dmlldygpICYmIG1fZnJhbWUtPmRvY3VtZW50KCkpCi0gICAgICAgIG1f ZnJhbWUtPmRvY3VtZW50KCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkuc2Nyb2xsRXZlbnQsIHRydWUsIGZhbHNlKSk7CisgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50 KCktPmV2ZW50UXVldWUoKS0+ZW5xdWV1ZVNjcm9sbEV2ZW50KG1fZnJhbWUtPmRvY3VtZW50KCks IEV2ZW50UXVldWU6OlNjcm9sbEV2ZW50RG9jdW1lbnRUYXJnZXQpOwogfQogCiB2b2lkIEV2ZW50 SGFuZGxlcjo6c2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXll ci5jcHAKaW5kZXggN2I5MDAwYzY1NTNhMjQ2MjVhMDBiNjY2NjFiODg0M2QwMjc2MWY4Yi4uMTdm NTEzNmQ3MzNkYmQ5MmY0NWFlZDUxOTg5MWNiMzM5Zjk2NTU4OSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxheWVyLmNwcApAQCAtNTEsNyArNTEsNyBAQAogI2luY2x1ZGUgIkNocm9tZS5oIgogI2luY2x1 ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0jaW5jbHVkZSAiRXZl bnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJGbG9hdFBvaW50 M0QuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIu aCIKQEAgLTEzOTcsMTAgKzEzOTcsNyBAQCB2b2lkIFJlbmRlckxheWVyOjpzY3JvbGxUb09mZnNl dChpbnQgeCwgaW50IHksIGJvb2wgdXBkYXRlU2Nyb2xsYmFycywgYm9vbCByZXBhaQogICAgIH0K IAogICAgIC8vIFNjaGVkdWxlIHRoZSBzY3JvbGwgRE9NIGV2ZW50LgotICAgIGlmICh2aWV3KSB7 Ci0gICAgICAgIGlmIChGcmFtZVZpZXcqIGZyYW1lVmlldyA9IHZpZXctPmZyYW1lVmlldygpKQot ICAgICAgICAgICAgZnJhbWVWaWV3LT5zY2hlZHVsZUV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnRO YW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpLCByZW5kZXJlcigpLT5ub2RlKCkpOwot ICAgIH0KKyAgICByZW5kZXJlcigpLT5ub2RlKCktPmRvY3VtZW50KCktPmV2ZW50UXVldWUoKS0+ ZW5xdWV1ZVNjcm9sbEV2ZW50KHJlbmRlcmVyKCktPm5vZGUoKSwgRXZlbnRRdWV1ZTo6U2Nyb2xs RXZlbnRFbGVtZW50VGFyZ2V0KTsKIH0KIAogdm9pZCBSZW5kZXJMYXllcjo6c2Nyb2xsUmVjdFRv VmlzaWJsZShjb25zdCBJbnRSZWN0JiByZWN0LCBib29sIHNjcm9sbFRvQW5jaG9yLCBjb25zdCBT Y3JvbGxBbGlnbm1lbnQmIGFsaWduWCwgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnblkpCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcCBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCmluZGV4IDUzMmM1NTEyZDc4YjQ5NWY3MmVmMzM5 YjBmZjZkNzhmNDdkNTI0ZTEuLmVlNGQyY2Q0ODFkMTlmZjM3M2FkMzhmOWEzNGZhN2FkOGFlZTJh OTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCisrKyBi L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCkBAIC0zNiw3ICszNiw3IEBACiAj aW5jbHVkZSAiQ1NTU3R5bGVTZWxlY3Rvci5oIgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5j bHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0jaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUg IkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJG cmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgpAQCAtNTQwLDcgKzU0MCw3IEBAIHZvaWQg UmVuZGVyTGlzdEJveDo6dmFsdWVDaGFuZ2VkKFNjcm9sbGJhciopCiAgICAgaWYgKG5ld09mZnNl dCAhPSBtX2luZGV4T2Zmc2V0KSB7CiAgICAgICAgIG1faW5kZXhPZmZzZXQgPSBuZXdPZmZzZXQ7 CiAgICAgICAgIHJlcGFpbnQoKTsKLSAgICAgICAgbm9kZSgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50 OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKKyAgICAg ICAgbm9kZSgpLT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChu b2RlKCksIEV2ZW50UXVldWU6OlNjcm9sbEV2ZW50RWxlbWVudFRhcmdldCk7CiAgICAgfQogfQog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHAKaW5kZXggNTgzM2M1 OWYwNDYyZDliMzA3YWNlZTgxZGU2MTlhOGM2ZDJjYWI0ZC4uNWNlNTZjNjMzZDE5MTA0YWUxZDdk Y2VkMmFlY2RhZWU0MTVkNzFkOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VF dmVudERpc3BhdGNoZXIuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlRXZlbnREaXNw YXRjaGVyLmNwcApAQCAtNTgsNyArNTgsNyBAQCB2b2lkIFN0b3JhZ2VFdmVudERpc3BhdGNoZXI6 OmRpc3BhdGNoKGNvbnN0IFN0cmluZyYga2V5LCBjb25zdCBTdHJpbmcmIG9sZFZhbHVlLAogICAg ICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAgICAgICBTdG9yYWdlKiBzdG9y YWdlID0gZnJhbWVzW2ldLT5kb21XaW5kb3coKS0+c2Vzc2lvblN0b3JhZ2UoZWMpOwogICAgICAg ICAgICAgaWYgKCFlYykKLSAgICAgICAgICAgICAgICBmcmFtZXNbaV0tPmRvY3VtZW50KCktPmVu cXVldWVFdmVudChTdG9yYWdlRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc3RvcmFnZUV2ZW50 LCBrZXksIG9sZFZhbHVlLCBuZXdWYWx1ZSwgc291cmNlRnJhbWUtPmRvY3VtZW50KCktPnVybCgp LCBzdG9yYWdlKSk7CisgICAgICAgICAgICAgICAgZnJhbWVzW2ldLT5kb2N1bWVudCgpLT5lbnF1 ZXVlV2luZG93RXZlbnQoU3RvcmFnZUV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnN0b3JhZ2VF dmVudCwga2V5LCBvbGRWYWx1ZSwgbmV3VmFsdWUsIHNvdXJjZUZyYW1lLT5kb2N1bWVudCgpLT51 cmwoKSwgc3RvcmFnZSkpOwogICAgICAgICB9CiAgICAgfSBlbHNlIHsKICAgICAgICAgLy8gU2Vu ZCBldmVudHMgdG8gZXZlcnkgcGFnZS4KQEAgLTc1LDcgKzc1LDcgQEAgdm9pZCBTdG9yYWdlRXZl bnREaXNwYXRjaGVyOjpkaXNwYXRjaChjb25zdCBTdHJpbmcmIGtleSwgY29uc3QgU3RyaW5nJiBv bGRWYWx1ZSwKICAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgICAgICAgICAg U3RvcmFnZSogc3RvcmFnZSA9IGZyYW1lc1tpXS0+ZG9tV2luZG93KCktPmxvY2FsU3RvcmFnZShl Yyk7CiAgICAgICAgICAgICBpZiAoIWVjKQotICAgICAgICAgICAgICAgIGZyYW1lc1tpXS0+ZG9j dW1lbnQoKS0+ZW5xdWV1ZUV2ZW50KFN0b3JhZ2VFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5z dG9yYWdlRXZlbnQsIGtleSwgb2xkVmFsdWUsIG5ld1ZhbHVlLCBzb3VyY2VGcmFtZS0+ZG9jdW1l bnQoKS0+dXJsKCksIHN0b3JhZ2UpKTsKKyAgICAgICAgICAgICAgICBmcmFtZXNbaV0tPmRvY3Vt ZW50KCktPmVucXVldWVXaW5kb3dFdmVudChTdG9yYWdlRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkuc3RvcmFnZUV2ZW50LCBrZXksIG9sZFZhbHVlLCBuZXdWYWx1ZSwgc291cmNlRnJhbWUtPmRv Y3VtZW50KCktPnVybCgpLCBzdG9yYWdlKSk7CiAgICAgICAgIH0KICAgICB9CiB9Cg== 74027 2010-11-16 12:55:13 -0800 2010-12-14 15:30:35 -0800 Patch bug-45631-20101116125512.patch text/plain 48732 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4MjYzMzU1YzcxMzg0NmExOTcxZjFkZGFmNTE4YWE1NTIxNWFiYTkwLi4yYTk5MzY0 ZWE2NTE3MWNjZDhjZDFjMDA5MTMyM2ZjNDU2OGFkYjY5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMTEtMTUgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuCisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93 bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAt ZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6IEFkZGVkLiBEb2VzIHRoZSBzYW1lCisg ICAgICAgICAgICB0ZXN0cyBhcyBmaXJlLXNjcm9sbC1ldmVudC5odG1sLCBidXQgb24gYW4gaW5k aXZpZHVhbCBlbGVtZW50IGluc3RlYWQKKyAgICAgICAgICAgIG9mIHRoZSB3aG9sZSBkb2N1bWVu dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQ6 CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbDogTm93IGV4cGxp Y2l0bHkgdGVzdHMgZm9yCisgICAgICAgICAgICBzeW5jaHJvbm91cyBiZWhhdmlvciB3aGVuIHNj cm9sbGluZyB0aGUgZG9jdW1lbnQsIGFuZCB0aGF0IHdlIGRvbid0CisgICAgICAgICAgICBmaXJl IHRoZSBldmVudCBtb3JlIHRoYW4gb25jZS4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9yZW1vdmUt Y2hpbGQtb25zY3JvbGwuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5n LXpvb20tY2hhbmdlLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sOiBBZGRlZC4gQ2hlY2tzIHRoYXQgd2UgY2FuIGxpc3RlbgorICAgICAg ICAgICAgZm9yIHNjcm9sbCBldmVudHMgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlLgorICAgICAgICAqIGZhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRt bDoKKyAgICAgICAgKiBmYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbDoKKyAgICAgICAgKiBmYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWw6 CisKIDIwMTAtMTEtMTYgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgVW5yZXZpZXdlZCBDaHJvbWl1bSBleHBlY3RhdGlvbnMgdXBkYXRlLgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxz LWV4cGVjdGVkLnR4dAppbmRleCAyNGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNk NjY0Li5iNWIwY2YwZjU0NmMyZTQxZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVk LnR4dAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxz LWV4cGVjdGVkLnR4dApAQCAtMSw0ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhp dHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNo b3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJl cyBEUlQgdG8gcGFzcy4KK1RoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBw YWdlIGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0 bHkgb25lIHNjcm9sbCBldmVudC4gSWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMg bm93LgogUEFTUwogKGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZj ODNiMTQ4MjNkMmVkNzBkYjMyNTAwODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEy MjdjMWM5Mzg2ZmQ5ZjQ5YjQ2YmEyNWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1s PgogPGhlYWQ+CiA8c2NyaXB0PgotaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgp OworfQogCi1mdW5jdGlvbiBzY3IoKQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1 bmN0aW9uKCkgewogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQg Kz0gJ3gnOworCisgICAgc3dpdGNoIChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAo d2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFn ZVVwJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAg c3RlcCsrOwogfQogCiBmdW5jdGlvbiBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVu dFNlbmRlcikKLSAgICAgICAgcmV0dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIo J3Njcm9sbCcsIHNjciwgZmFsc2UpOwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURv d24iKTsKLSAgICB2YXIgdGV4dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5l clRleHQ7Ci0gICAgaWYgKHRleHQgIT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBj b250YWluIHgsIG5vdCAiICsgdGV4dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VV cCIpOwotICAgIHZhciB0ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVy VGV4dDsKLSAgICBpZiAodGV4dCAhPSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBj b250YWluIHh4LCBub3QgIiArIHRleHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi cmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVy KQorICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+ CiA8L2hlYWQ+CiA8Ym9keSBvbmxvYWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5 bGU9InBvc2l0aW9uOmZpeGVkIj48L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhp dHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNo b3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJl cyBEUlQgdG8gcGFzcy48L2Rpdj4KKzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBh Z2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2Vu ZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVz cyB0aGUga2V5cyBub3cuPC9kaXY+CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2 IHN0eWxlPSJoZWlnaHQ6NTAwMDBweCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwv ZGl2PiAKIDxzY3JpcHQ+IApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmly ZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5j ZmU2YTU2ZjkwMmEwZGFmY2M1ZmU5MTc3ZTYyOTZkMTM4ZjY0YjMzCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSwxMSBAQAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBldmVudCBm aXJlcyBvbiBlbGVtZW50cyBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworCitTY3JvbGwgZXZlbnQgYnViYmxlczogZmFsc2UKK1BBU1Mg U2Nyb2xsIHBvc2l0aW9uOiAoMCwgMjAwKQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1 ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43Yzk4YmFkNTM0OWU3 Y2Q2ZGMxZTA2MWIyYWYyZWU4YjQ4YmNjNjRmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEs NTEgQEAKKzxodG1sPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10 ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgor PGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVy ZmxvdzogYXV0bzsgd2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0i aGVpZ2h0OiA1MDAwcHg7IHdpZHRoOiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPHNjcmlwdD4K K2Rlc2NyaXB0aW9uKCdDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIGVsZW1l bnRzIGFzeWNocm9ub3VzbHkgYW5kIG9ubHkgb25jZS4nKTsKKwordmFyIGV2ZW50Q291bnQgPSAw OwordmFyIGRvbmVUaW1lb3V0OworCitmdW5jdGlvbiBzY3JvbGxIYW5kbGVyKGV2ZW50KQorewor ICAgIGV2ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIGRl YnVnKCdTY3JvbGwgZXZlbnQgYnViYmxlczogJyArIGV2ZW50LmJ1YmJsZXMpOworICAgICAgICB2 YXIgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAg ICAgICB2YXIgc2Nyb2xsWCA9IGNvbnRhaW5lci5zY3JvbGxMZWZ0OworICAgICAgICB2YXIgc2Ny b2xsWSA9IGNvbnRhaW5lci5zY3JvbGxUb3A7CisgICAgICAgIHRlc3RQYXNzZWQoJ1Njcm9sbCBw b3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyArIHNjcm9sbFkgKyAnKScpOworICAgICAgICAv LyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFu b3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1l b3V0KGZpbmlzaEpTVGVzdCwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBjbGVhclRpbWVv dXQoZG9uZVRpbWVvdXQpOworICAgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwgaGFuZGxlciB3YXMg aW52b2tlZCAnICsgZXZlbnRDb3VudCArICcgdGltZXMnKTsKKyAgICAgICAgZmluaXNoSlNUZXN0 KCk7CisgICAgfQorfQorCitvbmxvYWQgPSBmdW5jdGlvbigpCit7CisgICAgdmFyIGNvbnRhaW5l ciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb250YWluZXInKTsKKyAgICBjb250YWluZXIu YWRkRXZlbnRMaXN0ZW5lcignc2Nyb2xsJywgc2Nyb2xsSGFuZGxlciwgZmFsc2UpOworICAgIGNv bnRhaW5lci5zY3JvbGxUb3AgPSAxMDA7CisgICAgaWYgKGV2ZW50Q291bnQgPiAwKSB7CisgICAg ICB0ZXN0RmFpbGVkKCdTY3JvbGwgZXZlbnQgZmlyZWQgc3luY2hyb25vdXNseScpOworICAgICAg ZmluaXNoSlNUZXN0KCk7CisgICAgfQorICAgIGNvbnRhaW5lci5zY3JvbGxUb3AgPSAyMDA7Cit9 CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwordmFyIGpzVGVzdElzQXN5bmMgPSB0 cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2Yg ZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZXhwZWN0ZWQudHh0CmluZGV4IDE2ODZjZWQzOWFlMmJlMmQ1OWI2M2U5ZDNmZGFlNGIxZTJj ODg2NTYuLmU3NjY2Njk1YmM2MzBlMjUyOTk4MmExMzVmMTI5NzE0NzQwNjkyNDMgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3Rl ZC50eHQKQEAgLTEsNTkgKzEsMTEgQEAKLVBBU1NFRAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBl dmVudCBmaXJlcyBvbiB0aGUgZG9jdW1lbnQgYXN5Y2hyb25vdXNseSBhbmQgb25seSBvbmNlLgog Ci1JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRl c3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwg ZXZlbnQgZGlkIG5vdCBmaXJlLgorT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9m ICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCisKK1Njcm9sbCBldmVudCBi dWJibGVzOiB0cnVlCitQQVNTIFNjcm9sbCBwb3NpdGlvbjogKDIwMCwgMjAwKQorUEFTUyBzdWNj ZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwgYi9MYXlvdXRUZXN0 cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCmluZGV4IGEwNTZjMDY3YmQ5ZjI3 YzRiMzQ2NWM4NGExNmUyMWE5ZmEzZTcxNGMuLjkyMjQ3MGEyMzE0ZGU4Zjc5MzljNjFlMmE2YjAy OTA0ZDk5YWRkZWYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Ny b2xsLWV2ZW50Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwt ZXZlbnQuaHRtbApAQCAtMSwzMCArMSw0NSBAQAogPGh0bWw+Cis8bGluayByZWw9InN0eWxlc2hl ZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNy Yz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxib2R5IHN0eWxl PSJtaW4td2lkdGg6IDUwMDBweDsgbWluLWhlaWdodDogNTAwMHB4Ij4KKzxwIGlkPSJkZXNjcmlw dGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CiA8c2NyaXB0PgotdmFyIGV2ZW50 RmlyZWQgPSBmYWxzZTsKK2Rlc2NyaXB0aW9uKCdDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50 IGZpcmVzIG9uIHRoZSBkb2N1bWVudCBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuJyk7CiAK LWZ1bmN0aW9uIHNjcm9sbGVyKCkgewotICAgIGlmICghZXZlbnRGaXJlZCkgewotICAgICAgICBl dmVudEZpcmVkID0gdHJ1ZTsKLSAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhc3Nl ZCIpLmlubmVySFRNTCA9ICI8cCBzdHlsZT0nY29sb3I6cmVkJz5QQVNTRUQ8L3A+IjsKK3ZhciBl dmVudENvdW50ID0gMDsKK3ZhciBkb25lVGltZW91dDsKKworb25zY3JvbGwgPSBmdW5jdGlvbihl dmVudCkKK3sKKyAgICBldmVudENvdW50Kys7CisgICAgaWYgKGV2ZW50Q291bnQgPT0gMSkgewor ICAgICAgICBkZWJ1ZygnU2Nyb2xsIGV2ZW50IGJ1YmJsZXM6ICcgKyBldmVudC5idWJibGVzKTsK KyAgICAgICAgdmFyIHNjcm9sbFggPSBkb2N1bWVudC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAg IHZhciBzY3JvbGxZID0gZG9jdW1lbnQuYm9keS5zY3JvbGxUb3A7CisgICAgICAgIHRlc3RQYXNz ZWQoJ1Njcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxYICsgJywgJyArIHNjcm9sbFkgKyAnKScp OworICAgICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2Fz ZSB0aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVv dXQgPSBzZXRUaW1lb3V0KGZpbmlzaEpTVGVzdCwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAg ICBjbGVhclRpbWVvdXQoZG9uZVRpbWVvdXQpOworICAgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwg aGFuZGxlciB3YXMgaW52b2tlZCAnICsgZXZlbnRDb3VudCArICcgdGltZXMnKTsKKyAgICAgICAg ZmluaXNoSlNUZXN0KCk7CiAgICAgfQogfQogCi13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7 Ci0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7 Ci0gICAgd2luZG93LnNjcm9sbFRvKDUwMCwgNTAwKTsKLSAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKSB7Ci0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKK29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDAp OworICAgIGlmIChldmVudENvdW50ID4gMCkgeworICAgICAgdGVzdEZhaWxlZCgnU2Nyb2xsIGV2 ZW50IGZpcmVkIHN5bmNocm9ub3VzbHknKTsKKyAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0K KyAgICB3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOwogfQogCit2YXIgc3VjY2Vzc2Z1bGx5UGFy c2VkID0gdHJ1ZTsKK3ZhciBqc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKIDwvc2NyaXB0PgotPGJvZHk+ Ci08ZGl2IGlkPSJwYXNzZWQiPjwvZGl2PgotCi08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2Vz IG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3Qg ZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KLQot YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgorPHNjcmlwdCBz cmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5Pgog PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZXZlbnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sIGIvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZl NTAyMjc4ZDM2ZWYxOGUwNzFmY2IzNjU0Y2MzNS4uZWFiYjA3OWVhY2FhNzliODhlMGYwYWFkYTcw MTk1ZGUzOGIzNjNiOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3Zl LWNoaWxkLW9uc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3Zl LWNoaWxkLW9uc2Nyb2xsLmh0bWwKQEAgLTksMTcgKzksMjggQEAKICAgICAgICAgICAgIGZ1bmN0 aW9uIGRpc3BhdGNoU2Nyb2xsRXZlbnRzKCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAg ICBpZiAod2luZG93LmV2ZW50U2VuZGVyICYmIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg eworICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25l KCk7CiAgICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAw KTsKICAgICAgICAgICAgICAgICAgICAgZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7 Ci0gICAgICAgICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsK LSAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwor ICAgICAgICAgICAgICAgICAgICB2YXIgc2Nyb2xsQ291bnQgPSAwOworICAgICAgICAgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHYnKS5hZGRFdmVudExpc3RlbmVyKAorICAg ICAgICAgICAgICAgICAgICAgICAgJ3Njcm9sbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBm dW5jdGlvbihldmVudCkgeworICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzLnJlbW92ZUNo aWxkKHRoaXMuZmlyc3RDaGlsZCkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgc2Nyb2xsQ291 bnQrKzsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHNjcm9sbENvdW50ID09IDEpCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0x LCAtMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIH0sCisgICAgICAgICAgICAgICAgICAgICAgICBmYWxzZSk7CiAgICAg ICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICA8L3NjcmlwdD4KICAgICA8L2hl YWQ+CiAgICAgPGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygp OycsIDEpOyI+CiAgICAgICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBi ZSByZW1vdmVkIGJ5IHRoZWlyIHBhcmVudCBlbGVtZW50J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxl ci4gIFRoZSB0ZXN0IHN1Y2NlZWRzIGlmIHRoaXMgaXMgdGhlIG9ubHkgdGV4dCByZW1haW5pbmcg YWZ0ZXIgdGhlIHR3byBzY3JvbGwgZXZlbnRzIGFyZSBkaXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFp bHMgaWYgdGhlIGlubmVyIGRpdiByZW1haW5zIGluIHRoZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNy YXNoZXMuPGJyPjxicj4KLSAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0 bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNj cm9sbD0idGhpcy5yZW1vdmVDaGlsZCh0aGlzLmZpcnN0Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBp ZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4 OyB3aGl0ZXNwYWNlOiBub3dyYXA7Ij4KICAgICAgICAgPGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7 IGhlaWdodDozMDBweCI+TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFk aXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9y ZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmltIGFkIG1pbmltIHZlbmlhbSwgcXVpcyBu b3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9yaXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVh IGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJp dCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0gZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBw YXJpYXR1ci4gRXhjZXB0ZXVyIHNpbnQgb2NjYWVjYXQgY3VwaWRhdGF0IG5vbiBwcm9pZGVudCwg c3VudCBpbiBjdWxwYSBxdWkgb2ZmaWNpYSBkZXNlcnVudCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFi b3J1bQogICAgICAgICA8L2Rpdj4KICAgICAgICAgPC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwKaW5kZXggNGZj MTUyODRkZWYxZjU4ZDkzNzM1ZmFjYWRlNGE1NmQ3MTBkNTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4 MjUzM2FjYjA0NDJhOTJjZTcyNzFmZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVu dHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZXZlbnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbApAQCAtMTYsNiArMTYsOSBAQAog ICAgIGZ1bmN0aW9uIHNjcm9sbGVkKGV2ZW50KQogICAgIHsKICAgICAgICAgZXZlbnQudGFyZ2V0 LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZXZlbnQudGFyZ2V0KTsKKyAgICAgICAgaWYgKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CiAgICAgfQogCiAgICAgZnVuY3Rpb24gdGVzdCgp CkBAIC0yNyw3ICszMCw5IEBACiAgICAgICAgIGRvY3VtZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7 CiAgICAgfQogCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOworICAgIH0KICAgICB0ZXN0KCk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbApp bmRleCAyMjJhZGE4MDVkYTUzMDYyMmU0ZjgxZjViZGNlZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3 NDMzZGU4YWJlZTZmMzY3MTUxZTUyMDNlMmVlZDQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0x LDExICsxLDIyIEBACiA8aHRtbD4KIDxzY3JpcHQ+Cit2YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBm YWxzZTsKK3ZhciBkb25lVGltZW91dDsKKwogZnVuY3Rpb24gd2luZG93U2Nyb2xsZWQoKSB7Cisg ICAgd2luZG93V2FzU2Nyb2xsZWQgPSB0cnVlOwogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnRkFJTFVSRTogd2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxs ZWQuJzsgCisgICAgY2xlYXJUaW1lb3V0KGRvbmVUaW1lb3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9u IGRpdlNjcm9sbGVkKCkgewotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5p bm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xsIHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cu b25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICBpZiAoIXdpbmRvd1dhc1Njcm9sbGVkKQorICAgICAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6 IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2luZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsg CisgICAgLy8gRG9uJ3QgY2FsbCBub3RpZnlEb25lIHN0cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhl cmUncyBhbm90aGVyIHNjcm9sbCBldmVudCBjb21pbmcvYnViYmxpbmcuCisgICAgZG9uZVRpbWVv dXQgPSBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9u ZSgpOworICAgICAgICB9LCAxMDApOyAgICAKIH0KIAogZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAg LTI0LDEwICszNSw2IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKSB7CiAgICAgCiAgICAgLy8gRG9uJ3Qg cG9sbHV0ZSB0aGUgdGVzdCByZXN1bHQgd2l0aCBub25zZW5zZS4KICAgICBkaXYuaW5uZXJIVE1M ID0gJyc7Ci0gICAgCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgCi0gICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKLSAgICAKIH0KIAogPC9zY3Jp cHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhh c2UtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBo YXNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zZTk0YTMwZDdkODc2ODE2N2Y4OWE3NGE1NWU1 Y2I5ZjE2M2ZjNGViCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv c2Nyb2xsLWV2ZW50LXBoYXNlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUZXN0cyB0 aGF0IHdlIGNhbiBsaXN0ZW4gZm9yIHNjcm9sbCBldmVudHMgb24gdGhlIGRvY3VtZW50IGluIGJv dGggdGhlIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFzZXMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCitCb3RoIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFzZSBsaXN0ZW5lcnMgd2VyZSBp bnZva2VkLgorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRF CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFz ZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uYzBjZTVjMDJlMmFlMWQxZjJlZTE3YmYwMmIzYTU5NWNlMWQwODM4MAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFz ZS5odG1sCkBAIC0wLDAgKzEsNDUgQEAKKzxodG1sPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBo cmVmPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8Ym9keSBzdHlsZT0ibWlu LWhlaWdodDogMjAwMHB4Ij4gCis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNv bnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CitkZXNjcmlw dGlvbignVGVzdHMgdGhhdCB3ZSBjYW4gbGlzdGVuIGZvciBzY3JvbGwgZXZlbnRzIG9uIHRoZSBk b2N1bWVudCBpbiBib3RoIHRoZSBjYXB0dXJlIGFuZCBidWJibGUgcGhhc2VzLicpOworCit2YXIg dHJpZ2dlcmVkQ2FwdHVyZUxpc3RlbmVyID0gZmFsc2U7Cit2YXIgdHJpZ2dlcmVkQnViYmxlTGlz dGVuZXIgPSBmYWxzZTsKKword2luZG93LmFkZEV2ZW50TGlzdGVuZXIoCisgICAgJ3Njcm9sbCcs CisgICAgZnVuY3Rpb24oKSB7CisgICAgICAgIHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciA9IHRy dWU7CisgICAgICAgIGNoZWNrQ29tcGxldGUoKTsKKyAgICB9LAorICAgIHRydWUpOworCit3aW5k b3cuYWRkRXZlbnRMaXN0ZW5lcigKKyAgICAnc2Nyb2xsJywKKyAgICBmdW5jdGlvbihldmVudCkg eworICAgICAgICB0cmlnZ2VyZWRCdWJibGVMaXN0ZW5lciA9IHRydWU7CisgICAgICAgIGNoZWNr Q29tcGxldGUoKTsKKyAgICB9LAorICAgIGZhbHNlKTsKKworZnVuY3Rpb24gY2hlY2tDb21wbGV0 ZSgpCit7CisgICAgaWYgKHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciAmJiB0cmlnZ2VyZWRCdWJi bGVMaXN0ZW5lcikgeworICAgICAgICBkZWJ1ZygnQm90aCBjYXB0dXJlIGFuZCBidWJibGUgcGhh c2UgbGlzdGVuZXJzIHdlcmUgaW52b2tlZC4nKTsKKyAgICAgICAgZmluaXNoSlNUZXN0KCk7Cisg ICAgfQorfQorCit3aW5kb3cuc2Nyb2xsVG8oMjAwLCAyMDApOworCit2YXIgc3VjY2Vzc2Z1bGx5 UGFyc2VkID0gdHJ1ZTsKK3ZhciBqc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNj cmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3Zl ZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCmluZGV4IGJhMWEzNTE2NGM1NmIyYzQxZWEzODBiZWE3 NjNlN2U0YTFlNTlmOTguLmQyZjlhYzY0NWU3ZDYxYjQ1MDFiMWIyYjhmNTBmYjY2OTU3N2E1NjIg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhh bmRsZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9s bC1oYW5kbGVyLmh0bWwKQEAgLTExLDI5ICsxMSwzMyBAQAogPHA+CiAgICAgUmVzdWx0OiA8c3Bh biBpZD0icmVzdWx0Ij50ZXN0IGRpZCBub3QgY29tcGxldGUuPC9zcGFuPgogPC9wPgotPGRpdiBp ZD0idCIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7 IiBvbnNjcm9sbD0iaWYgKG92ZXJmbG93UmVtb3ZlKSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hp bGQodGhpcyk7Ij4KKzxkaXYgaWQ9InQiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIw MHB4OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGls ZCh0aGlzKTtoYW5kbGVTY3JvbGwoMCk7Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4 OyI+PC9kaXY+CiA8L2Rpdj4KIAotPGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAy MDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAoc2Vjb25kT3ZlcmZsb3dSZW1vdmUp IHRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBzdHlsZT0ib3ZlcmZs b3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBh cmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7aGFuZGxlU2Nyb2xsKDEpOyI+CiAgICAgPGRpdiBz dHlsZT0iaGVpZ2h0OiAyMDBweDsiPjwvZGl2PgogICAgIDxkaXYgaWQ9ImQiPjwvZGl2PgogPC9k aXY+CiAKIDxzY3JpcHQ+Ci0gICAgdmFyIG92ZXJmbG93UmVtb3ZlID0gZmFsc2U7Ci0gICAgdmFy IHNlY29uZE92ZXJmbG93UmVtb3ZlID0gZmFsc2U7CisgICAgdmFyIHNjcm9sbGVkRmlyc3RDb250 YWluZXIgPSBmYWxzZTsKKyAgICB2YXIgc2Nyb2xsZWRTZWNvbmRDb250YWluZXIgPSBmYWxzZTsK IAogICAgIGRvY3VtZW50LmJvZHkub2Zmc2V0VG9wOyB0LnNjcm9sbFRvcCA9IDIwOwogCi0gICAg b3ZlcmZsb3dSZW1vdmUgPSB0cnVlOwotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0Jyku aW5uZXJIVE1MID0gJyc7Ci0KLSAgICBzZWNvbmRPdmVyZmxvd1JlbW92ZSA9IHRydWU7CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2QnKS5zY3JvbGxJbnRvVmlldygpOwogICAgIAotICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7 Ci0KLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgZnVuY3Rpb24gaGFuZGxlU2Nyb2xsKGlu ZGV4KQorICAgIHsKKyAgICAgICAgaWYgKGluZGV4ID09IDApIHNjcm9sbGVkRmlyc3RDb250YWlu ZXIgPSB0cnVlOworICAgICAgICBlbHNlIGlmIChpbmRleCA9PSAxKSBzY3JvbGxlZFNlY29uZENv bnRhaW5lciA9IHRydWU7CisgICAgICAgIAorICAgICAgICBpZiAoc2Nyb2xsZWRGaXJzdENvbnRh aW5lciAmJiBzY3JvbGxlZFNlY29uZENvbnRhaW5lcikgeworICAgICAgICAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVyVGV4dCA9ICJTVUNDRVNTIjsKKyAgICAgICAg CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQorICAg IH0KIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNj cm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93 L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAppbmRleCA2NGIyMGFjNGFlZmRjZDU2 MTRkMmM0OGMwM2U2Y2QyYTMyMmJkNGRlLi4zNTc0MTJmZTIzZmI2NmM1ZGVjMWRhMDU4YWVhNzUy YmUzNjEwNzhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xs LWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93 L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3QuaHRtbApAQCAtMSwxNCArMSwxNiBAQAogPGhl YWQ+CiA8c2NyaXB0PgogZnVuY3Rpb24gdGVzdCgpIHsKLSAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfQogICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJpdCIpLnNjcm9sbFRvcCA9IDEwMDsKIH0KIDwvc2NyaXB0PgogPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgogPHA+VGhpcyB0ZXN0IGludm9sdmVzIGEgbGF5ZXIgdGhhdCBzZWxmLWRl c3RydWN0cyB3aGVuIHNjcm9sbGVkLiBJZiB0aGVyZSdzIG5vIGNyYXNoLCB0aGVuIHRoZSB0ZXN0 IHN1Y2NlZWRlZC48L3A+Ci08ZGl2IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZs b3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlzcGxheSA9ICdub25lJyI+Cis8ZGl2IGlkPSJp dCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUu ZGlzcGxheSA9ICdub25lJztpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ij4KIDxkaXYgc3R5bGU9ImhlaWdodDogMjAwMHB4 OyI+PC9kaXY+CiA8L2Rpdj4KIDwvYm9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv cmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvcmVw YWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAppbmRleCBlM2YwYWM0NGMxOWJjYTVkYmRl MTRkMTM4NzNhMGNkNWYwZWU3MjBjLi5kYzY5NzEyMjE2ZjdiNTE2NjBhZTMyMjRiMmNlZWFlNDYx YjE0NGFhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJp bmctc2Nyb2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVy aW5nLXNjcm9sbC5odG1sCkBAIC0zLDYgKzMsOCBAQAogICAgIDxzY3JpcHQ+CiAgICAgICAgIGZ1 bmN0aW9uIHJlcGFpbnRUZXN0KCkKICAgICAgICAgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgc2Nyb2xsQnkoMCwgMTAwKTsKICAg ICAgICAgfQpAQCAtMTEsNiArMTMsOCBAQAogICAgICAgICB7CiAgICAgICAgICAgICB2YXIgdGFy Z2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgdGFy Z2V0LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICJncmVlbiI7CisgICAgICAgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm5vdGlmeURvbmUoKTsKICAgICAgICAgfQogICAgIDwvc2NyaXB0PgogPC9oZWFkPgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9BbmRyb2lkLm1rIGIvV2ViQ29yZS9BbmRyb2lkLm1rCmluZGV4 IGI2NGUzMmI2ZDg1ZjRhYzYyZjc1MmMwMjNiN2E3ZWUxY2EwNmE0NDQuLmNhMDc0ZWNkZmVkZGFi ZWRkNzRhMGM0MDU5Y2Q5NWNjYzJjOGZiMTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQW5kcm9pZC5t aworKysgYi9XZWJDb3JlL0FuZHJvaWQubWsKQEAgLTEzNSw2ICsxMzUsNyBAQCBMT0NBTF9TUkNf RklMRVMgOj0gJChMT0NBTF9TUkNfRklMRVMpIFwKIAlkb20vRXZlbnRDb250ZXh0LmNwcCBcCiAJ ZG9tL0V2ZW50TmFtZXMuY3BwIFwKIAlkb20vRXZlbnRUYXJnZXQuY3BwIFwKKwlkb20vRXZlbnRR dWV1ZS5jcHAgXAogCWRvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAJZG9tL0V4Y2VwdGlvbkNvZGUu Y3BwIFwKIAlkb20vSW5wdXRFbGVtZW50LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NNYWtl TGlzdHMudHh0IGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAppbmRleCA5MzE3Njg3ZGRiZmIwODJh NjQ0ZDVhZjNjMDA5ZTg1NWU4ZjNlYjEyLi5mYTI2ZDQ4OGQ4MGYxMjRhYTRhYTNmMTI5NGNjNzk4 NTZjZWI0MTg5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1dlYkNv cmUvQ01ha2VMaXN0cy50eHQKQEAgLTgyNiw2ICs4MjYsNyBAQCBTRVQoV2ViQ29yZV9TT1VSQ0VT CiAgICAgZG9tL0V2ZW50Q29udGV4dC5jcHAKICAgICBkb20vRXZlbnROYW1lcy5jcHAKICAgICBk b20vRXZlbnRUYXJnZXQuY3BwCisgICAgZG9tL0V2ZW50UXVldWUuY3BwCiAgICAgZG9tL0V4Y2Vw dGlvbkJhc2UuY3BwCiAgICAgZG9tL0V4Y2VwdGlvbkNvZGUuY3BwCiAgICAgZG9tL0lucHV0RWxl bWVudC5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggZWY0ZTQ3NjJjZTg2NmYwZTY4YzFiMzBmYjQ0NTk4MDgyNjVjMjIxNC4uY2Y3M2M3 N2E2NzRiMjM5N2RlMGVkNDY5YzI1NzI3MTE4M2M0OTNkZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9D aGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MSBAQAorMjAxMC0x MS0xNSAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTY3JvbGwgZXZlbnQgc2hvdWxk IGJlIGZpcmVkIGFzeW5jaHJvbm91c2x5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD00NTYzMQorCisgICAgICAgIFRlc3RzOiBmYXN0L2V2ZW50cy9maXJl LXNjcm9sbC1ldmVudC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2V2ZW50cy9maXJlLXNjcm9s bC1ldmVudC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sCisKKyAgICAgICAgTWFrZXMgc2Nyb2xsIGV2ZW50cyBmaXJlIGFzeW5j aHJvbm91c2x5IHRvIGJlIGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUKKyAgICAgICAgQ1NTT00gVmll dyBNb2R1bGUgYW5kIGNvbnNpc3RlbnQgd2l0aCBHZWNrbywgT3BlcmEgYW5kICh0byBzb21lIGRl Z3JlZSkKKyAgICAgICAgSUUuCisKKyAgICAgICAgVGhpcyBpcyBhY2NvbXBsaXNoZWQgYnkgbW92 aW5nIHRoZSBEb2N1bWVudDo6ZW5xdWV1ZUV2ZW50IGFuZCBzdXBwb3J0aW5nCisgICAgICAgIGNv ZGUgdG8gYSBzdGFuZGFsb25lIEV2ZW50UXVldWUgY2xhc3MuIEFkZGl0aW9uYWxseSwgdGhlcmUg aXMgbm93IGFuCisgICAgICAgIGVucXVldWVTY3JvbGxFdmVudCBtZXRob2QgdGhhdCBoYW5kbGVz IHNjcm9sbCBldmVudC1zcGVjaWZpYyBiZWhhdmlvcgorICAgICAgICAoZG9uJ3QgZW5xdWV1ZSBh bm90aGVyIGV2ZW50IGlmIHRoZXJlJ3MgYWxyZWFkeSBvbmUgZW5xdWV1ZWQgZm9yIHRoZQorICAg ICAgICBlbGVtZW50KS4gRG9jdW1lbnQ6OmVucXVldWVFdmVudCBoYXMgYmVlbiByZW5hbWVkIHRv IGVucXVldWVXaW5kb3dFdmVudAorICAgICAgICAoZm9yIGNsYXJpdHkpIHNpbmNlIHRoYXQncyB3 aGF0IGl0IGRpZCBhbGwgYWxvbmcuCisgICAgICAgIAorICAgICAgICAqIEFuZHJvaWQubWs6Cisg ICAgICAgICogQ01ha2VMaXN0cy50eHQ6CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAg ICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdl YkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50 OjplbnF1ZXVlV2luZG93RXZlbnQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmV2ZW50UXVldWUpOgorICAgICAgICAqIGRvbS9FdmVudFF1 ZXVlLmNwcDogQWRkZWQuCisgICAgICAgICogZG9tL0V2ZW50UXVldWUuaDogQWRkZWQuCisgICAg ICAgICogZG9tL05vZGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6ZW5xdWV1ZVNjcm9s bEV2ZW50KToKKyAgICAgICAgKiBkb20vTm9kZS5oOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50 KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyTGlzdEJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMaXN0Qm94Ojp2YWx1ZUNo YW5nZWQpOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpTdG9yYWdlRXZlbnREaXNwYXRjaGVyOjpkaXNwYXRjaCk6ICAgICAg ICAKKwogMjAxMC0xMS0xNSAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IDA5ODc1ZDViOWI5ZjBlOWQwNzRi NDBjMThhODM4M2ZmNTA4ZDlhODAuLjFiNjQyNTg3OWY4M2MwZDlkMjZhNzgzNDY0OTA5NWY0Y2Zk ZmI0ZmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9H TlVtYWtlZmlsZS5hbQpAQCAtMTE0NCw2ICsxMTQ0LDggQEAgd2ViY29yZV9zb3VyY2VzICs9IFwK IAlXZWJDb3JlL2RvbS9FdmVudE5hbWVzLmggXAogCVdlYkNvcmUvZG9tL0V2ZW50VGFyZ2V0LmNw cCBcCiAJV2ViQ29yZS9kb20vRXZlbnRUYXJnZXQuaCBcCisJV2ViQ29yZS9kb20vRXZlbnRRdWV1 ZS5jcHAgXAorCVdlYkNvcmUvZG9tL0V2ZW50UXVldWUuaCBcCiAJV2ViQ29yZS9kb20vRXhjZXB0 aW9uQmFzZS5jcHAgXAogCVdlYkNvcmUvZG9tL0V4Y2VwdGlvbkJhc2UuaCBcCiAJV2ViQ29yZS9k b20vRXhjZXB0aW9uQ29kZS5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkg Yi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCAyMTZiNTU3NTNiMjAyMGU0NmYyYmNmNGVkYzFj MzJkZjQ2NTgzY2NjLi40NjZlZTY2NzY5MzBjYjc4Yjc2ZTRmNjU2MDAxZGY3YzBiNWNiZTlhIDEw MDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lw aQpAQCAtMTIxMCw2ICsxMjEwLDggQEAKICAgICAgICAgICAgICdkb20vRXZlbnROYW1lcy5oJywK ICAgICAgICAgICAgICdkb20vRXZlbnRUYXJnZXQuY3BwJywKICAgICAgICAgICAgICdkb20vRXZl bnRUYXJnZXQuaCcsCisgICAgICAgICAgICAnZG9tL0V2ZW50UXVldWUuY3BwJywKKyAgICAgICAg ICAgICdkb20vRXZlbnRRdWV1ZS5oJywKICAgICAgICAgICAgICdkb20vRXhjZXB0aW9uQmFzZS5j cHAnLAogICAgICAgICAgICAgJ2RvbS9FeGNlcHRpb25CYXNlLmgnLAogICAgICAgICAgICAgJ2Rv bS9FeGNlcHRpb25Db2RlLmNwcCcsCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIv V2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCA3MzczMDRiN2E0OWJiYjIwNWM5MDU0M2UwYjk2NmI0 ZDlmYWFiMWZlLi45ODRiNTI2M2RiOTE5MWExNjg4YTU0NzA4NjhhZWE0ODQyYTA1Y2Q0IDEwMDY0 NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAg LTcxMiw2ICs3MTIsNyBAQCBTT1VSQ0VTICs9IFwKICAgICBkb20vRXZlbnRDb250ZXh0LmNwcCBc CiAgICAgZG9tL0V2ZW50TmFtZXMuY3BwIFwKICAgICBkb20vRXZlbnRUYXJnZXQuY3BwIFwKKyAg ICBkb20vRXZlbnRRdWV1ZS5jcHAgXAogICAgIGRvbS9FeGNlcHRpb25CYXNlLmNwcCBcCiAgICAg ZG9tL0V4Y2VwdGlvbkNvZGUuY3BwIFwKICAgICBkb20vSW5wdXRFbGVtZW50LmNwcCBcCmRpZmYg LS1naXQgYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCA5ZjkwZDhlNjYwYzc4NTc2MDA5MmZi ZDMxY2EwYjE3MjQxZGI0MjljLi5lMTI2ZDA5NjY4OTk1ZjM3N2Q5OWQwYmNlZGVkNzU2YjAwOWYz MjQ4IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisr KyBiL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTQyNTYzLDYgKzQy NTYzLDYyIEBACiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZlbnRUYXJnZXQuaCINCiAJCQkJ Pg0KIAkJCTwvRmlsZT4NCisJCSAgPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxkb21cRXZl bnRRdWV1ZS5jcHAiDQorCQkJCT4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlOYW1l PSJEZWJ1Z3xXaW4zMiINCisJCQkJCUV4Y2x1ZGVkRnJvbUJ1aWxkPSJ0cnVlIg0KKwkJCQkJPg0K KwkJCQkJPFRvb2wNCisJCQkJCQlOYW1lPSJWQ0NMQ29tcGlsZXJUb29sIg0KKwkJCQkJLz4NCisJ CQkJPC9GaWxlQ29uZmlndXJhdGlvbj4NCisJCQkJPEZpbGVDb25maWd1cmF0aW9uDQorCQkJCQlO YW1lPSJSZWxlYXNlfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJ CQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkv Pg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCisJ CQkJCU5hbWU9IkRlYnVnX0ludGVybmFsfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9 InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRv b2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8RmlsZUNvbmZp Z3VyYXRpb24NCisJCQkJCU5hbWU9IkRlYnVnX0NhaXJvfFdpbjMyIg0KKwkJCQkJRXhjbHVkZWRG cm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0KKwkJCQkJCU5hbWU9IlZDQ0xD b21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KKwkJCQk8 RmlsZUNvbmZpZ3VyYXRpb24NCisJCQkJCU5hbWU9IlJlbGVhc2VfQ2Fpcm98V2luMzIiDQorCQkJ CQlFeGNsdWRlZEZyb21CdWlsZD0idHJ1ZSINCisJCQkJCT4NCisJCQkJCTxUb29sDQorCQkJCQkJ TmFtZT0iVkNDTENvbXBpbGVyVG9vbCINCisJCQkJCS8+DQorCQkJCTwvRmlsZUNvbmZpZ3VyYXRp b24+DQorCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KKwkJCQkJTmFtZT0iRGVidWdfQWxsfFdpbjMy Ig0KKwkJCQkJRXhjbHVkZWRGcm9tQnVpbGQ9InRydWUiDQorCQkJCQk+DQorCQkJCQk8VG9vbA0K KwkJCQkJCU5hbWU9IlZDQ0xDb21waWxlclRvb2wiDQorCQkJCQkvPg0KKwkJCQk8L0ZpbGVDb25m aWd1cmF0aW9uPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4u XGRvbVxFdmVudFF1ZXVlLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCiAJCQkJ UmVsYXRpdmVQYXRoPSIuLlxkb21cRXhjZXB0aW9uQmFzZS5jcHAiDQogCQkJCT4NCmRpZmYgLS1n aXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDc4YTlhOTAxZjJjYzE4Mjg2 NzRjNGFlMDNmZmM4YTRjZmVhN2VkNzEuLjkzYzQ1MWMxOTZlMDU5YzA4OWVlMzIzNjJhNzA2Mzdh M2JhMjc0NTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBA IC0yNjU0LDYgKzI2NTQsOCBAQAogCQk4QUY0RTU1QzExREM1QTYzMDAwRUQzREUgLyogUGVyZm9y bWFuY2VUaW1pbmcuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDhBRjRFNTU5MTFEQzVBNjMwMDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5oICovOyB9 OwogCQk4QzZFQTYxOTExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYx NzExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi87IH07CiAJ CThDNkVBNjFBMTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QzZFQTYxODExRUY3 RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oICovOyB9OworCQk4RjY3NTYx QjEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEY2NzU2MTkxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50 UXVldWUuaCAqLzsgfTsKKwkJOEY2NzU2MUMxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEY2NzU2 MUExMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuY3BwICovOyB9OwogCQk4RkFDNzc0RDEx OTg3MkNCMDAxNUFFOTQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhGOTM0RDg0MTE4OUYxRUUwMDUwOEQ1 RCAvKiBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwICovOyB9OwogCQk5MzAyQjBCRDBENzlGODI5 MDBDN0VFODMgLyogUGFnZUdyb3VwLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzMDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3Bw ICovOyB9OwogCQk5MzAyQjBCRjBENzlGODJDMDBDN0VFODMgLyogUGFnZUdyb3VwLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzAyQjBCRTBENzlGODJD MDBDN0VFODMgLyogUGFnZUdyb3VwLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKQEAgLTg3ODMsNiArODc4NSw4IEBACiAJCThBRjRFNTVBMTFEQzVBNjMw MDBFRDNERSAvKiBQZXJmb3JtYW5jZVRpbWluZy5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0g UGVyZm9ybWFuY2VUaW1pbmcuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QzZF QTYxNzExRUY3RTA0MDBGRDhFRTMgLyogUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBSdW50aW1lRW5hYmxlZEZlYXR1cmVzLmNw cDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCThDNkVBNjE4MTFFRjdFMDQwMEZEOEVFMyAvKiBSdW50aW1lRW5h YmxlZEZlYXR1cmVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFJ1bnRpbWVF bmFibGVkRmVhdHVyZXMuaDsgcGF0aCA9IGdlbmVyaWMvUnVudGltZUVuYWJsZWRGZWF0dXJlcy5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMg LyogRXZlbnRRdWV1ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFdmVudFF1 ZXVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCThGNjc1NjFBMTI4OEIxN0IwMDQ3 QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IEV2ZW50UXVldWUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4 MzExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhyZWFkRXhlY1N0YXRlLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTTWFpblRocmVhZEV4ZWNTdGF0ZS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk4RjkzNEQ4NDExODlGMUVFMDA1MDhENUQgLyogSlNNYWluVGhy ZWFkRXhlY1N0YXRlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpT TWFpblRocmVhZEV4ZWNTdGF0ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkz MDJCMEJDMEQ3OUY4MjkwMEM3RUU4MyAvKiBQYWdlR3JvdXAuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gUGFnZUdyb3VwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKQEAgLTE4NDQ1LDYgKzE4NDQ5LDggQEAKIAkJCQk1NEM1MEY3QTBFODAxREYzMDA5ODMy QTAgLyogWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCAqLywKIAkJCQk1RDE1RTNBOTBGOUU2 QUMxMDA5RTBFM0YgLyogWE1MRG9jdW1lbnRQYXJzZXJTY29wZS5jcHAgKi8sCiAJCQkJNUQxNUUz QUEwRjlFNkFDMTAwOUUwRTNGIC8qIFhNTERvY3VtZW50UGFyc2VyU2NvcGUuaCAqLywKKwkJCQk4 RjY3NTYxOTEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5oICovLAorCQkJCThGNjc1NjFB MTI4OEIxN0IwMDQ3QUNBMyAvKiBFdmVudFF1ZXVlLmNwcCAqLywKIAkJCSk7CiAJCQlwYXRoID0g ZG9tOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTIxMzgzLDYgKzIxMzg5LDcgQEAK IAkJCQk0OTlCM0M1OTEyOEM2NDFFMDBFNzI2QzIgLyogR3JhcGhpY3NMYXllck1hYy5oIGluIEhl YWRlcnMgKi8sCiAJCQkJMDgyNTA5MzkxMjhCRDREODAwRTJFRDhFIC8qIFNWR0FuaW1hdGVkVHJh bnNmb3JtTGlzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMzg4OEY2RUYxMjhDOTg4OTAwMENBOEUw IC8qIEluc3BlY3RvckZpbGVTeXN0ZW1BZ2VudC5oIGluIEhlYWRlcnMgKi8sCisJCQkJOEY2NzU2 MUIxMjg4QjE3QjAwNDdBQ0EzIC8qIEV2ZW50UXVldWUuaCBpbiBIZWFkZXJzICovLAogCQkJKTsK IAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMjM5 NTYsNiArMjM5NjMsNyBAQAogCQkJCTk3REQ0RDg2MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRp dG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTQ5OUIzQzVBMTI4QzY0MUUwMEU3MjZDMiAvKiBH cmFwaGljc0xheWVyTWFjLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJMzg4OEY2RUUxMjhDOTg4OTAw MENBOEUwIC8qIEluc3BlY3RvckZpbGVTeXN0ZW1BZ2VudC5jcHAgaW4gU291cmNlcyAqLywKKwkJ CQk4RjY3NTYxQzEyODhCMTdCMDA0N0FDQTMgLyogRXZlbnRRdWV1ZS5jcHAgaW4gU291cmNlcyAq LywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJ fTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1dlYkNvcmUvZG9tL0Rv Y3VtZW50LmNwcAppbmRleCA0YzM0MjVhNzNkZmQ4YmZiOGQ1MDVjMDg5MzQyZWQ4NTk2ZTJkODMz Li44NDRhYjNlMTgzMGY4ZDRjNmEzMTYwOWY0MzUzMjJmZGE2ZjExZWRiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBA IC01OCw2ICs1OCw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5jbHVkZSAiRXZl bnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1 ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJv bGxlci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCkBAIC0zOTksNyArNDAwLDcgQEAgRG9jdW1lbnQ6 OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBib29sIGlzWEhUTUwsIGJv b2wgaXNIVE1MLCBjb24KICAgICAsIG1fbm9ybWFsV29ybGRXcmFwcGVyQ2FjaGUoMCkKICNlbmRp ZgogICAgICwgbV91c2luZ0dlb2xvY2F0aW9uKGZhbHNlKQotICAgICwgbV9wZW5kaW5nRXZlbnRU aW1lcih0aGlzLCAmRG9jdW1lbnQ6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpCisgICAgLCBtX2V2 ZW50UXVldWUoYWRvcHRQdHIobmV3IEV2ZW50UXVldWUpKQogI2lmIEVOQUJMRShXTUwpCiAgICAg LCBtX2NvbnRhaW5zV01MQ29udGVudChmYWxzZSkKICNlbmRpZgpAQCAtMzQzNywyMyArMzQzOCwx MCBAQCB2b2lkIERvY3VtZW50OjpkaXNwYXRjaFdpbmRvd0xvYWRFdmVudCgpCiAgICAgZG9tV2lu ZG93LT5kaXNwYXRjaExvYWRFdmVudCgpOwogfQogCi12b2lkIERvY3VtZW50OjplbnF1ZXVlRXZl bnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCit2b2lkIERvY3VtZW50OjplbnF1ZXVlV2luZG93 RXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCiB7Ci0gICAgbV9wZW5kaW5nRXZlbnRRdWV1 ZS5hcHBlbmQoZXZlbnQpOwotICAgIGlmICghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgp KQotICAgICAgICBtX3BlbmRpbmdFdmVudFRpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9p ZCBEb2N1bWVudDo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxEb2N1bWVudD4qKQotewot ICAgIEFTU0VSVCghbV9wZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKTsKLSAgICBWZWN0b3I8 UmVmUHRyPEV2ZW50PiA+IGV2ZW50UXVldWU7Ci0gICAgZXZlbnRRdWV1ZS5zd2FwKG1fcGVuZGlu Z0V2ZW50UXVldWUpOwotCi0gICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+Ojpjb25z dF9pdGVyYXRvciBJdGVyYXRvcjsKLSAgICBJdGVyYXRvciBlbmQgPSBldmVudFF1ZXVlLmVuZCgp OwotICAgIGZvciAoSXRlcmF0b3IgaXQgPSBldmVudFF1ZXVlLmJlZ2luKCk7IGl0ICE9IGVuZDsg KytpdCkKLSAgICAgICAgZGlzcGF0Y2hXaW5kb3dFdmVudCgqaXQpOworICAgIGV2ZW50LT5zZXRU YXJnZXQoZG9tV2luZG93KCkpOworICAgIG1fZXZlbnRRdWV1ZS0+ZW5xdWV1ZUV2ZW50KGV2ZW50 KTsKIH0KIAogUGFzc1JlZlB0cjxFdmVudD4gRG9jdW1lbnQ6OmNyZWF0ZUV2ZW50KGNvbnN0IFN0 cmluZyYgZXZlbnRUeXBlLCBFeGNlcHRpb25Db2RlJiBlYykKQEAgLTQ3MTUsNyArNDcwMyw3IEBA IHZvaWQgRG9jdW1lbnQ6OmVucXVldWVQYWdlc2hvd0V2ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0 ZW5jZSBwZXJzaXN0ZWQpCiAKIHZvaWQgRG9jdW1lbnQ6OmVucXVldWVIYXNoY2hhbmdlRXZlbnQo Y29uc3QgU3RyaW5nJiBvbGRVUkwsIGNvbnN0IFN0cmluZyYgbmV3VVJMKQogewotICAgIGVucXVl dWVFdmVudChIYXNoQ2hhbmdlRXZlbnQ6OmNyZWF0ZShvbGRVUkwsIG5ld1VSTCkpOworICAgIGVu cXVldWVXaW5kb3dFdmVudChIYXNoQ2hhbmdlRXZlbnQ6OmNyZWF0ZShvbGRVUkwsIG5ld1VSTCkp OwogfQogCiB2b2lkIERvY3VtZW50OjplbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gc3RhdGVPYmplY3QpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5oIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAppbmRleCBiYTQ4ZDZmODJlY2I0 MDhiZGJkMTQ3ZjYyM2U5ZTZjOWNiZjIyMTY5Li4zMWI3NWJmMDhiNTA1ZDEwMDRkNDYzYjNjYWE2 NTkxZDg0ODgxNjNjIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1dl YkNvcmUvZG9tL0RvY3VtZW50LmgKQEAgLTc1LDYgKzc1LDcgQEAgY2xhc3MgRWxlbWVudDsKIGNs YXNzIEVudGl0eVJlZmVyZW5jZTsKIGNsYXNzIEV2ZW50OwogY2xhc3MgRXZlbnRMaXN0ZW5lcjsK K2NsYXNzIEV2ZW50UXVldWU7CiBjbGFzcyBGcmFtZTsKIGNsYXNzIEZyYW1lVmlldzsKIGNsYXNz IEhUTUxDYW52YXNFbGVtZW50OwpAQCAtMTAxNiwxMCArMTAxNywxMSBAQCBwdWJsaWM6CiAgICAg Ym9vbCBjb250YWluc1ZhbGlkaXR5U3R5bGVSdWxlcygpIGNvbnN0IHsgcmV0dXJuIG1fY29udGFp bnNWYWxpZGl0eVN0eWxlUnVsZXM7IH0KICAgICB2b2lkIHNldENvbnRhaW5zVmFsaWRpdHlTdHls ZVJ1bGVzKCkgeyBtX2NvbnRhaW5zVmFsaWRpdHlTdHlsZVJ1bGVzID0gdHJ1ZTsgfQogCi0gICAg dm9pZCBlbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQgZW5xdWV1ZVdp bmRvd0V2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+KTsKICAgICB2b2lkIGVucXVldWVQYWdlc2hvd0V2 ZW50KFBhZ2VzaG93RXZlbnRQZXJzaXN0ZW5jZSk7CiAgICAgdm9pZCBlbnF1ZXVlSGFzaGNoYW5n ZUV2ZW50KGNvbnN0IFN0cmluZyYgb2xkVVJMLCBjb25zdCBTdHJpbmcmIG5ld1VSTCk7CiAgICAg dm9pZCBlbnF1ZXVlUG9wc3RhdGVFdmVudChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1 ZT4gc3RhdGVPYmplY3QpOworICAgIEV2ZW50UXVldWUqIGV2ZW50UXVldWUoKSBjb25zdCB7IHJl dHVybiBtX2V2ZW50UXVldWUuZ2V0KCk7IH0KIAogICAgIHZvaWQgYWRkTWVkaWFDYW5TdGFydExp c3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwogICAgIHZvaWQgcmVtb3ZlTWVkaWFDYW5T dGFydExpc3RlbmVyKE1lZGlhQ2FuU3RhcnRMaXN0ZW5lciopOwpAQCAtMTExNiw4ICsxMTE4LDYg QEAgcHJpdmF0ZToKIAogICAgIHZvaWQgY3JlYXRlU3R5bGVTZWxlY3RvcigpOwogCi0gICAgdm9p ZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPERvY3VtZW50PiopOwotCiAgICAgUGFzc1Jl ZlB0cjxOb2RlTGlzdD4gaGFuZGxlWmVyb1BhZGRpbmcoY29uc3QgSGl0VGVzdFJlcXVlc3QmLCBI aXRUZXN0UmVzdWx0JikgY29uc3Q7CiAKICAgICB2b2lkIGxvYWRFdmVudERlbGF5VGltZXJGaXJl ZChUaW1lcjxEb2N1bWVudD4qKTsKQEAgLTEzMzksOSArMTMzOSw4IEBAIHByaXZhdGU6CiAjZW5k aWYKIAogICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwotCi0gICAgVGltZXI8RG9jdW1lbnQ+ IG1fcGVuZGluZ0V2ZW50VGltZXI7Ci0gICAgVmVjdG9yPFJlZlB0cjxFdmVudD4gPiBtX3BlbmRp bmdFdmVudFF1ZXVlOworICAgIAorICAgIE93blB0cjxFdmVudFF1ZXVlPiBtX2V2ZW50UXVldWU7 CiAKICNpZiBFTkFCTEUoV01MKQogICAgIGJvb2wgbV9jb250YWluc1dNTENvbnRlbnQ7CmRpZmYg LS1naXQgYS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVl dWUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjJjMTFhY2RjZmYzNzFjMzdkMDY5YzNhMzM3ZjdkYmMxZTAwYTk1 NjIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcApAQCAtMCww ICsxLDg5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBSaWdo dHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6 CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAq IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuIAorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAi RXZlbnRRdWV1ZS5oIgorCisjaW5jbHVkZSAiRE9NV2luZG93LmgiCisjaW5jbHVkZSAiRG9jdW1l bnQuaCIKKyNpbmNsdWRlICJFdmVudC5oIgorI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitFdmVudFF1ZXVlOjpFdmVudFF1ZXVlKCkKKyAgICA6IG1fcGVu ZGluZ0V2ZW50VGltZXIodGhpcywgJkV2ZW50UXVldWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQp Cit7Cit9CisKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+ IGV2ZW50KQoreworICAgIEFTU0VSVChldmVudC0+dGFyZ2V0KCktPnRvTm9kZSgpIHx8IGV2ZW50 LT50YXJnZXQoKS0+dG9ET01XaW5kb3coKSk7CisgICAgbV9xdWV1ZWRFdmVudHMuYXBwZW5kKGV2 ZW50KTsKKyAgICAKKyAgICBpZiAoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUoKSkKKyAg ICAgICAgbV9wZW5kaW5nRXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgRXZl bnRRdWV1ZTo6ZW5xdWV1ZVNjcm9sbEV2ZW50KFBhc3NSZWZQdHI8Tm9kZT4gdGFyZ2V0LCBTY3Jv bGxFdmVudFRhcmdldFR5cGUgdGFyZ2V0VHlwZSkKK3sKKyAgICBpZiAoIW1fbm9kZXNXaXRoUXVl dWVkU2Nyb2xsRXZlbnRzLmFkZCh0YXJnZXQuZ2V0KCkpLnNlY29uZCkKKyAgICAgICAgcmV0dXJu OworCisgICAgLy8gUGVyIHRoZSBXM0MgQ1NTT00gVmlldyBNb2R1bGUsIHNjcm9sbCBldmVudHMg ZmlyZWQgYXQgdGhlIGRvY3VtZW50IHNob3VsZCBidWJibGUsIG90aGVycyBzaG91bGQgbm90Lgor ICAgIGJvb2wgY2FuQnViYmxlID0gdGFyZ2V0VHlwZSA9PSBTY3JvbGxFdmVudERvY3VtZW50VGFy Z2V0ID8gdHJ1ZSA6IGZhbHNlOworICAgIFJlZlB0cjxFdmVudD4gc2Nyb2xsRXZlbnQgPSBFdmVu dDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgY2FuQnViYmxlLCBmYWxzZSAvKiBu b24gY2FuY2VsbGVhYmxlICovKTsKKyAgICBzY3JvbGxFdmVudC0+c2V0VGFyZ2V0KHRhcmdldCk7 CisgICAgZW5xdWV1ZUV2ZW50KHNjcm9sbEV2ZW50LnJlbGVhc2UoKSk7Cit9CisKK3ZvaWQgRXZl bnRRdWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopCit7Cisg ICAgQVNTRVJUKCFtX3BlbmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpOworCisgICAgVmVjdG9y PFJlZlB0cjxFdmVudD4gPiBxdWV1ZWRFdmVudHM7CisgICAgcXVldWVkRXZlbnRzLnN3YXAobV9x dWV1ZWRFdmVudHMpOworCisgICAgbV9ub2Rlc1dpdGhRdWV1ZWRTY3JvbGxFdmVudHMuY2xlYXIo KTsKKyAgICAKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHF1ZXVlZEV2ZW50cy5zaXplKCk7 IGkrKykKKyAgICAgICAgZGlzcGF0Y2hFdmVudChxdWV1ZWRFdmVudHNbaV0ucmVsZWFzZSgpKTsK K30KKwordm9pZCBFdmVudFF1ZXVlOjpkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8RXZlbnQ+IGV2 ZW50KQoreworICAgIEV2ZW50VGFyZ2V0KiBldmVudFRhcmdldCA9IGV2ZW50LT50YXJnZXQoKTsK KyAgICBpZiAoZXZlbnRUYXJnZXQtPnRvTm9kZSgpKSB7CisgICAgICAgIGlmICghZXZlbnRUYXJn ZXQtPnRvTm9kZSgpLT5pbkRvY3VtZW50KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAg IGV2ZW50VGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50KTsKKyAgICB9CisgICAgCisgICAgaWYg KGV2ZW50VGFyZ2V0LT50b0RPTVdpbmRvdygpKQorICAgICAgICBldmVudFRhcmdldC0+dG9ET01X aW5kb3coKS0+ZGlzcGF0Y2hFdmVudChldmVudCwgMCk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1dl YkNvcmUvZG9tL0V2ZW50UXVldWUuaCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi4wNDY0ZTZhNDM0MzAwNDBlM2QwMzE4ZWMzMjZmODIyOGNlMzA0ZGY5Ci0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVS LCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIs IElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisg KiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisg KgorICovCisKKyNpZm5kZWYgRXZlbnRRdWV1ZV9oCisjZGVmaW5lIEV2ZW50UXVldWVfaAorCisj aW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgorI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworY2xhc3MgRXZlbnQ7CitjbGFzcyBOb2RlOworCitjbGFzcyBFdmVudFF1ZXVlIHsKK3B1 YmxpYzoKKyAgICBlbnVtIFNjcm9sbEV2ZW50VGFyZ2V0VHlwZSB7CisgICAgICAgIFNjcm9sbEV2 ZW50RG9jdW1lbnRUYXJnZXQsCisgICAgICAgIFNjcm9sbEV2ZW50RWxlbWVudFRhcmdldAorICAg IH07CisKKyAgICBFdmVudFF1ZXVlKCk7CisKKyAgICB2b2lkIGVucXVldWVFdmVudChQYXNzUmVm UHRyPEV2ZW50Pik7CisgICAgdm9pZCBlbnF1ZXVlU2Nyb2xsRXZlbnQoUGFzc1JlZlB0cjxOb2Rl PiwgU2Nyb2xsRXZlbnRUYXJnZXRUeXBlKTsKKworcHJpdmF0ZToKKyAgICB2b2lkIHBlbmRpbmdF dmVudFRpbWVyRmlyZWQoVGltZXI8RXZlbnRRdWV1ZT4qKTsKKyAgICB2b2lkIGRpc3BhdGNoRXZl bnQoUGFzc1JlZlB0cjxFdmVudD4pOworCisgICAgVGltZXI8RXZlbnRRdWV1ZT4gbV9wZW5kaW5n RXZlbnRUaW1lcjsKKyAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IG1fcXVldWVkRXZlbnRzOwor ICAgIEhhc2hTZXQ8Tm9kZSo+IG1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRzOworfTsKKwor fQorCisjZW5kaWYgLy8gRXZlbnRRdWV1ZV9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Ob2Rl LmNwcCBiL1dlYkNvcmUvZG9tL05vZGUuY3BwCmluZGV4IGU3MWM0YmRmZTA5ZjE3N2IzZTY1ZGVm ZWI0Yjc5NTYzMzk2MTQ3N2IuLjAwNWIwZWViM2M1YTFhOWY4NWQ4Y2I3ZTBkYmY5YzhlMzE3ZTQ0 ZTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGUuY3BwCisrKyBiL1dlYkNvcmUvZG9tL05v ZGUuY3BwCkBAIC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5j bHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRl ICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2Uv RXZlbnRIYW5kbGVyLmNwcCBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IGY2 YTIzNTM4MTVmNjFhZGJkMWRjNDE4MTAwNWUyNWNhMDc2YmFiYTEuLjgyYzdlN2U1OGNjYTcyMTZl NjE5ZWE1ZjZkY2M0Y2IwMzdkMjkxZTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9FdmVudEhh bmRsZXIuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0zNiw2ICsz Niw3IEBACiAjaW5jbHVkZSAiRHJhZ0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJFZGl0b3IuaCIK ICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCisjaW5jbHVkZSAiRXZlbnRRdWV1ZS5oIgogI2luY2x1 ZGUgIkZsb2F0UG9pbnQuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGb2N1 c0NvbnRyb2xsZXIuaCIKQEAgLTI3NTcsNyArMjc1OCw3IEBAIHZvaWQgRXZlbnRIYW5kbGVyOjpz ZW5kU2Nyb2xsRXZlbnQoKQogewogICAgIHNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIoKTsKICAg ICBpZiAobV9mcmFtZS0+dmlldygpICYmIG1fZnJhbWUtPmRvY3VtZW50KCkpCi0gICAgICAgIG1f ZnJhbWUtPmRvY3VtZW50KCktPmRpc3BhdGNoRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkuc2Nyb2xsRXZlbnQsIHRydWUsIGZhbHNlKSk7CisgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50 KCktPmV2ZW50UXVldWUoKS0+ZW5xdWV1ZVNjcm9sbEV2ZW50KG1fZnJhbWUtPmRvY3VtZW50KCks IEV2ZW50UXVldWU6OlNjcm9sbEV2ZW50RG9jdW1lbnRUYXJnZXQpOwogfQogCiB2b2lkIEV2ZW50 SGFuZGxlcjo6c2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXll ci5jcHAKaW5kZXggN2I5MDAwYzY1NTNhMjQ2MjVhMDBiNjY2NjFiODg0M2QwMjc2MWY4Yi4uMTdm NTEzNmQ3MzNkYmQ5MmY0NWFlZDUxOTg5MWNiMzM5Zjk2NTU4OSAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxheWVyLmNwcApAQCAtNTEsNyArNTEsNyBAQAogI2luY2x1ZGUgIkNocm9tZS5oIgogI2luY2x1 ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0jaW5jbHVkZSAiRXZl bnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJGbG9hdFBvaW50 M0QuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIu aCIKQEAgLTEzOTcsMTAgKzEzOTcsNyBAQCB2b2lkIFJlbmRlckxheWVyOjpzY3JvbGxUb09mZnNl dChpbnQgeCwgaW50IHksIGJvb2wgdXBkYXRlU2Nyb2xsYmFycywgYm9vbCByZXBhaQogICAgIH0K IAogICAgIC8vIFNjaGVkdWxlIHRoZSBzY3JvbGwgRE9NIGV2ZW50LgotICAgIGlmICh2aWV3KSB7 Ci0gICAgICAgIGlmIChGcmFtZVZpZXcqIGZyYW1lVmlldyA9IHZpZXctPmZyYW1lVmlldygpKQot ICAgICAgICAgICAgZnJhbWVWaWV3LT5zY2hlZHVsZUV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnRO YW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpLCByZW5kZXJlcigpLT5ub2RlKCkpOwot ICAgIH0KKyAgICByZW5kZXJlcigpLT5ub2RlKCktPmRvY3VtZW50KCktPmV2ZW50UXVldWUoKS0+ ZW5xdWV1ZVNjcm9sbEV2ZW50KHJlbmRlcmVyKCktPm5vZGUoKSwgRXZlbnRRdWV1ZTo6U2Nyb2xs RXZlbnRFbGVtZW50VGFyZ2V0KTsKIH0KIAogdm9pZCBSZW5kZXJMYXllcjo6c2Nyb2xsUmVjdFRv VmlzaWJsZShjb25zdCBJbnRSZWN0JiByZWN0LCBib29sIHNjcm9sbFRvQW5jaG9yLCBjb25zdCBT Y3JvbGxBbGlnbm1lbnQmIGFsaWduWCwgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnblkpCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcCBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCmluZGV4IDUzMmM1NTEyZDc4YjQ5NWY3MmVmMzM5 YjBmZjZkNzhmNDdkNTI0ZTEuLmVlNGQyY2Q0ODFkMTlmZjM3M2FkMzhmOWEzNGZhN2FkOGFlZTJh OTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCisrKyBi L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCkBAIC0zNiw3ICszNiw3IEBACiAj aW5jbHVkZSAiQ1NTU3R5bGVTZWxlY3Rvci5oIgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5j bHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0jaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUg IkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJG cmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgpAQCAtNTQwLDcgKzU0MCw3IEBAIHZvaWQg UmVuZGVyTGlzdEJveDo6dmFsdWVDaGFuZ2VkKFNjcm9sbGJhciopCiAgICAgaWYgKG5ld09mZnNl dCAhPSBtX2luZGV4T2Zmc2V0KSB7CiAgICAgICAgIG1faW5kZXhPZmZzZXQgPSBuZXdPZmZzZXQ7 CiAgICAgICAgIHJlcGFpbnQoKTsKLSAgICAgICAgbm9kZSgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50 OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpKTsKKyAgICAg ICAgbm9kZSgpLT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChu b2RlKCksIEV2ZW50UXVldWU6OlNjcm9sbEV2ZW50RWxlbWVudFRhcmdldCk7CiAgICAgfQogfQog CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUV2ZW50RGlzcGF0Y2hlci5jcHAKaW5kZXggNTgzM2M1 OWYwNDYyZDliMzA3YWNlZTgxZGU2MTlhOGM2ZDJjYWI0ZC4uNWNlNTZjNjMzZDE5MTA0YWUxZDdk Y2VkMmFlY2RhZWU0MTVkNzFkOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VF dmVudERpc3BhdGNoZXIuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlRXZlbnREaXNw YXRjaGVyLmNwcApAQCAtNTgsNyArNTgsNyBAQCB2b2lkIFN0b3JhZ2VFdmVudERpc3BhdGNoZXI6 OmRpc3BhdGNoKGNvbnN0IFN0cmluZyYga2V5LCBjb25zdCBTdHJpbmcmIG9sZFZhbHVlLAogICAg ICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAgICAgICBTdG9yYWdlKiBzdG9y YWdlID0gZnJhbWVzW2ldLT5kb21XaW5kb3coKS0+c2Vzc2lvblN0b3JhZ2UoZWMpOwogICAgICAg ICAgICAgaWYgKCFlYykKLSAgICAgICAgICAgICAgICBmcmFtZXNbaV0tPmRvY3VtZW50KCktPmVu cXVldWVFdmVudChTdG9yYWdlRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc3RvcmFnZUV2ZW50 LCBrZXksIG9sZFZhbHVlLCBuZXdWYWx1ZSwgc291cmNlRnJhbWUtPmRvY3VtZW50KCktPnVybCgp LCBzdG9yYWdlKSk7CisgICAgICAgICAgICAgICAgZnJhbWVzW2ldLT5kb2N1bWVudCgpLT5lbnF1 ZXVlV2luZG93RXZlbnQoU3RvcmFnZUV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnN0b3JhZ2VF dmVudCwga2V5LCBvbGRWYWx1ZSwgbmV3VmFsdWUsIHNvdXJjZUZyYW1lLT5kb2N1bWVudCgpLT51 cmwoKSwgc3RvcmFnZSkpOwogICAgICAgICB9CiAgICAgfSBlbHNlIHsKICAgICAgICAgLy8gU2Vu ZCBldmVudHMgdG8gZXZlcnkgcGFnZS4KQEAgLTc1LDcgKzc1LDcgQEAgdm9pZCBTdG9yYWdlRXZl bnREaXNwYXRjaGVyOjpkaXNwYXRjaChjb25zdCBTdHJpbmcmIGtleSwgY29uc3QgU3RyaW5nJiBv bGRWYWx1ZSwKICAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgICAgICAgICAg U3RvcmFnZSogc3RvcmFnZSA9IGZyYW1lc1tpXS0+ZG9tV2luZG93KCktPmxvY2FsU3RvcmFnZShl Yyk7CiAgICAgICAgICAgICBpZiAoIWVjKQotICAgICAgICAgICAgICAgIGZyYW1lc1tpXS0+ZG9j dW1lbnQoKS0+ZW5xdWV1ZUV2ZW50KFN0b3JhZ2VFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5z dG9yYWdlRXZlbnQsIGtleSwgb2xkVmFsdWUsIG5ld1ZhbHVlLCBzb3VyY2VGcmFtZS0+ZG9jdW1l bnQoKS0+dXJsKCksIHN0b3JhZ2UpKTsKKyAgICAgICAgICAgICAgICBmcmFtZXNbaV0tPmRvY3Vt ZW50KCktPmVucXVldWVXaW5kb3dFdmVudChTdG9yYWdlRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkuc3RvcmFnZUV2ZW50LCBrZXksIG9sZFZhbHVlLCBuZXdWYWx1ZSwgc291cmNlRnJhbWUtPmRv Y3VtZW50KCktPnVybCgpLCBzdG9yYWdlKSk7CiAgICAgICAgIH0KICAgICB9CiB9CmRpZmYgLS1n aXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxv ZwppbmRleCBhYTAxZTg0NzhlZjZlOTNlYTEwNmJkZWNiMTFjOTI4ZDM3OWZjMTY2Li5hOTJkMWI5 YjgxNDcxN2NiNmM3MzNiNjE2ZTZlNDYzMmFjYjVmNjJjIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxMyBAQAorMjAxMC0xMS0xNiAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9y Zz4KKworICAgICAgICBTY3JvbGwgZXZlbnQgc2hvdWxkIGJlIGZpcmVkIGFzeW5jaHJvbm91c2x5 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NTYzMQor ICAgICAgICAKKyAgICAgICAgQ2hhbmdlIGVucXVldWVFdmVudCBjYWxsc2l0ZS4KKworICAgICAg ICAqIHNyYy9TdG9yYWdlQXJlYVByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VB cmVhUHJveHk6OnN0b3JhZ2VFdmVudCk6CisKIDIwMTAtMTEtMTYgIFBhdmVsIEZlbGRtYW4gIDxw ZmVsZG1hbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTm90IHJldmlld2VkLiBDaHJvbWl1bSBi dWlsZCBmaXguCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1N0b3JhZ2VBcmVhUHJv eHkuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9TdG9yYWdlQXJlYVByb3h5LmNwcAppbmRleCA1 MzExYjY1YjExODVkNzkwODUwMmI5NDViNjA3YzNkM2QwY2IxZmQ2Li5lZDg5YjJjOGNmN2NhOWJh YzY4YWQ3NGVhNjBjZWMzZWUzOWU2NmNkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1N0b3JhZ2VBcmVhUHJveHkuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvU3RvcmFnZUFy ZWFQcm94eS5jcHAKQEAgLTEyOSw3ICsxMjksNyBAQCB2b2lkIFN0b3JhZ2VBcmVhUHJveHk6OnN0 b3JhZ2VFdmVudChjb25zdCBTdHJpbmcmIGtleSwgY29uc3QgU3RyaW5nJiBvbGRWYWx1ZSwgYwog ICAgICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAgICAgICBTdG9yYWdlKiBz dG9yYWdlID0gZnJhbWVzW2ldLT5kb21XaW5kb3coKS0+c2Vzc2lvblN0b3JhZ2UoZWMpOwogICAg ICAgICAgICAgaWYgKCFlYykKLSAgICAgICAgICAgICAgICBmcmFtZXNbaV0tPmRvY3VtZW50KCkt PmVucXVldWVFdmVudChTdG9yYWdlRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc3RvcmFnZUV2 ZW50LCBrZXksIG9sZFZhbHVlLCBuZXdWYWx1ZSwgc291cmNlRnJhbWUtPmRvY3VtZW50KCktPnVy bCgpLCBzdG9yYWdlKSk7CisgICAgICAgICAgICAgICAgZnJhbWVzW2ldLT5kb2N1bWVudCgpLT5l bnF1ZXVlV2luZG93RXZlbnQoU3RvcmFnZUV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnN0b3Jh Z2VFdmVudCwga2V5LCBvbGRWYWx1ZSwgbmV3VmFsdWUsIHNvdXJjZUZyYW1lLT5kb2N1bWVudCgp LT51cmwoKSwgc3RvcmFnZSkpOwogICAgICAgICB9CiAgICAgfSBlbHNlIHsKICAgICAgICAgLy8g U2VuZCBldmVudHMgdG8gZXZlcnkgcGFnZS4KQEAgLTE0Niw3ICsxNDYsNyBAQCB2b2lkIFN0b3Jh Z2VBcmVhUHJveHk6OnN0b3JhZ2VFdmVudChjb25zdCBTdHJpbmcmIGtleSwgY29uc3QgU3RyaW5n JiBvbGRWYWx1ZSwgYwogICAgICAgICAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgICAg ICAgICBTdG9yYWdlKiBzdG9yYWdlID0gZnJhbWVzW2ldLT5kb21XaW5kb3coKS0+bG9jYWxTdG9y YWdlKGVjKTsKICAgICAgICAgICAgIGlmICghZWMpCi0gICAgICAgICAgICAgICAgZnJhbWVzW2ld LT5kb2N1bWVudCgpLT5lbnF1ZXVlRXZlbnQoU3RvcmFnZUV2ZW50OjpjcmVhdGUoZXZlbnROYW1l cygpLnN0b3JhZ2VFdmVudCwga2V5LCBvbGRWYWx1ZSwgbmV3VmFsdWUsIHNvdXJjZUZyYW1lLT5k b2N1bWVudCgpLT51cmwoKSwgc3RvcmFnZSkpOworICAgICAgICAgICAgICAgIGZyYW1lc1tpXS0+ ZG9jdW1lbnQoKS0+ZW5xdWV1ZVdpbmRvd0V2ZW50KFN0b3JhZ2VFdmVudDo6Y3JlYXRlKGV2ZW50 TmFtZXMoKS5zdG9yYWdlRXZlbnQsIGtleSwgb2xkVmFsdWUsIG5ld1ZhbHVlLCBzb3VyY2VGcmFt ZS0+ZG9jdW1lbnQoKS0+dXJsKCksIHN0b3JhZ2UpKTsKICAgICAgICAgfQogICAgIH0KIH0K 76581 2010-12-14 15:30:40 -0800 2011-01-10 17:10:33 -0800 Patch bug-45631-20101214153039.patch text/plain 28229 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNmVlMjE3YmFkNWRhNmRmMDlkNjZlZmE5ZDgzNzNlN2QyODRhNDY0Li4xOTgzZjRj MDVmMWZkNGFiNmI2MzdjODkyMDc5ZWFmODc2MDBlZmNlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMTItMTQgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuCisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93 bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAt ZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6IEFkZGVkLiBEb2VzIHRoZSBzYW1lCisg ICAgICAgICAgICB0ZXN0cyBhcyBmaXJlLXNjcm9sbC1ldmVudC5odG1sLCBidXQgb24gYW4gaW5k aXZpZHVhbCBlbGVtZW50IGluc3RlYWQKKyAgICAgICAgICAgIG9mIHRoZSB3aG9sZSBkb2N1bWVu dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQ6 CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbDogTm93IGV4cGxp Y2l0bHkgdGVzdHMgZm9yCisgICAgICAgICAgICBzeW5jaHJvbm91cyBiZWhhdmlvciB3aGVuIHNj cm9sbGluZyB0aGUgZG9jdW1lbnQsIGFuZCB0aGF0IHdlIGRvbid0CisgICAgICAgICAgICBmaXJl IHRoZSBldmVudCBtb3JlIHRoYW4gb25jZS4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9yZW1vdmUt Y2hpbGQtb25zY3JvbGwuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5n LXpvb20tY2hhbmdlLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sOiBBZGRlZC4gQ2hlY2tzIHRoYXQgd2UgY2FuIGxpc3RlbgorICAgICAg ICAgICAgZm9yIHNjcm9sbCBldmVudHMgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlLgorICAgICAgICAqIGZhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRt bDoKKyAgICAgICAgKiBmYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbDoKKyAgICAgICAgKiBmYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWw6 CisKIDIwMTAtMTItMTQgIERhdmlkIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0 aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0CmluZGV4IDI0 ZGVlNGQ4ODhkYjFkYWI0NjgwYzMwNmY4MmI2NGJmNjI2M2Q2NjQuLmI1YjBjZjBmNTQ2YzJlNDFl ZTFjNzg0YzA1Y2FiMjM3MDRhYjk2YjUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0CkBAIC0xLDQg KzEsNCBAQAogeHgKLVRoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdl IGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkg b25lIHNjcm9sbCBldmVudC4gVGhpcyB0ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLgorVGhpcyB0 ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVhY2guIEJv dGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2ZW50LiBJ ZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBub3cuCiBQQVNTCiAoanVzdCBoZXJl IHRvIGZvcmNlIHNjcm9sbGJhcnMpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2lu cHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0 L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwKaW5kZXggZmM4M2IxNDgyM2QyZWQ3MGRiMzI1MDA4 OTViMTRjY2IzYmE5NzFlNy4uZTViYWJjN2RiMGNiYjBkYTIyN2MxYzkzODZmZDlmNDliNDZiYTI1 ZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Ny b2xscy5odG1sCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNj cm9sbHMuaHRtbApAQCAtMiwzOCArMiw0MSBAQAogPGh0bWw+CiA8aGVhZD4KIDxzY3JpcHQ+Ci1p ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgewogICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICBs YXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7Cit9CiAKLWZ1bmN0aW9uIHNjcigp Ci17Cit2YXIgc3RlcCA9IDA7CisKK29uc2Nyb2xsID0gZnVuY3Rpb24oKSB7CiAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dCArPSAneCc7CisKKyAgICBzd2l0Y2gg KHN0ZXApIHsKKyAgICBjYXNlIDA6CisgICAgICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisg ICAgICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKCdwYWdlVXAnKTsKKyAgICAgICAgICAgIGJy ZWFrOworICAgIGNhc2UgMToKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3Vs dHMnKS5pbm5lclRleHQgPSAnUEFTUyc7CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7 CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICAKKyAgICBzdGVwKys7CiB9CiAKIGZ1bmN0aW9u IHJ1blRlc3QoKQogewotICAgIGlmICghd2luZG93LmV2ZW50U2VuZGVyKQotICAgICAgICByZXR1 cm47Ci0KLSAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcignc2Nyb2xsJywgc2NyLCBmYWxzZSk7 Ci0KLSAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIpOwotICAgIHZhciB0ZXh0ID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBpZiAodGV4dCAh PSAieCIpCi0gICAgICAgIHRocm93ICJsb2cgc2hvdWxkIGNvbnRhaW4geCwgbm90ICIgKyB0ZXh0 OwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIik7Ci0gICAgdmFyIHRleHQgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbG9nJykuaW5uZXJUZXh0OwotICAgIGlmICh0ZXh0ICE9 ICJ4eCIpCi0gICAgICAgIHRocm93ICJsb2cgc2hvdWxkIGNvbnRhaW4geHgsIG5vdCAiICsgdGV4 dDsKLQotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0g IlBBU1MiOworICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgIGV2ZW50U2VuZGVy LmtleURvd24oJ3BhZ2VEb3duJyk7CiB9CiA8L3NjcmlwdD4KIDwvaGVhZD4KIDxib2R5IG9ubG9h ZD0icnVuVGVzdCgpIj4gCiA8c3BhbiBpZD0ibG9nIiBzdHlsZT0icG9zaXRpb246Zml4ZWQiPjwv c3Bhbj4gCi08ZGl2PlRoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdl IGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkg b25lIHNjcm9sbCBldmVudC4gVGhpcyB0ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLjwvZGl2Pgor PGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBkb3duIG9u Y2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9uZSBzY3Jv bGwgZXZlbnQuIElmIHJ1bm5pbmcgbWFudWFsbHksIHByZXNzIHRoZSBrZXlzIG5vdy48L2Rpdj4K IDxkaXYgaWQ9InJlc3VsdHMiPkZBSUw8L2Rpdj4KIDxkaXYgc3R5bGU9ImhlaWdodDo1MDAwMHB4 Ij4oanVzdCBoZXJlIHRvIGZvcmNlIHNjcm9sbGJhcnMpPC9kaXY+IAogPHNjcmlwdD4gCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50 LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNmZTZhNTZmOTAyYTBkYWZjYzVmZTkx NzdlNjI5NmQxMzhmNjRiMzMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEx IEBACitDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIGVsZW1lbnRzIGFzeWNo cm9ub3VzbHkgYW5kIG9ubHkgb25jZS4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2Vy aWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisK K1Njcm9sbCBldmVudCBidWJibGVzOiBmYWxzZQorUEFTUyBTY3JvbGwgcG9zaXRpb246ICgwLCAy MDApCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxl bWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxl bWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdjOThiYWQ1MzQ5ZTdjZDZkYzFlMDYxYjJhZjJlZThiNDhi Y2M2NGYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw1MSBAQAorPGh0bWw+Cis8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+ Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4K Kzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rp dj4KKzxkaXYgaWQ9ImNvbnRhaW5lciIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogNTAw cHg7IGhlaWdodDogNTAwcHgiPgorICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDUwMDBweDsgd2lkdGg6 IDUwMDBweDsiPjwvZGl2PgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ0NoZWNrcyB0 aGF0IHRoZSBzY3JvbGwgZXZlbnQgZmlyZXMgb24gZWxlbWVudHMgYXN5Y2hyb25vdXNseSBhbmQg b25seSBvbmNlLicpOworCit2YXIgZXZlbnRDb3VudCA9IDA7Cit2YXIgZG9uZVRpbWVvdXQ7CisK K2Z1bmN0aW9uIHNjcm9sbEhhbmRsZXIoZXZlbnQpCit7CisgICAgZXZlbnRDb3VudCsrOworICAg IGlmIChldmVudENvdW50ID09IDEpIHsKKyAgICAgICAgZGVidWcoJ1Njcm9sbCBldmVudCBidWJi bGVzOiAnICsgZXZlbnQuYnViYmxlcyk7CisgICAgICAgIHZhciBjb250YWluZXIgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVyJyk7CisgICAgICAgIHZhciBzY3JvbGxYID0gY29u dGFpbmVyLnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gY29udGFpbmVyLnNjcm9s bFRvcDsKKyAgICAgICAgdGVzdFBhc3NlZCgnU2Nyb2xsIHBvc2l0aW9uOiAoJyArIHNjcm9sbFgg KyAnLCAnICsgc2Nyb2xsWSArICcpJyk7CisgICAgICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9u ZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29t aW5nLgorICAgICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZmluaXNoSlNUZXN0LCAxMDAp OworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyVGltZW91dChkb25lVGltZW91dCk7CisgICAg ICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBoYW5kbGVyIHdhcyBpbnZva2VkICcgKyBldmVudENvdW50 ICsgJyB0aW1lcycpOworICAgICAgICBmaW5pc2hKU1Rlc3QoKTsKKyAgICB9Cit9CisKK29ubG9h ZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB2YXIgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoJ2NvbnRhaW5lcicpOworICAgIGNvbnRhaW5lci5hZGRFdmVudExpc3RlbmVyKCdzY3Jv bGwnLCBzY3JvbGxIYW5kbGVyLCBmYWxzZSk7CisgICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDEw MDsKKyAgICBpZiAoZXZlbnRDb3VudCA+IDApIHsKKyAgICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBl dmVudCBmaXJlZCBzeW5jaHJvbm91c2x5Jyk7CisgICAgICBmaW5pc2hKU1Rlc3QoKTsKKyAgICB9 CisgICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDIwMDsKK30KKwordmFyIHN1Y2Nlc3NmdWxseVBh cnNlZCA9IHRydWU7Cit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3Jp cHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9k eT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQKaW5kZXgg MTY4NmNlZDM5YWUyYmUyZDU5YjYzZTlkM2ZkYWU0YjFlMmM4ODY1Ni4uZTc2NjY2OTViYzYzMGUy NTI5OTgyYTEzNWYxMjk3MTQ3NDA2OTI0MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dApAQCAtMSw1OSArMSwxMSBA QAotUEFTU0VECitDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIHRoZSBkb2N1 bWVudCBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuCiAKLUlmIHRoZSB3b3JkICdQQVNTRUQn IGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUg dGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUuCitP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCiAKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKKworU2Nyb2xsIGV2ZW50IGJ1YmJsZXM6IHRydWUKK1BBU1MgU2Ny b2xsIHBvc2l0aW9uOiAoMjAwLCAyMDApCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CisKK1RFU1QgQ09NUExFVEUKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv ZmlyZS1zY3JvbGwtZXZlbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Ny b2xsLWV2ZW50Lmh0bWwKaW5kZXggYTA1NmMwNjdiZDlmMjdjNGIzNDY1Yzg0YTE2ZTIxYTlmYTNl NzE0Yy4uOTIyNDcwYTIzMTRkZThmNzkzOWM2MWUyYTZiMDI5MDRkOTlhZGRlZiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCkBAIC0xLDMwICsx LDQ1IEBACiA8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHkgc3R5bGU9Im1pbi13aWR0aDogNTAwMHB4OyBt aW4taGVpZ2h0OiA1MDAwcHgiPgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJj b25zb2xlIj48L2Rpdj4KIDxzY3JpcHQ+Ci12YXIgZXZlbnRGaXJlZCA9IGZhbHNlOworZGVzY3Jp cHRpb24oJ0NoZWNrcyB0aGF0IHRoZSBzY3JvbGwgZXZlbnQgZmlyZXMgb24gdGhlIGRvY3VtZW50 IGFzeWNocm9ub3VzbHkgYW5kIG9ubHkgb25jZS4nKTsKIAotZnVuY3Rpb24gc2Nyb2xsZXIoKSB7 Ci0gICAgaWYgKCFldmVudEZpcmVkKSB7Ci0gICAgICAgIGV2ZW50RmlyZWQgPSB0cnVlOwotICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFzc2VkIikuaW5uZXJIVE1MID0gIjxwIHN0 eWxlPSdjb2xvcjpyZWQnPlBBU1NFRDwvcD4iOwordmFyIGV2ZW50Q291bnQgPSAwOwordmFyIGRv bmVUaW1lb3V0OworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKGV2ZW50KQoreworICAgIGV2ZW50Q291 bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIGRlYnVnKCdTY3JvbGwg ZXZlbnQgYnViYmxlczogJyArIGV2ZW50LmJ1YmJsZXMpOworICAgICAgICB2YXIgc2Nyb2xsWCA9 IGRvY3VtZW50LmJvZHkuc2Nyb2xsTGVmdDsKKyAgICAgICAgdmFyIHNjcm9sbFkgPSBkb2N1bWVu dC5ib2R5LnNjcm9sbFRvcDsKKyAgICAgICAgdGVzdFBhc3NlZCgnU2Nyb2xsIHBvc2l0aW9uOiAo JyArIHNjcm9sbFggKyAnLCAnICsgc2Nyb2xsWSArICcpJyk7CisgICAgICAgIC8vIERvbid0IGNh bGwgbm90aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3Jv bGwgZXZlbnQgY29taW5nLgorICAgICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZmluaXNo SlNUZXN0LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyVGltZW91dChkb25lVGlt ZW91dCk7CisgICAgICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBoYW5kbGVyIHdhcyBpbnZva2VkICcg KyBldmVudENvdW50ICsgJyB0aW1lcycpOworICAgICAgICBmaW5pc2hKU1Rlc3QoKTsKICAgICB9 CiB9CiAKLXdpbmRvdy5vbmxvYWQgPSBmdW5jdGlvbigpIHsKLSAgICB3aW5kb3cuYWRkRXZlbnRM aXN0ZW5lcignc2Nyb2xsJywgc2Nyb2xsZXIsIGZhbHNlKTsKLSAgICB3aW5kb3cuc2Nyb2xsVG8o NTAwLCA1MDApOwotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKLSAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworb25sb2FkID0gZnVuY3Rpb24o KQoreworICAgIHdpbmRvdy5zY3JvbGxUbygxMDAsIDEwMCk7CisgICAgaWYgKGV2ZW50Q291bnQg PiAwKSB7CisgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwgZXZlbnQgZmlyZWQgc3luY2hyb25vdXNs eScpOworICAgICAgZmluaXNoSlNUZXN0KCk7CiAgICAgfQorICAgIHdpbmRvdy5zY3JvbGxUbygy MDAsIDIwMCk7CiB9CiAKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwordmFyIGpzVGVz dElzQXN5bmMgPSB0cnVlOwogPC9zY3JpcHQ+Ci08Ym9keT4KLTxkaXYgaWQ9InBhc3NlZCI+PC9k aXY+Ci0KLTxwPklmIHRoZSB3b3JkICdQQVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhl biB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBh IHNjcm9sbCBldmVudCBkaWQgbm90IGZpcmUuPC9wPgotCi1hPGJyPmE8YnI+YTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj4KLWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgotYTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5h PGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pz LXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+CiA8L2JvZHk+CiA8L2h0bWw+ClwgTm8gbmV3bGluZSBh dCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3Zl LWNoaWxkLW9uc2Nyb2xsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9yZW1vdmUtY2hp bGQtb25zY3JvbGwuaHRtbAppbmRleCAyNTJjZmVhMzMwZmU1MDIyNzhkMzZlZjE4ZTA3MWZjYjM2 NTRjYzM1Li5lYWJiMDc5ZWFjYWE3OWI4OGUwZjBhYWRhNzAxOTVkZTM4YjM2M2I4IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9yZW1vdmUtY2hpbGQtb25zY3JvbGwuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9yZW1vdmUtY2hpbGQtb25zY3JvbGwuaHRtbApA QCAtOSwxNyArOSwyOCBAQAogICAgICAgICAgICAgZnVuY3Rpb24gZGlzcGF0Y2hTY3JvbGxFdmVu dHMoKQogICAgICAgICAgICAgewogICAgICAgICAgICAgICAgIGlmICh3aW5kb3cuZXZlbnRTZW5k ZXIgJiYgd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAgICAg IGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAgICAgICAgICAgICAgICAg ICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oMTAwLCAxMDApOwogICAgICAgICAgICAgICAgICAg ICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KDAsIC0xKTsKLSAgICAgICAgICAgICAgICAgICAg ZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgtMSwgLTEpOwotICAgICAgICAgICAgICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICAgICAgICAgIHZh ciBzY3JvbGxDb3VudCA9IDA7CisgICAgICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdkdicpLmFkZEV2ZW50TGlzdGVuZXIoCisgICAgICAgICAgICAgICAgICAgICAgICAn c2Nyb2xsJywKKyAgICAgICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uKGV2ZW50KSB7CisgICAg ICAgICAgICAgICAgICAgICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQodGhpcy5maXJzdENoaWxkKQor ICAgICAgICAgICAgICAgICAgICAgICAgICBzY3JvbGxDb3VudCsrOworICAgICAgICAgICAgICAg ICAgICAgICAgICBpZiAoc2Nyb2xsQ291bnQgPT0gMSkKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgICAgICAgICAgICAgfSwKKyAg ICAgICAgICAgICAgICAgICAgICAgIGZhbHNlKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAg ICAgICB9CiAgICAgICAgIDwvc2NyaXB0PgogICAgIDwvaGVhZD4KICAgICA8Ym9keSBvbmxvYWQ9 InNldFRpbWVvdXQoJ2Rpc3BhdGNoU2Nyb2xsRXZlbnRzKCk7JywgMSk7Ij4KICAgICAgICAgVGhp cyB0ZXN0IHZlcmlmaWVzIHRoYXQgY2hpbGRyZW4gY2FuIGJlIHJlbW92ZWQgYnkgdGhlaXIgcGFy ZW50IGVsZW1lbnQncyBvbnNjcm9sbCBldmVudCBoYW5kbGVyLiAgVGhlIHRlc3Qgc3VjY2VlZHMg aWYgdGhpcyBpcyB0aGUgb25seSB0ZXh0IHJlbWFpbmluZyBhZnRlciB0aGUgdHdvIHNjcm9sbCBl dmVudHMgYXJlIGRpc3BhdGNoZWQuICBUaGUgdGVzdCBmYWlscyBpZiB0aGUgaW5uZXIgZGl2IHJl bWFpbnMgaW4gdGhlIG91dHB1dCBvciBpZiBXZWJLaXQgY3Jhc2hlcy48YnI+PGJyPgotICAgICAg ICA8ZGl2IGlkPSJkdiIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdo dDogMjAwcHg7IHdoaXRlc3BhY2U6IG5vd3JhcDsiIG9uc2Nyb2xsPSJ0aGlzLnJlbW92ZUNoaWxk KHRoaXMuZmlyc3RDaGlsZCkiPgorICAgICAgICA8ZGl2IGlkPSJkdiIgc3R5bGU9Im92ZXJmbG93 OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMjAwcHg7IHdoaXRlc3BhY2U6IG5vd3JhcDsi PgogICAgICAgICA8ZGl2IHN0eWxlPSJ3aWR0aDozMDBweDsgaGVpZ2h0OjMwMHB4Ij5Mb3JlbSBp cHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRv IGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlx dWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVs bGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1 aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBl c3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2lu dCBvY2NhZWNhdCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZp Y2lhIGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtCiAgICAgICAgIDwvZGl2Pgog ICAgICAgICA8L2Rpdj4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9s bC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9s bC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbAppbmRleCA0ZmMxNTI4NGRlZjFmNThkOTM3MzVmYWNh ZGU0YTU2ZDcxMGQ1MWZlLi5hZTEyYTc5ZTUzYmY2ODQwZjgyNTMzYWNiMDQ0MmE5MmNlNzI3MWZm IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20t Y2hhbmdlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16 b29tLWNoYW5nZS5odG1sCkBAIC0xNiw2ICsxNiw5IEBACiAgICAgZnVuY3Rpb24gc2Nyb2xsZWQo ZXZlbnQpCiAgICAgewogICAgICAgICBldmVudC50YXJnZXQucGFyZW50Tm9kZS5yZW1vdmVDaGls ZChldmVudC50YXJnZXQpOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAg ICAgIH0KICAgICB9CiAKICAgICBmdW5jdGlvbiB0ZXN0KCkKQEAgLTI3LDcgKzMwLDkgQEAKICAg ICAgICAgZG9jdW1lbnQuYm9keS5zdHlsZS56b29tID0gMjsKICAgICB9CiAKLSAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfQogICAgIHRl c3QoKTsKIDwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Ny b2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv c2Nyb2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCmluZGV4IDIyMmFkYTgwNWRhNTMwNjIy ZTRmODFmNWJkY2VmM2E3MWFjMzYwMDAuLjFlODUxMTNmNzc0MzNkZThhYmVlNmYzNjcxNTFlNTIw M2UyZWVkNDAgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVu dC1kb2VzLW5vdC1idWJibGUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3Jv bGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwKQEAgLTEsMTEgKzEsMjIgQEAKIDxodG1sPgog PHNjcmlwdD4KK3ZhciB3aW5kb3dXYXNTY3JvbGxlZCA9IGZhbHNlOwordmFyIGRvbmVUaW1lb3V0 OworCiBmdW5jdGlvbiB3aW5kb3dTY3JvbGxlZCgpIHsKKyAgICB3aW5kb3dXYXNTY3JvbGxlZCA9 IHRydWU7CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9 ICdGQUlMVVJFOiB3aW5kb3cub25zY3JvbGwgd2FzIGNhbGxlZC4nOyAKKyAgICBjbGVhclRpbWVv dXQoZG9uZVRpbWVvdXQpOyAgICAKIH0KIAogZnVuY3Rpb24gZGl2U2Nyb2xsZWQoKSB7Ci0gICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdTVUNDRVNTOiBk aXYub25zY3JvbGwgd2FzIGNhbGxlZCwgYnV0IHdpbmRvdy5vbnNjcm9sbCB3YXMgbm90Lic7IAor ICAgIGlmICghd2luZG93V2FzU2Nyb2xsZWQpCisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnU1VDQ0VTUzogZGl2Lm9uc2Nyb2xsIHdhcyBjYWxs ZWQsIGJ1dCB3aW5kb3cub25zY3JvbGwgd2FzIG5vdC4nOyAKKyAgICAvLyBEb24ndCBjYWxsIG5v dGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2 ZW50IGNvbWluZy9idWJibGluZy4KKyAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZnVuY3Rp b24oKSB7CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIH0sIDEwMCk7 ICAgIAogfQogCiBmdW5jdGlvbiBydW5UZXN0KCkgewpAQCAtMjQsMTAgKzM1LDYgQEAgZnVuY3Rp b24gcnVuVGVzdCgpIHsKICAgICAKICAgICAvLyBEb24ndCBwb2xsdXRlIHRoZSB0ZXN0IHJlc3Vs dCB3aXRoIG5vbnNlbnNlLgogICAgIGRpdi5pbm5lckhUTUwgPSAnJzsKLSAgICAKLSAgICBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSAKLSAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOwotICAgIAogfQogCiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjNlOTRhMzBkN2Q4NzY4MTY3Zjg5YTc0YTU1ZTVjYjlmMTYzZmM0ZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTAgQEAKK1Rlc3RzIHRoYXQgd2UgY2FuIGxpc3RlbiBmb3Ig c2Nyb2xsIGV2ZW50cyBvbiB0aGUgZG9jdW1lbnQgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnVi YmxlIHBoYXNlcy4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNT IiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK0JvdGggY2FwdHVy ZSBhbmQgYnViYmxlIHBoYXNlIGxpc3RlbmVycyB3ZXJlIGludm9rZWQuCitQQVNTIHN1Y2Nlc3Nm dWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMGNlNWMwMmUy YWUxZDFmMmVlMTdiZjAyYjNhNTk1Y2UxZDA4MzgwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwKQEAgLTAsMCArMSw0NSBA QAorPGh0bWw+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9q cy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qt cHJlLmpzIj48L3NjcmlwdD4KKzxib2R5IHN0eWxlPSJtaW4taGVpZ2h0OiAyMDAwcHgiPiAKKzxw IGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisKKzxzY3Jp cHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUZXN0cyB0aGF0IHdlIGNh biBsaXN0ZW4gZm9yIHNjcm9sbCBldmVudHMgb24gdGhlIGRvY3VtZW50IGluIGJvdGggdGhlIGNh cHR1cmUgYW5kIGJ1YmJsZSBwaGFzZXMuJyk7CisKK3ZhciB0cmlnZ2VyZWRDYXB0dXJlTGlzdGVu ZXIgPSBmYWxzZTsKK3ZhciB0cmlnZ2VyZWRCdWJibGVMaXN0ZW5lciA9IGZhbHNlOworCit3aW5k b3cuYWRkRXZlbnRMaXN0ZW5lcigKKyAgICAnc2Nyb2xsJywKKyAgICBmdW5jdGlvbigpIHsKKyAg ICAgICAgdHJpZ2dlcmVkQ2FwdHVyZUxpc3RlbmVyID0gdHJ1ZTsKKyAgICAgICAgY2hlY2tDb21w bGV0ZSgpOworICAgIH0sCisgICAgdHJ1ZSk7CisKK3dpbmRvdy5hZGRFdmVudExpc3RlbmVyKAor ICAgICdzY3JvbGwnLAorICAgIGZ1bmN0aW9uKGV2ZW50KSB7CisgICAgICAgIHRyaWdnZXJlZEJ1 YmJsZUxpc3RlbmVyID0gdHJ1ZTsKKyAgICAgICAgY2hlY2tDb21wbGV0ZSgpOworICAgIH0sCisg ICAgZmFsc2UpOworCitmdW5jdGlvbiBjaGVja0NvbXBsZXRlKCkKK3sKKyAgICBpZiAodHJpZ2dl cmVkQ2FwdHVyZUxpc3RlbmVyICYmIHRyaWdnZXJlZEJ1YmJsZUxpc3RlbmVyKSB7CisgICAgICAg IGRlYnVnKCdCb3RoIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFzZSBsaXN0ZW5lcnMgd2VyZSBpbnZv a2VkLicpOworICAgICAgICBmaW5pc2hKU1Rlc3QoKTsKKyAgICB9Cit9CisKK3dpbmRvdy5zY3Jv bGxUbygyMDAsIDIwMCk7CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwordmFyIGpz VGVzdElzQXN5bmMgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0 bWwKaW5kZXggYmExYTM1MTY0YzU2YjJjNDFlYTM4MGJlYTc2M2U3ZTRhMWU1OWY5OC4uZDJmOWFj NjQ1ZTdkNjFiNDUwMWIxYjJiOGY1MGZiNjY5NTc3YTU2MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5odG1sCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbApAQCAtMTEs MjkgKzExLDMzIEBACiA8cD4KICAgICBSZXN1bHQ6IDxzcGFuIGlkPSJyZXN1bHQiPnRlc3QgZGlk IG5vdCBjb21wbGV0ZS48L3NwYW4+CiA8L3A+Ci08ZGl2IGlkPSJ0IiBzdHlsZT0ib3ZlcmZsb3c6 IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJpZiAob3ZlcmZs b3dSZW1vdmUpIHRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTsiPgorPGRpdiBpZD0i dCIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBv bnNjcm9sbD0idGhpcy5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHRoaXMpO2hhbmRsZVNjcm9sbCgw KTsiPgogICAgIDxkaXYgc3R5bGU9ImhlaWdodDogMjAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogCi08 ZGl2IHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIg b25zY3JvbGw9ImlmIChzZWNvbmRPdmVyZmxvd1JlbW92ZSkgdGhpcy5wYXJlbnROb2RlLnJlbW92 ZUNoaWxkKHRoaXMpOyI+Cis8ZGl2IHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4 OyBoZWlnaHQ6IDEwMHB4OyIgb25zY3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0 aGlzKTtoYW5kbGVTY3JvbGwoMSk7Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+ PC9kaXY+CiAgICAgPGRpdiBpZD0iZCI+PC9kaXY+CiA8L2Rpdj4KIAogPHNjcmlwdD4KLSAgICB2 YXIgb3ZlcmZsb3dSZW1vdmUgPSBmYWxzZTsKLSAgICB2YXIgc2Vjb25kT3ZlcmZsb3dSZW1vdmUg PSBmYWxzZTsKKyAgICB2YXIgc2Nyb2xsZWRGaXJzdENvbnRhaW5lciA9IGZhbHNlOworICAgIHZh ciBzY3JvbGxlZFNlY29uZENvbnRhaW5lciA9IGZhbHNlOwogCiAgICAgZG9jdW1lbnQuYm9keS5v ZmZzZXRUb3A7IHQuc2Nyb2xsVG9wID0gMjA7CiAKLSAgICBvdmVyZmxvd1JlbW92ZSA9IHRydWU7 Ci0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3QnKS5pbm5lckhUTUwgPSAnJzsKLQotICAg IHNlY29uZE92ZXJmbG93UmVtb3ZlID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgnZCcpLnNjcm9sbEludG9WaWV3KCk7CiAgICAgCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ3Jlc3VsdCcpLmlubmVyVGV4dCA9ICJTVUNDRVNTIjsKLQotICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCi0gICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKKyAgICBmdW5jdGlvbiBoYW5kbGVTY3JvbGwoaW5kZXgpCisgICAgeworICAgICAgICBp ZiAoaW5kZXggPT0gMCkgc2Nyb2xsZWRGaXJzdENvbnRhaW5lciA9IHRydWU7CisgICAgICAgIGVs c2UgaWYgKGluZGV4ID09IDEpIHNjcm9sbGVkU2Vjb25kQ29udGFpbmVyID0gdHJ1ZTsKKyAgICAg ICAgCisgICAgICAgIGlmIChzY3JvbGxlZEZpcnN0Q29udGFpbmVyICYmIHNjcm9sbGVkU2Vjb25k Q29udGFpbmVyKSB7CisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0 JykuaW5uZXJUZXh0ID0gIlNVQ0NFU1MiOworICAgICAgICAKKyAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CisgICAgfQogPC9zY3JpcHQ+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1 Y3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1k ZXN0cnVjdC5odG1sCmluZGV4IDY0YjIwYWM0YWVmZGNkNTYxNGQyYzQ4YzAzZTZjZDJhMzIyYmQ0 ZGUuLjM1NzQxMmZlMjNmYjY2YzVkZWMxZGEwNThhZWE3NTJiZTM2MTA3OGIgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5o dG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qvb3ZlcmZsb3cvb25zY3JvbGwtbGF5ZXItc2VsZi1k ZXN0cnVjdC5odG1sCkBAIC0xLDE0ICsxLDE2IEBACiA8aGVhZD4KIDxzY3JpcHQ+CiBmdW5jdGlv biB0ZXN0KCkgewotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRp bERvbmUoKTsKKyAgICB9CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIml0Iikuc2Nyb2xs VG9wID0gMTAwOwogfQogPC9zY3JpcHQ+CiA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CiA8cD5UaGlz IHRlc3QgaW52b2x2ZXMgYSBsYXllciB0aGF0IHNlbGYtZGVzdHJ1Y3RzIHdoZW4gc2Nyb2xsZWQu IElmIHRoZXJlJ3Mgbm8gY3Jhc2gsIHRoZW4gdGhlIHRlc3Qgc3VjY2VlZGVkLjwvcD4KLTxkaXYg aWQ9Iml0IiBzdHlsZT0iaGVpZ2h0OiAxMDAlOyBvdmVyZmxvdzogYXV0bzsiIG9uc2Nyb2xsPSJz dHlsZS5kaXNwbGF5ID0gJ25vbmUnIj4KKzxkaXYgaWQ9Iml0IiBzdHlsZT0iaGVpZ2h0OiAxMDAl OyBvdmVyZmxvdzogYXV0bzsiIG9uc2Nyb2xsPSJzdHlsZS5kaXNwbGF5ID0gJ25vbmUnO2lmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsiPgogPGRpdiBzdHlsZT0iaGVpZ2h0OiAyMDAwcHg7Ij48L2Rpdj4KIDwvZGl2PgogPC9i b2R5PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5n LXNjcm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNj cm9sbC5odG1sCmluZGV4IGUzZjBhYzQ0YzE5YmNhNWRiZGUxNGQxMzg3M2EwY2Q1ZjBlZTcyMGMu LmRjNjk3MTIyMTZmN2I1MTY2MGFlMzIyNGIyY2VlYWU0NjFiMTQ0YWEgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1zY3JvbGwuaHRtbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKQEAgLTMs NiArMyw4IEBACiAgICAgPHNjcmlwdD4KICAgICAgICAgZnVuY3Rpb24gcmVwYWludFRlc3QoKQog ICAgICAgICB7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAg ICAgICAgICAgIHZhciB0YXJnZXQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7 CiAgICAgICAgICAgICBzY3JvbGxCeSgwLCAxMDApOwogICAgICAgICB9CkBAIC0xMSw2ICsxMyw4 IEBACiAgICAgICAgIHsKICAgICAgICAgICAgIHZhciB0YXJnZXQgPSBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgidGFyZ2V0Iik7CiAgICAgICAgICAgICB0YXJnZXQuc3R5bGUuYmFja2dyb3VuZENv bG9yID0gImdyZWVuIjsKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOwog ICAgICAgICB9CiAgICAgPC9zY3JpcHQ+CiA8L2hlYWQ+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0No YW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGVmMzg0OGQzNjZkOTZjYTVlNzY3MDRm YzdjNGIxODRjZTQwMjJhYWEuLmVjYjUzMzYyYmYzOTAyMjcxYjFkOWJjODBiOTExYTFhZWRkMDI1 NWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMzIgQEAKKzIwMTAtMTItMTQgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgU2Nyb2xsIGV2ZW50IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKworICAgICAg ICBUZXN0czogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbAorICAgICAgICAgICAg ICAgZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCisgICAgICAgICAg ICAgICBmYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UuaHRtbAorCisgICAgICAgIE1ha2Vz IHNjcm9sbCBldmVudHMgZmlyZSBhc3luY2hyb25vdXNseSB0byBiZSBpbiBjb21wbGlhbmNlIHdp dGggdGhlCisgICAgICAgIENTU09NIFZpZXcgTW9kdWxlIGFuZCBjb25zaXN0ZW50IHdpdGggR2Vj a28sIE9wZXJhIGFuZCAodG8gc29tZSBkZWdyZWUpCisgICAgICAgIElFLgorICAgICAgICAKKyAg ICAgICAgSW1wbGVtZW50ZWQgdmlhIHRoZSBFdmVudFF1ZXVlIGNsYXNzIGFkZGVkIGJ5IHI3NDA2 MiAoRXZlbnRRdWV1ZSBub3cKKyAgICAgICAgaGFzIGEgY29udmVuaWVuY2UgZW5xdWV1ZVNjcm9s bEV2ZW50IG1ldGhvZCkuCisKKyAgICAgICAgKiBkb20vRXZlbnRRdWV1ZS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpFdmVudFF1ZXVlOjplbnF1ZXVlU2Nyb2xsRXZlbnQpOgorICAgICAgICAoV2Vi Q29yZTo6RXZlbnRRdWV1ZTo6cGVuZGluZ0V2ZW50VGltZXJGaXJlZCk6CisgICAgICAgICogZG9t L0V2ZW50UXVldWUuaDoKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAg IChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnNlbmRTY3JvbGxFdmVudCk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxheWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckxheWVyOjpz Y3JvbGxUb09mZnNldCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGlzdEJveDo6dmFsdWVDaGFuZ2VkKToKKwogMjAxMC0x Mi0xNCAgRGF2aWQgSHlhdHQgIDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGFuIEJlcm5zdGVpbi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuY3Bw IGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAKaW5kZXggMjdjZDgwMmJiYjA0YjI4ODUxNDlh N2U1NzE1YWU4MGZkY2QxM2Q1Zi4uMmRhNGJjYjliMDQ4MGRkNmQyODViMjNkNzQ2ODhlN2JjMDYy ZDFkYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAKKysrIGIvV2ViQ29y ZS9kb20vRXZlbnRRdWV1ZS5jcHAKQEAgLTQ4LDEyICs0OCwyNiBAQCB2b2lkIEV2ZW50UXVldWU6 OmVucXVldWVFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBldmVudCkKICAgICAgICAgbV9wZW5kaW5n RXZlbnRUaW1lci5zdGFydE9uZVNob3QoMCk7CiB9CiAKK3ZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1 ZVNjcm9sbEV2ZW50KFBhc3NSZWZQdHI8Tm9kZT4gdGFyZ2V0LCBTY3JvbGxFdmVudFRhcmdldFR5 cGUgdGFyZ2V0VHlwZSkKK3sKKyAgICBpZiAoIW1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRz LmFkZCh0YXJnZXQuZ2V0KCkpLnNlY29uZCkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gUGVy IHRoZSBXM0MgQ1NTT00gVmlldyBNb2R1bGUsIHNjcm9sbCBldmVudHMgZmlyZWQgYXQgdGhlIGRv Y3VtZW50IHNob3VsZCBidWJibGUsIG90aGVycyBzaG91bGQgbm90LgorICAgIGJvb2wgY2FuQnVi YmxlID0gdGFyZ2V0VHlwZSA9PSBTY3JvbGxFdmVudERvY3VtZW50VGFyZ2V0ID8gdHJ1ZSA6IGZh bHNlOworICAgIFJlZlB0cjxFdmVudD4gc2Nyb2xsRXZlbnQgPSBFdmVudDo6Y3JlYXRlKGV2ZW50 TmFtZXMoKS5zY3JvbGxFdmVudCwgY2FuQnViYmxlLCBmYWxzZSAvKiBub24gY2FuY2VsbGVhYmxl ICovKTsKKyAgICBzY3JvbGxFdmVudC0+c2V0VGFyZ2V0KHRhcmdldCk7CisgICAgZW5xdWV1ZUV2 ZW50KHNjcm9sbEV2ZW50LnJlbGVhc2UoKSk7Cit9CisKIHZvaWQgRXZlbnRRdWV1ZTo6cGVuZGlu Z0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopCiB7CiAgICAgQVNTRVJUKCFtX3Bl bmRpbmdFdmVudFRpbWVyLmlzQWN0aXZlKCkpOwogCiAgICAgVmVjdG9yPFJlZlB0cjxFdmVudD4g PiBxdWV1ZWRFdmVudHM7CiAgICAgcXVldWVkRXZlbnRzLnN3YXAobV9xdWV1ZWRFdmVudHMpOwor ICAgIAorICAgIG1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRzLmNsZWFyKCk7CiAKICAgICBm b3IgKHNpemVfdCBpID0gMDsgaSA8IHF1ZXVlZEV2ZW50cy5zaXplKCk7IGkrKykKICAgICAgICAg ZGlzcGF0Y2hFdmVudChxdWV1ZWRFdmVudHNbaV0ucmVsZWFzZSgpKTsKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZG9tL0V2ZW50UXVldWUuaCBiL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaAppbmRleCA4 ZGQ3ZWM5YmIwNTMyZTdlOWQ2ODE1YzExMTNkYTg2YTIxOTU3MjM1Li43ZjhkNWZiMjU0NjExNDZh ZDQ3OTU0MmJhZjQ1YTc4MGNiOWQ2YWQ0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9FdmVudFF1 ZXVlLmgKKysrIGIvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCkBAIC0yOCw2ICsyOCw3IEBACiAj ZGVmaW5lIEV2ZW50UXVldWVfaAogCiAjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYv SGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9S ZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CkBAIC00MSw5ICs0MiwxNSBAQCBjbGFz cyBFdmVudFF1ZXVlIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShFdmVudFF1ZXVlKTsKIAog cHVibGljOgorICAgIGVudW0gU2Nyb2xsRXZlbnRUYXJnZXRUeXBlIHsKKyAgICAgICAgU2Nyb2xs RXZlbnREb2N1bWVudFRhcmdldCwKKyAgICAgICAgU2Nyb2xsRXZlbnRFbGVtZW50VGFyZ2V0Cisg ICAgfTsKKwogICAgIEV2ZW50UXVldWUoKTsKIAogICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NS ZWZQdHI8RXZlbnQ+KTsKKyAgICB2b2lkIGVucXVldWVTY3JvbGxFdmVudChQYXNzUmVmUHRyPE5v ZGU+LCBTY3JvbGxFdmVudFRhcmdldFR5cGUpOwogCiBwcml2YXRlOgogICAgIHZvaWQgcGVuZGlu Z0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopOwpAQCAtNTEsNiArNTgsNyBAQCBw cml2YXRlOgogCiAgICAgVGltZXI8RXZlbnRRdWV1ZT4gbV9wZW5kaW5nRXZlbnRUaW1lcjsKICAg ICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IG1fcXVldWVkRXZlbnRzOworICAgIEhhc2hTZXQ8Tm9k ZSo+IG1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRzOwogfTsKIAogfQpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVy LmNwcAppbmRleCAyODE0OThhZjhjMzdmYWY0MzQ3NjNkNGM4YWJlY2ZlZjM2Y2EyMWQ0Li41NWYw MmQ0NjQyZDA1YzliODRkZDkyZWRmNjU1NWI3MjI3ZDVhNGI0IDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIkRyYWdDb250cm9sbGVyLmgiCiAjaW5jbHVk ZSAiRWRpdG9yLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVl dWUuaCIKICNpbmNsdWRlICJGbG9hdFBvaW50LmgiCiAjaW5jbHVkZSAiRmxvYXRSZWN0LmgiCiAj aW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCkBAIC0yNzk4LDcgKzI3OTksNyBAQCB2b2lkIEV2 ZW50SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50KCkKIHsKICAgICBzZXRGcmFtZVdhc1Njcm9sbGVk QnlVc2VyKCk7CiAgICAgaWYgKG1fZnJhbWUtPnZpZXcoKSAmJiBtX2ZyYW1lLT5kb2N1bWVudCgp KQotICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVh dGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCB0cnVlLCBmYWxzZSkpOworICAgICAgICBtX2Zy YW1lLT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChtX2ZyYW1l LT5kb2N1bWVudCgpLCBFdmVudFF1ZXVlOjpTY3JvbGxFdmVudERvY3VtZW50VGFyZ2V0KTsKIH0K IAogdm9pZCBFdmVudEhhbmRsZXI6OnNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIoKQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwIGIvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyTGF5ZXIuY3BwCmluZGV4IDM2Mjk4MWM0MGY1Njc3ZTZmNWY4MjNiMmViZmQxODU5 MTBkZGU0N2QuLmZjNWNkYmEzYTVhMzg2NDQ1NDJkMWZhZDk1MjdjYzU2N2RlNDk4ZjEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcAorKysgYi9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJMYXllci5jcHAKQEAgLTUxLDcgKzUxLDcgQEAKICNpbmNsdWRlICJDaHJv bWUuaCIKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkV2ZW50SGFuZGxlci5oIgot I2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVk ZSAiRmxvYXRQb2ludDNELmgiCiAjaW5jbHVkZSAiRmxvYXRSZWN0LmgiCiAjaW5jbHVkZSAiRm9j dXNDb250cm9sbGVyLmgiCkBAIC0xMzk3LDEwICsxMzk3LDcgQEAgdm9pZCBSZW5kZXJMYXllcjo6 c2Nyb2xsVG9PZmZzZXQoaW50IHgsIGludCB5LCBib29sIHVwZGF0ZVNjcm9sbGJhcnMsIGJvb2wg cmVwYWkKICAgICB9CiAKICAgICAvLyBTY2hlZHVsZSB0aGUgc2Nyb2xsIERPTSBldmVudC4KLSAg ICBpZiAodmlldykgewotICAgICAgICBpZiAoRnJhbWVWaWV3KiBmcmFtZVZpZXcgPSB2aWV3LT5m cmFtZVZpZXcoKSkKLSAgICAgICAgICAgIGZyYW1lVmlldy0+c2NoZWR1bGVFdmVudChFdmVudDo6 Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZhbHNlKSwgcmVuZGVyZXIo KS0+bm9kZSgpKTsKLSAgICB9CisgICAgcmVuZGVyZXIoKS0+bm9kZSgpLT5kb2N1bWVudCgpLT5l dmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChyZW5kZXJlcigpLT5ub2RlKCksIEV2ZW50 UXVldWU6OlNjcm9sbEV2ZW50RWxlbWVudFRhcmdldCk7CiB9CiAKIHZvaWQgUmVuZGVyTGF5ZXI6 OnNjcm9sbFJlY3RUb1Zpc2libGUoY29uc3QgSW50UmVjdCYgcmVjdCwgYm9vbCBzY3JvbGxUb0Fu Y2hvciwgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnblgsIGNvbnN0IFNjcm9sbEFsaWdubWVu dCYgYWxpZ25ZKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5j cHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcAppbmRleCBlZDdmOGVlZDhl YmFmNTRmYTNhMmE0NWMxMmE1Njg1NDFkZjIyMjU3Li5kNWY2MGFlNmRkOGNlZmZiOTM2NDg2MGU2 NDJkNDhkNTdlMGIwMjA1IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0 Qm94LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcApAQCAtMzYs NyArMzYsNyBAQAogI2luY2x1ZGUgIkNTU1N0eWxlU2VsZWN0b3IuaCIKICNpbmNsdWRlICJEb2N1 bWVudC5oIgogI2luY2x1ZGUgIkV2ZW50SGFuZGxlci5oIgotI2luY2x1ZGUgIkV2ZW50TmFtZXMu aCIKKyNpbmNsdWRlICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgi CiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKQEAgLTU0NSw3ICs1 NDUsNyBAQCB2b2lkIFJlbmRlckxpc3RCb3g6OnZhbHVlQ2hhbmdlZChTY3JvbGxiYXIqKQogICAg IGlmIChuZXdPZmZzZXQgIT0gbV9pbmRleE9mZnNldCkgewogICAgICAgICBtX2luZGV4T2Zmc2V0 ID0gbmV3T2Zmc2V0OwogICAgICAgICByZXBhaW50KCk7Ci0gICAgICAgIG5vZGUoKS0+ZGlzcGF0 Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZh bHNlKSk7CisgICAgICAgIG5vZGUoKS0+ZG9jdW1lbnQoKS0+ZXZlbnRRdWV1ZSgpLT5lbnF1ZXVl U2Nyb2xsRXZlbnQobm9kZSgpLCBFdmVudFF1ZXVlOjpTY3JvbGxFdmVudEVsZW1lbnRUYXJnZXQp OwogICAgIH0KIH0KIAo= 78475 2011-01-10 17:10:38 -0800 2011-01-11 12:41:34 -0800 Patch bug-45631-20110110171037.patch text/plain 28399 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAwMzk3ODlhNjdlMWI0NDg3NTc0YjUxZDBiOTczNmYzOWNkNmM5YTg4Li5mZmYwMTNl MjYzZjEzZTUzMmFkMTViYzZlNTc4YWI5MWM0NmNiM2FkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTEtMDEtMTAgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU2Nyb2xsIGV2ZW50 IHNob3VsZCBiZSBmaXJlZCBhc3luY2hyb25vdXNseQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDU2MzEKKyAgICAgICAgCisgICAgICAgIFVwZGF0ZSBl eGlzdGluZyB0ZXN0cyB0aGF0IGFzc3VtZWQgdGhhdCBzY3JvbGwgZXZlbnRzIGZpcmVkCisgICAg ICAgIHN5bmNocm9ub3VzbHkuCisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93 bi1zY3JvbGxzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3BhZ2UtdXAt ZG93bi1zY3JvbGxzLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWw6IEFkZGVkLiBEb2VzIHRoZSBzYW1lCisg ICAgICAgICAgICB0ZXN0cyBhcyBmaXJlLXNjcm9sbC1ldmVudC5odG1sLCBidXQgb24gYW4gaW5k aXZpZHVhbCBlbGVtZW50IGluc3RlYWQKKyAgICAgICAgICAgIG9mIHRoZSB3aG9sZSBkb2N1bWVu dC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQ6 CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbDogTm93IGV4cGxp Y2l0bHkgdGVzdHMgZm9yCisgICAgICAgICAgICBzeW5jaHJvbm91cyBiZWhhdmlvciB3aGVuIHNj cm9sbGluZyB0aGUgZG9jdW1lbnQsIGFuZCB0aGF0IHdlIGRvbid0CisgICAgICAgICAgICBmaXJl IHRoZSBldmVudCBtb3JlIHRoYW4gb25jZS4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9yZW1vdmUt Y2hpbGQtb25zY3JvbGwuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZHVyaW5n LXpvb20tY2hhbmdlLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRv ZXMtbm90LWJ1YmJsZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1l dmVudC1waGFzZS5odG1sOiBBZGRlZC4gQ2hlY2tzIHRoYXQgd2UgY2FuIGxpc3RlbgorICAgICAg ICAgICAgZm9yIHNjcm9sbCBldmVudHMgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlLgorICAgICAgICAqIGZhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRt bDoKKyAgICAgICAgKiBmYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbDoKKyAgICAgICAgKiBmYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWw6 CisKIDIwMTEtMDEtMTAgIEplciBOb2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dAppbmRleCAy NGRlZTRkODg4ZGIxZGFiNDY4MGMzMDZmODJiNjRiZjYyNjNkNjY0Li5iNWIwY2YwZjU0NmMyZTQx ZWUxYzc4NGMwNWNhYjIzNzA0YWI5NmI1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9lZGl0aW5n L2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dApAQCAtMSw0 ICsxLDQgQEAKIHh4Ci1UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBhbmQgcGFn ZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBleGFjdGx5 IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFzcy4KK1RoaXMg dGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFuZCBwYWdlIGRvd24gb25jZSBlYWNoLiBC b3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4YWN0bHkgb25lIHNjcm9sbCBldmVudC4g SWYgcnVubmluZyBtYW51YWxseSwgcHJlc3MgdGhlIGtleXMgbm93LgogUEFTUwogKGp1c3QgaGVy ZSB0byBmb3JjZSBzY3JvbGxiYXJzKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9p bnB1dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1 dC9wYWdlLXVwLWRvd24tc2Nyb2xscy5odG1sCmluZGV4IGZjODNiMTQ4MjNkMmVkNzBkYjMyNTAw ODk1YjE0Y2NiM2JhOTcxZTcuLmU1YmFiYzdkYjBjYmIwZGEyMjdjMWM5Mzg2ZmQ5ZjQ5YjQ2YmEy NWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNj cm9sbHMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1z Y3JvbGxzLmh0bWwKQEAgLTIsMzggKzIsNDEgQEAKIDxodG1sPgogPGhlYWQ+CiA8c2NyaXB0Pgot aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKK2lmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQogCi1mdW5jdGlvbiBzY3Io KQotewordmFyIHN0ZXAgPSAwOworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKCkgewogICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQgKz0gJ3gnOworCisgICAgc3dpdGNo IChzdGVwKSB7CisgICAgY2FzZSAwOgorICAgICAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQor ICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigncGFnZVVwJyk7CisgICAgICAgICAgICBi cmVhazsKKyAgICBjYXNlIDE6CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1 bHRzJykuaW5uZXJUZXh0ID0gJ1BBU1MnOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgp OworICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgc3RlcCsrOwogfQogCiBmdW5jdGlv biBydW5UZXN0KCkKIHsKLSAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikKLSAgICAgICAgcmV0 dXJuOwotCi0gICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Njcm9sbCcsIHNjciwgZmFsc2Up OwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iKTsKLSAgICB2YXIgdGV4dCA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsb2cnKS5pbm5lclRleHQ7Ci0gICAgaWYgKHRleHQg IT0gIngiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHgsIG5vdCAiICsgdGV4 dDsKLQotICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIpOwotICAgIHZhciB0ZXh0ID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBpZiAodGV4dCAh PSAieHgiKQotICAgICAgICB0aHJvdyAibG9nIHNob3VsZCBjb250YWluIHh4LCBub3QgIiArIHRl eHQ7Ci0KLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9 ICJQQVNTIjsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICBldmVudFNlbmRl ci5rZXlEb3duKCdwYWdlRG93bicpOwogfQogPC9zY3JpcHQ+CiA8L2hlYWQ+CiA8Ym9keSBvbmxv YWQ9InJ1blRlc3QoKSI+IAogPHNwYW4gaWQ9ImxvZyIgc3R5bGU9InBvc2l0aW9uOmZpeGVkIj48 L3NwYW4+IAotPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBhbmQgcGFn ZSBkb3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBleGFjdGx5 IG9uZSBzY3JvbGwgZXZlbnQuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFzcy48L2Rpdj4K KzxkaXY+VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBv bmNlIGVhY2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Ny b2xsIGV2ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBub3cuPC9kaXY+ CiA8ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+CiA8ZGl2IHN0eWxlPSJoZWlnaHQ6NTAwMDBw eCI+KGp1c3QgaGVyZSB0byBmb3JjZSBzY3JvbGxiYXJzKTwvZGl2PiAKIDxzY3JpcHQ+IApkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVu dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVu dC1lbGVtZW50LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jZmU2YTU2ZjkwMmEwZGFmY2M1ZmU5 MTc3ZTYyOTZkMTM4ZjY0YjMzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwx MSBAQAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBldmVudCBmaXJlcyBvbiBlbGVtZW50cyBhc3lj aHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNl cmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKwor CitTY3JvbGwgZXZlbnQgYnViYmxlczogZmFsc2UKK1BBU1MgU2Nyb2xsIHBvc2l0aW9uOiAoMCwg MjAwKQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVs ZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVs ZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43Yzk4YmFkNTM0OWU3Y2Q2ZGMxZTA2MWIyYWYyZWU4YjQ4 YmNjNjRmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1z Y3JvbGwtZXZlbnQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNTEgQEAKKzxodG1sPgorPGxpbmsg cmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3Mi PgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9k aXY+Cis8ZGl2IGlkPSJjb250YWluZXIiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDUw MHB4OyBoZWlnaHQ6IDUwMHB4Ij4KKyAgPGRpdiBzdHlsZT0iaGVpZ2h0OiA1MDAwcHg7IHdpZHRo OiA1MDAwcHg7Ij48L2Rpdj4KKzwvZGl2PgorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdDaGVja3Mg dGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIGVsZW1lbnRzIGFzeWNocm9ub3VzbHkgYW5k IG9ubHkgb25jZS4nKTsKKwordmFyIGV2ZW50Q291bnQgPSAwOwordmFyIGRvbmVUaW1lb3V0Owor CitmdW5jdGlvbiBzY3JvbGxIYW5kbGVyKGV2ZW50KQoreworICAgIGV2ZW50Q291bnQrKzsKKyAg ICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIGRlYnVnKCdTY3JvbGwgZXZlbnQgYnVi YmxlczogJyArIGV2ZW50LmJ1YmJsZXMpOworICAgICAgICB2YXIgY29udGFpbmVyID0gZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAgICAgICB2YXIgc2Nyb2xsWCA9IGNv bnRhaW5lci5zY3JvbGxMZWZ0OworICAgICAgICB2YXIgc2Nyb2xsWSA9IGNvbnRhaW5lci5zY3Jv bGxUb3A7CisgICAgICAgIHRlc3RQYXNzZWQoJ1Njcm9sbCBwb3NpdGlvbjogKCcgKyBzY3JvbGxY ICsgJywgJyArIHNjcm9sbFkgKyAnKScpOworICAgICAgICAvLyBEb24ndCBjYWxsIG5vdGlmeURv bmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFub3RoZXIgc2Nyb2xsIGV2ZW50IGNv bWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZpbmlzaEpTVGVzdCwgMTAw KTsKKyAgICB9IGVsc2UgeworICAgICAgICBjbGVhclRpbWVvdXQoZG9uZVRpbWVvdXQpOworICAg ICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAnICsgZXZlbnRDb3Vu dCArICcgdGltZXMnKTsKKyAgICAgICAgZmluaXNoSlNUZXN0KCk7CisgICAgfQorfQorCitvbmxv YWQgPSBmdW5jdGlvbigpCit7CisgICAgdmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCdjb250YWluZXInKTsKKyAgICBjb250YWluZXIuYWRkRXZlbnRMaXN0ZW5lcignc2Ny b2xsJywgc2Nyb2xsSGFuZGxlciwgZmFsc2UpOworICAgIGNvbnRhaW5lci5zY3JvbGxUb3AgPSAx MDA7CisgICAgaWYgKGV2ZW50Q291bnQgPiAwKSB7CisgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwg ZXZlbnQgZmlyZWQgc3luY2hyb25vdXNseScpOworICAgICAgZmluaXNoSlNUZXN0KCk7CisgICAg fQorICAgIGNvbnRhaW5lci5zY3JvbGxUb3AgPSAyMDA7Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQ YXJzZWQgPSB0cnVlOwordmFyIGpzVGVzdElzQXN5bmMgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2Ny aXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2Jv ZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CmluZGV4 IDE2ODZjZWQzOWFlMmJlMmQ1OWI2M2U5ZDNmZGFlNGIxZTJjODg2NTYuLmU3NjY2Njk1YmM2MzBl MjUyOTk4MmExMzVmMTI5NzE0NzQwNjkyNDMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3Qv ZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQKQEAgLTEsNTkgKzEsMTEg QEAKLVBBU1NFRAorQ2hlY2tzIHRoYXQgdGhlIHNjcm9sbCBldmVudCBmaXJlcyBvbiB0aGUgZG9j dW1lbnQgYXN5Y2hyb25vdXNseSBhbmQgb25seSBvbmNlLgogCi1JZiB0aGUgd29yZCAnUEFTU0VE JyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhl IHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLgor T24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9s bG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgogCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1hCi1h Ci1hCi1hCi1hCi1hCi1hCi1hCisKK1Njcm9sbCBldmVudCBidWJibGVzOiB0cnVlCitQQVNTIFNj cm9sbCBwb3NpdGlvbjogKDIwMCwgMjAwKQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1 ZQorCitURVNUIENPTVBMRVRFCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC5odG1sCmluZGV4IGEwNTZjMDY3YmQ5ZjI3YzRiMzQ2NWM4NGExNmUyMWE5ZmEz ZTcxNGMuLjkyMjQ3MGEyMzE0ZGU4Zjc5MzljNjFlMmE2YjAyOTA0ZDk5YWRkZWYgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbApAQCAtMSwzMCAr MSw0NSBAQAogPGh0bWw+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2pzL3Jlc291 cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pz LXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzxib2R5IHN0eWxlPSJtaW4td2lkdGg6IDUwMDBweDsg bWluLWhlaWdodDogNTAwMHB4Ij4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0i Y29uc29sZSI+PC9kaXY+CiA8c2NyaXB0PgotdmFyIGV2ZW50RmlyZWQgPSBmYWxzZTsKK2Rlc2Ny aXB0aW9uKCdDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIHRoZSBkb2N1bWVu dCBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuJyk7CiAKLWZ1bmN0aW9uIHNjcm9sbGVyKCkg ewotICAgIGlmICghZXZlbnRGaXJlZCkgewotICAgICAgICBldmVudEZpcmVkID0gdHJ1ZTsKLSAg ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInBhc3NlZCIpLmlubmVySFRNTCA9ICI8cCBz dHlsZT0nY29sb3I6cmVkJz5QQVNTRUQ8L3A+IjsKK3ZhciBldmVudENvdW50ID0gMDsKK3ZhciBk b25lVGltZW91dDsKKworb25zY3JvbGwgPSBmdW5jdGlvbihldmVudCkKK3sKKyAgICBldmVudENv dW50Kys7CisgICAgaWYgKGV2ZW50Q291bnQgPT0gMSkgeworICAgICAgICBkZWJ1ZygnU2Nyb2xs IGV2ZW50IGJ1YmJsZXM6ICcgKyBldmVudC5idWJibGVzKTsKKyAgICAgICAgdmFyIHNjcm9sbFgg PSBkb2N1bWVudC5ib2R5LnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gZG9jdW1l bnQuYm9keS5zY3JvbGxUb3A7CisgICAgICAgIHRlc3RQYXNzZWQoJ1Njcm9sbCBwb3NpdGlvbjog KCcgKyBzY3JvbGxYICsgJywgJyArIHNjcm9sbFkgKyAnKScpOworICAgICAgICAvLyBEb24ndCBj YWxsIG5vdGlmeURvbmUgc3RyYWlnaHQgYXdheSwgaW4gY2FzZSB0aGVyZSdzIGFub3RoZXIgc2Ny b2xsIGV2ZW50IGNvbWluZy4KKyAgICAgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZpbmlz aEpTVGVzdCwgMTAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBjbGVhclRpbWVvdXQoZG9uZVRp bWVvdXQpOworICAgICAgICB0ZXN0RmFpbGVkKCdTY3JvbGwgaGFuZGxlciB3YXMgaW52b2tlZCAn ICsgZXZlbnRDb3VudCArICcgdGltZXMnKTsKKyAgICAgICAgZmluaXNoSlNUZXN0KCk7CiAgICAg fQogfQogCi13aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgd2luZG93LmFkZEV2ZW50 TGlzdGVuZXIoJ3Njcm9sbCcsIHNjcm9sbGVyLCBmYWxzZSk7Ci0gICAgd2luZG93LnNjcm9sbFRv KDUwMCwgNTAwKTsKLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Ci0gICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK29ubG9hZCA9IGZ1bmN0aW9u KCkKK3sKKyAgICB3aW5kb3cuc2Nyb2xsVG8oMTAwLCAxMDApOworICAgIGlmIChldmVudENvdW50 ID4gMCkgeworICAgICAgdGVzdEZhaWxlZCgnU2Nyb2xsIGV2ZW50IGZpcmVkIHN5bmNocm9ub3Vz bHknKTsKKyAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0KKyAgICB3aW5kb3cuc2Nyb2xsVG8o MjAwLCAyMDApOwogfQogCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKK3ZhciBqc1Rl c3RJc0FzeW5jID0gdHJ1ZTsKIDwvc2NyaXB0PgotPGJvZHk+Ci08ZGl2IGlkPSJwYXNzZWQiPjwv ZGl2PgotCi08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIgYWJvdmUsIHRo ZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1lYW5zIHRoYXQg YSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KLQotYTxicj5hPGJyPmE8YnI+YTxicj5h PGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxi cj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxi cj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj4KLWE8YnI+YTxi cj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+ YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9q cy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5PgogPC9odG1sPgpcIE5vIG5ld2xpbmUg YXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3JlbW92 ZS1jaGlsZC1vbnNjcm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNo aWxkLW9uc2Nyb2xsLmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZlNTAyMjc4ZDM2ZWYxOGUwNzFmY2Iz NjU0Y2MzNS4uZWFiYjA3OWVhY2FhNzliODhlMGYwYWFkYTcwMTk1ZGUzOGIzNjNiOCAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwK QEAgLTksMTcgKzksMjggQEAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRpc3BhdGNoU2Nyb2xsRXZl bnRzKCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBpZiAod2luZG93LmV2ZW50U2Vu ZGVyICYmIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgICAg ICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAgICAgICAgICAg ICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAwKTsKICAgICAgICAgICAgICAgICAg ICAgZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7Ci0gICAgICAgICAgICAgICAgICAg IGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKLSAgICAgICAgICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgICAgICAgICB2 YXIgc2Nyb2xsQ291bnQgPSAwOworICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgnZHYnKS5hZGRFdmVudExpc3RlbmVyKAorICAgICAgICAgICAgICAgICAgICAgICAg J3Njcm9sbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbihldmVudCkgeworICAg ICAgICAgICAgICAgICAgICAgICAgICB0aGlzLnJlbW92ZUNoaWxkKHRoaXMuZmlyc3RDaGlsZCkK KyAgICAgICAgICAgICAgICAgICAgICAgICAgc2Nyb2xsQ291bnQrKzsKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgaWYgKHNjcm9sbENvdW50ID09IDEpCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAtMSk7CisgICAgICAgICAgICAg ICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0sCisg ICAgICAgICAgICAgICAgICAgICAgICBmYWxzZSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAg ICAgICAgfQogICAgICAgICA8L3NjcmlwdD4KICAgICA8L2hlYWQ+CiAgICAgPGJvZHkgb25sb2Fk PSJzZXRUaW1lb3V0KCdkaXNwYXRjaFNjcm9sbEV2ZW50cygpOycsIDEpOyI+CiAgICAgICAgIFRo aXMgdGVzdCB2ZXJpZmllcyB0aGF0IGNoaWxkcmVuIGNhbiBiZSByZW1vdmVkIGJ5IHRoZWlyIHBh cmVudCBlbGVtZW50J3Mgb25zY3JvbGwgZXZlbnQgaGFuZGxlci4gIFRoZSB0ZXN0IHN1Y2NlZWRz IGlmIHRoaXMgaXMgdGhlIG9ubHkgdGV4dCByZW1haW5pbmcgYWZ0ZXIgdGhlIHR3byBzY3JvbGwg ZXZlbnRzIGFyZSBkaXNwYXRjaGVkLiAgVGhlIHRlc3QgZmFpbHMgaWYgdGhlIGlubmVyIGRpdiBy ZW1haW5zIGluIHRoZSBvdXRwdXQgb3IgaWYgV2ViS2l0IGNyYXNoZXMuPGJyPjxicj4KLSAgICAg ICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWln aHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7IiBvbnNjcm9sbD0idGhpcy5yZW1vdmVDaGls ZCh0aGlzLmZpcnN0Q2hpbGQpIj4KKyAgICAgICAgPGRpdiBpZD0iZHYiIHN0eWxlPSJvdmVyZmxv dzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDIwMHB4OyB3aGl0ZXNwYWNlOiBub3dyYXA7 Ij4KICAgICAgICAgPGRpdiBzdHlsZT0id2lkdGg6MzAwcHg7IGhlaWdodDozMDBweCI+TG9yZW0g aXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBk byBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxp cXVhLiBVdCBlbmltIGFkIG1pbmltIHZlbmlhbSwgcXVpcyBub3N0cnVkIGV4ZXJjaXRhdGlvbiB1 bGxhbWNvIGxhYm9yaXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVhIGNvbW1vZG8gY29uc2VxdWF0LiBE dWlzIGF1dGUgaXJ1cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJpdCBpbiB2b2x1cHRhdGUgdmVsaXQg ZXNzZSBjaWxsdW0gZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBwYXJpYXR1ci4gRXhjZXB0ZXVyIHNp bnQgb2NjYWVjYXQgY3VwaWRhdGF0IG5vbiBwcm9pZGVudCwgc3VudCBpbiBjdWxwYSBxdWkgb2Zm aWNpYSBkZXNlcnVudCBtb2xsaXQgYW5pbSBpZCBlc3QgbGFib3J1bQogICAgICAgICA8L2Rpdj4K ICAgICAgICAgPC9kaXY+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3Jv bGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3Jv bGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwKaW5kZXggNGZjMTUyODRkZWYxZjU4ZDkzNzM1ZmFj YWRlNGE1NmQ3MTBkNTFmZS4uYWUxMmE3OWU1M2JmNjg0MGY4MjUzM2FjYjA0NDJhOTJjZTcyNzFm ZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29t LWNoYW5nZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1kdXJpbmct em9vbS1jaGFuZ2UuaHRtbApAQCAtMTYsNiArMTYsOSBAQAogICAgIGZ1bmN0aW9uIHNjcm9sbGVk KGV2ZW50KQogICAgIHsKICAgICAgICAgZXZlbnQudGFyZ2V0LnBhcmVudE5vZGUucmVtb3ZlQ2hp bGQoZXZlbnQudGFyZ2V0KTsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAg ICAgICB9CiAgICAgfQogCiAgICAgZnVuY3Rpb24gdGVzdCgpCkBAIC0yNyw3ICszMCw5IEBACiAg ICAgICAgIGRvY3VtZW50LmJvZHkuc3R5bGUuem9vbSA9IDI7CiAgICAgfQogCi0gICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CiAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgIH0KICAgICB0 ZXN0KCk7CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Nj cm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbAppbmRleCAyMjJhZGE4MDVkYTUzMDYy MmU0ZjgxZjViZGNlZjNhNzFhYzM2MDAwLi4xZTg1MTEzZjc3NDMzZGU4YWJlZTZmMzY3MTUxZTUy MDNlMmVlZDQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZl bnQtZG9lcy1ub3QtYnViYmxlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Ny b2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCkBAIC0xLDExICsxLDIyIEBACiA8aHRtbD4K IDxzY3JpcHQ+Cit2YXIgd2luZG93V2FzU2Nyb2xsZWQgPSBmYWxzZTsKK3ZhciBkb25lVGltZW91 dDsKKwogZnVuY3Rpb24gd2luZG93U2Nyb2xsZWQoKSB7CisgICAgd2luZG93V2FzU2Nyb2xsZWQg PSB0cnVlOwogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwg PSAnRkFJTFVSRTogd2luZG93Lm9uc2Nyb2xsIHdhcyBjYWxsZWQuJzsgCisgICAgY2xlYXJUaW1l b3V0KGRvbmVUaW1lb3V0KTsgICAgCiB9CiAKIGZ1bmN0aW9uIGRpdlNjcm9sbGVkKCkgewotICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lckhUTUwgPSAnU1VDQ0VTUzog ZGl2Lm9uc2Nyb2xsIHdhcyBjYWxsZWQsIGJ1dCB3aW5kb3cub25zY3JvbGwgd2FzIG5vdC4nOyAK KyAgICBpZiAoIXdpbmRvd1dhc1Njcm9sbGVkKQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2Fs bGVkLCBidXQgd2luZG93Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgLy8gRG9uJ3QgY2FsbCBu b3RpZnlEb25lIHN0cmFpZ2h0IGF3YXksIGluIGNhc2UgdGhlcmUncyBhbm90aGVyIHNjcm9sbCBl dmVudCBjb21pbmcvYnViYmxpbmcuCisgICAgZG9uZVRpbWVvdXQgPSBzZXRUaW1lb3V0KGZ1bmN0 aW9uKCkgeworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9LCAxMDAp OyAgICAKIH0KIAogZnVuY3Rpb24gcnVuVGVzdCgpIHsKQEAgLTI0LDEwICszNSw2IEBAIGZ1bmN0 aW9uIHJ1blRlc3QoKSB7CiAgICAgCiAgICAgLy8gRG9uJ3QgcG9sbHV0ZSB0aGUgdGVzdCByZXN1 bHQgd2l0aCBub25zZW5zZS4KICAgICBkaXYuaW5uZXJIVE1MID0gJyc7Ci0gICAgCi0gICAgaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgCi0gICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLm5vdGlmeURvbmUoKTsKLSAgICAKIH0KIAogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhhc2UtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi4zZTk0YTMwZDdkODc2ODE2N2Y4OWE3NGE1NWU1Y2I5ZjE2M2ZjNGViCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUZXN0cyB0aGF0IHdlIGNhbiBsaXN0ZW4gZm9y IHNjcm9sbCBldmVudHMgb24gdGhlIGRvY3VtZW50IGluIGJvdGggdGhlIGNhcHR1cmUgYW5kIGJ1 YmJsZSBwaGFzZXMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFT UyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitCb3RoIGNhcHR1 cmUgYW5kIGJ1YmJsZSBwaGFzZSBsaXN0ZW5lcnMgd2VyZSBpbnZva2VkLgorUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS5odG1sIGIvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYzBjZTVjMDJl MmFlMWQxZjJlZTE3YmYwMmIzYTU5NWNlMWQwODM4MAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS5odG1sCkBAIC0wLDAgKzEsNDUg QEAKKzxodG1sPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi9qcy9yZXNvdXJjZXMv anMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXByZS5qcyI+PC9zY3JpcHQ+Cis8Ym9keSBzdHlsZT0ibWluLWhlaWdodDogMjAwMHB4Ij4gCis8 cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2Ny aXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CitkZXNjcmlwdGlvbignVGVzdHMgdGhhdCB3ZSBj YW4gbGlzdGVuIGZvciBzY3JvbGwgZXZlbnRzIG9uIHRoZSBkb2N1bWVudCBpbiBib3RoIHRoZSBj YXB0dXJlIGFuZCBidWJibGUgcGhhc2VzLicpOworCit2YXIgdHJpZ2dlcmVkQ2FwdHVyZUxpc3Rl bmVyID0gZmFsc2U7Cit2YXIgdHJpZ2dlcmVkQnViYmxlTGlzdGVuZXIgPSBmYWxzZTsKKword2lu ZG93LmFkZEV2ZW50TGlzdGVuZXIoCisgICAgJ3Njcm9sbCcsCisgICAgZnVuY3Rpb24oKSB7Cisg ICAgICAgIHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciA9IHRydWU7CisgICAgICAgIGNoZWNrQ29t cGxldGUoKTsKKyAgICB9LAorICAgIHRydWUpOworCit3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcigK KyAgICAnc2Nyb2xsJywKKyAgICBmdW5jdGlvbihldmVudCkgeworICAgICAgICB0cmlnZ2VyZWRC dWJibGVMaXN0ZW5lciA9IHRydWU7CisgICAgICAgIGNoZWNrQ29tcGxldGUoKTsKKyAgICB9LAor ICAgIGZhbHNlKTsKKworZnVuY3Rpb24gY2hlY2tDb21wbGV0ZSgpCit7CisgICAgaWYgKHRyaWdn ZXJlZENhcHR1cmVMaXN0ZW5lciAmJiB0cmlnZ2VyZWRCdWJibGVMaXN0ZW5lcikgeworICAgICAg ICBkZWJ1ZygnQm90aCBjYXB0dXJlIGFuZCBidWJibGUgcGhhc2UgbGlzdGVuZXJzIHdlcmUgaW52 b2tlZC4nKTsKKyAgICAgICAgZmluaXNoSlNUZXN0KCk7CisgICAgfQorfQorCit3aW5kb3cuc2Ny b2xsVG8oMjAwLCAyMDApOworCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKK3ZhciBq c1Rlc3RJc0FzeW5jID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291 cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3JvbGwtaGFuZGxlci5o dG1sCmluZGV4IGJhMWEzNTE2NGM1NmIyYzQxZWEzODBiZWE3NjNlN2U0YTFlNTlmOTguLmQyZjlh YzY0NWU3ZDYxYjQ1MDFiMWIyYjhmNTBmYjY2OTU3N2E1NjIgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL2Zhc3QvbGF5ZXJzL3JlbW92ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWwKQEAgLTEx LDI5ICsxMSwzMyBAQAogPHA+CiAgICAgUmVzdWx0OiA8c3BhbiBpZD0icmVzdWx0Ij50ZXN0IGRp ZCBub3QgY29tcGxldGUuPC9zcGFuPgogPC9wPgotPGRpdiBpZD0idCIgc3R5bGU9Im92ZXJmbG93 OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0iaWYgKG92ZXJm bG93UmVtb3ZlKSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7Ij4KKzxkaXYgaWQ9 InQiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4OyIg b25zY3JvbGw9InRoaXMucGFyZW50Tm9kZS5yZW1vdmVDaGlsZCh0aGlzKTtoYW5kbGVTY3JvbGwo MCk7Ij4KICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMHB4OyI+PC9kaXY+CiA8L2Rpdj4KIAot PGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAxMDBweDsi IG9uc2Nyb2xsPSJpZiAoc2Vjb25kT3ZlcmZsb3dSZW1vdmUpIHRoaXMucGFyZW50Tm9kZS5yZW1v dmVDaGlsZCh0aGlzKTsiPgorPGRpdiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBw eDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQo dGhpcyk7aGFuZGxlU2Nyb2xsKDEpOyI+CiAgICAgPGRpdiBzdHlsZT0iaGVpZ2h0OiAyMDBweDsi PjwvZGl2PgogICAgIDxkaXYgaWQ9ImQiPjwvZGl2PgogPC9kaXY+CiAKIDxzY3JpcHQ+Ci0gICAg dmFyIG92ZXJmbG93UmVtb3ZlID0gZmFsc2U7Ci0gICAgdmFyIHNlY29uZE92ZXJmbG93UmVtb3Zl ID0gZmFsc2U7CisgICAgdmFyIHNjcm9sbGVkRmlyc3RDb250YWluZXIgPSBmYWxzZTsKKyAgICB2 YXIgc2Nyb2xsZWRTZWNvbmRDb250YWluZXIgPSBmYWxzZTsKIAogICAgIGRvY3VtZW50LmJvZHku b2Zmc2V0VG9wOyB0LnNjcm9sbFRvcCA9IDIwOwogCi0gICAgb3ZlcmZsb3dSZW1vdmUgPSB0cnVl OwotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0JykuaW5uZXJIVE1MID0gJyc7Ci0KLSAg ICBzZWNvbmRPdmVyZmxvd1JlbW92ZSA9IHRydWU7CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ2QnKS5zY3JvbGxJbnRvVmlldygpOwogICAgIAotICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCdyZXN1bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7Ci0KLSAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgZnVuY3Rpb24gaGFuZGxlU2Nyb2xsKGluZGV4KQorICAgIHsKKyAgICAgICAg aWYgKGluZGV4ID09IDApIHNjcm9sbGVkRmlyc3RDb250YWluZXIgPSB0cnVlOworICAgICAgICBl bHNlIGlmIChpbmRleCA9PSAxKSBzY3JvbGxlZFNlY29uZENvbnRhaW5lciA9IHRydWU7CisgICAg ICAgIAorICAgICAgICBpZiAoc2Nyb2xsZWRGaXJzdENvbnRhaW5lciAmJiBzY3JvbGxlZFNlY29u ZENvbnRhaW5lcikgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3Vs dCcpLmlubmVyVGV4dCA9ICJTVUNDRVNTIjsKKyAgICAgICAgCisgICAgICAgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQorICAgIH0KIDwvc2NyaXB0PgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNjcm9sbC1sYXllci1zZWxmLWRlc3Ry dWN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYt ZGVzdHJ1Y3QuaHRtbAppbmRleCA2NGIyMGFjNGFlZmRjZDU2MTRkMmM0OGMwM2U2Y2QyYTMyMmJk NGRlLi4zNTc0MTJmZTIzZmI2NmM1ZGVjMWRhMDU4YWVhNzUyYmUzNjEwNzhiIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYtZGVzdHJ1Y3Qu aHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L292ZXJmbG93L29uc2Nyb2xsLWxheWVyLXNlbGYt ZGVzdHJ1Y3QuaHRtbApAQCAtMSwxNCArMSwxNiBAQAogPGhlYWQ+CiA8c2NyaXB0PgogZnVuY3Rp b24gdGVzdCgpIHsKLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGlm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50 aWxEb25lKCk7CisgICAgfQogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJpdCIpLnNjcm9s bFRvcCA9IDEwMDsKIH0KIDwvc2NyaXB0PgogPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgogPHA+VGhp cyB0ZXN0IGludm9sdmVzIGEgbGF5ZXIgdGhhdCBzZWxmLWRlc3RydWN0cyB3aGVuIHNjcm9sbGVk LiBJZiB0aGVyZSdzIG5vIGNyYXNoLCB0aGVuIHRoZSB0ZXN0IHN1Y2NlZWRlZC48L3A+Ci08ZGl2 IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAwJTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0i c3R5bGUuZGlzcGxheSA9ICdub25lJyI+Cis8ZGl2IGlkPSJpdCIgc3R5bGU9ImhlaWdodDogMTAw JTsgb3ZlcmZsb3c6IGF1dG87IiBvbnNjcm9sbD0ic3R5bGUuZGlzcGxheSA9ICdub25lJztpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7Ij4KIDxkaXYgc3R5bGU9ImhlaWdodDogMjAwMHB4OyI+PC9kaXY+CiA8L2Rpdj4KIDwv Ym9keT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1cmlu Zy1zY3JvbGwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1cmluZy1z Y3JvbGwuaHRtbAppbmRleCBlM2YwYWM0NGMxOWJjYTVkYmRlMTRkMTM4NzNhMGNkNWYwZWU3MjBj Li5kYzY5NzEyMjE2ZjdiNTE2NjBhZTMyMjRiMmNlZWFlNDYxYjE0NGFhIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9mYXN0L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sCkBAIC0z LDYgKzMsOCBAQAogICAgIDxzY3JpcHQ+CiAgICAgICAgIGZ1bmN0aW9uIHJlcGFpbnRUZXN0KCkK ICAgICAgICAgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAg ICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIp OwogICAgICAgICAgICAgc2Nyb2xsQnkoMCwgMTAwKTsKICAgICAgICAgfQpAQCAtMTEsNiArMTMs OCBAQAogICAgICAgICB7CiAgICAgICAgICAgICB2YXIgdGFyZ2V0ID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInRhcmdldCIpOwogICAgICAgICAgICAgdGFyZ2V0LnN0eWxlLmJhY2tncm91bmRD b2xvciA9ICJncmVlbiI7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsK ICAgICAgICAgfQogICAgIDwvc2NyaXB0PgogPC9oZWFkPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGJhODQxNzQ0 ZjQ4NzNiNGIzYWI0ZGI3YjQyMGVlYWJiMDlkMWIyYWEuLjM0NjgxZGI5Mjc5Y2ExMWM2ODI5MDM1 ODMyMDllMzdjZjQ1YTY3YjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAxMS0wMS0x MCAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTY3JvbGwgZXZlbnQgc2hvdWxkIGJl IGZpcmVkIGFzeW5jaHJvbm91c2x5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD00NTYzMQorCisgICAgICAgIFRlc3RzOiBmYXN0L2V2ZW50cy9maXJlLXNj cm9sbC1ldmVudC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1l dmVudC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVu dC1waGFzZS5odG1sCisKKyAgICAgICAgTWFrZXMgc2Nyb2xsIGV2ZW50cyBmaXJlIGFzeW5jaHJv bm91c2x5IHRvIGJlIGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUKKyAgICAgICAgQ1NTT00gVmlldyBN b2R1bGUgYW5kIGNvbnNpc3RlbnQgd2l0aCBHZWNrbywgT3BlcmEgYW5kICh0byBzb21lIGRlZ3Jl ZSkKKyAgICAgICAgSUUuCisgICAgICAgIAorICAgICAgICBJbXBsZW1lbnRlZCB2aWEgdGhlIEV2 ZW50UXVldWUgY2xhc3MgYWRkZWQgYnkgcjc0MDYyIChFdmVudFF1ZXVlIG5vdworICAgICAgICBo YXMgYSBjb252ZW5pZW5jZSBlbnF1ZXVlU2Nyb2xsRXZlbnQgbWV0aG9kKS4KKworICAgICAgICAq IGRvbS9FdmVudFF1ZXVlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50UXVldWU6OmVucXVl dWVTY3JvbGxFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudFF1ZXVlOjpwZW5kaW5nRXZl bnRUaW1lckZpcmVkKToKKyAgICAgICAgKiBkb20vRXZlbnRRdWV1ZS5oOgorICAgICAgICAqIHBh Z2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6c2Vu ZFNjcm9sbEV2ZW50KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0KToKKyAgICAgICAgKiBy ZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMaXN0 Qm94Ojp2YWx1ZUNoYW5nZWQpOgorCiAyMDExLTAxLTEwICBKZXIgTm9ibGUgIDxqZXIubm9ibGVA YXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEZyYXNlci4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9FdmVudFF1ZXVlLmNwcAppbmRleCAyN2NkODAyYmJiMDRiMjg4NTE0OWE3ZTU3MTVhZTgwZmRj ZDEzZDVmLi4yZGE0YmNiOWIwNDgwZGQ2ZDI4NWIyM2Q3NDY4OGU3YmMwNjJkMWRiIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvZG9tL0V2ZW50UXVldWUuY3BwCkBAIC00OCwxMiArNDgsMjYgQEAgdm9pZCBFdmVudFF1ZXVl OjplbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpCiAgICAgICAgIG1fcGVuZGlu Z0V2ZW50VGltZXIuc3RhcnRPbmVTaG90KDApOwogfQogCit2b2lkIEV2ZW50UXVldWU6OmVucXVl dWVTY3JvbGxFdmVudChQYXNzUmVmUHRyPE5vZGU+IHRhcmdldCwgU2Nyb2xsRXZlbnRUYXJnZXRU eXBlIHRhcmdldFR5cGUpCit7CisgICAgaWYgKCFtX25vZGVzV2l0aFF1ZXVlZFNjcm9sbEV2ZW50 cy5hZGQodGFyZ2V0LmdldCgpKS5zZWNvbmQpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIFBl ciB0aGUgVzNDIENTU09NIFZpZXcgTW9kdWxlLCBzY3JvbGwgZXZlbnRzIGZpcmVkIGF0IHRoZSBk b2N1bWVudCBzaG91bGQgYnViYmxlLCBvdGhlcnMgc2hvdWxkIG5vdC4KKyAgICBib29sIGNhbkJ1 YmJsZSA9IHRhcmdldFR5cGUgPT0gU2Nyb2xsRXZlbnREb2N1bWVudFRhcmdldCA/IHRydWUgOiBm YWxzZTsKKyAgICBSZWZQdHI8RXZlbnQ+IHNjcm9sbEV2ZW50ID0gRXZlbnQ6OmNyZWF0ZShldmVu dE5hbWVzKCkuc2Nyb2xsRXZlbnQsIGNhbkJ1YmJsZSwgZmFsc2UgLyogbm9uIGNhbmNlbGxlYWJs ZSAqLyk7CisgICAgc2Nyb2xsRXZlbnQtPnNldFRhcmdldCh0YXJnZXQpOworICAgIGVucXVldWVF dmVudChzY3JvbGxFdmVudC5yZWxlYXNlKCkpOworfQorCiB2b2lkIEV2ZW50UXVldWU6OnBlbmRp bmdFdmVudFRpbWVyRmlyZWQoVGltZXI8RXZlbnRRdWV1ZT4qKQogewogICAgIEFTU0VSVCghbV9w ZW5kaW5nRXZlbnRUaW1lci5pc0FjdGl2ZSgpKTsKIAogICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ ID4gcXVldWVkRXZlbnRzOwogICAgIHF1ZXVlZEV2ZW50cy5zd2FwKG1fcXVldWVkRXZlbnRzKTsK KyAgICAKKyAgICBtX25vZGVzV2l0aFF1ZXVlZFNjcm9sbEV2ZW50cy5jbGVhcigpOwogCiAgICAg Zm9yIChzaXplX3QgaSA9IDA7IGkgPCBxdWV1ZWRFdmVudHMuc2l6ZSgpOyBpKyspCiAgICAgICAg IGRpc3BhdGNoRXZlbnQocXVldWVkRXZlbnRzW2ldLnJlbGVhc2UoKSk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0V2ZW50 UXVldWUuaAppbmRleCA4ZGQ3ZWM5YmIwNTMyZTdlOWQ2ODE1YzExMTNkYTg2YTIxOTU3MjM1Li43 ZjhkNWZiMjU0NjExNDZhZDQ3OTU0MmJhZjQ1YTc4MGNiOWQ2YWQ0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FdmVu dFF1ZXVlLmgKQEAgLTI4LDYgKzI4LDcgQEAKICNkZWZpbmUgRXZlbnRRdWV1ZV9oCiAKICNpbmNs dWRlICJUaW1lci5oIgorI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL05v bmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KQEAgLTQxLDkgKzQyLDE1IEBAIGNsYXNzIEV2ZW50UXVldWUgewogICAgIFdURl9NQUtF X05PTkNPUFlBQkxFKEV2ZW50UXVldWUpOwogCiBwdWJsaWM6CisgICAgZW51bSBTY3JvbGxFdmVu dFRhcmdldFR5cGUgeworICAgICAgICBTY3JvbGxFdmVudERvY3VtZW50VGFyZ2V0LAorICAgICAg ICBTY3JvbGxFdmVudEVsZW1lbnRUYXJnZXQKKyAgICB9OworCiAgICAgRXZlbnRRdWV1ZSgpOwog CiAgICAgdm9pZCBlbnF1ZXVlRXZlbnQoUGFzc1JlZlB0cjxFdmVudD4pOworICAgIHZvaWQgZW5x dWV1ZVNjcm9sbEV2ZW50KFBhc3NSZWZQdHI8Tm9kZT4sIFNjcm9sbEV2ZW50VGFyZ2V0VHlwZSk7 CiAKIHByaXZhdGU6CiAgICAgdm9pZCBwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPEV2ZW50 UXVldWU+Kik7CkBAIC01MSw2ICs1OCw3IEBAIHByaXZhdGU6CiAKICAgICBUaW1lcjxFdmVudFF1 ZXVlPiBtX3BlbmRpbmdFdmVudFRpbWVyOwogICAgIFZlY3RvcjxSZWZQdHI8RXZlbnQ+ID4gbV9x dWV1ZWRFdmVudHM7CisgICAgSGFzaFNldDxOb2RlKj4gbV9ub2Rlc1dpdGhRdWV1ZWRTY3JvbGxF dmVudHM7CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFu ZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggMDQ4 YTNjYzBjMzllY2I4ODJkYjIzMzkwNTA1NjA2MzNiNWU1YTg0Yi4uZDBmMTc1NmE5NTZmZTY2YzQy MGE1MjY2MmM4N2E5MWU5YWMyMjZhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9F dmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIkRyYWdDb250cm9sbGVyLmgiCiAjaW5jbHVk ZSAiRWRpdG9yLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVl dWUuaCIKICNpbmNsdWRlICJGbG9hdFBvaW50LmgiCiAjaW5jbHVkZSAiRmxvYXRSZWN0LmgiCiAj aW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCkBAIC0yNzk4LDcgKzI3OTksNyBAQCB2b2lkIEV2 ZW50SGFuZGxlcjo6c2VuZFNjcm9sbEV2ZW50KCkKIHsKICAgICBzZXRGcmFtZVdhc1Njcm9sbGVk QnlVc2VyKCk7CiAgICAgaWYgKG1fZnJhbWUtPnZpZXcoKSAmJiBtX2ZyYW1lLT5kb2N1bWVudCgp KQotICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT5kaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVh dGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCB0cnVlLCBmYWxzZSkpOworICAgICAgICBtX2Zy YW1lLT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVTY3JvbGxFdmVudChtX2ZyYW1l LT5kb2N1bWVudCgpLCBFdmVudFF1ZXVlOjpTY3JvbGxFdmVudERvY3VtZW50VGFyZ2V0KTsKIH0K IAogdm9pZCBFdmVudEhhbmRsZXI6OnNldEZyYW1lV2FzU2Nyb2xsZWRCeVVzZXIoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKaW5kZXggYmQ5NTRlZDMzN2VjZTFjOWY5 MWNkZjc0MDM2MjlkZmMzOTE5MDM5Yi4uYzMzZDMwNTlkM2VmNWExMDVkZjljODQzOTM3MTJmZjBm ZDU1ODJjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVy LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIuY3BwCkBAIC01 MSw3ICs1MSw3IEBACiAjaW5jbHVkZSAiQ2hyb21lLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIK ICNpbmNsdWRlICJFdmVudEhhbmRsZXIuaCIKLSNpbmNsdWRlICJFdmVudE5hbWVzLmgiCisjaW5j bHVkZSAiRXZlbnRRdWV1ZS5oIgogI2luY2x1ZGUgIkZsb2F0UG9pbnQzRC5oIgogI2luY2x1ZGUg IkZsb2F0UmVjdC5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgpAQCAtMTM5NywxMCAr MTM5Nyw3IEBAIHZvaWQgUmVuZGVyTGF5ZXI6OnNjcm9sbFRvT2Zmc2V0KGludCB4LCBpbnQgeSwg Ym9vbCB1cGRhdGVTY3JvbGxiYXJzLCBib29sIHJlcGFpCiAgICAgfQogCiAgICAgLy8gU2NoZWR1 bGUgdGhlIHNjcm9sbCBET00gZXZlbnQuCi0gICAgaWYgKHZpZXcpIHsKLSAgICAgICAgaWYgKEZy YW1lVmlldyogZnJhbWVWaWV3ID0gdmlldy0+ZnJhbWVWaWV3KCkpCi0gICAgICAgICAgICBmcmFt ZVZpZXctPnNjaGVkdWxlRXZlbnQoRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVzKCkuc2Nyb2xsRXZl bnQsIGZhbHNlLCBmYWxzZSksIHJlbmRlcmVyKCktPm5vZGUoKSk7Ci0gICAgfQorICAgIHJlbmRl cmVyKCktPm5vZGUoKS0+ZG9jdW1lbnQoKS0+ZXZlbnRRdWV1ZSgpLT5lbnF1ZXVlU2Nyb2xsRXZl bnQocmVuZGVyZXIoKS0+bm9kZSgpLCBFdmVudFF1ZXVlOjpTY3JvbGxFdmVudEVsZW1lbnRUYXJn ZXQpOwogfQogCiB2b2lkIFJlbmRlckxheWVyOjpzY3JvbGxSZWN0VG9WaXNpYmxlKGNvbnN0IElu dFJlY3QmIHJlY3QsIGJvb2wgc2Nyb2xsVG9BbmNob3IsIGNvbnN0IFNjcm9sbEFsaWdubWVudCYg YWxpZ25YLCBjb25zdCBTY3JvbGxBbGlnbm1lbnQmIGFsaWduWSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcAppbmRleCBlZDdmOGVlZDhlYmFmNTRmYTNhMmE0NWMx MmE1Njg1NDFkZjIyMjU3Li5kNWY2MGFlNmRkOGNlZmZiOTM2NDg2MGU2NDJkNDhkNTdlMGIwMjA1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCkBAIC0zNiw3 ICszNiw3IEBACiAjaW5jbHVkZSAiQ1NTU3R5bGVTZWxlY3Rvci5oIgogI2luY2x1ZGUgIkRvY3Vt ZW50LmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0jaW5jbHVkZSAiRXZlbnROYW1lcy5o IgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIuaCIK ICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgpAQCAtNTQ1LDcgKzU0 NSw3IEBAIHZvaWQgUmVuZGVyTGlzdEJveDo6dmFsdWVDaGFuZ2VkKFNjcm9sbGJhciopCiAgICAg aWYgKG5ld09mZnNldCAhPSBtX2luZGV4T2Zmc2V0KSB7CiAgICAgICAgIG1faW5kZXhPZmZzZXQg PSBuZXdPZmZzZXQ7CiAgICAgICAgIHJlcGFpbnQoKTsKLSAgICAgICAgbm9kZSgpLT5kaXNwYXRj aEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFs c2UpKTsKKyAgICAgICAgbm9kZSgpLT5kb2N1bWVudCgpLT5ldmVudFF1ZXVlKCktPmVucXVldWVT Y3JvbGxFdmVudChub2RlKCksIEV2ZW50UXVldWU6OlNjcm9sbEV2ZW50RWxlbWVudFRhcmdldCk7 CiAgICAgfQogfQogCg== 78582 2011-01-11 12:41:38 -0800 2011-01-11 14:47:30 -0800 Patch for landing bug-45631-20110111124137.patch text/plain 28427 mihaip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1NjgwNjRkNDI4YjFhMjFmMDA4NDRiNmRmODhkOTk2NDE3ZTllMDE4Li44YzRkYjA4 ODhjOWZiYzgzMGQxZjFjMzU1MjZjNWQ1NTIwNTA5MDlmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTEtMDEtMTAgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gRmlzaGVyLgorCisgICAgICAgIFNjcm9sbCBldmVudCBz aG91bGQgYmUgZmlyZWQgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NjMxCisgICAgICAgIAorICAgICAgICBVcGRhdGUgZXhp c3RpbmcgdGVzdHMgdGhhdCBhc3N1bWVkIHRoYXQgc2Nyb2xsIGV2ZW50cyBmaXJlZAorICAgICAg ICBzeW5jaHJvbm91c2x5LgorCisgICAgICAgICogZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRvd24t c2Nyb2xscy1leHBlY3RlZC50eHQ6CisgICAgICAgICogZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRv d24tc2Nyb2xscy5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50 LWVsZW1lbnQtZXhwZWN0ZWQudHh0OiBDb3BpZWQgZnJvbSBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50 cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQuCisgICAgICAgICogZmFzdC9ldmVudHMv ZmlyZS1zY3JvbGwtZXZlbnQtZWxlbWVudC5odG1sOiBBZGRlZC4gRG9lcyB0aGUgc2FtZQorICAg ICAgICAgICAgdGVzdHMgYXMgZmlyZS1zY3JvbGwtZXZlbnQuaHRtbCwgYnV0IG9uIGFuIGluZGl2 aWR1YWwgZWxlbWVudCBpbnN0ZWFkCisgICAgICAgICAgICBvZiB0aGUgd2hvbGUgZG9jdW1lbnQu CisgICAgICAgICogZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0Ogor ICAgICAgICAqIGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWw6IE5vdyBleHBsaWNp dGx5IHRlc3RzIGZvcgorICAgICAgICAgICAgc3luY2hyb25vdXMgYmVoYXZpb3Igd2hlbiBzY3Jv bGxpbmcgdGhlIGRvY3VtZW50LCBhbmQgdGhhdCB3ZSBkb24ndAorICAgICAgICAgICAgZmlyZSB0 aGUgZXZlbnQgbW9yZSB0aGFuIG9uY2UuCisgICAgICAgICogZmFzdC9ldmVudHMvcmVtb3ZlLWNo aWxkLW9uc2Nyb2xsLmh0bWw6CisgICAgICAgICogZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16 b29tLWNoYW5nZS5odG1sOgorICAgICAgICAqIGZhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2Vz LW5vdC1idWJibGUuaHRtbDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhh c2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JvbGwtZXZl bnQtcGhhc2UuaHRtbDogQWRkZWQuIENoZWNrcyB0aGF0IHdlIGNhbiBsaXN0ZW4KKyAgICAgICAg ICAgIGZvciBzY3JvbGwgZXZlbnRzIGluIGJvdGggdGhlIGNhcHR1cmUgYW5kIGJ1YmJsZSBwaGFz ZS4KKyAgICAgICAgKiBmYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1oYW5kbGVyLmh0bWw6 CisgICAgICAgICogZmFzdC9vdmVyZmxvdy9vbnNjcm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0 bWw6CisgICAgICAgICogZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVyaW5nLXNjcm9sbC5odG1sOgor CiAyMDExLTAxLTExICBaaGVueWFvIE1vICA8em1vQGdvb2dsZS5jb20+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgdGVzdCBleHBlY3RhdGlvbiB1cGRhdGUuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0Cmlu ZGV4IDI0ZGVlNGQ4ODhkYjFkYWI0NjgwYzMwNmY4MmI2NGJmNjI2M2Q2NjQuLmI1YjBjZjBmNTQ2 YzJlNDFlZTFjNzg0YzA1Y2FiMjM3MDRhYjk2YjUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Vk aXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91 dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1kb3duLXNjcm9sbHMtZXhwZWN0ZWQudHh0CkBA IC0xLDQgKzEsNCBAQAogeHgKLVRoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFu ZCBwYWdlIGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4 YWN0bHkgb25lIHNjcm9sbCBldmVudC4gVGhpcyB0ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLgor VGhpcyB0ZXN0IHNpbXVsYXRlcyBoaXR0aW5nIHBhZ2UgdXAgYW5kIHBhZ2UgZG93biBvbmNlIGVh Y2guIEJvdGgga2V5cHJlc3NlcyBzaG91bGQgZ2VuZXJhdGUgZXhhY3RseSBvbmUgc2Nyb2xsIGV2 ZW50LiBJZiBydW5uaW5nIG1hbnVhbGx5LCBwcmVzcyB0aGUga2V5cyBub3cuCiBQQVNTCiAoanVz dCBoZXJlIHRvIGZvcmNlIHNjcm9sbGJhcnMpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0 aW5nL2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2lucHV0L3BhZ2UtdXAtZG93bi1zY3JvbGxzLmh0bWwKaW5kZXggZmM4M2IxNDgyM2QyZWQ3MGRi MzI1MDA4OTViMTRjY2IzYmE5NzFlNy4uZTViYWJjN2RiMGNiYjBkYTIyN2MxYzkzODZmZDlmNDli NDZiYTI1ZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9wYWdlLXVwLWRv d24tc2Nyb2xscy5odG1sCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvcGFnZS11cC1k b3duLXNjcm9sbHMuaHRtbApAQCAtMiwzOCArMiw0MSBAQAogPGh0bWw+CiA8aGVhZD4KIDxzY3Jp cHQ+Ci1pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQoraWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgewogICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7Cit9CiAKLWZ1bmN0aW9u IHNjcigpCi17Cit2YXIgc3RlcCA9IDA7CisKK29uc2Nyb2xsID0gZnVuY3Rpb24oKSB7CiAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dCArPSAneCc7CisKKyAgICBz d2l0Y2ggKHN0ZXApIHsKKyAgICBjYXNlIDA6CisgICAgICAgIGlmICh3aW5kb3cuZXZlbnRTZW5k ZXIpCisgICAgICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKCdwYWdlVXAnKTsKKyAgICAgICAg ICAgIGJyZWFrOworICAgIGNhc2UgMToKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo J3Jlc3VsdHMnKS5pbm5lclRleHQgPSAnUEFTUyc7CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICAKKyAgICBzdGVwKys7CiB9CiAKIGZ1 bmN0aW9uIHJ1blRlc3QoKQogewotICAgIGlmICghd2luZG93LmV2ZW50U2VuZGVyKQotICAgICAg ICByZXR1cm47Ci0KLSAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcignc2Nyb2xsJywgc2NyLCBm YWxzZSk7Ci0KLSAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIpOwotICAgIHZhciB0 ZXh0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xvZycpLmlubmVyVGV4dDsKLSAgICBpZiAo dGV4dCAhPSAieCIpCi0gICAgICAgIHRocm93ICJsb2cgc2hvdWxkIGNvbnRhaW4geCwgbm90ICIg KyB0ZXh0OwotCi0gICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIik7Ci0gICAgdmFyIHRl eHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbG9nJykuaW5uZXJUZXh0OwotICAgIGlmICh0 ZXh0ICE9ICJ4eCIpCi0gICAgICAgIHRocm93ICJsb2cgc2hvdWxkIGNvbnRhaW4geHgsIG5vdCAi ICsgdGV4dDsKLQotICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJU ZXh0ID0gIlBBU1MiOworICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgIGV2ZW50 U2VuZGVyLmtleURvd24oJ3BhZ2VEb3duJyk7CiB9CiA8L3NjcmlwdD4KIDwvaGVhZD4KIDxib2R5 IG9ubG9hZD0icnVuVGVzdCgpIj4gCiA8c3BhbiBpZD0ibG9nIiBzdHlsZT0icG9zaXRpb246Zml4 ZWQiPjwvc3Bhbj4gCi08ZGl2PlRoaXMgdGVzdCBzaW11bGF0ZXMgaGl0dGluZyBwYWdlIHVwIGFu ZCBwYWdlIGRvd24gb25jZSBlYWNoLiBCb3RoIGtleXByZXNzZXMgc2hvdWxkIGdlbmVyYXRlIGV4 YWN0bHkgb25lIHNjcm9sbCBldmVudC4gVGhpcyB0ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLjwv ZGl2PgorPGRpdj5UaGlzIHRlc3Qgc2ltdWxhdGVzIGhpdHRpbmcgcGFnZSB1cCBhbmQgcGFnZSBk b3duIG9uY2UgZWFjaC4gQm90aCBrZXlwcmVzc2VzIHNob3VsZCBnZW5lcmF0ZSBleGFjdGx5IG9u ZSBzY3JvbGwgZXZlbnQuIElmIHJ1bm5pbmcgbWFudWFsbHksIHByZXNzIHRoZSBrZXlzIG5vdy48 L2Rpdj4KIDxkaXYgaWQ9InJlc3VsdHMiPkZBSUw8L2Rpdj4KIDxkaXYgc3R5bGU9ImhlaWdodDo1 MDAwMHB4Ij4oanVzdCBoZXJlIHRvIGZvcmNlIHNjcm9sbGJhcnMpPC9kaXY+IAogPHNjcmlwdD4g CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1l bGVtZW50LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xs LWV2ZW50LWVsZW1lbnQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNmZTZhNTZmOTAyYTBkYWZj YzVmZTkxNzdlNjI5NmQxMzhmNjRiMzMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1lbGVtZW50LWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDExIEBACitDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIGVsZW1lbnRz IGFzeWNocm9ub3VzbHkgYW5kIG9ubHkgb25jZS4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2Vl IGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUi LgorCisKK1Njcm9sbCBldmVudCBidWJibGVzOiBmYWxzZQorUEFTUyBTY3JvbGwgcG9zaXRpb246 ICgwLCAyMDApCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExF VEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZl bnQtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdjOThiYWQ1MzQ5ZTdjZDZkYzFlMDYxYjJhZjJl ZThiNDhiY2M2NGYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9m aXJlLXNjcm9sbC1ldmVudC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw1MSBAQAorPGh0bWw+Cis8 bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxl LmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3Nj cmlwdD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KKzxkaXYgaWQ9ImNvbnRhaW5lciIgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0 aDogNTAwcHg7IGhlaWdodDogNTAwcHgiPgorICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDUwMDBweDsg d2lkdGg6IDUwMDBweDsiPjwvZGl2PgorPC9kaXY+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ0No ZWNrcyB0aGF0IHRoZSBzY3JvbGwgZXZlbnQgZmlyZXMgb24gZWxlbWVudHMgYXN5Y2hyb25vdXNs eSBhbmQgb25seSBvbmNlLicpOworCit2YXIgZXZlbnRDb3VudCA9IDA7Cit2YXIgZG9uZVRpbWVv dXQ7CisKK2Z1bmN0aW9uIHNjcm9sbEhhbmRsZXIoZXZlbnQpCit7CisgICAgZXZlbnRDb3VudCsr OworICAgIGlmIChldmVudENvdW50ID09IDEpIHsKKyAgICAgICAgZGVidWcoJ1Njcm9sbCBldmVu dCBidWJibGVzOiAnICsgZXZlbnQuYnViYmxlcyk7CisgICAgICAgIHZhciBjb250YWluZXIgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29udGFpbmVyJyk7CisgICAgICAgIHZhciBzY3JvbGxY ID0gY29udGFpbmVyLnNjcm9sbExlZnQ7CisgICAgICAgIHZhciBzY3JvbGxZID0gY29udGFpbmVy LnNjcm9sbFRvcDsKKyAgICAgICAgdGVzdFBhc3NlZCgnU2Nyb2xsIHBvc2l0aW9uOiAoJyArIHNj cm9sbFggKyAnLCAnICsgc2Nyb2xsWSArICcpJyk7CisgICAgICAgIC8vIERvbid0IGNhbGwgbm90 aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZl bnQgY29taW5nLgorICAgICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQoZmluaXNoSlNUZXN0 LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyVGltZW91dChkb25lVGltZW91dCk7 CisgICAgICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBoYW5kbGVyIHdhcyBpbnZva2VkICcgKyBldmVu dENvdW50ICsgJyB0aW1lcycpOworICAgICAgICBmaW5pc2hKU1Rlc3QoKTsKKyAgICB9Cit9CisK K29ubG9hZCA9IGZ1bmN0aW9uKCkKK3sKKyAgICB2YXIgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2NvbnRhaW5lcicpOworICAgIGNvbnRhaW5lci5hZGRFdmVudExpc3RlbmVy KCdzY3JvbGwnLCBzY3JvbGxIYW5kbGVyLCBmYWxzZSk7CisgICAgY29udGFpbmVyLnNjcm9sbFRv cCA9IDEwMDsKKyAgICBpZiAoZXZlbnRDb3VudCA+IDApIHsKKyAgICAgIHRlc3RGYWlsZWQoJ1Nj cm9sbCBldmVudCBmaXJlZCBzeW5jaHJvbm91c2x5Jyk7CisgICAgICBmaW5pc2hKU1Rlc3QoKTsK KyAgICB9CisgICAgY29udGFpbmVyLnNjcm9sbFRvcCA9IDIwMDsKK30KKwordmFyIHN1Y2Nlc3Nm dWxseVBhcnNlZCA9IHRydWU7Cit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7Cis8L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4K KzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC1leHBlY3RlZC50eHQK aW5kZXggMTY4NmNlZDM5YWUyYmUyZDU5YjYzZTlkM2ZkYWU0YjFlMmM4ODY1Ni4uZTc2NjY2OTVi YzYzMGUyNTI5OTgyYTEzNWYxMjk3MTQ3NDA2OTI0MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRl c3RzL2Zhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWV4cGVjdGVkLnR4dApAQCAtMSw1OSAr MSwxMSBAQAotUEFTU0VECitDaGVja3MgdGhhdCB0aGUgc2Nyb2xsIGV2ZW50IGZpcmVzIG9uIHRo ZSBkb2N1bWVudCBhc3ljaHJvbm91c2x5IGFuZCBvbmx5IG9uY2UuCiAKLUlmIHRoZSB3b3JkICdQ QVNTRUQnIGRvZXMgbm90IGFwcGVhciBhYm92ZSwgdGhlbiB0aGUgdGVzdCBoYXMgZmFpbGVkLiBJ ZiB0aGUgdGVzdCBmYWlscywgaXQgbWVhbnMgdGhhdCBhIHNjcm9sbCBldmVudCBkaWQgbm90IGZp cmUuCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2Vz LCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCiAKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEK LWEKLWEKLWEKLWEKLWEKLWEKLWEKLWEKKworU2Nyb2xsIGV2ZW50IGJ1YmJsZXM6IHRydWUKK1BB U1MgU2Nyb2xsIHBvc2l0aW9uOiAoMjAwLCAyMDApCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBp cyB0cnVlCisKK1RFU1QgQ09NUExFVEUKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2Zp cmUtc2Nyb2xsLWV2ZW50Lmh0bWwKaW5kZXggYTA1NmMwNjdiZDlmMjdjNGIzNDY1Yzg0YTE2ZTIx YTlmYTNlNzE0Yy4uODE3MGIxMjBkZWNhZjdhMzk5ZjZjZDY4NTk1MjZlMDg5NmEyYmM3YyAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZmlyZS1zY3JvbGwtZXZlbnQuaHRtbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9maXJlLXNjcm9sbC1ldmVudC5odG1sCkBAIC0x LDMwICsxLDQ1IEBACiA8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vanMv cmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHkgc3R5bGU9Im1pbi13aWR0aDogNTAw MHB4OyBtaW4taGVpZ2h0OiA1MDAwcHgiPgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2 IGlkPSJjb25zb2xlIj48L2Rpdj4KIDxzY3JpcHQ+Ci12YXIgZXZlbnRGaXJlZCA9IGZhbHNlOwor ZGVzY3JpcHRpb24oJ0NoZWNrcyB0aGF0IHRoZSBzY3JvbGwgZXZlbnQgZmlyZXMgb24gdGhlIGRv Y3VtZW50IGFzeWNocm9ub3VzbHkgYW5kIG9ubHkgb25jZS4nKTsKIAotZnVuY3Rpb24gc2Nyb2xs ZXIoKSB7Ci0gICAgaWYgKCFldmVudEZpcmVkKSB7Ci0gICAgICAgIGV2ZW50RmlyZWQgPSB0cnVl OwotICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicGFzc2VkIikuaW5uZXJIVE1MID0g IjxwIHN0eWxlPSdjb2xvcjpyZWQnPlBBU1NFRDwvcD4iOwordmFyIGV2ZW50Q291bnQgPSAwOwor dmFyIGRvbmVUaW1lb3V0OworCitvbnNjcm9sbCA9IGZ1bmN0aW9uKGV2ZW50KQoreworICAgIGV2 ZW50Q291bnQrKzsKKyAgICBpZiAoZXZlbnRDb3VudCA9PSAxKSB7CisgICAgICAgIGRlYnVnKCdT Y3JvbGwgZXZlbnQgYnViYmxlczogJyArIGV2ZW50LmJ1YmJsZXMpOworICAgICAgICB2YXIgc2Ny b2xsWCA9IGRvY3VtZW50LmJvZHkuc2Nyb2xsTGVmdDsKKyAgICAgICAgdmFyIHNjcm9sbFkgPSBk b2N1bWVudC5ib2R5LnNjcm9sbFRvcDsKKyAgICAgICAgdGVzdFBhc3NlZCgnU2Nyb2xsIHBvc2l0 aW9uOiAoJyArIHNjcm9sbFggKyAnLCAnICsgc2Nyb2xsWSArICcpJyk7CisgICAgICAgIC8vIERv bid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRoZXJlJ3MgYW5vdGhl ciBzY3JvbGwgZXZlbnQgY29taW5nLgorICAgICAgICBkb25lVGltZW91dCA9IHNldFRpbWVvdXQo ZmluaXNoSlNUZXN0LCAxMDApOworICAgIH0gZWxzZSB7CisgICAgICAgIGNsZWFyVGltZW91dChk b25lVGltZW91dCk7CisgICAgICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBoYW5kbGVyIHdhcyBpbnZv a2VkICcgKyBldmVudENvdW50ICsgJyB0aW1lcycpOworICAgICAgICBmaW5pc2hKU1Rlc3QoKTsK ICAgICB9CiB9CiAKLXdpbmRvdy5vbmxvYWQgPSBmdW5jdGlvbigpIHsKLSAgICB3aW5kb3cuYWRk RXZlbnRMaXN0ZW5lcignc2Nyb2xsJywgc2Nyb2xsZXIsIGZhbHNlKTsKLSAgICB3aW5kb3cuc2Ny b2xsVG8oNTAwLCA1MDApOwotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsK LSAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworb25sb2FkID0gZnVu Y3Rpb24oKQoreworICAgIHdpbmRvdy5zY3JvbGxUbygxMDAsIDEwMCk7CisgICAgaWYgKGV2ZW50 Q291bnQgPiAwKSB7CisgICAgICAgIHRlc3RGYWlsZWQoJ1Njcm9sbCBldmVudCBmaXJlZCBzeW5j aHJvbm91c2x5Jyk7CisgICAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0KKyAgICB3aW5kb3cu c2Nyb2xsVG8oMjAwLCAyMDApOwogfQogCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsK K3ZhciBqc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKIDwvc2NyaXB0PgotPGJvZHk+Ci08ZGl2IGlkPSJw YXNzZWQiPjwvZGl2PgotCi08cD5JZiB0aGUgd29yZCAnUEFTU0VEJyBkb2VzIG5vdCBhcHBlYXIg YWJvdmUsIHRoZW4gdGhlIHRlc3QgaGFzIGZhaWxlZC4gSWYgdGhlIHRlc3QgZmFpbHMsIGl0IG1l YW5zIHRoYXQgYSBzY3JvbGwgZXZlbnQgZGlkIG5vdCBmaXJlLjwvcD4KLQotYTxicj5hPGJyPmE8 YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+Ci1hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJy PmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj4K LWE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5h PGJyPmE8YnI+YTxicj5hPGJyPmE8YnI+YTxicj5hPGJyPgorPHNjcmlwdCBzcmM9Ii4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgogPC9ib2R5PgogPC9odG1sPgpcIE5v IG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZl bnRzL3JlbW92ZS1jaGlsZC1vbnNjcm9sbC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv cmVtb3ZlLWNoaWxkLW9uc2Nyb2xsLmh0bWwKaW5kZXggMjUyY2ZlYTMzMGZlNTAyMjc4ZDM2ZWYx OGUwNzFmY2IzNjU0Y2MzNS4uMTA5YTVkNjI3MzNhZjRhOTMwODRkNTVjNGQyYTE1ZGNjMDZhZTNh NyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Ny b2xsLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvcmVtb3ZlLWNoaWxkLW9uc2Ny b2xsLmh0bWwKQEAgLTksMTcgKzksMjggQEAKICAgICAgICAgICAgIGZ1bmN0aW9uIGRpc3BhdGNo U2Nyb2xsRXZlbnRzKCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBpZiAod2luZG93 LmV2ZW50U2VuZGVyICYmIHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CiAgICAgICAg ICAgICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKDEwMCwgMTAwKTsKICAgICAgICAg ICAgICAgICAgICAgZXZlbnRTZW5kZXIubW91c2VTY3JvbGxCeSgwLCAtMSk7Ci0gICAgICAgICAg ICAgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlU2Nyb2xsQnkoLTEsIC0xKTsKLSAgICAgICAgICAg ICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAg ICAgICAgICB2YXIgc2Nyb2xsQ291bnQgPSAwOworICAgICAgICAgICAgICAgICAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnZHYnKS5hZGRFdmVudExpc3RlbmVyKAorICAgICAgICAgICAgICAg ICAgICAgICAgJ3Njcm9sbCcsCisgICAgICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbihldmVu dCkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQodGhpcy5m aXJzdENoaWxkKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBzY3JvbGxDb3VudCsrOwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChzY3JvbGxDb3VudCA9PSAxKQorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBldmVudFNlbmRlci5tb3VzZVNjcm9sbEJ5KC0xLCAt MSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAg ICAgICAgICAgICAgICAgICB9LAorICAgICAgICAgICAgICAgICAgICAgICAgZmFsc2UpOwogICAg ICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH0KICAgICAgICAgPC9zY3JpcHQ+CiAgICAgPC9o ZWFkPgogICAgIDxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgnZGlzcGF0Y2hTY3JvbGxFdmVudHMo KTsnLCAxKTsiPgogICAgICAgICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBjaGlsZHJlbiBjYW4g YmUgcmVtb3ZlZCBieSB0aGVpciBwYXJlbnQgZWxlbWVudCdzIG9uc2Nyb2xsIGV2ZW50IGhhbmRs ZXIuICBUaGUgdGVzdCBzdWNjZWVkcyBpZiB0aGlzIGlzIHRoZSBvbmx5IHRleHQgcmVtYWluaW5n IGFmdGVyIHRoZSB0d28gc2Nyb2xsIGV2ZW50cyBhcmUgZGlzcGF0Y2hlZC4gIFRoZSB0ZXN0IGZh aWxzIGlmIHRoZSBpbm5lciBkaXYgcmVtYWlucyBpbiB0aGUgb3V0cHV0IG9yIGlmIFdlYktpdCBj cmFzaGVzLjxicj48YnI+Ci0gICAgICAgIDxkaXYgaWQ9ImR2IiBzdHlsZT0ib3ZlcmZsb3c6IGF1 dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAyMDBweDsgd2hpdGVzcGFjZTogbm93cmFwOyIgb25z Y3JvbGw9InRoaXMucmVtb3ZlQ2hpbGQodGhpcy5maXJzdENoaWxkKSI+CisgICAgICAgIDxkaXYg aWQ9ImR2IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAyMDBweDsgaGVpZ2h0OiAyMDBw eDsgd2hpdGVzcGFjZTogbm93cmFwOyI+CiAgICAgICAgIDxkaXYgc3R5bGU9IndpZHRoOjMwMHB4 OyBoZWlnaHQ6MzAwcHgiPkxvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBh ZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJv cmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4gVXQgZW5pbSBhZCBtaW5pbSB2ZW5pYW0sIHF1aXMg bm9zdHJ1ZCBleGVyY2l0YXRpb24gdWxsYW1jbyBsYWJvcmlzIG5pc2kgdXQgYWxpcXVpcCBleCBl YSBjb21tb2RvIGNvbnNlcXVhdC4gRHVpcyBhdXRlIGlydXJlIGRvbG9yIGluIHJlcHJlaGVuZGVy aXQgaW4gdm9sdXB0YXRlIHZlbGl0IGVzc2UgY2lsbHVtIGRvbG9yZSBldSBmdWdpYXQgbnVsbGEg cGFyaWF0dXIuIEV4Y2VwdGV1ciBzaW50IG9jY2FlY2F0IGN1cGlkYXRhdCBub24gcHJvaWRlbnQs IHN1bnQgaW4gY3VscGEgcXVpIG9mZmljaWEgZGVzZXJ1bnQgbW9sbGl0IGFuaW0gaWQgZXN0IGxh Ym9ydW0KICAgICAgICAgPC9kaXY+CiAgICAgICAgIDwvZGl2PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWR1cmluZy16b29tLWNoYW5nZS5odG1sCmluZGV4IDRm YzE1Mjg0ZGVmMWY1OGQ5MzczNWZhY2FkZTRhNTZkNzEwZDUxZmUuLmFlMTJhNzllNTNiZjY4NDBm ODI1MzNhY2IwNDQyYTkyY2U3MjcxZmYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvZXZl bnRzL3Njcm9sbC1kdXJpbmctem9vbS1jaGFuZ2UuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2V2ZW50cy9zY3JvbGwtZHVyaW5nLXpvb20tY2hhbmdlLmh0bWwKQEAgLTE2LDYgKzE2LDkgQEAK ICAgICBmdW5jdGlvbiBzY3JvbGxlZChldmVudCkKICAgICB7CiAgICAgICAgIGV2ZW50LnRhcmdl dC5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKGV2ZW50LnRhcmdldCk7CisgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIGZ1bmN0aW9uIHRlc3Qo KQpAQCAtMjcsNyArMzAsOSBAQAogICAgICAgICBkb2N1bWVudC5ib2R5LnN0eWxlLnpvb20gPSAy OwogICAgIH0KIAotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewogICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRp bERvbmUoKTsKKyAgICB9CiAgICAgdGVzdCgpOwogPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtZG9lcy1ub3QtYnViYmxlLmh0bWwK aW5kZXggMjIyYWRhODA1ZGE1MzA2MjJlNGY4MWY1YmRjZWYzYTcxYWMzNjAwMC4uMWU4NTExM2Y3 NzQzM2RlOGFiZWU2ZjM2NzE1MWU1MjAzZTJlZWQ0MCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LWRvZXMtbm90LWJ1YmJsZS5odG1sCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1kb2VzLW5vdC1idWJibGUuaHRtbApAQCAt MSwxMSArMSwyMiBAQAogPGh0bWw+CiA8c2NyaXB0PgordmFyIHdpbmRvd1dhc1Njcm9sbGVkID0g ZmFsc2U7Cit2YXIgZG9uZVRpbWVvdXQ7CisKIGZ1bmN0aW9uIHdpbmRvd1Njcm9sbGVkKCkgewor ICAgIHdpbmRvd1dhc1Njcm9sbGVkID0gdHJ1ZTsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgncmVzdWx0JykuaW5uZXJIVE1MID0gJ0ZBSUxVUkU6IHdpbmRvdy5vbnNjcm9sbCB3YXMgY2Fs bGVkLic7IAorICAgIGNsZWFyVGltZW91dChkb25lVGltZW91dCk7ICAgIAogfQogCiBmdW5jdGlv biBkaXZTY3JvbGxlZCgpIHsKLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0Jyku aW5uZXJIVE1MID0gJ1NVQ0NFU1M6IGRpdi5vbnNjcm9sbCB3YXMgY2FsbGVkLCBidXQgd2luZG93 Lm9uc2Nyb2xsIHdhcyBub3QuJzsgCisgICAgaWYgKCF3aW5kb3dXYXNTY3JvbGxlZCkKKyAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpLmlubmVySFRNTCA9ICdTVUNDRVNT OiBkaXYub25zY3JvbGwgd2FzIGNhbGxlZCwgYnV0IHdpbmRvdy5vbnNjcm9sbCB3YXMgbm90Lic7 IAorICAgIC8vIERvbid0IGNhbGwgbm90aWZ5RG9uZSBzdHJhaWdodCBhd2F5LCBpbiBjYXNlIHRo ZXJlJ3MgYW5vdGhlciBzY3JvbGwgZXZlbnQgY29taW5nL2J1YmJsaW5nLgorICAgIGRvbmVUaW1l b3V0ID0gc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKKyAgICAgICAgfSwgMTAwKTsgICAgCiB9CiAKIGZ1bmN0aW9uIHJ1blRlc3QoKSB7CkBA IC0yNCwxMCArMzUsNiBAQCBmdW5jdGlvbiBydW5UZXN0KCkgewogICAgIAogICAgIC8vIERvbid0 IHBvbGx1dGUgdGhlIHRlc3QgcmVzdWx0IHdpdGggbm9uc2Vuc2UuCiAgICAgZGl2LmlubmVySFRN TCA9ICcnOwotICAgIAotICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIAotICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ci0gICAgCiB9CiAKIDwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBo YXNlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1w aGFzZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2U5NGEzMGQ3ZDg3NjgxNjdmODlhNzRhNTVl NWNiOWYxNjNmYzRlYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3Njcm9sbC1ldmVudC1waGFzZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGVzdHMg dGhhdCB3ZSBjYW4gbGlzdGVuIGZvciBzY3JvbGwgZXZlbnRzIG9uIHRoZSBkb2N1bWVudCBpbiBi b3RoIHRoZSBjYXB0dXJlIGFuZCBidWJibGUgcGhhc2VzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2ls bCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01Q TEVURSIuCisKKworQm90aCBjYXB0dXJlIGFuZCBidWJibGUgcGhhc2UgbGlzdGVuZXJzIHdlcmUg aW52b2tlZC4KK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhh c2UuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3Njcm9sbC1ldmVudC1waGFzZS5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmMwY2U1YzAyZTJhZTFkMWYyZWUxN2JmMDJiM2E1OTVjZTFkMDgzODAKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JvbGwtZXZlbnQtcGhh c2UuaHRtbApAQCAtMCwwICsxLDQ1IEBACis8aHRtbD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIg aHJlZj0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPGJvZHkgc3R5bGU9Im1p bi1oZWlnaHQ6IDIwMDBweCI+IAorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJj b25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3Jp cHRpb24oJ1Rlc3RzIHRoYXQgd2UgY2FuIGxpc3RlbiBmb3Igc2Nyb2xsIGV2ZW50cyBvbiB0aGUg ZG9jdW1lbnQgaW4gYm90aCB0aGUgY2FwdHVyZSBhbmQgYnViYmxlIHBoYXNlcy4nKTsKKwordmFy IHRyaWdnZXJlZENhcHR1cmVMaXN0ZW5lciA9IGZhbHNlOwordmFyIHRyaWdnZXJlZEJ1YmJsZUxp c3RlbmVyID0gZmFsc2U7CisKK3dpbmRvdy5hZGRFdmVudExpc3RlbmVyKAorICAgICdzY3JvbGwn LAorICAgIGZ1bmN0aW9uKCkgeworICAgICAgICB0cmlnZ2VyZWRDYXB0dXJlTGlzdGVuZXIgPSB0 cnVlOworICAgICAgICBjaGVja0NvbXBsZXRlKCk7CisgICAgfSwKKyAgICB0cnVlKTsKKword2lu ZG93LmFkZEV2ZW50TGlzdGVuZXIoCisgICAgJ3Njcm9sbCcsCisgICAgZnVuY3Rpb24oZXZlbnQp IHsKKyAgICAgICAgdHJpZ2dlcmVkQnViYmxlTGlzdGVuZXIgPSB0cnVlOworICAgICAgICBjaGVj a0NvbXBsZXRlKCk7CisgICAgfSwKKyAgICBmYWxzZSk7CisKK2Z1bmN0aW9uIGNoZWNrQ29tcGxl dGUoKQoreworICAgIGlmICh0cmlnZ2VyZWRDYXB0dXJlTGlzdGVuZXIgJiYgdHJpZ2dlcmVkQnVi YmxlTGlzdGVuZXIpIHsKKyAgICAgICAgZGVidWcoJ0JvdGggY2FwdHVyZSBhbmQgYnViYmxlIHBo YXNlIGxpc3RlbmVycyB3ZXJlIGludm9rZWQuJyk7CisgICAgICAgIGZpbmlzaEpTVGVzdCgpOwor ICAgIH0KK30KKword2luZG93LnNjcm9sbFRvKDIwMCwgMjAwKTsKKwordmFyIHN1Y2Nlc3NmdWxs eVBhcnNlZCA9IHRydWU7Cit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7Cis8L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92 ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGF5ZXJzL3JlbW92 ZWQtYnktc2Nyb2xsLWhhbmRsZXIuaHRtbAppbmRleCBiYTFhMzUxNjRjNTZiMmM0MWVhMzgwYmVh NzYzZTdlNGExZTU5Zjk4Li5kMmY5YWM2NDVlN2Q2MWI0NTAxYjFiMmI4ZjUwZmI2Njk1NzdhNTYy IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2xheWVycy9yZW1vdmVkLWJ5LXNjcm9sbC1o YW5kbGVyLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9sYXllcnMvcmVtb3ZlZC1ieS1zY3Jv bGwtaGFuZGxlci5odG1sCkBAIC0xMSwyOSArMTEsMzMgQEAKIDxwPgogICAgIFJlc3VsdDogPHNw YW4gaWQ9InJlc3VsdCI+dGVzdCBkaWQgbm90IGNvbXBsZXRlLjwvc3Bhbj4KIDwvcD4KLTxkaXYg aWQ9InQiIHN0eWxlPSJvdmVyZmxvdzogYXV0bzsgd2lkdGg6IDIwMHB4OyBoZWlnaHQ6IDEwMHB4 OyIgb25zY3JvbGw9ImlmIChvdmVyZmxvd1JlbW92ZSkgdGhpcy5wYXJlbnROb2RlLnJlbW92ZUNo aWxkKHRoaXMpOyI+Cis8ZGl2IGlkPSJ0IiBzdHlsZT0ib3ZlcmZsb3c6IGF1dG87IHdpZHRoOiAy MDBweDsgaGVpZ2h0OiAxMDBweDsiIG9uc2Nyb2xsPSJ0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hp bGQodGhpcyk7aGFuZGxlU2Nyb2xsKDApOyI+CiAgICAgPGRpdiBzdHlsZT0iaGVpZ2h0OiAyMDBw eDsiPjwvZGl2PgogPC9kaXY+CiAKLTxkaXYgc3R5bGU9Im92ZXJmbG93OiBhdXRvOyB3aWR0aDog MjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0iaWYgKHNlY29uZE92ZXJmbG93UmVtb3Zl KSB0aGlzLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQodGhpcyk7Ij4KKzxkaXYgc3R5bGU9Im92ZXJm bG93OiBhdXRvOyB3aWR0aDogMjAwcHg7IGhlaWdodDogMTAwcHg7IiBvbnNjcm9sbD0idGhpcy5w YXJlbnROb2RlLnJlbW92ZUNoaWxkKHRoaXMpO2hhbmRsZVNjcm9sbCgxKTsiPgogICAgIDxkaXYg c3R5bGU9ImhlaWdodDogMjAwcHg7Ij48L2Rpdj4KICAgICA8ZGl2IGlkPSJkIj48L2Rpdj4KIDwv ZGl2PgogCiA8c2NyaXB0PgotICAgIHZhciBvdmVyZmxvd1JlbW92ZSA9IGZhbHNlOwotICAgIHZh ciBzZWNvbmRPdmVyZmxvd1JlbW92ZSA9IGZhbHNlOworICAgIHZhciBzY3JvbGxlZEZpcnN0Q29u dGFpbmVyID0gZmFsc2U7CisgICAgdmFyIHNjcm9sbGVkU2Vjb25kQ29udGFpbmVyID0gZmFsc2U7 CiAKICAgICBkb2N1bWVudC5ib2R5Lm9mZnNldFRvcDsgdC5zY3JvbGxUb3AgPSAyMDsKIAotICAg IG92ZXJmbG93UmVtb3ZlID0gdHJ1ZTsKLSAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndCcp LmlubmVySFRNTCA9ICcnOwotCi0gICAgc2Vjb25kT3ZlcmZsb3dSZW1vdmUgPSB0cnVlOwogICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkJykuc2Nyb2xsSW50b1ZpZXcoKTsKICAgICAKLSAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0JykuaW5uZXJUZXh0ID0gIlNVQ0NFU1Mi OwotCi0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKLSAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIGZ1bmN0aW9uIGhhbmRsZVNjcm9sbChp bmRleCkKKyAgICB7CisgICAgICAgIGlmIChpbmRleCA9PSAwKSBzY3JvbGxlZEZpcnN0Q29udGFp bmVyID0gdHJ1ZTsKKyAgICAgICAgZWxzZSBpZiAoaW5kZXggPT0gMSkgc2Nyb2xsZWRTZWNvbmRD b250YWluZXIgPSB0cnVlOworICAgICAgICAKKyAgICAgICAgaWYgKHNjcm9sbGVkRmlyc3RDb250 YWluZXIgJiYgc2Nyb2xsZWRTZWNvbmRDb250YWluZXIpIHsKKyAgICAgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5pbm5lclRleHQgPSAiU1VDQ0VTUyI7CisgICAgICAg IAorICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAg ICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIH0KKyAg ICB9CiA8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qvb3ZlcmZsb3cvb25z Y3JvbGwtbGF5ZXItc2VsZi1kZXN0cnVjdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxv dy9vbnNjcm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwKaW5kZXggNjRiMjBhYzRhZWZkY2Q1 NjE0ZDJjNDhjMDNlNmNkMmEzMjJiZDRkZS4uMzU3NDEyZmUyM2ZiNjZjNWRlYzFkYTA1OGFlYTc1 MmJlMzYxMDc4YiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxvdy9vbnNjcm9s bC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9vdmVyZmxv dy9vbnNjcm9sbC1sYXllci1zZWxmLWRlc3RydWN0Lmh0bWwKQEAgLTEsMTQgKzEsMTYgQEAKIDxo ZWFkPgogPHNjcmlwdD4KIGZ1bmN0aW9uIHRlc3QoKSB7Ci0gICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CiAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgIH0KICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiaXQiKS5zY3JvbGxUb3AgPSAxMDA7CiB9CiA8L3NjcmlwdD4KIDxib2R5IG9u bG9hZD0idGVzdCgpIj4KIDxwPlRoaXMgdGVzdCBpbnZvbHZlcyBhIGxheWVyIHRoYXQgc2VsZi1k ZXN0cnVjdHMgd2hlbiBzY3JvbGxlZC4gSWYgdGhlcmUncyBubyBjcmFzaCwgdGhlbiB0aGUgdGVz dCBzdWNjZWVkZWQuPC9wPgotPGRpdiBpZD0iaXQiIHN0eWxlPSJoZWlnaHQ6IDEwMCU7IG92ZXJm bG93OiBhdXRvOyIgb25zY3JvbGw9InN0eWxlLmRpc3BsYXkgPSAnbm9uZSciPgorPGRpdiBpZD0i aXQiIHN0eWxlPSJoZWlnaHQ6IDEwMCU7IG92ZXJmbG93OiBhdXRvOyIgb25zY3JvbGw9InN0eWxl LmRpc3BsYXkgPSAnbm9uZSc7aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOyI+CiA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDIwMDBw eDsiPjwvZGl2PgogPC9kaXY+CiA8L2JvZHk+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L3JlcGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3Jl cGFpbnQvcmVwYWludC1kdXJpbmctc2Nyb2xsLmh0bWwKaW5kZXggZTNmMGFjNDRjMTliY2E1ZGJk ZTE0ZDEzODczYTBjZDVmMGVlNzIwYy4uZGM2OTcxMjIxNmY3YjUxNjYwYWUzMjI0YjJjZWVhZTQ2 MWIxNDRhYSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9yZXBhaW50L3JlcGFpbnQtZHVy aW5nLXNjcm9sbC5odG1sCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcmVwYWludC9yZXBhaW50LWR1 cmluZy1zY3JvbGwuaHRtbApAQCAtMyw2ICszLDggQEAKICAgICA8c2NyaXB0PgogICAgICAgICBm dW5jdGlvbiByZXBhaW50VGVzdCgpCiAgICAgICAgIHsKKyAgICAgICAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIud2FpdFVudGlsRG9uZSgpOwogICAgICAgICAgICAgdmFyIHRhcmdldCA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJ0YXJnZXQiKTsKICAgICAgICAgICAgIHNjcm9sbEJ5KDAsIDEwMCk7CiAg ICAgICAgIH0KQEAgLTExLDYgKzEzLDggQEAKICAgICAgICAgewogICAgICAgICAgICAgdmFyIHRh cmdldCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0YXJnZXQiKTsKICAgICAgICAgICAgIHRh cmdldC5zdHlsZS5iYWNrZ3JvdW5kQ29sb3IgPSAiZ3JlZW4iOworICAgICAgICAgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5ub3RpZnlEb25lKCk7CiAgICAgICAgIH0KICAgICA8L3NjcmlwdD4KIDwvaGVhZD4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBmY2FkMDVjODI5OGM2NGUzODQ2ZGI1YjRiODg4MTU1MDgwY2IwMGU3Li4y ZTZkMDAxODFiMjk3OTI4NTllOWRmNTMxNTZmZmQ5ODU4YjFkZThlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzIgQEAKKzIwMTEtMDEtMTAgIE1paGFpIFBhcnBhcml0YSAgPG1paGFpcEBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gRmlzaGVyLgorCisgICAgICAgIFNj cm9sbCBldmVudCBzaG91bGQgYmUgZmlyZWQgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1NjMxCisKKyAgICAgICAgVGVzdHM6 IGZhc3QvZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3Qv ZXZlbnRzL2ZpcmUtc2Nyb2xsLWV2ZW50LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9ldmVudHMvc2Nyb2xsLWV2ZW50LXBoYXNlLmh0bWwKKworICAgICAgICBNYWtlcyBzY3JvbGwg ZXZlbnRzIGZpcmUgYXN5bmNocm9ub3VzbHkgdG8gYmUgaW4gY29tcGxpYW5jZSB3aXRoIHRoZQor ICAgICAgICBDU1NPTSBWaWV3IE1vZHVsZSBhbmQgY29uc2lzdGVudCB3aXRoIEdlY2tvLCBPcGVy YSBhbmQgKHRvIHNvbWUgZGVncmVlKQorICAgICAgICBJRS4KKyAgICAgICAgCisgICAgICAgIElt cGxlbWVudGVkIHZpYSB0aGUgRXZlbnRRdWV1ZSBjbGFzcyBhZGRlZCBieSByNzQwNjIgKEV2ZW50 UXVldWUgbm93CisgICAgICAgIGhhcyBhIGNvbnZlbmllbmNlIGVucXVldWVTY3JvbGxFdmVudCBt ZXRob2QpLgorCisgICAgICAgICogZG9tL0V2ZW50UXVldWUuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RXZlbnRRdWV1ZTo6ZW5xdWV1ZVNjcm9sbEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2 ZW50UXVldWU6OnBlbmRpbmdFdmVudFRpbWVyRmlyZWQpOgorICAgICAgICAqIGRvbS9FdmVudFF1 ZXVlLmg6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RXZlbnRIYW5kbGVyOjpzZW5kU2Nyb2xsRXZlbnQpOgorICAgICAgICAqIHJlbmRlcmluZy9S ZW5kZXJMYXllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJMYXllcjo6c2Nyb2xsVG9P ZmZzZXQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMaXN0Qm94LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlJlbmRlckxpc3RCb3g6OnZhbHVlQ2hhbmdlZCk6CisKIDIwMTEtMDEtMTEgIFZp YXRjaGVzbGF2IE9zdGFwZW5rbyAgPG9zdGFwZW5rby52aWF0Y2hlc2xhdkBub2tpYS5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9kb20vRXZlbnRRdWV1ZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5j cHAKaW5kZXggMjdjZDgwMmJiYjA0YjI4ODUxNDlhN2U1NzE1YWU4MGZkY2QxM2Q1Zi4uYTQzOTI5 ZTc1ZTkzNDExNzk5MTRhNjVhOGQ2NDgwZDdiNzRmMzNmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZG9tL0V2ZW50UXVldWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FdmVudFF1 ZXVlLmNwcApAQCAtNDgsMTIgKzQ4LDI2IEBAIHZvaWQgRXZlbnRRdWV1ZTo6ZW5xdWV1ZUV2ZW50 KFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KQogICAgICAgICBtX3BlbmRpbmdFdmVudFRpbWVyLnN0 YXJ0T25lU2hvdCgwKTsKIH0KIAordm9pZCBFdmVudFF1ZXVlOjplbnF1ZXVlU2Nyb2xsRXZlbnQo UGFzc1JlZlB0cjxOb2RlPiB0YXJnZXQsIFNjcm9sbEV2ZW50VGFyZ2V0VHlwZSB0YXJnZXRUeXBl KQoreworICAgIGlmICghbV9ub2Rlc1dpdGhRdWV1ZWRTY3JvbGxFdmVudHMuYWRkKHRhcmdldC5n ZXQoKSkuc2Vjb25kKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBQZXIgdGhlIFczQyBDU1NP TSBWaWV3IE1vZHVsZSwgc2Nyb2xsIGV2ZW50cyBmaXJlZCBhdCB0aGUgZG9jdW1lbnQgc2hvdWxk IGJ1YmJsZSwgb3RoZXJzIHNob3VsZCBub3QuCisgICAgYm9vbCBjYW5CdWJibGUgPSB0YXJnZXRU eXBlID09IFNjcm9sbEV2ZW50RG9jdW1lbnRUYXJnZXQ7CisgICAgUmVmUHRyPEV2ZW50PiBzY3Jv bGxFdmVudCA9IEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBjYW5CdWJi bGUsIGZhbHNlIC8qIG5vbiBjYW5jZWxsZWFibGUgKi8pOworICAgIHNjcm9sbEV2ZW50LT5zZXRU YXJnZXQodGFyZ2V0KTsKKyAgICBlbnF1ZXVlRXZlbnQoc2Nyb2xsRXZlbnQucmVsZWFzZSgpKTsK K30KKwogdm9pZCBFdmVudFF1ZXVlOjpwZW5kaW5nRXZlbnRUaW1lckZpcmVkKFRpbWVyPEV2ZW50 UXVldWU+KikKIHsKICAgICBBU1NFUlQoIW1fcGVuZGluZ0V2ZW50VGltZXIuaXNBY3RpdmUoKSk7 CiAKICAgICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IHF1ZXVlZEV2ZW50czsKICAgICBxdWV1ZWRF dmVudHMuc3dhcChtX3F1ZXVlZEV2ZW50cyk7CisgICAgCisgICAgbV9ub2Rlc1dpdGhRdWV1ZWRT Y3JvbGxFdmVudHMuY2xlYXIoKTsKIAogICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcXVldWVk RXZlbnRzLnNpemUoKTsgaSsrKQogICAgICAgICBkaXNwYXRjaEV2ZW50KHF1ZXVlZEV2ZW50c1tp XS5yZWxlYXNlKCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUu aCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FdmVudFF1ZXVlLmgKaW5kZXggOGRkN2VjOWJiMDUzMmU3 ZTlkNjgxNWMxMTEzZGE4NmEyMTk1NzIzNS4uN2Y4ZDVmYjI1NDYxMTQ2YWQ0Nzk1NDJiYWY0NWE3 ODBjYjlkNmFkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0V2ZW50UXVldWUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRXZlbnRRdWV1ZS5oCkBAIC0yOCw2ICsyOCw3IEBACiAj ZGVmaW5lIEV2ZW50UXVldWVfaAogCiAjaW5jbHVkZSAiVGltZXIuaCIKKyNpbmNsdWRlIDx3dGYv SGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9S ZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CkBAIC00MSw5ICs0MiwxNSBAQCBjbGFz cyBFdmVudFF1ZXVlIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShFdmVudFF1ZXVlKTsKIAog cHVibGljOgorICAgIGVudW0gU2Nyb2xsRXZlbnRUYXJnZXRUeXBlIHsKKyAgICAgICAgU2Nyb2xs RXZlbnREb2N1bWVudFRhcmdldCwKKyAgICAgICAgU2Nyb2xsRXZlbnRFbGVtZW50VGFyZ2V0Cisg ICAgfTsKKwogICAgIEV2ZW50UXVldWUoKTsKIAogICAgIHZvaWQgZW5xdWV1ZUV2ZW50KFBhc3NS ZWZQdHI8RXZlbnQ+KTsKKyAgICB2b2lkIGVucXVldWVTY3JvbGxFdmVudChQYXNzUmVmUHRyPE5v ZGU+LCBTY3JvbGxFdmVudFRhcmdldFR5cGUpOwogCiBwcml2YXRlOgogICAgIHZvaWQgcGVuZGlu Z0V2ZW50VGltZXJGaXJlZChUaW1lcjxFdmVudFF1ZXVlPiopOwpAQCAtNTEsNiArNTgsNyBAQCBw cml2YXRlOgogCiAgICAgVGltZXI8RXZlbnRRdWV1ZT4gbV9wZW5kaW5nRXZlbnRUaW1lcjsKICAg ICBWZWN0b3I8UmVmUHRyPEV2ZW50PiA+IG1fcXVldWVkRXZlbnRzOworICAgIEhhc2hTZXQ8Tm9k ZSo+IG1fbm9kZXNXaXRoUXVldWVkU2Nyb2xsRXZlbnRzOwogfTsKIAogfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IDA0OGEzY2MwYzM5ZWNiODgyZGIyMzM5MDUwNTYwNjMz YjVlNWE4NGIuLmQwZjE3NTZhOTU2ZmU2NmM0MjBhNTI2NjJjODdhOTFlOWFjMjI2YWUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRl ICJEcmFnQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkVkaXRvci5oIgogI2luY2x1ZGUgIkV2ZW50 TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1ZXVlLmgiCiAjaW5jbHVkZSAiRmxvYXRQb2ludC5o IgogI2luY2x1ZGUgIkZsb2F0UmVjdC5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgpA QCAtMjc5OCw3ICsyNzk5LDcgQEAgdm9pZCBFdmVudEhhbmRsZXI6OnNlbmRTY3JvbGxFdmVudCgp CiB7CiAgICAgc2V0RnJhbWVXYXNTY3JvbGxlZEJ5VXNlcigpOwogICAgIGlmIChtX2ZyYW1lLT52 aWV3KCkgJiYgbV9mcmFtZS0+ZG9jdW1lbnQoKSkKLSAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQo KS0+ZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5zY3JvbGxFdmVudCwg dHJ1ZSwgZmFsc2UpKTsKKyAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+ZXZlbnRRdWV1ZSgp LT5lbnF1ZXVlU2Nyb2xsRXZlbnQobV9mcmFtZS0+ZG9jdW1lbnQoKSwgRXZlbnRRdWV1ZTo6U2Ny b2xsRXZlbnREb2N1bWVudFRhcmdldCk7CiB9CiAKIHZvaWQgRXZlbnRIYW5kbGVyOjpzZXRGcmFt ZVdhc1Njcm9sbGVkQnlVc2VyKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMYXllci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXIu Y3BwCmluZGV4IDU0MTYxNGNmMjlkNjc1YjA1ZWVlNzcwZmE5ODJlYzc1NjViZjYwZjAuLmVkNDYz OWVmZmI3MzE2NmQyZjA4NmVmZmFlYzAzMjljYTBmODcwNDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckxheWVyLmNwcApAQCAtNTEsNyArNTEsNyBAQAogI2luY2x1ZGUgIkNocm9t ZS5oIgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCi0j aW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkV2ZW50UXVldWUuaCIKICNpbmNsdWRl ICJGbG9hdFBvaW50M0QuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGb2N1 c0NvbnRyb2xsZXIuaCIKQEAgLTEzOTcsMTAgKzEzOTcsNyBAQCB2b2lkIFJlbmRlckxheWVyOjpz Y3JvbGxUb09mZnNldChpbnQgeCwgaW50IHksIGJvb2wgdXBkYXRlU2Nyb2xsYmFycywgYm9vbCBy ZXBhaQogICAgIH0KIAogICAgIC8vIFNjaGVkdWxlIHRoZSBzY3JvbGwgRE9NIGV2ZW50LgotICAg IGlmICh2aWV3KSB7Ci0gICAgICAgIGlmIChGcmFtZVZpZXcqIGZyYW1lVmlldyA9IHZpZXctPmZy YW1lVmlldygpKQotICAgICAgICAgICAgZnJhbWVWaWV3LT5zY2hlZHVsZUV2ZW50KEV2ZW50Ojpj cmVhdGUoZXZlbnROYW1lcygpLnNjcm9sbEV2ZW50LCBmYWxzZSwgZmFsc2UpLCByZW5kZXJlcigp LT5ub2RlKCkpOwotICAgIH0KKyAgICByZW5kZXJlcigpLT5ub2RlKCktPmRvY3VtZW50KCktPmV2 ZW50UXVldWUoKS0+ZW5xdWV1ZVNjcm9sbEV2ZW50KHJlbmRlcmVyKCktPm5vZGUoKSwgRXZlbnRR dWV1ZTo6U2Nyb2xsRXZlbnRFbGVtZW50VGFyZ2V0KTsKIH0KIAogdm9pZCBSZW5kZXJMYXllcjo6 c2Nyb2xsUmVjdFRvVmlzaWJsZShjb25zdCBJbnRSZWN0JiByZWN0LCBib29sIHNjcm9sbFRvQW5j aG9yLCBjb25zdCBTY3JvbGxBbGlnbm1lbnQmIGFsaWduWCwgY29uc3QgU2Nyb2xsQWxpZ25tZW50 JiBhbGlnblkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlz dEJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEJveC5jcHAKaW5k ZXggZWQ3ZjhlZWQ4ZWJhZjU0ZmEzYTJhNDVjMTJhNTY4NTQxZGYyMjI1Ny4uZDVmNjBhZTZkZDhj ZWZmYjkzNjQ4NjBlNjQyZDQ4ZDU3ZTBiMDIwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxpc3RCb3guY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJMaXN0Qm94LmNwcApAQCAtMzYsNyArMzYsNyBAQAogI2luY2x1ZGUgIkNTU1N0eWxl U2VsZWN0b3IuaCIKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkV2ZW50SGFuZGxl ci5oIgotI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJFdmVudFF1ZXVlLmgiCiAj aW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRl ICJGcmFtZVZpZXcuaCIKQEAgLTU0NSw3ICs1NDUsNyBAQCB2b2lkIFJlbmRlckxpc3RCb3g6OnZh bHVlQ2hhbmdlZChTY3JvbGxiYXIqKQogICAgIGlmIChuZXdPZmZzZXQgIT0gbV9pbmRleE9mZnNl dCkgewogICAgICAgICBtX2luZGV4T2Zmc2V0ID0gbmV3T2Zmc2V0OwogICAgICAgICByZXBhaW50 KCk7Ci0gICAgICAgIG5vZGUoKS0+ZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFt ZXMoKS5zY3JvbGxFdmVudCwgZmFsc2UsIGZhbHNlKSk7CisgICAgICAgIG5vZGUoKS0+ZG9jdW1l bnQoKS0+ZXZlbnRRdWV1ZSgpLT5lbnF1ZXVlU2Nyb2xsRXZlbnQobm9kZSgpLCBFdmVudFF1ZXVl OjpTY3JvbGxFdmVudEVsZW1lbnRUYXJnZXQpOwogICAgIH0KIH0KIAo=