189924 2018-09-24 12:37:40 -0700 [MSE][GStreamer] Use sentinel buffer to detect end of append 2018-10-02 02:20:58 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 aboya aboya bugs-noreply calvaris commit-queue eocanha mcatanzaro pnormand tsaunier oldest_to_newest 1462820 0 aboya 2018-09-24 12:37:40 -0700 This patch introduces a new mechanism to detect when an append has been consumed completely by the demuxer. It takes advantage of the fact that buffer pushing is synchronous: both the appsrc and the demuxer live in the same streaming thread. When appsrc pushes a buffer, it's actually making a qtdemux function call (it calls its "chain" function). The demuxer will return from that call when it has finished processing that buffer; only then the control returns to appsrc, who can push the next buffer. By pushing an additional buffer and capturing it in a probe we can detect reliably when the previous buffer has been processed. Because the pipeline only has one thread, at this point no more frames can arrive to the appsink. This replaces the old method of detecting end of append which relied on the `need-data` event, which is more difficult to handle correctly because it fires whenever the appsrc is empty (or below a given level), which also happens when a buffer has not been pushed yet or in response to a flush. 1462827 1 350669 aboya 2018-09-24 12:44:18 -0700 Created attachment 350669 Patch 1463103 2 calvaris 2018-09-24 23:21:35 -0700 (In reply to Alicia Boya García from comment #0) > This patch introduces a new mechanism to detect when an append has > been consumed completely by the demuxer. It takes advantage of the > fact that buffer pushing is synchronous: both the appsrc and the > demuxer live in the same streaming thread. When appsrc pushes a > buffer, it's actually making a qtdemux function call (it calls its > "chain" function). The demuxer will return from that call when it has > finished processing that buffer; only then the control returns to > appsrc, who can push the next buffer. Ok, I'll review this but I have one question. Can we guarantee that this is going to happen for other demuxers we require, say matroskademux for WebM? Cause we'd be screwed... 1463114 3 pnormand 2018-09-25 02:07:08 -0700 I think the same could be done with an event. No need for a GstMeta. 1463116 4 350669 calvaris 2018-09-25 02:19:07 -0700 Comment on attachment 350669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350669&action=review I am not against the idea of this patch, we should ensure that it is not going to backfire soon and that you should fix some stuff in it. Thibault's and Enrique's opinion are appreciated here. Another question is which problems are you trying to fix with it. > Source/WebCore/ChangeLog:12 > + fact that buffer pushing is synchronous: both the appsrc and the > + demuxer live in the same streaming thread. When appsrc pushes a > + buffer, it's actually making a qtdemux function call (it calls its As I said in my first comment, I can think this is true for qtdemux but I don't know how this is going to work for other demuxers like matroska's. Besides, this relies on the internal implementation of qtdemux which might change at some point, creating a lot of trouble in this case. Thibault, what do you think about this? > Source/WebCore/ChangeLog:15 > + appsrc, who can push the next buffer. that can push the buffer > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:59 > +static GType endOfAppendMetaType = 0; > +static const GstMetaInfo* webKitEndOfAppendMetaInfo = nullptr; Even when they are not static members, my gut still tells me they should be prefixed with s_. If you have any doubts, I think we could even put all this (struct EndOfAppendMeta and GType definitions) inside AppendPipeline's class. It is integral part of its new way of working in the end, right? > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:65 > +void AppendPipeline::staticInitialization() > +{ > + ASSERT(WTF::isMainThread()); > + if (s_staticInitializationDone) > + return; Where this is called, you should use std::call_once instead: https://en.cppreference.com/w/cpp/thread/call_once and avoid this manually. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:67 > + const char* tags[] = {nullptr}; I don't know why but my gut tells me it should be { nullprt }. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:140 > + staticInitialization(); What I said about std::call_once goes here. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:798 > + RELEASE_ASSERT(pushDataBufferRet == GST_FLOW_OK); We should handle this more gracefully. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:802 > + // Push an additional empty buffer that marks the end of the append. > + // This buffer is detected and consumed by appsrcEndOfAppendCheckerProbe(), > + // which uses it to signal the successful completion of the append. I would appreciate here a bit more of elaboration as you did on the ChangeLog to explain the same thread, etc. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:809 > + RELEASE_ASSERT(pushEndOfAppendBufferRet == GST_FLOW_OK); Ditto. 1463117 5 calvaris 2018-09-25 02:24:45 -0700 (In reply to Philippe Normand from comment #3) > I think the same could be done with an event. No need for a GstMeta. Also true. 1463121 6 eocanha 2018-09-25 03:05:15 -0700 View in context: https://bugs.webkit.org/attachment.cgi?id=350669&action=review Is there some use case that this patch solves but is broken with the already existing implementation? This implementation relies on sharing the same streaming thread between all the pipeline elements. This hasn't always been the case, because the (asynchronous = multithread) EME decryptors were placed in the append pipeline at some point (even though now they have or are going to be moved to the playback pipeline). As an extra safety measure, would it make sense to store the WTF::currentThead() in an AppendPipeline attribute in handleNewAppsinkSample() and check that currentThread() is the same one in appsrcEndOfAppendCheckerProbe()? If they're different, it means that the assumption of "same streaming thread in all the pipeline" no longer applies and we should runtime_assert. I feared that this patch was sustained on a race condition but I was wrong. Let me explain: The concept of "end of append" means that all the possible samples that could have been generated in this append operation have been generated. You're detecting the end of the processing in the appsrc, but as the probe is called before the buffer goes on to the demuxer, some time must still pass (so, a race can happen) between the moment the probe detects the sentinel and the sentinel buffer finishes being processing in the demuxe... hmmm... wait... The sentinel buffer is discarded. And if it was captured by the probe it means that the previous "real" buffer processing (in the demuxer, etc.) has already finished (because of single threading), so the end of the append can actually be signaled (if single threading is guaranteed), so YOU ARE RIGHT. :-) > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:-637 > - if (m_appendState != AppendState::Ongoing && m_appendState != AppendState::Sampling) { Why can't this condition happen anymore? > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:-1036 > - // No useful data, but notify anyway to complete the append operation. Why is this removed? Would this hipotetical condition trigger an end-of-append and didReceiveAllPendingSamples() would have been called anyway in the end, so no need to call it here? (You can fake this hipotetical condition by commenting out one of the types (eg: audio or video) in parseDemuxerSrcPadCaps() so it gets detected as Unknown) 1463124 7 350669 tsaunier 2018-09-25 04:19:36 -0700 Comment on attachment 350669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350669&action=review We discussed that approach with Alicia a while back and this was the best approach we came up with. Ideally appsrc would let us push serialized event and query and we could reuse that mechanism but it is not the case and not totally needed here. >> Source/WebCore/ChangeLog:12 >> + buffer, it's actually making a qtdemux function call (it calls its > > As I said in my first comment, I can think this is true for qtdemux but I don't know how this is going to work for other demuxers like matroska's. Besides, this relies on the internal implementation of qtdemux which might change at some point, creating a lot of trouble in this case. Thibault, what do you think about this? I do not see anything qtdemux specific in here no. The only thing that could screw that approach is to add a queue between the src and the demuxer which, well we are in control of afaict. 1463199 8 aboya 2018-09-25 10:56:57 -0700 (In reply to Philippe Normand from comment #3) > I think the same could be done with an event. No need for a GstMeta. This is something I have discussed in the past Multimedia Hackfest. Yes, a downstream in-band non-sticky event would work for this. But (and this is a big but), you need a way to ensure the event is sent *after* the buffer and this is impossible to do that with the current appsrc API, because although there is gst_app_src_push_buffer() and gst_app_src_push_sample(), as of writing there is no gst_app_src_push_event(). You may be tempted to attempt to workaround it like this: pushNewBuffer(GstBuffer* buffer) { gst_app_src_push_buffer(appsrc, buffer); gst_pad_push_event(appsrc_pad, endOfAppendEvent); } But that won't work. To understand why, think carefully about what each of these functions do: gst_app_src_push_buffer() adds the buffer to the appsrc internal queue and returns immediately. That's all there is to it as far as the calling thread is concerned (in this case the main thread). At some point later, the streaming thread that was blocked in the appsrc loop function waiting for new buffers to arrive will notice it. It will remove the buffer from its internal queue, release the appsrc lock and call gst_pad_push(appsrc:src) with the new buffer, which in turn pass it to the peer pad using gst_pad_chain_data_unchecked(peer_pad) and will result in the chain function of the next element being called. At that point the streaming thread is running code from the demuxer element. The demuxer may in turn create some new GstBuffers with some demuxed frames and call gst_pad_push() with them, and so on. A typical (very simplified) stack trace of the streaming thread would look like this: gst_app_sink_chain (appsink:sink, parsed_frame) gst_pad_chain_data_unchecked (appsink:sink, parsed_frame) gst_pad_push (opusparse:src, parsed_frame) gst_opus_parse_chain (opusparse:sink, opus_frame) gst_pad_chain_data_unchecked (opusparse:sink, opus_frame) gst_pad_push (matroskademux:audio_0, opus_frame) gst_matroska_demux_chain (matroskademux:sink, mkv_buffer) gst_pad_chain_data_unchecked (matroskademux:sink, mkv_buffer) gst_pad_push (appsrc:src, mkv_buffer) gst_app_src_loop (appsrc:src) (The actual stack trace is more complicated. Many of these functions don't exist with that name because they are actually implemented by base classes that call configurable functions of their child class... Still, this pseudo-stack trace is helpful for illustrating the control flow.) Notice there is nothing fancy here. Pushing a buffer esentially amounts to calling a function of the downstream element. When the downstream element is done, it returns and the upstream element can continue. The streaming thread is running code of only one element at a time. This does not mean that you could not call code of an element from the main thread... In fact, this is often done for operations that require waiting for the element to do something, like changing its state or sending flush events. How do elements manage to not explode in cases like this? That's what the element locks are for. In order to do something with an element, you need to acquire the element lock, so in these cases the main thread and the streaming thread take turns to borrow a certain element. Let's give a look at events now. gst_pad_push_event(pad, event) receives an event, find the peer pad and calls gst_pad_send_event(peer_pad, event). This function, in turn, calls the "event" function specific of the element, which was defined with gst_pad_set_event_function() during the initialization of the pad. This is very similar to what was described before for gst_pad_send(). There are many types of events. Some travel downstream (e.g. SEGMENT, CAPS, EOS...) and some travel upstream (e.g. SEEK, QOS...). A few can travel either way, depending on whether they are received by a sink pad or source pad (currently that list includes only FLUSH_START, FLUSH_STOP and potentially custom events you create). Our potential END_OF_APPEND event would travel only downstream. Furthermore, downstream events are divided in two kinds: serialized (AKA "in-band") and non-serialized (AKA "out-of-band"). Serialized events travel the pipeline serialized with the buffers: that is, for any element downstream, a buffer pushed before the event is guaranteed to arrive before the event and a buffer pushed after the event is guaranteed to arrive after the event. This serialization of buffers and in-band events pushed from potentially different threads (think the case where gst_pad_push_event() is called from the main thread) is achieved by the sinkpads' STREAM_LOCK. The stream lock of a pad is held during the gst_pad_chain_data_unchecked() or gst_pad_send_event() call. That is, until downstream of a pad has finished with a given buffer or serialized event, the pad will not accept more buffers or serialized events. (Further attempts will block.) Most downstream events are in-band, with the notable exception of FLUSH_START. Our potential END_OF_APPEND event would also need to be in-band: we would not want it to overtake the data we wanted to demux in the pipeline. Downstream events further divide into sticky and non-sticky. Sticky events are stored by the pad and can be later queried with gst_pad_get_sticky_event(). They are also resent if the pad is relinked. We are not interested in any of that, so the END_OF_APPEND would be non-sticky. With all this understood... What would be the problem with calling gst_pad_push_event() from the main thread like in the pseudo code before? 1. If the buffer had already been pushed by appsrc, the attempt to acquire the stream lock of matroskademux' sinkpad would block the main thread while the demuxing occurs. Once matroskademux is done, the event would be sent and the gst_pad_push_event() call would return. Actually at this point the event would be of no use to us. We know the demuxer has finished processing the buffer with the stream lock alone. In effect, we would be making demuxing synchronous: even if the demuxer is running in another thread, we end up blocking the main thread waiting for it. Not ideal, definitely not what we wanted initially. 2. More worringly, there is a fatal race condition: If the streaming thread has not awaken and appsrc sent the buffer by the time we make the call (which is perfectly plausible), we will acquire the stream lock before the demuxer receives the buffer with the actual data. Therefore, we would be receiving the END_OF_APPEND event before the append has actually arrived the demuxer. The only way to fix these problems with events would be to add support in appsrc to enqueue downstream on-band events *in the same queue* that it already uses for buffers. This would solve (1) because the event would be sent from the streaming thread without blocking the main thread for it and (2) because events and buffer would be stored as if they were the same thing and emitted in FIFO order. Of course, adding event support to appsrc would not be an easy patch, partly because appsrc already emits some events (like SEGMENT, CAPS and EOS) -- so what should it do if the user enqueues one of these? It would require a new API function and a new GStreamer release. Based on previous experience, that could delay this patch for months. So, as a conclusion, yes, we could use events, but only after adding support for them in appsrc. Alternatively, instead of enqueing downstream in-band events that work like buffers we could... just use buffers. That is what this patch is about. Should appsrc support event queing at some point, modifying AppendPipeline to use an event instead of a buffer would be trivial. In fact, apart from the semantics -- whether we call this thing "buffer" or "event", the mechanics using events would be exactly the same: instead of calling gst_app_src_push_buffer() you would call gst_app_src_push_event(), instead of creating a buffer with a GstMeta you would create a custom event with a GstStructure, instead of creating a probe that listens for a buffer containing a specific meta and drops it, you would create a probe that listens for an event containing a specific GstStructure and drops it. 1463557 9 350669 aboya 2018-09-26 04:12:48 -0700 Comment on attachment 350669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350669&action=review >> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:59 >> +static const GstMetaInfo* webKitEndOfAppendMetaInfo = nullptr; > > Even when they are not static members, my gut still tells me they should be prefixed with s_. If you have any doubts, I think we could even put all this (struct EndOfAppendMeta and GType definitions) inside AppendPipeline's class. It is integral part of its new way of working in the end, right? I think it would be too surprising to use s_* for something that is not a static member of the class. About making it a static member vs a static global variable... I don't know, they are esentially the same with the difference that members are scoped (which has little relevance in this case, since the whole AppendPipeline.cpp is all about AppendPipeline class) and that static members have to be exposed in the header file (which is undesirable for implementation details like this, but overall it's not a big problem anyway). I have no strong feelings towards neither approach; I'll go with the static member as suggested. >> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:65 >> + return; > > Where this is called, you should use std::call_once instead: https://en.cppreference.com/w/cpp/thread/call_once and avoid this manually. Cool, I didn't know about it. >> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:798 >> + RELEASE_ASSERT(pushDataBufferRet == GST_FLOW_OK); > > We should handle this more gracefully. The assert has a reason to be there. This can only fail if the appsrc is flushing or EOS. That should not happen unless there is a bug in AppendPipeline or another piece of our MSE implementation, therefore it makes sense to assert. Notwithstanding that, I could use g_return_if_fail() instead of RELEASE_ASSERT(), so that should the assertion fail, WebKit does not crash but a CRITICAL is printed and captured with the debugger if necessary. 1463570 10 aboya 2018-09-26 05:40:11 -0700 (In reply to Xabier Rodríguez Calvar from comment #4) > Another question is which problems are you trying to fix with it. (In reply to Enrique Ocaña from comment #6) > Is there some use case that this patch solves but is broken with the already > existing implementation? I want to get rid of complexity in the AppendPipeline. Eventually I want to get rid of the entire state machine, and all the special-cases in if()s. In the end, I want an AppendPipeline that I can understand and explain fully and use without fear of so many edge cases. I also want aborts to work as in the spec and do so reliably (currently blocked by https://bugzilla.gnome.org/show_bug.cgi?id=795424). I did that in the past in my work branch and now I'm trying to bring that upstream. This is a piece of that. (In reply to Xabier Rodríguez Calvar from comment #4) > As I said in my first comment, I can think this is true for qtdemux but I > don't know how this is going to work for other demuxers like matroska's. > Besides, this relies on the internal implementation of qtdemux which might > change at some point, creating a lot of trouble in this case. Thibault, what > do you think about this? This is independent of the specific demuxer used. In relies just on how push mode scheduling works in GStreamer, which is extremely unlikely to change anytime soon (and should it happen, it would break all GStreamer). (In reply to Enrique Ocaña from comment #6) > This implementation relies on sharing the same streaming thread between all > the pipeline elements. This hasn't always been the case, because the > (asynchronous = multithread) EME decryptors were placed in the append > pipeline at some point (even though now they have or are going to be moved > to the playback pipeline). This depends on being there only one streaming thread indeed. But so did the previous implementation. `need-data` fires when the appsrc is empty, not when the whole pipeline is empty. If it worked before with multiple streaming threads, I don't know how. What I wrote in the previous mega-reply applies for queues too, but there is a small important detail: the chain method of a queue element stores the buffer in the queue and returns immediately. Then the next streaming thread notices it and continues on its own. Queues are special elements in that their sinkpad and srcpad live in different streaming threads. Most elements spawning threads are queues of some kind. If at some point it becomes necessary to introduce a element that spawns a new streaming thread (hopefully not), it would be necessary to rethink this. In general terms, the end-of-append buffer/event would have to travel the queue and be detected and removed somewhere in the last streaming thread. A event is better in this case because it can travel easily through many elements (at least transform elements), but because of what I explained before, it would have to be pushed initially as a buffer so that it is correctly serialized; it can later be converted into an event in a probe. The actual challenges would be convincing the demuxers to forward the event to all the srcpads (neither qtdemux nor matroskademux do this currently) and handling the case where there are no srcpads yet. I'm not going down that route since I have no reason to do that as of now. (In reply to Enrique Ocaña from comment #6) > As an extra safety measure, would it make sense to store the > WTF::currentThead() in an AppendPipeline attribute in > handleNewAppsinkSample() and check that currentThread() is the same one in > appsrcEndOfAppendCheckerProbe()? If they're different, it means that the > assumption of "same streaming thread in all the pipeline" no longer applies > and we should runtime_assert. It can be done. It would add a little bit of noise to the code, but not too much. The only case it would fail would be if someone modified the pipeline to introduce a queue element or similar, in which case they would be warned of what they have broken. (In reply to Enrique Ocaña from comment #6) > > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:-637 > > - if (m_appendState != AppendState::Ongoing && m_appendState != AppendState::Sampling) { > > Why can't this condition happen anymore? Could it happen before? How? I've never seen it so far. I've run the YT tests after re-adding it just in case but found not a single instance. (In reply to Enrique Ocaña from comment #6) > > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:-1036 > > - // No useful data, but notify anyway to complete the append operation. > > Why is this removed? Would this hipotetical condition trigger an > end-of-append and didReceiveAllPendingSamples() would have been called > anyway in the end, so no need to call it here? (You can fake this > hipotetical condition by commenting out one of the types (eg: audio or > video) in parseDemuxerSrcPadCaps() so it gets detected as Unknown) It has been removed because otherwise we would handle end-of-append twice. The end of append mechanism works exactly the same way regardless of whether what has been appended is an initialization segment, a media segment with a track of any type, or chunks or concatenations thereof. No need for special cases there. BTW: The append is not guaranteed to end after the initialization segment, despite what the old code seemed to assume. 1463647 11 350873 aboya 2018-09-26 10:58:51 -0700 Created attachment 350873 Patch 1463933 12 350873 pnormand 2018-09-27 05:39:42 -0700 Comment on attachment 350873 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350873&action=review > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:159 > + }, this, nullptr); Would it be possible to pass a weak ptr here instead of `this`? The AppendPipeline could inherit from CanMakeWeakPtr. > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:281 > + GST_TRACE_OBJECT(this, "posting end-of-append request to bus"); s/this/m_pipeline.get() > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:617 > + GST_TRACE_OBJECT(this, "received end-of-append"); s/this/m_pipeline.get() > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:793 > + GST_TRACE_OBJECT(this, "pushing data buffer %p", buffer); Nit: Use GST_PTR_FORMAT Also, s/this/m_pipeline.get() :) > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:811 > + GST_TRACE_OBJECT(this, "pushing end-of-append buffer %p", endOfAppendBuffer); s/this/m_pipeline.get() and GST_PTR_FORMAT 1463936 13 350873 eocanha 2018-09-27 05:56:47 -0700 Comment on attachment 350873 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350873&action=review >> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:159 >> + }, this, nullptr); > > Would it be possible to pass a weak ptr here instead of `this`? The AppendPipeline could inherit from CanMakeWeakPtr. But in the end, even if you use a WeakPtr, you still need to pass a pointer to the WeakPtr (not a WeakPtr full object). How would you manage the pointer lifecycle? What we have done in the past with probes is to save the probe id as an AppendPipeline private attribute and then remove the probe in ~AppendPipeline(). IMHO, that's what should be done here. 1463951 14 350873 aboya 2018-09-27 07:55:21 -0700 Comment on attachment 350873 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350873&action=review >>> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:159 >>> + }, this, nullptr); >> >> Would it be possible to pass a weak ptr here instead of `this`? The AppendPipeline could inherit from CanMakeWeakPtr. > > But in the end, even if you use a WeakPtr, you still need to pass a pointer to the WeakPtr (not a WeakPtr full object). How would you manage the pointer lifecycle? > > What we have done in the past with probes is to save the probe id as an AppendPipeline private attribute and then remove the probe in ~AppendPipeline(). IMHO, that's what should be done here. By the time AppendPipeline is destroyed the pipeline has already transitioned to NULL state and has been unref'ed (and hence become impossible for the probe to be called). There is no need to use a weak pointer there. Saving the probe id is unnecessary if you don't need to remove it later while the element is active. All the probes are tear down with the pad. Adding a probe will not increase the reference count of the pad, it will not leak. >> Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp:281 >> + GST_TRACE_OBJECT(this, "posting end-of-append request to bus"); > > s/this/m_pipeline.get() Why? It's actually the AppendPipeline doing its thing, not the boring pipeline. If I want to know which AppendPipeline is doing something it's usually more useful to know the AppendPipeline pointer than the GstPipeline object owned by it. 1463957 15 350961 aboya 2018-09-27 08:26:21 -0700 Created attachment 350961 Patch 1463972 16 350961 commit-queue 2018-09-27 09:03:56 -0700 Comment on attachment 350961 Patch Clearing flags on attachment: 350961 Committed r236547: <https://trac.webkit.org/changeset/236547> 1463973 17 commit-queue 2018-09-27 09:03:58 -0700 All reviewed patches have been landed. Closing bug. 1464004 18 pnormand 2018-09-27 09:32:18 -0700 Because that macro is intended to be used for GstObjects, not any kind of pointer 1464041 19 aboya 2018-09-27 10:39:49 -0700 (In reply to Philippe Normand from comment #18) > Because that macro is intended to be used for GstObjects, not any kind of > pointer Hmmm... You are right, the documentation says "the GObject the message belongs to". Then gst_debug_print_object() tries to guess what it is with GObject metadata and if it fails it returns just the pointer string. This works, but theoretically the AppendPipeline object layout could end up in such a way it could be misunderstood for a certain GStreamer object. 1464055 20 tsaunier 2018-09-27 10:52:30 -0700 (In reply to Alicia Boya García from comment #19) > (In reply to Philippe Normand from comment #18) > > Because that macro is intended to be used for GstObjects, not any kind of > > pointer > > Hmmm... You are right, the documentation says "the GObject the message > belongs to". The doc is wrong, this also perfectly handle GstMiniObject :-) > Then gst_debug_print_object() tries to guess what it is with GObject > metadata and if it fails it returns just the pointer string. > > This works, but theoretically the AppendPipeline object layout could end up > in such a way it could be misunderstood for a certain GStreamer object. In that case I would rather use a good Pipeline name and use `m_pipeline.get()` all around (I started to do that everywhere I put my handes actually :-)) 1464057 21 aboya 2018-09-27 10:54:50 -0700 Amended in https://bugs.webkit.org/show_bug.cgi?id=190045 1464980 22 350961 calvaris 2018-10-01 06:27:39 -0700 Comment on attachment 350961 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=350961&action=review > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.h:108 > + // Used only for asserting that there is only one streaming thread. > + // Only the pointers are compared. > + WTF::Thread* m_streamingThread; My preference would have been to keep the code related to check the streaming thread under #ifndef NDEBUG for debug builds 1464993 23 aboya 2018-10-01 06:55:42 -0700 (In reply to Xabier Rodríguez Calvar from comment #22) > Comment on attachment 350961 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=350961&action=review > > > Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.h:108 > > + // Used only for asserting that there is only one streaming thread. > > + // Only the pointers are compared. > > + WTF::Thread* m_streamingThread; > > My preference would have been to keep the code related to check the > streaming thread under #ifndef NDEBUG for debug builds I checked in advance that getting the thread is a very fast operation (after the first call, it just gets a pointer from thread local storage). Comparing pointers of course is also very fast. 1465044 24 mcatanzaro 2018-10-01 09:47:27 -0700 Any substantial extra code needed for ASSERTS is usually guarded by #if !ASSERT_DISABLED. 1465120 25 aboya 2018-10-01 11:10:50 -0700 After discussion with Calvaris, we have decided to keep the check, but make it not a release assert. 1465124 26 351276 aboya 2018-10-01 11:14:38 -0700 Created attachment 351276 Patch 1465457 27 351276 commit-queue 2018-10-02 02:20:56 -0700 Comment on attachment 351276 Patch Clearing flags on attachment: 351276 Committed r236717: <https://trac.webkit.org/changeset/236717> 1465458 28 commit-queue 2018-10-02 02:20:58 -0700 All reviewed patches have been landed. Closing bug. 350669 2018-09-24 12:44:18 -0700 2018-09-26 10:58:47 -0700 Patch bug-189924-20180924214417.patch text/plain 19920 aboya U3VidmVyc2lvbiBSZXZpc2lvbjogMjM2NDE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2RmODBkODgzMjU1YmJl ZjBmYmY4MTU0MTMyMGExMGE5MGQ4NzM3YS4uMmIxY2RiNzI4M2Q3NDNkODJmYWQwOGUyZWM4NTQ2 ZDg5MDIwMjk1NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDE4LTA5LTI0ICBBbGlj aWEgQm95YSBHYXJjw61hICA8YWJveWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbTVNFXVtHU3Ry ZWFtZXJdIFVzZSBzZW50aW5lbCBidWZmZXIgdG8gZGV0ZWN0IGVuZCBvZiBhcHBlbmQKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTkyNAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaW50 cm9kdWNlcyBhIG5ldyBtZWNoYW5pc20gdG8gZGV0ZWN0IHdoZW4gYW4gYXBwZW5kIGhhcworICAg ICAgICBiZWVuIGNvbnN1bWVkIGNvbXBsZXRlbHkgYnkgdGhlIGRlbXV4ZXIuIEl0IHRha2VzIGFk dmFudGFnZSBvZiB0aGUKKyAgICAgICAgZmFjdCB0aGF0IGJ1ZmZlciBwdXNoaW5nIGlzIHN5bmNo cm9ub3VzOiBib3RoIHRoZSBhcHBzcmMgYW5kIHRoZQorICAgICAgICBkZW11eGVyIGxpdmUgaW4g dGhlIHNhbWUgc3RyZWFtaW5nIHRocmVhZC4gV2hlbiBhcHBzcmMgcHVzaGVzIGEKKyAgICAgICAg YnVmZmVyLCBpdCdzIGFjdHVhbGx5IG1ha2luZyBhIHF0ZGVtdXggZnVuY3Rpb24gY2FsbCAoaXQg Y2FsbHMgaXRzCisgICAgICAgICJjaGFpbiIgZnVuY3Rpb24pLiBUaGUgZGVtdXhlciB3aWxsIHJl dHVybiBmcm9tIHRoYXQgY2FsbCB3aGVuIGl0IGhhcworICAgICAgICBmaW5pc2hlZCBwcm9jZXNz aW5nIHRoYXQgYnVmZmVyOyBvbmx5IHRoZW4gdGhlIGNvbnRyb2wgcmV0dXJucyB0bworICAgICAg ICBhcHBzcmMsIHdobyBjYW4gcHVzaCB0aGUgbmV4dCBidWZmZXIuCisKKyAgICAgICAgQnkgcHVz aGluZyBhbiBhZGRpdGlvbmFsIGJ1ZmZlciBhbmQgY2FwdHVyaW5nIGl0IGluIGEgcHJvYmUgd2Ug Y2FuCisgICAgICAgIGRldGVjdCByZWxpYWJseSB3aGVuIHRoZSBwcmV2aW91cyBidWZmZXIgaGFz IGJlZW4gcHJvY2Vzc2VkLgorICAgICAgICBCZWNhdXNlIHRoZSBwaXBlbGluZSBvbmx5IGhhcyBv bmUgdGhyZWFkLCBhdCB0aGlzIHBvaW50IG5vIG1vcmUgZnJhbWVzCisgICAgICAgIGNhbiBhcnJp dmUgdG8gdGhlIGFwcHNpbmsuCisKKyAgICAgICAgVGhpcyByZXBsYWNlcyB0aGUgb2xkIG1ldGhv ZCBvZiBkZXRlY3RpbmcgZW5kIG9mIGFwcGVuZCB3aGljaCByZWxpZWQKKyAgICAgICAgb24gdGhl IGBuZWVkLWRhdGFgIGV2ZW50LCB3aGljaCBpcyBtb3JlIGRpZmZpY3VsdCB0byBoYW5kbGUgY29y cmVjdGx5CisgICAgICAgIGJlY2F1c2UgaXQgZmlyZXMgd2hlbmV2ZXIgdGhlIGFwcHNyYyBpcyBl bXB0eSAob3IgYmVsb3cgYSBnaXZlbgorICAgICAgICBsZXZlbCksIHdoaWNoIGFsc28gaGFwcGVu cyB3aGVuIGEgYnVmZmVyIGhhcyBub3QgYmVlbiBwdXNoZWQgeWV0IG9yCisgICAgICAgIGluIHJl c3BvbnNlIHRvIGEgZmx1c2guCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVuZE9mQXBwZW5k TWV0YTo6aW5pdCk6CisgICAgICAgIChXZWJDb3JlOjpFbmRPZkFwcGVuZE1ldGE6OnRyYW5zZm9y bSk6CisgICAgICAgIChXZWJDb3JlOjpFbmRPZkFwcGVuZE1ldGE6OmZyZWUpOgorICAgICAgICAo V2ViQ29yZTo6QXBwZW5kUGlwZWxpbmU6OnN0YXRpY0luaXRpYWxpemF0aW9uKToKKyAgICAgICAg KFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpBcHBlbmRQaXBlbGluZSk6CisgICAgICAgIChXZWJD b3JlOjpBcHBlbmRQaXBlbGluZTo6fkFwcGVuZFBpcGVsaW5lKToKKyAgICAgICAgKFdlYkNvcmU6 OkFwcGVuZFBpcGVsaW5lOjphcHBzcmNFbmRPZkFwcGVuZENoZWNrZXJQcm9iZSk6CisgICAgICAg IChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwbGljYXRpb25NZXNzYWdlKToKKyAg ICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpoYW5kbGVFbmRPZkFwcGVuZCk6CisgICAg ICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6Y29uc3VtZUFwcHNpbmtBdmFpbGFibGVTYW1w bGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZXNldFBpcGVsaW5lKToK KyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpwdXNoTmV3QnVmZmVyKToKKyAgICAg ICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpoYW5kbGVBcHBzcmNOZWVkRGF0YVJlY2VpdmVk KTogRGVsZXRlZC46CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBw c3JjQXRMZWFzdEFCdWZmZXJMZWZ0KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkFwcGVu ZFBpcGVsaW5lOjpjaGVja0VuZE9mQXBwZW5kKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkFwcGVuZFBpcGVsaW5lOjpzZXRBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKTogRGVsZXRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZW1vdmVBcHBzcmNEYXRhTGVhdmluZ1By b2JlKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZXBvcnRB cHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6QXBw ZW5kUGlwZWxpbmU6OnJlcG9ydEFwcHNyY05lZWREYXRhUmVjZWl2ZWQpOiBEZWxldGVkLgorICAg ICAgICAoV2ViQ29yZTo6YXBwZW5kUGlwZWxpbmVBcHBzcmNEYXRhTGVhdmluZyk6IERlbGV0ZWQu CisgICAgICAgIChXZWJDb3JlOjphcHBlbmRQaXBlbGluZUFwcHNyY05lZWREYXRhKTogRGVsZXRl ZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVs aW5lLmg6CisKIDIwMTgtMDktMjQgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5j b20+CiAKICAgICAgICAgZmVNb3JwaG9sb2d5IGZpbHRlciBpbiBDU1MgZG9lc24ndCB1cGRhdGUg d2hlbiBlbGVtZW50IG1vdmVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuY3BwCmluZGV4 IDg4N2UzZDViMjFkMTc2MzAzMTIzOWI0NTVjNWRkNDUzNmE4N2M4OTcuLjRiZjU3MTMzYTNkYWFl ZTYxOGM0MjBmNGRhMGE5OGE0MWZkZmQzMTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlwZWxp bmUuY3BwCkBAIC00Niw2ICs0NiwzMCBAQCBHU1RfREVCVUdfQ0FURUdPUllfRVhURVJOKHdlYmtp dF9tc2VfZGVidWcpOwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2Jvb2wgQXBwZW5kUGlwZWxp bmU6OnNfc3RhdGljSW5pdGlhbGl6YXRpb25Eb25lID0gZmFsc2U7CisKK3N0cnVjdCBFbmRPZkFw cGVuZE1ldGEgeworICAgIEdzdE1ldGEgYmFzZTsKKyAgICBzdGF0aWMgZ2Jvb2xlYW4gaW5pdChH c3RNZXRhKiwgdm9pZCosIEdzdEJ1ZmZlciopIHsgcmV0dXJuIFRSVUU7IH0KKyAgICBzdGF0aWMg Z2Jvb2xlYW4gdHJhbnNmb3JtKEdzdEJ1ZmZlciosIEdzdE1ldGEqLCBHc3RCdWZmZXIqLCBHUXVh cmssIHZvaWQqKSB7IGdfcmV0dXJuX3ZhbF9pZl9yZWFjaGVkKEZBTFNFKTsgfQorICAgIHN0YXRp YyB2b2lkIGZyZWUoR3N0TWV0YSosIEdzdEJ1ZmZlciopIHsgfQorfTsKKworc3RhdGljIEdUeXBl IGVuZE9mQXBwZW5kTWV0YVR5cGUgPSAwOworc3RhdGljIGNvbnN0IEdzdE1ldGFJbmZvKiB3ZWJL aXRFbmRPZkFwcGVuZE1ldGFJbmZvID0gbnVsbHB0cjsKKwordm9pZCBBcHBlbmRQaXBlbGluZTo6 c3RhdGljSW5pdGlhbGl6YXRpb24oKQoreworICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgp KTsKKyAgICBpZiAoc19zdGF0aWNJbml0aWFsaXphdGlvbkRvbmUpCisgICAgICAgIHJldHVybjsK KworICAgIGNvbnN0IGNoYXIqIHRhZ3NbXSA9IHtudWxscHRyfTsKKyAgICBlbmRPZkFwcGVuZE1l dGFUeXBlID0gZ3N0X21ldGFfYXBpX3R5cGVfcmVnaXN0ZXIoIldlYktpdEVuZE9mQXBwZW5kTWV0 YUFQSSIsIHRhZ3MpOworICAgIHdlYktpdEVuZE9mQXBwZW5kTWV0YUluZm8gPSBnc3RfbWV0YV9y ZWdpc3RlcihlbmRPZkFwcGVuZE1ldGFUeXBlLCAiV2ViS2l0RW5kT2ZBcHBlbmRNZXRhIiwgc2l6 ZW9mKEVuZE9mQXBwZW5kTWV0YSksIEVuZE9mQXBwZW5kTWV0YTo6aW5pdCwgRW5kT2ZBcHBlbmRN ZXRhOjpmcmVlLCBFbmRPZkFwcGVuZE1ldGE6OnRyYW5zZm9ybSk7CisgICAgc19zdGF0aWNJbml0 aWFsaXphdGlvbkRvbmUgPSB0cnVlOworfQorCiBzdGF0aWMgY29uc3QgY2hhciogZHVtcEFwcGVu ZFN0YXRlKEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRTdGF0ZSBhcHBlbmRTdGF0ZSkKIHsKICAgICBz d2l0Y2ggKGFwcGVuZFN0YXRlKSB7CkBAIC02OCwxMSArOTIsOSBAQCBzdGF0aWMgY29uc3QgY2hh ciogZHVtcEFwcGVuZFN0YXRlKEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRTdGF0ZSBhcHBlbmRTdGF0 ZSkKICAgICB9CiB9CiAKLXN0YXRpYyB2b2lkIGFwcGVuZFBpcGVsaW5lQXBwc3JjTmVlZERhdGEo R3N0QXBwU3JjKiwgZ3VpbnQsIEFwcGVuZFBpcGVsaW5lKik7CiBzdGF0aWMgdm9pZCBhcHBlbmRQ aXBlbGluZURlbXV4ZXJQYWRBZGRlZChHc3RFbGVtZW50KiwgR3N0UGFkKiwgQXBwZW5kUGlwZWxp bmUqKTsKIHN0YXRpYyB2b2lkIGFwcGVuZFBpcGVsaW5lRGVtdXhlclBhZFJlbW92ZWQoR3N0RWxl bWVudCosIEdzdFBhZCosIEFwcGVuZFBpcGVsaW5lKik7CiBzdGF0aWMgdm9pZCBhcHBlbmRQaXBl bGluZUFwcHNpbmtDYXBzQ2hhbmdlZChHT2JqZWN0KiwgR1BhcmFtU3BlYyosIEFwcGVuZFBpcGVs aW5lKik7Ci1zdGF0aWMgR3N0UGFkUHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVBcHBzcmNEYXRh TGVhdmluZyhHc3RQYWQqLCBHc3RQYWRQcm9iZUluZm8qLCBBcHBlbmRQaXBlbGluZSopOwogI2lm ICFMT0dfRElTQUJMRUQKIHN0YXRpYyBHc3RQYWRQcm9iZVJldHVybiBhcHBlbmRQaXBlbGluZVBh ZFByb2JlRGVidWdJbmZvcm1hdGlvbihHc3RQYWQqLCBHc3RQYWRQcm9iZUluZm8qLCBzdHJ1Y3Qg UGFkUHJvYmVJbmZvcm1hdGlvbiopOwogI2VuZGlmCkBAIC0xMTAsMTQgKzEzMiwxMiBAQCBBcHBl bmRQaXBlbGluZTo6QXBwZW5kUGlwZWxpbmUoUmVmPE1lZGlhU291cmNlQ2xpZW50R1N0cmVhbWVy TVNFPiBtZWRpYVNvdXJjZUNsaQogICAgICwgbV9wbGF5ZXJQcml2YXRlKCZwbGF5ZXJQcml2YXRl KQogICAgICwgbV9pZCgwKQogICAgICwgbV93YXNCdXNBbHJlYWR5Tm90aWZpZWRPZkF2YWlsYWJs ZVNhbXBsZXMoZmFsc2UpCi0gICAgLCBtX2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdChmYWxzZSkK LSAgICAsIG1fYXBwc3JjTmVlZERhdGFSZWNlaXZlZChmYWxzZSkKLSAgICAsIG1fYXBwc3JjRGF0 YUxlYXZpbmdQcm9iZUlkKDApCiAgICAgLCBtX2FwcGVuZFN0YXRlKEFwcGVuZFN0YXRlOjpOb3RT dGFydGVkKQogICAgICwgbV9hYm9ydFBlbmRpbmcoZmFsc2UpCiAgICAgLCBtX3N0cmVhbVR5cGUo VW5rbm93bikKIHsKICAgICBBU1NFUlQoV1RGOjppc01haW5UaHJlYWQoKSk7CisgICAgc3RhdGlj SW5pdGlhbGl6YXRpb24oKTsKIAogICAgIEdTVF9UUkFDRSgiQ3JlYXRpbmcgQXBwZW5kUGlwZWxp bmUgKCVwKSIsIHRoaXMpOwogCkBAIC0xMzcsNiArMTU3LDExIEBAIEFwcGVuZFBpcGVsaW5lOjpB cHBlbmRQaXBlbGluZShSZWY8TWVkaWFTb3VyY2VDbGllbnRHU3RyZWFtZXJNU0U+IG1lZGlhU291 cmNlQ2xpCiAgICAgLy8gYmVsb3cgd2lsbCBhbHJlYWR5IHRha2UgdGhlIGluaXRpYWwgcmVmZXJl bmNlIGFuZCB3ZSBuZWVkIGFuIGFkZGl0aW9uYWwgb25lIGZvciB1cy4KICAgICBtX2FwcHNyYyA9 IGdzdF9lbGVtZW50X2ZhY3RvcnlfbWFrZSgiYXBwc3JjIiwgbnVsbHB0cik7CiAKKyAgICBHUmVm UHRyPEdzdFBhZD4gYXBwc3JjUGFkID0gYWRvcHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNf cGFkKG1fYXBwc3JjLmdldCgpLCAic3JjIikpOworICAgIGdzdF9wYWRfYWRkX3Byb2JlKGFwcHNy Y1BhZC5nZXQoKSwgR1NUX1BBRF9QUk9CRV9UWVBFX0JVRkZFUiwgW10oR3N0UGFkKiwgR3N0UGFk UHJvYmVJbmZvKiBwYWRQcm9iZUluZm8sIHZvaWQqIHVzZXJEYXRhKSB7CisgICAgICAgIHJldHVy biBzdGF0aWNfY2FzdDxBcHBlbmRQaXBlbGluZSo+KHVzZXJEYXRhKS0+YXBwc3JjRW5kT2ZBcHBl bmRDaGVja2VyUHJvYmUocGFkUHJvYmVJbmZvKTsKKyAgICB9LCB0aGlzLCBudWxscHRyKTsKKwog ICAgIGNvbnN0IFN0cmluZyYgdHlwZSA9IG1fc291cmNlQnVmZmVyUHJpdmF0ZS0+dHlwZSgpLmNv bnRhaW5lclR5cGUoKTsKICAgICBpZiAodHlwZS5lbmRzV2l0aCgibXA0IikpCiAgICAgICAgIG1f ZGVtdXggPSBnc3RfZWxlbWVudF9mYWN0b3J5X21ha2UoInF0ZGVtdXgiLCBudWxscHRyKTsKQEAg LTE1NCw4ICsxNzksNiBAQCBBcHBlbmRQaXBlbGluZTo6QXBwZW5kUGlwZWxpbmUoUmVmPE1lZGlh U291cmNlQ2xpZW50R1N0cmVhbWVyTVNFPiBtZWRpYVNvdXJjZUNsaQogICAgIEdSZWZQdHI8R3N0 UGFkPiBhcHBzaW5rUGFkID0gYWRvcHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNfcGFkKG1f YXBwc2luay5nZXQoKSwgInNpbmsiKSk7CiAgICAgZ19zaWduYWxfY29ubmVjdChhcHBzaW5rUGFk LmdldCgpLCAibm90aWZ5OjpjYXBzIiwgR19DQUxMQkFDSyhhcHBlbmRQaXBlbGluZUFwcHNpbmtD YXBzQ2hhbmdlZCksIHRoaXMpOwogCi0gICAgc2V0QXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgpOwot CiAjaWYgIUxPR19ESVNBQkxFRAogICAgIEdSZWZQdHI8R3N0UGFkPiBkZW11eGVyUGFkID0gYWRv cHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNfcGFkKG1fZGVtdXguZ2V0KCksICJzaW5rIikp OwogICAgIG1fZGVtdXhlckRhdGFFbnRlcmluZ1BhZFByb2JlSW5mb3JtYXRpb24uYXBwZW5kUGlw ZWxpbmUgPSB0aGlzOwpAQCAtMTczLDcgKzE5Niw2IEBAIEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRQ aXBlbGluZShSZWY8TWVkaWFTb3VyY2VDbGllbnRHU3RyZWFtZXJNU0U+IG1lZGlhU291cmNlQ2xp CiAjZW5kaWYKIAogICAgIC8vIFRoZXNlIHNpZ25hbHMgd29uJ3QgYmUgY29ubmVjdGVkIG91dHNp ZGUgb2YgdGhlIGxpZmV0aW1lIG9mICJ0aGlzIi4KLSAgICBnX3NpZ25hbF9jb25uZWN0KG1fYXBw c3JjLmdldCgpLCAibmVlZC1kYXRhIiwgR19DQUxMQkFDSyhhcHBlbmRQaXBlbGluZUFwcHNyY05l ZWREYXRhKSwgdGhpcyk7CiAgICAgZ19zaWduYWxfY29ubmVjdChtX2RlbXV4LmdldCgpLCAicGFk LWFkZGVkIiwgR19DQUxMQkFDSyhhcHBlbmRQaXBlbGluZURlbXV4ZXJQYWRBZGRlZCksIHRoaXMp OwogICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9kZW11eC5nZXQoKSwgInBhZC1yZW1vdmVkIiwgR19D QUxMQkFDSyhhcHBlbmRQaXBlbGluZURlbXV4ZXJQYWRSZW1vdmVkKSwgdGhpcyk7CiAgICAgZ19z aWduYWxfY29ubmVjdChtX2RlbXV4LmdldCgpLCAibm8tbW9yZS1wYWRzIiwgR19DQUxMQkFDSyhh cHBlbmRQaXBlbGluZURlbXV4ZXJOb01vcmVQYWRzKSwgdGhpcyk7CkBAIC0yMTMsNyArMjM1LDYg QEAgQXBwZW5kUGlwZWxpbmU6On5BcHBlbmRQaXBlbGluZSgpCiAgICAgfQogCiAgICAgaWYgKG1f YXBwc3JjKSB7Ci0gICAgICAgIHJlbW92ZUFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKTsKICAgICAg ICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9ieV9kYXRhKG1fYXBwc3JjLmdldCgpLCB0 aGlzKTsKICAgICAgICAgbV9hcHBzcmMgPSBudWxscHRyOwogICAgIH0KQEAgLTI0Nyw2ICsyNjgs MjYgQEAgQXBwZW5kUGlwZWxpbmU6On5BcHBlbmRQaXBlbGluZSgpCiAgICAgbV9kZW11eGVyU3Jj UGFkQ2FwcyA9IG51bGxwdHI7CiB9OwogCitHc3RQYWRQcm9iZVJldHVybiBBcHBlbmRQaXBlbGlu ZTo6YXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoR3N0UGFkUHJvYmVJbmZvKiBwYWRQcm9i ZUluZm8pCit7CisgICAgQVNTRVJUKCFXVEY6OmlzTWFpblRocmVhZCgpKTsKKworICAgIEdzdEJ1 ZmZlciogYnVmZmVyID0gR1NUX0JVRkZFUihwYWRQcm9iZUluZm8tPmRhdGEpOworICAgIEFTU0VS VChHU1RfSVNfQlVGRkVSKGJ1ZmZlcikpOworCisgICAgRW5kT2ZBcHBlbmRNZXRhKiBlbmRPZkFw cGVuZE1ldGEgPSByZWludGVycHJldF9jYXN0PEVuZE9mQXBwZW5kTWV0YSo+KGdzdF9idWZmZXJf Z2V0X21ldGEoYnVmZmVyLCBlbmRPZkFwcGVuZE1ldGFUeXBlKSk7CisgICAgaWYgKCFlbmRPZkFw cGVuZE1ldGEpIHsKKyAgICAgICAgLy8gTm9ybWFsIGJ1ZmZlciwgbm90aGluZyB0byBkby4KKyAg ICAgICAgcmV0dXJuIEdTVF9QQURfUFJPQkVfT0s7CisgICAgfQorCisgICAgR1NUX1RSQUNFX09C SkVDVCh0aGlzLCAicG9zdGluZyBlbmQtb2YtYXBwZW5kIHJlcXVlc3QgdG8gYnVzIik7CisgICAg R3N0U3RydWN0dXJlKiBzdHJ1Y3R1cmUgPSBnc3Rfc3RydWN0dXJlX25ld19lbXB0eSgiZW5kLW9m LWFwcGVuZCIpOworICAgIEdzdE1lc3NhZ2UqIG1lc3NhZ2UgPSBnc3RfbWVzc2FnZV9uZXdfYXBw bGljYXRpb24oR1NUX09CSkVDVChtX2FwcHNyYy5nZXQoKSksIHN0cnVjdHVyZSk7CisgICAgZ3N0 X2J1c19wb3N0KG1fYnVzLmdldCgpLCBtZXNzYWdlKTsKKyAgICByZXR1cm4gR1NUX1BBRF9QUk9C RV9EUk9QOworfQorCiB2b2lkIEFwcGVuZFBpcGVsaW5lOjpjbGVhclBsYXllclByaXZhdGUoKQog ewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgpKTsKQEAgLTI4NSwxNiArMzI2LDYgQEAg dm9pZCBBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwbGljYXRpb25NZXNzYWdlKEdzdE1lc3NhZ2Uq IG1lc3NhZ2UpCiAKICAgICBjb25zdCBHc3RTdHJ1Y3R1cmUqIHN0cnVjdHVyZSA9IGdzdF9tZXNz YWdlX2dldF9zdHJ1Y3R1cmUobWVzc2FnZSk7CiAKLSAgICBpZiAoZ3N0X3N0cnVjdHVyZV9oYXNf bmFtZShzdHJ1Y3R1cmUsICJhcHBzcmMtbmVlZC1kYXRhIikpIHsKLSAgICAgICAgaGFuZGxlQXBw c3JjTmVlZERhdGFSZWNlaXZlZCgpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgaWYg KGdzdF9zdHJ1Y3R1cmVfaGFzX25hbWUoc3RydWN0dXJlLCAiYXBwc3JjLWJ1ZmZlci1sZWZ0Iikp IHsKLSAgICAgICAgaGFuZGxlQXBwc3JjQXRMZWFzdEFCdWZmZXJMZWZ0KCk7Ci0gICAgICAgIHJl dHVybjsKLSAgICB9Ci0KICAgICBpZiAoZ3N0X3N0cnVjdHVyZV9oYXNfbmFtZShzdHJ1Y3R1cmUs ICJkZW11eGVyLWNvbm5lY3QtdG8tYXBwc2luayIpKSB7CiAgICAgICAgIEdSZWZQdHI8R3N0UGFk PiBkZW11eGVyU3JjUGFkOwogICAgICAgICBnc3Rfc3RydWN0dXJlX2dldChzdHJ1Y3R1cmUsICJk ZW11eGVyLXNyYy1wYWQiLCBHX1RZUEVfT0JKRUNULCAmZGVtdXhlclNyY1BhZC5vdXRQdHIoKSwg bnVsbHB0cik7CkBAIC0zMjQsNiArMzU1LDExIEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRs ZUFwcGxpY2F0aW9uTWVzc2FnZShHc3RNZXNzYWdlKiBtZXNzYWdlKQogICAgICAgICByZXR1cm47 CiAgICAgfQogCisgICAgaWYgKGdzdF9zdHJ1Y3R1cmVfaGFzX25hbWUoc3RydWN0dXJlLCAiZW5k LW9mLWFwcGVuZCIpKSB7CisgICAgICAgIGhhbmRsZUVuZE9mQXBwZW5kKCk7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIApAQCAtMzUzLDMx ICszODksNiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpoYW5kbGVTdGF0ZUNoYW5nZU1lc3NhZ2Uo R3N0TWVzc2FnZSogbWVzc2FnZSkKICAgICB9CiB9CiAKLXZvaWQgQXBwZW5kUGlwZWxpbmU6Omhh bmRsZUFwcHNyY05lZWREYXRhUmVjZWl2ZWQoKQotewotICAgIGlmICghbV9hcHBzcmNBdExlYXN0 QUJ1ZmZlckxlZnQpIHsKLSAgICAgICAgR1NUX1RSQUNFKCJkaXNjYXJkaW5nIHVudGlsIGF0IGxl YXN0IGEgYnVmZmVyIGxlYXZlcyBhcHBzcmMiKTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQot ICAgIEFTU0VSVChtX2FwcGVuZFN0YXRlID09IEFwcGVuZFN0YXRlOjpPbmdvaW5nIHx8IG1fYXBw ZW5kU3RhdGUgPT0gQXBwZW5kU3RhdGU6OlNhbXBsaW5nKTsKLSAgICBBU1NFUlQoIW1fYXBwc3Jj TmVlZERhdGFSZWNlaXZlZCk7Ci0KLSAgICBHU1RfVFJBQ0UoInJlY2VpdmVkIG5lZWQtZGF0YSBm cm9tIGFwcHNyYyIpOwotCi0gICAgbV9hcHBzcmNOZWVkRGF0YVJlY2VpdmVkID0gdHJ1ZTsKLSAg ICBjaGVja0VuZE9mQXBwZW5kKCk7Ci19Ci0KLXZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFw cHNyY0F0TGVhc3RBQnVmZmVyTGVmdCgpCi17Ci0gICAgbV9hcHBzcmNBdExlYXN0QUJ1ZmZlckxl ZnQgPSB0cnVlOwotICAgIEdTVF9UUkFDRSgicmVjZWl2ZWQgYnVmZmVyLWxlZnQgZnJvbSBhcHBz cmMiKTsKLSNpZiBMT0dfRElTQUJMRUQKLSAgICByZW1vdmVBcHBzcmNEYXRhTGVhdmluZ1Byb2Jl KCk7Ci0jZW5kaWYKLX0KLQogZ2ludCBBcHBlbmRQaXBlbGluZTo6aWQoKQogewogICAgIEFTU0VS VChXVEY6OmlzTWFpblRocmVhZCgpKTsKQEAgLTYwMywyNCArNjE0LDE5IEBAIHZvaWQgQXBwZW5k UGlwZWxpbmU6OmFwcHNpbmtDYXBzQ2hhbmdlZCgpCiAgICAgfQogfQogCi12b2lkIEFwcGVuZFBp cGVsaW5lOjpjaGVja0VuZE9mQXBwZW5kKCkKK3ZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUVu ZE9mQXBwZW5kKCkKIHsKICAgICBBU1NFUlQoV1RGOjppc01haW5UaHJlYWQoKSk7CisgICAgR1NU X1RSQUNFX09CSkVDVCh0aGlzLCAicmVjZWl2ZWQgZW5kLW9mLWFwcGVuZCIpOwogCi0gICAgaWYg KCFtX2FwcHNyY05lZWREYXRhUmVjZWl2ZWQgfHwgKG1fYXBwZW5kU3RhdGUgIT0gQXBwZW5kU3Rh dGU6Ok9uZ29pbmcgJiYgbV9hcHBlbmRTdGF0ZSAhPSBBcHBlbmRTdGF0ZTo6U2FtcGxpbmcpKQot ICAgICAgICByZXR1cm47Ci0KLSAgICBHU1RfVFJBQ0UoImVuZCBvZiBhcHBlbmQgZGF0YSBtYXJr IHdhcyByZWNlaXZlZCIpOwotCisgICAgLy8gUmVnYXJkbGVzcyBvZiB0aGUgc3RhdGUgdHJhbnNp dGlvbiwgdGhlIHJlc3VsdCBpcyB0aGUgc2FtZTogZGlkUmVjZWl2ZUFsbFBlbmRpbmdTYW1wbGVz KCkgaXMgY2FsbGVkLgogICAgIHN3aXRjaCAobV9hcHBlbmRTdGF0ZSkgewogICAgIGNhc2UgQXBw ZW5kU3RhdGU6Ok9uZ29pbmc6CiAgICAgICAgIEdTVF9UUkFDRSgiRGF0YVN0YXJ2ZSIpOwotICAg ICAgICBtX2FwcHNyY05lZWREYXRhUmVjZWl2ZWQgPSBmYWxzZTsKICAgICAgICAgc2V0QXBwZW5k U3RhdGUoQXBwZW5kU3RhdGU6OkRhdGFTdGFydmUpOwogICAgICAgICBicmVhazsKICAgICBjYXNl IEFwcGVuZFN0YXRlOjpTYW1wbGluZzoKICAgICAgICAgR1NUX1RSQUNFKCJMYXN0U2FtcGxlIik7 Ci0gICAgICAgIG1fYXBwc3JjTmVlZERhdGFSZWNlaXZlZCA9IGZhbHNlOwogICAgICAgICBzZXRB cHBlbmRTdGF0ZShBcHBlbmRTdGF0ZTo6TGFzdFNhbXBsZSk7CiAgICAgICAgIGJyZWFrOwogICAg IGRlZmF1bHQ6CkBAIC02MzMsMTQgKzYzOSw2IEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFwcHNp bmtOZXdTYW1wbGUoR1JlZlB0cjxHc3RTYW1wbGU+JiYgc2FtcGxlKQogewogICAgIEFTU0VSVChX VEY6OmlzTWFpblRocmVhZCgpKTsKIAotICAgIC8vIElnbm9yZSBzYW1wbGVzIGlmIHdlJ3JlIG5v dCBleHBlY3RpbmcgdGhlbS4gUmVmdXNlIHByb2Nlc3NpbmcgaWYgd2UncmUgaW4gSW52YWxpZCBz dGF0ZS4KLSAgICBpZiAobV9hcHBlbmRTdGF0ZSAhPSBBcHBlbmRTdGF0ZTo6T25nb2luZyAmJiBt X2FwcGVuZFN0YXRlICE9IEFwcGVuZFN0YXRlOjpTYW1wbGluZykgewotICAgICAgICBHU1RfV0FS TklORygiVW5leHBlY3RlZCBzYW1wbGUsIGFwcGVuZFN0YXRlPSVzIiwgZHVtcEFwcGVuZFN0YXRl KG1fYXBwZW5kU3RhdGUpKTsKLSAgICAgICAgLy8gRklYTUU6IFJldHVybiBFUlJPUiBhbmQgZmlu ZCBhIG1vcmUgcm9idXN0IHdheSB0byBkZXRlY3QgdGhhdCBhbGwgdGhlCi0gICAgICAgIC8vIGRh dGEgaGFzIGJlZW4gcHJvY2Vzc2VkLCBzbyB3ZSBkb24ndCBuZWVkIHRvIHJlc29ydCB0byB0aGVz ZSBoYWNrcy4KLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQogICAgIGlmIChVTkxJS0VMWSghZ3N0 X3NhbXBsZV9nZXRfYnVmZmVyKHNhbXBsZS5nZXQoKSkpKSB7CiAgICAgICAgIEdTVF9XQVJOSU5H KCJSZWNlaXZlZCBzYW1wbGUgd2l0aG91dCBidWZmZXIgZnJvbSBhcHBzaW5rLiIpOwogICAgICAg ICByZXR1cm47CkBAIC03NDgsMTcgKzc0NiwxMiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpjb25z dW1lQXBwc2lua0F2YWlsYWJsZVNhbXBsZXMoKQogICAgIH0KIAogICAgIEdTVF9UUkFDRV9PQkpF Q1QodGhpcywgImJhdGNoZWRTYW1wbGVDb3VudCA9ICVkIiwgYmF0Y2hlZFNhbXBsZUNvdW50KTsK LQotICAgIGlmIChiYXRjaGVkU2FtcGxlQ291bnQgPiAwKQotICAgICAgICBjaGVja0VuZE9mQXBw ZW5kKCk7CiB9CiAKIHZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlc2V0UGlwZWxpbmUoKQogewogICAg IEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgpKTsKICAgICBHU1RfREVCVUcoInJlc2V0dGluZyBw aXBlbGluZSIpOwotICAgIG1fYXBwc3JjQXRMZWFzdEFCdWZmZXJMZWZ0ID0gZmFsc2U7Ci0gICAg c2V0QXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgpOwogCiAgICAgZ3N0X2VsZW1lbnRfc2V0X3N0YXRl KG1fcGlwZWxpbmUuZ2V0KCksIEdTVF9TVEFURV9SRUFEWSk7CiAgICAgZ3N0X2VsZW1lbnRfZ2V0 X3N0YXRlKG1fcGlwZWxpbmUuZ2V0KCksIG51bGxwdHIsIG51bGxwdHIsIDApOwpAQCAtNzc0LDI5 ICs3NjcsNiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpyZXNldFBpcGVsaW5lKCkKIAogfQogCi12 b2lkIEFwcGVuZFBpcGVsaW5lOjpzZXRBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCkKLXsKLSAgICBp ZiAobV9hcHBzcmNEYXRhTGVhdmluZ1Byb2JlSWQpCi0gICAgICAgIHJldHVybjsKLQotICAgIEdT VF9UUkFDRSgic2V0dGluZyBhcHBzcmMgZGF0YSBsZWF2aW5nIHByb2JlIik7Ci0KLSAgICBHUmVm UHRyPEdzdFBhZD4gYXBwc3JjUGFkID0gYWRvcHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNf cGFkKG1fYXBwc3JjLmdldCgpLCAic3JjIikpOwotICAgIG1fYXBwc3JjRGF0YUxlYXZpbmdQcm9i ZUlkID0gZ3N0X3BhZF9hZGRfcHJvYmUoYXBwc3JjUGFkLmdldCgpLCBHU1RfUEFEX1BST0JFX1RZ UEVfQlVGRkVSLCByZWludGVycHJldF9jYXN0PEdzdFBhZFByb2JlQ2FsbGJhY2s+KGFwcGVuZFBp cGVsaW5lQXBwc3JjRGF0YUxlYXZpbmcpLCB0aGlzLCBudWxscHRyKTsKLX0KLQotdm9pZCBBcHBl bmRQaXBlbGluZTo6cmVtb3ZlQXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgpCi17Ci0gICAgaWYgKCFt X2FwcHNyY0RhdGFMZWF2aW5nUHJvYmVJZCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgR1NUX1RS QUNFKCJyZW1vdmluZyBhcHBzcmMgZGF0YSBsZWF2aW5nIHByb2JlIik7Ci0KLSAgICBHUmVmUHRy PEdzdFBhZD4gYXBwc3JjUGFkID0gYWRvcHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNfcGFk KG1fYXBwc3JjLmdldCgpLCAic3JjIikpOwotICAgIGdzdF9wYWRfcmVtb3ZlX3Byb2JlKGFwcHNy Y1BhZC5nZXQoKSwgbV9hcHBzcmNEYXRhTGVhdmluZ1Byb2JlSWQpOwotICAgIG1fYXBwc3JjRGF0 YUxlYXZpbmdQcm9iZUlkID0gMDsKLX0KLQogdm9pZCBBcHBlbmRQaXBlbGluZTo6YWJvcnQoKQog ewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgpKTsKQEAgLTgxNiwzNCArNzg2LDI5IEBA IHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFib3J0KCkKIAogR3N0Rmxvd1JldHVybiBBcHBlbmRQaXBl bGluZTo6cHVzaE5ld0J1ZmZlcihHc3RCdWZmZXIqIGJ1ZmZlcikKIHsKLSAgICBHc3RGbG93UmV0 dXJuIHJlc3VsdDsKLQogICAgIGlmIChtX2Fib3J0UGVuZGluZykgewogICAgICAgICBtX3BlbmRp bmdCdWZmZXIgPSBhZG9wdEdSZWYoYnVmZmVyKTsKLSAgICAgICAgcmVzdWx0ID0gR1NUX0ZMT1df T0s7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgc2V0QXBwZW5kU3RhdGUoQXBwZW5kUGlwZWxpbmU6 OkFwcGVuZFN0YXRlOjpPbmdvaW5nKTsKLSAgICAgICAgR1NUX1RSQUNFKCJwdXNoaW5nIG5ldyBi dWZmZXIgJXAiLCBidWZmZXIpOwotICAgICAgICByZXN1bHQgPSBnc3RfYXBwX3NyY19wdXNoX2J1 ZmZlcihHU1RfQVBQX1NSQyhhcHBzcmMoKSksIGJ1ZmZlcik7CisgICAgICAgIHJldHVybiBHU1Rf RkxPV19PSzsKICAgICB9CiAKLSAgICByZXR1cm4gcmVzdWx0OwotfQorICAgIHNldEFwcGVuZFN0 YXRlKEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRTdGF0ZTo6T25nb2luZyk7CiAKLXZvaWQgQXBwZW5k UGlwZWxpbmU6OnJlcG9ydEFwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCgpCi17Ci0gICAgR1NUX1RS QUNFKCJidWZmZXIgbGVmdCBhcHBzcmMsIHJlcG9zdGluZyB0byBidXMiKTsKLSAgICBHc3RTdHJ1 Y3R1cmUqIHN0cnVjdHVyZSA9IGdzdF9zdHJ1Y3R1cmVfbmV3X2VtcHR5KCJhcHBzcmMtYnVmZmVy LWxlZnQiKTsKLSAgICBHc3RNZXNzYWdlKiBtZXNzYWdlID0gZ3N0X21lc3NhZ2VfbmV3X2FwcGxp Y2F0aW9uKEdTVF9PQkpFQ1QobV9hcHBzcmMuZ2V0KCkpLCBzdHJ1Y3R1cmUpOwotICAgIGdzdF9i dXNfcG9zdChtX2J1cy5nZXQoKSwgbWVzc2FnZSk7Ci19CisgICAgR1NUX1RSQUNFX09CSkVDVCh0 aGlzLCAicHVzaGluZyBkYXRhIGJ1ZmZlciAlcCIsIGJ1ZmZlcik7CisgICAgR3N0Rmxvd1JldHVy biBwdXNoRGF0YUJ1ZmZlclJldCA9IGdzdF9hcHBfc3JjX3B1c2hfYnVmZmVyKEdTVF9BUFBfU1JD KG1fYXBwc3JjLmdldCgpKSwgYnVmZmVyKTsKKyAgICBSRUxFQVNFX0FTU0VSVChwdXNoRGF0YUJ1 ZmZlclJldCA9PSBHU1RfRkxPV19PSyk7CiAKLXZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlcG9ydEFw cHNyY05lZWREYXRhUmVjZWl2ZWQoKQotewotICAgIEdTVF9UUkFDRSgicmVjZWl2ZWQgbmVlZC1k YXRhIHNpZ25hbCBhdCBhcHBzcmMsIHJlcG9zdGluZyB0byBidXMiKTsKLSAgICBHc3RTdHJ1Y3R1 cmUqIHN0cnVjdHVyZSA9IGdzdF9zdHJ1Y3R1cmVfbmV3X2VtcHR5KCJhcHBzcmMtbmVlZC1kYXRh Iik7Ci0gICAgR3N0TWVzc2FnZSogbWVzc2FnZSA9IGdzdF9tZXNzYWdlX25ld19hcHBsaWNhdGlv bihHU1RfT0JKRUNUKG1fYXBwc3JjLmdldCgpKSwgc3RydWN0dXJlKTsKLSAgICBnc3RfYnVzX3Bv c3QobV9idXMuZ2V0KCksIG1lc3NhZ2UpOworICAgIC8vIFB1c2ggYW4gYWRkaXRpb25hbCBlbXB0 eSBidWZmZXIgdGhhdCBtYXJrcyB0aGUgZW5kIG9mIHRoZSBhcHBlbmQuCisgICAgLy8gVGhpcyBi dWZmZXIgaXMgZGV0ZWN0ZWQgYW5kIGNvbnN1bWVkIGJ5IGFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tl clByb2JlKCksCisgICAgLy8gd2hpY2ggdXNlcyBpdCB0byBzaWduYWwgdGhlIHN1Y2Nlc3NmdWwg Y29tcGxldGlvbiBvZiB0aGUgYXBwZW5kLgorCisgICAgR3N0QnVmZmVyKiBlbmRPZkFwcGVuZEJ1 ZmZlciA9IGdzdF9idWZmZXJfbmV3KCk7CisgICAgZ3N0X2J1ZmZlcl9hZGRfbWV0YShlbmRPZkFw cGVuZEJ1ZmZlciwgd2ViS2l0RW5kT2ZBcHBlbmRNZXRhSW5mbywgbnVsbHB0cik7CisKKyAgICBH U1RfVFJBQ0VfT0JKRUNUKHRoaXMsICJwdXNoaW5nIGVuZC1vZi1hcHBlbmQgYnVmZmVyICVwIiwg ZW5kT2ZBcHBlbmRCdWZmZXIpOworICAgIEdzdEZsb3dSZXR1cm4gcHVzaEVuZE9mQXBwZW5kQnVm ZmVyUmV0ID0gZ3N0X2FwcF9zcmNfcHVzaF9idWZmZXIoR1NUX0FQUF9TUkMobV9hcHBzcmMuZ2V0 KCkpLCBlbmRPZkFwcGVuZEJ1ZmZlcik7CisgICAgUkVMRUFTRV9BU1NFUlQocHVzaEVuZE9mQXBw ZW5kQnVmZmVyUmV0ID09IEdTVF9GTE9XX09LKTsKKworICAgIHJldHVybiBHU1RfRkxPV19PSzsK IH0KIAogR3N0Rmxvd1JldHVybiBBcHBlbmRQaXBlbGluZTo6aGFuZGxlTmV3QXBwc2lua1NhbXBs ZShHc3RFbGVtZW50KiBhcHBzaW5rKQpAQCAtMTAzMyw5ICs5OTgsNyBAQCB2b2lkIEFwcGVuZFBp cGVsaW5lOjpjb25uZWN0RGVtdXhlclNyY1BhZFRvQXBwc2luayhHc3RQYWQqIGRlbXV4ZXJTcmNQ YWQpCiAgICAgICAgIGRpZFJlY2VpdmVJbml0aWFsaXphdGlvblNlZ21lbnQoKTsKICAgICAgICAg cmV0dXJuOwogICAgIGRlZmF1bHQ6Ci0gICAgICAgIC8vIE5vIHVzZWZ1bCBkYXRhLCBidXQgbm90 aWZ5IGFueXdheSB0byBjb21wbGV0ZSB0aGUgYXBwZW5kIG9wZXJhdGlvbi4KLSAgICAgICAgR1NU X0RFQlVHKCJSZWNlaXZlZCBhbGwgcGVuZGluZyBzYW1wbGVzIChubyBkYXRhKSIpOwotICAgICAg ICBtX3NvdXJjZUJ1ZmZlclByaXZhdGUtPmRpZFJlY2VpdmVBbGxQZW5kaW5nU2FtcGxlcygpOwor ICAgICAgICAvLyBObyB1c2VmdWwgZGF0YS4KICAgICAgICAgYnJlYWs7CiAgICAgfQogCkBAIC0x MDc4LDIwICsxMDQxLDYgQEAgc3RhdGljIHZvaWQgYXBwZW5kUGlwZWxpbmVBcHBzaW5rQ2Fwc0No YW5nZWQoR09iamVjdCogYXBwc2lua1BhZCwgR1BhcmFtU3BlYyosIEEKICAgICBHU1RfVFJBQ0Uo ImFwcHNpbmstY2Fwcy1jaGFuZ2VkIG1lc3NhZ2UgcG9zdGVkIHRvIGJ1cyIpOwogfQogCi1zdGF0 aWMgR3N0UGFkUHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVBcHBzcmNEYXRhTGVhdmluZyhHc3RQ YWQqLCBHc3RQYWRQcm9iZUluZm8qIGluZm8sIEFwcGVuZFBpcGVsaW5lKiBhcHBlbmRQaXBlbGlu ZSkKLXsKLSAgICBBU1NFUlQoR1NUX1BBRF9QUk9CRV9JTkZPX1RZUEUoaW5mbykgJiBHU1RfUEFE X1BST0JFX1RZUEVfQlVGRkVSKTsKLQotICAgIEdzdEJ1ZmZlciogYnVmZmVyID0gR1NUX1BBRF9Q Uk9CRV9JTkZPX0JVRkZFUihpbmZvKTsKLSAgICBnc2l6ZSBidWZmZXJTaXplID0gZ3N0X2J1ZmZl cl9nZXRfc2l6ZShidWZmZXIpOwotCi0gICAgR1NUX1RSQUNFKCJidWZmZXIgb2Ygc2l6ZSAlIiBH X0dTSVpFX0ZPUk1BVCAiIGdvaW5nIHRocnUiLCBidWZmZXJTaXplKTsKLQotICAgIGFwcGVuZFBp cGVsaW5lLT5yZXBvcnRBcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQoKTsKLQotICAgIHJldHVybiBH U1RfUEFEX1BST0JFX09LOwotfQotCiAjaWYgIUxPR19ESVNBQkxFRAogc3RhdGljIEdzdFBhZFBy b2JlUmV0dXJuIGFwcGVuZFBpcGVsaW5lUGFkUHJvYmVEZWJ1Z0luZm9ybWF0aW9uKEdzdFBhZCos IEdzdFBhZFByb2JlSW5mbyogaW5mbywgc3RydWN0IFBhZFByb2JlSW5mb3JtYXRpb24qIHBhZFBy b2JlSW5mb3JtYXRpb24pCiB7CkBAIC0xMTMxLDExICsxMDgwLDYgQEAgc3RhdGljIEdzdFBhZFBy b2JlUmV0dXJuIGFwcGVuZFBpcGVsaW5lRGVtdXhlckJsYWNrSG9sZVBhZFByb2JlKEdzdFBhZCos IEdzdFBhZFAKICAgICByZXR1cm4gR1NUX1BBRF9QUk9CRV9EUk9QOwogfQogCi1zdGF0aWMgdm9p ZCBhcHBlbmRQaXBlbGluZUFwcHNyY05lZWREYXRhKEdzdEFwcFNyYyosIGd1aW50LCBBcHBlbmRQ aXBlbGluZSogYXBwZW5kUGlwZWxpbmUpCi17Ci0gICAgYXBwZW5kUGlwZWxpbmUtPnJlcG9ydEFw cHNyY05lZWREYXRhUmVjZWl2ZWQoKTsKLX0KLQogc3RhdGljIHZvaWQgYXBwZW5kUGlwZWxpbmVE ZW11eGVyUGFkQWRkZWQoR3N0RWxlbWVudCosIEdzdFBhZCogZGVtdXhlclNyY1BhZCwgQXBwZW5k UGlwZWxpbmUqIGFwcGVuZFBpcGVsaW5lKQogewogICAgIGFwcGVuZFBpcGVsaW5lLT5jb25uZWN0 RGVtdXhlclNyY1BhZFRvQXBwc2lua0Zyb21BbnlUaHJlYWQoZGVtdXhlclNyY1BhZCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0Fw cGVuZFBpcGVsaW5lLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmgKaW5kZXggMzY2MGNiNmMxNWFiNzU3OWVhYTEyODM3ZGNi ZGZhNWQ5Njg3NzMxYi4uOTcwZmI2MGMwNTUyZWE1MWM4ZmNlYzk5ZjE0N2FiMmIwNTBlZjg2MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21z ZS9BcHBlbmRQaXBlbGluZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2dzdHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuaApAQCAtNjQsNiArNjQsNyBAQCBwdWJsaWM6 CiAgICAgdm9pZCBhcHBzaW5rQ2Fwc0NoYW5nZWQoKTsKICAgICB2b2lkIGFwcHNpbmtOZXdTYW1w bGUoR1JlZlB0cjxHc3RTYW1wbGU+JiYpOwogICAgIHZvaWQgYXBwc2lua0VPUygpOworICAgIHZv aWQgaGFuZGxlRW5kT2ZBcHBlbmQoKTsKICAgICB2b2lkIGRpZFJlY2VpdmVJbml0aWFsaXphdGlv blNlZ21lbnQoKTsKICAgICBBdG9taWNTdHJpbmcgdHJhY2tJZCgpOwogICAgIHZvaWQgYWJvcnQo KTsKQEAgLTg1LDIwICs4NiwxOSBAQCBwdWJsaWM6CiAgICAgdm9pZCBjb25uZWN0RGVtdXhlclNy Y1BhZFRvQXBwc2lua0Zyb21BbnlUaHJlYWQoR3N0UGFkKik7CiAgICAgdm9pZCBjb25uZWN0RGVt dXhlclNyY1BhZFRvQXBwc2luayhHc3RQYWQqKTsKIAotICAgIHZvaWQgcmVwb3J0QXBwc3JjQXRM ZWFzdEFCdWZmZXJMZWZ0KCk7Ci0gICAgdm9pZCByZXBvcnRBcHBzcmNOZWVkRGF0YVJlY2VpdmVk KCk7Ci0KIHByaXZhdGU6CiAgICAgdm9pZCByZXNldFBpcGVsaW5lKCk7CiAgICAgdm9pZCBjaGVj a0VuZE9mQXBwZW5kKCk7Ci0gICAgdm9pZCBoYW5kbGVBcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQo KTsKLSAgICB2b2lkIGhhbmRsZUFwcHNyY05lZWREYXRhUmVjZWl2ZWQoKTsKLSAgICB2b2lkIHJl bW92ZUFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKTsKLSAgICB2b2lkIHNldEFwcHNyY0RhdGFMZWF2 aW5nUHJvYmUoKTsKICAgICB2b2lkIGRlbXV4ZXJOb01vcmVQYWRzKCk7CiAKICAgICB2b2lkIGNv bnN1bWVBcHBzaW5rQXZhaWxhYmxlU2FtcGxlcygpOwogCisgICAgR3N0UGFkUHJvYmVSZXR1cm4g YXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoR3N0UGFkUHJvYmVJbmZvKik7CisKKyAgICBz dGF0aWMgdm9pZCBzdGF0aWNJbml0aWFsaXphdGlvbigpOworCisgICAgYm9vbCBzdGF0aWMgc19z dGF0aWNJbml0aWFsaXphdGlvbkRvbmU7CisKICAgICBSZWY8TWVkaWFTb3VyY2VDbGllbnRHU3Ry ZWFtZXJNU0U+IG1fbWVkaWFTb3VyY2VDbGllbnQ7CiAgICAgUmVmPFNvdXJjZUJ1ZmZlclByaXZh dGVHU3RyZWFtZXI+IG1fc291cmNlQnVmZmVyUHJpdmF0ZTsKICAgICBNZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJNU0UqIG1fcGxheWVyUHJpdmF0ZTsKQEAgLTEzMCwxMCArMTMwLDYgQEAgcHJp dmF0ZToKICAgICBHUmVmUHRyPEdzdENhcHM+IG1fZGVtdXhlclNyY1BhZENhcHM7CiAgICAgRmxv YXRTaXplIG1fcHJlc2VudGF0aW9uU2l6ZTsKIAotICAgIGJvb2wgbV9hcHBzcmNBdExlYXN0QUJ1 ZmZlckxlZnQ7Ci0gICAgYm9vbCBtX2FwcHNyY05lZWREYXRhUmVjZWl2ZWQ7Ci0KLSAgICBndWxv bmcgbV9hcHBzcmNEYXRhTGVhdmluZ1Byb2JlSWQ7CiAjaWYgIUxPR19ESVNBQkxFRAogICAgIHN0 cnVjdCBQYWRQcm9iZUluZm9ybWF0aW9uIG1fZGVtdXhlckRhdGFFbnRlcmluZ1BhZFByb2JlSW5m b3JtYXRpb247CiAgICAgc3RydWN0IFBhZFByb2JlSW5mb3JtYXRpb24gbV9hcHBzaW5rRGF0YUVu dGVyaW5nUGFkUHJvYmVJbmZvcm1hdGlvbjsK 350873 2018-09-26 10:58:51 -0700 2018-09-27 08:26:16 -0700 Patch bug-189924-20180926195850.patch text/plain 21972 aboya U3VidmVyc2lvbiBSZXZpc2lvbjogMjM2NTAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDQ1ZTk0NzVlZWJiYzA0 NDYzZDYyZjgzMTVhMmE3ZTdiM2NkNjQ1Ni4uYjZmNmVhMDQ0MDJlNWI4ZTFjMmIzZWYxMzgzMTZj NWYyZmRmNzk5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDE4LTA5LTI0ICBBbGlj aWEgQm95YSBHYXJjw61hICA8YWJveWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbTVNFXVtHU3Ry ZWFtZXJdIFVzZSBzZW50aW5lbCBidWZmZXIgdG8gZGV0ZWN0IGVuZCBvZiBhcHBlbmQKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTkyNAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaW50 cm9kdWNlcyBhIG5ldyBtZWNoYW5pc20gdG8gZGV0ZWN0IHdoZW4gYW4gYXBwZW5kIGhhcworICAg ICAgICBiZWVuIGNvbnN1bWVkIGNvbXBsZXRlbHkgYnkgdGhlIGRlbXV4ZXIuIEl0IHRha2VzIGFk dmFudGFnZSBvZiB0aGUKKyAgICAgICAgZmFjdCB0aGF0IGJ1ZmZlciBwdXNoaW5nIGlzIHN5bmNo cm9ub3VzOiBib3RoIHRoZSBhcHBzcmMgYW5kIHRoZQorICAgICAgICBkZW11eGVyIGxpdmUgaW4g dGhlIHNhbWUgc3RyZWFtaW5nIHRocmVhZC4gV2hlbiBhcHBzcmMgcHVzaGVzIGEKKyAgICAgICAg YnVmZmVyLCBpdCdzIGFjdHVhbGx5IG1ha2luZyBhIHF0ZGVtdXggZnVuY3Rpb24gY2FsbCAoaXQg Y2FsbHMgaXRzCisgICAgICAgICJjaGFpbiIgZnVuY3Rpb24pLiBUaGUgZGVtdXhlciB3aWxsIHJl dHVybiBmcm9tIHRoYXQgY2FsbCB3aGVuIGl0IGhhcworICAgICAgICBmaW5pc2hlZCBwcm9jZXNz aW5nIHRoYXQgYnVmZmVyOyBvbmx5IHRoZW4gdGhlIGNvbnRyb2wgcmV0dXJucyB0bworICAgICAg ICBhcHBzcmMsIHRoYXQgY2FuIHB1c2ggdGhlIG5leHQgYnVmZmVyLgorCisgICAgICAgIEJ5IHB1 c2hpbmcgYW4gYWRkaXRpb25hbCBidWZmZXIgYW5kIGNhcHR1cmluZyBpdCBpbiBhIHByb2JlIHdl IGNhbgorICAgICAgICBkZXRlY3QgcmVsaWFibHkgd2hlbiB0aGUgcHJldmlvdXMgYnVmZmVyIGhh cyBiZWVuIHByb2Nlc3NlZC4KKyAgICAgICAgQmVjYXVzZSB0aGUgcGlwZWxpbmUgb25seSBoYXMg b25lIHRocmVhZCwgYXQgdGhpcyBwb2ludCBubyBtb3JlIGZyYW1lcworICAgICAgICBjYW4gYXJy aXZlIHRvIHRoZSBhcHBzaW5rLgorCisgICAgICAgIFRoaXMgcmVwbGFjZXMgdGhlIG9sZCBtZXRo b2Qgb2YgZGV0ZWN0aW5nIGVuZCBvZiBhcHBlbmQgd2hpY2ggcmVsaWVkCisgICAgICAgIG9uIHRo ZSBgbmVlZC1kYXRhYCBldmVudCwgd2hpY2ggaXMgbW9yZSBkaWZmaWN1bHQgdG8gaGFuZGxlIGNv cnJlY3RseQorICAgICAgICBiZWNhdXNlIGl0IGZpcmVzIHdoZW5ldmVyIHRoZSBhcHBzcmMgaXMg ZW1wdHkgKG9yIGJlbG93IGEgZ2l2ZW4KKyAgICAgICAgbGV2ZWwpLCB3aGljaCBhbHNvIGhhcHBl bnMgd2hlbiBhIGJ1ZmZlciBoYXMgbm90IGJlZW4gcHVzaGVkIHlldCBvcgorICAgICAgICBpbiBy ZXNwb25zZSB0byBhIGZsdXNoLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFbmRPZkFwcGVu ZE1ldGE6OmluaXQpOgorICAgICAgICAoV2ViQ29yZTo6RW5kT2ZBcHBlbmRNZXRhOjp0cmFuc2Zv cm0pOgorICAgICAgICAoV2ViQ29yZTo6RW5kT2ZBcHBlbmRNZXRhOjpmcmVlKToKKyAgICAgICAg KFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpzdGF0aWNJbml0aWFsaXphdGlvbik6CisgICAgICAg IChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6QXBwZW5kUGlwZWxpbmUpOgorICAgICAgICAoV2Vi Q29yZTo6QXBwZW5kUGlwZWxpbmU6On5BcHBlbmRQaXBlbGluZSk6CisgICAgICAgIChXZWJDb3Jl OjpBcHBlbmRQaXBlbGluZTo6YXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUpOgorICAgICAg ICAoV2ViQ29yZTo6QXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFwcGxpY2F0aW9uTWVzc2FnZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxlRW5kT2ZBcHBlbmQpOgorICAg ICAgICAoV2ViQ29yZTo6QXBwZW5kUGlwZWxpbmU6OmNvbnN1bWVBcHBzaW5rQXZhaWxhYmxlU2Ft cGxlcyk6CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6cmVzZXRQaXBlbGluZSk6 CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6cHVzaE5ld0J1ZmZlcik6CisgICAg ICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwc3JjTmVlZERhdGFSZWNlaXZl ZCk6IERlbGV0ZWQuOgorICAgICAgICAoV2ViQ29yZTo6QXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFw cHNyY0F0TGVhc3RBQnVmZmVyTGVmdCk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpBcHBl bmRQaXBlbGluZTo6Y2hlY2tFbmRPZkFwcGVuZCk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3Jl OjpBcHBlbmRQaXBlbGluZTo6c2V0QXBwc3JjRGF0YUxlYXZpbmdQcm9iZSk6IERlbGV0ZWQuCisg ICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6cmVtb3ZlQXBwc3JjRGF0YUxlYXZpbmdQ cm9iZSk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6cmVwb3J0 QXBwc3JjQXRMZWFzdEFCdWZmZXJMZWZ0KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkFw cGVuZFBpcGVsaW5lOjpyZXBvcnRBcHBzcmNOZWVkRGF0YVJlY2VpdmVkKTogRGVsZXRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OmFwcGVuZFBpcGVsaW5lQXBwc3JjRGF0YUxlYXZpbmcpOiBEZWxldGVk LgorICAgICAgICAoV2ViQ29yZTo6YXBwZW5kUGlwZWxpbmVBcHBzcmNOZWVkRGF0YSk6IERlbGV0 ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9BcHBlbmRQaXBl bGluZS5oOgorCiAyMDE4LTA5LTI1ICBFcmljIENhcmxzb24gIDxlcmljLmNhcmxzb25AYXBwbGUu Y29tPgogCiAgICAgICAgIFtNZWRpYVN0cmVhbV0gQWRkIE1hYyB3aW5kb3cgY2FwdHVyZSBzb3Vy Y2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1l ci9tc2UvQXBwZW5kUGlwZWxpbmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHAKaW5kZXggODg3ZTNkNWIyMWQxNzYz MDMxMjM5YjQ1NWM1ZGQ0NTM2YTg3Yzg5Ny4uNzFkN2M5ZTNjNDM3YmFiNWVhNTllMDkwMGEyMGU4 YjFlOGIyOTljMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHAKQEAgLTQ2LDYg KzQ2LDI2IEBAIEdTVF9ERUJVR19DQVRFR09SWV9FWFRFUk4od2Via2l0X21zZV9kZWJ1Zyk7CiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorR1R5cGUgQXBwZW5kUGlwZWxpbmU6OnNfZW5kT2ZBcHBl bmRNZXRhVHlwZSA9IDA7Citjb25zdCBHc3RNZXRhSW5mbyogQXBwZW5kUGlwZWxpbmU6OnNfd2Vi S2l0RW5kT2ZBcHBlbmRNZXRhSW5mbyA9IG51bGxwdHI7CitzdGQ6Om9uY2VfZmxhZyBBcHBlbmRQ aXBlbGluZTo6c19zdGF0aWNJbml0aWFsaXphdGlvbkZsYWc7CisKK3N0cnVjdCBFbmRPZkFwcGVu ZE1ldGEgeworICAgIEdzdE1ldGEgYmFzZTsKKyAgICBzdGF0aWMgZ2Jvb2xlYW4gaW5pdChHc3RN ZXRhKiwgdm9pZCosIEdzdEJ1ZmZlciopIHsgcmV0dXJuIFRSVUU7IH0KKyAgICBzdGF0aWMgZ2Jv b2xlYW4gdHJhbnNmb3JtKEdzdEJ1ZmZlciosIEdzdE1ldGEqLCBHc3RCdWZmZXIqLCBHUXVhcmss IHZvaWQqKSB7IGdfcmV0dXJuX3ZhbF9pZl9yZWFjaGVkKEZBTFNFKTsgfQorICAgIHN0YXRpYyB2 b2lkIGZyZWUoR3N0TWV0YSosIEdzdEJ1ZmZlciopIHsgfQorfTsKKwordm9pZCBBcHBlbmRQaXBl bGluZTo6c3RhdGljSW5pdGlhbGl6YXRpb24oKQoreworICAgIEFTU0VSVChXVEY6OmlzTWFpblRo cmVhZCgpKTsKKworICAgIGNvbnN0IGNoYXIqIHRhZ3NbXSA9IHsgbnVsbHB0ciB9OworICAgIHNf ZW5kT2ZBcHBlbmRNZXRhVHlwZSA9IGdzdF9tZXRhX2FwaV90eXBlX3JlZ2lzdGVyKCJXZWJLaXRF bmRPZkFwcGVuZE1ldGFBUEkiLCB0YWdzKTsKKyAgICBzX3dlYktpdEVuZE9mQXBwZW5kTWV0YUlu Zm8gPSBnc3RfbWV0YV9yZWdpc3RlcihzX2VuZE9mQXBwZW5kTWV0YVR5cGUsICJXZWJLaXRFbmRP ZkFwcGVuZE1ldGEiLCBzaXplb2YoRW5kT2ZBcHBlbmRNZXRhKSwgRW5kT2ZBcHBlbmRNZXRhOjpp bml0LCBFbmRPZkFwcGVuZE1ldGE6OmZyZWUsIEVuZE9mQXBwZW5kTWV0YTo6dHJhbnNmb3JtKTsK K30KKwogc3RhdGljIGNvbnN0IGNoYXIqIGR1bXBBcHBlbmRTdGF0ZShBcHBlbmRQaXBlbGluZTo6 QXBwZW5kU3RhdGUgYXBwZW5kU3RhdGUpCiB7CiAgICAgc3dpdGNoIChhcHBlbmRTdGF0ZSkgewpA QCAtNjgsMTEgKzg4LDkgQEAgc3RhdGljIGNvbnN0IGNoYXIqIGR1bXBBcHBlbmRTdGF0ZShBcHBl bmRQaXBlbGluZTo6QXBwZW5kU3RhdGUgYXBwZW5kU3RhdGUpCiAgICAgfQogfQogCi1zdGF0aWMg dm9pZCBhcHBlbmRQaXBlbGluZUFwcHNyY05lZWREYXRhKEdzdEFwcFNyYyosIGd1aW50LCBBcHBl bmRQaXBlbGluZSopOwogc3RhdGljIHZvaWQgYXBwZW5kUGlwZWxpbmVEZW11eGVyUGFkQWRkZWQo R3N0RWxlbWVudCosIEdzdFBhZCosIEFwcGVuZFBpcGVsaW5lKik7CiBzdGF0aWMgdm9pZCBhcHBl bmRQaXBlbGluZURlbXV4ZXJQYWRSZW1vdmVkKEdzdEVsZW1lbnQqLCBHc3RQYWQqLCBBcHBlbmRQ aXBlbGluZSopOwogc3RhdGljIHZvaWQgYXBwZW5kUGlwZWxpbmVBcHBzaW5rQ2Fwc0NoYW5nZWQo R09iamVjdCosIEdQYXJhbVNwZWMqLCBBcHBlbmRQaXBlbGluZSopOwotc3RhdGljIEdzdFBhZFBy b2JlUmV0dXJuIGFwcGVuZFBpcGVsaW5lQXBwc3JjRGF0YUxlYXZpbmcoR3N0UGFkKiwgR3N0UGFk UHJvYmVJbmZvKiwgQXBwZW5kUGlwZWxpbmUqKTsKICNpZiAhTE9HX0RJU0FCTEVECiBzdGF0aWMg R3N0UGFkUHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVQYWRQcm9iZURlYnVnSW5mb3JtYXRpb24o R3N0UGFkKiwgR3N0UGFkUHJvYmVJbmZvKiwgc3RydWN0IFBhZFByb2JlSW5mb3JtYXRpb24qKTsK ICNlbmRpZgpAQCAtMTEwLDE0ICsxMjgsMTIgQEAgQXBwZW5kUGlwZWxpbmU6OkFwcGVuZFBpcGVs aW5lKFJlZjxNZWRpYVNvdXJjZUNsaWVudEdTdHJlYW1lck1TRT4gbWVkaWFTb3VyY2VDbGkKICAg ICAsIG1fcGxheWVyUHJpdmF0ZSgmcGxheWVyUHJpdmF0ZSkKICAgICAsIG1faWQoMCkKICAgICAs IG1fd2FzQnVzQWxyZWFkeU5vdGlmaWVkT2ZBdmFpbGFibGVTYW1wbGVzKGZhbHNlKQotICAgICwg bV9hcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQoZmFsc2UpCi0gICAgLCBtX2FwcHNyY05lZWREYXRh UmVjZWl2ZWQoZmFsc2UpCi0gICAgLCBtX2FwcHNyY0RhdGFMZWF2aW5nUHJvYmVJZCgwKQogICAg ICwgbV9hcHBlbmRTdGF0ZShBcHBlbmRTdGF0ZTo6Tm90U3RhcnRlZCkKICAgICAsIG1fYWJvcnRQ ZW5kaW5nKGZhbHNlKQogICAgICwgbV9zdHJlYW1UeXBlKFVua25vd24pCiB7CiAgICAgQVNTRVJU KFdURjo6aXNNYWluVGhyZWFkKCkpOworICAgIHN0ZDo6Y2FsbF9vbmNlKHNfc3RhdGljSW5pdGlh bGl6YXRpb25GbGFnLCBBcHBlbmRQaXBlbGluZTo6c3RhdGljSW5pdGlhbGl6YXRpb24pOwogCiAg ICAgR1NUX1RSQUNFKCJDcmVhdGluZyBBcHBlbmRQaXBlbGluZSAoJXApIiwgdGhpcyk7CiAKQEAg LTEzNyw2ICsxNTMsMTEgQEAgQXBwZW5kUGlwZWxpbmU6OkFwcGVuZFBpcGVsaW5lKFJlZjxNZWRp YVNvdXJjZUNsaWVudEdTdHJlYW1lck1TRT4gbWVkaWFTb3VyY2VDbGkKICAgICAvLyBiZWxvdyB3 aWxsIGFscmVhZHkgdGFrZSB0aGUgaW5pdGlhbCByZWZlcmVuY2UgYW5kIHdlIG5lZWQgYW4gYWRk aXRpb25hbCBvbmUgZm9yIHVzLgogICAgIG1fYXBwc3JjID0gZ3N0X2VsZW1lbnRfZmFjdG9yeV9t YWtlKCJhcHBzcmMiLCBudWxscHRyKTsKIAorICAgIEdSZWZQdHI8R3N0UGFkPiBhcHBzcmNQYWQg PSBhZG9wdEdSZWYoZ3N0X2VsZW1lbnRfZ2V0X3N0YXRpY19wYWQobV9hcHBzcmMuZ2V0KCksICJz cmMiKSk7CisgICAgZ3N0X3BhZF9hZGRfcHJvYmUoYXBwc3JjUGFkLmdldCgpLCBHU1RfUEFEX1BS T0JFX1RZUEVfQlVGRkVSLCBbXShHc3RQYWQqLCBHc3RQYWRQcm9iZUluZm8qIHBhZFByb2JlSW5m bywgdm9pZCogdXNlckRhdGEpIHsKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFwcGVuZFBp cGVsaW5lKj4odXNlckRhdGEpLT5hcHBzcmNFbmRPZkFwcGVuZENoZWNrZXJQcm9iZShwYWRQcm9i ZUluZm8pOworICAgIH0sIHRoaXMsIG51bGxwdHIpOworCiAgICAgY29uc3QgU3RyaW5nJiB0eXBl ID0gbV9zb3VyY2VCdWZmZXJQcml2YXRlLT50eXBlKCkuY29udGFpbmVyVHlwZSgpOwogICAgIGlm ICh0eXBlLmVuZHNXaXRoKCJtcDQiKSkKICAgICAgICAgbV9kZW11eCA9IGdzdF9lbGVtZW50X2Zh Y3RvcnlfbWFrZSgicXRkZW11eCIsIG51bGxwdHIpOwpAQCAtMTU0LDggKzE3NSw2IEBAIEFwcGVu ZFBpcGVsaW5lOjpBcHBlbmRQaXBlbGluZShSZWY8TWVkaWFTb3VyY2VDbGllbnRHU3RyZWFtZXJN U0U+IG1lZGlhU291cmNlQ2xpCiAgICAgR1JlZlB0cjxHc3RQYWQ+IGFwcHNpbmtQYWQgPSBhZG9w dEdSZWYoZ3N0X2VsZW1lbnRfZ2V0X3N0YXRpY19wYWQobV9hcHBzaW5rLmdldCgpLCAic2luayIp KTsKICAgICBnX3NpZ25hbF9jb25uZWN0KGFwcHNpbmtQYWQuZ2V0KCksICJub3RpZnk6OmNhcHMi LCBHX0NBTExCQUNLKGFwcGVuZFBpcGVsaW5lQXBwc2lua0NhcHNDaGFuZ2VkKSwgdGhpcyk7CiAK LSAgICBzZXRBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCk7Ci0KICNpZiAhTE9HX0RJU0FCTEVECiAg ICAgR1JlZlB0cjxHc3RQYWQ+IGRlbXV4ZXJQYWQgPSBhZG9wdEdSZWYoZ3N0X2VsZW1lbnRfZ2V0 X3N0YXRpY19wYWQobV9kZW11eC5nZXQoKSwgInNpbmsiKSk7CiAgICAgbV9kZW11eGVyRGF0YUVu dGVyaW5nUGFkUHJvYmVJbmZvcm1hdGlvbi5hcHBlbmRQaXBlbGluZSA9IHRoaXM7CkBAIC0xNzMs NyArMTkyLDYgQEAgQXBwZW5kUGlwZWxpbmU6OkFwcGVuZFBpcGVsaW5lKFJlZjxNZWRpYVNvdXJj ZUNsaWVudEdTdHJlYW1lck1TRT4gbWVkaWFTb3VyY2VDbGkKICNlbmRpZgogCiAgICAgLy8gVGhl c2Ugc2lnbmFscyB3b24ndCBiZSBjb25uZWN0ZWQgb3V0c2lkZSBvZiB0aGUgbGlmZXRpbWUgb2Yg InRoaXMiLgotICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9hcHBzcmMuZ2V0KCksICJuZWVkLWRhdGEi LCBHX0NBTExCQUNLKGFwcGVuZFBpcGVsaW5lQXBwc3JjTmVlZERhdGEpLCB0aGlzKTsKICAgICBn X3NpZ25hbF9jb25uZWN0KG1fZGVtdXguZ2V0KCksICJwYWQtYWRkZWQiLCBHX0NBTExCQUNLKGFw cGVuZFBpcGVsaW5lRGVtdXhlclBhZEFkZGVkKSwgdGhpcyk7CiAgICAgZ19zaWduYWxfY29ubmVj dChtX2RlbXV4LmdldCgpLCAicGFkLXJlbW92ZWQiLCBHX0NBTExCQUNLKGFwcGVuZFBpcGVsaW5l RGVtdXhlclBhZFJlbW92ZWQpLCB0aGlzKTsKICAgICBnX3NpZ25hbF9jb25uZWN0KG1fZGVtdXgu Z2V0KCksICJuby1tb3JlLXBhZHMiLCBHX0NBTExCQUNLKGFwcGVuZFBpcGVsaW5lRGVtdXhlck5v TW9yZVBhZHMpLCB0aGlzKTsKQEAgLTIxMyw3ICsyMzEsNiBAQCBBcHBlbmRQaXBlbGluZTo6fkFw cGVuZFBpcGVsaW5lKCkKICAgICB9CiAKICAgICBpZiAobV9hcHBzcmMpIHsKLSAgICAgICAgcmVt b3ZlQXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgpOwogICAgICAgICBnX3NpZ25hbF9oYW5kbGVyc19k aXNjb25uZWN0X2J5X2RhdGEobV9hcHBzcmMuZ2V0KCksIHRoaXMpOwogICAgICAgICBtX2FwcHNy YyA9IG51bGxwdHI7CiAgICAgfQpAQCAtMjQ3LDYgKzI2NCwyNyBAQCBBcHBlbmRQaXBlbGluZTo6 fkFwcGVuZFBpcGVsaW5lKCkKICAgICBtX2RlbXV4ZXJTcmNQYWRDYXBzID0gbnVsbHB0cjsKIH07 CiAKK0dzdFBhZFByb2JlUmV0dXJuIEFwcGVuZFBpcGVsaW5lOjphcHBzcmNFbmRPZkFwcGVuZENo ZWNrZXJQcm9iZShHc3RQYWRQcm9iZUluZm8qIHBhZFByb2JlSW5mbykKK3sKKyAgICBBU1NFUlQo IVdURjo6aXNNYWluVGhyZWFkKCkpOworICAgIG1fc3RyZWFtaW5nVGhyZWFkID0gJldURjo6VGhy ZWFkOjpjdXJyZW50KCk7CisKKyAgICBHc3RCdWZmZXIqIGJ1ZmZlciA9IEdTVF9CVUZGRVIocGFk UHJvYmVJbmZvLT5kYXRhKTsKKyAgICBBU1NFUlQoR1NUX0lTX0JVRkZFUihidWZmZXIpKTsKKwor ICAgIEVuZE9mQXBwZW5kTWV0YSogZW5kT2ZBcHBlbmRNZXRhID0gcmVpbnRlcnByZXRfY2FzdDxF bmRPZkFwcGVuZE1ldGEqPihnc3RfYnVmZmVyX2dldF9tZXRhKGJ1ZmZlciwgc19lbmRPZkFwcGVu ZE1ldGFUeXBlKSk7CisgICAgaWYgKCFlbmRPZkFwcGVuZE1ldGEpIHsKKyAgICAgICAgLy8gTm9y bWFsIGJ1ZmZlciwgbm90aGluZyB0byBkby4KKyAgICAgICAgcmV0dXJuIEdTVF9QQURfUFJPQkVf T0s7CisgICAgfQorCisgICAgR1NUX1RSQUNFX09CSkVDVCh0aGlzLCAicG9zdGluZyBlbmQtb2Yt YXBwZW5kIHJlcXVlc3QgdG8gYnVzIik7CisgICAgR3N0U3RydWN0dXJlKiBzdHJ1Y3R1cmUgPSBn c3Rfc3RydWN0dXJlX25ld19lbXB0eSgiZW5kLW9mLWFwcGVuZCIpOworICAgIEdzdE1lc3NhZ2Uq IG1lc3NhZ2UgPSBnc3RfbWVzc2FnZV9uZXdfYXBwbGljYXRpb24oR1NUX09CSkVDVChtX2FwcHNy Yy5nZXQoKSksIHN0cnVjdHVyZSk7CisgICAgZ3N0X2J1c19wb3N0KG1fYnVzLmdldCgpLCBtZXNz YWdlKTsKKyAgICByZXR1cm4gR1NUX1BBRF9QUk9CRV9EUk9QOworfQorCiB2b2lkIEFwcGVuZFBp cGVsaW5lOjpjbGVhclBsYXllclByaXZhdGUoKQogewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRo cmVhZCgpKTsKQEAgLTI4NSwxNiArMzIzLDYgQEAgdm9pZCBBcHBlbmRQaXBlbGluZTo6aGFuZGxl QXBwbGljYXRpb25NZXNzYWdlKEdzdE1lc3NhZ2UqIG1lc3NhZ2UpCiAKICAgICBjb25zdCBHc3RT dHJ1Y3R1cmUqIHN0cnVjdHVyZSA9IGdzdF9tZXNzYWdlX2dldF9zdHJ1Y3R1cmUobWVzc2FnZSk7 CiAKLSAgICBpZiAoZ3N0X3N0cnVjdHVyZV9oYXNfbmFtZShzdHJ1Y3R1cmUsICJhcHBzcmMtbmVl ZC1kYXRhIikpIHsKLSAgICAgICAgaGFuZGxlQXBwc3JjTmVlZERhdGFSZWNlaXZlZCgpOwotICAg ICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgaWYgKGdzdF9zdHJ1Y3R1cmVfaGFzX25hbWUoc3Ry dWN0dXJlLCAiYXBwc3JjLWJ1ZmZlci1sZWZ0IikpIHsKLSAgICAgICAgaGFuZGxlQXBwc3JjQXRM ZWFzdEFCdWZmZXJMZWZ0KCk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KICAgICBpZiAoZ3N0 X3N0cnVjdHVyZV9oYXNfbmFtZShzdHJ1Y3R1cmUsICJkZW11eGVyLWNvbm5lY3QtdG8tYXBwc2lu ayIpKSB7CiAgICAgICAgIEdSZWZQdHI8R3N0UGFkPiBkZW11eGVyU3JjUGFkOwogICAgICAgICBn c3Rfc3RydWN0dXJlX2dldChzdHJ1Y3R1cmUsICJkZW11eGVyLXNyYy1wYWQiLCBHX1RZUEVfT0JK RUNULCAmZGVtdXhlclNyY1BhZC5vdXRQdHIoKSwgbnVsbHB0cik7CkBAIC0zMjQsNiArMzUyLDEx IEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFwcGxpY2F0aW9uTWVzc2FnZShHc3RNZXNz YWdlKiBtZXNzYWdlKQogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgaWYgKGdzdF9zdHJ1 Y3R1cmVfaGFzX25hbWUoc3RydWN0dXJlLCAiZW5kLW9mLWFwcGVuZCIpKSB7CisgICAgICAgIGhh bmRsZUVuZE9mQXBwZW5kKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsKIH0KIApAQCAtMzUzLDMxICszODYsNiBAQCB2b2lkIEFwcGVuZFBpcGVs aW5lOjpoYW5kbGVTdGF0ZUNoYW5nZU1lc3NhZ2UoR3N0TWVzc2FnZSogbWVzc2FnZSkKICAgICB9 CiB9CiAKLXZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFwcHNyY05lZWREYXRhUmVjZWl2ZWQo KQotewotICAgIGlmICghbV9hcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQpIHsKLSAgICAgICAgR1NU X1RSQUNFKCJkaXNjYXJkaW5nIHVudGlsIGF0IGxlYXN0IGEgYnVmZmVyIGxlYXZlcyBhcHBzcmMi KTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQotICAgIEFTU0VSVChtX2FwcGVuZFN0YXRlID09 IEFwcGVuZFN0YXRlOjpPbmdvaW5nIHx8IG1fYXBwZW5kU3RhdGUgPT0gQXBwZW5kU3RhdGU6OlNh bXBsaW5nKTsKLSAgICBBU1NFUlQoIW1fYXBwc3JjTmVlZERhdGFSZWNlaXZlZCk7Ci0KLSAgICBH U1RfVFJBQ0UoInJlY2VpdmVkIG5lZWQtZGF0YSBmcm9tIGFwcHNyYyIpOwotCi0gICAgbV9hcHBz cmNOZWVkRGF0YVJlY2VpdmVkID0gdHJ1ZTsKLSAgICBjaGVja0VuZE9mQXBwZW5kKCk7Ci19Ci0K LXZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUFwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCgpCi17 Ci0gICAgbV9hcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQgPSB0cnVlOwotICAgIEdTVF9UUkFDRSgi cmVjZWl2ZWQgYnVmZmVyLWxlZnQgZnJvbSBhcHBzcmMiKTsKLSNpZiBMT0dfRElTQUJMRUQKLSAg ICByZW1vdmVBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCk7Ci0jZW5kaWYKLX0KLQogZ2ludCBBcHBl bmRQaXBlbGluZTo6aWQoKQogewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgpKTsKQEAg LTYwMywyNCArNjExLDE5IEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFwcHNpbmtDYXBzQ2hhbmdl ZCgpCiAgICAgfQogfQogCi12b2lkIEFwcGVuZFBpcGVsaW5lOjpjaGVja0VuZE9mQXBwZW5kKCkK K3ZvaWQgQXBwZW5kUGlwZWxpbmU6OmhhbmRsZUVuZE9mQXBwZW5kKCkKIHsKICAgICBBU1NFUlQo V1RGOjppc01haW5UaHJlYWQoKSk7CisgICAgR1NUX1RSQUNFX09CSkVDVCh0aGlzLCAicmVjZWl2 ZWQgZW5kLW9mLWFwcGVuZCIpOwogCi0gICAgaWYgKCFtX2FwcHNyY05lZWREYXRhUmVjZWl2ZWQg fHwgKG1fYXBwZW5kU3RhdGUgIT0gQXBwZW5kU3RhdGU6Ok9uZ29pbmcgJiYgbV9hcHBlbmRTdGF0 ZSAhPSBBcHBlbmRTdGF0ZTo6U2FtcGxpbmcpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBHU1Rf VFJBQ0UoImVuZCBvZiBhcHBlbmQgZGF0YSBtYXJrIHdhcyByZWNlaXZlZCIpOwotCisgICAgLy8g UmVnYXJkbGVzcyBvZiB0aGUgc3RhdGUgdHJhbnNpdGlvbiwgdGhlIHJlc3VsdCBpcyB0aGUgc2Ft ZTogZGlkUmVjZWl2ZUFsbFBlbmRpbmdTYW1wbGVzKCkgaXMgY2FsbGVkLgogICAgIHN3aXRjaCAo bV9hcHBlbmRTdGF0ZSkgewogICAgIGNhc2UgQXBwZW5kU3RhdGU6Ok9uZ29pbmc6CiAgICAgICAg IEdTVF9UUkFDRSgiRGF0YVN0YXJ2ZSIpOwotICAgICAgICBtX2FwcHNyY05lZWREYXRhUmVjZWl2 ZWQgPSBmYWxzZTsKICAgICAgICAgc2V0QXBwZW5kU3RhdGUoQXBwZW5kU3RhdGU6OkRhdGFTdGFy dmUpOwogICAgICAgICBicmVhazsKICAgICBjYXNlIEFwcGVuZFN0YXRlOjpTYW1wbGluZzoKICAg ICAgICAgR1NUX1RSQUNFKCJMYXN0U2FtcGxlIik7Ci0gICAgICAgIG1fYXBwc3JjTmVlZERhdGFS ZWNlaXZlZCA9IGZhbHNlOwogICAgICAgICBzZXRBcHBlbmRTdGF0ZShBcHBlbmRTdGF0ZTo6TGFz dFNhbXBsZSk7CiAgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CkBAIC02MzMsMTQgKzYzNiw2 IEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFwcHNpbmtOZXdTYW1wbGUoR1JlZlB0cjxHc3RTYW1w bGU+JiYgc2FtcGxlKQogewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgpKTsKIAotICAg IC8vIElnbm9yZSBzYW1wbGVzIGlmIHdlJ3JlIG5vdCBleHBlY3RpbmcgdGhlbS4gUmVmdXNlIHBy b2Nlc3NpbmcgaWYgd2UncmUgaW4gSW52YWxpZCBzdGF0ZS4KLSAgICBpZiAobV9hcHBlbmRTdGF0 ZSAhPSBBcHBlbmRTdGF0ZTo6T25nb2luZyAmJiBtX2FwcGVuZFN0YXRlICE9IEFwcGVuZFN0YXRl OjpTYW1wbGluZykgewotICAgICAgICBHU1RfV0FSTklORygiVW5leHBlY3RlZCBzYW1wbGUsIGFw cGVuZFN0YXRlPSVzIiwgZHVtcEFwcGVuZFN0YXRlKG1fYXBwZW5kU3RhdGUpKTsKLSAgICAgICAg Ly8gRklYTUU6IFJldHVybiBFUlJPUiBhbmQgZmluZCBhIG1vcmUgcm9idXN0IHdheSB0byBkZXRl Y3QgdGhhdCBhbGwgdGhlCi0gICAgICAgIC8vIGRhdGEgaGFzIGJlZW4gcHJvY2Vzc2VkLCBzbyB3 ZSBkb24ndCBuZWVkIHRvIHJlc29ydCB0byB0aGVzZSBoYWNrcy4KLSAgICAgICAgcmV0dXJuOwot ICAgIH0KLQogICAgIGlmIChVTkxJS0VMWSghZ3N0X3NhbXBsZV9nZXRfYnVmZmVyKHNhbXBsZS5n ZXQoKSkpKSB7CiAgICAgICAgIEdTVF9XQVJOSU5HKCJSZWNlaXZlZCBzYW1wbGUgd2l0aG91dCBi dWZmZXIgZnJvbSBhcHBzaW5rLiIpOwogICAgICAgICByZXR1cm47CkBAIC03NDgsMTcgKzc0Mywx MiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpjb25zdW1lQXBwc2lua0F2YWlsYWJsZVNhbXBsZXMo KQogICAgIH0KIAogICAgIEdTVF9UUkFDRV9PQkpFQ1QodGhpcywgImJhdGNoZWRTYW1wbGVDb3Vu dCA9ICVkIiwgYmF0Y2hlZFNhbXBsZUNvdW50KTsKLQotICAgIGlmIChiYXRjaGVkU2FtcGxlQ291 bnQgPiAwKQotICAgICAgICBjaGVja0VuZE9mQXBwZW5kKCk7CiB9CiAKIHZvaWQgQXBwZW5kUGlw ZWxpbmU6OnJlc2V0UGlwZWxpbmUoKQogewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRocmVhZCgp KTsKICAgICBHU1RfREVCVUcoInJlc2V0dGluZyBwaXBlbGluZSIpOwotICAgIG1fYXBwc3JjQXRM ZWFzdEFCdWZmZXJMZWZ0ID0gZmFsc2U7Ci0gICAgc2V0QXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgp OwogCiAgICAgZ3N0X2VsZW1lbnRfc2V0X3N0YXRlKG1fcGlwZWxpbmUuZ2V0KCksIEdTVF9TVEFU RV9SRUFEWSk7CiAgICAgZ3N0X2VsZW1lbnRfZ2V0X3N0YXRlKG1fcGlwZWxpbmUuZ2V0KCksIG51 bGxwdHIsIG51bGxwdHIsIDApOwpAQCAtNzc0LDI5ICs3NjQsNiBAQCB2b2lkIEFwcGVuZFBpcGVs aW5lOjpyZXNldFBpcGVsaW5lKCkKIAogfQogCi12b2lkIEFwcGVuZFBpcGVsaW5lOjpzZXRBcHBz cmNEYXRhTGVhdmluZ1Byb2JlKCkKLXsKLSAgICBpZiAobV9hcHBzcmNEYXRhTGVhdmluZ1Byb2Jl SWQpCi0gICAgICAgIHJldHVybjsKLQotICAgIEdTVF9UUkFDRSgic2V0dGluZyBhcHBzcmMgZGF0 YSBsZWF2aW5nIHByb2JlIik7Ci0KLSAgICBHUmVmUHRyPEdzdFBhZD4gYXBwc3JjUGFkID0gYWRv cHRHUmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNfcGFkKG1fYXBwc3JjLmdldCgpLCAic3JjIikp OwotICAgIG1fYXBwc3JjRGF0YUxlYXZpbmdQcm9iZUlkID0gZ3N0X3BhZF9hZGRfcHJvYmUoYXBw c3JjUGFkLmdldCgpLCBHU1RfUEFEX1BST0JFX1RZUEVfQlVGRkVSLCByZWludGVycHJldF9jYXN0 PEdzdFBhZFByb2JlQ2FsbGJhY2s+KGFwcGVuZFBpcGVsaW5lQXBwc3JjRGF0YUxlYXZpbmcpLCB0 aGlzLCBudWxscHRyKTsKLX0KLQotdm9pZCBBcHBlbmRQaXBlbGluZTo6cmVtb3ZlQXBwc3JjRGF0 YUxlYXZpbmdQcm9iZSgpCi17Ci0gICAgaWYgKCFtX2FwcHNyY0RhdGFMZWF2aW5nUHJvYmVJZCkK LSAgICAgICAgcmV0dXJuOwotCi0gICAgR1NUX1RSQUNFKCJyZW1vdmluZyBhcHBzcmMgZGF0YSBs ZWF2aW5nIHByb2JlIik7Ci0KLSAgICBHUmVmUHRyPEdzdFBhZD4gYXBwc3JjUGFkID0gYWRvcHRH UmVmKGdzdF9lbGVtZW50X2dldF9zdGF0aWNfcGFkKG1fYXBwc3JjLmdldCgpLCAic3JjIikpOwot ICAgIGdzdF9wYWRfcmVtb3ZlX3Byb2JlKGFwcHNyY1BhZC5nZXQoKSwgbV9hcHBzcmNEYXRhTGVh dmluZ1Byb2JlSWQpOwotICAgIG1fYXBwc3JjRGF0YUxlYXZpbmdQcm9iZUlkID0gMDsKLX0KLQog dm9pZCBBcHBlbmRQaXBlbGluZTo6YWJvcnQoKQogewogICAgIEFTU0VSVChXVEY6OmlzTWFpblRo cmVhZCgpKTsKQEAgLTgxNiwzOSArNzgzLDUxIEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFib3J0 KCkKIAogR3N0Rmxvd1JldHVybiBBcHBlbmRQaXBlbGluZTo6cHVzaE5ld0J1ZmZlcihHc3RCdWZm ZXIqIGJ1ZmZlcikKIHsKLSAgICBHc3RGbG93UmV0dXJuIHJlc3VsdDsKLQogICAgIGlmIChtX2Fi b3J0UGVuZGluZykgewogICAgICAgICBtX3BlbmRpbmdCdWZmZXIgPSBhZG9wdEdSZWYoYnVmZmVy KTsKLSAgICAgICAgcmVzdWx0ID0gR1NUX0ZMT1dfT0s7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAg c2V0QXBwZW5kU3RhdGUoQXBwZW5kUGlwZWxpbmU6OkFwcGVuZFN0YXRlOjpPbmdvaW5nKTsKLSAg ICAgICAgR1NUX1RSQUNFKCJwdXNoaW5nIG5ldyBidWZmZXIgJXAiLCBidWZmZXIpOwotICAgICAg ICByZXN1bHQgPSBnc3RfYXBwX3NyY19wdXNoX2J1ZmZlcihHU1RfQVBQX1NSQyhhcHBzcmMoKSks IGJ1ZmZlcik7CisgICAgICAgIHJldHVybiBHU1RfRkxPV19PSzsKICAgICB9CiAKLSAgICByZXR1 cm4gcmVzdWx0OwotfQorICAgIHNldEFwcGVuZFN0YXRlKEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRT dGF0ZTo6T25nb2luZyk7CiAKLXZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlcG9ydEFwcHNyY0F0TGVh c3RBQnVmZmVyTGVmdCgpCi17Ci0gICAgR1NUX1RSQUNFKCJidWZmZXIgbGVmdCBhcHBzcmMsIHJl cG9zdGluZyB0byBidXMiKTsKLSAgICBHc3RTdHJ1Y3R1cmUqIHN0cnVjdHVyZSA9IGdzdF9zdHJ1 Y3R1cmVfbmV3X2VtcHR5KCJhcHBzcmMtYnVmZmVyLWxlZnQiKTsKLSAgICBHc3RNZXNzYWdlKiBt ZXNzYWdlID0gZ3N0X21lc3NhZ2VfbmV3X2FwcGxpY2F0aW9uKEdTVF9PQkpFQ1QobV9hcHBzcmMu Z2V0KCkpLCBzdHJ1Y3R1cmUpOwotICAgIGdzdF9idXNfcG9zdChtX2J1cy5nZXQoKSwgbWVzc2Fn ZSk7Ci19CisgICAgR1NUX1RSQUNFX09CSkVDVCh0aGlzLCAicHVzaGluZyBkYXRhIGJ1ZmZlciAl cCIsIGJ1ZmZlcik7CisgICAgR3N0Rmxvd1JldHVybiBwdXNoRGF0YUJ1ZmZlclJldCA9IGdzdF9h cHBfc3JjX3B1c2hfYnVmZmVyKEdTVF9BUFBfU1JDKG1fYXBwc3JjLmdldCgpKSwgYnVmZmVyKTsK KyAgICAvLyBQdXNoaW5nIGJ1ZmZlcnMgdG8gYXBwc3JjIGNhbiBvbmx5IGZhaWwgaWYgdGhlIGFw cHNyYyBpcyBmbHVzaGluZywgaW4gRU9TIG9yIHN0b3BwZWQuIE5laXRoZXIgb2YgdGhlc2Ugc2hv dWxkCisgICAgLy8gYmUgdHJ1ZSBhdCB0aGlzIHBvaW50LgorICAgIGdfcmV0dXJuX3ZhbF9pZl9m YWlsKHB1c2hEYXRhQnVmZmVyUmV0ID09IEdTVF9GTE9XX09LLCBHU1RfRkxPV19FUlJPUik7CiAK LXZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlcG9ydEFwcHNyY05lZWREYXRhUmVjZWl2ZWQoKQotewot ICAgIEdTVF9UUkFDRSgicmVjZWl2ZWQgbmVlZC1kYXRhIHNpZ25hbCBhdCBhcHBzcmMsIHJlcG9z dGluZyB0byBidXMiKTsKLSAgICBHc3RTdHJ1Y3R1cmUqIHN0cnVjdHVyZSA9IGdzdF9zdHJ1Y3R1 cmVfbmV3X2VtcHR5KCJhcHBzcmMtbmVlZC1kYXRhIik7Ci0gICAgR3N0TWVzc2FnZSogbWVzc2Fn ZSA9IGdzdF9tZXNzYWdlX25ld19hcHBsaWNhdGlvbihHU1RfT0JKRUNUKG1fYXBwc3JjLmdldCgp KSwgc3RydWN0dXJlKTsKLSAgICBnc3RfYnVzX3Bvc3QobV9idXMuZ2V0KCksIG1lc3NhZ2UpOwor ICAgIC8vIFB1c2ggYW4gYWRkaXRpb25hbCBlbXB0eSBidWZmZXIgdGhhdCBtYXJrcyB0aGUgZW5k IG9mIHRoZSBhcHBlbmQuCisgICAgLy8gVGhpcyBidWZmZXIgaXMgZGV0ZWN0ZWQgYW5kIGNvbnN1 bWVkIGJ5IGFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tlclByb2JlKCksIHdoaWNoIHVzZXMgaXQgdG8g c2lnbmFsIHRoZSBzdWNjZXNzZnVsCisgICAgLy8gY29tcGxldGlvbiBvZiB0aGUgYXBwZW5kLgor ICAgIC8vCisgICAgLy8gVGhpcyB3b3JrcyBiYXNlZCBvbiBob3cgcHVzaCBtb2RlIHNjaGVkdWxp bmcgd29ya3MgaW4gR1N0cmVhbWVyLiBOb3RlIHRoZXJlIGlzIGEgc2luZ2xlIHN0cmVhbWluZyB0 aHJlYWQgZm9yIHRoZQorICAgIC8vIEFwcGVuZFBpcGVsaW5lLCBhbmQgd2l0aGluIGEgc3RyZWFt ICh0aGUgcG9ydGlvbiBvZiBhIHBpcGVsaW5lIGNvdmVyZWQgYnkgdGhlIHNhbWUgc3RyZWFtaW5n IHRocmVhZCwgaW4gdGhpcyBjYXNlCisgICAgLy8gdGhlIHdob2xlIHBpcGVsaW5lKSBhIGJ1ZmZl ciBpcyBndWFyYW50ZWVkIG5vdCB0byBiZSBwcm9jZXNzZWQgYnkgZG93bnN0cmVhbSB1bnRpbCBw cm9jZXNzaW5nIG9mIHRoZSBwcmV2aW91cworICAgIC8vIGJ1ZmZlciBoYXMgY29tcGxldGVkLgor CisgICAgR3N0QnVmZmVyKiBlbmRPZkFwcGVuZEJ1ZmZlciA9IGdzdF9idWZmZXJfbmV3KCk7Cisg ICAgZ3N0X2J1ZmZlcl9hZGRfbWV0YShlbmRPZkFwcGVuZEJ1ZmZlciwgc193ZWJLaXRFbmRPZkFw cGVuZE1ldGFJbmZvLCBudWxscHRyKTsKKworICAgIEdTVF9UUkFDRV9PQkpFQ1QodGhpcywgInB1 c2hpbmcgZW5kLW9mLWFwcGVuZCBidWZmZXIgJXAiLCBlbmRPZkFwcGVuZEJ1ZmZlcik7CisgICAg R3N0Rmxvd1JldHVybiBwdXNoRW5kT2ZBcHBlbmRCdWZmZXJSZXQgPSBnc3RfYXBwX3NyY19wdXNo X2J1ZmZlcihHU1RfQVBQX1NSQyhtX2FwcHNyYy5nZXQoKSksIGVuZE9mQXBwZW5kQnVmZmVyKTsK KyAgICBnX3JldHVybl92YWxfaWZfZmFpbChwdXNoRW5kT2ZBcHBlbmRCdWZmZXJSZXQgPT0gR1NU X0ZMT1dfT0ssIEdTVF9GTE9XX0VSUk9SKTsKKworICAgIHJldHVybiBHU1RfRkxPV19PSzsKIH0K IAogR3N0Rmxvd1JldHVybiBBcHBlbmRQaXBlbGluZTo6aGFuZGxlTmV3QXBwc2lua1NhbXBsZShH c3RFbGVtZW50KiBhcHBzaW5rKQogewogICAgIEFTU0VSVCghV1RGOjppc01haW5UaHJlYWQoKSk7 CisgICAgaWYgKCZXVEY6OlRocmVhZDo6Y3VycmVudCgpICE9IG1fc3RyZWFtaW5nVGhyZWFkKSB7 CisgICAgICAgIC8vIG1fc3RyZWFtaW5nVGhyZWFkSWQgaGFzIGJlZW4gaW5pdGlhbGl6ZWQgaW4g YXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoKS4KKyAgICAgICAgLy8gRm9yIGEgYnVmZmVy IHRvIHJlYWNoIHRoZSBhcHBzaW5rLCBhIGJ1ZmZlciBtdXN0IGhhdmUgcGFzc2VkIHRocm91Z2gg YXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoKSBmaXJzdC4KKyAgICAgICAgLy8gVGhpcyBl cnJvciB3aWxsIG9ubHkgcmFpc2UgaWYgc29tZW9uZSBtb2RpZmllcyB0aGUgcGlwZWxpbmUgdG8g aW5jbHVkZSBtb3JlIHRoYW4gb25lIHN0cmVhbWluZyB0aHJlYWQgb3IKKyAgICAgICAgLy8gcmVt b3ZlcyB0aGUgYXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoKS4gRWl0aGVyIHdheSwgdGhl IGVuZC1vZi1hcHBlbmQgZGV0ZWN0aW9uIHdvdWxkIGJlIGJyb2tlbi4KKyAgICAgICAgLy8gQXBw ZW5kUGlwZWxpbmUgc2hvdWxkIGhhdmUgb25seSBvbmUgc3RyZWFtaW5nIHRocmVhZC4gT3RoZXJ3 aXNlIHdlIGNhbid0IGRldGVjdCByZWxpYWJseSB3aGVuIGFuIGFwcGVuZHMgaGFzCisgICAgICAg IC8vIGJlZW4gZGVtdXhlZCBjb21wbGV0ZWx5LjsKKyAgICAgICAgZ19jcml0aWNhbCgiQXBwc2lu ayByZWNlaXZlZCBhIHNhbXBsZSBpbiBhIGRpZmZlcmVudCB0aHJlYWQgdGhhbiBhcHBzcmNFbmRP ZkFwcGVuZENoZWNrZXJQcm9iZSBydW4uIik7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9S RUFDSEVEKCk7CisgICAgfQogCiAgICAgaWYgKCFtX3BsYXllclByaXZhdGUgfHwgbV9hcHBlbmRT dGF0ZSA9PSBBcHBlbmRTdGF0ZTo6SW52YWxpZCkgewogICAgICAgICBHU1RfV0FSTklORygiQXBw ZW5kUGlwZWxpbmUgaGFzIGJlZW4gZGlzYWJsZWQsIGlnbm9yaW5nIHRoaXMgc2FtcGxlIik7CkBA IC0xMDMzLDkgKzEwMTIsNyBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpjb25uZWN0RGVtdXhlclNy Y1BhZFRvQXBwc2luayhHc3RQYWQqIGRlbXV4ZXJTcmNQYWQpCiAgICAgICAgIGRpZFJlY2VpdmVJ bml0aWFsaXphdGlvblNlZ21lbnQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIGRlZmF1bHQ6Ci0g ICAgICAgIC8vIE5vIHVzZWZ1bCBkYXRhLCBidXQgbm90aWZ5IGFueXdheSB0byBjb21wbGV0ZSB0 aGUgYXBwZW5kIG9wZXJhdGlvbi4KLSAgICAgICAgR1NUX0RFQlVHKCJSZWNlaXZlZCBhbGwgcGVu ZGluZyBzYW1wbGVzIChubyBkYXRhKSIpOwotICAgICAgICBtX3NvdXJjZUJ1ZmZlclByaXZhdGUt PmRpZFJlY2VpdmVBbGxQZW5kaW5nU2FtcGxlcygpOworICAgICAgICAvLyBObyB1c2VmdWwgZGF0 YS4KICAgICAgICAgYnJlYWs7CiAgICAgfQogCkBAIC0xMDc4LDIwICsxMDU1LDYgQEAgc3RhdGlj IHZvaWQgYXBwZW5kUGlwZWxpbmVBcHBzaW5rQ2Fwc0NoYW5nZWQoR09iamVjdCogYXBwc2lua1Bh ZCwgR1BhcmFtU3BlYyosIEEKICAgICBHU1RfVFJBQ0UoImFwcHNpbmstY2Fwcy1jaGFuZ2VkIG1l c3NhZ2UgcG9zdGVkIHRvIGJ1cyIpOwogfQogCi1zdGF0aWMgR3N0UGFkUHJvYmVSZXR1cm4gYXBw ZW5kUGlwZWxpbmVBcHBzcmNEYXRhTGVhdmluZyhHc3RQYWQqLCBHc3RQYWRQcm9iZUluZm8qIGlu Zm8sIEFwcGVuZFBpcGVsaW5lKiBhcHBlbmRQaXBlbGluZSkKLXsKLSAgICBBU1NFUlQoR1NUX1BB RF9QUk9CRV9JTkZPX1RZUEUoaW5mbykgJiBHU1RfUEFEX1BST0JFX1RZUEVfQlVGRkVSKTsKLQot ICAgIEdzdEJ1ZmZlciogYnVmZmVyID0gR1NUX1BBRF9QUk9CRV9JTkZPX0JVRkZFUihpbmZvKTsK LSAgICBnc2l6ZSBidWZmZXJTaXplID0gZ3N0X2J1ZmZlcl9nZXRfc2l6ZShidWZmZXIpOwotCi0g ICAgR1NUX1RSQUNFKCJidWZmZXIgb2Ygc2l6ZSAlIiBHX0dTSVpFX0ZPUk1BVCAiIGdvaW5nIHRo cnUiLCBidWZmZXJTaXplKTsKLQotICAgIGFwcGVuZFBpcGVsaW5lLT5yZXBvcnRBcHBzcmNBdExl YXN0QUJ1ZmZlckxlZnQoKTsKLQotICAgIHJldHVybiBHU1RfUEFEX1BST0JFX09LOwotfQotCiAj aWYgIUxPR19ESVNBQkxFRAogc3RhdGljIEdzdFBhZFByb2JlUmV0dXJuIGFwcGVuZFBpcGVsaW5l UGFkUHJvYmVEZWJ1Z0luZm9ybWF0aW9uKEdzdFBhZCosIEdzdFBhZFByb2JlSW5mbyogaW5mbywg c3RydWN0IFBhZFByb2JlSW5mb3JtYXRpb24qIHBhZFByb2JlSW5mb3JtYXRpb24pCiB7CkBAIC0x MTMxLDExICsxMDk0LDYgQEAgc3RhdGljIEdzdFBhZFByb2JlUmV0dXJuIGFwcGVuZFBpcGVsaW5l RGVtdXhlckJsYWNrSG9sZVBhZFByb2JlKEdzdFBhZCosIEdzdFBhZFAKICAgICByZXR1cm4gR1NU X1BBRF9QUk9CRV9EUk9QOwogfQogCi1zdGF0aWMgdm9pZCBhcHBlbmRQaXBlbGluZUFwcHNyY05l ZWREYXRhKEdzdEFwcFNyYyosIGd1aW50LCBBcHBlbmRQaXBlbGluZSogYXBwZW5kUGlwZWxpbmUp Ci17Ci0gICAgYXBwZW5kUGlwZWxpbmUtPnJlcG9ydEFwcHNyY05lZWREYXRhUmVjZWl2ZWQoKTsK LX0KLQogc3RhdGljIHZvaWQgYXBwZW5kUGlwZWxpbmVEZW11eGVyUGFkQWRkZWQoR3N0RWxlbWVu dCosIEdzdFBhZCogZGVtdXhlclNyY1BhZCwgQXBwZW5kUGlwZWxpbmUqIGFwcGVuZFBpcGVsaW5l KQogewogICAgIGFwcGVuZFBpcGVsaW5lLT5jb25uZWN0RGVtdXhlclNyY1BhZFRvQXBwc2lua0Zy b21BbnlUaHJlYWQoZGVtdXhlclNyY1BhZCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmgK aW5kZXggMzY2MGNiNmMxNWFiNzU3OWVhYTEyODM3ZGNiZGZhNWQ5Njg3NzMxYi4uZGE0Zjc1ZWVj M2FjNjg2NzJlN2RjNTM0ODg3YWU4NDdmNzhhMjdmNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlw ZWxpbmUuaApAQCAtMjksNyArMjksOSBAQAogCiAjaW5jbHVkZSA8YXRvbWljPgogI2luY2x1ZGUg PGdzdC9nc3QuaD4KKyNpbmNsdWRlIDxtdXRleD4KICNpbmNsdWRlIDx3dGYvQ29uZGl0aW9uLmg+ CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAg LTY0LDYgKzY2LDcgQEAgcHVibGljOgogICAgIHZvaWQgYXBwc2lua0NhcHNDaGFuZ2VkKCk7CiAg ICAgdm9pZCBhcHBzaW5rTmV3U2FtcGxlKEdSZWZQdHI8R3N0U2FtcGxlPiYmKTsKICAgICB2b2lk IGFwcHNpbmtFT1MoKTsKKyAgICB2b2lkIGhhbmRsZUVuZE9mQXBwZW5kKCk7CiAgICAgdm9pZCBk aWRSZWNlaXZlSW5pdGlhbGl6YXRpb25TZWdtZW50KCk7CiAgICAgQXRvbWljU3RyaW5nIHRyYWNr SWQoKTsKICAgICB2b2lkIGFib3J0KCk7CkBAIC04NSwyMCArODgsMjUgQEAgcHVibGljOgogICAg IHZvaWQgY29ubmVjdERlbXV4ZXJTcmNQYWRUb0FwcHNpbmtGcm9tQW55VGhyZWFkKEdzdFBhZCop OwogICAgIHZvaWQgY29ubmVjdERlbXV4ZXJTcmNQYWRUb0FwcHNpbmsoR3N0UGFkKik7CiAKLSAg ICB2b2lkIHJlcG9ydEFwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCgpOwotICAgIHZvaWQgcmVwb3J0 QXBwc3JjTmVlZERhdGFSZWNlaXZlZCgpOwotCiBwcml2YXRlOgogICAgIHZvaWQgcmVzZXRQaXBl bGluZSgpOwogICAgIHZvaWQgY2hlY2tFbmRPZkFwcGVuZCgpOwotICAgIHZvaWQgaGFuZGxlQXBw c3JjQXRMZWFzdEFCdWZmZXJMZWZ0KCk7Ci0gICAgdm9pZCBoYW5kbGVBcHBzcmNOZWVkRGF0YVJl Y2VpdmVkKCk7Ci0gICAgdm9pZCByZW1vdmVBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCk7Ci0gICAg dm9pZCBzZXRBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCk7CiAgICAgdm9pZCBkZW11eGVyTm9Nb3Jl UGFkcygpOwogCiAgICAgdm9pZCBjb25zdW1lQXBwc2lua0F2YWlsYWJsZVNhbXBsZXMoKTsKIAor ICAgIEdzdFBhZFByb2JlUmV0dXJuIGFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tlclByb2JlKEdzdFBh ZFByb2JlSW5mbyopOworCisgICAgc3RhdGljIHZvaWQgc3RhdGljSW5pdGlhbGl6YXRpb24oKTsK KworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBzX3N0YXRpY0luaXRpYWxpemF0aW9uRmxhZzsK KyAgICBzdGF0aWMgR1R5cGUgc19lbmRPZkFwcGVuZE1ldGFUeXBlOworICAgIHN0YXRpYyBjb25z dCBHc3RNZXRhSW5mbyogc193ZWJLaXRFbmRPZkFwcGVuZE1ldGFJbmZvOworCisgICAgLy8gVXNl ZCBvbmx5IGZvciBhc3NlcnRpbmcgdGhhdCB0aGVyZSBpcyBvbmx5IG9uZSBzdHJlYW1pbmcgdGhy ZWFkLgorICAgIC8vIE9ubHkgdGhlIHBvaW50ZXJzIGFyZSBjb21wYXJlZC4KKyAgICBXVEY6OlRo cmVhZCogbV9zdHJlYW1pbmdUaHJlYWQ7CisKICAgICBSZWY8TWVkaWFTb3VyY2VDbGllbnRHU3Ry ZWFtZXJNU0U+IG1fbWVkaWFTb3VyY2VDbGllbnQ7CiAgICAgUmVmPFNvdXJjZUJ1ZmZlclByaXZh dGVHU3RyZWFtZXI+IG1fc291cmNlQnVmZmVyUHJpdmF0ZTsKICAgICBNZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJNU0UqIG1fcGxheWVyUHJpdmF0ZTsKQEAgLTEzMCwxMCArMTM4LDYgQEAgcHJp dmF0ZToKICAgICBHUmVmUHRyPEdzdENhcHM+IG1fZGVtdXhlclNyY1BhZENhcHM7CiAgICAgRmxv YXRTaXplIG1fcHJlc2VudGF0aW9uU2l6ZTsKIAotICAgIGJvb2wgbV9hcHBzcmNBdExlYXN0QUJ1 ZmZlckxlZnQ7Ci0gICAgYm9vbCBtX2FwcHNyY05lZWREYXRhUmVjZWl2ZWQ7Ci0KLSAgICBndWxv bmcgbV9hcHBzcmNEYXRhTGVhdmluZ1Byb2JlSWQ7CiAjaWYgIUxPR19ESVNBQkxFRAogICAgIHN0 cnVjdCBQYWRQcm9iZUluZm9ybWF0aW9uIG1fZGVtdXhlckRhdGFFbnRlcmluZ1BhZFByb2JlSW5m b3JtYXRpb247CiAgICAgc3RydWN0IFBhZFByb2JlSW5mb3JtYXRpb24gbV9hcHBzaW5rRGF0YUVu dGVyaW5nUGFkUHJvYmVJbmZvcm1hdGlvbjsK 350961 2018-09-27 08:26:21 -0700 2018-10-01 11:14:34 -0700 Patch bug-189924-20180927172619.patch text/plain 22523 aboya U3VidmVyc2lvbiBSZXZpc2lvbjogMjM2NTAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDQ1ZTk0NzVlZWJiYzA0 NDYzZDYyZjgzMTVhMmE3ZTdiM2NkNjQ1Ni4uOWE1NDYxMjk2MjA1ZDgyM2VmMDQ3MzJiNGM5OWYx N2JlNjRlNDFiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDE4LTA5LTI0ICBBbGlj aWEgQm95YSBHYXJjw61hICA8YWJveWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbTVNFXVtHU3Ry ZWFtZXJdIFVzZSBzZW50aW5lbCBidWZmZXIgdG8gZGV0ZWN0IGVuZCBvZiBhcHBlbmQKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4OTkyNAorCisgICAg ICAgIFJldmlld2VkIGJ5IFBoaWxpcHBlIE5vcm1hbmQuCisKKyAgICAgICAgVGhpcyBwYXRjaCBp bnRyb2R1Y2VzIGEgbmV3IG1lY2hhbmlzbSB0byBkZXRlY3Qgd2hlbiBhbiBhcHBlbmQgaGFzCisg ICAgICAgIGJlZW4gY29uc3VtZWQgY29tcGxldGVseSBieSB0aGUgZGVtdXhlci4gSXQgdGFrZXMg YWR2YW50YWdlIG9mIHRoZQorICAgICAgICBmYWN0IHRoYXQgYnVmZmVyIHB1c2hpbmcgaXMgc3lu Y2hyb25vdXM6IGJvdGggdGhlIGFwcHNyYyBhbmQgdGhlCisgICAgICAgIGRlbXV4ZXIgbGl2ZSBp biB0aGUgc2FtZSBzdHJlYW1pbmcgdGhyZWFkLiBXaGVuIGFwcHNyYyBwdXNoZXMgYQorICAgICAg ICBidWZmZXIsIGl0J3MgYWN0dWFsbHkgbWFraW5nIGEgcXRkZW11eCBmdW5jdGlvbiBjYWxsIChp dCBjYWxscyBpdHMKKyAgICAgICAgImNoYWluIiBmdW5jdGlvbikuIFRoZSBkZW11eGVyIHdpbGwg cmV0dXJuIGZyb20gdGhhdCBjYWxsIHdoZW4gaXQgaGFzCisgICAgICAgIGZpbmlzaGVkIHByb2Nl c3NpbmcgdGhhdCBidWZmZXI7IG9ubHkgdGhlbiB0aGUgY29udHJvbCByZXR1cm5zIHRvCisgICAg ICAgIGFwcHNyYywgdGhhdCBjYW4gcHVzaCB0aGUgbmV4dCBidWZmZXIuCisKKyAgICAgICAgQnkg cHVzaGluZyBhbiBhZGRpdGlvbmFsIGJ1ZmZlciBhbmQgY2FwdHVyaW5nIGl0IGluIGEgcHJvYmUg d2UgY2FuCisgICAgICAgIGRldGVjdCByZWxpYWJseSB3aGVuIHRoZSBwcmV2aW91cyBidWZmZXIg aGFzIGJlZW4gcHJvY2Vzc2VkLgorICAgICAgICBCZWNhdXNlIHRoZSBwaXBlbGluZSBvbmx5IGhh cyBvbmUgdGhyZWFkLCBhdCB0aGlzIHBvaW50IG5vIG1vcmUgZnJhbWVzCisgICAgICAgIGNhbiBh cnJpdmUgdG8gdGhlIGFwcHNpbmsuCisKKyAgICAgICAgVGhpcyByZXBsYWNlcyB0aGUgb2xkIG1l dGhvZCBvZiBkZXRlY3RpbmcgZW5kIG9mIGFwcGVuZCB3aGljaCByZWxpZWQKKyAgICAgICAgb24g dGhlIGBuZWVkLWRhdGFgIGV2ZW50LCB3aGljaCBpcyBtb3JlIGRpZmZpY3VsdCB0byBoYW5kbGUg Y29ycmVjdGx5CisgICAgICAgIGJlY2F1c2UgaXQgZmlyZXMgd2hlbmV2ZXIgdGhlIGFwcHNyYyBp cyBlbXB0eSAob3IgYmVsb3cgYSBnaXZlbgorICAgICAgICBsZXZlbCksIHdoaWNoIGFsc28gaGFw cGVucyB3aGVuIGEgYnVmZmVyIGhhcyBub3QgYmVlbiBwdXNoZWQgeWV0IG9yCisgICAgICAgIGlu IHJlc3BvbnNlIHRvIGEgZmx1c2guCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3Ry ZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVuZE9mQXBw ZW5kTWV0YTo6aW5pdCk6CisgICAgICAgIChXZWJDb3JlOjpFbmRPZkFwcGVuZE1ldGE6OnRyYW5z Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpFbmRPZkFwcGVuZE1ldGE6OmZyZWUpOgorICAgICAg ICAoV2ViQ29yZTo6QXBwZW5kUGlwZWxpbmU6OnN0YXRpY0luaXRpYWxpemF0aW9uKToKKyAgICAg ICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpBcHBlbmRQaXBlbGluZSk6CisgICAgICAgIChX ZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6fkFwcGVuZFBpcGVsaW5lKToKKyAgICAgICAgKFdlYkNv cmU6OkFwcGVuZFBpcGVsaW5lOjphcHBzcmNFbmRPZkFwcGVuZENoZWNrZXJQcm9iZSk6CisgICAg ICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwbGljYXRpb25NZXNzYWdlKToK KyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpoYW5kbGVFbmRPZkFwcGVuZCk6Cisg ICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6Y29uc3VtZUFwcHNpbmtBdmFpbGFibGVT YW1wbGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZXNldFBpcGVsaW5l KToKKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpwdXNoTmV3QnVmZmVyKToKKyAg ICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpoYW5kbGVBcHBzcmNOZWVkRGF0YVJlY2Vp dmVkKTogRGVsZXRlZC46CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmRQaXBlbGluZTo6aGFuZGxl QXBwc3JjQXRMZWFzdEFCdWZmZXJMZWZ0KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkFw cGVuZFBpcGVsaW5lOjpjaGVja0VuZE9mQXBwZW5kKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNv cmU6OkFwcGVuZFBpcGVsaW5lOjpzZXRBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKTogRGVsZXRlZC4K KyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZW1vdmVBcHBzcmNEYXRhTGVhdmlu Z1Byb2JlKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZFBpcGVsaW5lOjpyZXBv cnRBcHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6 QXBwZW5kUGlwZWxpbmU6OnJlcG9ydEFwcHNyY05lZWREYXRhUmVjZWl2ZWQpOiBEZWxldGVkLgor ICAgICAgICAoV2ViQ29yZTo6YXBwZW5kUGlwZWxpbmVBcHBzcmNEYXRhTGVhdmluZyk6IERlbGV0 ZWQuCisgICAgICAgIChXZWJDb3JlOjphcHBlbmRQaXBlbGluZUFwcHNyY05lZWREYXRhKTogRGVs ZXRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBp cGVsaW5lLmg6CisKIDIwMTgtMDktMjUgIEVyaWMgQ2FybHNvbiAgPGVyaWMuY2FybHNvbkBhcHBs ZS5jb20+CiAKICAgICAgICAgW01lZGlhU3RyZWFtXSBBZGQgTWFjIHdpbmRvdyBjYXB0dXJlIHNv dXJjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcAppbmRleCA4ODdlM2Q1YjIxZDE3 NjMwMzEyMzliNDU1YzVkZDQ1MzZhODdjODk3Li5lZmVmN2MzYmIyMDUyZmY4NDc2ZDUwMzMxNWM0 NmRmYmQ4ZTU3M2JlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmNwcApAQCAtNDYs NiArNDYsMjYgQEAgR1NUX0RFQlVHX0NBVEVHT1JZX0VYVEVSTih3ZWJraXRfbXNlX2RlYnVnKTsK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitHVHlwZSBBcHBlbmRQaXBlbGluZTo6c19lbmRPZkFw cGVuZE1ldGFUeXBlID0gMDsKK2NvbnN0IEdzdE1ldGFJbmZvKiBBcHBlbmRQaXBlbGluZTo6c193 ZWJLaXRFbmRPZkFwcGVuZE1ldGFJbmZvID0gbnVsbHB0cjsKK3N0ZDo6b25jZV9mbGFnIEFwcGVu ZFBpcGVsaW5lOjpzX3N0YXRpY0luaXRpYWxpemF0aW9uRmxhZzsKKworc3RydWN0IEVuZE9mQXBw ZW5kTWV0YSB7CisgICAgR3N0TWV0YSBiYXNlOworICAgIHN0YXRpYyBnYm9vbGVhbiBpbml0KEdz dE1ldGEqLCB2b2lkKiwgR3N0QnVmZmVyKikgeyByZXR1cm4gVFJVRTsgfQorICAgIHN0YXRpYyBn Ym9vbGVhbiB0cmFuc2Zvcm0oR3N0QnVmZmVyKiwgR3N0TWV0YSosIEdzdEJ1ZmZlciosIEdRdWFy aywgdm9pZCopIHsgZ19yZXR1cm5fdmFsX2lmX3JlYWNoZWQoRkFMU0UpOyB9CisgICAgc3RhdGlj IHZvaWQgZnJlZShHc3RNZXRhKiwgR3N0QnVmZmVyKikgeyB9Cit9OworCit2b2lkIEFwcGVuZFBp cGVsaW5lOjpzdGF0aWNJbml0aWFsaXphdGlvbigpCit7CisgICAgQVNTRVJUKFdURjo6aXNNYWlu VGhyZWFkKCkpOworCisgICAgY29uc3QgY2hhciogdGFnc1tdID0geyBudWxscHRyIH07CisgICAg c19lbmRPZkFwcGVuZE1ldGFUeXBlID0gZ3N0X21ldGFfYXBpX3R5cGVfcmVnaXN0ZXIoIldlYktp dEVuZE9mQXBwZW5kTWV0YUFQSSIsIHRhZ3MpOworICAgIHNfd2ViS2l0RW5kT2ZBcHBlbmRNZXRh SW5mbyA9IGdzdF9tZXRhX3JlZ2lzdGVyKHNfZW5kT2ZBcHBlbmRNZXRhVHlwZSwgIldlYktpdEVu ZE9mQXBwZW5kTWV0YSIsIHNpemVvZihFbmRPZkFwcGVuZE1ldGEpLCBFbmRPZkFwcGVuZE1ldGE6 OmluaXQsIEVuZE9mQXBwZW5kTWV0YTo6ZnJlZSwgRW5kT2ZBcHBlbmRNZXRhOjp0cmFuc2Zvcm0p OworfQorCiBzdGF0aWMgY29uc3QgY2hhciogZHVtcEFwcGVuZFN0YXRlKEFwcGVuZFBpcGVsaW5l OjpBcHBlbmRTdGF0ZSBhcHBlbmRTdGF0ZSkKIHsKICAgICBzd2l0Y2ggKGFwcGVuZFN0YXRlKSB7 CkBAIC02OCwxMSArODgsOSBAQCBzdGF0aWMgY29uc3QgY2hhciogZHVtcEFwcGVuZFN0YXRlKEFw cGVuZFBpcGVsaW5lOjpBcHBlbmRTdGF0ZSBhcHBlbmRTdGF0ZSkKICAgICB9CiB9CiAKLXN0YXRp YyB2b2lkIGFwcGVuZFBpcGVsaW5lQXBwc3JjTmVlZERhdGEoR3N0QXBwU3JjKiwgZ3VpbnQsIEFw cGVuZFBpcGVsaW5lKik7CiBzdGF0aWMgdm9pZCBhcHBlbmRQaXBlbGluZURlbXV4ZXJQYWRBZGRl ZChHc3RFbGVtZW50KiwgR3N0UGFkKiwgQXBwZW5kUGlwZWxpbmUqKTsKIHN0YXRpYyB2b2lkIGFw cGVuZFBpcGVsaW5lRGVtdXhlclBhZFJlbW92ZWQoR3N0RWxlbWVudCosIEdzdFBhZCosIEFwcGVu ZFBpcGVsaW5lKik7CiBzdGF0aWMgdm9pZCBhcHBlbmRQaXBlbGluZUFwcHNpbmtDYXBzQ2hhbmdl ZChHT2JqZWN0KiwgR1BhcmFtU3BlYyosIEFwcGVuZFBpcGVsaW5lKik7Ci1zdGF0aWMgR3N0UGFk UHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVBcHBzcmNEYXRhTGVhdmluZyhHc3RQYWQqLCBHc3RQ YWRQcm9iZUluZm8qLCBBcHBlbmRQaXBlbGluZSopOwogI2lmICFMT0dfRElTQUJMRUQKIHN0YXRp YyBHc3RQYWRQcm9iZVJldHVybiBhcHBlbmRQaXBlbGluZVBhZFByb2JlRGVidWdJbmZvcm1hdGlv bihHc3RQYWQqLCBHc3RQYWRQcm9iZUluZm8qLCBzdHJ1Y3QgUGFkUHJvYmVJbmZvcm1hdGlvbiop OwogI2VuZGlmCkBAIC0xMTAsMTQgKzEyOCwxMiBAQCBBcHBlbmRQaXBlbGluZTo6QXBwZW5kUGlw ZWxpbmUoUmVmPE1lZGlhU291cmNlQ2xpZW50R1N0cmVhbWVyTVNFPiBtZWRpYVNvdXJjZUNsaQog ICAgICwgbV9wbGF5ZXJQcml2YXRlKCZwbGF5ZXJQcml2YXRlKQogICAgICwgbV9pZCgwKQogICAg ICwgbV93YXNCdXNBbHJlYWR5Tm90aWZpZWRPZkF2YWlsYWJsZVNhbXBsZXMoZmFsc2UpCi0gICAg LCBtX2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdChmYWxzZSkKLSAgICAsIG1fYXBwc3JjTmVlZERh dGFSZWNlaXZlZChmYWxzZSkKLSAgICAsIG1fYXBwc3JjRGF0YUxlYXZpbmdQcm9iZUlkKDApCiAg ICAgLCBtX2FwcGVuZFN0YXRlKEFwcGVuZFN0YXRlOjpOb3RTdGFydGVkKQogICAgICwgbV9hYm9y dFBlbmRpbmcoZmFsc2UpCiAgICAgLCBtX3N0cmVhbVR5cGUoVW5rbm93bikKIHsKICAgICBBU1NF UlQoV1RGOjppc01haW5UaHJlYWQoKSk7CisgICAgc3RkOjpjYWxsX29uY2Uoc19zdGF0aWNJbml0 aWFsaXphdGlvbkZsYWcsIEFwcGVuZFBpcGVsaW5lOjpzdGF0aWNJbml0aWFsaXphdGlvbik7CiAK ICAgICBHU1RfVFJBQ0UoIkNyZWF0aW5nIEFwcGVuZFBpcGVsaW5lICglcCkiLCB0aGlzKTsKIApA QCAtMTM3LDYgKzE1MywxMSBAQCBBcHBlbmRQaXBlbGluZTo6QXBwZW5kUGlwZWxpbmUoUmVmPE1l ZGlhU291cmNlQ2xpZW50R1N0cmVhbWVyTVNFPiBtZWRpYVNvdXJjZUNsaQogICAgIC8vIGJlbG93 IHdpbGwgYWxyZWFkeSB0YWtlIHRoZSBpbml0aWFsIHJlZmVyZW5jZSBhbmQgd2UgbmVlZCBhbiBh ZGRpdGlvbmFsIG9uZSBmb3IgdXMuCiAgICAgbV9hcHBzcmMgPSBnc3RfZWxlbWVudF9mYWN0b3J5 X21ha2UoImFwcHNyYyIsIG51bGxwdHIpOwogCisgICAgR1JlZlB0cjxHc3RQYWQ+IGFwcHNyY1Bh ZCA9IGFkb3B0R1JlZihnc3RfZWxlbWVudF9nZXRfc3RhdGljX3BhZChtX2FwcHNyYy5nZXQoKSwg InNyYyIpKTsKKyAgICBnc3RfcGFkX2FkZF9wcm9iZShhcHBzcmNQYWQuZ2V0KCksIEdTVF9QQURf UFJPQkVfVFlQRV9CVUZGRVIsIFtdKEdzdFBhZCosIEdzdFBhZFByb2JlSW5mbyogcGFkUHJvYmVJ bmZvLCB2b2lkKiB1c2VyRGF0YSkgeworICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QXBwZW5k UGlwZWxpbmUqPih1c2VyRGF0YSktPmFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tlclByb2JlKHBhZFBy b2JlSW5mbyk7CisgICAgfSwgdGhpcywgbnVsbHB0cik7CisKICAgICBjb25zdCBTdHJpbmcmIHR5 cGUgPSBtX3NvdXJjZUJ1ZmZlclByaXZhdGUtPnR5cGUoKS5jb250YWluZXJUeXBlKCk7CiAgICAg aWYgKHR5cGUuZW5kc1dpdGgoIm1wNCIpKQogICAgICAgICBtX2RlbXV4ID0gZ3N0X2VsZW1lbnRf ZmFjdG9yeV9tYWtlKCJxdGRlbXV4IiwgbnVsbHB0cik7CkBAIC0xNTQsOCArMTc1LDYgQEAgQXBw ZW5kUGlwZWxpbmU6OkFwcGVuZFBpcGVsaW5lKFJlZjxNZWRpYVNvdXJjZUNsaWVudEdTdHJlYW1l ck1TRT4gbWVkaWFTb3VyY2VDbGkKICAgICBHUmVmUHRyPEdzdFBhZD4gYXBwc2lua1BhZCA9IGFk b3B0R1JlZihnc3RfZWxlbWVudF9nZXRfc3RhdGljX3BhZChtX2FwcHNpbmsuZ2V0KCksICJzaW5r IikpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QoYXBwc2lua1BhZC5nZXQoKSwgIm5vdGlmeTo6Y2Fw cyIsIEdfQ0FMTEJBQ0soYXBwZW5kUGlwZWxpbmVBcHBzaW5rQ2Fwc0NoYW5nZWQpLCB0aGlzKTsK IAotICAgIHNldEFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKTsKLQogI2lmICFMT0dfRElTQUJMRUQK ICAgICBHUmVmUHRyPEdzdFBhZD4gZGVtdXhlclBhZCA9IGFkb3B0R1JlZihnc3RfZWxlbWVudF9n ZXRfc3RhdGljX3BhZChtX2RlbXV4LmdldCgpLCAic2luayIpKTsKICAgICBtX2RlbXV4ZXJEYXRh RW50ZXJpbmdQYWRQcm9iZUluZm9ybWF0aW9uLmFwcGVuZFBpcGVsaW5lID0gdGhpczsKQEAgLTE3 Myw3ICsxOTIsNiBAQCBBcHBlbmRQaXBlbGluZTo6QXBwZW5kUGlwZWxpbmUoUmVmPE1lZGlhU291 cmNlQ2xpZW50R1N0cmVhbWVyTVNFPiBtZWRpYVNvdXJjZUNsaQogI2VuZGlmCiAKICAgICAvLyBU aGVzZSBzaWduYWxzIHdvbid0IGJlIGNvbm5lY3RlZCBvdXRzaWRlIG9mIHRoZSBsaWZldGltZSBv ZiAidGhpcyIuCi0gICAgZ19zaWduYWxfY29ubmVjdChtX2FwcHNyYy5nZXQoKSwgIm5lZWQtZGF0 YSIsIEdfQ0FMTEJBQ0soYXBwZW5kUGlwZWxpbmVBcHBzcmNOZWVkRGF0YSksIHRoaXMpOwogICAg IGdfc2lnbmFsX2Nvbm5lY3QobV9kZW11eC5nZXQoKSwgInBhZC1hZGRlZCIsIEdfQ0FMTEJBQ0so YXBwZW5kUGlwZWxpbmVEZW11eGVyUGFkQWRkZWQpLCB0aGlzKTsKICAgICBnX3NpZ25hbF9jb25u ZWN0KG1fZGVtdXguZ2V0KCksICJwYWQtcmVtb3ZlZCIsIEdfQ0FMTEJBQ0soYXBwZW5kUGlwZWxp bmVEZW11eGVyUGFkUmVtb3ZlZCksIHRoaXMpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9kZW11 eC5nZXQoKSwgIm5vLW1vcmUtcGFkcyIsIEdfQ0FMTEJBQ0soYXBwZW5kUGlwZWxpbmVEZW11eGVy Tm9Nb3JlUGFkcyksIHRoaXMpOwpAQCAtMjEzLDcgKzIzMSw2IEBAIEFwcGVuZFBpcGVsaW5lOjp+ QXBwZW5kUGlwZWxpbmUoKQogICAgIH0KIAogICAgIGlmIChtX2FwcHNyYykgewotICAgICAgICBy ZW1vdmVBcHBzcmNEYXRhTGVhdmluZ1Byb2JlKCk7CiAgICAgICAgIGdfc2lnbmFsX2hhbmRsZXJz X2Rpc2Nvbm5lY3RfYnlfZGF0YShtX2FwcHNyYy5nZXQoKSwgdGhpcyk7CiAgICAgICAgIG1fYXBw c3JjID0gbnVsbHB0cjsKICAgICB9CkBAIC0yNDcsNiArMjY0LDI3IEBAIEFwcGVuZFBpcGVsaW5l Ojp+QXBwZW5kUGlwZWxpbmUoKQogICAgIG1fZGVtdXhlclNyY1BhZENhcHMgPSBudWxscHRyOwog fTsKIAorR3N0UGFkUHJvYmVSZXR1cm4gQXBwZW5kUGlwZWxpbmU6OmFwcHNyY0VuZE9mQXBwZW5k Q2hlY2tlclByb2JlKEdzdFBhZFByb2JlSW5mbyogcGFkUHJvYmVJbmZvKQoreworICAgIEFTU0VS VCghV1RGOjppc01haW5UaHJlYWQoKSk7CisgICAgbV9zdHJlYW1pbmdUaHJlYWQgPSAmV1RGOjpU aHJlYWQ6OmN1cnJlbnQoKTsKKworICAgIEdzdEJ1ZmZlciogYnVmZmVyID0gR1NUX0JVRkZFUihw YWRQcm9iZUluZm8tPmRhdGEpOworICAgIEFTU0VSVChHU1RfSVNfQlVGRkVSKGJ1ZmZlcikpOwor CisgICAgRW5kT2ZBcHBlbmRNZXRhKiBlbmRPZkFwcGVuZE1ldGEgPSByZWludGVycHJldF9jYXN0 PEVuZE9mQXBwZW5kTWV0YSo+KGdzdF9idWZmZXJfZ2V0X21ldGEoYnVmZmVyLCBzX2VuZE9mQXBw ZW5kTWV0YVR5cGUpKTsKKyAgICBpZiAoIWVuZE9mQXBwZW5kTWV0YSkgeworICAgICAgICAvLyBO b3JtYWwgYnVmZmVyLCBub3RoaW5nIHRvIGRvLgorICAgICAgICByZXR1cm4gR1NUX1BBRF9QUk9C RV9PSzsKKyAgICB9CisKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHRoaXMsICJwb3N0aW5nIGVuZC1v Zi1hcHBlbmQgcmVxdWVzdCB0byBidXMiKTsKKyAgICBHc3RTdHJ1Y3R1cmUqIHN0cnVjdHVyZSA9 IGdzdF9zdHJ1Y3R1cmVfbmV3X2VtcHR5KCJlbmQtb2YtYXBwZW5kIik7CisgICAgR3N0TWVzc2Fn ZSogbWVzc2FnZSA9IGdzdF9tZXNzYWdlX25ld19hcHBsaWNhdGlvbihHU1RfT0JKRUNUKG1fYXBw c3JjLmdldCgpKSwgc3RydWN0dXJlKTsKKyAgICBnc3RfYnVzX3Bvc3QobV9idXMuZ2V0KCksIG1l c3NhZ2UpOworICAgIHJldHVybiBHU1RfUEFEX1BST0JFX0RST1A7Cit9CisKIHZvaWQgQXBwZW5k UGlwZWxpbmU6OmNsZWFyUGxheWVyUHJpdmF0ZSgpCiB7CiAgICAgQVNTRVJUKFdURjo6aXNNYWlu VGhyZWFkKCkpOwpAQCAtMjg1LDE2ICszMjMsNiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjpoYW5k bGVBcHBsaWNhdGlvbk1lc3NhZ2UoR3N0TWVzc2FnZSogbWVzc2FnZSkKIAogICAgIGNvbnN0IEdz dFN0cnVjdHVyZSogc3RydWN0dXJlID0gZ3N0X21lc3NhZ2VfZ2V0X3N0cnVjdHVyZShtZXNzYWdl KTsKIAotICAgIGlmIChnc3Rfc3RydWN0dXJlX2hhc19uYW1lKHN0cnVjdHVyZSwgImFwcHNyYy1u ZWVkLWRhdGEiKSkgewotICAgICAgICBoYW5kbGVBcHBzcmNOZWVkRGF0YVJlY2VpdmVkKCk7Ci0g ICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBpZiAoZ3N0X3N0cnVjdHVyZV9oYXNfbmFtZShz dHJ1Y3R1cmUsICJhcHBzcmMtYnVmZmVyLWxlZnQiKSkgewotICAgICAgICBoYW5kbGVBcHBzcmNB dExlYXN0QUJ1ZmZlckxlZnQoKTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQogICAgIGlmIChn c3Rfc3RydWN0dXJlX2hhc19uYW1lKHN0cnVjdHVyZSwgImRlbXV4ZXItY29ubmVjdC10by1hcHBz aW5rIikpIHsKICAgICAgICAgR1JlZlB0cjxHc3RQYWQ+IGRlbXV4ZXJTcmNQYWQ7CiAgICAgICAg IGdzdF9zdHJ1Y3R1cmVfZ2V0KHN0cnVjdHVyZSwgImRlbXV4ZXItc3JjLXBhZCIsIEdfVFlQRV9P QkpFQ1QsICZkZW11eGVyU3JjUGFkLm91dFB0cigpLCBudWxscHRyKTsKQEAgLTMyNCw2ICszNTIs MTEgQEAgdm9pZCBBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwbGljYXRpb25NZXNzYWdlKEdzdE1l c3NhZ2UqIG1lc3NhZ2UpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKKyAgICBpZiAoZ3N0X3N0 cnVjdHVyZV9oYXNfbmFtZShzdHJ1Y3R1cmUsICJlbmQtb2YtYXBwZW5kIikpIHsKKyAgICAgICAg aGFuZGxlRW5kT2ZBcHBlbmQoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIEFTU0VS VF9OT1RfUkVBQ0hFRCgpOwogfQogCkBAIC0zNTMsMzEgKzM4Niw2IEBAIHZvaWQgQXBwZW5kUGlw ZWxpbmU6OmhhbmRsZVN0YXRlQ2hhbmdlTWVzc2FnZShHc3RNZXNzYWdlKiBtZXNzYWdlKQogICAg IH0KIH0KIAotdm9pZCBBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwc3JjTmVlZERhdGFSZWNlaXZl ZCgpCi17Ci0gICAgaWYgKCFtX2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCkgewotICAgICAgICBH U1RfVFJBQ0UoImRpc2NhcmRpbmcgdW50aWwgYXQgbGVhc3QgYSBidWZmZXIgbGVhdmVzIGFwcHNy YyIpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgQVNTRVJUKG1fYXBwZW5kU3RhdGUg PT0gQXBwZW5kU3RhdGU6Ok9uZ29pbmcgfHwgbV9hcHBlbmRTdGF0ZSA9PSBBcHBlbmRTdGF0ZTo6 U2FtcGxpbmcpOwotICAgIEFTU0VSVCghbV9hcHBzcmNOZWVkRGF0YVJlY2VpdmVkKTsKLQotICAg IEdTVF9UUkFDRSgicmVjZWl2ZWQgbmVlZC1kYXRhIGZyb20gYXBwc3JjIik7Ci0KLSAgICBtX2Fw cHNyY05lZWREYXRhUmVjZWl2ZWQgPSB0cnVlOwotICAgIGNoZWNrRW5kT2ZBcHBlbmQoKTsKLX0K LQotdm9pZCBBcHBlbmRQaXBlbGluZTo6aGFuZGxlQXBwc3JjQXRMZWFzdEFCdWZmZXJMZWZ0KCkK LXsKLSAgICBtX2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCA9IHRydWU7Ci0gICAgR1NUX1RSQUNF KCJyZWNlaXZlZCBidWZmZXItbGVmdCBmcm9tIGFwcHNyYyIpOwotI2lmIExPR19ESVNBQkxFRAot ICAgIHJlbW92ZUFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKTsKLSNlbmRpZgotfQotCiBnaW50IEFw cGVuZFBpcGVsaW5lOjppZCgpCiB7CiAgICAgQVNTRVJUKFdURjo6aXNNYWluVGhyZWFkKCkpOwpA QCAtNDM4LDcgKzQ0Niw3IEBAIHZvaWQgQXBwZW5kUGlwZWxpbmU6OnNldEFwcGVuZFN0YXRlKEFw cGVuZFN0YXRlIG5ld0FwcGVuZFN0YXRlKQogICAgICAgICBjYXNlIEFwcGVuZFN0YXRlOjpOb3RT dGFydGVkOgogICAgICAgICAgICAgb2sgPSB0cnVlOwogICAgICAgICAgICAgaWYgKG1fcGVuZGlu Z0J1ZmZlcikgewotICAgICAgICAgICAgICAgIEdTVF9UUkFDRSgicHVzaGluZyBwZW5kaW5nIGJ1 ZmZlciAlcCIsIG1fcGVuZGluZ0J1ZmZlci5nZXQoKSk7CisgICAgICAgICAgICAgICAgR1NUX1RS QUNFKCJwdXNoaW5nIHBlbmRpbmcgYnVmZmVyICUiIEdTVF9QVFJfRk9STUFULCBtX3BlbmRpbmdC dWZmZXIuZ2V0KCkpOwogICAgICAgICAgICAgICAgIGdzdF9hcHBfc3JjX3B1c2hfYnVmZmVyKEdT VF9BUFBfU1JDKGFwcHNyYygpKSwgbV9wZW5kaW5nQnVmZmVyLmxlYWtSZWYoKSk7CiAgICAgICAg ICAgICAgICAgbmV4dEFwcGVuZFN0YXRlID0gQXBwZW5kU3RhdGU6Ok9uZ29pbmc7CiAgICAgICAg ICAgICB9CkBAIC02MDMsMjQgKzYxMSwxOSBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjphcHBzaW5r Q2Fwc0NoYW5nZWQoKQogICAgIH0KIH0KIAotdm9pZCBBcHBlbmRQaXBlbGluZTo6Y2hlY2tFbmRP ZkFwcGVuZCgpCit2b2lkIEFwcGVuZFBpcGVsaW5lOjpoYW5kbGVFbmRPZkFwcGVuZCgpCiB7CiAg ICAgQVNTRVJUKFdURjo6aXNNYWluVGhyZWFkKCkpOworICAgIEdTVF9UUkFDRV9PQkpFQ1QodGhp cywgInJlY2VpdmVkIGVuZC1vZi1hcHBlbmQiKTsKIAotICAgIGlmICghbV9hcHBzcmNOZWVkRGF0 YVJlY2VpdmVkIHx8IChtX2FwcGVuZFN0YXRlICE9IEFwcGVuZFN0YXRlOjpPbmdvaW5nICYmIG1f YXBwZW5kU3RhdGUgIT0gQXBwZW5kU3RhdGU6OlNhbXBsaW5nKSkKLSAgICAgICAgcmV0dXJuOwot Ci0gICAgR1NUX1RSQUNFKCJlbmQgb2YgYXBwZW5kIGRhdGEgbWFyayB3YXMgcmVjZWl2ZWQiKTsK LQorICAgIC8vIFJlZ2FyZGxlc3Mgb2YgdGhlIHN0YXRlIHRyYW5zaXRpb24sIHRoZSByZXN1bHQg aXMgdGhlIHNhbWU6IGRpZFJlY2VpdmVBbGxQZW5kaW5nU2FtcGxlcygpIGlzIGNhbGxlZC4KICAg ICBzd2l0Y2ggKG1fYXBwZW5kU3RhdGUpIHsKICAgICBjYXNlIEFwcGVuZFN0YXRlOjpPbmdvaW5n OgogICAgICAgICBHU1RfVFJBQ0UoIkRhdGFTdGFydmUiKTsKLSAgICAgICAgbV9hcHBzcmNOZWVk RGF0YVJlY2VpdmVkID0gZmFsc2U7CiAgICAgICAgIHNldEFwcGVuZFN0YXRlKEFwcGVuZFN0YXRl OjpEYXRhU3RhcnZlKTsKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBBcHBlbmRTdGF0ZTo6U2Ft cGxpbmc6CiAgICAgICAgIEdTVF9UUkFDRSgiTGFzdFNhbXBsZSIpOwotICAgICAgICBtX2FwcHNy Y05lZWREYXRhUmVjZWl2ZWQgPSBmYWxzZTsKICAgICAgICAgc2V0QXBwZW5kU3RhdGUoQXBwZW5k U3RhdGU6Okxhc3RTYW1wbGUpOwogICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgpAQCAtNjMz LDE0ICs2MzYsNiBAQCB2b2lkIEFwcGVuZFBpcGVsaW5lOjphcHBzaW5rTmV3U2FtcGxlKEdSZWZQ dHI8R3N0U2FtcGxlPiYmIHNhbXBsZSkKIHsKICAgICBBU1NFUlQoV1RGOjppc01haW5UaHJlYWQo KSk7CiAKLSAgICAvLyBJZ25vcmUgc2FtcGxlcyBpZiB3ZSdyZSBub3QgZXhwZWN0aW5nIHRoZW0u IFJlZnVzZSBwcm9jZXNzaW5nIGlmIHdlJ3JlIGluIEludmFsaWQgc3RhdGUuCi0gICAgaWYgKG1f YXBwZW5kU3RhdGUgIT0gQXBwZW5kU3RhdGU6Ok9uZ29pbmcgJiYgbV9hcHBlbmRTdGF0ZSAhPSBB cHBlbmRTdGF0ZTo6U2FtcGxpbmcpIHsKLSAgICAgICAgR1NUX1dBUk5JTkcoIlVuZXhwZWN0ZWQg c2FtcGxlLCBhcHBlbmRTdGF0ZT0lcyIsIGR1bXBBcHBlbmRTdGF0ZShtX2FwcGVuZFN0YXRlKSk7 Ci0gICAgICAgIC8vIEZJWE1FOiBSZXR1cm4gRVJST1IgYW5kIGZpbmQgYSBtb3JlIHJvYnVzdCB3 YXkgdG8gZGV0ZWN0IHRoYXQgYWxsIHRoZQotICAgICAgICAvLyBkYXRhIGhhcyBiZWVuIHByb2Nl c3NlZCwgc28gd2UgZG9uJ3QgbmVlZCB0byByZXNvcnQgdG8gdGhlc2UgaGFja3MuCi0gICAgICAg IHJldHVybjsKLSAgICB9Ci0KICAgICBpZiAoVU5MSUtFTFkoIWdzdF9zYW1wbGVfZ2V0X2J1ZmZl cihzYW1wbGUuZ2V0KCkpKSkgewogICAgICAgICBHU1RfV0FSTklORygiUmVjZWl2ZWQgc2FtcGxl IHdpdGhvdXQgYnVmZmVyIGZyb20gYXBwc2luay4iKTsKICAgICAgICAgcmV0dXJuOwpAQCAtNzQ4 LDE3ICs3NDMsMTIgQEAgdm9pZCBBcHBlbmRQaXBlbGluZTo6Y29uc3VtZUFwcHNpbmtBdmFpbGFi bGVTYW1wbGVzKCkKICAgICB9CiAKICAgICBHU1RfVFJBQ0VfT0JKRUNUKHRoaXMsICJiYXRjaGVk U2FtcGxlQ291bnQgPSAlZCIsIGJhdGNoZWRTYW1wbGVDb3VudCk7Ci0KLSAgICBpZiAoYmF0Y2hl ZFNhbXBsZUNvdW50ID4gMCkKLSAgICAgICAgY2hlY2tFbmRPZkFwcGVuZCgpOwogfQogCiB2b2lk IEFwcGVuZFBpcGVsaW5lOjpyZXNldFBpcGVsaW5lKCkKIHsKICAgICBBU1NFUlQoV1RGOjppc01h aW5UaHJlYWQoKSk7CiAgICAgR1NUX0RFQlVHKCJyZXNldHRpbmcgcGlwZWxpbmUiKTsKLSAgICBt X2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCA9IGZhbHNlOwotICAgIHNldEFwcHNyY0RhdGFMZWF2 aW5nUHJvYmUoKTsKIAogICAgIGdzdF9lbGVtZW50X3NldF9zdGF0ZShtX3BpcGVsaW5lLmdldCgp LCBHU1RfU1RBVEVfUkVBRFkpOwogICAgIGdzdF9lbGVtZW50X2dldF9zdGF0ZShtX3BpcGVsaW5l LmdldCgpLCBudWxscHRyLCBudWxscHRyLCAwKTsKQEAgLTc3NCwyOSArNzY0LDYgQEAgdm9pZCBB cHBlbmRQaXBlbGluZTo6cmVzZXRQaXBlbGluZSgpCiAKIH0KIAotdm9pZCBBcHBlbmRQaXBlbGlu ZTo6c2V0QXBwc3JjRGF0YUxlYXZpbmdQcm9iZSgpCi17Ci0gICAgaWYgKG1fYXBwc3JjRGF0YUxl YXZpbmdQcm9iZUlkKQotICAgICAgICByZXR1cm47Ci0KLSAgICBHU1RfVFJBQ0UoInNldHRpbmcg YXBwc3JjIGRhdGEgbGVhdmluZyBwcm9iZSIpOwotCi0gICAgR1JlZlB0cjxHc3RQYWQ+IGFwcHNy Y1BhZCA9IGFkb3B0R1JlZihnc3RfZWxlbWVudF9nZXRfc3RhdGljX3BhZChtX2FwcHNyYy5nZXQo KSwgInNyYyIpKTsKLSAgICBtX2FwcHNyY0RhdGFMZWF2aW5nUHJvYmVJZCA9IGdzdF9wYWRfYWRk X3Byb2JlKGFwcHNyY1BhZC5nZXQoKSwgR1NUX1BBRF9QUk9CRV9UWVBFX0JVRkZFUiwgcmVpbnRl cnByZXRfY2FzdDxHc3RQYWRQcm9iZUNhbGxiYWNrPihhcHBlbmRQaXBlbGluZUFwcHNyY0RhdGFM ZWF2aW5nKSwgdGhpcywgbnVsbHB0cik7Ci19Ci0KLXZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlbW92 ZUFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKQotewotICAgIGlmICghbV9hcHBzcmNEYXRhTGVhdmlu Z1Byb2JlSWQpCi0gICAgICAgIHJldHVybjsKLQotICAgIEdTVF9UUkFDRSgicmVtb3ZpbmcgYXBw c3JjIGRhdGEgbGVhdmluZyBwcm9iZSIpOwotCi0gICAgR1JlZlB0cjxHc3RQYWQ+IGFwcHNyY1Bh ZCA9IGFkb3B0R1JlZihnc3RfZWxlbWVudF9nZXRfc3RhdGljX3BhZChtX2FwcHNyYy5nZXQoKSwg InNyYyIpKTsKLSAgICBnc3RfcGFkX3JlbW92ZV9wcm9iZShhcHBzcmNQYWQuZ2V0KCksIG1fYXBw c3JjRGF0YUxlYXZpbmdQcm9iZUlkKTsKLSAgICBtX2FwcHNyY0RhdGFMZWF2aW5nUHJvYmVJZCA9 IDA7Ci19Ci0KIHZvaWQgQXBwZW5kUGlwZWxpbmU6OmFib3J0KCkKIHsKICAgICBBU1NFUlQoV1RG Ojppc01haW5UaHJlYWQoKSk7CkBAIC04MTYsMzkgKzc4Myw1MSBAQCB2b2lkIEFwcGVuZFBpcGVs aW5lOjphYm9ydCgpCiAKIEdzdEZsb3dSZXR1cm4gQXBwZW5kUGlwZWxpbmU6OnB1c2hOZXdCdWZm ZXIoR3N0QnVmZmVyKiBidWZmZXIpCiB7Ci0gICAgR3N0Rmxvd1JldHVybiByZXN1bHQ7Ci0KICAg ICBpZiAobV9hYm9ydFBlbmRpbmcpIHsKICAgICAgICAgbV9wZW5kaW5nQnVmZmVyID0gYWRvcHRH UmVmKGJ1ZmZlcik7Ci0gICAgICAgIHJlc3VsdCA9IEdTVF9GTE9XX09LOwotICAgIH0gZWxzZSB7 Ci0gICAgICAgIHNldEFwcGVuZFN0YXRlKEFwcGVuZFBpcGVsaW5lOjpBcHBlbmRTdGF0ZTo6T25n b2luZyk7Ci0gICAgICAgIEdTVF9UUkFDRSgicHVzaGluZyBuZXcgYnVmZmVyICVwIiwgYnVmZmVy KTsKLSAgICAgICAgcmVzdWx0ID0gZ3N0X2FwcF9zcmNfcHVzaF9idWZmZXIoR1NUX0FQUF9TUkMo YXBwc3JjKCkpLCBidWZmZXIpOworICAgICAgICByZXR1cm4gR1NUX0ZMT1dfT0s7CiAgICAgfQog Ci0gICAgcmV0dXJuIHJlc3VsdDsKLX0KKyAgICBzZXRBcHBlbmRTdGF0ZShBcHBlbmRQaXBlbGlu ZTo6QXBwZW5kU3RhdGU6Ok9uZ29pbmcpOwogCi12b2lkIEFwcGVuZFBpcGVsaW5lOjpyZXBvcnRB cHBzcmNBdExlYXN0QUJ1ZmZlckxlZnQoKQotewotICAgIEdTVF9UUkFDRSgiYnVmZmVyIGxlZnQg YXBwc3JjLCByZXBvc3RpbmcgdG8gYnVzIik7Ci0gICAgR3N0U3RydWN0dXJlKiBzdHJ1Y3R1cmUg PSBnc3Rfc3RydWN0dXJlX25ld19lbXB0eSgiYXBwc3JjLWJ1ZmZlci1sZWZ0Iik7Ci0gICAgR3N0 TWVzc2FnZSogbWVzc2FnZSA9IGdzdF9tZXNzYWdlX25ld19hcHBsaWNhdGlvbihHU1RfT0JKRUNU KG1fYXBwc3JjLmdldCgpKSwgc3RydWN0dXJlKTsKLSAgICBnc3RfYnVzX3Bvc3QobV9idXMuZ2V0 KCksIG1lc3NhZ2UpOwotfQorICAgIEdTVF9UUkFDRV9PQkpFQ1QodGhpcywgInB1c2hpbmcgZGF0 YSBidWZmZXIgJSIgR1NUX1BUUl9GT1JNQVQsIGJ1ZmZlcik7CisgICAgR3N0Rmxvd1JldHVybiBw dXNoRGF0YUJ1ZmZlclJldCA9IGdzdF9hcHBfc3JjX3B1c2hfYnVmZmVyKEdTVF9BUFBfU1JDKG1f YXBwc3JjLmdldCgpKSwgYnVmZmVyKTsKKyAgICAvLyBQdXNoaW5nIGJ1ZmZlcnMgdG8gYXBwc3Jj IGNhbiBvbmx5IGZhaWwgaWYgdGhlIGFwcHNyYyBpcyBmbHVzaGluZywgaW4gRU9TIG9yIHN0b3Bw ZWQuIE5laXRoZXIgb2YgdGhlc2Ugc2hvdWxkCisgICAgLy8gYmUgdHJ1ZSBhdCB0aGlzIHBvaW50 LgorICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHB1c2hEYXRhQnVmZmVyUmV0ID09IEdTVF9GTE9X X09LLCBHU1RfRkxPV19FUlJPUik7CiAKLXZvaWQgQXBwZW5kUGlwZWxpbmU6OnJlcG9ydEFwcHNy Y05lZWREYXRhUmVjZWl2ZWQoKQotewotICAgIEdTVF9UUkFDRSgicmVjZWl2ZWQgbmVlZC1kYXRh IHNpZ25hbCBhdCBhcHBzcmMsIHJlcG9zdGluZyB0byBidXMiKTsKLSAgICBHc3RTdHJ1Y3R1cmUq IHN0cnVjdHVyZSA9IGdzdF9zdHJ1Y3R1cmVfbmV3X2VtcHR5KCJhcHBzcmMtbmVlZC1kYXRhIik7 Ci0gICAgR3N0TWVzc2FnZSogbWVzc2FnZSA9IGdzdF9tZXNzYWdlX25ld19hcHBsaWNhdGlvbihH U1RfT0JKRUNUKG1fYXBwc3JjLmdldCgpKSwgc3RydWN0dXJlKTsKLSAgICBnc3RfYnVzX3Bvc3Qo bV9idXMuZ2V0KCksIG1lc3NhZ2UpOworICAgIC8vIFB1c2ggYW4gYWRkaXRpb25hbCBlbXB0eSBi dWZmZXIgdGhhdCBtYXJrcyB0aGUgZW5kIG9mIHRoZSBhcHBlbmQuCisgICAgLy8gVGhpcyBidWZm ZXIgaXMgZGV0ZWN0ZWQgYW5kIGNvbnN1bWVkIGJ5IGFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tlclBy b2JlKCksIHdoaWNoIHVzZXMgaXQgdG8gc2lnbmFsIHRoZSBzdWNjZXNzZnVsCisgICAgLy8gY29t cGxldGlvbiBvZiB0aGUgYXBwZW5kLgorICAgIC8vCisgICAgLy8gVGhpcyB3b3JrcyBiYXNlZCBv biBob3cgcHVzaCBtb2RlIHNjaGVkdWxpbmcgd29ya3MgaW4gR1N0cmVhbWVyLiBOb3RlIHRoZXJl IGlzIGEgc2luZ2xlIHN0cmVhbWluZyB0aHJlYWQgZm9yIHRoZQorICAgIC8vIEFwcGVuZFBpcGVs aW5lLCBhbmQgd2l0aGluIGEgc3RyZWFtICh0aGUgcG9ydGlvbiBvZiBhIHBpcGVsaW5lIGNvdmVy ZWQgYnkgdGhlIHNhbWUgc3RyZWFtaW5nIHRocmVhZCwgaW4gdGhpcyBjYXNlCisgICAgLy8gdGhl IHdob2xlIHBpcGVsaW5lKSBhIGJ1ZmZlciBpcyBndWFyYW50ZWVkIG5vdCB0byBiZSBwcm9jZXNz ZWQgYnkgZG93bnN0cmVhbSB1bnRpbCBwcm9jZXNzaW5nIG9mIHRoZSBwcmV2aW91cworICAgIC8v IGJ1ZmZlciBoYXMgY29tcGxldGVkLgorCisgICAgR3N0QnVmZmVyKiBlbmRPZkFwcGVuZEJ1ZmZl ciA9IGdzdF9idWZmZXJfbmV3KCk7CisgICAgZ3N0X2J1ZmZlcl9hZGRfbWV0YShlbmRPZkFwcGVu ZEJ1ZmZlciwgc193ZWJLaXRFbmRPZkFwcGVuZE1ldGFJbmZvLCBudWxscHRyKTsKKworICAgIEdT VF9UUkFDRV9PQkpFQ1QodGhpcywgInB1c2hpbmcgZW5kLW9mLWFwcGVuZCBidWZmZXIgJSIgR1NU X1BUUl9GT1JNQVQsIGVuZE9mQXBwZW5kQnVmZmVyKTsKKyAgICBHc3RGbG93UmV0dXJuIHB1c2hF bmRPZkFwcGVuZEJ1ZmZlclJldCA9IGdzdF9hcHBfc3JjX3B1c2hfYnVmZmVyKEdTVF9BUFBfU1JD KG1fYXBwc3JjLmdldCgpKSwgZW5kT2ZBcHBlbmRCdWZmZXIpOworICAgIGdfcmV0dXJuX3ZhbF9p Zl9mYWlsKHB1c2hFbmRPZkFwcGVuZEJ1ZmZlclJldCA9PSBHU1RfRkxPV19PSywgR1NUX0ZMT1df RVJST1IpOworCisgICAgcmV0dXJuIEdTVF9GTE9XX09LOwogfQogCiBHc3RGbG93UmV0dXJuIEFw cGVuZFBpcGVsaW5lOjpoYW5kbGVOZXdBcHBzaW5rU2FtcGxlKEdzdEVsZW1lbnQqIGFwcHNpbmsp CiB7CiAgICAgQVNTRVJUKCFXVEY6OmlzTWFpblRocmVhZCgpKTsKKyAgICBpZiAoJldURjo6VGhy ZWFkOjpjdXJyZW50KCkgIT0gbV9zdHJlYW1pbmdUaHJlYWQpIHsKKyAgICAgICAgLy8gbV9zdHJl YW1pbmdUaHJlYWRJZCBoYXMgYmVlbiBpbml0aWFsaXplZCBpbiBhcHBzcmNFbmRPZkFwcGVuZENo ZWNrZXJQcm9iZSgpLgorICAgICAgICAvLyBGb3IgYSBidWZmZXIgdG8gcmVhY2ggdGhlIGFwcHNp bmssIGEgYnVmZmVyIG11c3QgaGF2ZSBwYXNzZWQgdGhyb3VnaCBhcHBzcmNFbmRPZkFwcGVuZENo ZWNrZXJQcm9iZSgpIGZpcnN0LgorICAgICAgICAvLyBUaGlzIGVycm9yIHdpbGwgb25seSByYWlz ZSBpZiBzb21lb25lIG1vZGlmaWVzIHRoZSBwaXBlbGluZSB0byBpbmNsdWRlIG1vcmUgdGhhbiBv bmUgc3RyZWFtaW5nIHRocmVhZCBvcgorICAgICAgICAvLyByZW1vdmVzIHRoZSBhcHBzcmNFbmRP ZkFwcGVuZENoZWNrZXJQcm9iZSgpLiBFaXRoZXIgd2F5LCB0aGUgZW5kLW9mLWFwcGVuZCBkZXRl Y3Rpb24gd291bGQgYmUgYnJva2VuLgorICAgICAgICAvLyBBcHBlbmRQaXBlbGluZSBzaG91bGQg aGF2ZSBvbmx5IG9uZSBzdHJlYW1pbmcgdGhyZWFkLiBPdGhlcndpc2Ugd2UgY2FuJ3QgZGV0ZWN0 IHJlbGlhYmx5IHdoZW4gYW4gYXBwZW5kcyBoYXMKKyAgICAgICAgLy8gYmVlbiBkZW11eGVkIGNv bXBsZXRlbHkuOworICAgICAgICBnX2NyaXRpY2FsKCJBcHBzaW5rIHJlY2VpdmVkIGEgc2FtcGxl IGluIGEgZGlmZmVyZW50IHRocmVhZCB0aGFuIGFwcHNyY0VuZE9mQXBwZW5kQ2hlY2tlclByb2Jl IHJ1bi4iKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CiAK ICAgICBpZiAoIW1fcGxheWVyUHJpdmF0ZSB8fCBtX2FwcGVuZFN0YXRlID09IEFwcGVuZFN0YXRl OjpJbnZhbGlkKSB7CiAgICAgICAgIEdTVF9XQVJOSU5HKCJBcHBlbmRQaXBlbGluZSBoYXMgYmVl biBkaXNhYmxlZCwgaWdub3JpbmcgdGhpcyBzYW1wbGUiKTsKQEAgLTEwMzMsOSArMTAxMiw3IEBA IHZvaWQgQXBwZW5kUGlwZWxpbmU6OmNvbm5lY3REZW11eGVyU3JjUGFkVG9BcHBzaW5rKEdzdFBh ZCogZGVtdXhlclNyY1BhZCkKICAgICAgICAgZGlkUmVjZWl2ZUluaXRpYWxpemF0aW9uU2VnbWVu dCgpOwogICAgICAgICByZXR1cm47CiAgICAgZGVmYXVsdDoKLSAgICAgICAgLy8gTm8gdXNlZnVs IGRhdGEsIGJ1dCBub3RpZnkgYW55d2F5IHRvIGNvbXBsZXRlIHRoZSBhcHBlbmQgb3BlcmF0aW9u LgotICAgICAgICBHU1RfREVCVUcoIlJlY2VpdmVkIGFsbCBwZW5kaW5nIHNhbXBsZXMgKG5vIGRh dGEpIik7Ci0gICAgICAgIG1fc291cmNlQnVmZmVyUHJpdmF0ZS0+ZGlkUmVjZWl2ZUFsbFBlbmRp bmdTYW1wbGVzKCk7CisgICAgICAgIC8vIE5vIHVzZWZ1bCBkYXRhLgogICAgICAgICBicmVhazsK ICAgICB9CiAKQEAgLTEwNzgsMjAgKzEwNTUsNiBAQCBzdGF0aWMgdm9pZCBhcHBlbmRQaXBlbGlu ZUFwcHNpbmtDYXBzQ2hhbmdlZChHT2JqZWN0KiBhcHBzaW5rUGFkLCBHUGFyYW1TcGVjKiwgQQog ICAgIEdTVF9UUkFDRSgiYXBwc2luay1jYXBzLWNoYW5nZWQgbWVzc2FnZSBwb3N0ZWQgdG8gYnVz Iik7CiB9CiAKLXN0YXRpYyBHc3RQYWRQcm9iZVJldHVybiBhcHBlbmRQaXBlbGluZUFwcHNyY0Rh dGFMZWF2aW5nKEdzdFBhZCosIEdzdFBhZFByb2JlSW5mbyogaW5mbywgQXBwZW5kUGlwZWxpbmUq IGFwcGVuZFBpcGVsaW5lKQotewotICAgIEFTU0VSVChHU1RfUEFEX1BST0JFX0lORk9fVFlQRShp bmZvKSAmIEdTVF9QQURfUFJPQkVfVFlQRV9CVUZGRVIpOwotCi0gICAgR3N0QnVmZmVyKiBidWZm ZXIgPSBHU1RfUEFEX1BST0JFX0lORk9fQlVGRkVSKGluZm8pOwotICAgIGdzaXplIGJ1ZmZlclNp emUgPSBnc3RfYnVmZmVyX2dldF9zaXplKGJ1ZmZlcik7Ci0KLSAgICBHU1RfVFJBQ0UoImJ1ZmZl ciBvZiBzaXplICUiIEdfR1NJWkVfRk9STUFUICIgZ29pbmcgdGhydSIsIGJ1ZmZlclNpemUpOwot Ci0gICAgYXBwZW5kUGlwZWxpbmUtPnJlcG9ydEFwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdCgpOwot Ci0gICAgcmV0dXJuIEdTVF9QQURfUFJPQkVfT0s7Ci19Ci0KICNpZiAhTE9HX0RJU0FCTEVECiBz dGF0aWMgR3N0UGFkUHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVQYWRQcm9iZURlYnVnSW5mb3Jt YXRpb24oR3N0UGFkKiwgR3N0UGFkUHJvYmVJbmZvKiBpbmZvLCBzdHJ1Y3QgUGFkUHJvYmVJbmZv cm1hdGlvbiogcGFkUHJvYmVJbmZvcm1hdGlvbikKIHsKQEAgLTExMzEsMTEgKzEwOTQsNiBAQCBz dGF0aWMgR3N0UGFkUHJvYmVSZXR1cm4gYXBwZW5kUGlwZWxpbmVEZW11eGVyQmxhY2tIb2xlUGFk UHJvYmUoR3N0UGFkKiwgR3N0UGFkUAogICAgIHJldHVybiBHU1RfUEFEX1BST0JFX0RST1A7CiB9 CiAKLXN0YXRpYyB2b2lkIGFwcGVuZFBpcGVsaW5lQXBwc3JjTmVlZERhdGEoR3N0QXBwU3JjKiwg Z3VpbnQsIEFwcGVuZFBpcGVsaW5lKiBhcHBlbmRQaXBlbGluZSkKLXsKLSAgICBhcHBlbmRQaXBl bGluZS0+cmVwb3J0QXBwc3JjTmVlZERhdGFSZWNlaXZlZCgpOwotfQotCiBzdGF0aWMgdm9pZCBh cHBlbmRQaXBlbGluZURlbXV4ZXJQYWRBZGRlZChHc3RFbGVtZW50KiwgR3N0UGFkKiBkZW11eGVy U3JjUGFkLCBBcHBlbmRQaXBlbGluZSogYXBwZW5kUGlwZWxpbmUpCiB7CiAgICAgYXBwZW5kUGlw ZWxpbmUtPmNvbm5lY3REZW11eGVyU3JjUGFkVG9BcHBzaW5rRnJvbUFueVRocmVhZChkZW11eGVy U3JjUGFkKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuaAppbmRleCAzNjYwY2I2YzE1YWI3 NTc5ZWFhMTI4MzdkY2JkZmE1ZDk2ODc3MzFiLi5kYTRmNzVlZWMzYWM2ODY3MmU3ZGM1MzQ4ODdh ZTg0N2Y3OGEyN2Y3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9nc3RyZWFtZXIvbXNlL0FwcGVuZFBpcGVsaW5lLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5oCkBAIC0yOSw3ICsy OSw5IEBACiAKICNpbmNsdWRlIDxhdG9taWM+CiAjaW5jbHVkZSA8Z3N0L2dzdC5oPgorI2luY2x1 ZGUgPG11dGV4PgogI2luY2x1ZGUgPHd0Zi9Db25kaXRpb24uaD4KKyNpbmNsdWRlIDx3dGYvVGhy ZWFkaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtNjQsNiArNjYsNyBAQCBwdWJs aWM6CiAgICAgdm9pZCBhcHBzaW5rQ2Fwc0NoYW5nZWQoKTsKICAgICB2b2lkIGFwcHNpbmtOZXdT YW1wbGUoR1JlZlB0cjxHc3RTYW1wbGU+JiYpOwogICAgIHZvaWQgYXBwc2lua0VPUygpOworICAg IHZvaWQgaGFuZGxlRW5kT2ZBcHBlbmQoKTsKICAgICB2b2lkIGRpZFJlY2VpdmVJbml0aWFsaXph dGlvblNlZ21lbnQoKTsKICAgICBBdG9taWNTdHJpbmcgdHJhY2tJZCgpOwogICAgIHZvaWQgYWJv cnQoKTsKQEAgLTg1LDIwICs4OCwyNSBAQCBwdWJsaWM6CiAgICAgdm9pZCBjb25uZWN0RGVtdXhl clNyY1BhZFRvQXBwc2lua0Zyb21BbnlUaHJlYWQoR3N0UGFkKik7CiAgICAgdm9pZCBjb25uZWN0 RGVtdXhlclNyY1BhZFRvQXBwc2luayhHc3RQYWQqKTsKIAotICAgIHZvaWQgcmVwb3J0QXBwc3Jj QXRMZWFzdEFCdWZmZXJMZWZ0KCk7Ci0gICAgdm9pZCByZXBvcnRBcHBzcmNOZWVkRGF0YVJlY2Vp dmVkKCk7Ci0KIHByaXZhdGU6CiAgICAgdm9pZCByZXNldFBpcGVsaW5lKCk7CiAgICAgdm9pZCBj aGVja0VuZE9mQXBwZW5kKCk7Ci0gICAgdm9pZCBoYW5kbGVBcHBzcmNBdExlYXN0QUJ1ZmZlckxl ZnQoKTsKLSAgICB2b2lkIGhhbmRsZUFwcHNyY05lZWREYXRhUmVjZWl2ZWQoKTsKLSAgICB2b2lk IHJlbW92ZUFwcHNyY0RhdGFMZWF2aW5nUHJvYmUoKTsKLSAgICB2b2lkIHNldEFwcHNyY0RhdGFM ZWF2aW5nUHJvYmUoKTsKICAgICB2b2lkIGRlbXV4ZXJOb01vcmVQYWRzKCk7CiAKICAgICB2b2lk IGNvbnN1bWVBcHBzaW5rQXZhaWxhYmxlU2FtcGxlcygpOwogCisgICAgR3N0UGFkUHJvYmVSZXR1 cm4gYXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUoR3N0UGFkUHJvYmVJbmZvKik7CisKKyAg ICBzdGF0aWMgdm9pZCBzdGF0aWNJbml0aWFsaXphdGlvbigpOworCisgICAgc3RhdGljIHN0ZDo6 b25jZV9mbGFnIHNfc3RhdGljSW5pdGlhbGl6YXRpb25GbGFnOworICAgIHN0YXRpYyBHVHlwZSBz X2VuZE9mQXBwZW5kTWV0YVR5cGU7CisgICAgc3RhdGljIGNvbnN0IEdzdE1ldGFJbmZvKiBzX3dl YktpdEVuZE9mQXBwZW5kTWV0YUluZm87CisKKyAgICAvLyBVc2VkIG9ubHkgZm9yIGFzc2VydGlu ZyB0aGF0IHRoZXJlIGlzIG9ubHkgb25lIHN0cmVhbWluZyB0aHJlYWQuCisgICAgLy8gT25seSB0 aGUgcG9pbnRlcnMgYXJlIGNvbXBhcmVkLgorICAgIFdURjo6VGhyZWFkKiBtX3N0cmVhbWluZ1Ro cmVhZDsKKwogICAgIFJlZjxNZWRpYVNvdXJjZUNsaWVudEdTdHJlYW1lck1TRT4gbV9tZWRpYVNv dXJjZUNsaWVudDsKICAgICBSZWY8U291cmNlQnVmZmVyUHJpdmF0ZUdTdHJlYW1lcj4gbV9zb3Vy Y2VCdWZmZXJQcml2YXRlOwogICAgIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lck1TRSogbV9w bGF5ZXJQcml2YXRlOwpAQCAtMTMwLDEwICsxMzgsNiBAQCBwcml2YXRlOgogICAgIEdSZWZQdHI8 R3N0Q2Fwcz4gbV9kZW11eGVyU3JjUGFkQ2FwczsKICAgICBGbG9hdFNpemUgbV9wcmVzZW50YXRp b25TaXplOwogCi0gICAgYm9vbCBtX2FwcHNyY0F0TGVhc3RBQnVmZmVyTGVmdDsKLSAgICBib29s IG1fYXBwc3JjTmVlZERhdGFSZWNlaXZlZDsKLQotICAgIGd1bG9uZyBtX2FwcHNyY0RhdGFMZWF2 aW5nUHJvYmVJZDsKICNpZiAhTE9HX0RJU0FCTEVECiAgICAgc3RydWN0IFBhZFByb2JlSW5mb3Jt YXRpb24gbV9kZW11eGVyRGF0YUVudGVyaW5nUGFkUHJvYmVJbmZvcm1hdGlvbjsKICAgICBzdHJ1 Y3QgUGFkUHJvYmVJbmZvcm1hdGlvbiBtX2FwcHNpbmtEYXRhRW50ZXJpbmdQYWRQcm9iZUluZm9y bWF0aW9uOwo= 351276 2018-10-01 11:14:38 -0700 2018-10-02 02:20:56 -0700 Patch bug-189924-20181001201437.patch text/plain 1630 aboya U3VidmVyc2lvbiBSZXZpc2lvbjogMjM2NTAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWZmYTJkMmU0Y2Y0MTQ4 OWYwZWMyMDc5ZDQzZDVlMTRiODYwNzE0NS4uYWQ2MmM5ODUxNWQ0ZThjMWMzODRhMDI3MTFmZmQ4 ZjUyYTQ2ZThiOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDE4LTEwLTAxICBBbGlj aWEgQm95YSBHYXJjw61hICA8YWJveWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbTVNFXVtHU3Ry ZWFtZXJdIE1ha2Ugc2FtZSB0aHJlYWQgYXNzZXJ0IG5vbi1yZWxlYXNlCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODk5MjQKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9tc2UvQXBwZW5kUGlwZWxpbmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXBwZW5k UGlwZWxpbmU6OmhhbmRsZU5ld0FwcHNpbmtTYW1wbGUpOgorCiAyMDE4LTEwLTAxICBBbGljaWEg Qm95YSBHYXJjw61hICA8YWJveWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBbTVNFXVtHU3RyZWFt ZXJdIEFkZCBoMjY0cGFyc2UgdG8gYWNjZXB0IE1QNCB3aXRob3V0IHN0c3MKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9tc2UvQXBwZW5kUGlw ZWxpbmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21z ZS9BcHBlbmRQaXBlbGluZS5jcHAKaW5kZXggYTM4ZmUwNTg1YzM3ZmJjM2M1YTJkYTFiNzA1ZDNj MmQ3N2U4YzMzMC4uY2QyMGJhMTI5YmE2ODMyMmRlMTdiOTRhMDcxNzNlNGM2MzgwZGVlNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9B cHBlbmRQaXBlbGluZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL21zZS9BcHBlbmRQaXBlbGluZS5jcHAKQEAgLTgyOSw3ICs4MjksNyBAQCBHc3RG bG93UmV0dXJuIEFwcGVuZFBpcGVsaW5lOjpoYW5kbGVOZXdBcHBzaW5rU2FtcGxlKEdzdEVsZW1l bnQqIGFwcHNpbmspCiAgICAgICAgIC8vIEFwcGVuZFBpcGVsaW5lIHNob3VsZCBoYXZlIG9ubHkg b25lIHN0cmVhbWluZyB0aHJlYWQuIE90aGVyd2lzZSB3ZSBjYW4ndCBkZXRlY3QgcmVsaWFibHkg d2hlbiBhbiBhcHBlbmRzIGhhcwogICAgICAgICAvLyBiZWVuIGRlbXV4ZWQgY29tcGxldGVseS47 CiAgICAgICAgIGdfY3JpdGljYWwoIkFwcHNpbmsgcmVjZWl2ZWQgYSBzYW1wbGUgaW4gYSBkaWZm ZXJlbnQgdGhyZWFkIHRoYW4gYXBwc3JjRW5kT2ZBcHBlbmRDaGVja2VyUHJvYmUgcnVuLiIpOwot ICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICBBU1NFUlRfTk9U X1JFQUNIRUQoKTsKICAgICB9CiAKICAgICBpZiAoIW1fcGxheWVyUHJpdmF0ZSB8fCBtX2FwcGVu ZFN0YXRlID09IEFwcGVuZFN0YXRlOjpJbnZhbGlkKSB7Cg==