77224 2012-01-27 08:52:22 -0800 noteGrainOn is too long 2012-06-25 22:40:34 -0700 1 1 1 Unclassified WebKit Web Audio 528+ (Nightly build) Unspecified Unspecified NEW P1 Normal --- 74553 85681 87904 1 rtoy rtoy crogers eric.carlson feature-media-reviews jer.noble rtoy webkit.review.bot oldest_to_newest 544108 0 rtoy 2012-01-27 08:52:22 -0800 As discovered in the note-grain-on-timing test in bug 76659, noteGrainOn generates a signal that is longer than the specified duration. This is caused by AudioBufferSourceNode::renderFromBuffer always adding 512 samples to the end to allow for HRTF tail-time, according to the fixme comment. This should be fixed. 559884 1 crogers 2012-02-19 00:40:55 -0800 This should be handled more generally. 562369 2 rtoy 2012-02-22 14:08:50 -0800 (In reply to comment #1) > This should be handled more generally. Can you describe this a little bit more? 562389 3 crogers 2012-02-22 14:25:09 -0800 Sorry, I'll try to explain a bit better. This is a work-around for the latency in HRTFPanner processing (assuming that there is an AudioPannerNode in the processing chain after AudioBufferSourceNode). If there is a panner and the extra 512 sample-frames are not generated in AudioBufferSourceNode, then the nodes get torn down immediately when the grain finishes playing. But, because the HRTFPanner incurs a processing latency, it still has unprocessed sample-data which has not yet been output. And so the very end of the rendered signal is truncated and can cause glitches. Ideally, the handling would be more general than just HRTFPanner, and would handle *any* node which incurs processing latency. We should talk about this offline to consider the best solution. 573195 4 rtoy 2012-03-07 13:42:38 -0800 Adding dependency to 74750. Once the tailTime feature is added, we can build on that to remove the extra 512 samples from noteGrainOn, and fix the HRTF panner to continue to output samples after the input has been disconnected. 584426 5 rtoy 2012-03-21 11:41:08 -0700 Add dependency on 74533. 584446 6 beidson 2012-03-21 11:53:22 -0700 (In reply to comment #5) > Add dependency on 74533. A very curious dependency, as 74533 was a crasher in code not at all related to Web Audio, and has already been resolved. 584452 7 rtoy 2012-03-21 11:59:07 -0700 Oops. That's 74553, not 74533. 596891 8 135899 rtoy 2012-04-05 13:58:23 -0700 Created attachment 135899 Patch 596894 9 rtoy 2012-04-05 14:01:39 -0700 Please review this preliminary patch. Ignore the debugging stuff for now. I want to try this patch on another platform and having the debugging stuff will help if I find a problem. This patch depends on the patch for 74553; it won't work without 74553. Also ignore the patch for revolver which was needed so that I could run in debug mode. (That bug is fixed in another patch, already.) 596897 10 rtoy 2012-04-05 14:05:08 -0700 One additional thing. This patch implements the tail time processing for all nodes that have a non-zero tail time or latency time, in addition to fixing noteGrainOn() being too long. 596967 11 135899 crogers 2012-04-05 15:35:00 -0700 Comment on attachment 135899 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135899&action=review Hi Ray, thanks for the early patch. I'll have to have Jer's patch landed first before I can go deeper here. Also, we should probably talk about the logic offline to work this out more quickly. > Source/WebCore/platform/audio/ReverbConvolverStage.cpp:77 > + } Please update sources. This change in ReverbConvolverStage.cpp should not be part of this patch. > Source/WebCore/webaudio/AudioNode.cpp:40 > +#endif Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). > Source/WebCore/webaudio/AudioNode.cpp:192 > + endTailProcessingIfNeeded(); I'm going to have to wait until Jer's patch lands before fully being able to understand this logic. > Source/WebCore/webaudio/AudioNode.cpp:370 > + // Establish a ref to ourselves so we don't get removed when the inputs go away. We are now "when the inputs go away" -> "when all nodes have disconnected from us" > Source/WebCore/webaudio/AudioNode.cpp:375 > +#endif Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). > Source/WebCore/webaudio/AudioNode.cpp:391 > +#endif Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). > Source/WebCore/webaudio/AudioNode.cpp:405 > +#endif Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). > Source/WebCore/webaudio/AudioNode.cpp:407 > + deref(RefTypeConnection); If you have a method that calls deref() directly then you should have (at the top of the method: ASSERT(context()->isGraphOwner()); > Source/WebCore/webaudio/AudioNode.h:34 > +#define DEBUG_AUDIONODE_TAIL 0 Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). DEBUG_AUDIONODE_REFERENCES also should probably not be in AudioNode.h - let's not pile on more debugging conditionals > Source/WebCore/webaudio/AudioNode.h:159 > + // one at least input is outputting silence. This will create an additional connection ref to typo: grammar/wording is funny here. "input is outputting silence" -> "input is receiving silence" Shouldn't the logic be when ALL inputs are receiving silence, not "at least one"? > Source/WebCore/webaudio/AudioNodeInput.cpp:67 > + node()->resetTailProcessingIfNeeded(); I don't understand why this logic is here. Why should silent processing logic be affected if somebody connects to us? > Source/WebCore/webaudio/AudioNodeInput.cpp:113 > + // If an input to a node is disabled, we want to enable tail processing for the nodes that have nit: "inputs" are not disabled, instead "connections" (from AudioNodeOutputs) are disabled. There's a difference between an "input" to a node and connections (which can be multiple) to that input. I don't understand why we should start tail processing just because one particular AudioNodeOutput is calling our disable() method. What if there are ten other AudioNodeOutputs still connected to us? 597006 12 135899 rtoy 2012-04-05 16:27:05 -0700 Comment on attachment 135899 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135899&action=review Just a few comments that might clarify things. If not, we'll discuss this in person which will be easier. >> Source/WebCore/platform/audio/ReverbConvolverStage.cpp:77 >> + } > > Please update sources. This change in ReverbConvolverStage.cpp should not be part of this patch. I didn't do that due to the move of the webaudio files to the Modules directory. Otherwise I would have. >> Source/WebCore/webaudio/AudioNodeInput.cpp:67 >> + node()->resetTailProcessingIfNeeded(); > > I don't understand why this logic is here. Why should silent processing logic be affected if somebody connects to us? Yes, you're right. In the original version where I had a countdown for tail processing, I wanted to reset the counter and state. With the current implementation, it doesn't matter because we don't count down the tail frames anymore. (It wasn't needed in the original version either, I think.) >> Source/WebCore/webaudio/AudioNodeInput.cpp:113 >> + // If an input to a node is disabled, we want to enable tail processing for the nodes that have > > nit: "inputs" are not disabled, instead "connections" (from AudioNodeOutputs) are disabled. There's a difference between an "input" to a node and connections (which can be multiple) to that input. > > I don't understand why we should start tail processing just because one particular AudioNodeOutput is calling our disable() method. What if there are ten other AudioNodeOutputs still connected to us? Perhaps the name is bad. It's really more like enable processing. The actual tail processing doesn't happen until processIfNecessary is passing silence through. This just establishes a reference to ourselves so we don't go away before processing the tail. I don't think we can wait to until processIfNecessary to establish the reference because the node will have already been disabled by then. 597771 13 135899 rtoy 2012-04-06 15:57:37 -0700 Comment on attachment 135899 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135899&action=review > Source/WebCore/webaudio/AudioNodeInput.cpp:114 > + // tail or latency time. Fixed. It shouldn't be here and it works just fine running it in processIfNecessary. 600542 14 136738 rtoy 2012-04-11 13:24:48 -0700 Created attachment 136738 Patch 600544 15 135899 rtoy 2012-04-11 13:28:12 -0700 Comment on attachment 135899 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135899&action=review >>> Source/WebCore/platform/audio/ReverbConvolverStage.cpp:77 >>> + } >> >> Please update sources. This change in ReverbConvolverStage.cpp should not be part of this patch. > > I didn't do that due to the move of the webaudio files to the Modules directory. Otherwise I would have. Updated (and therefore removed). >> Source/WebCore/webaudio/AudioNode.cpp:40 >> +#endif > > Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). Removed. >> Source/WebCore/webaudio/AudioNode.cpp:370 >> + // Establish a ref to ourselves so we don't get removed when the inputs go away. We are now > > "when the inputs go away" -> "when all nodes have disconnected from us" Fixed. >> Source/WebCore/webaudio/AudioNode.cpp:375 >> +#endif > > Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). Done. >> Source/WebCore/webaudio/AudioNode.cpp:391 >> +#endif > > Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). Done. >> Source/WebCore/webaudio/AudioNode.cpp:405 >> +#endif > > Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). Done. >> Source/WebCore/webaudio/AudioNode.cpp:407 >> + deref(RefTypeConnection); > > If you have a method that calls deref() directly then you should have (at the top of the method: > ASSERT(context()->isGraphOwner()); As discussed, we can't do that. We call addDeferredFinishDeref() instead. >> Source/WebCore/webaudio/AudioNode.h:34 >> +#define DEBUG_AUDIONODE_TAIL 0 > > Please remove debugging code. For your own testing purposes, you can keep these locally in a git branch (for example). > > > DEBUG_AUDIONODE_REFERENCES also should probably not be in AudioNode.h - let's not pile on more debugging conditionals Removed. >> Source/WebCore/webaudio/AudioNode.h:159 >> + // one at least input is outputting silence. This will create an additional connection ref to > > typo: grammar/wording is funny here. > > "input is outputting silence" -> "input is receiving silence" > > Shouldn't the logic be when ALL inputs are receiving silence, not "at least one"? Fixed. 611097 16 136738 crogers 2012-04-26 17:03:41 -0700 Comment on attachment 136738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=136738&action=review Looks pretty good overall, but I have one question about AudioNode lifetime. Since an AudioNode can now ref() itself, what happens in the case when the AudioContext is uninitialized (when the page unloads), but there are still some AudioNodes sitting around still processing tails. In this case AudioNode::processIfNecessary() will never have a chance to get called again enough times to fully empty the tails, so endTailProcessingIfNeeded() will never get called and the derefs() will never happen. So I think we're going to have to keep track of these "special" nodes and add a final cleanup method which we call in AudioContext::uninitialize(). Looking at this a little closer, I think you may be able to leverage AudioContext::refNode() and AudioContext::derefUnfinishedSourceNodes(). Then the only tricky thing left is that you can't *directly* call AudioContext::refNode() in the processIfNecessaryMethod() > Source/WebCore/Modules/webaudio/AudioNode.cpp:216 > + allowTailProcessingIfNeeded(); WebKit style: avoid redundant comments - I would just remove the comments on lines 214:215 since the name of the method itself says the same thing. The comment in the 2nd sentence is already included in the comments in the method impl itself Also, shouldn't this line be moved down to just above line 223 (call to process())? This is because we don't want to call this *until* we have received non-silent input > Source/WebCore/Modules/webaudio/AudioNode.cpp:398 > + // Establish a ref to ourselves if we haven't already so we don't get removed when all nodes "ourselves" -> "ourself" > Source/WebCore/Modules/webaudio/AudioNode.cpp:400 > + // actually processing the tail. That happens when all of the inputs become silent. Part of this comment can be made a little more clear: "We can process the tail, but that does not imply we are actually processing the tail. That happens when all of the inputs become silent." -> "We hold this ref during the time when we are receiving non-silent input, or during the time after first receiving silent input when we empty the processing pipeline to account for latency and tail." > Source/WebCore/Modules/webaudio/AudioNode.cpp:411 > + // Stop tail processing. Just need to deref ourselves, but we can't do that while the graph "ourselves" -> "ourself" > Source/WebCore/Modules/webaudio/AudioNode.h:156 > + bool allowTailProcessing() const { return m_allowTailProcessing; } As a simplification, I would simply remove this method and access m_allowTailProcessing directly in the .cpp file. In both uses of this method, m_allowTailProcessing is already accessed directly within two or three lines. So in these cases its simpler and more direct to avoid creating methods like this. > Source/WebCore/Modules/webaudio/AudioNode.h:159 > + // additional connection ref to ourselves so we don't get removed from the graph before the tail ourselves -> ourself > Source/WebCore/Modules/webaudio/AudioNode.h:164 > + // end tail processing. The connection ref to ourselves will also be removed. ourselves -> ourself "The connection ref to ourselves will also be removed" -> "This balances the reference we took in allowTailProcessingIfNeeded()" > LayoutTests/webaudio/resources/note-grain-on-testing.js:128 > + // The end point is the duration nit: period at end of sentence 613646 17 139673 rtoy 2012-05-01 14:03:12 -0700 Created attachment 139673 Patch 613653 18 136738 rtoy 2012-05-01 14:11:25 -0700 Comment on attachment 136738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=136738&action=review >> Source/WebCore/Modules/webaudio/AudioNode.cpp:216 >> + allowTailProcessingIfNeeded(); > > WebKit style: avoid redundant comments - I would just remove the comments on lines 214:215 since the name of the method itself says the same thing. > The comment in the 2nd sentence is already included in the comments in the method impl itself > > Also, shouldn't this line be moved down to just above line 223 (call to process())? This is because we don't want to call this *until* we have received non-silent input Done. >> Source/WebCore/Modules/webaudio/AudioNode.cpp:398 >> + // Establish a ref to ourselves if we haven't already so we don't get removed when all nodes > > "ourselves" -> "ourself" Done. >> Source/WebCore/Modules/webaudio/AudioNode.cpp:400 >> + // actually processing the tail. That happens when all of the inputs become silent. > > Part of this comment can be made a little more clear: > > "We can process the tail, but that does not imply we are actually processing the tail. That happens when all of the inputs become silent." > > -> "We hold this ref during the time when we are receiving non-silent input, or during the time after first receiving silent input when we empty the processing pipeline to account for latency and tail." Done. >> Source/WebCore/Modules/webaudio/AudioNode.cpp:411 >> + // Stop tail processing. Just need to deref ourselves, but we can't do that while the graph > > "ourselves" -> "ourself" Done. >> Source/WebCore/Modules/webaudio/AudioNode.h:156 >> + bool allowTailProcessing() const { return m_allowTailProcessing; } > > As a simplification, I would simply remove this method and access m_allowTailProcessing directly in the .cpp file. > In both uses of this method, m_allowTailProcessing is already accessed directly within two or three lines. > So in these cases its simpler and more direct to avoid creating methods like this. Removed. >> Source/WebCore/Modules/webaudio/AudioNode.h:159 >> + // additional connection ref to ourselves so we don't get removed from the graph before the tail > > ourselves -> ourself Done. >> Source/WebCore/Modules/webaudio/AudioNode.h:164 >> + // end tail processing. The connection ref to ourselves will also be removed. > > ourselves -> ourself > > "The connection ref to ourselves will also be removed" -> "This balances the reference we took in allowTailProcessingIfNeeded()" Done. >> LayoutTests/webaudio/resources/note-grain-on-testing.js:128 >> + // The end point is the duration > > nit: period at end of sentence Done. 613656 19 139676 rtoy 2012-05-01 14:12:42 -0700 Created attachment 139676 Patch 613667 20 rtoy 2012-05-01 14:17:40 -0700 I've tested this patch on Safari where I can see the audiocontext being destroyed when the page is torn down. The atexit function also shows that there are no AudioNodes left dangling. I ran this test on several of the audio demos successfully. There is a slight difference in approach from what we discussed (offline). Instead of call addDeferredFinishDeref, I call addDeferredDerefNode because we need to remove the node from m_referencedNodes list. Otherwise the list grows forever, holding on to nodes that have actually stopped. 616605 21 139676 crogers 2012-05-04 13:52:41 -0700 Comment on attachment 139676 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=139676&action=review I notice there are many fprintfs in the code. Please make sure to carefully examine any patches that you're uploading with "webkit-patch upload" to make sure they look good to you before asking for review. "webkit-patch upload" normally should bring up the patch/diff in a browser so you can catch these obvious mistakes before uploading -- thanks! > Source/WebCore/Modules/webaudio/AudioContext.cpp:197 > + fprintf(stderr, "AudioContext::~AudioContext(): %p\n", this); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioContext.cpp:581 > // Don't allow regular lock in real-time audio thread. This comment needs to change to match your code change on line 582 Probably best to simply remove the comment at this point > Source/WebCore/Modules/webaudio/AudioContext.cpp:658 > +} addDeferredDerefNode() should not be needed. Please see comment about this method in your changes to AudioContext.h > Source/WebCore/Modules/webaudio/AudioContext.cpp:748 > +} handleDeferredDerefNodes() should not be needed (see my comment about this in AudioContext.h) > Source/WebCore/Modules/webaudio/AudioContext.h:220 > + void handleDeferredDerefNodes(); I don't understand why you've added these two new methods: addDeferredDerefNode() handleDeferredDerefNodes() We already have the mechanism in place with: addDeferredFinishDeref() and handleDeferredFinishDerefs() Why are these being added in addition? Your old patch was even calling addDeferredFinishDeref() in AudioNode::endTailProcessingIfNeeded() > Source/WebCore/Modules/webaudio/AudioNode.cpp:42 > + Please remove > Source/WebCore/Modules/webaudio/AudioNode.cpp:71 > + fprintf(stderr, "%p: %d: AudioNode::~AudioNode() %d %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount, m_disabledRefCount); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioNode.cpp:293 > + fprintf(stderr, "%p: %d: AudioNode::ref(%d) %d %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount, m_disabledRefCount); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioNode.cpp:365 > + fprintf(stderr, "%p: %d: AudioNode::deref(%d) %d %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount, m_disabledRefCount); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioNode.cpp:416 > + context()->addDeferredDerefNode(this); Your previous approach was correct in calling addDeferredFinishDeref(). I don't understand why you've changed this here. > Source/WebCore/Modules/webaudio/AudioNode.cpp:430 > + fprintf(stderr, "===========================\n"); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioNode.cpp:433 > + fprintf(stderr, "%d: %d\n", i, s_nodeCount[i]); Please remove stray fprintf > Source/WebCore/Modules/webaudio/AudioNode.cpp:435 > + fprintf(stderr, "===========================\n\n\n"); Please remove stray fprintf 616643 22 rtoy 2012-05-04 14:16:13 -0700 (In reply to comment #21) > (From update of attachment 139676 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=139676&action=review > > I notice there are many fprintfs in the code. Please make sure to carefully examine any patches that you're uploading with "webkit-patch upload" to make sure they look good to you before asking for review. "webkit-patch upload" normally should bring up the patch/diff in a browser so you can catch these obvious mistakes before uploading -- thanks! I changed the original printfs to fprintfs because they were getting interleaved with my other debugging prints (that have been removed). Do you really want to remove all of the debugging prints that you left in the code? > addDeferredDerefNode() should not be needed. Please see comment about this method in your changes to AudioContext.h As we had originally discussed, we just had addDeferredRef and handleDeferredRef, and just used addDeferredFinishDeref. The problem with this approach is that addDeferredRef and handleDeferredRef would just keep adding nodes to m_referencedNodes. There was no way to remove them when the tail processing is done. This list would hang on to the nodes forever until we tried to deref unfinished nodes. This would get an error on debug builds because we would decrement the ref too many times. (Once in handleDeferredFinishDeref and once in derefUnfinishedNodes.) I didn't see any way for addDeferredFinishDeref to do this without adding another list anyway. (Because we can't modify m_referencedNodes until we reach a safe point when we run handleDeferredFinishDerefs.) Is this analysis wrong? If so, please correct my understanding. 616676 23 crogers 2012-05-04 14:32:47 -0700 (In reply to comment #22) > (In reply to comment #21) > > (From update of attachment 139676 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=139676&action=review > > > > I notice there are many fprintfs in the code. Please make sure to carefully examine any patches that you're uploading with "webkit-patch upload" to make sure they look good to you before asking for review. "webkit-patch upload" normally should bring up the patch/diff in a browser so you can catch these obvious mistakes before uploading -- thanks! > > I changed the original printfs to fprintfs because they were getting interleaved with my other debugging prints (that have been removed). > > Do you really want to remove all of the debugging prints that you left in the code? No, please just leave all of this debugging code alone and don't add anything more as you are in this patch. > > > > addDeferredDerefNode() should not be needed. Please see comment about this method in your changes to AudioContext.h > > As we had originally discussed, we just had addDeferredRef and handleDeferredRef, and just used addDeferredFinishDeref. > > The problem with this approach is that addDeferredRef and handleDeferredRef would just keep adding nodes to m_referencedNodes. There was no way to remove them when the tail processing is done. This list would hang on to the nodes forever until we tried to deref unfinished nodes. This would get an error on debug builds because we would decrement the ref too many times. (Once in handleDeferredFinishDeref and once in derefUnfinishedNodes.) > > I didn't see any way for addDeferredFinishDeref to do this without adding another list anyway. (Because we can't modify m_referencedNodes until we reach a safe point when we run handleDeferredFinishDerefs.) > > Is this analysis wrong? If so, please correct my understanding. I'm not sure I follow you. It looks like your addDeferredRefNode() method *does* actually create a new vector called "m_deferredRefList" which is then emptied in handleDeferredRefNodes() which you are calling in the post-render tasks. So this part seems fine. There shouldn't be any list which "keeps growing". The part you don't need is the addDeferredDerefNode(), handleDeferredDerefNodes() methods and the associated m_deferredDerefList 616779 24 140353 rtoy 2012-05-04 16:12:14 -0700 Created attachment 140353 Patch 616783 25 139676 rtoy 2012-05-04 16:18:19 -0700 Comment on attachment 139676 Patch All fprintf's reverted to printf's, and simplified handleDeferredDerefNodes(). As discussed (offline), this patch should be applied after 85681 which will clean things up and help us remove the parallel deferredDerefNodes list. 616785 26 rtoy 2012-05-04 16:19:46 -0700 (In reply to comment #23) > (In reply to comment #22) > > (In reply to comment #21) > > > (From update of attachment 139676 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=139676&action=review > > > > > > I notice there are many fprintfs in the code. Please make sure to carefully examine any patches that you're uploading with "webkit-patch upload" to make sure they look good to you before asking for review. "webkit-patch upload" normally should bring up the patch/diff in a browser so you can catch these obvious mistakes before uploading -- thanks! > > > > I changed the original printfs to fprintfs because they were getting interleaved with my other debugging prints (that have been removed). > > > > Do you really want to remove all of the debugging prints that you left in the code? > > No, please just leave all of this debugging code alone and don't add anything more as you are in this patch. > > > > > > > > addDeferredDerefNode() should not be needed. Please see comment about this method in your changes to AudioContext.h > > > > As we had originally discussed, we just had addDeferredRef and handleDeferredRef, and just used addDeferredFinishDeref. > > > > The problem with this approach is that addDeferredRef and handleDeferredRef would just keep adding nodes to m_referencedNodes. There was no way to remove them when the tail processing is done. This list would hang on to the nodes forever until we tried to deref unfinished nodes. This would get an error on debug builds because we would decrement the ref too many times. (Once in handleDeferredFinishDeref and once in derefUnfinishedNodes.) > > > > I didn't see any way for addDeferredFinishDeref to do this without adding another list anyway. (Because we can't modify m_referencedNodes until we reach a safe point when we run handleDeferredFinishDerefs.) > > > > Is this analysis wrong? If so, please correct my understanding. > > I'm not sure I follow you. It looks like your addDeferredRefNode() method *does* actually create a new vector called "m_deferredRefList" which is then emptied in handleDeferredRefNodes() which you are calling in the post-render tasks. So this part seems fine. There shouldn't be any list which "keeps growing". > > The part you don't need is the addDeferredDerefNode(), handleDeferredDerefNodes() methods and the associated m_deferredDerefList For the record, we discussed this offline and the approach is correct, but could be simplified. The simplification will happen after 85681 is implemented. 624729 27 142096 rtoy 2012-05-15 16:44:03 -0700 Created attachment 142096 Proposed patch Tentative patch assuming 85681 has been applied. 625857 28 142096 crogers 2012-05-16 14:13:23 -0700 Comment on attachment 142096 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=142096&action=review > LayoutTests/ChangeLog:46 > + Please re-upload patch with the ChangeLog fixed > Source/WebCore/ChangeLog:145 > + (WebCore::AudioPannerNode::process): Please re-upload patch with the ChangeLog fixed > Source/WebCore/Modules/webaudio/AudioContext.cpp:577 > + } Please remove changes to this method. > Source/WebCore/Modules/webaudio/AudioContext.h:217 > + void addDeferredDerefNode(AudioNode* node) { derefNode(node, true); } Please call addDeferredFinishDeref() directly here, instead of going indirectly through this hacked derefNode() > Source/WebCore/Modules/webaudio/AudioContext.h:273 > + void derefNode(AudioNode*, bool deferred = false); Please revert change to derefNode() 625869 29 142096 rtoy 2012-05-16 14:25:55 -0700 Comment on attachment 142096 Proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=142096&action=review Sorry for the bad Changelog. I wasn't ready for this to be reviewed yet because it needs the dependent bug to be landed before this can be applied. (I thought setting no review flags would prevent any email notifications.) >> Source/WebCore/Modules/webaudio/AudioContext.h:217 >> + void addDeferredDerefNode(AudioNode* node) { derefNode(node, true); } > > Please call addDeferredFinishDeref() directly here, instead of going indirectly through this hacked derefNode() No, I cannot. derefNode removes the node from m_referencedNodes, but addDeferredFinishDeref does not. Thus, the m_referencedNodes grows forever, holding on to the nodes, which won't get removed until context is closed. 642778 30 146104 rtoy 2012-06-06 13:59:29 -0700 Created attachment 146104 WIP Work in progress. chrome crashes running the granular demo, trying to read from renderingOutput(i) for some renderingOutput that has been apparently deleted. 657300 31 149457 rtoy 2012-06-25 22:40:34 -0700 Created attachment 149457 WIP 135899 2012-04-05 13:58:23 -0700 2012-04-11 13:28:12 -0700 Patch bug-77224-20120405135822.patch text/plain 12637 rtoy ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYkNvbnZvbHZl clN0YWdlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYkNvbnZvbHZl clN0YWdlLmNwcAppbmRleCAxZDM1ZTI5ZGZmZDJlZTZlZTE4NGJlNWQ2ZGI3NGE4ZmRlNTg1ZmYw Li5lOGM0ZDNmYjg0Mzc4ZGM2MzE3NDdiMDRkMWY5NGFlZTQwMTc5NzI1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmJDb252b2x2ZXJTdGFnZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJiQ29udm9sdmVyU3RhZ2UuY3Bw CkBAIC03MCw5ICs3MCwxMSBAQCBSZXZlcmJDb252b2x2ZXJTdGFnZTo6UmV2ZXJiQ29udm9sdmVy U3RhZ2UoY29uc3QgZmxvYXQqIGltcHVsc2VSZXNwb25zZSwgc2l6ZV90CiAKICAgICAvLyBCdXQs IHRoZSBGRlQgY29udm9sdXRpb24gaXRzZWxmIGluY3VycyBmZnRTaXplIC8gMiBsYXRlbmN5LCBz byBzdWJ0cmFjdCB0aGlzIG91dC4uLgogICAgIHNpemVfdCBoYWxmU2l6ZSA9IGZmdFNpemUgLyAy OwotICAgIEFTU0VSVCh0b3RhbERlbGF5ID49IGhhbGZTaXplKTsKLSAgICBpZiAodG90YWxEZWxh eSA+PSBoYWxmU2l6ZSkKLSAgICAgICAgdG90YWxEZWxheSAtPSBoYWxmU2l6ZTsKKyAgICBpZiAo IW1fZGlyZWN0TW9kZSkgeworICAgICAgICBBU1NFUlQodG90YWxEZWxheSA+PSBoYWxmU2l6ZSk7 CisgICAgICAgIGlmICh0b3RhbERlbGF5ID49IGhhbGZTaXplKQorICAgICAgICAgICAgdG90YWxE ZWxheSAtPSBoYWxmU2l6ZTsKKyAgICB9CiAKICAgICAvLyBXZSBkaXZpZGUgdXAgdGhlIHRvdGFs IGRlbGF5LCBpbnRvIHByZSBhbmQgcG9zdCBkZWxheSBzZWN0aW9ucyBzbyB0aGF0IHdlIGNhbiBz Y2hlZHVsZSBhdCBleGFjdGx5IHRoZSBtb21lbnQgd2hlbiB0aGUgRkZUIHdpbGwgaGFwcGVuLgog ICAgIC8vIFRoaXMgaXMgY29vcmRpbmF0ZWQgd2l0aCB0aGUgb3RoZXIgc3RhZ2VzLCBzbyB0aGV5 IGRvbid0IGFsbCBkbyB0aGVpciBGRlRzIGF0IHRoZSBzYW1lIHRpbWUuLi4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCmluZGV4IGM4OTE0 YTdmNTIzODRiMzk2NGZmMDc4NTcwOTVlNGViZWE2ZjgyMTEuLjE1YTAwNzI0MWUwMmJlNTk5M2Jh ZmE2ZmZlNzI0MTFiOTI3MDllZjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3dlYmF1ZGlv L0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvd2ViYXVkaW8v QXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcApAQCAtMjQ1LDExICsyNDUsNiBAQCB2b2lkIEF1ZGlv QnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcihBdWRpb0J1cyogYnVzLCB1bnNpZ25l ZCBkZXN0aW5hdGlvbgogICAgIAogICAgIHVuc2lnbmVkIGRlbHRhRnJhbWVzID0gZW5kRnJhbWUg LSBzdGFydEZyYW1lOwogICAgIAotICAgIC8vIFRoaXMgaXMgYSBIQUNLIHRvIGFsbG93IGZvciBI UlRGIHRhaWwtdGltZSAtIGF2b2lkcyBnbGl0Y2ggYXQgZW5kLgotICAgIC8vIEZJWE1FOiBpbXBs ZW1lbnQgdGFpbFRpbWUgZm9yIGVhY2ggQXVkaW9Ob2RlIGZvciBhIG1vcmUgZ2VuZXJhbCBzb2x1 dGlvbiB0byB0aGlzIHByb2JsZW0uCi0gICAgaWYgKG1faXNHcmFpbikKLSAgICAgICAgZW5kRnJh bWUgKz0gNTEyOwotCiAgICAgLy8gRG8gc29tZSBzYW5pdHkgY2hlY2tpbmcuCiAgICAgaWYgKHN0 YXJ0RnJhbWUgPj0gYnVmZmVyTGVuZ3RoKQogICAgICAgICBzdGFydEZyYW1lID0gIWJ1ZmZlckxl bmd0aCA/IDAgOiBidWZmZXJMZW5ndGggLSAxOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv d2ViYXVkaW8vQXVkaW9Ob2RlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvTm9k ZS5jcHAKaW5kZXggOTJjNGNiMTRhYmJiNDJmYWY5OWZlYjk3NTk5MmE1NDRlYjE3ZjFhMi4uMDgy MTgxNWZjOWJiOGNmODNmOWIwMjlmYzU5YjhkN2Y3M2FmOGYxYiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS93ZWJh dWRpby9BdWRpb05vZGUuY3BwCkBAIC0zNSw2ICszNSwxMCBAQAogI2luY2x1ZGUgPHd0Zi9BdG9t aWNzLmg+CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KIAorI2lmIERFQlVHX0FVRElPTk9E RV9SRUZFUkVOQ0VTIHx8IERFQlVHX0FVRElPX05PREVfVEFJTAorI2luY2x1ZGUgPHN0ZGlvLmg+ CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBBdWRpb05vZGU6OkF1ZGlvTm9kZShB dWRpb0NvbnRleHQqIGNvbnRleHQsIGZsb2F0IHNhbXBsZVJhdGUpCkBAIC00OSw2ICs1Myw3IEBA IEF1ZGlvTm9kZTo6QXVkaW9Ob2RlKEF1ZGlvQ29udGV4dCogY29udGV4dCwgZmxvYXQgc2FtcGxl UmF0ZSkKICAgICAsIG1fZGlzYWJsZWRSZWZDb3VudCgwKQogICAgICwgbV9pc01hcmtlZEZvckRl bGV0aW9uKGZhbHNlKQogICAgICwgbV9pc0Rpc2FibGVkKGZhbHNlKQorICAgICwgbV9pc1Byb2Nl c3NpbmdUYWlsKGZhbHNlKQogewogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAgICAg aWYgKCFzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQpIHsKQEAgLTE4MSwxMSArMTg2LDEyIEBAIHZv aWQgQXVkaW9Ob2RlOjpwcm9jZXNzSWZOZWNlc3Nhcnkoc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykK IAogICAgICAgICBpZiAoIWlucHV0c0FyZVNpbGVudCgpKQogICAgICAgICAgICAgbV9sYXN0Tm9u U2lsZW50VGltZSA9IChjb250ZXh0KCktPmN1cnJlbnRTYW1wbGVGcmFtZSgpICsgZnJhbWVzVG9Q cm9jZXNzKSAvIHN0YXRpY19jYXN0PGRvdWJsZT4obV9zYW1wbGVSYXRlKTsKLQorICAgICAgICAK ICAgICAgICAgcHVsbElucHV0cyhmcmFtZXNUb1Byb2Nlc3MpOwotICAgICAgICBpZiAoaW5wdXRz QXJlU2lsZW50KCkgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkKKyAgICAgICAgaWYgKGlucHV0c0Fy ZVNpbGVudCgpICYmIHByb3BhZ2F0ZXNTaWxlbmNlKCkpIHsKKyAgICAgICAgICAgIGVuZFRhaWxQ cm9jZXNzaW5nSWZOZWVkZWQoKTsKICAgICAgICAgICAgIHNpbGVuY2VPdXRwdXRzKCk7Ci0gICAg ICAgIGVsc2UgeworICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcHJvY2VzcyhmcmFtZXNU b1Byb2Nlc3MpOwogICAgICAgICAgICAgdW5zaWxlbmNlT3V0cHV0cygpOwogICAgICAgICB9CkBA IC0yMDUsNyArMjExLDcgQEAgdm9pZCBBdWRpb05vZGU6OmNoZWNrTnVtYmVyT2ZDaGFubmVsc0Zv cklucHV0KEF1ZGlvTm9kZUlucHV0KiBpbnB1dCkKIAogYm9vbCBBdWRpb05vZGU6OnByb3BhZ2F0 ZXNTaWxlbmNlKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbV9sYXN0Tm9uU2lsZW50VGltZSArIHRh aWxUaW1lKCkgPCBjb250ZXh0KCktPmN1cnJlbnRUaW1lKCk7CisgICAgcmV0dXJuIG1fbGFzdE5v blNpbGVudFRpbWUgKyBsYXRlbmN5VGltZSgpICsgdGFpbFRpbWUoKSA8IGNvbnRleHQoKS0+Y3Vy cmVudFRpbWUoKTsKIH0KIAogdm9pZCBBdWRpb05vZGU6OnB1bGxJbnB1dHMoc2l6ZV90IGZyYW1l c1RvUHJvY2VzcykKQEAgLTM1MCwyMCArMzU2LDU4IEBAIHZvaWQgQXVkaW9Ob2RlOjpmaW5pc2hE ZXJlZihSZWZUeXBlIHJlZlR5cGUpCiAgICAgICAgICAgICAgICAgLy8gQnV0IGludGVybmFsbHkg b3VyIG91dHB1dHMgc2hvdWxkIGJlIGRpc2FibGVkIGZyb20gdGhlIGlucHV0cyB0aGV5J3JlIGNv bm5lY3RlZCB0by4KICAgICAgICAgICAgICAgICAvLyBkaXNhYmxlKCkgY2FuIHJlY3Vyc2l2ZWx5 IGRlcmVmIGNvbm5lY3Rpb25zIChhbmQgY2FsbCBkaXNhYmxlKCkpIGRvd24gYSB3aG9sZSBjaGFp biBvZiBjb25uZWN0ZWQgbm9kZXMuCiAKLSAgICAgICAgICAgICAgICAvLyBGSVhNRTogd2Ugc3Bl Y2lhbCBjYXNlIHRoZSBjb252b2x2ZXIgYW5kIGRlbGF5IHNpbmNlIHRoZXkgaGF2ZSBhIHNpZ25p ZmljYW50IHRhaWwtdGltZSBhbmQgc2hvdWxkbid0IGJlIGRpc2Nvbm5lY3RlZCBzaW1wbHkKLSAg ICAgICAgICAgICAgICAvLyBiZWNhdXNlIHRoZXkgbm8gbG9uZ2VyIGhhdmUgYW55IGlucHV0IGNv bm5lY3Rpb25zLiAgVGhpcyBuZWVkcyB0byBiZSBoYW5kbGVkIG1vcmUgZ2VuZXJhbGx5IHdoZXJl IEF1ZGlvTm9kZXMgaGF2ZQotICAgICAgICAgICAgICAgIC8vIGEgdGFpbFRpbWUgYXR0cmlidXRl LiAgVGhlbiB0aGUgQXVkaW9Ob2RlIG9ubHkgbmVlZHMgdG8gcmVtYWluICJhY3RpdmUiIGZvciB0 YWlsVGltZSBzZWNvbmRzIGFmdGVyIHRoZXJlIGFyZSBubwotICAgICAgICAgICAgICAgIC8vIGxv bmdlciBhbnkgYWN0aXZlIGNvbm5lY3Rpb25zLgotICAgICAgICAgICAgICAgIGlmIChub2RlVHlw ZSgpICE9IE5vZGVUeXBlQ29udm9sdmVyICYmIG5vZGVUeXBlKCkgIT0gTm9kZVR5cGVEZWxheSkg ewotICAgICAgICAgICAgICAgICAgICBtX2lzRGlzYWJsZWQgPSB0cnVlOwotICAgICAgICAgICAg ICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9vdXRwdXRzLnNpemUoKTsgKytpKQot ICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0KGkpLT5kaXNhYmxlKCk7Ci0gICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgIG1faXNEaXNhYmxlZCA9IHRydWU7CisgICAgICAgICAg ICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fb3V0cHV0cy5zaXplKCk7ICsraSkKKyAg ICAgICAgICAgICAgICAgICAgb3V0cHV0KGkpLT5kaXNhYmxlKCk7CiAgICAgICAgICAgICB9CiAg ICAgICAgIH0KICAgICB9CiB9CiAKK3ZvaWQgQXVkaW9Ob2RlOjpiZWdpblRhaWxQcm9jZXNzaW5n SWZOZWVkZWQoKQoreworICAgIGlmICghaXNQcm9jZXNzaW5nVGFpbCgpICYmIChsYXRlbmN5VGlt ZSgpICsgdGFpbFRpbWUoKSA+IDApKSB7CisgICAgICAgIC8vIEVzdGFibGlzaCBhIHJlZiB0byBv dXJzZWx2ZXMgc28gd2UgZG9uJ3QgZ2V0IHJlbW92ZWQgd2hlbiB0aGUgaW5wdXRzIGdvIGF3YXku IFdlIGFyZSBub3cKKyAgICAgICAgLy8gcHJvY2Vzc2luZyB0aGUgdGFpbC4KKyNpZiBERUJVR19B VURJT05PREVfVEFJTAorICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIiVzOiAlcDogbm9kZSAlZDog dGltZSAlLjE1Z1xuIiwgX19GVU5DVElPTl9fLAorICAgICAgICAgICAgICAgIHRoaXMsIG5vZGVU eXBlKCksIGNvbnRleHQoKS0+Y3VycmVudFRpbWUoKSk7CisjZW5kaWYKKyAgICAgICAgbV9pc1By b2Nlc3NpbmdUYWlsID0gdHJ1ZTsKKyAgICAgICAgcmVmKFJlZlR5cGVDb25uZWN0aW9uKTsKKyAg ICB9Cit9CisKK3ZvaWQgQXVkaW9Ob2RlOjplbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkKK3sK KyAgICBBU1NFUlQocHJvcGFnYXRlc1NpbGVuY2UoKSk7CisgICAgCisgICAgaWYgKGlzUHJvY2Vz c2luZ1RhaWwoKSkgeworICAgICAgICAvLyBTdG9wIHRhaWwgcHJvY2Vzc2luZy4gSnVzdCBuZWVk IHRvIGRlcmVmIG91cnNlbHZlcywgYnV0IHdlIGNhbid0IGRvIHRoYXQgd2hpbGUgdGhlIGdyYXBo CisgICAgICAgIC8vIGlzIGJlaW5nIHJlbmRlcmVkLiBTY2hlZHVsZSB0aGUgZGVyZWYgdG8gaGFw cGVuIGR1cmluZyB0aGUgcG9zdC1yZW5kZXJpbmcgcGhhc2UuCisjaWYgREVCVUdfQVVESU9OT0RF X1RBSUwKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICIlczogJXA6IG5vZGUgJWQgdGltZSAlLjE1 Z1xuIiwKKyAgICAgICAgICAgICAgICBfX0ZVTkNUSU9OX18sIHRoaXMsIG5vZGVUeXBlKCksIGNv bnRleHQoKS0+Y3VycmVudFRpbWUoKSk7CisjZW5kaWYKKyAgICAgICAgbV9pc1Byb2Nlc3NpbmdU YWlsID0gZmFsc2U7CisgICAgICAgIGNvbnRleHQoKS0+YWRkRGVmZXJyZWRGaW5pc2hEZXJlZih0 aGlzLCBSZWZUeXBlQ29ubmVjdGlvbik7CisgICAgfQorfQorCit2b2lkIEF1ZGlvTm9kZTo6cmVz ZXRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkKK3sKKyAgICBpZiAoaXNQcm9jZXNzaW5nVGFpbCgp KSB7CisgICAgICAgIC8vIFN0b3AgdGFpbCBwcm9jZXNzaW5nLiBKdXN0IG5lZWQgdG8gZGVyZWYg b3Vyc2VsdmVzLgorI2lmIERFQlVHX0FVRElPTk9ERV9UQUlMCisgICAgICAgIGZwcmludGYoc3Rk ZXJyLCAiJXM6ICVwOiB0eXBlICVkOiBzdGF0ZSAlZCBjb3VudDogJWQgdGltZSAlLjE1Z1xuIiwK KyAgICAgICAgICAgICAgICBfX0ZVTkNUSU9OX18sIHRoaXMsIG5vZGVUeXBlKCksIG1faXNQcm9j ZXNzaW5nVGFpbCwKKyAgICAgICAgICAgICAgICBtX2Nvbm5lY3Rpb25SZWZDb3VudCwgY29udGV4 dCgpLT5jdXJyZW50VGltZSgpKTsKKyNlbmRpZgorICAgICAgICBtX2lzUHJvY2Vzc2luZ1RhaWwg PSBmYWxzZTsKKyAgICAgICAgZGVyZWYoUmVmVHlwZUNvbm5lY3Rpb24pOworICAgIH0KK30KKwog I2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAKIGJvb2wgQXVkaW9Ob2RlOjpzX2lzTm9k ZUNvdW50SW5pdGlhbGl6ZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3dl YmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Ob2RlLmgK aW5kZXggMzYyNThiOGE3MDk0NDYzYzliMjU5NzAyY2I3MjFkMjVmYWEyM2NjNy4uY2UxZmVkNmZl Y2RmOWI3YWQ4MDFjMWMxYjRkZDZmZTM2ZDM0N2U4ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVk aW9Ob2RlLmgKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAKICNk ZWZpbmUgREVCVUdfQVVESU9OT0RFX1JFRkVSRU5DRVMgMAorI2RlZmluZSBERUJVR19BVURJT05P REVfVEFJTCAwCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtMTUyLDYgKzE1MywyMCBAQCBw dWJsaWM6CiAgICAgdm9pZCBzaWxlbmNlT3V0cHV0cygpOwogICAgIHZvaWQgdW5zaWxlbmNlT3V0 cHV0cygpOwogCisgICAgYm9vbCBpc1Byb2Nlc3NpbmdUYWlsKCkgY29uc3QgeyByZXR1cm4gbV9p c1Byb2Nlc3NpbmdUYWlsOyB9CisKKyAgICAvLyBFbmFibGUgdGFpbCBwcm9jZXNzaW5nIGZvciBu b2RlcyB0aGF0IGhhdmUgdGFpbCBvciBsYXRlbmN5IHRpbWUuIFRoaXMgc2hvdWxkIGJlIGNhbGxl ZCB3aGVuCisgICAgLy8gb25lIGF0IGxlYXN0IGlucHV0IGlzIG91dHB1dHRpbmcgc2lsZW5jZS4g VGhpcyB3aWxsIGNyZWF0ZSBhbiBhZGRpdGlvbmFsIGNvbm5lY3Rpb24gcmVmIHRvCisgICAgLy8g b3Vyc2VsdmVzIHNvIHdlIGRvbid0IGdldCByZW1vdmVkIGZyb20gdGhlIGdyYXBoLgorICAgIHZv aWQgYmVnaW5UYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CisKKyAgICAvLyBJZiB3ZSdyZSBwcm9j ZXNzaW5nIHRoZSB0YWlsIGZvciB0aGlzIG5vZGUgYW5kIGFsbCBvdXRwdXRzIHNob3VsZCBiZSBw cm9wYWdhdGluZyBzaWxlbmNlLCB3ZQorICAgIC8vIGVuZCB0YWlsIHByb2Nlc3NpbmcuIFRoZSBj b25uZWN0aW9uIHJlZiB0byBvdXJzZWx2ZXMgd2lsbCBhbHNvIGJlIHJlbW92ZWQuCisgICAgdm9p ZCBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CisKKyAgICAvLyBJZiB3ZSdyZSBwcm9jZXNz aW5nIHRoZSB0YWlsLCBkZXJlZiBvdXJzZWx2ZXMsIGFuZCBkaXNhYmxlIHRhaWwgcHJvY2Vzc2lu Zy4KKyAgICB2b2lkIHJlc2V0VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCiBwcm90ZWN0ZWQ6 CiAgICAgLy8gSW5wdXRzIGFuZCBvdXRwdXRzIG11c3QgYmUgY3JlYXRlZCBiZWZvcmUgdGhlIEF1 ZGlvTm9kZSBpcyBpbml0aWFsaXplZC4KICAgICB2b2lkIGFkZElucHV0KFBhc3NPd25QdHI8QXVk aW9Ob2RlSW5wdXQ+KTsKQEAgLTE4MCw3ICsxOTUsOSBAQCBwcml2YXRlOgogICAgIAogICAgIGJv b2wgbV9pc01hcmtlZEZvckRlbGV0aW9uOwogICAgIGJvb2wgbV9pc0Rpc2FibGVkOwotICAgIAor CisgICAgYm9vbCBtX2lzUHJvY2Vzc2luZ1RhaWw7CisKICNpZiBERUJVR19BVURJT05PREVfUkVG RVJFTkNFUwogICAgIHN0YXRpYyBib29sIHNfaXNOb2RlQ291bnRJbml0aWFsaXplZDsKICAgICBz dGF0aWMgaW50IHNfbm9kZUNvdW50W05vZGVUeXBlRW5kXTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3dlYmF1 ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcAppbmRleCAzNzRmMjdhMTg3YTQzYWU3M2FhOGU0N2ZmNzhl ZGI2MzQxMmRiNDYzLi45NjEwY2NmMTc4NDM2NWNjODEzZGU4NTc0ZGY1Mzc0ZjBlNmJlNmE3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb05vZGVJbnB1dC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Ob2RlSW5wdXQuY3BwCkBAIC02Myw2ICs2 Myw4IEBAIHZvaWQgQXVkaW9Ob2RlSW5wdXQ6OmNvbm5lY3QoQXVkaW9Ob2RlT3V0cHV0KiBvdXRw dXQpCiAKICAgICAvLyBTb21ib2R5IGhhcyBqdXN0IGNvbm5lY3RlZCB0byB1cywgc28gY291bnQg aXQgYXMgYSByZWZlcmVuY2UuCiAgICAgbm9kZSgpLT5yZWYoQXVkaW9Ob2RlOjpSZWZUeXBlQ29u bmVjdGlvbik7CisgICAgLy8gVHVybiBvZmYgYW55IHRhaWwgcHJvY2Vzc2luZyBpbiBwcm9ncmVz cyBhbmQgZ28gYmFjayB0byBub3JtYWwgcHJvY2Vzc2luZy4KKyAgICBub2RlKCktPnJlc2V0VGFp bFByb2Nlc3NpbmdJZk5lZWRlZCgpOwogfQogCiB2b2lkIEF1ZGlvTm9kZUlucHV0OjpkaXNjb25u ZWN0KEF1ZGlvTm9kZU91dHB1dCogb3V0cHV0KQpAQCAtMTA4LDYgKzExMCw5IEBAIHZvaWQgQXVk aW9Ob2RlSW5wdXQ6OmRpc2FibGUoQXVkaW9Ob2RlT3V0cHV0KiBvdXRwdXQpCiAgICAgY2hhbmdl ZE91dHB1dHMoKTsKIAogICAgIG5vZGUoKS0+cmVmKEF1ZGlvTm9kZTo6UmVmVHlwZURpc2FibGVk KTsKKyAgICAvLyBJZiBhbiBpbnB1dCB0byBhIG5vZGUgaXMgZGlzYWJsZWQsIHdlIHdhbnQgdG8g ZW5hYmxlIHRhaWwgcHJvY2Vzc2luZyBmb3IgdGhlIG5vZGVzIHRoYXQgaGF2ZQorICAgIC8vIHRh aWwgb3IgbGF0ZW5jeSB0aW1lLgorICAgIG5vZGUoKS0+YmVnaW5UYWlsUHJvY2Vzc2luZ0lmTmVl ZGVkKCk7CiAgICAgbm9kZSgpLT5kZXJlZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsg Ly8gTm90ZTogaXQncyBpbXBvcnRhbnQgdG8gcmV0dXJuIGltbWVkaWF0ZWx5IGFmdGVyIGFsbCBk ZXJlZigpIGNhbGxzIHNpbmNlIHRoZSBub2RlIG1heSBiZSBkZWxldGVkLgogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwIGIvU291cmNl L1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcAppbmRleCAxMTA1NzczMjYwNDhh ZmYwOGFmOWU0ZTdmOTFiNzMzYjE4M2EyYWM3Li41NjQ5YTk4MjE1MDBlMzU3MmVlOGU3OTgzMGVh Zjg1ZDkwYzI3N2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb1Bh bm5lck5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9k ZS5jcHAKQEAgLTkxLDcgKzkxLDcgQEAgdm9pZCBBdWRpb1Bhbm5lck5vZGU6OnByb2Nlc3Moc2l6 ZV90IGZyYW1lc1RvUHJvY2VzcykKIHsKICAgICBBdWRpb0J1cyogZGVzdGluYXRpb24gPSBvdXRw dXQoMCktPmJ1cygpOwogCi0gICAgaWYgKCFpc0luaXRpYWxpemVkKCkgfHwgIWlucHV0KDApLT5p c0Nvbm5lY3RlZCgpIHx8ICFtX3Bhbm5lci5nZXQoKSkgeworICAgIGlmICghaXNJbml0aWFsaXpl ZCgpIHx8ICFtX3Bhbm5lci5nZXQoKSkgewogICAgICAgICBkZXN0aW5hdGlvbi0+emVybygpOwog ICAgICAgICByZXR1cm47CiAgICAgfQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8v cmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qcyBiL0xheW91dFRlc3RzL3dlYmF1ZGlv L3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMKaW5kZXggNDVkZDcyZmNhYWRiMjg0 N2Q5ZDJlNGI1OGNjMWI0YzA2YmE1Y2U5OS4uMmZhZDY4MGQwMDgyYjUzNTFhNWVmZThiYzk3ZjJj NzIxMTA2MGY3ZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25v dGUtZ3JhaW4tb24tdGVzdGluZy5qcworKysgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNvdXJj ZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5nLmpzCkBAIC0xLDExICsxLDUgQEAKIHZhciBzYW1wbGVS YXRlID0gNDQxMDAuMDsKIAotLy8gSFJURiBleHRyYSBmcmFtZXMuICBUaGlzIGlzIGEgbWFnaWMg Y29uc3RhbnQgY3VycmVudGx5IGluCi0vLyBBdWRpb0J1ZmZlclNvdXJjZU5vZGU6OnByb2Nlc3Mg dGhhdCBhbHdheXMgZXh0ZW5kcyB0aGUKLS8vIGR1cmF0aW9uIGJ5IHRoaXMgbnVtYmVyIG9mIHNh bXBsZXMuICBTZWUgYnVnIDc3MjI0Ci0vLyAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc3MjI0KS4KLXZhciBleHRyYUZyYW1lc0hSVEYgPSA1MTI7Ci0KIC8vIEhvdyBt YW55IGdyYWlucyB0byBwbGF5LgogdmFyIG51bWJlck9mVGVzdHMgPSAxMDA7CiAKQEAgLTEzLDkg KzcsOCBAQCB2YXIgbnVtYmVyT2ZUZXN0cyA9IDEwMDsKIHZhciBkdXJhdGlvbiA9IDAuMDE7CiAK IC8vIFRpbWUgc3RlcCBiZXR3ZWVuIHRoZSBzdGFydCBvZiBlYWNoIGdyYWluLiAgV2UgbmVlZCB0 byBhZGQgYSBsaXR0bGUKLS8vIGJpdCBvZiBzaWxlbmNlIHNvIHdlIGNhbiBkZXRlY3QgZ3JhaW4g Ym91bmRhcmllcyBhbmQgYWxzbyBhY2NvdW50Ci0vLyBmb3IgdGhlIGV4dHJhIGZyYW1lcyBmb3Ig SFJURi4KLXZhciB0aW1lU3RlcCA9IGR1cmF0aW9uICsgLjAwNSArIGV4dHJhRnJhbWVzSFJURiAv IHNhbXBsZVJhdGU7CisvLyBiaXQgb2Ygc2lsZW5jZSBzbyB3ZSBjYW4gZGV0ZWN0IGdyYWluIGJv dW5kYXJpZXMuCit2YXIgdGltZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDU7CiAKIC8vIFRpbWUgc3Rl cCBiZXR3ZWVuIHRoZSBzdGFydCBmb3IgZWFjaCBncmFpbi4KIHZhciBncmFpbk9mZnNldFN0ZXAg PSAwLjAwMTsKQEAgLTMwLDEwICsyMyw5IEBAIHZhciByZW5kZXJlZERhdGE7CiAvLyByZXR1cm5z IHRoZSBkZXNpcmVkIHZhbHVlIGF0IHNhbXBsZSBmcmFtZSBrLgogZnVuY3Rpb24gY3JlYXRlU2ln bmFsQnVmZmVyKGNvbnRleHQsIGYpIHsKIAotICAgIC8vIE1ha2Ugc3VyZSB0aGUgYnVmZmVyIGhh cyBlbm91Z2ggZGF0YSBmb3IgYWxsIG9mIHRoZSBwb3NzaWJsZQotICAgIC8vIGdyYWluIG9mZnNl dHMgYW5kIGR1cmF0aW9ucy4gIE5lZWQgdG8gaW5jbHVkZSB0aGUgZXh0cmEgZnJhbWVzCi0gICAg Ly8gZm9yIEhSVEYuICBUaGUgYWRkaXRpb25hbCAxIGlzIGZvciBhbnkgcm91bmQtb2ZmIGVycm9y cy4KLSAgICB2YXIgc2lnbmFsTGVuZ3RoID0gTWF0aC5mbG9vcigxICsgZXh0cmFGcmFtZXNIUlRG ICsgc2FtcGxlUmF0ZSAqIChudW1iZXJPZlRlc3RzICogZ3JhaW5PZmZzZXRTdGVwICsgZHVyYXRp b24pKTsKKyAgICAvLyBNYWtlIHN1cmUgdGhlIGJ1ZmZlciBoYXMgZW5vdWdoIGRhdGEgZm9yIGFs bCBvZiB0aGUgcG9zc2libGUgZ3JhaW4gb2Zmc2V0cyBhbmQgZHVyYXRpb25zLgorICAgIC8vIFRo ZSBhZGRpdGlvbmFsIDEgaXMgZm9yIGFueSByb3VuZC1vZmYgZXJyb3JzLgorICAgIHZhciBzaWdu YWxMZW5ndGggPSBNYXRoLmZsb29yKDEgKyBzYW1wbGVSYXRlICogKG51bWJlck9mVGVzdHMgKiBn cmFpbk9mZnNldFN0ZXAgKyBkdXJhdGlvbikpOwogCiAgICAgdmFyIGJ1ZmZlciA9IGNvbnRleHQu Y3JlYXRlQnVmZmVyKDIsIHNpZ25hbExlbmd0aCwgc2FtcGxlUmF0ZSk7CiAgICAgdmFyIGRhdGEg PSBidWZmZXIuZ2V0Q2hhbm5lbERhdGEoMCk7CkBAIC0xMzMsOSArMTI1LDggQEAgZnVuY3Rpb24g dmVyaWZ5U3RhcnRBbmRFbmRGcmFtZXMoc3RhcnRFbmRGcmFtZXMpIHsKICAgICAvLyBleHBlY3Rh dGlvbnMuCiAgICAgZm9yICh2YXIgayA9IDA7IGsgPCBzdGFydEZyYW1lcy5sZW5ndGg7ICsraykg ewogICAgICAgICB2YXIgZXhwZWN0ZWRTdGFydCA9IHRpbWVUb1NhbXBsZUZyYW1lKGsgKiB0aW1l U3RlcCwgc2FtcGxlUmF0ZSk7Ci0gICAgICAgIC8vIFRoZSBlbmQgcG9pbnQgaXMgdGhlIGR1cmF0 aW9uLCBwbHVzIHRoZSBleHRyYSBmcmFtZXMKLSAgICAgICAgLy8gZm9yIEhSVEYuCi0gICAgICAg IHZhciBleHBlY3RlZEVuZCA9IGV4dHJhRnJhbWVzSFJURiArIGV4cGVjdGVkU3RhcnQgKyBncmFp bkxlbmd0aEluU2FtcGxlRnJhbWVzKGsgKiBncmFpbk9mZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1w bGVSYXRlKTsKKyAgICAgICAgLy8gVGhlIGVuZCBwb2ludCBpcyB0aGUgZHVyYXRpb24KKyAgICAg ICAgdmFyIGV4cGVjdGVkRW5kID0gZXhwZWN0ZWRTdGFydCArIGdyYWluTGVuZ3RoSW5TYW1wbGVG cmFtZXMoayAqIGdyYWluT2Zmc2V0U3RlcCwgZHVyYXRpb24sIHNhbXBsZVJhdGUpOwogCiAgICAg ICAgIGlmIChzdGFydEZyYW1lc1trXSAhPSBleHBlY3RlZFN0YXJ0KSB7CiAgICAgICAgICAgICB0 ZXN0RmFpbGVkKCJQdWxzZSAiICsgayArICIgc3RhcnRlZCBhdCAiICsgc3RhcnRGcmFtZXNba10g KyAiIGJ1dCBleHBlY3RlZCBhdCAiICsgZXhwZWN0ZWRTdGFydCk7Cg== 136738 2012-04-11 13:24:48 -0700 2012-05-01 14:11:25 -0700 Patch bug-77224-20120411132447.patch text/plain 11398 rtoy U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzODU3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDExOWUwNDEyNjlhMDEx Y2JmNGE1MTczOWI2ODA2Y2QxM2VhNDNlZi4uNjZhM2M1ZTE0ZjJkNWY3NTA2MjNlYmE5YzJiZDAy OWEzY2JhZTQ0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTA0LTA1ICBSYXlt b25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5PbiBpcyB0b28g bG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcy MjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBub3Rl LWdyYWluLW9uIHRlc3QgdXBkYXRlZCB0byBzaG93IHRoZSBidWcgaGFzIGJlZW4gZml4ZWQuICBB bHNvCisgICAgICAgIHRyeSBvdXQgaHR0cDovL3N0YXRpYy5lY2hvbmVzdC5jb20vQm9oZW1pYW5S aGFwc2ljaG9yZC9pbmRleC5odG1sCisgICAgICAgIHdoaWNoIG5vIGxvbmdlciBoYXMgZ2xpdGNo ZXMuCisKKyAgICAgICAgKiB3ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6QXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5kZXJGcm9tQnVmZmVyKTog UmVtb3ZlIGV4dHJhIGZyYW1lcy4KKyAgICAgICAgTmV3IGZ1bmN0aW9ucyB0aGF0IGltcGxlbWVu dCB0YWlsIHByb2Nlc3NpbmcgdG8gZml4IG5vdGUtZ3JhaW4tb24gYnVnLgorICAgICAgICAqIHdl YmF1ZGlvL0F1ZGlvTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1ZGlv Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJ Zk5lZWRlZCk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5n SWZOZWVkZWQpOgorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvTm9kZS5oOgorICAgICAgICAoV2Vi Q29yZTo6QXVkaW9Ob2RlOjphbGxvd1RhaWxQcm9jZXNzaW5nKToKKworICAgICAgICBGaXggUGFu bmVyIG5vZGUgdG8gYWxsb3cgdGFpbCBwcm9jZXNzaW5nLgorICAgICAgICAqIHdlYmF1ZGlvL0F1 ZGlvUGFubmVyTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb1Bhbm5lck5vZGU6OnBy b2Nlc3MpOiBOZWVkIHRvIGNvbnRpbnVlIHByb2Nlc3NpbmcKKyAgICAgICAgZm9yIHRhaWwgdGlt ZSBldmVuIGlmIHRoZSBpbnB1dCBpcyBkaXNjb25uZWN0ZWQuCisKIDIwMTItMDQtMTEgIFN0ZXBo ZW4gQ2hlbm5leSAgPHNjaGVubmV5QGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaGFkb3cgdHJl ZSBUcmVlU2NvcGUgZGF0YSBpcyBub3QgcmVtb3ZlZCBieSBDb250YWluZXJOb2RlOjpyZW1vdmVB bGxDaGlsZHJlbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRp by9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCmluZGV4IDcyMTA1MWQzNDkxNTUzNTkxMTJhYTU3 ZWYxZmM1NTY1YTJhZDZhNDYuLjdjN2EyZmRiMjgyMzI4MmE1ZDA0NWViY2ZmOTY5ZTVjOTc1ODQ3 M2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZm ZXJTb3VyY2VOb2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1 ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKQEAgLTI0NCwxMSArMjQ0LDYgQEAgdm9pZCBBdWRpb0J1 ZmZlclNvdXJjZU5vZGU6OnJlbmRlckZyb21CdWZmZXIoQXVkaW9CdXMqIGJ1cywgdW5zaWduZWQg ZGVzdGluYXRpb24KICAgICAKICAgICB1bnNpZ25lZCBkZWx0YUZyYW1lcyA9IGVuZEZyYW1lIC0g c3RhcnRGcmFtZTsKICAgICAKLSAgICAvLyBUaGlzIGlzIGEgSEFDSyB0byBhbGxvdyBmb3IgSFJU RiB0YWlsLXRpbWUgLSBhdm9pZHMgZ2xpdGNoIGF0IGVuZC4KLSAgICAvLyBGSVhNRTogaW1wbGVt ZW50IHRhaWxUaW1lIGZvciBlYWNoIEF1ZGlvTm9kZSBmb3IgYSBtb3JlIGdlbmVyYWwgc29sdXRp b24gdG8gdGhpcyBwcm9ibGVtLgotICAgIGlmIChtX2lzR3JhaW4pCi0gICAgICAgIGVuZEZyYW1l ICs9IDUxMjsKLQogICAgIC8vIERvIHNvbWUgc2FuaXR5IGNoZWNraW5nLgogICAgIGlmIChzdGFy dEZyYW1lID49IGJ1ZmZlckxlbmd0aCkKICAgICAgICAgc3RhcnRGcmFtZSA9ICFidWZmZXJMZW5n dGggPyAwIDogYnVmZmVyTGVuZ3RoIC0gMTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2Vi YXVkaW8vQXVkaW9Ob2RlLmNwcAppbmRleCA4YWY5ZmM3MzQ0MTA5MzhmMmQzMWMxNjg1MmRlOTlk YzRmYTQ2ZjM3Li44N2UwMDI4YTc5OWI3Mjc3ODNjNGQ5MGY3ZGI4MzZkZDY1MGE5MWM2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCkBAIC01MCw2 ICs1MCw3IEBAIEF1ZGlvTm9kZTo6QXVkaW9Ob2RlKEF1ZGlvQ29udGV4dCogY29udGV4dCwgZmxv YXQgc2FtcGxlUmF0ZSkKICAgICAsIG1fZGlzYWJsZWRSZWZDb3VudCgwKQogICAgICwgbV9pc01h cmtlZEZvckRlbGV0aW9uKGZhbHNlKQogICAgICwgbV9pc0Rpc2FibGVkKGZhbHNlKQorICAgICwg bV9hbGxvd1RhaWxQcm9jZXNzaW5nKGZhbHNlKQogewogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZF UkVOQ0VTCiAgICAgaWYgKCFzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQpIHsKQEAgLTIxMCw5ICsy MTEsMTUgQEAgdm9pZCBBdWRpb05vZGU6OnByb2Nlc3NJZk5lY2Vzc2FyeShzaXplX3QgZnJhbWVz VG9Qcm9jZXNzKQogICAgICAgICBpZiAoIXNpbGVudElucHV0cykKICAgICAgICAgICAgIG1fbGFz dE5vblNpbGVudFRpbWUgPSAoY29udGV4dCgpLT5jdXJyZW50U2FtcGxlRnJhbWUoKSArIGZyYW1l c1RvUHJvY2VzcykgLyBzdGF0aWNfY2FzdDxkb3VibGU+KG1fc2FtcGxlUmF0ZSk7CiAKLSAgICAg ICAgaWYgKHNpbGVudElucHV0cyAmJiBwcm9wYWdhdGVzU2lsZW5jZSgpKQorICAgICAgICAvLyBB bGxvdyB0YWlsIHByb2Nlc3NpbmcuIEJ1dCB0YWlsIHByb2Nlc3NpbmcgZG9lc24ndCBhY3R1YWxs eSBiZWdpbiB1bnRpbCBhbGwgb2Ygb3VyCisgICAgICAgIC8vIGlucHV0cyBnbyBzaWxlbnQuCisg ICAgICAgIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCisgICAgICAgIGlmIChzaWxl bnRJbnB1dHMgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkgeworICAgICAgICAgICAgLy8gVGFpbCBw cm9jZXNzaW5nIGNhbiBlbmQgbm93IGJlY2F1c2Ugd2UgYXJlIHByb3BhZ2F0aW5nIHNpbGVuY2Uu CisgICAgICAgICAgICBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CiAgICAgICAgICAgICBz aWxlbmNlT3V0cHV0cygpOwotICAgICAgICBlbHNlIHsKKyAgICAgICAgfSBlbHNlIHsKICAgICAg ICAgICAgIHByb2Nlc3MoZnJhbWVzVG9Qcm9jZXNzKTsKICAgICAgICAgICAgIHVuc2lsZW5jZU91 dHB1dHMoKTsKICAgICAgICAgfQpAQCAtMzc3LDIwICszODQsMzcgQEAgdm9pZCBBdWRpb05vZGU6 OmZpbmlzaERlcmVmKFJlZlR5cGUgcmVmVHlwZSkKICAgICAgICAgICAgICAgICAvLyBCdXQgaW50 ZXJuYWxseSBvdXIgb3V0cHV0cyBzaG91bGQgYmUgZGlzYWJsZWQgZnJvbSB0aGUgaW5wdXRzIHRo ZXkncmUgY29ubmVjdGVkIHRvLgogICAgICAgICAgICAgICAgIC8vIGRpc2FibGUoKSBjYW4gcmVj dXJzaXZlbHkgZGVyZWYgY29ubmVjdGlvbnMgKGFuZCBjYWxsIGRpc2FibGUoKSkgZG93biBhIHdo b2xlIGNoYWluIG9mIGNvbm5lY3RlZCBub2Rlcy4KIAotICAgICAgICAgICAgICAgIC8vIEZJWE1F OiB3ZSBzcGVjaWFsIGNhc2UgdGhlIGNvbnZvbHZlciBhbmQgZGVsYXkgc2luY2UgdGhleSBoYXZl IGEgc2lnbmlmaWNhbnQgdGFpbC10aW1lIGFuZCBzaG91bGRuJ3QgYmUgZGlzY29ubmVjdGVkIHNp bXBseQotICAgICAgICAgICAgICAgIC8vIGJlY2F1c2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkg aW5wdXQgY29ubmVjdGlvbnMuICBUaGlzIG5lZWRzIHRvIGJlIGhhbmRsZWQgbW9yZSBnZW5lcmFs bHkgd2hlcmUgQXVkaW9Ob2RlcyBoYXZlCi0gICAgICAgICAgICAgICAgLy8gYSB0YWlsVGltZSBh dHRyaWJ1dGUuICBUaGVuIHRoZSBBdWRpb05vZGUgb25seSBuZWVkcyB0byByZW1haW4gImFjdGl2 ZSIgZm9yIHRhaWxUaW1lIHNlY29uZHMgYWZ0ZXIgdGhlcmUgYXJlIG5vCi0gICAgICAgICAgICAg ICAgLy8gbG9uZ2VyIGFueSBhY3RpdmUgY29ubmVjdGlvbnMuCi0gICAgICAgICAgICAgICAgaWYg KG5vZGVUeXBlKCkgIT0gTm9kZVR5cGVDb252b2x2ZXIgJiYgbm9kZVR5cGUoKSAhPSBOb2RlVHlw ZURlbGF5KSB7Ci0gICAgICAgICAgICAgICAgICAgIG1faXNEaXNhYmxlZCA9IHRydWU7Ci0gICAg ICAgICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBtX291dHB1dHMuc2l6ZSgp OyArK2kpCi0gICAgICAgICAgICAgICAgICAgICAgICBvdXRwdXQoaSktPmRpc2FibGUoKTsKLSAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbV9pc0Rpc2FibGVkID0gdHJ1ZTsKKyAg ICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9vdXRwdXRzLnNpemUoKTsg KytpKQorICAgICAgICAgICAgICAgICAgICBvdXRwdXQoaSktPmRpc2FibGUoKTsKICAgICAgICAg ICAgIH0KICAgICAgICAgfQogICAgIH0KIH0KIAordm9pZCBBdWRpb05vZGU6OmFsbG93VGFpbFBy b2Nlc3NpbmdJZk5lZWRlZCgpCit7CisgICAgaWYgKCFhbGxvd1RhaWxQcm9jZXNzaW5nKCkgJiYg KGxhdGVuY3lUaW1lKCkgKyB0YWlsVGltZSgpID4gMCkpIHsKKyAgICAgICAgLy8gRXN0YWJsaXNo IGEgcmVmIHRvIG91cnNlbHZlcyBpZiB3ZSBoYXZlbid0IGFscmVhZHkgc28gd2UgZG9uJ3QgZ2V0 IHJlbW92ZWQgd2hlbiBhbGwgbm9kZXMKKyAgICAgICAgLy8gaGF2ZSBkaXNjb25uZWN0ZWQgZnJv bSB1cy4gV2UgY2FuIHByb2Nlc3MgdGhlIHRhaWwsIGJ1dCB0aGF0IGRvZXMgbm90IGltcGx5IHdl IGFyZQorICAgICAgICAvLyBhY3R1YWxseSBwcm9jZXNzaW5nIHRoZSB0YWlsLiBUaGF0IGhhcHBl bnMgd2hlbiBhbGwgb2YgdGhlIGlucHV0cyBiZWNvbWUgc2lsZW50LgorICAgICAgICBtX2FsbG93 VGFpbFByb2Nlc3NpbmcgPSB0cnVlOworICAgICAgICByZWYoUmVmVHlwZUNvbm5lY3Rpb24pOwor ICAgIH0KK30KKwordm9pZCBBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKQor eworICAgIEFTU0VSVChwcm9wYWdhdGVzU2lsZW5jZSgpKTsKKyAgICAKKyAgICBpZiAoYWxsb3dU YWlsUHJvY2Vzc2luZygpKSB7CisgICAgICAgIC8vIFN0b3AgdGFpbCBwcm9jZXNzaW5nLiBKdXN0 IG5lZWQgdG8gZGVyZWYgb3Vyc2VsdmVzLCBidXQgd2UgY2FuJ3QgZG8gdGhhdCB3aGlsZSB0aGUg Z3JhcGgKKyAgICAgICAgLy8gaXMgYmVpbmcgcmVuZGVyZWQuIFNjaGVkdWxlIHRoZSBkZXJlZiB0 byBoYXBwZW4gZHVyaW5nIHRoZSBwb3N0LXJlbmRlcmluZyBwaGFzZS4KKyAgICAgICAgbV9hbGxv d1RhaWxQcm9jZXNzaW5nID0gZmFsc2U7CisgICAgICAgIGNvbnRleHQoKS0+YWRkRGVmZXJyZWRG aW5pc2hEZXJlZih0aGlzLCBSZWZUeXBlQ29ubmVjdGlvbik7CisgICAgfQorfQorCiAjaWYgREVC VUdfQVVESU9OT0RFX1JFRkVSRU5DRVMKIAogYm9vbCBBdWRpb05vZGU6OnNfaXNOb2RlQ291bnRJ bml0aWFsaXplZCA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9BdWRpb05vZGUuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVk aW9Ob2RlLmgKaW5kZXggYzI2MTRjYjNiMTJkNmQxNTUwZmRmNzRmODQ4OGU0MWY0NWY5Y2RhMi4u ZjA1ZDI0OWQ2ZDJhZGEzNTY2MDE3MjVhZjgwZTgxZTcxNmVjMzQ1MyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCkBAIC0xNTMsNiArMTUzLDE3IEBAIHB1 YmxpYzoKICAgICB2b2lkIHNpbGVuY2VPdXRwdXRzKCk7CiAgICAgdm9pZCB1bnNpbGVuY2VPdXRw dXRzKCk7CiAKKyAgICBib29sIGFsbG93VGFpbFByb2Nlc3NpbmcoKSBjb25zdCB7IHJldHVybiBt X2FsbG93VGFpbFByb2Nlc3Npbmc7IH0KKworICAgIC8vIEFsbG93IHRhaWwgcHJvY2Vzc2luZyBm b3Igbm9kZXMgdGhhdCBoYXZlIHRhaWwgb3IgbGF0ZW5jeSB0aW1lLiBUaGlzIHdpbGwgY3JlYXRl IGFuCisgICAgLy8gYWRkaXRpb25hbCBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWx2ZXMgc28gd2Ug ZG9uJ3QgZ2V0IHJlbW92ZWQgZnJvbSB0aGUgZ3JhcGggYmVmb3JlIHRoZSB0YWlsCisgICAgLy8g aGFzIGJlZW4gcHJvY2Vzc2VkLgorICAgIHZvaWQgYWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVk KCk7CisKKyAgICAvLyBJZiB3ZSdyZSBwcm9jZXNzaW5nIHRoZSB0YWlsIGZvciB0aGlzIG5vZGUg YW5kIGFsbCBvdXRwdXRzIHNob3VsZCBiZSBwcm9wYWdhdGluZyBzaWxlbmNlLCB3ZQorICAgIC8v IGVuZCB0YWlsIHByb2Nlc3NpbmcuIFRoZSBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWx2ZXMgd2ls bCBhbHNvIGJlIHJlbW92ZWQuCisgICAgdm9pZCBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7 CisKIHByb3RlY3RlZDoKICAgICAvLyBJbnB1dHMgYW5kIG91dHB1dHMgbXVzdCBiZSBjcmVhdGVk IGJlZm9yZSB0aGUgQXVkaW9Ob2RlIGlzIGluaXRpYWxpemVkLgogICAgIHZvaWQgYWRkSW5wdXQo UGFzc093blB0cjxBdWRpb05vZGVJbnB1dD4pOwpAQCAtMTgxLDcgKzE5Miw5IEBAIHByaXZhdGU6 CiAgICAgCiAgICAgYm9vbCBtX2lzTWFya2VkRm9yRGVsZXRpb247CiAgICAgYm9vbCBtX2lzRGlz YWJsZWQ7Ci0gICAgCisKKyAgICBib29sIG1fYWxsb3dUYWlsUHJvY2Vzc2luZzsKKwogI2lmIERF QlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAgICAgc3RhdGljIGJvb2wgc19pc05vZGVDb3VudElu aXRpYWxpemVkOwogICAgIHN0YXRpYyBpbnQgc19ub2RlQ291bnRbTm9kZVR5cGVFbmRdOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUu Y3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3Bw CmluZGV4IDExMDU3NzMyNjA0OGFmZjA4YWY5ZTRlN2Y5MWI3MzNiMTgzYTJhYzcuLjU2NDlhOTgy MTUwMGUzNTcyZWU4ZTc5ODMwZWFmODVkOTBjMjc3ZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKQEAgLTkxLDcgKzkxLDcg QEAgdm9pZCBBdWRpb1Bhbm5lck5vZGU6OnByb2Nlc3Moc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykK IHsKICAgICBBdWRpb0J1cyogZGVzdGluYXRpb24gPSBvdXRwdXQoMCktPmJ1cygpOwogCi0gICAg aWYgKCFpc0luaXRpYWxpemVkKCkgfHwgIWlucHV0KDApLT5pc0Nvbm5lY3RlZCgpIHx8ICFtX3Bh bm5lci5nZXQoKSkgeworICAgIGlmICghaXNJbml0aWFsaXplZCgpIHx8ICFtX3Bhbm5lci5nZXQo KSkgewogICAgICAgICBkZXN0aW5hdGlvbi0+emVybygpOwogICAgICAgICByZXR1cm47CiAgICAg fQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCmluZGV4IDZjNjdkYjQ2ZjFkYzI5ZDZiNmQzMDM5YjQ3MzQ0MGU4N2QwY2EzMjAuLjM3YTZk MzBhODBmZTE0ZGYyMzJmOWE4NWY4MDBmOTY5MzU0NzZlMWYgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBA QAorMjAxMi0wNC0xMSAgUmF5bW9uZCBUb3kgIDxydG95QGdvb2dsZS5jb20+CisKKyAgICAgICAg bm90ZUdyYWluT24gaXMgdG9vIGxvbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTc3MjI0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgUmVtb3ZlIGV4dHJhRnJhbWVzSFJURiB0aGF0IGlzIG5vIGxvbmdlciBu ZWVkZWQ6CisgICAgICAgICogd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGlu Zy5qczoKKyAgICAgICAgKGNyZWF0ZVNpZ25hbEJ1ZmZlcik6IAorICAgICAgICAodmVyaWZ5U3Rh cnRBbmRFbmRGcmFtZXMpOgorCiAyMDEyLTA0LTExICBTdGVwaGVuIENoZW5uZXkgIDxzY2hlbm5l eUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgc3ZnL3RleHQvc3ZnLXpvb20tbGFyZ2UtdmFsdWUu eGh0bWwgQVNTRVJUcyBvbiBDaHJvbWl1bSBMaW51eCBEZWJ1ZwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qcyBiL0xheW91 dFRlc3RzL3dlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMKaW5kZXgg NDVkZDcyZmNhYWRiMjg0N2Q5ZDJlNGI1OGNjMWI0YzA2YmE1Y2U5OS4uMmZhZDY4MGQwMDgyYjUz NTFhNWVmZThiYzk3ZjJjNzIxMTA2MGY3ZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVk aW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qcworKysgYi9MYXlvdXRUZXN0cy93 ZWJhdWRpby9yZXNvdXJjZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5nLmpzCkBAIC0xLDExICsxLDUg QEAKIHZhciBzYW1wbGVSYXRlID0gNDQxMDAuMDsKIAotLy8gSFJURiBleHRyYSBmcmFtZXMuICBU aGlzIGlzIGEgbWFnaWMgY29uc3RhbnQgY3VycmVudGx5IGluCi0vLyBBdWRpb0J1ZmZlclNvdXJj ZU5vZGU6OnByb2Nlc3MgdGhhdCBhbHdheXMgZXh0ZW5kcyB0aGUKLS8vIGR1cmF0aW9uIGJ5IHRo aXMgbnVtYmVyIG9mIHNhbXBsZXMuICBTZWUgYnVnIDc3MjI0Ci0vLyAoaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MjI0KS4KLXZhciBleHRyYUZyYW1lc0hSVEYgPSA1 MTI7Ci0KIC8vIEhvdyBtYW55IGdyYWlucyB0byBwbGF5LgogdmFyIG51bWJlck9mVGVzdHMgPSAx MDA7CiAKQEAgLTEzLDkgKzcsOCBAQCB2YXIgbnVtYmVyT2ZUZXN0cyA9IDEwMDsKIHZhciBkdXJh dGlvbiA9IDAuMDE7CiAKIC8vIFRpbWUgc3RlcCBiZXR3ZWVuIHRoZSBzdGFydCBvZiBlYWNoIGdy YWluLiAgV2UgbmVlZCB0byBhZGQgYSBsaXR0bGUKLS8vIGJpdCBvZiBzaWxlbmNlIHNvIHdlIGNh biBkZXRlY3QgZ3JhaW4gYm91bmRhcmllcyBhbmQgYWxzbyBhY2NvdW50Ci0vLyBmb3IgdGhlIGV4 dHJhIGZyYW1lcyBmb3IgSFJURi4KLXZhciB0aW1lU3RlcCA9IGR1cmF0aW9uICsgLjAwNSArIGV4 dHJhRnJhbWVzSFJURiAvIHNhbXBsZVJhdGU7CisvLyBiaXQgb2Ygc2lsZW5jZSBzbyB3ZSBjYW4g ZGV0ZWN0IGdyYWluIGJvdW5kYXJpZXMuCit2YXIgdGltZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDU7 CiAKIC8vIFRpbWUgc3RlcCBiZXR3ZWVuIHRoZSBzdGFydCBmb3IgZWFjaCBncmFpbi4KIHZhciBn cmFpbk9mZnNldFN0ZXAgPSAwLjAwMTsKQEAgLTMwLDEwICsyMyw5IEBAIHZhciByZW5kZXJlZERh dGE7CiAvLyByZXR1cm5zIHRoZSBkZXNpcmVkIHZhbHVlIGF0IHNhbXBsZSBmcmFtZSBrLgogZnVu Y3Rpb24gY3JlYXRlU2lnbmFsQnVmZmVyKGNvbnRleHQsIGYpIHsKIAotICAgIC8vIE1ha2Ugc3Vy ZSB0aGUgYnVmZmVyIGhhcyBlbm91Z2ggZGF0YSBmb3IgYWxsIG9mIHRoZSBwb3NzaWJsZQotICAg IC8vIGdyYWluIG9mZnNldHMgYW5kIGR1cmF0aW9ucy4gIE5lZWQgdG8gaW5jbHVkZSB0aGUgZXh0 cmEgZnJhbWVzCi0gICAgLy8gZm9yIEhSVEYuICBUaGUgYWRkaXRpb25hbCAxIGlzIGZvciBhbnkg cm91bmQtb2ZmIGVycm9ycy4KLSAgICB2YXIgc2lnbmFsTGVuZ3RoID0gTWF0aC5mbG9vcigxICsg ZXh0cmFGcmFtZXNIUlRGICsgc2FtcGxlUmF0ZSAqIChudW1iZXJPZlRlc3RzICogZ3JhaW5PZmZz ZXRTdGVwICsgZHVyYXRpb24pKTsKKyAgICAvLyBNYWtlIHN1cmUgdGhlIGJ1ZmZlciBoYXMgZW5v dWdoIGRhdGEgZm9yIGFsbCBvZiB0aGUgcG9zc2libGUgZ3JhaW4gb2Zmc2V0cyBhbmQgZHVyYXRp b25zLgorICAgIC8vIFRoZSBhZGRpdGlvbmFsIDEgaXMgZm9yIGFueSByb3VuZC1vZmYgZXJyb3Jz LgorICAgIHZhciBzaWduYWxMZW5ndGggPSBNYXRoLmZsb29yKDEgKyBzYW1wbGVSYXRlICogKG51 bWJlck9mVGVzdHMgKiBncmFpbk9mZnNldFN0ZXAgKyBkdXJhdGlvbikpOwogCiAgICAgdmFyIGJ1 ZmZlciA9IGNvbnRleHQuY3JlYXRlQnVmZmVyKDIsIHNpZ25hbExlbmd0aCwgc2FtcGxlUmF0ZSk7 CiAgICAgdmFyIGRhdGEgPSBidWZmZXIuZ2V0Q2hhbm5lbERhdGEoMCk7CkBAIC0xMzMsOSArMTI1 LDggQEAgZnVuY3Rpb24gdmVyaWZ5U3RhcnRBbmRFbmRGcmFtZXMoc3RhcnRFbmRGcmFtZXMpIHsK ICAgICAvLyBleHBlY3RhdGlvbnMuCiAgICAgZm9yICh2YXIgayA9IDA7IGsgPCBzdGFydEZyYW1l cy5sZW5ndGg7ICsraykgewogICAgICAgICB2YXIgZXhwZWN0ZWRTdGFydCA9IHRpbWVUb1NhbXBs ZUZyYW1lKGsgKiB0aW1lU3RlcCwgc2FtcGxlUmF0ZSk7Ci0gICAgICAgIC8vIFRoZSBlbmQgcG9p bnQgaXMgdGhlIGR1cmF0aW9uLCBwbHVzIHRoZSBleHRyYSBmcmFtZXMKLSAgICAgICAgLy8gZm9y IEhSVEYuCi0gICAgICAgIHZhciBleHBlY3RlZEVuZCA9IGV4dHJhRnJhbWVzSFJURiArIGV4cGVj dGVkU3RhcnQgKyBncmFpbkxlbmd0aEluU2FtcGxlRnJhbWVzKGsgKiBncmFpbk9mZnNldFN0ZXAs IGR1cmF0aW9uLCBzYW1wbGVSYXRlKTsKKyAgICAgICAgLy8gVGhlIGVuZCBwb2ludCBpcyB0aGUg ZHVyYXRpb24KKyAgICAgICAgdmFyIGV4cGVjdGVkRW5kID0gZXhwZWN0ZWRTdGFydCArIGdyYWlu TGVuZ3RoSW5TYW1wbGVGcmFtZXMoayAqIGdyYWluT2Zmc2V0U3RlcCwgZHVyYXRpb24sIHNhbXBs ZVJhdGUpOwogCiAgICAgICAgIGlmIChzdGFydEZyYW1lc1trXSAhPSBleHBlY3RlZFN0YXJ0KSB7 CiAgICAgICAgICAgICB0ZXN0RmFpbGVkKCJQdWxzZSAiICsgayArICIgc3RhcnRlZCBhdCAiICsg c3RhcnRGcmFtZXNba10gKyAiIGJ1dCBleHBlY3RlZCBhdCAiICsgZXhwZWN0ZWRTdGFydCk7Cg== 139673 2012-05-01 14:03:12 -0700 2012-05-01 14:12:39 -0700 Patch bug-77224-20120501140310.patch text/plain 19745 rtoy U3VidmVyc2lvbiBSZXZpc2lvbjogMTE1NjIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjg3MDI0MzIxYmJlYjRj YTNlM2VmY2Y1Y2E4Yjc0OTU2YTRhNzkzOS4uMTc2NzEyMjRiMjM5ZTg5MGVhZGJmMTc5NWFmZjAw MWMwMjRiZGEzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA0LTA1ICBSYXlt b25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5PbiBpcyB0b28g bG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcy MjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBub3Rl LWdyYWluLW9uIHRlc3QgdXBkYXRlZCB0byBzaG93IHRoZSBidWcgaGFzIGJlZW4gZml4ZWQuICBB bHNvCisgICAgICAgIHRyeSBvdXQgaHR0cDovL3N0YXRpYy5lY2hvbmVzdC5jb20vQm9oZW1pYW5S aGFwc2ljaG9yZC9pbmRleC5odG1sCisgICAgICAgIHdoaWNoIG5vIGxvbmdlciBoYXMgZ2xpdGNo ZXMgYW5kCisgICAgICAgIGh0dHA6Ly9jaHJvbWl1bS5nb29nbGVjb2RlLmNvbS9zdm4vdHJ1bmsv c2FtcGxlcy9hdWRpby9ncmFudWxhci5odG1sCisgICAgICAgIHdoaWNoIHN0aWxsIHNvdW5kcyBn b29kLgorCisgICAgICAgICogd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcik6 IFJlbW92ZSBleHRyYSBmcmFtZXMuCisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBpbXBsZW1l bnQgdGFpbCBwcm9jZXNzaW5nIHRvIGZpeCBub3RlLWdyYWluLW9uIGJ1Zy4KKyAgICAgICAgKiB3 ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjph ZGREZWZlcnJlZFJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVE ZWZlcnJlZFJlZk5vZGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6YWRkRGVmZXJy ZWREZXJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVEZWZlcnJl ZERlcmVmTm9kZXMpOgorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oOiBEZWNsYXJh dGlvbnMgb2YgbmV3IGZ1bmN0aW9ucyBhbmQgc2xvdHMKKyAgICAgICAgdG8gc3VwcG9ydCB0YWls IHByb2Nlc3NpbmcuCisgICAgICAgIAorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1ZGlvTm9kZSk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgorCisgICAgICAg IEZpeCBQYW5uZXIgbm9kZSB0byBhbGxvdyB0YWlsIHByb2Nlc3NpbmcuCisgICAgICAgICogd2Vi YXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFubmVy Tm9kZTo6cHJvY2Vzcyk6IE5lZWQgdG8gY29udGludWUgcHJvY2Vzc2luZworICAgICAgICBmb3Ig dGFpbCB0aW1lIGV2ZW4gaWYgdGhlIGlucHV0IGlzIGRpc2Nvbm5lY3RlZC4KKwogMjAxMi0wNC0y OSAgS2Vpc2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KIAogICAgICAgICBCdWlsZCBm aXggZm9yIExvY2FsaXplZERhdGVNYWMubW0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcAppbmRleCA0M2E5Y2I0 OGFjNWY0MTRjZmQ5YTg1MjBjYjg0Y2JiZjZjNTZlYjU3Li40OTQ3NzJkZDQ5NWE3MWExZjhkYjE4 MTJhMmY5YTEyZTg3M2I1OTMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCkBAIC0yMzMsMTEgKzIzMyw2 IEBAIHZvaWQgQXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5kZXJGcm9tQnVmZmVyKEF1ZGlvQnVz KiBidXMsIHVuc2lnbmVkIGRlc3RpbmF0aW9uCiAgICAgCiAgICAgdW5zaWduZWQgZGVsdGFGcmFt ZXMgPSBlbmRGcmFtZSAtIHN0YXJ0RnJhbWU7CiAgICAgCi0gICAgLy8gVGhpcyBpcyBhIEhBQ0sg dG8gYWxsb3cgZm9yIEhSVEYgdGFpbC10aW1lIC0gYXZvaWRzIGdsaXRjaCBhdCBlbmQuCi0gICAg Ly8gRklYTUU6IGltcGxlbWVudCB0YWlsVGltZSBmb3IgZWFjaCBBdWRpb05vZGUgZm9yIGEgbW9y ZSBnZW5lcmFsIHNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbS4KLSAgICBpZiAobV9pc0dyYWluKQot ICAgICAgICBlbmRGcmFtZSArPSA1MTI7Ci0KICAgICAvLyBEbyBzb21lIHNhbml0eSBjaGVja2lu Zy4KICAgICBpZiAoc3RhcnRGcmFtZSA+PSBidWZmZXJMZW5ndGgpCiAgICAgICAgIHN0YXJ0RnJh bWUgPSAhYnVmZmVyTGVuZ3RoID8gMCA6IGJ1ZmZlckxlbmd0aCAtIDE7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAKaW5kZXggZjc4OTA1YmU2 N2E3MTAzYjVkNTFjYWM2YWFkZDc2NDFhMzBiNzdkMC4uZmI0Yzc2MWYxYTI0MTQwNmJhYzVhMGZm MGIwYTI4ZTQ2Y2I2ODg2MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJh dWRpby9BdWRpb0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVk aW8vQXVkaW9Db250ZXh0LmNwcApAQCAtMTk0LDcgKzE5NCw3IEBAIHZvaWQgQXVkaW9Db250ZXh0 Ojpjb25zdHJ1Y3RDb21tb24oKQogQXVkaW9Db250ZXh0Ojp+QXVkaW9Db250ZXh0KCkKIHsKICNp ZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwotICAgIHByaW50ZigiJXA6IEF1ZGlvQ29udGV4 dDo6fkF1ZGlvQ29udGV4dCgpXG4iLCB0aGlzKTsKKyAgICBmcHJpbnRmKHN0ZGVyciwgIkF1ZGlv Q29udGV4dDo6fkF1ZGlvQ29udGV4dCgpOiAlcFxuIiwgdGhpcyk7CiAjZW5kaWYKICAgICAvLyBB dWRpb05vZGVzIGtlZXAgYSByZWZlcmVuY2UgdG8gdGhlaXIgY29udGV4dCwgc28gdGhlcmUgc2hv dWxkIGJlIG5vIHdheSB0byBiZSBpbiB0aGUgZGVzdHJ1Y3RvciBpZiB0aGVyZSBhcmUgc3RpbGwg QXVkaW9Ob2RlcyBhcm91bmQuCiAgICAgQVNTRVJUKCFtX25vZGVzVG9EZWxldGUuc2l6ZSgpKTsK QEAgLTU0Niw3ICs1NDYsNyBAQCB2b2lkIEF1ZGlvQ29udGV4dDo6ZGVyZWZGaW5pc2hlZFNvdXJj ZU5vZGVzKCkKIAogdm9pZCBBdWRpb0NvbnRleHQ6OnJlZk5vZGUoQXVkaW9Ob2RlKiBub2RlKQog ewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgp IHx8IChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpKTsKICAgICBBdXRvTG9ja2Vy IGxvY2tlcih0aGlzKTsKICAgICAKICAgICBub2RlLT5yZWYoQXVkaW9Ob2RlOjpSZWZUeXBlQ29u bmVjdGlvbik7CkBAIC01NzksNyArNTc5LDcgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmRlcmVmVW5m aW5pc2hlZFNvdXJjZU5vZGVzKCkKIHZvaWQgQXVkaW9Db250ZXh0Ojpsb2NrKGJvb2wmIG11c3RS ZWxlYXNlTG9jaykKIHsKICAgICAvLyBEb24ndCBhbGxvdyByZWd1bGFyIGxvY2sgaW4gcmVhbC10 aW1lIGF1ZGlvIHRocmVhZC4KLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VS VChpc01haW5UaHJlYWQoKSB8fCAoaXNBdWRpb1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKSk7 CiAKICAgICBUaHJlYWRJZGVudGlmaWVyIHRoaXNUaHJlYWQgPSBjdXJyZW50VGhyZWFkKCk7CiAK QEAgLTY0NSw2ICs2NDUsMTggQEAgYm9vbCBBdWRpb0NvbnRleHQ6OmlzR3JhcGhPd25lcigpIGNv bnN0CiAgICAgcmV0dXJuIGN1cnJlbnRUaHJlYWQoKSA9PSBtX2dyYXBoT3duZXJUaHJlYWQ7CiB9 CiAKK3ZvaWQgQXVkaW9Db250ZXh0OjphZGREZWZlcnJlZFJlZk5vZGUoQXVkaW9Ob2RlKiBub2Rl KQoreworICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkpOworICAgIG1fZGVmZXJyZWRSZWZMaXN0 LmFwcGVuZChub2RlKTsKK30KKwordm9pZCBBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRGVyZWZO b2RlKEF1ZGlvTm9kZSogbm9kZSkKK3sKKyAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKKyAg ICBtX2RlZmVycmVkRGVyZWZMaXN0LmFwcGVuZChub2RlKTsKK30KKwogdm9pZCBBdWRpb0NvbnRl eHQ6OmFkZERlZmVycmVkRmluaXNoRGVyZWYoQXVkaW9Ob2RlKiBub2RlLCBBdWRpb05vZGU6OlJl ZlR5cGUgcmVmVHlwZSkKIHsKICAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKQEAgLTY3Nyw2 ICs2ODksMTAgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RSZW5kZXJUYXNrcygpCiAg ICAgLy8gZnJvbSB0aGUgcmVuZGVyIGdyYXBoIChpbiB3aGljaCBjYXNlIHRoZXknbGwgcmVuZGVy IHNpbGVuY2UpLgogICAgIGJvb2wgbXVzdFJlbGVhc2VMb2NrOwogICAgIGlmICh0cnlMb2NrKG11 c3RSZWxlYXNlTG9jaykpIHsKKyAgICAgICAgLy8gVGFrZSBjYXJlIG9mIGFueSBkZWZlcnJlZCBy ZWZOb2RlcyBhbmQgZGVmZXJyZWQgZGVyZWZOb2RlcyB0aGF0IHdlcmUgYWRkZWQuCisgICAgICAg IGhhbmRsZURlZmVycmVkUmVmTm9kZXMoKTsKKyAgICAgICAgaGFuZGxlRGVmZXJyZWREZXJlZk5v ZGVzKCk7CisgICAgICAgIAogICAgICAgICAvLyBUYWtlIGNhcmUgb2YgZmluaXNoaW5nIGFueSBk ZXJlZnMgd2hlcmUgdGhlIHRyeUxvY2soKSBmYWlsZWQgcHJldmlvdXNseS4KICAgICAgICAgaGFu ZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKTsKIApAQCAtNjk2LDYgKzcxMiw0MSBAQCB2b2lkIEF1 ZGlvQ29udGV4dDo6aGFuZGxlUG9zdFJlbmRlclRhc2tzKCkKICAgICB9CiB9CiAKK3ZvaWQgQXVk aW9Db250ZXh0OjpoYW5kbGVEZWZlcnJlZFJlZk5vZGVzKCkKK3sKKyAgICBBU1NFUlQoaXNBdWRp b1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKTsKKworICAgIGZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCBtX2RlZmVycmVkUmVmTGlzdC5zaXplKCk7ICsraSkgeworICAgICAgICBBdWRpb05vZGUq IG5vZGUgPSBtX2RlZmVycmVkUmVmTGlzdFtpXTsKKyAgICAgICAgLy8gQWRkIGEgcmVmZXJlbmNl IHRvIG5vZGUgdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoaXMgbm9kZSBpcyBzdGlsbCBhbGl2 ZS4KKyAgICAgICAgcmVmTm9kZShub2RlKTsKKyAgICB9CisgICAgCisgICAgbV9kZWZlcnJlZFJl Zkxpc3QuY2xlYXIoKTsKK30KKwordm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkRGVy ZWZOb2RlcygpCit7CisgICAgQVNTRVJUKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3duZXIo KSk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fZGVmZXJyZWREZXJlZkxpc3Quc2l6 ZSgpOyArK2kpIHsKKyAgICAgICAgQXVkaW9Ob2RlKiBub2RlID0gbV9kZWZlcnJlZERlcmVmTGlz dFtpXTsKKyAgICAgICAgLy8gTmVlZCB0byBkbyBhbnkgbm9ybWFsIGRlcmVmIHByb2Nlc3Npbmcg b2YgdGhlIG5vZGUuCisgICAgICAgIG5vZGUtPmZpbmlzaERlcmVmKEF1ZGlvTm9kZTo6UmVmVHlw ZUNvbm5lY3Rpb24pOworICAgICAgICAKKyAgICAgICAgLy8gQW5kIGFsc28gbmVlZCB0byByZW1v dmUgdGhlIG5vZGUgZnJvbSB0aGUgbV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0ZWxsIHRoZSBj b250ZXh0IHRoYXQKKyAgICAgICAgLy8gdGhlIG5vZGUgaXMgbm8gbG9uZ2VyIGFjdGl2ZS4gV2Un ZCBsaWtlIHRvIGNhbGwgZGVyZWZOb2RlLCBidXQgdGhhdCB3aWxsIGRlY3JlbWVudCB0aGUKKyAg ICAgICAgLy8gcmVmIGNvdW50ZXIgYWdhaW4uCisgICAgICAgIGZvciAodW5zaWduZWQgayA9IDA7 IGsgPCBtX3JlZmVyZW5jZWROb2Rlcy5zaXplKCk7ICsraykgeworICAgICAgICAgICAgaWYgKG1f cmVmZXJlbmNlZE5vZGVzW2tdID09IG5vZGUpIHsKKyAgICAgICAgICAgICAgICBtX3JlZmVyZW5j ZWROb2Rlcy5yZW1vdmUoayk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgbV9kZWZlcnJlZERlcmVmTGlzdC5jbGVhcigp OworfQorCiB2b2lkIEF1ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKQog ewogICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaCBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKaW5kZXggNTI1NGVm NjRmZGY1NTIwZjAxMDZiMTk4OWFmMGJkZGJjOThkNjg3Ni4uMTRlNDExZGE3YzBhMjAyNGNlNWM5 NjkxNDA0NzhjMWZmNTlkMjY5MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9BdWRpb0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvQ29udGV4dC5oCkBAIC0yMDIsNiArMjAyLDIyIEBAIHB1YmxpYzoKICAgICAgICAg QXVkaW9Db250ZXh0KiBtX2NvbnRleHQ7CiAgICAgICAgIGJvb2wgbV9tdXN0UmVsZWFzZUxvY2s7 CiAgICAgfTsKKworICAgIC8vIEFkZCBhdWRpbyBub2RlIHRvIGxpc3Qgb2Ygbm9kZXMgdGhhdCB3 ZSB3YW50IHRvIGNhbGwgcmVmTm9kZSgpIG9uLiBUaGVyZSBtdXN0IGV2ZW50dWFsbHkgYmUgYQor ICAgIC8vIGNhbGwgdG8gYWRkRGVmZXJyZWREZXJlZk5vZGUoKSBmb3IgdGhlIHNhbWUgbm9kZS4K KyAgICB2b2lkIGFkZERlZmVycmVkUmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIER1cmlu ZyBwb3N0IHJlbmRlciBwcm9jZXNzaW5nLCBhbGwgdGhlIG5vZGVzIGFkZGVkIGJ5IGFkZERlZmVy cmVkUmVmTm9kZXMoKSB3aWxsIGJlIGFkZGVkIHRvCisgICAgLy8gbV9yZWZlcmVuY2VkTm9kZXMg bGlzdCB0byB0ZWxsIHRoZSBjb250ZXh0IHRoYXQgdGhlc2Ugbm9kZXMgYXJlIHN0aWxsIGFsaXZl LgorICAgIHZvaWQgaGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOworCisgICAgLy8gVGhlIG9wcG9z aXRlIG9mIGFkZERlZmVycmVkUmVmTm9kZSgpLiBUaGlzIGluZGljYXRlcyB0aGF0IHRoZSBub2Rl IHNob3VsZCBiZSBkZXJlZidlZCBkdXJpbmcKKyAgICAvLyBwb3N0IHJlbmRlciBwcm9jZXNzaW5n IGFuZCByZW1vdmVkIGZyb20gdGhlIG1fcmVmZXJlbmNlZE5vZGVzIGxpc3QuCisgICAgdm9pZCBh ZGREZWZlcnJlZERlcmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIFByb2Nlc3MgdGhlIGxp c3Qgb2Ygbm9kZXMgYWRkZWQgYnkgYWRkRGVmZXJyZWREZXJlZk5vZGUuIFRoaXMgZGVyZWYncyB0 aGUgbm9kZSBmcm9tIHRoZSBncmFwaAorICAgIC8vIGFuZCByZW1vdmVzIHRoZSBub2RlIGZyb20g bV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0ZWxsIHRoZSBjb250ZXh0IHRoZSBub2RlIGlzIG5v IGxvbmdlciBhY3RpdmUuCisgICAgdm9pZCBoYW5kbGVEZWZlcnJlZERlcmVmTm9kZXMoKTsKICAg ICAKICAgICAvLyBJbiBBdWRpb05vZGU6OmRlcmVmKCkgYSB0cnlMb2NrKCkgaXMgdXNlZCBmb3Ig Y2FsbGluZyBmaW5pc2hEZXJlZigpLCBidXQgaWYgaXQgZmFpbHMga2VlcCB0cmFjayBoZXJlLgog ICAgIHZvaWQgYWRkRGVmZXJyZWRGaW5pc2hEZXJlZihBdWRpb05vZGUqLCBBdWRpb05vZGU6OlJl ZlR5cGUpOwpAQCAtMzAxLDYgKzMxNywxMiBAQCBwcml2YXRlOgogCiAgICAgLy8gT25seSBhY2Nl c3NlZCBpbiB0aGUgYXVkaW8gdGhyZWFkLgogICAgIFZlY3RvcjxSZWZJbmZvPiBtX2RlZmVycmVk RmluaXNoRGVyZWZMaXN0OworCisgICAgLy8gTGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8g Y2FsbCByZWZOb2RlKCkgb24gdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZSBub2RlIGlzIHN0 aWxsIGFjdGl2ZS4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZFJlZkxpc3Q7CisK KyAgICAvLyBMaXN0IG9mIG5vZGVzIHRoYXQgd2Ugd2FudCB0byBkZXJlZiBkdXJpbmcgcG9zdCBy ZW5kZXIgcHJvY2Vzc2luZy4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZERlcmVm TGlzdDsKICAgICAKICAgICAvLyBIUlRGIERhdGFiYXNlIGxvYWRlcgogICAgIFJlZlB0cjxIUlRG RGF0YWJhc2VMb2FkZXI+IG1faHJ0ZkRhdGFiYXNlTG9hZGVyOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCmluZGV4IDhhZjlmYzczNDQxMDkzOGYyZDMx YzE2ODUyZGU5OWRjNGZhNDZmMzcuLjEzNTgxNTEyOTM0M2QxOGJjNzVmYmY4MzU1OTAxMmU5MjVi YzU0OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9O b2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5j cHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5jbHVkZSA8d3RmL0F0b21pY3MuaD4KICNpbmNsdWRl IDx3dGYvTWFpblRocmVhZC5oPgogCisjaWYgREVCVUdfQVVESU9OT0RFX1JFRkVSRU5DRVMKKyNp bmNsdWRlIDxzdGRpby5oPgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogQXVkaW9O b2RlOjpBdWRpb05vZGUoQXVkaW9Db250ZXh0KiBjb250ZXh0LCBmbG9hdCBzYW1wbGVSYXRlKQpA QCAtNTAsNiArNTQsNyBAQCBBdWRpb05vZGU6OkF1ZGlvTm9kZShBdWRpb0NvbnRleHQqIGNvbnRl eHQsIGZsb2F0IHNhbXBsZVJhdGUpCiAgICAgLCBtX2Rpc2FibGVkUmVmQ291bnQoMCkKICAgICAs IG1faXNNYXJrZWRGb3JEZWxldGlvbihmYWxzZSkKICAgICAsIG1faXNEaXNhYmxlZChmYWxzZSkK KyAgICAsIG1fYWxsb3dUYWlsUHJvY2Vzc2luZyhmYWxzZSkKIHsKICNpZiBERUJVR19BVURJT05P REVfUkVGRVJFTkNFUwogICAgIGlmICghc19pc05vZGVDb3VudEluaXRpYWxpemVkKSB7CkBAIC02 Myw3ICs2OCw3IEBAIEF1ZGlvTm9kZTo6fkF1ZGlvTm9kZSgpCiB7CiAjaWYgREVCVUdfQVVESU9O T0RFX1JFRkVSRU5DRVMKICAgICAtLXNfbm9kZUNvdW50W25vZGVUeXBlKCldOwotICAgIHByaW50 ZigiJXA6ICVkOiBBdWRpb05vZGU6On5BdWRpb05vZGUoKSAlZCAlZCAlZFxuIiwgdGhpcywgbm9k ZVR5cGUoKSwgbV9ub3JtYWxSZWZDb3VudCwgbV9jb25uZWN0aW9uUmVmQ291bnQsIG1fZGlzYWJs ZWRSZWZDb3VudCk7CisgICAgZnByaW50ZihzdGRlcnIsICIlcDogJWQ6IEF1ZGlvTm9kZTo6fkF1 ZGlvTm9kZSgpICVkICVkICVkXG4iLCB0aGlzLCBub2RlVHlwZSgpLCBtX25vcm1hbFJlZkNvdW50 LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCwgbV9kaXNhYmxlZFJlZkNvdW50KTsKICNlbmRpZgogfQog CkBAIC0yMTAsOSArMjE1LDEyIEBAIHZvaWQgQXVkaW9Ob2RlOjpwcm9jZXNzSWZOZWNlc3Nhcnko c2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKICAgICAgICAgaWYgKCFzaWxlbnRJbnB1dHMpCiAgICAg ICAgICAgICBtX2xhc3ROb25TaWxlbnRUaW1lID0gKGNvbnRleHQoKS0+Y3VycmVudFNhbXBsZUZy YW1lKCkgKyBmcmFtZXNUb1Byb2Nlc3MpIC8gc3RhdGljX2Nhc3Q8ZG91YmxlPihtX3NhbXBsZVJh dGUpOwogCi0gICAgICAgIGlmIChzaWxlbnRJbnB1dHMgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkK KyAgICAgICAgaWYgKHNpbGVudElucHV0cyAmJiBwcm9wYWdhdGVzU2lsZW5jZSgpKSB7CisgICAg ICAgICAgICAvLyBUYWlsIHByb2Nlc3NpbmcgY2FuIGVuZCBub3cgYmVjYXVzZSB3ZSBhcmUgcHJv cGFnYXRpbmcgc2lsZW5jZS4KKyAgICAgICAgICAgIGVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQo KTsKICAgICAgICAgICAgIHNpbGVuY2VPdXRwdXRzKCk7Ci0gICAgICAgIGVsc2UgeworICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgYWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CiAg ICAgICAgICAgICBwcm9jZXNzKGZyYW1lc1RvUHJvY2Vzcyk7CiAgICAgICAgICAgICB1bnNpbGVu Y2VPdXRwdXRzKCk7CiAgICAgICAgIH0KQEAgLTI4Miw3ICsyOTAsNyBAQCB2b2lkIEF1ZGlvTm9k ZTo6cmVmKFJlZlR5cGUgcmVmVHlwZSkKICAgICB9CiAKICNpZiBERUJVR19BVURJT05PREVfUkVG RVJFTkNFUwotICAgIHByaW50ZigiJXA6ICVkOiBBdWRpb05vZGU6OnJlZiglZCkgJWQgJWQgJWRc biIsIHRoaXMsIG5vZGVUeXBlKCksIHJlZlR5cGUsIG1fbm9ybWFsUmVmQ291bnQsIG1fY29ubmVj dGlvblJlZkNvdW50LCBtX2Rpc2FibGVkUmVmQ291bnQpOworICAgIGZwcmludGYoc3RkZXJyLCAi JXA6ICVkOiBBdWRpb05vZGU6OnJlZiglZCkgJWQgJWQgJWRcbiIsIHRoaXMsIG5vZGVUeXBlKCks IHJlZlR5cGUsIG1fbm9ybWFsUmVmQ291bnQsIG1fY29ubmVjdGlvblJlZkNvdW50LCBtX2Rpc2Fi bGVkUmVmQ291bnQpOwogI2VuZGlmCiAKICAgICAvLyBTZWUgdGhlIGRpc2FibGluZyBjb2RlIGlu IGZpbmlzaERlcmVmKCkgYmVsb3cuIFRoaXMgaGFuZGxlcyB0aGUgY2FzZSB3aGVyZSBhIG5vZGUK QEAgLTM1NCw3ICszNjIsNyBAQCB2b2lkIEF1ZGlvTm9kZTo6ZmluaXNoRGVyZWYoUmVmVHlwZSBy ZWZUeXBlKQogICAgIH0KICAgICAKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwotICAg IHByaW50ZigiJXA6ICVkOiBBdWRpb05vZGU6OmRlcmVmKCVkKSAlZCAlZCAlZFxuIiwgdGhpcywg bm9kZVR5cGUoKSwgcmVmVHlwZSwgbV9ub3JtYWxSZWZDb3VudCwgbV9jb25uZWN0aW9uUmVmQ291 bnQsIG1fZGlzYWJsZWRSZWZDb3VudCk7CisgICAgZnByaW50ZihzdGRlcnIsICIlcDogJWQ6IEF1 ZGlvTm9kZTo6ZGVyZWYoJWQpICVkICVkICVkXG4iLCB0aGlzLCBub2RlVHlwZSgpLCByZWZUeXBl LCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCwgbV9kaXNhYmxlZFJlZkNv dW50KTsKICNlbmRpZgogCiAgICAgaWYgKCFtX2Nvbm5lY3Rpb25SZWZDb3VudCkgewpAQCAtMzc3 LDIwICszODUsMzggQEAgdm9pZCBBdWRpb05vZGU6OmZpbmlzaERlcmVmKFJlZlR5cGUgcmVmVHlw ZSkKICAgICAgICAgICAgICAgICAvLyBCdXQgaW50ZXJuYWxseSBvdXIgb3V0cHV0cyBzaG91bGQg YmUgZGlzYWJsZWQgZnJvbSB0aGUgaW5wdXRzIHRoZXkncmUgY29ubmVjdGVkIHRvLgogICAgICAg ICAgICAgICAgIC8vIGRpc2FibGUoKSBjYW4gcmVjdXJzaXZlbHkgZGVyZWYgY29ubmVjdGlvbnMg KGFuZCBjYWxsIGRpc2FibGUoKSkgZG93biBhIHdob2xlIGNoYWluIG9mIGNvbm5lY3RlZCBub2Rl cy4KIAotICAgICAgICAgICAgICAgIC8vIEZJWE1FOiB3ZSBzcGVjaWFsIGNhc2UgdGhlIGNvbnZv bHZlciBhbmQgZGVsYXkgc2luY2UgdGhleSBoYXZlIGEgc2lnbmlmaWNhbnQgdGFpbC10aW1lIGFu ZCBzaG91bGRuJ3QgYmUgZGlzY29ubmVjdGVkIHNpbXBseQotICAgICAgICAgICAgICAgIC8vIGJl Y2F1c2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkgaW5wdXQgY29ubmVjdGlvbnMuICBUaGlzIG5l ZWRzIHRvIGJlIGhhbmRsZWQgbW9yZSBnZW5lcmFsbHkgd2hlcmUgQXVkaW9Ob2RlcyBoYXZlCi0g ICAgICAgICAgICAgICAgLy8gYSB0YWlsVGltZSBhdHRyaWJ1dGUuICBUaGVuIHRoZSBBdWRpb05v ZGUgb25seSBuZWVkcyB0byByZW1haW4gImFjdGl2ZSIgZm9yIHRhaWxUaW1lIHNlY29uZHMgYWZ0 ZXIgdGhlcmUgYXJlIG5vCi0gICAgICAgICAgICAgICAgLy8gbG9uZ2VyIGFueSBhY3RpdmUgY29u bmVjdGlvbnMuCi0gICAgICAgICAgICAgICAgaWYgKG5vZGVUeXBlKCkgIT0gTm9kZVR5cGVDb252 b2x2ZXIgJiYgbm9kZVR5cGUoKSAhPSBOb2RlVHlwZURlbGF5KSB7Ci0gICAgICAgICAgICAgICAg ICAgIG1faXNEaXNhYmxlZCA9IHRydWU7Ci0gICAgICAgICAgICAgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBtX291dHB1dHMuc2l6ZSgpOyArK2kpCi0gICAgICAgICAgICAgICAgICAg ICAgICBvdXRwdXQoaSktPmRpc2FibGUoKTsKLSAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgbV9pc0Rpc2FibGVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbV9vdXRwdXRzLnNpemUoKTsgKytpKQorICAgICAgICAgICAgICAgICAgICBv dXRwdXQoaSktPmRpc2FibGUoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIH0K IAordm9pZCBBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpCit7CisgICAg aWYgKCFtX2FsbG93VGFpbFByb2Nlc3NpbmcgJiYgKGxhdGVuY3lUaW1lKCkgKyB0YWlsVGltZSgp ID4gMCkpIHsKKyAgICAgICAgLy8gRXN0YWJsaXNoIGEgcmVmIHRvIG91cnNlbGYgaWYgd2UgaGF2 ZW4ndCBhbHJlYWR5IHNvIHdlIGRvbid0IGdldCByZW1vdmVkIHdoZW4gYWxsIG5vZGVzCisgICAg ICAgIC8vIGhhdmUgZGlzY29ubmVjdGVkIGZyb20gdXMuIFdlIGhvbGQgdGhpcyByZWYgZHVyaW5n IHRoZSB0aW1lIHdoZW4gd2UgYXJlIHJlY2VpdmluZworICAgICAgICAvLyBub24tc2lsZW50IGlu cHV0LCBvciBkdXJpbmcgdGhlIHRpbWUgYWZ0ZXIgZmlyc3QgcmVjZWl2aW5nIHNpbGVudCBpbnB1 dCB3aGVuIHdlIGVtcHR5IHRoZQorICAgICAgICAvLyBwcm9jZXNzaW5nIHBpcGVsaW5lIHRvIGFj Y291bnQgZm9yIGxhdGVuY3kgYW5kIHRhaWwuCisgICAgICAgIG1fYWxsb3dUYWlsUHJvY2Vzc2lu ZyA9IHRydWU7CisgICAgICAgIGNvbnRleHQoKS0+YWRkRGVmZXJyZWRSZWZOb2RlKHRoaXMpOwor ICAgIH0KK30KKwordm9pZCBBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKQor eworICAgIEFTU0VSVChwcm9wYWdhdGVzU2lsZW5jZSgpKTsKKyAgICAKKyAgICBpZiAobV9hbGxv d1RhaWxQcm9jZXNzaW5nKSB7CisgICAgICAgIC8vIFN0b3AgdGFpbCBwcm9jZXNzaW5nLiBKdXN0 IG5lZWQgdG8gZGVyZWYgb3Vyc2VsZiwgYnV0IHdlIGNhbid0IGRvIHRoYXQgd2hpbGUgdGhlIGdy YXBoCisgICAgICAgIC8vIGlzIGJlaW5nIHJlbmRlcmVkLiBTY2hlZHVsZSB0aGUgZGVyZWYgdG8g aGFwcGVuIGR1cmluZyB0aGUgcG9zdC1yZW5kZXJpbmcgcGhhc2UuCisgICAgICAgIG1fYWxsb3dU YWlsUHJvY2Vzc2luZyA9IGZhbHNlOworICAgICAgICBjb250ZXh0KCktPmFkZERlZmVycmVkRGVy ZWZOb2RlKHRoaXMpOworICAgIH0KK30KKwogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VT CiAKIGJvb2wgQXVkaW9Ob2RlOjpzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQgPSBmYWxzZTsKQEAg LTM5OCwxNSArNDI0LDE1IEBAIGludCBBdWRpb05vZGU6OnNfbm9kZUNvdW50W05vZGVUeXBlRW5k XTsKIAogdm9pZCBBdWRpb05vZGU6OnByaW50Tm9kZUNvdW50cygpCiB7Ci0gICAgcHJpbnRmKCJc blxuIik7Ci0gICAgcHJpbnRmKCI9PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIpOwotICAg IHByaW50ZigiQXVkaW9Ob2RlOiByZWZlcmVuY2UgY291bnRzXG4iKTsKLSAgICBwcmludGYoIj09 PT09PT09PT09PT09PT09PT09PT09PT09PVxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICJcblxu Iik7CisgICAgZnByaW50ZihzdGRlcnIsICI9PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIp OworICAgIGZwcmludGYoc3RkZXJyLCAiQXVkaW9Ob2RlOiByZWZlcmVuY2UgY291bnRzXG4iKTsK KyAgICBmcHJpbnRmKHN0ZGVyciwgIj09PT09PT09PT09PT09PT09PT09PT09PT09PVxuIik7CiAK ICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgTm9kZVR5cGVFbmQ7ICsraSkKLSAgICAgICAg cHJpbnRmKCIlZDogJWRcbiIsIGksIHNfbm9kZUNvdW50W2ldKTsKKyAgICAgICAgZnByaW50Zihz dGRlcnIsICIlZDogJWRcbiIsIGksIHNfbm9kZUNvdW50W2ldKTsKIAotICAgIHByaW50ZigiPT09 PT09PT09PT09PT09PT09PT09PT09PT09XG5cblxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICI9 PT09PT09PT09PT09PT09PT09PT09PT09PT1cblxuXG4iKTsKIH0KIAogI2VuZGlmIC8vIERFQlVH X0FVRElPTk9ERV9SRUZFUkVOQ0VTCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb05vZGUuaAppbmRleCBjMjYxNGNiM2IxMmQ2ZDE1NTBmZGY3NGY4NDg4ZTQxZjQ1ZjljZGEy Li44MmQ2NDBhMzMzMjc2NDRjNmVmN2M4ZTI2MzQ3MzdjOTEyMTViM2IyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKQEAgLTE1Myw2ICsxNTMsMTYgQEAg cHVibGljOgogICAgIHZvaWQgc2lsZW5jZU91dHB1dHMoKTsKICAgICB2b2lkIHVuc2lsZW5jZU91 dHB1dHMoKTsKIAorICAgIC8vIEFsbG93IHRhaWwgcHJvY2Vzc2luZyBmb3Igbm9kZXMgdGhhdCBo YXZlIHRhaWwgb3IgbGF0ZW5jeSB0aW1lLiBUaGlzIHdpbGwgY3JlYXRlIGFuCisgICAgLy8gYWRk aXRpb25hbCBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWxmcyBzbyB3ZSBkb24ndCBnZXQgcmVtb3Zl ZCBmcm9tIHRoZSBncmFwaCBiZWZvcmUgdGhlIHRhaWwKKyAgICAvLyBoYXMgYmVlbiBwcm9jZXNz ZWQuCisgICAgdm9pZCBhbGxvd1RhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKTsKKworICAgIC8vIElm IHdlJ3JlIHByb2Nlc3NpbmcgdGhlIHRhaWwgZm9yIHRoaXMgbm9kZSBhbmQgYWxsIG91dHB1dHMg c2hvdWxkIGJlIHByb3BhZ2F0aW5nIHNpbGVuY2UsIHdlCisgICAgLy8gZW5kIHRhaWwgcHJvY2Vz c2luZy4gVGhlIGNvbm5lY3Rpb24gcmVmIHRvIG91cnNlbGYgd2lsbCBiZSByZW1vdmVkLCBiYWxh bmNpbmcgdGhlIHJlZmVyZW5jZQorICAgIC8vIGFkZGVkIGluIGFsbG93VGFpbFByb2Nlc3NpbmdJ Zk5lZWRlZCgpLgorICAgIHZvaWQgZW5kVGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCiBwcm90 ZWN0ZWQ6CiAgICAgLy8gSW5wdXRzIGFuZCBvdXRwdXRzIG11c3QgYmUgY3JlYXRlZCBiZWZvcmUg dGhlIEF1ZGlvTm9kZSBpcyBpbml0aWFsaXplZC4KICAgICB2b2lkIGFkZElucHV0KFBhc3NPd25Q dHI8QXVkaW9Ob2RlSW5wdXQ+KTsKQEAgLTE4MSw3ICsxOTEsOSBAQCBwcml2YXRlOgogICAgIAog ICAgIGJvb2wgbV9pc01hcmtlZEZvckRlbGV0aW9uOwogICAgIGJvb2wgbV9pc0Rpc2FibGVkOwot ICAgIAorCisgICAgYm9vbCBtX2FsbG93VGFpbFByb2Nlc3Npbmc7CisKICNpZiBERUJVR19BVURJ T05PREVfUkVGRVJFTkNFUwogICAgIHN0YXRpYyBib29sIHNfaXNOb2RlQ291bnRJbml0aWFsaXpl ZDsKICAgICBzdGF0aWMgaW50IHNfbm9kZUNvdW50W05vZGVUeXBlRW5kXTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcAppbmRleCAx MTA1NzczMjYwNDhhZmYwOGFmOWU0ZTdmOTFiNzMzYjE4M2EyYWM3Li41NjQ5YTk4MjE1MDBlMzU3 MmVlOGU3OTgzMGVhZjg1ZDkwYzI3N2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCkBAIC05MSw3ICs5MSw3IEBAIHZvaWQg QXVkaW9QYW5uZXJOb2RlOjpwcm9jZXNzKHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpCiB7CiAgICAg QXVkaW9CdXMqIGRlc3RpbmF0aW9uID0gb3V0cHV0KDApLT5idXMoKTsKIAotICAgIGlmICghaXNJ bml0aWFsaXplZCgpIHx8ICFpbnB1dCgwKS0+aXNDb25uZWN0ZWQoKSB8fCAhbV9wYW5uZXIuZ2V0 KCkpIHsKKyAgICBpZiAoIWlzSW5pdGlhbGl6ZWQoKSB8fCAhbV9wYW5uZXIuZ2V0KCkpIHsKICAg ICAgICAgZGVzdGluYXRpb24tPnplcm8oKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCAzMzMzNTA4ZDkyODgzYjM1ZjM1NDk1ZjMxMTk0OTk0NjU5MzJlODFiLi5iODk5Y2JlYjVjNzk0 ZmE5OTE0YzkwOWQ0MDA4YTk2MDVjMThmYTk0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTIt MDQtMTEgIFJheW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAgICAgIG5vdGVHcmFp bk9uIGlzIHRvbyBsb25nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03NzIyNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFJlbW92ZSBleHRyYUZyYW1lc0hSVEYgdGhhdCBpcyBubyBsb25nZXIgbmVlZGVkOgor ICAgICAgICAqIHdlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanM6Cisg ICAgICAgIChjcmVhdGVTaWduYWxCdWZmZXIpOiAKKyAgICAgICAgKHZlcmlmeVN0YXJ0QW5kRW5k RnJhbWVzKToKKwogMjAxMi0wNC0zMCAgUGF2ZWwgRmVsZG1hbiAgPHBmZWxkbWFuQGNocm9taXVt Lm9yZz4KIAogICAgICAgICBOb3QgcmV2aWV3ZWQ6IGNocm9taXVtIGV4cGVjdGF0aW9ucyB1cGRh dGVkLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3Jh aW4tb24tdGVzdGluZy5qcyBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdy YWluLW9uLXRlc3RpbmcuanMKaW5kZXggNDVkZDcyZmNhYWRiMjg0N2Q5ZDJlNGI1OGNjMWI0YzA2 YmE1Y2U5OS4uM2I0NDhhYTFiMGNmODlkNjlhMjJlODAxYTM4ZGZmNzc5ZTM4OGVmOCAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGlu Zy5qcworKysgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNvdXJjZXMvbm90ZS1ncmFpbi1vbi10 ZXN0aW5nLmpzCkBAIC0xLDExICsxLDUgQEAKIHZhciBzYW1wbGVSYXRlID0gNDQxMDAuMDsKIAot Ly8gSFJURiBleHRyYSBmcmFtZXMuICBUaGlzIGlzIGEgbWFnaWMgY29uc3RhbnQgY3VycmVudGx5 IGluCi0vLyBBdWRpb0J1ZmZlclNvdXJjZU5vZGU6OnByb2Nlc3MgdGhhdCBhbHdheXMgZXh0ZW5k cyB0aGUKLS8vIGR1cmF0aW9uIGJ5IHRoaXMgbnVtYmVyIG9mIHNhbXBsZXMuICBTZWUgYnVnIDc3 MjI0Ci0vLyAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MjI0KS4K LXZhciBleHRyYUZyYW1lc0hSVEYgPSA1MTI7Ci0KIC8vIEhvdyBtYW55IGdyYWlucyB0byBwbGF5 LgogdmFyIG51bWJlck9mVGVzdHMgPSAxMDA7CiAKQEAgLTEzLDkgKzcsOCBAQCB2YXIgbnVtYmVy T2ZUZXN0cyA9IDEwMDsKIHZhciBkdXJhdGlvbiA9IDAuMDE7CiAKIC8vIFRpbWUgc3RlcCBiZXR3 ZWVuIHRoZSBzdGFydCBvZiBlYWNoIGdyYWluLiAgV2UgbmVlZCB0byBhZGQgYSBsaXR0bGUKLS8v IGJpdCBvZiBzaWxlbmNlIHNvIHdlIGNhbiBkZXRlY3QgZ3JhaW4gYm91bmRhcmllcyBhbmQgYWxz byBhY2NvdW50Ci0vLyBmb3IgdGhlIGV4dHJhIGZyYW1lcyBmb3IgSFJURi4KLXZhciB0aW1lU3Rl cCA9IGR1cmF0aW9uICsgLjAwNSArIGV4dHJhRnJhbWVzSFJURiAvIHNhbXBsZVJhdGU7CisvLyBi aXQgb2Ygc2lsZW5jZSBzbyB3ZSBjYW4gZGV0ZWN0IGdyYWluIGJvdW5kYXJpZXMuCit2YXIgdGlt ZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDU7CiAKIC8vIFRpbWUgc3RlcCBiZXR3ZWVuIHRoZSBzdGFy dCBmb3IgZWFjaCBncmFpbi4KIHZhciBncmFpbk9mZnNldFN0ZXAgPSAwLjAwMTsKQEAgLTMwLDEw ICsyMyw5IEBAIHZhciByZW5kZXJlZERhdGE7CiAvLyByZXR1cm5zIHRoZSBkZXNpcmVkIHZhbHVl IGF0IHNhbXBsZSBmcmFtZSBrLgogZnVuY3Rpb24gY3JlYXRlU2lnbmFsQnVmZmVyKGNvbnRleHQs IGYpIHsKIAotICAgIC8vIE1ha2Ugc3VyZSB0aGUgYnVmZmVyIGhhcyBlbm91Z2ggZGF0YSBmb3Ig YWxsIG9mIHRoZSBwb3NzaWJsZQotICAgIC8vIGdyYWluIG9mZnNldHMgYW5kIGR1cmF0aW9ucy4g IE5lZWQgdG8gaW5jbHVkZSB0aGUgZXh0cmEgZnJhbWVzCi0gICAgLy8gZm9yIEhSVEYuICBUaGUg YWRkaXRpb25hbCAxIGlzIGZvciBhbnkgcm91bmQtb2ZmIGVycm9ycy4KLSAgICB2YXIgc2lnbmFs TGVuZ3RoID0gTWF0aC5mbG9vcigxICsgZXh0cmFGcmFtZXNIUlRGICsgc2FtcGxlUmF0ZSAqIChu dW1iZXJPZlRlc3RzICogZ3JhaW5PZmZzZXRTdGVwICsgZHVyYXRpb24pKTsKKyAgICAvLyBNYWtl IHN1cmUgdGhlIGJ1ZmZlciBoYXMgZW5vdWdoIGRhdGEgZm9yIGFsbCBvZiB0aGUgcG9zc2libGUg Z3JhaW4gb2Zmc2V0cyBhbmQgZHVyYXRpb25zLgorICAgIC8vIFRoZSBhZGRpdGlvbmFsIDEgaXMg Zm9yIGFueSByb3VuZC1vZmYgZXJyb3JzLgorICAgIHZhciBzaWduYWxMZW5ndGggPSBNYXRoLmZs b29yKDEgKyBzYW1wbGVSYXRlICogKG51bWJlck9mVGVzdHMgKiBncmFpbk9mZnNldFN0ZXAgKyBk dXJhdGlvbikpOwogCiAgICAgdmFyIGJ1ZmZlciA9IGNvbnRleHQuY3JlYXRlQnVmZmVyKDIsIHNp Z25hbExlbmd0aCwgc2FtcGxlUmF0ZSk7CiAgICAgdmFyIGRhdGEgPSBidWZmZXIuZ2V0Q2hhbm5l bERhdGEoMCk7CkBAIC0xMzMsOSArMTI1LDggQEAgZnVuY3Rpb24gdmVyaWZ5U3RhcnRBbmRFbmRG cmFtZXMoc3RhcnRFbmRGcmFtZXMpIHsKICAgICAvLyBleHBlY3RhdGlvbnMuCiAgICAgZm9yICh2 YXIgayA9IDA7IGsgPCBzdGFydEZyYW1lcy5sZW5ndGg7ICsraykgewogICAgICAgICB2YXIgZXhw ZWN0ZWRTdGFydCA9IHRpbWVUb1NhbXBsZUZyYW1lKGsgKiB0aW1lU3RlcCwgc2FtcGxlUmF0ZSk7 Ci0gICAgICAgIC8vIFRoZSBlbmQgcG9pbnQgaXMgdGhlIGR1cmF0aW9uLCBwbHVzIHRoZSBleHRy YSBmcmFtZXMKLSAgICAgICAgLy8gZm9yIEhSVEYuCi0gICAgICAgIHZhciBleHBlY3RlZEVuZCA9 IGV4dHJhRnJhbWVzSFJURiArIGV4cGVjdGVkU3RhcnQgKyBncmFpbkxlbmd0aEluU2FtcGxlRnJh bWVzKGsgKiBncmFpbk9mZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1wbGVSYXRlKTsKKyAgICAgICAg Ly8gVGhlIGVuZCBwb2ludCBpcyB0aGUgZHVyYXRpb24uCisgICAgICAgIHZhciBleHBlY3RlZEVu ZCA9IGV4cGVjdGVkU3RhcnQgKyBncmFpbkxlbmd0aEluU2FtcGxlRnJhbWVzKGsgKiBncmFpbk9m ZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1wbGVSYXRlKTsKIAogICAgICAgICBpZiAoc3RhcnRGcmFt ZXNba10gIT0gZXhwZWN0ZWRTdGFydCkgewogICAgICAgICAgICAgdGVzdEZhaWxlZCgiUHVsc2Ug IiArIGsgKyAiIHN0YXJ0ZWQgYXQgIiArIHN0YXJ0RnJhbWVzW2tdICsgIiBidXQgZXhwZWN0ZWQg YXQgIiArIGV4cGVjdGVkU3RhcnQpOwo= 139676 2012-05-01 14:12:42 -0700 2012-05-04 16:18:19 -0700 Patch bug-77224-20120501141241.patch text/plain 19744 rtoy U3VidmVyc2lvbiBSZXZpc2lvbjogMTE1NjIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjg3MDI0MzIxYmJlYjRj YTNlM2VmY2Y1Y2E4Yjc0OTU2YTRhNzkzOS4uMTc2NzEyMjRiMjM5ZTg5MGVhZGJmMTc5NWFmZjAw MWMwMjRiZGEzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA0LTA1ICBSYXlt b25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5PbiBpcyB0b28g bG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcy MjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBub3Rl LWdyYWluLW9uIHRlc3QgdXBkYXRlZCB0byBzaG93IHRoZSBidWcgaGFzIGJlZW4gZml4ZWQuICBB bHNvCisgICAgICAgIHRyeSBvdXQgaHR0cDovL3N0YXRpYy5lY2hvbmVzdC5jb20vQm9oZW1pYW5S aGFwc2ljaG9yZC9pbmRleC5odG1sCisgICAgICAgIHdoaWNoIG5vIGxvbmdlciBoYXMgZ2xpdGNo ZXMgYW5kCisgICAgICAgIGh0dHA6Ly9jaHJvbWl1bS5nb29nbGVjb2RlLmNvbS9zdm4vdHJ1bmsv c2FtcGxlcy9hdWRpby9ncmFudWxhci5odG1sCisgICAgICAgIHdoaWNoIHN0aWxsIHNvdW5kcyBn b29kLgorCisgICAgICAgICogd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcik6 IFJlbW92ZSBleHRyYSBmcmFtZXMuCisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBpbXBsZW1l bnQgdGFpbCBwcm9jZXNzaW5nIHRvIGZpeCBub3RlLWdyYWluLW9uIGJ1Zy4KKyAgICAgICAgKiB3 ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjph ZGREZWZlcnJlZFJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVE ZWZlcnJlZFJlZk5vZGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6YWRkRGVmZXJy ZWREZXJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVEZWZlcnJl ZERlcmVmTm9kZXMpOgorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oOiBEZWNsYXJh dGlvbnMgb2YgbmV3IGZ1bmN0aW9ucyBhbmQgc2xvdHMKKyAgICAgICAgdG8gc3VwcG9ydCB0YWls IHByb2Nlc3NpbmcuCisgICAgICAgIAorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1ZGlvTm9kZSk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgorCisgICAgICAg IEZpeCBQYW5uZXIgbm9kZSB0byBhbGxvdyB0YWlsIHByb2Nlc3NpbmcuCisgICAgICAgICogd2Vi YXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFubmVy Tm9kZTo6cHJvY2Vzcyk6IE5lZWQgdG8gY29udGludWUgcHJvY2Vzc2luZworICAgICAgICBmb3Ig dGFpbCB0aW1lIGV2ZW4gaWYgdGhlIGlucHV0IGlzIGRpc2Nvbm5lY3RlZC4KKwogMjAxMi0wNC0y OSAgS2Vpc2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KIAogICAgICAgICBCdWlsZCBm aXggZm9yIExvY2FsaXplZERhdGVNYWMubW0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcAppbmRleCA0M2E5Y2I0 OGFjNWY0MTRjZmQ5YTg1MjBjYjg0Y2JiZjZjNTZlYjU3Li40OTQ3NzJkZDQ5NWE3MWExZjhkYjE4 MTJhMmY5YTEyZTg3M2I1OTMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCkBAIC0yMzMsMTEgKzIzMyw2 IEBAIHZvaWQgQXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5kZXJGcm9tQnVmZmVyKEF1ZGlvQnVz KiBidXMsIHVuc2lnbmVkIGRlc3RpbmF0aW9uCiAgICAgCiAgICAgdW5zaWduZWQgZGVsdGFGcmFt ZXMgPSBlbmRGcmFtZSAtIHN0YXJ0RnJhbWU7CiAgICAgCi0gICAgLy8gVGhpcyBpcyBhIEhBQ0sg dG8gYWxsb3cgZm9yIEhSVEYgdGFpbC10aW1lIC0gYXZvaWRzIGdsaXRjaCBhdCBlbmQuCi0gICAg Ly8gRklYTUU6IGltcGxlbWVudCB0YWlsVGltZSBmb3IgZWFjaCBBdWRpb05vZGUgZm9yIGEgbW9y ZSBnZW5lcmFsIHNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbS4KLSAgICBpZiAobV9pc0dyYWluKQot ICAgICAgICBlbmRGcmFtZSArPSA1MTI7Ci0KICAgICAvLyBEbyBzb21lIHNhbml0eSBjaGVja2lu Zy4KICAgICBpZiAoc3RhcnRGcmFtZSA+PSBidWZmZXJMZW5ndGgpCiAgICAgICAgIHN0YXJ0RnJh bWUgPSAhYnVmZmVyTGVuZ3RoID8gMCA6IGJ1ZmZlckxlbmd0aCAtIDE7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAKaW5kZXggZjc4OTA1YmU2 N2E3MTAzYjVkNTFjYWM2YWFkZDc2NDFhMzBiNzdkMC4uZmI0Yzc2MWYxYTI0MTQwNmJhYzVhMGZm MGIwYTI4ZTQ2Y2I2ODg2MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJh dWRpby9BdWRpb0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVk aW8vQXVkaW9Db250ZXh0LmNwcApAQCAtMTk0LDcgKzE5NCw3IEBAIHZvaWQgQXVkaW9Db250ZXh0 Ojpjb25zdHJ1Y3RDb21tb24oKQogQXVkaW9Db250ZXh0Ojp+QXVkaW9Db250ZXh0KCkKIHsKICNp ZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwotICAgIHByaW50ZigiJXA6IEF1ZGlvQ29udGV4 dDo6fkF1ZGlvQ29udGV4dCgpXG4iLCB0aGlzKTsKKyAgICBmcHJpbnRmKHN0ZGVyciwgIkF1ZGlv Q29udGV4dDo6fkF1ZGlvQ29udGV4dCgpOiAlcFxuIiwgdGhpcyk7CiAjZW5kaWYKICAgICAvLyBB dWRpb05vZGVzIGtlZXAgYSByZWZlcmVuY2UgdG8gdGhlaXIgY29udGV4dCwgc28gdGhlcmUgc2hv dWxkIGJlIG5vIHdheSB0byBiZSBpbiB0aGUgZGVzdHJ1Y3RvciBpZiB0aGVyZSBhcmUgc3RpbGwg QXVkaW9Ob2RlcyBhcm91bmQuCiAgICAgQVNTRVJUKCFtX25vZGVzVG9EZWxldGUuc2l6ZSgpKTsK QEAgLTU0Niw3ICs1NDYsNyBAQCB2b2lkIEF1ZGlvQ29udGV4dDo6ZGVyZWZGaW5pc2hlZFNvdXJj ZU5vZGVzKCkKIAogdm9pZCBBdWRpb0NvbnRleHQ6OnJlZk5vZGUoQXVkaW9Ob2RlKiBub2RlKQog ewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgp IHx8IChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpKTsKICAgICBBdXRvTG9ja2Vy IGxvY2tlcih0aGlzKTsKICAgICAKICAgICBub2RlLT5yZWYoQXVkaW9Ob2RlOjpSZWZUeXBlQ29u bmVjdGlvbik7CkBAIC01NzksNyArNTc5LDcgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmRlcmVmVW5m aW5pc2hlZFNvdXJjZU5vZGVzKCkKIHZvaWQgQXVkaW9Db250ZXh0Ojpsb2NrKGJvb2wmIG11c3RS ZWxlYXNlTG9jaykKIHsKICAgICAvLyBEb24ndCBhbGxvdyByZWd1bGFyIGxvY2sgaW4gcmVhbC10 aW1lIGF1ZGlvIHRocmVhZC4KLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VS VChpc01haW5UaHJlYWQoKSB8fCAoaXNBdWRpb1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKSk7 CiAKICAgICBUaHJlYWRJZGVudGlmaWVyIHRoaXNUaHJlYWQgPSBjdXJyZW50VGhyZWFkKCk7CiAK QEAgLTY0NSw2ICs2NDUsMTggQEAgYm9vbCBBdWRpb0NvbnRleHQ6OmlzR3JhcGhPd25lcigpIGNv bnN0CiAgICAgcmV0dXJuIGN1cnJlbnRUaHJlYWQoKSA9PSBtX2dyYXBoT3duZXJUaHJlYWQ7CiB9 CiAKK3ZvaWQgQXVkaW9Db250ZXh0OjphZGREZWZlcnJlZFJlZk5vZGUoQXVkaW9Ob2RlKiBub2Rl KQoreworICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkpOworICAgIG1fZGVmZXJyZWRSZWZMaXN0 LmFwcGVuZChub2RlKTsKK30KKwordm9pZCBBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRGVyZWZO b2RlKEF1ZGlvTm9kZSogbm9kZSkKK3sKKyAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKKyAg ICBtX2RlZmVycmVkRGVyZWZMaXN0LmFwcGVuZChub2RlKTsKK30KKwogdm9pZCBBdWRpb0NvbnRl eHQ6OmFkZERlZmVycmVkRmluaXNoRGVyZWYoQXVkaW9Ob2RlKiBub2RlLCBBdWRpb05vZGU6OlJl ZlR5cGUgcmVmVHlwZSkKIHsKICAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKQEAgLTY3Nyw2 ICs2ODksMTAgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RSZW5kZXJUYXNrcygpCiAg ICAgLy8gZnJvbSB0aGUgcmVuZGVyIGdyYXBoIChpbiB3aGljaCBjYXNlIHRoZXknbGwgcmVuZGVy IHNpbGVuY2UpLgogICAgIGJvb2wgbXVzdFJlbGVhc2VMb2NrOwogICAgIGlmICh0cnlMb2NrKG11 c3RSZWxlYXNlTG9jaykpIHsKKyAgICAgICAgLy8gVGFrZSBjYXJlIG9mIGFueSBkZWZlcnJlZCBy ZWZOb2RlcyBhbmQgZGVmZXJyZWQgZGVyZWZOb2RlcyB0aGF0IHdlcmUgYWRkZWQuCisgICAgICAg IGhhbmRsZURlZmVycmVkUmVmTm9kZXMoKTsKKyAgICAgICAgaGFuZGxlRGVmZXJyZWREZXJlZk5v ZGVzKCk7CisgICAgICAgIAogICAgICAgICAvLyBUYWtlIGNhcmUgb2YgZmluaXNoaW5nIGFueSBk ZXJlZnMgd2hlcmUgdGhlIHRyeUxvY2soKSBmYWlsZWQgcHJldmlvdXNseS4KICAgICAgICAgaGFu ZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKTsKIApAQCAtNjk2LDYgKzcxMiw0MSBAQCB2b2lkIEF1 ZGlvQ29udGV4dDo6aGFuZGxlUG9zdFJlbmRlclRhc2tzKCkKICAgICB9CiB9CiAKK3ZvaWQgQXVk aW9Db250ZXh0OjpoYW5kbGVEZWZlcnJlZFJlZk5vZGVzKCkKK3sKKyAgICBBU1NFUlQoaXNBdWRp b1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKTsKKworICAgIGZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCBtX2RlZmVycmVkUmVmTGlzdC5zaXplKCk7ICsraSkgeworICAgICAgICBBdWRpb05vZGUq IG5vZGUgPSBtX2RlZmVycmVkUmVmTGlzdFtpXTsKKyAgICAgICAgLy8gQWRkIGEgcmVmZXJlbmNl IHRvIG5vZGUgdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoaXMgbm9kZSBpcyBzdGlsbCBhbGl2 ZS4KKyAgICAgICAgcmVmTm9kZShub2RlKTsKKyAgICB9CisgICAgCisgICAgbV9kZWZlcnJlZFJl Zkxpc3QuY2xlYXIoKTsKK30KKwordm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkRGVy ZWZOb2RlcygpCit7CisgICAgQVNTRVJUKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3duZXIo KSk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fZGVmZXJyZWREZXJlZkxpc3Quc2l6 ZSgpOyArK2kpIHsKKyAgICAgICAgQXVkaW9Ob2RlKiBub2RlID0gbV9kZWZlcnJlZERlcmVmTGlz dFtpXTsKKyAgICAgICAgLy8gTmVlZCB0byBkbyBhbnkgbm9ybWFsIGRlcmVmIHByb2Nlc3Npbmcg b2YgdGhlIG5vZGUuCisgICAgICAgIG5vZGUtPmZpbmlzaERlcmVmKEF1ZGlvTm9kZTo6UmVmVHlw ZUNvbm5lY3Rpb24pOworICAgICAgICAKKyAgICAgICAgLy8gQW5kIGFsc28gbmVlZCB0byByZW1v dmUgdGhlIG5vZGUgZnJvbSB0aGUgbV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0ZWxsIHRoZSBj b250ZXh0IHRoYXQKKyAgICAgICAgLy8gdGhlIG5vZGUgaXMgbm8gbG9uZ2VyIGFjdGl2ZS4gV2Un ZCBsaWtlIHRvIGNhbGwgZGVyZWZOb2RlLCBidXQgdGhhdCB3aWxsIGRlY3JlbWVudCB0aGUKKyAg ICAgICAgLy8gcmVmIGNvdW50ZXIgYWdhaW4uCisgICAgICAgIGZvciAodW5zaWduZWQgayA9IDA7 IGsgPCBtX3JlZmVyZW5jZWROb2Rlcy5zaXplKCk7ICsraykgeworICAgICAgICAgICAgaWYgKG1f cmVmZXJlbmNlZE5vZGVzW2tdID09IG5vZGUpIHsKKyAgICAgICAgICAgICAgICBtX3JlZmVyZW5j ZWROb2Rlcy5yZW1vdmUoayk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgbV9kZWZlcnJlZERlcmVmTGlzdC5jbGVhcigp OworfQorCiB2b2lkIEF1ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKQog ewogICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaCBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKaW5kZXggNTI1NGVm NjRmZGY1NTIwZjAxMDZiMTk4OWFmMGJkZGJjOThkNjg3Ni4uMTRlNDExZGE3YzBhMjAyNGNlNWM5 NjkxNDA0NzhjMWZmNTlkMjY5MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9BdWRpb0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvQ29udGV4dC5oCkBAIC0yMDIsNiArMjAyLDIyIEBAIHB1YmxpYzoKICAgICAgICAg QXVkaW9Db250ZXh0KiBtX2NvbnRleHQ7CiAgICAgICAgIGJvb2wgbV9tdXN0UmVsZWFzZUxvY2s7 CiAgICAgfTsKKworICAgIC8vIEFkZCBhdWRpbyBub2RlIHRvIGxpc3Qgb2Ygbm9kZXMgdGhhdCB3 ZSB3YW50IHRvIGNhbGwgcmVmTm9kZSgpIG9uLiBUaGVyZSBtdXN0IGV2ZW50dWFsbHkgYmUgYQor ICAgIC8vIGNhbGwgdG8gYWRkRGVmZXJyZWREZXJlZk5vZGUoKSBmb3IgdGhlIHNhbWUgbm9kZS4K KyAgICB2b2lkIGFkZERlZmVycmVkUmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIER1cmlu ZyBwb3N0IHJlbmRlciBwcm9jZXNzaW5nLCBhbGwgdGhlIG5vZGVzIGFkZGVkIGJ5IGFkZERlZmVy cmVkUmVmTm9kZXMoKSB3aWxsIGJlIGFkZGVkIHRvCisgICAgLy8gbV9yZWZlcmVuY2VkTm9kZXMg bGlzdCB0byB0ZWxsIHRoZSBjb250ZXh0IHRoYXQgdGhlc2Ugbm9kZXMgYXJlIHN0aWxsIGFsaXZl LgorICAgIHZvaWQgaGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOworCisgICAgLy8gVGhlIG9wcG9z aXRlIG9mIGFkZERlZmVycmVkUmVmTm9kZSgpLiBUaGlzIGluZGljYXRlcyB0aGF0IHRoZSBub2Rl IHNob3VsZCBiZSBkZXJlZidlZCBkdXJpbmcKKyAgICAvLyBwb3N0IHJlbmRlciBwcm9jZXNzaW5n IGFuZCByZW1vdmVkIGZyb20gdGhlIG1fcmVmZXJlbmNlZE5vZGVzIGxpc3QuCisgICAgdm9pZCBh ZGREZWZlcnJlZERlcmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIFByb2Nlc3MgdGhlIGxp c3Qgb2Ygbm9kZXMgYWRkZWQgYnkgYWRkRGVmZXJyZWREZXJlZk5vZGUuIFRoaXMgZGVyZWYncyB0 aGUgbm9kZSBmcm9tIHRoZSBncmFwaAorICAgIC8vIGFuZCByZW1vdmVzIHRoZSBub2RlIGZyb20g bV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0ZWxsIHRoZSBjb250ZXh0IHRoZSBub2RlIGlzIG5v IGxvbmdlciBhY3RpdmUuCisgICAgdm9pZCBoYW5kbGVEZWZlcnJlZERlcmVmTm9kZXMoKTsKICAg ICAKICAgICAvLyBJbiBBdWRpb05vZGU6OmRlcmVmKCkgYSB0cnlMb2NrKCkgaXMgdXNlZCBmb3Ig Y2FsbGluZyBmaW5pc2hEZXJlZigpLCBidXQgaWYgaXQgZmFpbHMga2VlcCB0cmFjayBoZXJlLgog ICAgIHZvaWQgYWRkRGVmZXJyZWRGaW5pc2hEZXJlZihBdWRpb05vZGUqLCBBdWRpb05vZGU6OlJl ZlR5cGUpOwpAQCAtMzAxLDYgKzMxNywxMiBAQCBwcml2YXRlOgogCiAgICAgLy8gT25seSBhY2Nl c3NlZCBpbiB0aGUgYXVkaW8gdGhyZWFkLgogICAgIFZlY3RvcjxSZWZJbmZvPiBtX2RlZmVycmVk RmluaXNoRGVyZWZMaXN0OworCisgICAgLy8gTGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8g Y2FsbCByZWZOb2RlKCkgb24gdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZSBub2RlIGlzIHN0 aWxsIGFjdGl2ZS4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZFJlZkxpc3Q7CisK KyAgICAvLyBMaXN0IG9mIG5vZGVzIHRoYXQgd2Ugd2FudCB0byBkZXJlZiBkdXJpbmcgcG9zdCBy ZW5kZXIgcHJvY2Vzc2luZy4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZERlcmVm TGlzdDsKICAgICAKICAgICAvLyBIUlRGIERhdGFiYXNlIGxvYWRlcgogICAgIFJlZlB0cjxIUlRG RGF0YWJhc2VMb2FkZXI+IG1faHJ0ZkRhdGFiYXNlTG9hZGVyOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCmluZGV4IDhhZjlmYzczNDQxMDkzOGYyZDMx YzE2ODUyZGU5OWRjNGZhNDZmMzcuLjEzNTgxNTEyOTM0M2QxOGJjNzVmYmY4MzU1OTAxMmU5MjVi YzU0OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9O b2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5j cHAKQEAgLTM2LDYgKzM2LDEwIEBACiAjaW5jbHVkZSA8d3RmL0F0b21pY3MuaD4KICNpbmNsdWRl IDx3dGYvTWFpblRocmVhZC5oPgogCisjaWYgREVCVUdfQVVESU9OT0RFX1JFRkVSRU5DRVMKKyNp bmNsdWRlIDxzdGRpby5oPgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogQXVkaW9O b2RlOjpBdWRpb05vZGUoQXVkaW9Db250ZXh0KiBjb250ZXh0LCBmbG9hdCBzYW1wbGVSYXRlKQpA QCAtNTAsNiArNTQsNyBAQCBBdWRpb05vZGU6OkF1ZGlvTm9kZShBdWRpb0NvbnRleHQqIGNvbnRl eHQsIGZsb2F0IHNhbXBsZVJhdGUpCiAgICAgLCBtX2Rpc2FibGVkUmVmQ291bnQoMCkKICAgICAs IG1faXNNYXJrZWRGb3JEZWxldGlvbihmYWxzZSkKICAgICAsIG1faXNEaXNhYmxlZChmYWxzZSkK KyAgICAsIG1fYWxsb3dUYWlsUHJvY2Vzc2luZyhmYWxzZSkKIHsKICNpZiBERUJVR19BVURJT05P REVfUkVGRVJFTkNFUwogICAgIGlmICghc19pc05vZGVDb3VudEluaXRpYWxpemVkKSB7CkBAIC02 Myw3ICs2OCw3IEBAIEF1ZGlvTm9kZTo6fkF1ZGlvTm9kZSgpCiB7CiAjaWYgREVCVUdfQVVESU9O T0RFX1JFRkVSRU5DRVMKICAgICAtLXNfbm9kZUNvdW50W25vZGVUeXBlKCldOwotICAgIHByaW50 ZigiJXA6ICVkOiBBdWRpb05vZGU6On5BdWRpb05vZGUoKSAlZCAlZCAlZFxuIiwgdGhpcywgbm9k ZVR5cGUoKSwgbV9ub3JtYWxSZWZDb3VudCwgbV9jb25uZWN0aW9uUmVmQ291bnQsIG1fZGlzYWJs ZWRSZWZDb3VudCk7CisgICAgZnByaW50ZihzdGRlcnIsICIlcDogJWQ6IEF1ZGlvTm9kZTo6fkF1 ZGlvTm9kZSgpICVkICVkICVkXG4iLCB0aGlzLCBub2RlVHlwZSgpLCBtX25vcm1hbFJlZkNvdW50 LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCwgbV9kaXNhYmxlZFJlZkNvdW50KTsKICNlbmRpZgogfQog CkBAIC0yMTAsOSArMjE1LDEyIEBAIHZvaWQgQXVkaW9Ob2RlOjpwcm9jZXNzSWZOZWNlc3Nhcnko c2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKICAgICAgICAgaWYgKCFzaWxlbnRJbnB1dHMpCiAgICAg ICAgICAgICBtX2xhc3ROb25TaWxlbnRUaW1lID0gKGNvbnRleHQoKS0+Y3VycmVudFNhbXBsZUZy YW1lKCkgKyBmcmFtZXNUb1Byb2Nlc3MpIC8gc3RhdGljX2Nhc3Q8ZG91YmxlPihtX3NhbXBsZVJh dGUpOwogCi0gICAgICAgIGlmIChzaWxlbnRJbnB1dHMgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkK KyAgICAgICAgaWYgKHNpbGVudElucHV0cyAmJiBwcm9wYWdhdGVzU2lsZW5jZSgpKSB7CisgICAg ICAgICAgICAvLyBUYWlsIHByb2Nlc3NpbmcgY2FuIGVuZCBub3cgYmVjYXVzZSB3ZSBhcmUgcHJv cGFnYXRpbmcgc2lsZW5jZS4KKyAgICAgICAgICAgIGVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQo KTsKICAgICAgICAgICAgIHNpbGVuY2VPdXRwdXRzKCk7Ci0gICAgICAgIGVsc2UgeworICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgYWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CiAg ICAgICAgICAgICBwcm9jZXNzKGZyYW1lc1RvUHJvY2Vzcyk7CiAgICAgICAgICAgICB1bnNpbGVu Y2VPdXRwdXRzKCk7CiAgICAgICAgIH0KQEAgLTI4Miw3ICsyOTAsNyBAQCB2b2lkIEF1ZGlvTm9k ZTo6cmVmKFJlZlR5cGUgcmVmVHlwZSkKICAgICB9CiAKICNpZiBERUJVR19BVURJT05PREVfUkVG RVJFTkNFUwotICAgIHByaW50ZigiJXA6ICVkOiBBdWRpb05vZGU6OnJlZiglZCkgJWQgJWQgJWRc biIsIHRoaXMsIG5vZGVUeXBlKCksIHJlZlR5cGUsIG1fbm9ybWFsUmVmQ291bnQsIG1fY29ubmVj dGlvblJlZkNvdW50LCBtX2Rpc2FibGVkUmVmQ291bnQpOworICAgIGZwcmludGYoc3RkZXJyLCAi JXA6ICVkOiBBdWRpb05vZGU6OnJlZiglZCkgJWQgJWQgJWRcbiIsIHRoaXMsIG5vZGVUeXBlKCks IHJlZlR5cGUsIG1fbm9ybWFsUmVmQ291bnQsIG1fY29ubmVjdGlvblJlZkNvdW50LCBtX2Rpc2Fi bGVkUmVmQ291bnQpOwogI2VuZGlmCiAKICAgICAvLyBTZWUgdGhlIGRpc2FibGluZyBjb2RlIGlu IGZpbmlzaERlcmVmKCkgYmVsb3cuIFRoaXMgaGFuZGxlcyB0aGUgY2FzZSB3aGVyZSBhIG5vZGUK QEAgLTM1NCw3ICszNjIsNyBAQCB2b2lkIEF1ZGlvTm9kZTo6ZmluaXNoRGVyZWYoUmVmVHlwZSBy ZWZUeXBlKQogICAgIH0KICAgICAKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwotICAg IHByaW50ZigiJXA6ICVkOiBBdWRpb05vZGU6OmRlcmVmKCVkKSAlZCAlZCAlZFxuIiwgdGhpcywg bm9kZVR5cGUoKSwgcmVmVHlwZSwgbV9ub3JtYWxSZWZDb3VudCwgbV9jb25uZWN0aW9uUmVmQ291 bnQsIG1fZGlzYWJsZWRSZWZDb3VudCk7CisgICAgZnByaW50ZihzdGRlcnIsICIlcDogJWQ6IEF1 ZGlvTm9kZTo6ZGVyZWYoJWQpICVkICVkICVkXG4iLCB0aGlzLCBub2RlVHlwZSgpLCByZWZUeXBl LCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCwgbV9kaXNhYmxlZFJlZkNv dW50KTsKICNlbmRpZgogCiAgICAgaWYgKCFtX2Nvbm5lY3Rpb25SZWZDb3VudCkgewpAQCAtMzc3 LDIwICszODUsMzggQEAgdm9pZCBBdWRpb05vZGU6OmZpbmlzaERlcmVmKFJlZlR5cGUgcmVmVHlw ZSkKICAgICAgICAgICAgICAgICAvLyBCdXQgaW50ZXJuYWxseSBvdXIgb3V0cHV0cyBzaG91bGQg YmUgZGlzYWJsZWQgZnJvbSB0aGUgaW5wdXRzIHRoZXkncmUgY29ubmVjdGVkIHRvLgogICAgICAg ICAgICAgICAgIC8vIGRpc2FibGUoKSBjYW4gcmVjdXJzaXZlbHkgZGVyZWYgY29ubmVjdGlvbnMg KGFuZCBjYWxsIGRpc2FibGUoKSkgZG93biBhIHdob2xlIGNoYWluIG9mIGNvbm5lY3RlZCBub2Rl cy4KIAotICAgICAgICAgICAgICAgIC8vIEZJWE1FOiB3ZSBzcGVjaWFsIGNhc2UgdGhlIGNvbnZv bHZlciBhbmQgZGVsYXkgc2luY2UgdGhleSBoYXZlIGEgc2lnbmlmaWNhbnQgdGFpbC10aW1lIGFu ZCBzaG91bGRuJ3QgYmUgZGlzY29ubmVjdGVkIHNpbXBseQotICAgICAgICAgICAgICAgIC8vIGJl Y2F1c2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkgaW5wdXQgY29ubmVjdGlvbnMuICBUaGlzIG5l ZWRzIHRvIGJlIGhhbmRsZWQgbW9yZSBnZW5lcmFsbHkgd2hlcmUgQXVkaW9Ob2RlcyBoYXZlCi0g ICAgICAgICAgICAgICAgLy8gYSB0YWlsVGltZSBhdHRyaWJ1dGUuICBUaGVuIHRoZSBBdWRpb05v ZGUgb25seSBuZWVkcyB0byByZW1haW4gImFjdGl2ZSIgZm9yIHRhaWxUaW1lIHNlY29uZHMgYWZ0 ZXIgdGhlcmUgYXJlIG5vCi0gICAgICAgICAgICAgICAgLy8gbG9uZ2VyIGFueSBhY3RpdmUgY29u bmVjdGlvbnMuCi0gICAgICAgICAgICAgICAgaWYgKG5vZGVUeXBlKCkgIT0gTm9kZVR5cGVDb252 b2x2ZXIgJiYgbm9kZVR5cGUoKSAhPSBOb2RlVHlwZURlbGF5KSB7Ci0gICAgICAgICAgICAgICAg ICAgIG1faXNEaXNhYmxlZCA9IHRydWU7Ci0gICAgICAgICAgICAgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBtX291dHB1dHMuc2l6ZSgpOyArK2kpCi0gICAgICAgICAgICAgICAgICAg ICAgICBvdXRwdXQoaSktPmRpc2FibGUoKTsKLSAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgbV9pc0Rpc2FibGVkID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbV9vdXRwdXRzLnNpemUoKTsgKytpKQorICAgICAgICAgICAgICAgICAgICBv dXRwdXQoaSktPmRpc2FibGUoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIH0K IAordm9pZCBBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpCit7CisgICAg aWYgKCFtX2FsbG93VGFpbFByb2Nlc3NpbmcgJiYgKGxhdGVuY3lUaW1lKCkgKyB0YWlsVGltZSgp ID4gMCkpIHsKKyAgICAgICAgLy8gRXN0YWJsaXNoIGEgcmVmIHRvIG91cnNlbGYgaWYgd2UgaGF2 ZW4ndCBhbHJlYWR5IHNvIHdlIGRvbid0IGdldCByZW1vdmVkIHdoZW4gYWxsIG5vZGVzCisgICAg ICAgIC8vIGhhdmUgZGlzY29ubmVjdGVkIGZyb20gdXMuIFdlIGhvbGQgdGhpcyByZWYgZHVyaW5n IHRoZSB0aW1lIHdoZW4gd2UgYXJlIHJlY2VpdmluZworICAgICAgICAvLyBub24tc2lsZW50IGlu cHV0LCBvciBkdXJpbmcgdGhlIHRpbWUgYWZ0ZXIgZmlyc3QgcmVjZWl2aW5nIHNpbGVudCBpbnB1 dCB3aGVuIHdlIGVtcHR5IHRoZQorICAgICAgICAvLyBwcm9jZXNzaW5nIHBpcGVsaW5lIHRvIGFj Y291bnQgZm9yIGxhdGVuY3kgYW5kIHRhaWwuCisgICAgICAgIG1fYWxsb3dUYWlsUHJvY2Vzc2lu ZyA9IHRydWU7CisgICAgICAgIGNvbnRleHQoKS0+YWRkRGVmZXJyZWRSZWZOb2RlKHRoaXMpOwor ICAgIH0KK30KKwordm9pZCBBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKQor eworICAgIEFTU0VSVChwcm9wYWdhdGVzU2lsZW5jZSgpKTsKKyAgICAKKyAgICBpZiAobV9hbGxv d1RhaWxQcm9jZXNzaW5nKSB7CisgICAgICAgIC8vIFN0b3AgdGFpbCBwcm9jZXNzaW5nLiBKdXN0 IG5lZWQgdG8gZGVyZWYgb3Vyc2VsZiwgYnV0IHdlIGNhbid0IGRvIHRoYXQgd2hpbGUgdGhlIGdy YXBoCisgICAgICAgIC8vIGlzIGJlaW5nIHJlbmRlcmVkLiBTY2hlZHVsZSB0aGUgZGVyZWYgdG8g aGFwcGVuIGR1cmluZyB0aGUgcG9zdC1yZW5kZXJpbmcgcGhhc2UuCisgICAgICAgIG1fYWxsb3dU YWlsUHJvY2Vzc2luZyA9IGZhbHNlOworICAgICAgICBjb250ZXh0KCktPmFkZERlZmVycmVkRGVy ZWZOb2RlKHRoaXMpOworICAgIH0KK30KKwogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VT CiAKIGJvb2wgQXVkaW9Ob2RlOjpzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQgPSBmYWxzZTsKQEAg LTM5OCwxNSArNDI0LDE1IEBAIGludCBBdWRpb05vZGU6OnNfbm9kZUNvdW50W05vZGVUeXBlRW5k XTsKIAogdm9pZCBBdWRpb05vZGU6OnByaW50Tm9kZUNvdW50cygpCiB7Ci0gICAgcHJpbnRmKCJc blxuIik7Ci0gICAgcHJpbnRmKCI9PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIpOwotICAg IHByaW50ZigiQXVkaW9Ob2RlOiByZWZlcmVuY2UgY291bnRzXG4iKTsKLSAgICBwcmludGYoIj09 PT09PT09PT09PT09PT09PT09PT09PT09PVxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICJcblxu Iik7CisgICAgZnByaW50ZihzdGRlcnIsICI9PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIp OworICAgIGZwcmludGYoc3RkZXJyLCAiQXVkaW9Ob2RlOiByZWZlcmVuY2UgY291bnRzXG4iKTsK KyAgICBmcHJpbnRmKHN0ZGVyciwgIj09PT09PT09PT09PT09PT09PT09PT09PT09PVxuIik7CiAK ICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgTm9kZVR5cGVFbmQ7ICsraSkKLSAgICAgICAg cHJpbnRmKCIlZDogJWRcbiIsIGksIHNfbm9kZUNvdW50W2ldKTsKKyAgICAgICAgZnByaW50Zihz dGRlcnIsICIlZDogJWRcbiIsIGksIHNfbm9kZUNvdW50W2ldKTsKIAotICAgIHByaW50ZigiPT09 PT09PT09PT09PT09PT09PT09PT09PT09XG5cblxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICI9 PT09PT09PT09PT09PT09PT09PT09PT09PT1cblxuXG4iKTsKIH0KIAogI2VuZGlmIC8vIERFQlVH X0FVRElPTk9ERV9SRUZFUkVOQ0VTCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb05vZGUuaAppbmRleCBjMjYxNGNiM2IxMmQ2ZDE1NTBmZGY3NGY4NDg4ZTQxZjQ1ZjljZGEy Li5lZDUyZjQwNDczZTU1OTBkNGVlM2E5ODIyYzdkMjg5ZDk5YzJmNDljIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKQEAgLTE1Myw2ICsxNTMsMTYgQEAg cHVibGljOgogICAgIHZvaWQgc2lsZW5jZU91dHB1dHMoKTsKICAgICB2b2lkIHVuc2lsZW5jZU91 dHB1dHMoKTsKIAorICAgIC8vIEFsbG93IHRhaWwgcHJvY2Vzc2luZyBmb3Igbm9kZXMgdGhhdCBo YXZlIHRhaWwgb3IgbGF0ZW5jeSB0aW1lLiBUaGlzIHdpbGwgY3JlYXRlIGFuCisgICAgLy8gYWRk aXRpb25hbCBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWxmIHNvIHdlIGRvbid0IGdldCByZW1vdmVk IGZyb20gdGhlIGdyYXBoIGJlZm9yZSB0aGUgdGFpbAorICAgIC8vIGhhcyBiZWVuIHByb2Nlc3Nl ZC4KKyAgICB2b2lkIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCisgICAgLy8gSWYg d2UncmUgcHJvY2Vzc2luZyB0aGUgdGFpbCBmb3IgdGhpcyBub2RlIGFuZCBhbGwgb3V0cHV0cyBz aG91bGQgYmUgcHJvcGFnYXRpbmcgc2lsZW5jZSwgd2UKKyAgICAvLyBlbmQgdGFpbCBwcm9jZXNz aW5nLiBUaGUgY29ubmVjdGlvbiByZWYgdG8gb3Vyc2VsZiB3aWxsIGJlIHJlbW92ZWQsIGJhbGFu Y2luZyB0aGUgcmVmZXJlbmNlCisgICAgLy8gYWRkZWQgaW4gYWxsb3dUYWlsUHJvY2Vzc2luZ0lm TmVlZGVkKCkuCisgICAgdm9pZCBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CisKIHByb3Rl Y3RlZDoKICAgICAvLyBJbnB1dHMgYW5kIG91dHB1dHMgbXVzdCBiZSBjcmVhdGVkIGJlZm9yZSB0 aGUgQXVkaW9Ob2RlIGlzIGluaXRpYWxpemVkLgogICAgIHZvaWQgYWRkSW5wdXQoUGFzc093blB0 cjxBdWRpb05vZGVJbnB1dD4pOwpAQCAtMTgxLDcgKzE5MSw5IEBAIHByaXZhdGU6CiAgICAgCiAg ICAgYm9vbCBtX2lzTWFya2VkRm9yRGVsZXRpb247CiAgICAgYm9vbCBtX2lzRGlzYWJsZWQ7Ci0g ICAgCisKKyAgICBib29sIG1fYWxsb3dUYWlsUHJvY2Vzc2luZzsKKwogI2lmIERFQlVHX0FVRElP Tk9ERV9SRUZFUkVOQ0VTCiAgICAgc3RhdGljIGJvb2wgc19pc05vZGVDb3VudEluaXRpYWxpemVk OwogICAgIHN0YXRpYyBpbnQgc19ub2RlQ291bnRbTm9kZVR5cGVFbmRdOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwIGIvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCmluZGV4IDEx MDU3NzMyNjA0OGFmZjA4YWY5ZTRlN2Y5MWI3MzNiMTgzYTJhYzcuLjU2NDlhOTgyMTUwMGUzNTcy ZWU4ZTc5ODMwZWFmODVkOTBjMjc3ZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKQEAgLTkxLDcgKzkxLDcgQEAgdm9pZCBB dWRpb1Bhbm5lck5vZGU6OnByb2Nlc3Moc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKIHsKICAgICBB dWRpb0J1cyogZGVzdGluYXRpb24gPSBvdXRwdXQoMCktPmJ1cygpOwogCi0gICAgaWYgKCFpc0lu aXRpYWxpemVkKCkgfHwgIWlucHV0KDApLT5pc0Nvbm5lY3RlZCgpIHx8ICFtX3Bhbm5lci5nZXQo KSkgeworICAgIGlmICghaXNJbml0aWFsaXplZCgpIHx8ICFtX3Bhbm5lci5nZXQoKSkgewogICAg ICAgICBkZXN0aW5hdGlvbi0+emVybygpOwogICAgICAgICByZXR1cm47CiAgICAgfQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4 IDMzMzM1MDhkOTI4ODNiMzVmMzU0OTVmMzExOTQ5OTQ2NTkzMmU4MWIuLmI4OTljYmViNWM3OTRm YTk5MTRjOTA5ZDQwMDhhOTYwNWMxOGZhOTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0w NC0xMSAgUmF5bW9uZCBUb3kgIDxydG95QGdvb2dsZS5jb20+CisKKyAgICAgICAgbm90ZUdyYWlu T24gaXMgdG9vIGxvbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTc3MjI0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgUmVtb3ZlIGV4dHJhRnJhbWVzSFJURiB0aGF0IGlzIG5vIGxvbmdlciBuZWVkZWQ6Cisg ICAgICAgICogd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qczoKKyAg ICAgICAgKGNyZWF0ZVNpZ25hbEJ1ZmZlcik6IAorICAgICAgICAodmVyaWZ5U3RhcnRBbmRFbmRG cmFtZXMpOgorCiAyMDEyLTA0LTMwICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0u b3JnPgogCiAgICAgICAgIE5vdCByZXZpZXdlZDogY2hyb21pdW0gZXhwZWN0YXRpb25zIHVwZGF0 ZWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNvdXJjZXMvbm90ZS1ncmFp bi1vbi10ZXN0aW5nLmpzIGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3Jh aW4tb24tdGVzdGluZy5qcwppbmRleCA0NWRkNzJmY2FhZGIyODQ3ZDlkMmU0YjU4Y2MxYjRjMDZi YTVjZTk5Li4zYjQ0OGFhMWIwY2Y4OWQ2OWEyMmU4MDFhMzhkZmY3NzllMzg4ZWY4IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNvdXJjZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5n LmpzCisrKyBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRl c3RpbmcuanMKQEAgLTEsMTEgKzEsNSBAQAogdmFyIHNhbXBsZVJhdGUgPSA0NDEwMC4wOwogCi0v LyBIUlRGIGV4dHJhIGZyYW1lcy4gIFRoaXMgaXMgYSBtYWdpYyBjb25zdGFudCBjdXJyZW50bHkg aW4KLS8vIEF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cHJvY2VzcyB0aGF0IGFsd2F5cyBleHRlbmRz IHRoZQotLy8gZHVyYXRpb24gYnkgdGhpcyBudW1iZXIgb2Ygc2FtcGxlcy4gIFNlZSBidWcgNzcy MjQKLS8vIChodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcyMjQpLgot dmFyIGV4dHJhRnJhbWVzSFJURiA9IDUxMjsKLQogLy8gSG93IG1hbnkgZ3JhaW5zIHRvIHBsYXku CiB2YXIgbnVtYmVyT2ZUZXN0cyA9IDEwMDsKIApAQCAtMTMsOSArNyw4IEBAIHZhciBudW1iZXJP ZlRlc3RzID0gMTAwOwogdmFyIGR1cmF0aW9uID0gMC4wMTsKIAogLy8gVGltZSBzdGVwIGJldHdl ZW4gdGhlIHN0YXJ0IG9mIGVhY2ggZ3JhaW4uICBXZSBuZWVkIHRvIGFkZCBhIGxpdHRsZQotLy8g Yml0IG9mIHNpbGVuY2Ugc28gd2UgY2FuIGRldGVjdCBncmFpbiBib3VuZGFyaWVzIGFuZCBhbHNv IGFjY291bnQKLS8vIGZvciB0aGUgZXh0cmEgZnJhbWVzIGZvciBIUlRGLgotdmFyIHRpbWVTdGVw ID0gZHVyYXRpb24gKyAuMDA1ICsgZXh0cmFGcmFtZXNIUlRGIC8gc2FtcGxlUmF0ZTsKKy8vIGJp dCBvZiBzaWxlbmNlIHNvIHdlIGNhbiBkZXRlY3QgZ3JhaW4gYm91bmRhcmllcy4KK3ZhciB0aW1l U3RlcCA9IGR1cmF0aW9uICsgLjAwNTsKIAogLy8gVGltZSBzdGVwIGJldHdlZW4gdGhlIHN0YXJ0 IGZvciBlYWNoIGdyYWluLgogdmFyIGdyYWluT2Zmc2V0U3RlcCA9IDAuMDAxOwpAQCAtMzAsMTAg KzIzLDkgQEAgdmFyIHJlbmRlcmVkRGF0YTsKIC8vIHJldHVybnMgdGhlIGRlc2lyZWQgdmFsdWUg YXQgc2FtcGxlIGZyYW1lIGsuCiBmdW5jdGlvbiBjcmVhdGVTaWduYWxCdWZmZXIoY29udGV4dCwg ZikgewogCi0gICAgLy8gTWFrZSBzdXJlIHRoZSBidWZmZXIgaGFzIGVub3VnaCBkYXRhIGZvciBh bGwgb2YgdGhlIHBvc3NpYmxlCi0gICAgLy8gZ3JhaW4gb2Zmc2V0cyBhbmQgZHVyYXRpb25zLiAg TmVlZCB0byBpbmNsdWRlIHRoZSBleHRyYSBmcmFtZXMKLSAgICAvLyBmb3IgSFJURi4gIFRoZSBh ZGRpdGlvbmFsIDEgaXMgZm9yIGFueSByb3VuZC1vZmYgZXJyb3JzLgotICAgIHZhciBzaWduYWxM ZW5ndGggPSBNYXRoLmZsb29yKDEgKyBleHRyYUZyYW1lc0hSVEYgKyBzYW1wbGVSYXRlICogKG51 bWJlck9mVGVzdHMgKiBncmFpbk9mZnNldFN0ZXAgKyBkdXJhdGlvbikpOworICAgIC8vIE1ha2Ug c3VyZSB0aGUgYnVmZmVyIGhhcyBlbm91Z2ggZGF0YSBmb3IgYWxsIG9mIHRoZSBwb3NzaWJsZSBn cmFpbiBvZmZzZXRzIGFuZCBkdXJhdGlvbnMuCisgICAgLy8gVGhlIGFkZGl0aW9uYWwgMSBpcyBm b3IgYW55IHJvdW5kLW9mZiBlcnJvcnMuCisgICAgdmFyIHNpZ25hbExlbmd0aCA9IE1hdGguZmxv b3IoMSArIHNhbXBsZVJhdGUgKiAobnVtYmVyT2ZUZXN0cyAqIGdyYWluT2Zmc2V0U3RlcCArIGR1 cmF0aW9uKSk7CiAKICAgICB2YXIgYnVmZmVyID0gY29udGV4dC5jcmVhdGVCdWZmZXIoMiwgc2ln bmFsTGVuZ3RoLCBzYW1wbGVSYXRlKTsKICAgICB2YXIgZGF0YSA9IGJ1ZmZlci5nZXRDaGFubmVs RGF0YSgwKTsKQEAgLTEzMyw5ICsxMjUsOCBAQCBmdW5jdGlvbiB2ZXJpZnlTdGFydEFuZEVuZEZy YW1lcyhzdGFydEVuZEZyYW1lcykgewogICAgIC8vIGV4cGVjdGF0aW9ucy4KICAgICBmb3IgKHZh ciBrID0gMDsgayA8IHN0YXJ0RnJhbWVzLmxlbmd0aDsgKytrKSB7CiAgICAgICAgIHZhciBleHBl Y3RlZFN0YXJ0ID0gdGltZVRvU2FtcGxlRnJhbWUoayAqIHRpbWVTdGVwLCBzYW1wbGVSYXRlKTsK LSAgICAgICAgLy8gVGhlIGVuZCBwb2ludCBpcyB0aGUgZHVyYXRpb24sIHBsdXMgdGhlIGV4dHJh IGZyYW1lcwotICAgICAgICAvLyBmb3IgSFJURi4KLSAgICAgICAgdmFyIGV4cGVjdGVkRW5kID0g ZXh0cmFGcmFtZXNIUlRGICsgZXhwZWN0ZWRTdGFydCArIGdyYWluTGVuZ3RoSW5TYW1wbGVGcmFt ZXMoayAqIGdyYWluT2Zmc2V0U3RlcCwgZHVyYXRpb24sIHNhbXBsZVJhdGUpOworICAgICAgICAv LyBUaGUgZW5kIHBvaW50IGlzIHRoZSBkdXJhdGlvbi4KKyAgICAgICAgdmFyIGV4cGVjdGVkRW5k ID0gZXhwZWN0ZWRTdGFydCArIGdyYWluTGVuZ3RoSW5TYW1wbGVGcmFtZXMoayAqIGdyYWluT2Zm c2V0U3RlcCwgZHVyYXRpb24sIHNhbXBsZVJhdGUpOwogCiAgICAgICAgIGlmIChzdGFydEZyYW1l c1trXSAhPSBleHBlY3RlZFN0YXJ0KSB7CiAgICAgICAgICAgICB0ZXN0RmFpbGVkKCJQdWxzZSAi ICsgayArICIgc3RhcnRlZCBhdCAiICsgc3RhcnRGcmFtZXNba10gKyAiIGJ1dCBleHBlY3RlZCBh dCAiICsgZXhwZWN0ZWRTdGFydCk7Cg== 140353 2012-05-04 16:12:14 -0700 2012-06-25 22:40:21 -0700 Patch bug-77224-20120504161213.patch text/plain 16457 rtoy U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2MDczCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTIyOGNhZTllNGEwNzVm ODAzZjYwYmQ1OGJkZDZkY2ViMDgzNTYzMS4uZWM0OTU0NDFlZjRiYzdkNjA3YzgyNWUzYzA3ZDg5 ZmY3NTNlMDlmYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA0LTA1ICBSYXlt b25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5PbiBpcyB0b28g bG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcy MjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBub3Rl LWdyYWluLW9uIHRlc3QgdXBkYXRlZCB0byBzaG93IHRoZSBidWcgaGFzIGJlZW4gZml4ZWQuICBB bHNvCisgICAgICAgIHRyeSBvdXQgaHR0cDovL3N0YXRpYy5lY2hvbmVzdC5jb20vQm9oZW1pYW5S aGFwc2ljaG9yZC9pbmRleC5odG1sCisgICAgICAgIHdoaWNoIG5vIGxvbmdlciBoYXMgZ2xpdGNo ZXMgYW5kCisgICAgICAgIGh0dHA6Ly9jaHJvbWl1bS5nb29nbGVjb2RlLmNvbS9zdm4vdHJ1bmsv c2FtcGxlcy9hdWRpby9ncmFudWxhci5odG1sCisgICAgICAgIHdoaWNoIHN0aWxsIHNvdW5kcyBn b29kLgorCisgICAgICAgICogd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcik6 IFJlbW92ZSBleHRyYSBmcmFtZXMuCisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBpbXBsZW1l bnQgdGFpbCBwcm9jZXNzaW5nIHRvIGZpeCBub3RlLWdyYWluLW9uIGJ1Zy4KKyAgICAgICAgKiB3 ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjph ZGREZWZlcnJlZFJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVE ZWZlcnJlZFJlZk5vZGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6YWRkRGVmZXJy ZWREZXJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpoYW5kbGVEZWZlcnJl ZERlcmVmTm9kZXMpOgorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oOiBEZWNsYXJh dGlvbnMgb2YgbmV3IGZ1bmN0aW9ucyBhbmQgc2xvdHMKKyAgICAgICAgdG8gc3VwcG9ydCB0YWls IHByb2Nlc3NpbmcuCisgICAgICAgIAorICAgICAgICAqIHdlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1ZGlvTm9kZSk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgorCisgICAgICAg IEZpeCBQYW5uZXIgbm9kZSB0byBhbGxvdyB0YWlsIHByb2Nlc3NpbmcuCisgICAgICAgICogd2Vi YXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFubmVy Tm9kZTo6cHJvY2Vzcyk6IE5lZWQgdG8gY29udGludWUgcHJvY2Vzc2luZworICAgICAgICBmb3Ig dGFpbCB0aW1lIGV2ZW4gaWYgdGhlIGlucHV0IGlzIGRpc2Nvbm5lY3RlZC4KKwogMjAxMi0wNS0w MyAgRGF2aWQgQmFyciAgPGRhdmlkYmFyckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQW50aWFs aWFzIHNpbmdsZS1lZGdlIHNvbGlkIGJvcmRlcnMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcCBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcAppbmRleCA0M2E5 Y2I0OGFjNWY0MTRjZmQ5YTg1MjBjYjg0Y2JiZjZjNTZlYjU3Li40OTQ3NzJkZDQ5NWE3MWExZjhk YjE4MTJhMmY5YTEyZTg3M2I1OTMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCkBAIC0yMzMsMTEgKzIz Myw2IEBAIHZvaWQgQXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5kZXJGcm9tQnVmZmVyKEF1ZGlv QnVzKiBidXMsIHVuc2lnbmVkIGRlc3RpbmF0aW9uCiAgICAgCiAgICAgdW5zaWduZWQgZGVsdGFG cmFtZXMgPSBlbmRGcmFtZSAtIHN0YXJ0RnJhbWU7CiAgICAgCi0gICAgLy8gVGhpcyBpcyBhIEhB Q0sgdG8gYWxsb3cgZm9yIEhSVEYgdGFpbC10aW1lIC0gYXZvaWRzIGdsaXRjaCBhdCBlbmQuCi0g ICAgLy8gRklYTUU6IGltcGxlbWVudCB0YWlsVGltZSBmb3IgZWFjaCBBdWRpb05vZGUgZm9yIGEg bW9yZSBnZW5lcmFsIHNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbS4KLSAgICBpZiAobV9pc0dyYWlu KQotICAgICAgICBlbmRGcmFtZSArPSA1MTI7Ci0KICAgICAvLyBEbyBzb21lIHNhbml0eSBjaGVj a2luZy4KICAgICBpZiAoc3RhcnRGcmFtZSA+PSBidWZmZXJMZW5ndGgpCiAgICAgICAgIHN0YXJ0 RnJhbWUgPSAhYnVmZmVyTGVuZ3RoID8gMCA6IGJ1ZmZlckxlbmd0aCAtIDE7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAKaW5kZXggOWI0MDQz MjQzNGQ4MmI3YWViZWI4NmUxNDhhN2Q0MjgzNjA3NDUzMi4uODZjOTQ1MTY0NDE5MWYyMDYyNWM4 ZDU3YjBlZjEwOWVlYzI4YzBmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2Vi YXVkaW8vQXVkaW9Db250ZXh0LmNwcApAQCAtNTUwLDcgKzU1MCw3IEBAIHZvaWQgQXVkaW9Db250 ZXh0OjpkZXJlZkZpbmlzaGVkU291cmNlTm9kZXMoKQogCiB2b2lkIEF1ZGlvQ29udGV4dDo6cmVm Tm9kZShBdWRpb05vZGUqIG5vZGUpCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAg ICBBU1NFUlQoaXNNYWluVGhyZWFkKCkgfHwgKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3du ZXIoKSkpOwogICAgIEF1dG9Mb2NrZXIgbG9ja2VyKHRoaXMpOwogICAgIAogICAgIG5vZGUtPnJl ZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsKQEAgLTU4Miw4ICs1ODIsNyBAQCB2b2lk IEF1ZGlvQ29udGV4dDo6ZGVyZWZVbmZpbmlzaGVkU291cmNlTm9kZXMoKQogCiB2b2lkIEF1ZGlv Q29udGV4dDo6bG9jayhib29sJiBtdXN0UmVsZWFzZUxvY2spCiB7Ci0gICAgLy8gRG9uJ3QgYWxs b3cgcmVndWxhciBsb2NrIGluIHJlYWwtdGltZSBhdWRpbyB0aHJlYWQuCi0gICAgQVNTRVJUKGlz TWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkgfHwgKGlzQXVkaW9UaHJl YWQoKSAmJiBpc0dyYXBoT3duZXIoKSkpOwogCiAgICAgVGhyZWFkSWRlbnRpZmllciB0aGlzVGhy ZWFkID0gY3VycmVudFRocmVhZCgpOwogCkBAIC02NDksNiArNjQ4LDE4IEBAIGJvb2wgQXVkaW9D b250ZXh0Ojppc0dyYXBoT3duZXIoKSBjb25zdAogICAgIHJldHVybiBjdXJyZW50VGhyZWFkKCkg PT0gbV9ncmFwaE93bmVyVGhyZWFkOwogfQogCit2b2lkIEF1ZGlvQ29udGV4dDo6YWRkRGVmZXJy ZWRSZWZOb2RlKEF1ZGlvTm9kZSogbm9kZSkKK3sKKyAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgp KTsKKyAgICBtX2RlZmVycmVkUmVmTGlzdC5hcHBlbmQobm9kZSk7Cit9CisKK3ZvaWQgQXVkaW9D b250ZXh0OjphZGREZWZlcnJlZERlcmVmTm9kZShBdWRpb05vZGUqIG5vZGUpCit7CisgICAgQVNT RVJUKGlzQXVkaW9UaHJlYWQoKSk7CisgICAgbV9kZWZlcnJlZERlcmVmTGlzdC5hcHBlbmQobm9k ZSk7Cit9CisKIHZvaWQgQXVkaW9Db250ZXh0OjphZGREZWZlcnJlZEZpbmlzaERlcmVmKEF1ZGlv Tm9kZSogbm9kZSwgQXVkaW9Ob2RlOjpSZWZUeXBlIHJlZlR5cGUpCiB7CiAgICAgQVNTRVJUKGlz QXVkaW9UaHJlYWQoKSk7CkBAIC02ODMsNiArNjk0LDEwIEBAIHZvaWQgQXVkaW9Db250ZXh0Ojpo YW5kbGVQb3N0UmVuZGVyVGFza3MoKQogICAgIC8vIGZyb20gdGhlIHJlbmRlciBncmFwaCAoaW4g d2hpY2ggY2FzZSB0aGV5J2xsIHJlbmRlciBzaWxlbmNlKS4KICAgICBib29sIG11c3RSZWxlYXNl TG9jazsKICAgICBpZiAodHJ5TG9jayhtdXN0UmVsZWFzZUxvY2spKSB7CisgICAgICAgIC8vIFRh a2UgY2FyZSBvZiBhbnkgZGVmZXJyZWQgcmVmTm9kZXMgYW5kIGRlZmVycmVkIGRlcmVmTm9kZXMg dGhhdCB3ZXJlIGFkZGVkLgorICAgICAgICBoYW5kbGVEZWZlcnJlZFJlZk5vZGVzKCk7CisgICAg ICAgIGhhbmRsZURlZmVycmVkRGVyZWZOb2RlcygpOworICAgICAgICAKICAgICAgICAgLy8gVGFr ZSBjYXJlIG9mIGZpbmlzaGluZyBhbnkgZGVyZWZzIHdoZXJlIHRoZSB0cnlMb2NrKCkgZmFpbGVk IHByZXZpb3VzbHkuCiAgICAgICAgIGhhbmRsZURlZmVycmVkRmluaXNoRGVyZWZzKCk7CiAKQEAg LTcwNCw2ICs3MTksMzAgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RSZW5kZXJUYXNr cygpCiAgICAgfQogfQogCit2b2lkIEF1ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWRSZWZOb2Rl cygpCit7CisgICAgQVNTRVJUKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3duZXIoKSk7CisK KyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9kZWZlcnJlZFJlZkxpc3Quc2l6ZSgpOyAr K2kpIHsKKyAgICAgICAgQXVkaW9Ob2RlKiBub2RlID0gbV9kZWZlcnJlZFJlZkxpc3RbaV07Cisg ICAgICAgIC8vIEFkZCBhIHJlZmVyZW5jZSB0byBub2RlIHRvIHRlbGwgdGhlIGNvbnRleHQgdGhh dCB0aGlzIG5vZGUgaXMgc3RpbGwgYWxpdmUuCisgICAgICAgIHJlZk5vZGUobm9kZSk7CisgICAg fQorICAgIAorICAgIG1fZGVmZXJyZWRSZWZMaXN0LmNsZWFyKCk7Cit9CisKK3ZvaWQgQXVkaW9D b250ZXh0OjpoYW5kbGVEZWZlcnJlZERlcmVmTm9kZXMoKQoreworICAgIEFTU0VSVChpc0F1ZGlv VGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBtX2RlZmVycmVkRGVyZWZMaXN0LnNpemUoKTsgKytpKSB7CisgICAgICAgIEF1ZGlvTm9kZSog bm9kZSA9IG1fZGVmZXJyZWREZXJlZkxpc3RbaV07CisgICAgICAgIGRlcmVmTm9kZShub2RlKTsK KyAgICB9CisgICAgCisgICAgbV9kZWZlcnJlZERlcmVmTGlzdC5jbGVhcigpOworfQorCiB2b2lk IEF1ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKQogewogICAgIEFTU0VS VChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKaW5kZXggZWRiODdlN2U0ZmRjODE3ZWRl NmEyOGRmZGIzNGMxN2I4MWM3MTA1Yy4uOWZlZTQxZTAwYmE5NTNhMDBmZGIxODkyOTY0ODAwMWVj YWFmNTU2NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRp b0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29u dGV4dC5oCkBAIC0yMTAsNiArMjEwLDIyIEBAIHB1YmxpYzoKICAgICAgICAgQXVkaW9Db250ZXh0 KiBtX2NvbnRleHQ7CiAgICAgICAgIGJvb2wgbV9tdXN0UmVsZWFzZUxvY2s7CiAgICAgfTsKKwor ICAgIC8vIEFkZCBhdWRpbyBub2RlIHRvIGxpc3Qgb2Ygbm9kZXMgdGhhdCB3ZSB3YW50IHRvIGNh bGwgcmVmTm9kZSgpIG9uLiBUaGVyZSBtdXN0IGV2ZW50dWFsbHkgYmUgYQorICAgIC8vIGNhbGwg dG8gYWRkRGVmZXJyZWREZXJlZk5vZGUoKSBmb3IgdGhlIHNhbWUgbm9kZS4KKyAgICB2b2lkIGFk ZERlZmVycmVkUmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIER1cmluZyBwb3N0IHJlbmRl ciBwcm9jZXNzaW5nLCBhbGwgdGhlIG5vZGVzIGFkZGVkIGJ5IGFkZERlZmVycmVkUmVmTm9kZXMo KSB3aWxsIGJlIGFkZGVkIHRvCisgICAgLy8gbV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0ZWxs IHRoZSBjb250ZXh0IHRoYXQgdGhlc2Ugbm9kZXMgYXJlIHN0aWxsIGFsaXZlLgorICAgIHZvaWQg aGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOworCisgICAgLy8gVGhlIG9wcG9zaXRlIG9mIGFkZERl ZmVycmVkUmVmTm9kZSgpLiBUaGlzIGluZGljYXRlcyB0aGF0IHRoZSBub2RlIHNob3VsZCBiZSBk ZXJlZidlZCBkdXJpbmcKKyAgICAvLyBwb3N0IHJlbmRlciBwcm9jZXNzaW5nIGFuZCByZW1vdmVk IGZyb20gdGhlIG1fcmVmZXJlbmNlZE5vZGVzIGxpc3QuCisgICAgdm9pZCBhZGREZWZlcnJlZERl cmVmTm9kZShBdWRpb05vZGUqKTsKKworICAgIC8vIFByb2Nlc3MgdGhlIGxpc3Qgb2Ygbm9kZXMg YWRkZWQgYnkgYWRkRGVmZXJyZWREZXJlZk5vZGUuIFRoaXMgZGVyZWYncyB0aGUgbm9kZSBmcm9t IHRoZSBncmFwaAorICAgIC8vIGFuZCByZW1vdmVzIHRoZSBub2RlIGZyb20gbV9yZWZlcmVuY2Vk Tm9kZXMgbGlzdCB0byB0ZWxsIHRoZSBjb250ZXh0IHRoZSBub2RlIGlzIG5vIGxvbmdlciBhY3Rp dmUuCisgICAgdm9pZCBoYW5kbGVEZWZlcnJlZERlcmVmTm9kZXMoKTsKICAgICAKICAgICAvLyBJ biBBdWRpb05vZGU6OmRlcmVmKCkgYSB0cnlMb2NrKCkgaXMgdXNlZCBmb3IgY2FsbGluZyBmaW5p c2hEZXJlZigpLCBidXQgaWYgaXQgZmFpbHMga2VlcCB0cmFjayBoZXJlLgogICAgIHZvaWQgYWRk RGVmZXJyZWRGaW5pc2hEZXJlZihBdWRpb05vZGUqLCBBdWRpb05vZGU6OlJlZlR5cGUpOwpAQCAt MzE3LDYgKzMzMywxMiBAQCBwcml2YXRlOgogCiAgICAgLy8gT25seSBhY2Nlc3NlZCBpbiB0aGUg YXVkaW8gdGhyZWFkLgogICAgIFZlY3RvcjxSZWZJbmZvPiBtX2RlZmVycmVkRmluaXNoRGVyZWZM aXN0OworCisgICAgLy8gTGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8gY2FsbCByZWZOb2Rl KCkgb24gdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZSBub2RlIGlzIHN0aWxsIGFjdGl2ZS4K KyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZFJlZkxpc3Q7CisKKyAgICAvLyBMaXN0 IG9mIG5vZGVzIHRoYXQgd2Ugd2FudCB0byBkZXJlZiBkdXJpbmcgcG9zdCByZW5kZXIgcHJvY2Vz c2luZy4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZERlcmVmTGlzdDsKICAgICAK ICAgICAvLyBIUlRGIERhdGFiYXNlIGxvYWRlcgogICAgIFJlZlB0cjxIUlRGRGF0YWJhc2VMb2Fk ZXI+IG1faHJ0ZkRhdGFiYXNlTG9hZGVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJh dWRpby9BdWRpb05vZGUuY3BwCmluZGV4IDhhZjlmYzczNDQxMDkzOGYyZDMxYzE2ODUyZGU5OWRj NGZhNDZmMzcuLjliODBmMDYyMDc1YmFkZGU4N2ZhZTc1OTU4OWQ0YmI0MDcxNDk0NzAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHAKQEAgLTUwLDYg KzUwLDcgQEAgQXVkaW9Ob2RlOjpBdWRpb05vZGUoQXVkaW9Db250ZXh0KiBjb250ZXh0LCBmbG9h dCBzYW1wbGVSYXRlKQogICAgICwgbV9kaXNhYmxlZFJlZkNvdW50KDApCiAgICAgLCBtX2lzTWFy a2VkRm9yRGVsZXRpb24oZmFsc2UpCiAgICAgLCBtX2lzRGlzYWJsZWQoZmFsc2UpCisgICAgLCBt X2FsbG93VGFpbFByb2Nlc3NpbmcoZmFsc2UpCiB7CiAjaWYgREVCVUdfQVVESU9OT0RFX1JFRkVS RU5DRVMKICAgICBpZiAoIXNfaXNOb2RlQ291bnRJbml0aWFsaXplZCkgewpAQCAtMjEwLDkgKzIx MSwxMiBAQCB2b2lkIEF1ZGlvTm9kZTo6cHJvY2Vzc0lmTmVjZXNzYXJ5KHNpemVfdCBmcmFtZXNU b1Byb2Nlc3MpCiAgICAgICAgIGlmICghc2lsZW50SW5wdXRzKQogICAgICAgICAgICAgbV9sYXN0 Tm9uU2lsZW50VGltZSA9IChjb250ZXh0KCktPmN1cnJlbnRTYW1wbGVGcmFtZSgpICsgZnJhbWVz VG9Qcm9jZXNzKSAvIHN0YXRpY19jYXN0PGRvdWJsZT4obV9zYW1wbGVSYXRlKTsKIAotICAgICAg ICBpZiAoc2lsZW50SW5wdXRzICYmIHByb3BhZ2F0ZXNTaWxlbmNlKCkpCisgICAgICAgIGlmIChz aWxlbnRJbnB1dHMgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkgeworICAgICAgICAgICAgLy8gVGFp bCBwcm9jZXNzaW5nIGNhbiBlbmQgbm93IGJlY2F1c2Ugd2UgYXJlIHByb3BhZ2F0aW5nIHNpbGVu Y2UuCisgICAgICAgICAgICBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CiAgICAgICAgICAg ICBzaWxlbmNlT3V0cHV0cygpOwotICAgICAgICBlbHNlIHsKKyAgICAgICAgfSBlbHNlIHsKKyAg ICAgICAgICAgIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOwogICAgICAgICAgICAgcHJv Y2VzcyhmcmFtZXNUb1Byb2Nlc3MpOwogICAgICAgICAgICAgdW5zaWxlbmNlT3V0cHV0cygpOwog ICAgICAgICB9CkBAIC0zNzcsMjAgKzM4MSwzOCBAQCB2b2lkIEF1ZGlvTm9kZTo6ZmluaXNoRGVy ZWYoUmVmVHlwZSByZWZUeXBlKQogICAgICAgICAgICAgICAgIC8vIEJ1dCBpbnRlcm5hbGx5IG91 ciBvdXRwdXRzIHNob3VsZCBiZSBkaXNhYmxlZCBmcm9tIHRoZSBpbnB1dHMgdGhleSdyZSBjb25u ZWN0ZWQgdG8uCiAgICAgICAgICAgICAgICAgLy8gZGlzYWJsZSgpIGNhbiByZWN1cnNpdmVseSBk ZXJlZiBjb25uZWN0aW9ucyAoYW5kIGNhbGwgZGlzYWJsZSgpKSBkb3duIGEgd2hvbGUgY2hhaW4g b2YgY29ubmVjdGVkIG5vZGVzLgogCi0gICAgICAgICAgICAgICAgLy8gRklYTUU6IHdlIHNwZWNp YWwgY2FzZSB0aGUgY29udm9sdmVyIGFuZCBkZWxheSBzaW5jZSB0aGV5IGhhdmUgYSBzaWduaWZp Y2FudCB0YWlsLXRpbWUgYW5kIHNob3VsZG4ndCBiZSBkaXNjb25uZWN0ZWQgc2ltcGx5Ci0gICAg ICAgICAgICAgICAgLy8gYmVjYXVzZSB0aGV5IG5vIGxvbmdlciBoYXZlIGFueSBpbnB1dCBjb25u ZWN0aW9ucy4gIFRoaXMgbmVlZHMgdG8gYmUgaGFuZGxlZCBtb3JlIGdlbmVyYWxseSB3aGVyZSBB dWRpb05vZGVzIGhhdmUKLSAgICAgICAgICAgICAgICAvLyBhIHRhaWxUaW1lIGF0dHJpYnV0ZS4g IFRoZW4gdGhlIEF1ZGlvTm9kZSBvbmx5IG5lZWRzIHRvIHJlbWFpbiAiYWN0aXZlIiBmb3IgdGFp bFRpbWUgc2Vjb25kcyBhZnRlciB0aGVyZSBhcmUgbm8KLSAgICAgICAgICAgICAgICAvLyBsb25n ZXIgYW55IGFjdGl2ZSBjb25uZWN0aW9ucy4KLSAgICAgICAgICAgICAgICBpZiAobm9kZVR5cGUo KSAhPSBOb2RlVHlwZUNvbnZvbHZlciAmJiBub2RlVHlwZSgpICE9IE5vZGVUeXBlRGVsYXkpIHsK LSAgICAgICAgICAgICAgICAgICAgbV9pc0Rpc2FibGVkID0gdHJ1ZTsKLSAgICAgICAgICAgICAg ICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fb3V0cHV0cy5zaXplKCk7ICsraSkKLSAg ICAgICAgICAgICAgICAgICAgICAgIG91dHB1dChpKS0+ZGlzYWJsZSgpOwotICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICBtX2lzRGlzYWJsZWQgPSB0cnVlOworICAgICAgICAgICAg ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBtX291dHB1dHMuc2l6ZSgpOyArK2kpCisgICAg ICAgICAgICAgICAgICAgIG91dHB1dChpKS0+ZGlzYWJsZSgpOwogICAgICAgICAgICAgfQogICAg ICAgICB9CiAgICAgfQogfQogCit2b2lkIEF1ZGlvTm9kZTo6YWxsb3dUYWlsUHJvY2Vzc2luZ0lm TmVlZGVkKCkKK3sKKyAgICBpZiAoIW1fYWxsb3dUYWlsUHJvY2Vzc2luZyAmJiAobGF0ZW5jeVRp bWUoKSArIHRhaWxUaW1lKCkgPiAwKSkgeworICAgICAgICAvLyBFc3RhYmxpc2ggYSByZWYgdG8g b3Vyc2VsZiBpZiB3ZSBoYXZlbid0IGFscmVhZHkgc28gd2UgZG9uJ3QgZ2V0IHJlbW92ZWQgd2hl biBhbGwgbm9kZXMKKyAgICAgICAgLy8gaGF2ZSBkaXNjb25uZWN0ZWQgZnJvbSB1cy4gV2UgaG9s ZCB0aGlzIHJlZiBkdXJpbmcgdGhlIHRpbWUgd2hlbiB3ZSBhcmUgcmVjZWl2aW5nCisgICAgICAg IC8vIG5vbi1zaWxlbnQgaW5wdXQsIG9yIGR1cmluZyB0aGUgdGltZSBhZnRlciBmaXJzdCByZWNl aXZpbmcgc2lsZW50IGlucHV0IHdoZW4gd2UgZW1wdHkgdGhlCisgICAgICAgIC8vIHByb2Nlc3Np bmcgcGlwZWxpbmUgdG8gYWNjb3VudCBmb3IgbGF0ZW5jeSBhbmQgdGFpbC4KKyAgICAgICAgbV9h bGxvd1RhaWxQcm9jZXNzaW5nID0gdHJ1ZTsKKyAgICAgICAgY29udGV4dCgpLT5hZGREZWZlcnJl ZFJlZk5vZGUodGhpcyk7CisgICAgfQorfQorCit2b2lkIEF1ZGlvTm9kZTo6ZW5kVGFpbFByb2Nl c3NpbmdJZk5lZWRlZCgpCit7CisgICAgQVNTRVJUKHByb3BhZ2F0ZXNTaWxlbmNlKCkpOworICAg IAorICAgIGlmIChtX2FsbG93VGFpbFByb2Nlc3NpbmcpIHsKKyAgICAgICAgLy8gU3RvcCB0YWls IHByb2Nlc3NpbmcuIEp1c3QgbmVlZCB0byBkZXJlZiBvdXJzZWxmLCBidXQgd2UgY2FuJ3QgZG8g dGhhdCB3aGlsZSB0aGUgZ3JhcGgKKyAgICAgICAgLy8gaXMgYmVpbmcgcmVuZGVyZWQuIFNjaGVk dWxlIHRoZSBkZXJlZiB0byBoYXBwZW4gZHVyaW5nIHRoZSBwb3N0LXJlbmRlcmluZyBwaGFzZS4K KyAgICAgICAgbV9hbGxvd1RhaWxQcm9jZXNzaW5nID0gZmFsc2U7CisgICAgICAgIGNvbnRleHQo KS0+YWRkRGVmZXJyZWREZXJlZk5vZGUodGhpcyk7CisgICAgfQorfQorCiAjaWYgREVCVUdfQVVE SU9OT0RFX1JFRkVSRU5DRVMKIAogYm9vbCBBdWRpb05vZGU6OnNfaXNOb2RlQ291bnRJbml0aWFs aXplZCA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRp by9BdWRpb05vZGUuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2Rl LmgKaW5kZXggNjRjNWYyNjJlNDIyMDZkMTgzYjdhOTI0OGJlZjIxMmIwMGFkNGFlMy4uMGJhNTg1 ODM2NTFiOTQ1MTBiZTRlNzJmMWFiZDM0MDk5ZjRkYWZkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCkBAIC0xNTMsNiArMTUzLDE2IEBAIHB1YmxpYzoK ICAgICB2b2lkIHNpbGVuY2VPdXRwdXRzKCk7CiAgICAgdm9pZCB1bnNpbGVuY2VPdXRwdXRzKCk7 CiAKKyAgICAvLyBBbGxvdyB0YWlsIHByb2Nlc3NpbmcgZm9yIG5vZGVzIHRoYXQgaGF2ZSB0YWls IG9yIGxhdGVuY3kgdGltZS4gVGhpcyB3aWxsIGNyZWF0ZSBhbgorICAgIC8vIGFkZGl0aW9uYWwg Y29ubmVjdGlvbiByZWYgdG8gb3Vyc2VsZiBzbyB3ZSBkb24ndCBnZXQgcmVtb3ZlZCBmcm9tIHRo ZSBncmFwaCBiZWZvcmUgdGhlIHRhaWwKKyAgICAvLyBoYXMgYmVlbiBwcm9jZXNzZWQuCisgICAg dm9pZCBhbGxvd1RhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKTsKKworICAgIC8vIElmIHdlJ3JlIHBy b2Nlc3NpbmcgdGhlIHRhaWwgZm9yIHRoaXMgbm9kZSBhbmQgYWxsIG91dHB1dHMgc2hvdWxkIGJl IHByb3BhZ2F0aW5nIHNpbGVuY2UsIHdlCisgICAgLy8gZW5kIHRhaWwgcHJvY2Vzc2luZy4gVGhl IGNvbm5lY3Rpb24gcmVmIHRvIG91cnNlbGYgd2lsbCBiZSByZW1vdmVkLCBiYWxhbmNpbmcgdGhl IHJlZmVyZW5jZQorICAgIC8vIGFkZGVkIGluIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgp LgorICAgIHZvaWQgZW5kVGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCiBwcm90ZWN0ZWQ6CiAg ICAgLy8gSW5wdXRzIGFuZCBvdXRwdXRzIG11c3QgYmUgY3JlYXRlZCBiZWZvcmUgdGhlIEF1ZGlv Tm9kZSBpcyBpbml0aWFsaXplZC4KICAgICB2b2lkIGFkZElucHV0KFBhc3NPd25QdHI8QXVkaW9O b2RlSW5wdXQ+KTsKQEAgLTE4MSw3ICsxOTEsOSBAQCBwcml2YXRlOgogICAgIAogICAgIGJvb2wg bV9pc01hcmtlZEZvckRlbGV0aW9uOwogICAgIGJvb2wgbV9pc0Rpc2FibGVkOwotICAgIAorCisg ICAgYm9vbCBtX2FsbG93VGFpbFByb2Nlc3Npbmc7CisKICNpZiBERUJVR19BVURJT05PREVfUkVG RVJFTkNFUwogICAgIHN0YXRpYyBib29sIHNfaXNOb2RlQ291bnRJbml0aWFsaXplZDsKICAgICBz dGF0aWMgaW50IHNfbm9kZUNvdW50W05vZGVUeXBlRW5kXTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcCBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcAppbmRleCAxMTA1NzczMjYw NDhhZmYwOGFmOWU0ZTdmOTFiNzMzYjE4M2EyYWM3Li41NjQ5YTk4MjE1MDBlMzU3MmVlOGU3OTgz MGVhZjg1ZDkwYzI3N2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJh dWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCkBAIC05MSw3ICs5MSw3IEBAIHZvaWQgQXVkaW9QYW5u ZXJOb2RlOjpwcm9jZXNzKHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpCiB7CiAgICAgQXVkaW9CdXMq IGRlc3RpbmF0aW9uID0gb3V0cHV0KDApLT5idXMoKTsKIAotICAgIGlmICghaXNJbml0aWFsaXpl ZCgpIHx8ICFpbnB1dCgwKS0+aXNDb25uZWN0ZWQoKSB8fCAhbV9wYW5uZXIuZ2V0KCkpIHsKKyAg ICBpZiAoIWlzSW5pdGlhbGl6ZWQoKSB8fCAhbV9wYW5uZXIuZ2V0KCkpIHsKICAgICAgICAgZGVz dGluYXRpb24tPnplcm8oKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiZjdmY2Zm YzUxZDcxZGFhYTdiZWQ4N2M1NTc3MzY0NjlhNWI4MWIxLi4wMDlhYmFjZDc3ZTJmNjY4YzRiZDIx MjYxOTk3MzQxN2Y1ZDNlYjVlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysr IGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMDQtMTEgIFJh eW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAgICAgIG5vdGVHcmFpbk9uIGlzIHRv byBsb25nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03 NzIyNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJl bW92ZSBleHRyYUZyYW1lc0hSVEYgdGhhdCBpcyBubyBsb25nZXIgbmVlZGVkOgorICAgICAgICAq IHdlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanM6CisgICAgICAgIChj cmVhdGVTaWduYWxCdWZmZXIpOiAKKyAgICAgICAgKHZlcmlmeVN0YXJ0QW5kRW5kRnJhbWVzKToK KwogMjAxMi0wNS0wMyAgQ2hyaXN0b3BoZSBEdW1leiAgPGNocmlzdG9waGUuZHVtZXpAaW50ZWwu Y29tPgogCiAgICAgICAgIFtFRkxdIERSVCBzaG91bGQgb2JleSBsYXlvdXRUZXN0Q29udHJvbGxl cidzIGFkZFVSTFRvUmVkaXJlY3QoKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8v cmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qcyBiL0xheW91dFRlc3RzL3dlYmF1ZGlv L3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMKaW5kZXggNDVkZDcyZmNhYWRiMjg0 N2Q5ZDJlNGI1OGNjMWI0YzA2YmE1Y2U5OS4uM2I0NDhhYTFiMGNmODlkNjlhMjJlODAxYTM4ZGZm Nzc5ZTM4OGVmOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25v dGUtZ3JhaW4tb24tdGVzdGluZy5qcworKysgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNvdXJj ZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5nLmpzCkBAIC0xLDExICsxLDUgQEAKIHZhciBzYW1wbGVS YXRlID0gNDQxMDAuMDsKIAotLy8gSFJURiBleHRyYSBmcmFtZXMuICBUaGlzIGlzIGEgbWFnaWMg Y29uc3RhbnQgY3VycmVudGx5IGluCi0vLyBBdWRpb0J1ZmZlclNvdXJjZU5vZGU6OnByb2Nlc3Mg dGhhdCBhbHdheXMgZXh0ZW5kcyB0aGUKLS8vIGR1cmF0aW9uIGJ5IHRoaXMgbnVtYmVyIG9mIHNh bXBsZXMuICBTZWUgYnVnIDc3MjI0Ci0vLyAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc3MjI0KS4KLXZhciBleHRyYUZyYW1lc0hSVEYgPSA1MTI7Ci0KIC8vIEhvdyBt YW55IGdyYWlucyB0byBwbGF5LgogdmFyIG51bWJlck9mVGVzdHMgPSAxMDA7CiAKQEAgLTEzLDkg KzcsOCBAQCB2YXIgbnVtYmVyT2ZUZXN0cyA9IDEwMDsKIHZhciBkdXJhdGlvbiA9IDAuMDE7CiAK IC8vIFRpbWUgc3RlcCBiZXR3ZWVuIHRoZSBzdGFydCBvZiBlYWNoIGdyYWluLiAgV2UgbmVlZCB0 byBhZGQgYSBsaXR0bGUKLS8vIGJpdCBvZiBzaWxlbmNlIHNvIHdlIGNhbiBkZXRlY3QgZ3JhaW4g Ym91bmRhcmllcyBhbmQgYWxzbyBhY2NvdW50Ci0vLyBmb3IgdGhlIGV4dHJhIGZyYW1lcyBmb3Ig SFJURi4KLXZhciB0aW1lU3RlcCA9IGR1cmF0aW9uICsgLjAwNSArIGV4dHJhRnJhbWVzSFJURiAv IHNhbXBsZVJhdGU7CisvLyBiaXQgb2Ygc2lsZW5jZSBzbyB3ZSBjYW4gZGV0ZWN0IGdyYWluIGJv dW5kYXJpZXMuCit2YXIgdGltZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDU7CiAKIC8vIFRpbWUgc3Rl cCBiZXR3ZWVuIHRoZSBzdGFydCBmb3IgZWFjaCBncmFpbi4KIHZhciBncmFpbk9mZnNldFN0ZXAg PSAwLjAwMTsKQEAgLTMwLDEwICsyMyw5IEBAIHZhciByZW5kZXJlZERhdGE7CiAvLyByZXR1cm5z IHRoZSBkZXNpcmVkIHZhbHVlIGF0IHNhbXBsZSBmcmFtZSBrLgogZnVuY3Rpb24gY3JlYXRlU2ln bmFsQnVmZmVyKGNvbnRleHQsIGYpIHsKIAotICAgIC8vIE1ha2Ugc3VyZSB0aGUgYnVmZmVyIGhh cyBlbm91Z2ggZGF0YSBmb3IgYWxsIG9mIHRoZSBwb3NzaWJsZQotICAgIC8vIGdyYWluIG9mZnNl dHMgYW5kIGR1cmF0aW9ucy4gIE5lZWQgdG8gaW5jbHVkZSB0aGUgZXh0cmEgZnJhbWVzCi0gICAg Ly8gZm9yIEhSVEYuICBUaGUgYWRkaXRpb25hbCAxIGlzIGZvciBhbnkgcm91bmQtb2ZmIGVycm9y cy4KLSAgICB2YXIgc2lnbmFsTGVuZ3RoID0gTWF0aC5mbG9vcigxICsgZXh0cmFGcmFtZXNIUlRG ICsgc2FtcGxlUmF0ZSAqIChudW1iZXJPZlRlc3RzICogZ3JhaW5PZmZzZXRTdGVwICsgZHVyYXRp b24pKTsKKyAgICAvLyBNYWtlIHN1cmUgdGhlIGJ1ZmZlciBoYXMgZW5vdWdoIGRhdGEgZm9yIGFs bCBvZiB0aGUgcG9zc2libGUgZ3JhaW4gb2Zmc2V0cyBhbmQgZHVyYXRpb25zLgorICAgIC8vIFRo ZSBhZGRpdGlvbmFsIDEgaXMgZm9yIGFueSByb3VuZC1vZmYgZXJyb3JzLgorICAgIHZhciBzaWdu YWxMZW5ndGggPSBNYXRoLmZsb29yKDEgKyBzYW1wbGVSYXRlICogKG51bWJlck9mVGVzdHMgKiBn cmFpbk9mZnNldFN0ZXAgKyBkdXJhdGlvbikpOwogCiAgICAgdmFyIGJ1ZmZlciA9IGNvbnRleHQu Y3JlYXRlQnVmZmVyKDIsIHNpZ25hbExlbmd0aCwgc2FtcGxlUmF0ZSk7CiAgICAgdmFyIGRhdGEg PSBidWZmZXIuZ2V0Q2hhbm5lbERhdGEoMCk7CkBAIC0xMzMsOSArMTI1LDggQEAgZnVuY3Rpb24g dmVyaWZ5U3RhcnRBbmRFbmRGcmFtZXMoc3RhcnRFbmRGcmFtZXMpIHsKICAgICAvLyBleHBlY3Rh dGlvbnMuCiAgICAgZm9yICh2YXIgayA9IDA7IGsgPCBzdGFydEZyYW1lcy5sZW5ndGg7ICsraykg ewogICAgICAgICB2YXIgZXhwZWN0ZWRTdGFydCA9IHRpbWVUb1NhbXBsZUZyYW1lKGsgKiB0aW1l U3RlcCwgc2FtcGxlUmF0ZSk7Ci0gICAgICAgIC8vIFRoZSBlbmQgcG9pbnQgaXMgdGhlIGR1cmF0 aW9uLCBwbHVzIHRoZSBleHRyYSBmcmFtZXMKLSAgICAgICAgLy8gZm9yIEhSVEYuCi0gICAgICAg IHZhciBleHBlY3RlZEVuZCA9IGV4dHJhRnJhbWVzSFJURiArIGV4cGVjdGVkU3RhcnQgKyBncmFp bkxlbmd0aEluU2FtcGxlRnJhbWVzKGsgKiBncmFpbk9mZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1w bGVSYXRlKTsKKyAgICAgICAgLy8gVGhlIGVuZCBwb2ludCBpcyB0aGUgZHVyYXRpb24uCisgICAg ICAgIHZhciBleHBlY3RlZEVuZCA9IGV4cGVjdGVkU3RhcnQgKyBncmFpbkxlbmd0aEluU2FtcGxl RnJhbWVzKGsgKiBncmFpbk9mZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1wbGVSYXRlKTsKIAogICAg ICAgICBpZiAoc3RhcnRGcmFtZXNba10gIT0gZXhwZWN0ZWRTdGFydCkgewogICAgICAgICAgICAg dGVzdEZhaWxlZCgiUHVsc2UgIiArIGsgKyAiIHN0YXJ0ZWQgYXQgIiArIHN0YXJ0RnJhbWVzW2td ICsgIiBidXQgZXhwZWN0ZWQgYXQgIiArIGV4cGVjdGVkU3RhcnQpOwo= 142096 2012-05-15 16:44:03 -0700 2012-06-25 22:40:26 -0700 Proposed patch 77224.patch text/plain 20697 rtoy ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAzYTliNTkxLi5hMDgyMzY4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDkgQEAKKzIwMTItMDUt MTUgIFJheW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAgICAgIG5vdGVHcmFpbk9u IGlzIHRvbyBsb25nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD03NzIyNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qczoKKyAgICAg ICAgKGNyZWF0ZVNpZ25hbEJ1ZmZlcik6CisgICAgICAgICh2ZXJpZnlTdGFydEFuZEVuZEZyYW1l cyk6CisKKzIwMTItMDUtMTUgIFJheW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAg ICAgIG5vdGVHcmFpbk9uIGlzIHRvbyBsb25nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03NzIyNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVz dGluZy5qczoKKyAgICAgICAgKGNyZWF0ZVNpZ25hbEJ1ZmZlcik6CisgICAgICAgICh2ZXJpZnlT dGFydEFuZEVuZEZyYW1lcyk6CisKKzIwMTItMDUtMTUgIFJheW1vbmQgVG95ICA8cnRveUBnb29n bGUuY29tPgorCisgICAgICAgIG5vdGVHcmFpbk9uIGlzIHRvbyBsb25nCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzIyNAorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd2ViYXVkaW8vcmVzb3VyY2VzL25v dGUtZ3JhaW4tb24tdGVzdGluZy5qczoKKyAgICAgICAgKGNyZWF0ZVNpZ25hbEJ1ZmZlcik6Cisg ICAgICAgICh2ZXJpZnlTdGFydEFuZEVuZEZyYW1lcyk6CisKKzIwMTItMDUtMTUgIFJheW1vbmQg VG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAgICAgIG5vdGVHcmFpbk9uIGlzIHRvbyBsb25n CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzIyNAor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlbW92ZSBl eHRyYUhSVEZGcmFtZXMgdGhhdCdzIG5vIGxvbmdlciBuZWVkZWQuCisgICAgICAgIAorICAgICAg ICAqIHdlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanM6CisgICAgICAg IChjcmVhdGVTaWduYWxCdWZmZXIpOiAKKyAgICAgICAgKHZlcmlmeVN0YXJ0QW5kRW5kRnJhbWVz KToKKwogMjAxMi0wNS0xMSAgQWxleGFuZGVyIFBhdmxvdiAgPGFwYXZsb3ZAY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IFNlYXJjaCBib3ggZG9lc24ndCBhbGxvdyBDU1Mg c2VsZWN0b3JzIGFueW1vcmUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL3Jlc291 cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9yZXNv dXJjZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5nLmpzCmluZGV4IDQ1ZGQ3MmYuLmZjMGJhZjIgMTAw NjQ0Ci0tLSBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRl c3RpbmcuanMKKysrIGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4t b24tdGVzdGluZy5qcwpAQCAtMSwxMSArMSw1IEBACiB2YXIgc2FtcGxlUmF0ZSA9IDQ0MTAwLjA7 CiAKLS8vIEhSVEYgZXh0cmEgZnJhbWVzLiAgVGhpcyBpcyBhIG1hZ2ljIGNvbnN0YW50IGN1cnJl bnRseSBpbgotLy8gQXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpwcm9jZXNzIHRoYXQgYWx3YXlzIGV4 dGVuZHMgdGhlCi0vLyBkdXJhdGlvbiBieSB0aGlzIG51bWJlciBvZiBzYW1wbGVzLiAgU2VlIGJ1 ZyA3NzIyNAotLy8gKGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzIy NCkuCi12YXIgZXh0cmFGcmFtZXNIUlRGID0gNTEyOwotCiAvLyBIb3cgbWFueSBncmFpbnMgdG8g cGxheS4KIHZhciBudW1iZXJPZlRlc3RzID0gMTAwOwogCkBAIC0xMyw5ICs3LDggQEAgdmFyIG51 bWJlck9mVGVzdHMgPSAxMDA7CiB2YXIgZHVyYXRpb24gPSAwLjAxOwogCiAvLyBUaW1lIHN0ZXAg YmV0d2VlbiB0aGUgc3RhcnQgb2YgZWFjaCBncmFpbi4gIFdlIG5lZWQgdG8gYWRkIGEgbGl0dGxl Ci0vLyBiaXQgb2Ygc2lsZW5jZSBzbyB3ZSBjYW4gZGV0ZWN0IGdyYWluIGJvdW5kYXJpZXMgYW5k IGFsc28gYWNjb3VudAotLy8gZm9yIHRoZSBleHRyYSBmcmFtZXMgZm9yIEhSVEYuCi12YXIgdGlt ZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDUgKyBleHRyYUZyYW1lc0hSVEYgLyBzYW1wbGVSYXRlOwor Ly8gYml0IG9mIHNpbGVuY2Ugc28gd2UgY2FuIGRldGVjdCBncmFpbiBib3VuZGFyaWVzLgordmFy IHRpbWVTdGVwID0gZHVyYXRpb24gKyAuMDA1OwogCiAvLyBUaW1lIHN0ZXAgYmV0d2VlbiB0aGUg c3RhcnQgZm9yIGVhY2ggZ3JhaW4uCiB2YXIgZ3JhaW5PZmZzZXRTdGVwID0gMC4wMDE7CkBAIC0z MCwxMCArMjMsOSBAQCB2YXIgcmVuZGVyZWREYXRhOwogLy8gcmV0dXJucyB0aGUgZGVzaXJlZCB2 YWx1ZSBhdCBzYW1wbGUgZnJhbWUgay4KIGZ1bmN0aW9uIGNyZWF0ZVNpZ25hbEJ1ZmZlcihjb250 ZXh0LCBmKSB7CiAKLSAgICAvLyBNYWtlIHN1cmUgdGhlIGJ1ZmZlciBoYXMgZW5vdWdoIGRhdGEg Zm9yIGFsbCBvZiB0aGUgcG9zc2libGUKLSAgICAvLyBncmFpbiBvZmZzZXRzIGFuZCBkdXJhdGlv bnMuICBOZWVkIHRvIGluY2x1ZGUgdGhlIGV4dHJhIGZyYW1lcwotICAgIC8vIGZvciBIUlRGLiAg VGhlIGFkZGl0aW9uYWwgMSBpcyBmb3IgYW55IHJvdW5kLW9mZiBlcnJvcnMuCi0gICAgdmFyIHNp Z25hbExlbmd0aCA9IE1hdGguZmxvb3IoMSArIGV4dHJhRnJhbWVzSFJURiArIHNhbXBsZVJhdGUg KiAobnVtYmVyT2ZUZXN0cyAqIGdyYWluT2Zmc2V0U3RlcCArIGR1cmF0aW9uKSk7CisgICAgLy8g TWFrZSBzdXJlIHRoZSBidWZmZXIgaGFzIGVub3VnaCBkYXRhIGZvciBhbGwgb2YgdGhlIHBvc3Np YmxlIGdyYWluIG9mZnNldHMgYW5kIGR1cmF0aW9ucy4gVGhlCisgICAgLy8gYWRkaXRpb25hbCAx IGlzIGZvciBhbnkgcm91bmQtb2ZmIGVycm9ycy4KKyAgICB2YXIgc2lnbmFsTGVuZ3RoID0gTWF0 aC5mbG9vcigxICsgc2FtcGxlUmF0ZSAqIChudW1iZXJPZlRlc3RzICogZ3JhaW5PZmZzZXRTdGVw ICsgZHVyYXRpb24pKTsKIAogICAgIHZhciBidWZmZXIgPSBjb250ZXh0LmNyZWF0ZUJ1ZmZlcigy LCBzaWduYWxMZW5ndGgsIHNhbXBsZVJhdGUpOwogICAgIHZhciBkYXRhID0gYnVmZmVyLmdldENo YW5uZWxEYXRhKDApOwpAQCAtMTMzLDkgKzEyNSw4IEBAIGZ1bmN0aW9uIHZlcmlmeVN0YXJ0QW5k RW5kRnJhbWVzKHN0YXJ0RW5kRnJhbWVzKSB7CiAgICAgLy8gZXhwZWN0YXRpb25zLgogICAgIGZv ciAodmFyIGsgPSAwOyBrIDwgc3RhcnRGcmFtZXMubGVuZ3RoOyArK2spIHsKICAgICAgICAgdmFy IGV4cGVjdGVkU3RhcnQgPSB0aW1lVG9TYW1wbGVGcmFtZShrICogdGltZVN0ZXAsIHNhbXBsZVJh dGUpOwotICAgICAgICAvLyBUaGUgZW5kIHBvaW50IGlzIHRoZSBkdXJhdGlvbiwgcGx1cyB0aGUg ZXh0cmEgZnJhbWVzCi0gICAgICAgIC8vIGZvciBIUlRGLgotICAgICAgICB2YXIgZXhwZWN0ZWRF bmQgPSBleHRyYUZyYW1lc0hSVEYgKyBleHBlY3RlZFN0YXJ0ICsgZ3JhaW5MZW5ndGhJblNhbXBs ZUZyYW1lcyhrICogZ3JhaW5PZmZzZXRTdGVwLCBkdXJhdGlvbiwgc2FtcGxlUmF0ZSk7CisgICAg ICAgIC8vIFRoZSBlbmQgcG9pbnQgaXMgdGhlIGR1cmF0aW9uLgorICAgICAgICB2YXIgZXhwZWN0 ZWRFbmQgPSBleHBlY3RlZFN0YXJ0ICsgZ3JhaW5MZW5ndGhJblNhbXBsZUZyYW1lcyhrICogZ3Jh aW5PZmZzZXRTdGVwLCBkdXJhdGlvbiwgc2FtcGxlUmF0ZSk7CiAKICAgICAgICAgaWYgKHN0YXJ0 RnJhbWVzW2tdICE9IGV4cGVjdGVkU3RhcnQpIHsKICAgICAgICAgICAgIHRlc3RGYWlsZWQoIlB1 bHNlICIgKyBrICsgIiBzdGFydGVkIGF0ICIgKyBzdGFydEZyYW1lc1trXSArICIgYnV0IGV4cGVj dGVkIGF0ICIgKyBleHBlY3RlZFN0YXJ0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwYzAyM2FhLi43NzNiZTY4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nCkBAIC0xLDI3ICsxLDE0OCBAQAotMjAxMi0wNS0xNCAgUmF5bW9uZCBUb3kg IDxydG95QGdvb2dsZS5jb20+CisyMDEyLTA1LTE1ICBSYXltb25kIFRveSAgPHJ0b3lAZ29vZ2xl LmNvbT4KIAotICAgICAgICBSZW1vdmUgUmVmVHlwRGlzYWJsZWQgYW5kIGRpc2FibGUoKSBhbmQg ZW5hYmxlKCkgbWV0aG9kcwotICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9ODU2ODEKKyAgICAgICAgbm90ZUdyYWluT24gaXMgdG9vIGxvbmcKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MjI0CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCiAKLSAgICAgICAgRXhpc3RpbmcgdGVzdHMgc2hv dWxkIGNvdmVyIHRoZXNlIGNoYW5nZXMuCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQog Ci0gICAgICAgIFJlbW92ZSBSZWZUeXBlRGlzYWJsZWQgYW5kIG1fZGlzYWJsZWRSZWZDb3VudC4g IGRpc2FibGUoKSBhbmQKLSAgICAgICAgZW5hYmxlKCkgbWV0aG9kcyByZW1haW4uCisgICAgICAg ICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5kZXJGcm9tQnVmZmVyKToKKyAgICAg ICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb0NvbnRleHQ6OnJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0 OjpkZXJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0Ojpsb2NrKToKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6YWRkRGVmZXJyZWRSZWZOb2RlKToKKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjpoYW5kbGVQb3N0 UmVuZGVyVGFza3MpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjpoYW5kbGVEZWZl cnJlZFJlZk5vZGVzKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5o OgorICAgICAgICAoQXVkaW9Db250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4 dDo6YWRkRGVmZXJyZWREZXJlZk5vZGUpOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVk aW9Ob2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6QXVkaW9Ob2RlKToKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6cHJvY2Vzc0lmTmVjZXNzYXJ5KToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvTm9kZTo6YWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKToKKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjplbmRUYWlsUHJvY2Vz c2luZ0lmTmVlZGVkKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oOgor ICAgICAgICAoQXVkaW9Ob2RlKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFu bmVyTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb1Bhbm5lck5vZGU6OnByb2Nlc3Mp OgorCisyMDEyLTA1LTE1ICBSYXltb25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAg ICBub3RlR3JhaW5PbiBpcyB0b28gbG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NzcyMjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIChPT1BTISkKKworICAgICAgICAqIE1vZHVs ZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcik6CisgICAgICAgICogTW9k dWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9D b250ZXh0OjpyZWZOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6ZGVyZWZO b2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6bG9jayk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkUmVmTm9kZSk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6aGFuZGxlUG9zdFJlbmRlclRh c2tzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWRSZWZO b2Rlcyk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaDoKKyAgICAg ICAgKEF1ZGlvQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmFkZERl ZmVycmVkRGVyZWZOb2RlKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1ZGlvTm9kZSk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OnByb2Nlc3NJZk5lY2Vzc2FyeSk6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6ZW5kVGFpbFByb2Nlc3NpbmdJZk5l ZWRlZCk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaDoKKyAgICAgICAg KEF1ZGlvTm9kZSk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9QYW5uZXJOb2RlOjpwcm9jZXNzKToKKworMjAx Mi0wNS0xNSAgUmF5bW9uZCBUb3kgIDxydG95QGdvb2dsZS5jb20+CisKKyAgICAgICAgbm90ZUdy YWluT24gaXMgdG9vIGxvbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc3MjI0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1 ZmZlclNvdXJjZU5vZGU6OnJlbmRlckZyb21CdWZmZXIpOgorICAgICAgICAqIE1vZHVsZXMvd2Vi YXVkaW8vQXVkaW9Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6 cmVmTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmRlcmVmTm9kZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmxvY2spOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9Db250ZXh0OjphZGREZWZlcnJlZFJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RSZW5kZXJUYXNrcyk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkUmVmTm9kZXMpOgor ICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0Lmg6CisgICAgICAgIChBdWRp b0NvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjphZGREZWZlcnJlZERl cmVmTm9kZSk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpBdWRpb05vZGUpOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9Ob2RlOjpwcm9jZXNzSWZOZWNlc3NhcnkpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9O b2RlOjphbGxvd1RhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OmVuZFRhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgor ICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmg6CisgICAgICAgIChBdWRpb05v ZGUpOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFubmVyTm9kZTo6cHJvY2Vzcyk6CisKKzIwMTItMDUtMTUg IFJheW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgorCisgICAgICAgIG5vdGVHcmFpbk9uIGlz IHRvbyBsb25nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD03NzIyNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IE5vIG5ldyB0ZXN0cy4gbm90ZS1ncmFpbi1vbiB0ZXN0IHVwZGF0ZWQgdG8gdmVyaWZ5IHRoaXMu ICBTZWUgYWxzbworICAgICAgICBodHRwOi8vY2hyb21pdW0uZ29vZ2xlY29kZS5jb20vc3ZuL3Ry dW5rL3NhbXBsZXMvYXVkaW8vZ3JhbnVsYXIuaHRtbAorICAgICAgICB3aGljaCBzaG91bGQgc291 bmQgdGhlIHNhbWUsIGFuZAorICAgICAgICBodHRwOi8vc3RhdGljLmVjaG9uZXN0LmNvbS9Cb2hl bWlhblJoYXBzaWNob3JkL2luZGV4Lmh0bWwgd2hpY2gKKyAgICAgICAgc2hvdWxkIHNvdW5kIGJl dHRlciB3aXRoIHRoZSBhcnRpZmFjdHMgYWZ0ZXIgZWFjaCB0aWxlLgogICAgICAgICAKLSAgICAg ICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6IFJlbW92ZSBSZWZUeXBlRGlhYmxl ZCBhbmQgbV9kaXNhYmxlZFJlZkNvdW50LgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVk aW9CdWZmZXJTb3VyY2VOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVmZmVyU291 cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcik6IFJlbW92ZSB0aGUKKyAgICAgICAgZXh0cmEgNTEy IHNhbXBsZXMuCisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjpyZWZOb2RlKToKKyAgICAgICAgKFdlYkNv cmU6OkF1ZGlvQ29udGV4dDo6ZGVyZWZOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29u dGV4dDo6bG9jayk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVk UmVmTm9kZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29u dGV4dDo6aGFuZGxlUG9zdFJlbmRlclRhc2tzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29u dGV4dDo6aGFuZGxlRGVmZXJyZWRSZWZOb2Rlcyk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRp by9BdWRpb0NvbnRleHQuaDoKKyAgICAgICAgKEF1ZGlvQ29udGV4dCk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRGVyZWZOb2RlKToKKyAgICAgICAgKiBNb2R1 bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6CiAgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6 OkF1ZGlvTm9kZSk6CiAgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6On5BdWRpb05vZGUpOgot ICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjplbmFibGVPdXRwdXRzSWZOZWNlc3NhcnkpOiBO ZXcKLSAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6cmVmKTogCi0gICAgICAgIChXZWJDb3Jl OjpBdWRpb05vZGU6OmRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkpOiBOZXcKKyAgICAgICAgKFdl YkNvcmU6OkF1ZGlvTm9kZTo6cHJvY2Vzc0lmTmVjZXNzYXJ5KToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvTm9kZTo6ZW5hYmxlT3V0cHV0c0lmTmVjZXNzYXJ5KToKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpkaXNhYmxlT3V0cHV0c0lmTmVjZXNzYXJ5 KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6cmVmKToKICAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvTm9kZTo6ZmluaXNoRGVyZWYpOgotICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVk aW9Ob2RlLmg6IFJlbW92ZSBSZWZUeXBlRGlzYWJsZWQgYW5kIG1fZGlzYWJsZWRSZWZDb3VudC4K LSAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcDogUmVtb3ZlZCB1 c2VzIG9mIFJlZlR5cGVEaXNibGVkLgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjphbGxv d1RhaWxQcm9jZXNzaW5nSWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpl bmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1 ZGlvTm9kZS5oOgorICAgICAgICAoQXVkaW9Ob2RlKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcDoKICAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZUlucHV0 OjpkaXNjb25uZWN0KToKICAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZUlucHV0OjpkaXNhYmxl KToKICAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZUlucHV0OjplbmFibGUpOgorICAgICAgICAq IE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvUGFubmVyTm9kZTo6cHJvY2Vzcyk6CiAKIDIwMTItMDUtMTEgIFNoZXJpZmYgQm90ICA8 d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKaW5kZXggMDc3 NmJlOS4uOTFkZWJhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRp by9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8vQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcApAQCAtMjAzLDExICsyMDMsNiBAQCB2 b2lkIEF1ZGlvQnVmZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcihBdWRpb0J1cyogYnVz LCB1bnNpZ25lZCBkZXN0aW5hdGlvbgogICAgIAogICAgIHVuc2lnbmVkIGRlbHRhRnJhbWVzID0g ZW5kRnJhbWUgLSBzdGFydEZyYW1lOwogICAgIAotICAgIC8vIFRoaXMgaXMgYSBIQUNLIHRvIGFs bG93IGZvciBIUlRGIHRhaWwtdGltZSAtIGF2b2lkcyBnbGl0Y2ggYXQgZW5kLgotICAgIC8vIEZJ WE1FOiBpbXBsZW1lbnQgdGFpbFRpbWUgZm9yIGVhY2ggQXVkaW9Ob2RlIGZvciBhIG1vcmUgZ2Vu ZXJhbCBzb2x1dGlvbiB0byB0aGlzIHByb2JsZW0uCi0gICAgaWYgKG1faXNHcmFpbikKLSAgICAg ICAgZW5kRnJhbWUgKz0gNTEyOwotCiAgICAgLy8gRG8gc29tZSBzYW5pdHkgY2hlY2tpbmcuCiAg ICAgaWYgKHN0YXJ0RnJhbWUgPj0gYnVmZmVyTGVuZ3RoKQogICAgICAgICBzdGFydEZyYW1lID0g IWJ1ZmZlckxlbmd0aCA/IDAgOiBidWZmZXJMZW5ndGggLSAxOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwCmluZGV4IGY3NDNiMTEuLmNjNWQ2 MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250 ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4 dC5jcHAKQEAgLTU2MCwxOCArNTYwLDIxIEBAIHZvaWQgQXVkaW9Db250ZXh0OjpkZXJlZkZpbmlz aGVkU291cmNlTm9kZXMoKQogCiB2b2lkIEF1ZGlvQ29udGV4dDo6cmVmTm9kZShBdWRpb05vZGUq IG5vZGUpCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoaXNNYWlu VGhyZWFkKCkgfHwgKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3duZXIoKSkpOwogICAgIEF1 dG9Mb2NrZXIgbG9ja2VyKHRoaXMpOwogICAgIAogICAgIG5vZGUtPnJlZihBdWRpb05vZGU6OlJl ZlR5cGVDb25uZWN0aW9uKTsKICAgICBtX3JlZmVyZW5jZWROb2Rlcy5hcHBlbmQobm9kZSk7CiB9 CiAKLXZvaWQgQXVkaW9Db250ZXh0OjpkZXJlZk5vZGUoQXVkaW9Ob2RlKiBub2RlKQordm9pZCBB dWRpb0NvbnRleHQ6OmRlcmVmTm9kZShBdWRpb05vZGUqIG5vZGUsIGJvb2wgZGVmZXJyZWQpCiB7 Ci0gICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKLSAgICAKLSAgICBub2RlLT5kZXJlZihBdWRp b05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsKKyAgICBpZiAoZGVmZXJyZWQpCisgICAgICAgIGFk ZERlZmVycmVkRmluaXNoRGVyZWYobm9kZSwgQXVkaW9Ob2RlOjpSZWZUeXBlQ29ubmVjdGlvbik7 CisgICAgZWxzZSB7CisgICAgICAgIEFTU0VSVChpc0dyYXBoT3duZXIoKSk7CisgICAgICAgIG5v ZGUtPmRlcmVmKEF1ZGlvTm9kZTo6UmVmVHlwZUNvbm5lY3Rpb24pOworICAgIH0KIAogICAgIGZv ciAodW5zaWduZWQgaSA9IDA7IGkgPCBtX3JlZmVyZW5jZWROb2Rlcy5zaXplKCk7ICsraSkgewog ICAgICAgICBpZiAobm9kZSA9PSBtX3JlZmVyZW5jZWROb2Rlc1tpXSkgewpAQCAtNTkyLDggKzU5 NSw3IEBAIHZvaWQgQXVkaW9Db250ZXh0OjpkZXJlZlVuZmluaXNoZWRTb3VyY2VOb2RlcygpCiAK IHZvaWQgQXVkaW9Db250ZXh0Ojpsb2NrKGJvb2wmIG11c3RSZWxlYXNlTG9jaykKIHsKLSAgICAv LyBEb24ndCBhbGxvdyByZWd1bGFyIGxvY2sgaW4gcmVhbC10aW1lIGF1ZGlvIHRocmVhZC4KLSAg ICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSB8fCAo aXNBdWRpb1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKSk7CiAKICAgICBUaHJlYWRJZGVudGlm aWVyIHRoaXNUaHJlYWQgPSBjdXJyZW50VGhyZWFkKCk7CiAKQEAgLTY1OSw2ICs2NjEsMTIgQEAg Ym9vbCBBdWRpb0NvbnRleHQ6OmlzR3JhcGhPd25lcigpIGNvbnN0CiAgICAgcmV0dXJuIGN1cnJl bnRUaHJlYWQoKSA9PSBtX2dyYXBoT3duZXJUaHJlYWQ7CiB9CiAKK3ZvaWQgQXVkaW9Db250ZXh0 OjphZGREZWZlcnJlZFJlZk5vZGUoQXVkaW9Ob2RlKiBub2RlKQoreworICAgIEFTU0VSVChpc0F1 ZGlvVGhyZWFkKCkpOworICAgIG1fZGVmZXJyZWRSZWZMaXN0LmFwcGVuZChub2RlKTsKK30KKwog dm9pZCBBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRmluaXNoRGVyZWYoQXVkaW9Ob2RlKiBub2Rl LCBBdWRpb05vZGU6OlJlZlR5cGUgcmVmVHlwZSkKIHsKICAgICBBU1NFUlQoaXNBdWRpb1RocmVh ZCgpKTsKQEAgLTY5Myw2ICs3MDEsOSBAQCB2b2lkIEF1ZGlvQ29udGV4dDo6aGFuZGxlUG9zdFJl bmRlclRhc2tzKCkKICAgICAvLyBmcm9tIHRoZSByZW5kZXIgZ3JhcGggKGluIHdoaWNoIGNhc2Ug dGhleSdsbCByZW5kZXIgc2lsZW5jZSkuCiAgICAgYm9vbCBtdXN0UmVsZWFzZUxvY2s7CiAgICAg aWYgKHRyeUxvY2sobXVzdFJlbGVhc2VMb2NrKSkgeworICAgICAgICAvLyBUYWtlIGNhcmUgb2Yg YW55IGRlZmVycmVkIHJlZk5vZGVzIGFuZCBkZWZlcnJlZCBkZXJlZk5vZGVzIHRoYXQgd2VyZSBh ZGRlZC4KKyAgICAgICAgaGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOworCiAgICAgICAgIC8vIFRh a2UgY2FyZSBvZiBmaW5pc2hpbmcgYW55IGRlcmVmcyB3aGVyZSB0aGUgdHJ5TG9jaygpIGZhaWxl ZCBwcmV2aW91c2x5LgogICAgICAgICBoYW5kbGVEZWZlcnJlZEZpbmlzaERlcmVmcygpOwogCkBA IC03MTQsNiArNzI1LDE5IEBAIHZvaWQgQXVkaW9Db250ZXh0OjpoYW5kbGVQb3N0UmVuZGVyVGFz a3MoKQogICAgIH0KIH0KIAordm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkUmVmTm9k ZXMoKQoreworICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOwor CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fZGVmZXJyZWRSZWZMaXN0LnNpemUoKTsg KytpKSB7CisgICAgICAgIEF1ZGlvTm9kZSogbm9kZSA9IG1fZGVmZXJyZWRSZWZMaXN0W2ldOwor ICAgICAgICAvLyBBZGQgYSByZWZlcmVuY2UgdG8gbm9kZSB0byB0ZWxsIHRoZSBjb250ZXh0IHRo YXQgdGhpcyBub2RlIGlzIHN0aWxsIGFsaXZlLgorICAgICAgICByZWZOb2RlKG5vZGUpOworICAg IH0KKyAgICAKKyAgICBtX2RlZmVycmVkUmVmTGlzdC5jbGVhcigpOworfQorCiB2b2lkIEF1ZGlv Q29udGV4dDo6aGFuZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKQogewogICAgIEFTU0VSVChpc0F1 ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKaW5kZXggZWRiODdlNy4uZTM4MWNjZCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oCkBAIC0yMTAs NiArMjEwLDE1IEBAIHB1YmxpYzoKICAgICAgICAgQXVkaW9Db250ZXh0KiBtX2NvbnRleHQ7CiAg ICAgICAgIGJvb2wgbV9tdXN0UmVsZWFzZUxvY2s7CiAgICAgfTsKKworICAgIC8vIEFkZCBhdWRp byBub2RlIHRvIGxpc3Qgb2Ygbm9kZXMgdGhhdCB3ZSB3YW50IHRvIGNhbGwgcmVmTm9kZSgpIG9u LiBUaGVyZSBtdXN0IGV2ZW50dWFsbHkgYmUgYQorICAgIC8vIGNhbGwgdG8gYWRkRGVmZXJyZWRE ZXJlZk5vZGUoKSBmb3IgdGhlIHNhbWUgbm9kZS4KKyAgICB2b2lkIGFkZERlZmVycmVkUmVmTm9k ZShBdWRpb05vZGUqKTsKKyAgICB2b2lkIGFkZERlZmVycmVkRGVyZWZOb2RlKEF1ZGlvTm9kZSog bm9kZSkgeyBkZXJlZk5vZGUobm9kZSwgdHJ1ZSk7IH0KKworICAgIC8vIER1cmluZyBwb3N0IHJl bmRlciBwcm9jZXNzaW5nLCBhbGwgdGhlIG5vZGVzIGFkZGVkIGJ5IGFkZERlZmVycmVkUmVmTm9k ZXMoKSB3aWxsIGJlIGFkZGVkIHRvCisgICAgLy8gbV9yZWZlcmVuY2VkTm9kZXMgbGlzdCB0byB0 ZWxsIHRoZSBjb250ZXh0IHRoYXQgdGhlc2Ugbm9kZXMgYXJlIHN0aWxsIGFsaXZlLgorICAgIHZv aWQgaGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOwogICAgIAogICAgIC8vIEluIEF1ZGlvTm9kZTo6 ZGVyZWYoKSBhIHRyeUxvY2soKSBpcyB1c2VkIGZvciBjYWxsaW5nIGZpbmlzaERlcmVmKCksIGJ1 dCBpZiBpdCBmYWlscyBrZWVwIHRyYWNrIGhlcmUuCiAgICAgdm9pZCBhZGREZWZlcnJlZEZpbmlz aERlcmVmKEF1ZGlvTm9kZSosIEF1ZGlvTm9kZTo6UmVmVHlwZSk7CkBAIC0yNjEsNyArMjcwLDcg QEAgcHJpdmF0ZToKICAgICAvLyBXaGVuIHRoZSBjb250ZXh0IGRlcmVmZXJlbmNlcyBhIHNvdXJj ZSBub2RlLCBpdCB3aWxsIGJlIGRlYWN0aXZhdGVkIGZyb20gdGhlIHJlbmRlcmluZyBncmFwaCBh bG9uZyB3aXRoIGFsbCBvdGhlciBub2RlcyBpdCBpcwogICAgIC8vIHVuaXF1ZWx5IGNvbm5lY3Rl ZCB0by4gIFNlZSB0aGUgQXVkaW9Ob2RlOjpyZWYoKSBhbmQgQXVkaW9Ob2RlOjpkZXJlZigpIG1l dGhvZHMgZm9yIG1vcmUgZGV0YWlscy4KICAgICB2b2lkIHJlZk5vZGUoQXVkaW9Ob2RlKik7Ci0g ICAgdm9pZCBkZXJlZk5vZGUoQXVkaW9Ob2RlKik7CisgICAgdm9pZCBkZXJlZk5vZGUoQXVkaW9O b2RlKiwgYm9vbCBkZWZlcnJlZCA9IGZhbHNlKTsKIAogICAgIC8vIFdoZW4gdGhlIGNvbnRleHQg Z29lcyBhd2F5LCB0aGVyZSBtaWdodCBzdGlsbCBiZSBzb21lIHNvdXJjZXMgd2hpY2ggaGF2ZW4n dCBmaW5pc2hlZCBwbGF5aW5nLgogICAgIC8vIE1ha2Ugc3VyZSB0byBkZXJlZmVyZW5jZSB0aGVt IGhlcmUuCkBAIC0zMTgsNiArMzI3LDkgQEAgcHJpdmF0ZToKICAgICAvLyBPbmx5IGFjY2Vzc2Vk IGluIHRoZSBhdWRpbyB0aHJlYWQuCiAgICAgVmVjdG9yPFJlZkluZm8+IG1fZGVmZXJyZWRGaW5p c2hEZXJlZkxpc3Q7CiAgICAgCisgICAgLy8gTGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8g Y2FsbCByZWZOb2RlKCkgb24gdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZSBub2RlIGlzIHN0 aWxsIGFjdGl2ZS4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZFJlZkxpc3Q7CisK ICAgICAvLyBIUlRGIERhdGFiYXNlIGxvYWRlcgogICAgIFJlZlB0cjxIUlRGRGF0YWJhc2VMb2Fk ZXI+IG1faHJ0ZkRhdGFiYXNlTG9hZGVyOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvTm9kZS5jcHAKaW5kZXggM2U0ZWIyMC4uMzFmNDY5YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcApAQCAtNDksNiArNDksNyBA QCBBdWRpb05vZGU6OkF1ZGlvTm9kZShBdWRpb0NvbnRleHQqIGNvbnRleHQsIGZsb2F0IHNhbXBs ZVJhdGUpCiAgICAgLCBtX2Nvbm5lY3Rpb25SZWZDb3VudCgwKQogICAgICwgbV9pc01hcmtlZEZv ckRlbGV0aW9uKGZhbHNlKQogICAgICwgbV9pc0Rpc2FibGVkKGZhbHNlKQorICAgICwgbV9hbGxv d1RhaWxQcm9jZXNzaW5nKGZhbHNlKQogewogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VT CiAgICAgaWYgKCFzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQpIHsKQEAgLTIwOSw5ICsyMTAsMTIg QEAgdm9pZCBBdWRpb05vZGU6OnByb2Nlc3NJZk5lY2Vzc2FyeShzaXplX3QgZnJhbWVzVG9Qcm9j ZXNzKQogICAgICAgICBpZiAoIXNpbGVudElucHV0cykKICAgICAgICAgICAgIG1fbGFzdE5vblNp bGVudFRpbWUgPSAoY29udGV4dCgpLT5jdXJyZW50U2FtcGxlRnJhbWUoKSArIGZyYW1lc1RvUHJv Y2VzcykgLyBzdGF0aWNfY2FzdDxkb3VibGU+KG1fc2FtcGxlUmF0ZSk7CiAKLSAgICAgICAgaWYg KHNpbGVudElucHV0cyAmJiBwcm9wYWdhdGVzU2lsZW5jZSgpKQorICAgICAgICBpZiAoc2lsZW50 SW5wdXRzICYmIHByb3BhZ2F0ZXNTaWxlbmNlKCkpIHsKKyAgICAgICAgICAgIC8vIFRhaWwgcHJv Y2Vzc2luZyBjYW4gZW5kIG5vdyBiZWNhdXNlIHdlIGFyZSBwcm9wYWdhdGluZyBzaWxlbmNlLgor ICAgICAgICAgICAgZW5kVGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOwogICAgICAgICAgICAgc2ls ZW5jZU91dHB1dHMoKTsKLSAgICAgICAgZWxzZSB7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICBhbGxvd1RhaWxQcm9jZXNzaW5nSWZOZWVkZWQoKTsKICAgICAgICAgICAgIHByb2Nlc3Mo ZnJhbWVzVG9Qcm9jZXNzKTsKICAgICAgICAgICAgIHVuc2lsZW5jZU91dHB1dHMoKTsKICAgICAg ICAgfQpAQCAtMzk4LDYgKzQwMiwzMCBAQCB2b2lkIEF1ZGlvTm9kZTo6ZmluaXNoRGVyZWYoUmVm VHlwZSByZWZUeXBlKQogICAgIH0KIH0KIAordm9pZCBBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nl c3NpbmdJZk5lZWRlZCgpCit7CisgICAgaWYgKCFtX2FsbG93VGFpbFByb2Nlc3NpbmcgJiYgKGxh dGVuY3lUaW1lKCkgKyB0YWlsVGltZSgpID4gMCkpIHsKKyAgICAgICAgLy8gRXN0YWJsaXNoIGEg cmVmIHRvIG91cnNlbGYgaWYgd2UgaGF2ZW4ndCBhbHJlYWR5IHNvIHdlIGRvbid0IGdldCByZW1v dmVkIHdoZW4gYWxsIG5vZGVzCisgICAgICAgIC8vIGhhdmUgZGlzY29ubmVjdGVkIGZyb20gdXMu IFdlIGhvbGQgdGhpcyByZWYgZHVyaW5nIHRoZSB0aW1lIHdoZW4gd2UgYXJlIHJlY2VpdmluZwor ICAgICAgICAvLyBub24tc2lsZW50IGlucHV0LCBvciBkdXJpbmcgdGhlIHRpbWUgYWZ0ZXIgZmly c3QgcmVjZWl2aW5nIHNpbGVudCBpbnB1dCB3aGVuIHdlIGVtcHR5IHRoZQorICAgICAgICAvLyBw cm9jZXNzaW5nIHBpcGVsaW5lIHRvIGFjY291bnQgZm9yIGxhdGVuY3kgYW5kIHRhaWwuCisgICAg ICAgIG1fYWxsb3dUYWlsUHJvY2Vzc2luZyA9IHRydWU7CisgICAgICAgIGNvbnRleHQoKS0+YWRk RGVmZXJyZWRSZWZOb2RlKHRoaXMpOworICAgIH0KK30KKwordm9pZCBBdWRpb05vZGU6OmVuZFRh aWxQcm9jZXNzaW5nSWZOZWVkZWQoKQoreworICAgIEFTU0VSVChwcm9wYWdhdGVzU2lsZW5jZSgp KTsKKyAgICAKKyAgICBpZiAobV9hbGxvd1RhaWxQcm9jZXNzaW5nKSB7CisgICAgICAgIC8vIFN0 b3AgdGFpbCBwcm9jZXNzaW5nLiBKdXN0IG5lZWQgdG8gZGVyZWYgb3Vyc2VsZiwgYnV0IHdlIGNh bid0IGRvIHRoYXQgd2hpbGUgdGhlIGdyYXBoCisgICAgICAgIC8vIGlzIGJlaW5nIHJlbmRlcmVk LiBTY2hlZHVsZSB0aGUgZGVyZWYgdG8gaGFwcGVuIGR1cmluZyB0aGUgcG9zdC1yZW5kZXJpbmcg cGhhc2UuCisgICAgICAgIG1fYWxsb3dUYWlsUHJvY2Vzc2luZyA9IGZhbHNlOworICAgICAgICBj b250ZXh0KCktPmFkZERlZmVycmVkRGVyZWZOb2RlKHRoaXMpOworICAgIH0KK30KKwogI2lmIERF QlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAKIGJvb2wgQXVkaW9Ob2RlOjpzX2lzTm9kZUNvdW50 SW5pdGlhbGl6ZWQgPSBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8vQXVkaW9Ob2RlLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1 ZGlvTm9kZS5oCmluZGV4IGEyMDk1YzEuLjNiYzM2YTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaApAQCAtMTU1LDYgKzE1NSwxNyBAQCBwdWJsaWM6CiAK ICAgICB2b2lkIGVuYWJsZU91dHB1dHNJZk5lY2Vzc2FyeShSZWZUeXBlKTsKICAgICB2b2lkIGRp c2FibGVPdXRwdXRzSWZOZWNlc3NhcnkoKTsKKworICAgIC8vIEFsbG93IHRhaWwgcHJvY2Vzc2lu ZyBmb3Igbm9kZXMgdGhhdCBoYXZlIHRhaWwgb3IgbGF0ZW5jeSB0aW1lLiBUaGlzIHdpbGwgY3Jl YXRlIGFuCisgICAgLy8gYWRkaXRpb25hbCBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWxmIHNvIHdl IGRvbid0IGdldCByZW1vdmVkIGZyb20gdGhlIGdyYXBoIGJlZm9yZSB0aGUgdGFpbAorICAgIC8v IGhhcyBiZWVuIHByb2Nlc3NlZC4KKyAgICB2b2lkIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRl ZCgpOworCisgICAgLy8gSWYgd2UncmUgcHJvY2Vzc2luZyB0aGUgdGFpbCBmb3IgdGhpcyBub2Rl IGFuZCBhbGwgb3V0cHV0cyBzaG91bGQgYmUgcHJvcGFnYXRpbmcgc2lsZW5jZSwgd2UKKyAgICAv LyBlbmQgdGFpbCBwcm9jZXNzaW5nLiBUaGUgY29ubmVjdGlvbiByZWYgdG8gb3Vyc2VsZiB3aWxs IGJlIHJlbW92ZWQsIGJhbGFuY2luZyB0aGUgcmVmZXJlbmNlCisgICAgLy8gYWRkZWQgaW4gYWxs b3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkuCisgICAgdm9pZCBlbmRUYWlsUHJvY2Vzc2luZ0lm TmVlZGVkKCk7CisgICAgCiBwcm90ZWN0ZWQ6CiAgICAgLy8gSW5wdXRzIGFuZCBvdXRwdXRzIG11 c3QgYmUgY3JlYXRlZCBiZWZvcmUgdGhlIEF1ZGlvTm9kZSBpcyBpbml0aWFsaXplZC4KICAgICB2 b2lkIGFkZElucHV0KFBhc3NPd25QdHI8QXVkaW9Ob2RlSW5wdXQ+KTsKQEAgLTE4Miw3ICsxOTMs OSBAQCBwcml2YXRlOgogICAgIAogICAgIGJvb2wgbV9pc01hcmtlZEZvckRlbGV0aW9uOwogICAg IGJvb2wgbV9pc0Rpc2FibGVkOwotICAgIAorCisgICAgYm9vbCBtX2FsbG93VGFpbFByb2Nlc3Np bmc7CisKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwogICAgIHN0YXRpYyBib29sIHNf aXNOb2RlQ291bnRJbml0aWFsaXplZDsKICAgICBzdGF0aWMgaW50IHNfbm9kZUNvdW50W05vZGVU eXBlRW5kXTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVk aW9QYW5uZXJOb2RlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Q YW5uZXJOb2RlLmNwcAppbmRleCA0ZDBhZDE4Li45M2Q5ZmE2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCkBAIC05MSw3ICs5 MSw3IEBAIHZvaWQgQXVkaW9QYW5uZXJOb2RlOjpwcm9jZXNzKHNpemVfdCBmcmFtZXNUb1Byb2Nl c3MpCiB7CiAgICAgQXVkaW9CdXMqIGRlc3RpbmF0aW9uID0gb3V0cHV0KDApLT5idXMoKTsKIAot ICAgIGlmICghaXNJbml0aWFsaXplZCgpIHx8ICFpbnB1dCgwKS0+aXNDb25uZWN0ZWQoKSB8fCAh bV9wYW5uZXIuZ2V0KCkpIHsKKyAgICBpZiAoIWlzSW5pdGlhbGl6ZWQoKSB8fCAhbV9wYW5uZXIu Z2V0KCkpIHsKICAgICAgICAgZGVzdGluYXRpb24tPnplcm8oKTsKICAgICAgICAgcmV0dXJuOwog ICAgIH0K 146104 2012-06-06 13:59:29 -0700 2012-06-25 22:40:30 -0700 WIP 77224wip.patch text/plain 13079 rtoy ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZmZXJT b3VyY2VOb2RlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZm ZXJTb3VyY2VOb2RlLmNwcAppbmRleCA0NDI1N2I2Li5mZmY2NjIzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUu Y3BwCkBAIC0yMDQsMTEgKzIwNCw2IEBAIHZvaWQgQXVkaW9CdWZmZXJTb3VyY2VOb2RlOjpyZW5k ZXJGcm9tQnVmZmVyKEF1ZGlvQnVzKiBidXMsIHVuc2lnbmVkIGRlc3RpbmF0aW9uCiAgICAgCiAg ICAgdW5zaWduZWQgZGVsdGFGcmFtZXMgPSBlbmRGcmFtZSAtIHN0YXJ0RnJhbWU7CiAgICAgCi0g ICAgLy8gVGhpcyBpcyBhIEhBQ0sgdG8gYWxsb3cgZm9yIEhSVEYgdGFpbC10aW1lIC0gYXZvaWRz IGdsaXRjaCBhdCBlbmQuCi0gICAgLy8gRklYTUU6IGltcGxlbWVudCB0YWlsVGltZSBmb3IgZWFj aCBBdWRpb05vZGUgZm9yIGEgbW9yZSBnZW5lcmFsIHNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbS4K LSAgICBpZiAobV9pc0dyYWluKQotICAgICAgICBlbmRGcmFtZSArPSA1MTI7Ci0KICAgICAvLyBE byBzb21lIHNhbml0eSBjaGVja2luZy4KICAgICBpZiAoc3RhcnRGcmFtZSA+PSBidWZmZXJMZW5n dGgpCiAgICAgICAgIHN0YXJ0RnJhbWUgPSAhYnVmZmVyTGVuZ3RoID8gMCA6IGJ1ZmZlckxlbmd0 aCAtIDE7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlv Q29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4 dC5jcHAKaW5kZXggMGZjNmQ1My4uZTYwZjY0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmNwcApAQCAtNTYwLDcgKzU2MCw3IEBAIHZvaWQg QXVkaW9Db250ZXh0OjpkZXJlZkZpbmlzaGVkU291cmNlTm9kZXMoKQogCiB2b2lkIEF1ZGlvQ29u dGV4dDo6cmVmTm9kZShBdWRpb05vZGUqIG5vZGUpCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVh ZCgpKTsKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkgfHwgKGlzQXVkaW9UaHJlYWQoKSAmJiBp c0dyYXBoT3duZXIoKSkpOwogICAgIEF1dG9Mb2NrZXIgbG9ja2VyKHRoaXMpOwogICAgIAogICAg IG5vZGUtPnJlZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsKQEAgLTU5Myw3ICs1OTMs NyBAQCB2b2lkIEF1ZGlvQ29udGV4dDo6ZGVyZWZVbmZpbmlzaGVkU291cmNlTm9kZXMoKQogdm9p ZCBBdWRpb0NvbnRleHQ6OmxvY2soYm9vbCYgbXVzdFJlbGVhc2VMb2NrKQogewogICAgIC8vIERv bid0IGFsbG93IHJlZ3VsYXIgbG9jayBpbiByZWFsLXRpbWUgYXVkaW8gdGhyZWFkLgotICAgIEFT U0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpIHx8IChpc0F1 ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93bmVyKCkpKTsKIAogICAgIFRocmVhZElkZW50aWZpZXIg dGhpc1RocmVhZCA9IGN1cnJlbnRUaHJlYWQoKTsKIApAQCAtNjY1LDYgKzY2NSwxMiBAQCB2b2lk IEF1ZGlvQ29udGV4dDo6YWRkRGVmZXJyZWRGaW5pc2hEZXJlZihBdWRpb05vZGUqIG5vZGUpCiAg ICAgbV9kZWZlcnJlZEZpbmlzaERlcmVmTGlzdC5hcHBlbmQobm9kZSk7CiB9CiAKK3ZvaWQgQXVk aW9Db250ZXh0OjphZGREZWZlcnJlZFJlZk5vZGUoQXVkaW9Ob2RlKiBub2RlKQoreworICAgIEFT U0VSVChpc0F1ZGlvVGhyZWFkKCkpOworICAgIG1fZGVmZXJyZWRSZWZMaXN0LmFwcGVuZChub2Rl KTsKK30KKwogdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZVByZVJlbmRlclRhc2tzKCkKIHsKICAg ICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKQEAgLTY5Myw2ICs2OTksOSBAQCB2b2lkIEF1ZGlv Q29udGV4dDo6aGFuZGxlUG9zdFJlbmRlclRhc2tzKCkKICAgICAvLyBmcm9tIHRoZSByZW5kZXIg Z3JhcGggKGluIHdoaWNoIGNhc2UgdGhleSdsbCByZW5kZXIgc2lsZW5jZSkuCiAgICAgYm9vbCBt dXN0UmVsZWFzZUxvY2s7CiAgICAgaWYgKHRyeUxvY2sobXVzdFJlbGVhc2VMb2NrKSkgeworICAg ICAgICAvLyBUYWtlIGNhcmUgb2YgYW55IGRlZmVycmVkIHJlZk5vZGVzIHRoYXQgd2VyZSBhZGRl ZC4KKyAgICAgICAgaGFuZGxlRGVmZXJyZWRSZWZOb2RlcygpOworICAgICAgIAogICAgICAgICAv LyBUYWtlIGNhcmUgb2YgZmluaXNoaW5nIGFueSBkZXJlZnMgd2hlcmUgdGhlIHRyeUxvY2soKSBm YWlsZWQgcHJldmlvdXNseS4KICAgICAgICAgaGFuZGxlRGVmZXJyZWRGaW5pc2hEZXJlZnMoKTsK IApAQCAtNzI1LDExICs3MzQsMjUgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVk RmluaXNoRGVyZWZzKCkKICAgICBtX2RlZmVycmVkRmluaXNoRGVyZWZMaXN0LmNsZWFyKCk7CiB9 CiAKK3ZvaWQgQXVkaW9Db250ZXh0OjpoYW5kbGVEZWZlcnJlZFJlZk5vZGVzKCkKK3sKKyAgICBB U1NFUlQoaXNBdWRpb1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKTsKKworICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBtX2RlZmVycmVkUmVmTGlzdC5zaXplKCk7ICsraSkgeworICAgICAg ICBBdWRpb05vZGUqIG5vZGUgPSBtX2RlZmVycmVkUmVmTGlzdFtpXTsKKyAgICAgICAgLy8gQWRk IGEgcmVmZXJlbmNlIHRvIG5vZGUgdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoaXMgbm9kZSBp cyBzdGlsbCBhbGl2ZS4KKyAgICAgICAgcmVmTm9kZShub2RlKTsKKyAgICB9CisgICAgbV9kZWZl cnJlZFJlZkxpc3QuY2xlYXIoKTsKK30KKwogdm9pZCBBdWRpb0NvbnRleHQ6Om1hcmtGb3JEZWxl dGlvbihBdWRpb05vZGUqIG5vZGUpCiB7CiAgICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKICAg ICBtX25vZGVzVG9EZWxldGUuYXBwZW5kKG5vZGUpOwogCisgICAgZnByaW50ZihzdGRlcnIsICJt YXJrRm9yRGVsZXRpb246ICVwOiAlZDogbmV3IHNpemUgPSAlbHUgaXNBdWRpbyA9ICVkXG4iLCBu b2RlLCBub2RlLT5ub2RlVHlwZSgpLCBtX25vZGVzVG9EZWxldGUuc2l6ZSgpLCBpc0F1ZGlvVGhy ZWFkKCkpOworCiAgICAgLy8gVGhpcyBpcyBwcm9iYWJseSB0aGUgYmVzdCB0aW1lIGZvciB1cyB0 byByZW1vdmUgdGhlIG5vZGUgZnJvbSBhdXRvbWF0aWMgcHVsbCBsaXN0LAogICAgIC8vIHNpbmNl IGFsbCBjb25uZWN0aW9ucyBhcmUgZ29uZSBhbmQgd2UgaG9sZCB0aGUgZ3JhcGggbG9jay4gVGhl biB3aGVuIGhhbmRsZVBvc3RSZW5kZXJUYXNrcygpCiAgICAgLy8gZ2V0cyBhIGNoYW5jZSB0byBz Y2hlZHVsZSB0aGUgZGVsZXRpb24gd29yaywgdXBkYXRlQXV0b21hdGljUHVsbE5vZGVzKCkgYWxz byBnZXRzIGEgY2hhbmNlIHRvCkBAIC03NDgsNiArNzcxLDcgQEAgdm9pZCBBdWRpb0NvbnRleHQ6 OnNjaGVkdWxlTm9kZURlbGV0aW9uKCkKICAgICBpZiAobV9ub2Rlc1RvRGVsZXRlLnNpemUoKSAm JiAhbV9pc0RlbGV0aW9uU2NoZWR1bGVkKSB7CiAgICAgICAgIG1faXNEZWxldGlvblNjaGVkdWxl ZCA9IHRydWU7CiAKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICIqKnNjaGVkdWxlTm9kZURlbGV0 aW9uIG9mICVsdSBub2Rlc1xuIiwgbV9ub2Rlc1RvRGVsZXRlLnNpemUoKSk7CiAgICAgICAgIC8v IERvbid0IGxldCBvdXJzZWxmIGdldCBkZWxldGVkIGJlZm9yZSB0aGUgY2FsbGJhY2suCiAgICAg ICAgIC8vIFNlZSBtYXRjaGluZyBkZXJlZigpIGluIGRlbGV0ZU1hcmtlZE5vZGVzRGlzcGF0Y2go KS4KICAgICAgICAgcmVmKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb0NvbnRleHQuaAppbmRleCA1MmZlYTEyLi44OTE1N2RmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKQEAgLTIxNSw5ICsyMTUsMTcgQEAg cHVibGljOgogICAgIC8vIEluIEF1ZGlvTm9kZTo6ZGVyZWYoKSBhIHRyeUxvY2soKSBpcyB1c2Vk IGZvciBjYWxsaW5nIGZpbmlzaERlcmVmKCksIGJ1dCBpZiBpdCBmYWlscyBrZWVwIHRyYWNrIGhl cmUuCiAgICAgdm9pZCBhZGREZWZlcnJlZEZpbmlzaERlcmVmKEF1ZGlvTm9kZSopOwogCisgICAg Ly8gQWRkIGF1ZGlvIG5vZGUgdG8gbGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8gY2FsbCBy ZWZOb2RlKCkgb24uIFRoZXJlIG11c3QgZXZlbnR1YWxseSBiZSBhCisgICAgLy8gY2FsbCB0byBh ZGREZWZlcnJlZERlcmVmTm9kZSgpIGZvciB0aGUgc2FtZSBub2RlLgorICAgIHZvaWQgYWRkRGVm ZXJyZWRSZWZOb2RlKEF1ZGlvTm9kZSopOworCiAgICAgLy8gSW4gdGhlIGF1ZGlvIHRocmVhZCBh dCB0aGUgc3RhcnQgb2YgZWFjaCByZW5kZXIgY3ljbGUsIHdlJ2xsIGNhbGwgaGFuZGxlRGVmZXJy ZWRGaW5pc2hEZXJlZnMoKS4KICAgICB2b2lkIGhhbmRsZURlZmVycmVkRmluaXNoRGVyZWZzKCk7 CiAKKyAgICAvLyBEdXJpbmcgcG9zdCByZW5kZXIgcHJvY2Vzc2luZywgYWxsIHRoZSBub2RlcyBh ZGRlZCBieSBhZGREZWZlcnJlZFJlZk5vZGVzKCkgd2lsbCBiZSBhZGRlZCB0bworICAgIC8vIG1f cmVmZXJlbmNlZE5vZGVzIGxpc3QgdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZXNlIG5vZGVz IGFyZSBzdGlsbCBhbGl2ZS4KKyAgICB2b2lkIGhhbmRsZURlZmVycmVkUmVmTm9kZXMoKTsKKwog ICAgIC8vIE9ubHkgYWNjZXNzZWQgd2hlbiB0aGUgZ3JhcGggbG9jayBpcyBoZWxkLgogICAgIHZv aWQgbWFya1N1bW1pbmdKdW5jdGlvbkRpcnR5KEF1ZGlvU3VtbWluZ0p1bmN0aW9uKik7CiAgICAg dm9pZCBtYXJrQXVkaW9Ob2RlT3V0cHV0RGlydHkoQXVkaW9Ob2RlT3V0cHV0Kik7CkBAIC0zMTAs NyArMzE4LDEwIEBAIHByaXZhdGU6CiAgICAgCiAgICAgLy8gT25seSBhY2Nlc3NlZCBpbiB0aGUg YXVkaW8gdGhyZWFkLgogICAgIFZlY3RvcjxBdWRpb05vZGUqPiBtX2RlZmVycmVkRmluaXNoRGVy ZWZMaXN0OwotICAgIAorCisgICAgLy8gTGlzdCBvZiBub2RlcyB0aGF0IHdlIHdhbnQgdG8gY2Fs bCByZWZOb2RlKCkgb24gdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoZSBub2RlIGlzIHN0aWxs IGFjdGl2ZS4KKyAgICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9kZWZlcnJlZFJlZkxpc3Q7CisKICAg ICAvLyBIUlRGIERhdGFiYXNlIGxvYWRlcgogICAgIFJlZlB0cjxIUlRGRGF0YWJhc2VMb2FkZXI+ IG1faHJ0ZkRhdGFiYXNlTG9hZGVyOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1 ZGlvL0F1ZGlvTm9kZS5jcHAKaW5kZXggNTAwNmQ1OC4uNDU3YzFiZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcApAQCAtMzYsNiArMzYsOCBAQAog I2luY2x1ZGUgPHd0Zi9BdG9taWNzLmg+CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KIAor I2luY2x1ZGUgPHN0ZGlvLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogQXVkaW9Ob2RlOjpB dWRpb05vZGUoQXVkaW9Db250ZXh0KiBjb250ZXh0LCBmbG9hdCBzYW1wbGVSYXRlKQpAQCAtNDks NiArNTEsNyBAQCBBdWRpb05vZGU6OkF1ZGlvTm9kZShBdWRpb0NvbnRleHQqIGNvbnRleHQsIGZs b2F0IHNhbXBsZVJhdGUpCiAgICAgLCBtX2Nvbm5lY3Rpb25SZWZDb3VudCgwKQogICAgICwgbV9p c01hcmtlZEZvckRlbGV0aW9uKGZhbHNlKQogICAgICwgbV9pc0Rpc2FibGVkKGZhbHNlKQorICAg ICwgbV9hbGxvd1RhaWxQcm9jZXNzaW5nKGZhbHNlKQogewogI2lmIERFQlVHX0FVRElPTk9ERV9S RUZFUkVOQ0VTCiAgICAgaWYgKCFzX2lzTm9kZUNvdW50SW5pdGlhbGl6ZWQpIHsKQEAgLTYyLDcg KzY1LDcgQEAgQXVkaW9Ob2RlOjp+QXVkaW9Ob2RlKCkKIHsKICNpZiBERUJVR19BVURJT05PREVf UkVGRVJFTkNFUwogICAgIC0tc19ub2RlQ291bnRbbm9kZVR5cGUoKV07Ci0gICAgcHJpbnRmKCIl cDogJWQ6IEF1ZGlvTm9kZTo6fkF1ZGlvTm9kZSgpICVkICVkXG4iLCB0aGlzLCBub2RlVHlwZSgp LCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCk7CisgICAgZnByaW50Zihz dGRlcnIsICIlcDogJWQ6IEF1ZGlvTm9kZTo6fkF1ZGlvTm9kZSgpICVkICVkXG4iLCB0aGlzLCBu b2RlVHlwZSgpLCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCk7CiAjZW5k aWYKIH0KIApAQCAtMjA5LDkgKzIxMiwxMiBAQCB2b2lkIEF1ZGlvTm9kZTo6cHJvY2Vzc0lmTmVj ZXNzYXJ5KHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpCiAgICAgICAgIGlmICghc2lsZW50SW5wdXRz KQogICAgICAgICAgICAgbV9sYXN0Tm9uU2lsZW50VGltZSA9IChjb250ZXh0KCktPmN1cnJlbnRT YW1wbGVGcmFtZSgpICsgZnJhbWVzVG9Qcm9jZXNzKSAvIHN0YXRpY19jYXN0PGRvdWJsZT4obV9z YW1wbGVSYXRlKTsKIAotICAgICAgICBpZiAoc2lsZW50SW5wdXRzICYmIHByb3BhZ2F0ZXNTaWxl bmNlKCkpCisgICAgICAgIGlmIChzaWxlbnRJbnB1dHMgJiYgcHJvcGFnYXRlc1NpbGVuY2UoKSkg eworICAgICAgICAgICAgLy8gVGFpbCBwcm9jZXNzaW5nIGNhbiBlbmQgbm93IGJlY2F1c2Ugd2Ug YXJlIHByb3BhZ2F0aW5nIHNpbGVuY2UuCisgICAgICAgICAgICBlbmRUYWlsUHJvY2Vzc2luZ0lm TmVlZGVkKCk7CiAgICAgICAgICAgICBzaWxlbmNlT3V0cHV0cygpOwotICAgICAgICBlbHNlIHsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRl ZCgpOwogICAgICAgICAgICAgcHJvY2VzcyhmcmFtZXNUb1Byb2Nlc3MpOwogICAgICAgICAgICAg dW5zaWxlbmNlT3V0cHV0cygpOwogICAgICAgICB9CkBAIC0yOTAsMTUgKzI5Niw5IEBAIHZvaWQg QXVkaW9Ob2RlOjpkaXNhYmxlT3V0cHV0c0lmTmVjZXNzYXJ5KCkKICAgICAgICAgLy8gQnV0IGlu dGVybmFsbHkgb3VyIG91dHB1dHMgc2hvdWxkIGJlIGRpc2FibGVkIGZyb20gdGhlIGlucHV0cyB0 aGV5J3JlIGNvbm5lY3RlZCB0by4KICAgICAgICAgLy8gZGlzYWJsZSgpIGNhbiByZWN1cnNpdmVs eSBkZXJlZiBjb25uZWN0aW9ucyAoYW5kIGNhbGwgZGlzYWJsZSgpKSBkb3duIGEgd2hvbGUgY2hh aW4gb2YgY29ubmVjdGVkIG5vZGVzLgogCi0gICAgICAgIC8vIEZJWE1FOiB3ZSBzcGVjaWFsIGNh c2UgdGhlIGNvbnZvbHZlciBhbmQgZGVsYXkgc2luY2UgdGhleSBoYXZlIGEgc2lnbmlmaWNhbnQg dGFpbC10aW1lIGFuZCBzaG91bGRuJ3QgYmUgZGlzY29ubmVjdGVkIHNpbXBseQotICAgICAgICAv LyBiZWNhdXNlIHRoZXkgbm8gbG9uZ2VyIGhhdmUgYW55IGlucHV0IGNvbm5lY3Rpb25zLiBUaGlz IG5lZWRzIHRvIGJlIGhhbmRsZWQgbW9yZSBnZW5lcmFsbHkgd2hlcmUgQXVkaW9Ob2RlcyBoYXZl Ci0gICAgICAgIC8vIGEgdGFpbFRpbWUgYXR0cmlidXRlLiBUaGVuIHRoZSBBdWRpb05vZGUgb25s eSBuZWVkcyB0byByZW1haW4gImFjdGl2ZSIgZm9yIHRhaWxUaW1lIHNlY29uZHMgYWZ0ZXIgdGhl cmUgYXJlIG5vCi0gICAgICAgIC8vIGxvbmdlciBhbnkgYWN0aXZlIGNvbm5lY3Rpb25zLgotICAg ICAgICBpZiAobm9kZVR5cGUoKSAhPSBOb2RlVHlwZUNvbnZvbHZlciAmJiBub2RlVHlwZSgpICE9 IE5vZGVUeXBlRGVsYXkpIHsKLSAgICAgICAgICAgIG1faXNEaXNhYmxlZCA9IHRydWU7Ci0gICAg ICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9vdXRwdXRzLnNpemUoKTsgKytpKQot ICAgICAgICAgICAgICAgIG91dHB1dChpKS0+ZGlzYWJsZSgpOwotICAgICAgICB9CisgICAgICAg IG1faXNEaXNhYmxlZCA9IHRydWU7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBt X291dHB1dHMuc2l6ZSgpOyArK2kpCisgICAgICAgICAgICBvdXRwdXQoaSktPmRpc2FibGUoKTsK ICAgICB9CiB9CiAKQEAgLTMxNiw3ICszMTYsNyBAQCB2b2lkIEF1ZGlvTm9kZTo6cmVmKFJlZlR5 cGUgcmVmVHlwZSkKICAgICB9CiAKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwotICAg IHByaW50ZigiJXA6ICVkOiBBdWRpb05vZGU6OnJlZiglZCkgJWQgJWRcbiIsIHRoaXMsIG5vZGVU eXBlKCksIHJlZlR5cGUsIG1fbm9ybWFsUmVmQ291bnQsIG1fY29ubmVjdGlvblJlZkNvdW50KTsK KyAgICBmcHJpbnRmKHN0ZGVyciwgIiVwOiAlZDogQXVkaW9Ob2RlOjpyZWYoJWQpICVkICVkXG4i LCB0aGlzLCBub2RlVHlwZSgpLCByZWZUeXBlLCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rp b25SZWZDb3VudCk7CiAjZW5kaWYKIAogICAgIC8vIFNlZSB0aGUgZGlzYWJsaW5nIGNvZGUgaW4g ZmluaXNoRGVyZWYoKSBiZWxvdy4gVGhpcyBoYW5kbGVzIHRoZSBjYXNlIHdoZXJlIGEgbm9kZQpA QCAtMzc5LDcgKzM3OSw3IEBAIHZvaWQgQXVkaW9Ob2RlOjpmaW5pc2hEZXJlZihSZWZUeXBlIHJl ZlR5cGUpCiAgICAgfQogICAgIAogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCi0gICAg cHJpbnRmKCIlcDogJWQ6IEF1ZGlvTm9kZTo6ZGVyZWYoJWQpICVkICVkXG4iLCB0aGlzLCBub2Rl VHlwZSgpLCByZWZUeXBlLCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5lY3Rpb25SZWZDb3VudCk7 CisgICAgZnByaW50ZihzdGRlcnIsICIlcDogJWQ6IEF1ZGlvTm9kZTo6ZGVyZWYoJWQpICVkICVk XG4iLCB0aGlzLCBub2RlVHlwZSgpLCByZWZUeXBlLCBtX25vcm1hbFJlZkNvdW50LCBtX2Nvbm5l Y3Rpb25SZWZDb3VudCk7CiAjZW5kaWYKIAogICAgIGlmICghbV9jb25uZWN0aW9uUmVmQ291bnQp IHsKQEAgLTM5OCw2ICszOTgsMzAgQEAgdm9pZCBBdWRpb05vZGU6OmZpbmlzaERlcmVmKFJlZlR5 cGUgcmVmVHlwZSkKICAgICB9CiB9CiAKK3ZvaWQgQXVkaW9Ob2RlOjphbGxvd1RhaWxQcm9jZXNz aW5nSWZOZWVkZWQoKQoreworICAgIGlmICghbV9hbGxvd1RhaWxQcm9jZXNzaW5nICYmIChsYXRl bmN5VGltZSgpICsgdGFpbFRpbWUoKSA+IDApKSB7CisgICAgICAgIC8vIEVzdGFibGlzaCBhIHJl ZiB0byBvdXJzZWxmIGlmIHdlIGhhdmVuJ3QgYWxyZWFkeSBzbyB3ZSBkb24ndCBnZXQgcmVtb3Zl ZCB3aGVuIGFsbCBub2RlcworICAgICAgICAvLyBoYXZlIGRpc2Nvbm5lY3RlZCBmcm9tIHVzLiBX ZSBob2xkIHRoaXMgcmVmIGR1cmluZyB0aGUgdGltZSB3aGVuIHdlIGFyZSByZWNlaXZpbmcKKyAg ICAgICAgLy8gbm9uLXNpbGVudCBpbnB1dCwgb3IgZHVyaW5nIHRoZSB0aW1lIGFmdGVyIGZpcnN0 IHJlY2VpdmluZyBzaWxlbnQgaW5wdXQgd2hlbiB3ZSBlbXB0eSB0aGUKKyAgICAgICAgLy8gcHJv Y2Vzc2luZyBwaXBlbGluZSB0byBhY2NvdW50IGZvciBsYXRlbmN5IGFuZCB0YWlsLgorICAgICAg ICBtX2FsbG93VGFpbFByb2Nlc3NpbmcgPSB0cnVlOworICAgICAgICBjb250ZXh0KCktPmFkZERl ZmVycmVkUmVmTm9kZSh0aGlzKTsKKyAgICB9Cit9CisKK3ZvaWQgQXVkaW9Ob2RlOjplbmRUYWls UHJvY2Vzc2luZ0lmTmVlZGVkKCkKK3sKKyAgICBBU1NFUlQocHJvcGFnYXRlc1NpbGVuY2UoKSk7 CisgICAgCisgICAgaWYgKG1fYWxsb3dUYWlsUHJvY2Vzc2luZykgeworICAgICAgICAvLyBTdG9w IHRhaWwgcHJvY2Vzc2luZy4gSnVzdCBuZWVkIHRvIGRlcmVmIG91cnNlbGYsIGJ1dCB3ZSBjYW4n dCBkbyB0aGF0IHdoaWxlIHRoZSBncmFwaAorICAgICAgICAvLyBpcyBiZWluZyByZW5kZXJlZC4g U2NoZWR1bGUgdGhlIGRlcmVmIHRvIGhhcHBlbiBkdXJpbmcgdGhlIHBvc3QtcmVuZGVyaW5nIHBo YXNlLgorICAgICAgICBtX2FsbG93VGFpbFByb2Nlc3NpbmcgPSBmYWxzZTsKKyAgICAgICAgY29u dGV4dCgpLT5ub3RpZnlOb2RlRmluaXNoZWRQcm9jZXNzaW5nKHRoaXMpOworICAgIH0KK30KKwog I2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAKIGJvb2wgQXVkaW9Ob2RlOjpzX2lzTm9k ZUNvdW50SW5pdGlhbGl6ZWQgPSBmYWxzZTsKQEAgLTQwNSwxNSArNDI5LDE1IEBAIGludCBBdWRp b05vZGU6OnNfbm9kZUNvdW50W05vZGVUeXBlRW5kXTsKIAogdm9pZCBBdWRpb05vZGU6OnByaW50 Tm9kZUNvdW50cygpCiB7Ci0gICAgcHJpbnRmKCJcblxuIik7Ci0gICAgcHJpbnRmKCI9PT09PT09 PT09PT09PT09PT09PT09PT09PT1cbiIpOwotICAgIHByaW50ZigiQXVkaW9Ob2RlOiByZWZlcmVu Y2UgY291bnRzXG4iKTsKLSAgICBwcmludGYoIj09PT09PT09PT09PT09PT09PT09PT09PT09PVxu Iik7CisgICAgZnByaW50ZihzdGRlcnIsICJcblxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICI9 PT09PT09PT09PT09PT09PT09PT09PT09PT1cbiIpOworICAgIGZwcmludGYoc3RkZXJyLCAiQXVk aW9Ob2RlOiByZWZlcmVuY2UgY291bnRzXG4iKTsKKyAgICBmcHJpbnRmKHN0ZGVyciwgIj09PT09 PT09PT09PT09PT09PT09PT09PT09PVxuIik7CiAKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBp IDwgTm9kZVR5cGVFbmQ7ICsraSkKLSAgICAgICAgcHJpbnRmKCIlZDogJWRcbiIsIGksIHNfbm9k ZUNvdW50W2ldKTsKKyAgICAgICAgZnByaW50ZihzdGRlcnIsICIlZDogJWRcbiIsIGksIHNfbm9k ZUNvdW50W2ldKTsKIAotICAgIHByaW50ZigiPT09PT09PT09PT09PT09PT09PT09PT09PT09XG5c blxuIik7CisgICAgZnByaW50ZihzdGRlcnIsICI9PT09PT09PT09PT09PT09PT09PT09PT09PT1c blxuXG4iKTsKIH0KIAogI2VuZGlmIC8vIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaAppbmRleCBiZWU3OGY3Li4w ODk3NDVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlv Tm9kZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgK QEAgLTMwLDcgKzMwLDcgQEAKICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgogCi0jZGVmaW5lIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VTIDAKKyNkZWZp bmUgREVCVUdfQVVESU9OT0RFX1JFRkVSRU5DRVMgMQogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK QEAgLTE1NSw2ICsxNTUsMTkgQEAgcHVibGljOgogCiAgICAgdm9pZCBlbmFibGVPdXRwdXRzSWZO ZWNlc3NhcnkoKTsKICAgICB2b2lkIGRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkoKTsKKworICAg IC8vIEFsbG93IHRhaWwgcHJvY2Vzc2luZyBmb3Igbm9kZXMgdGhhdCBoYXZlIHRhaWwgb3IgbGF0 ZW5jeSB0aW1lLiBUaGlzIHdpbGwgY3JlYXRlIGFuCisgICAgLy8gYWRkaXRpb25hbCBjb25uZWN0 aW9uIHJlZiB0byBvdXJzZWxmIHNvIHdlIGRvbid0IGdldCByZW1vdmVkIGZyb20gdGhlIGdyYXBo IGJlZm9yZSB0aGUgdGFpbAorICAgIC8vIGhhcyBiZWVuIHByb2Nlc3NlZC4KKyAgICB2b2lkIGFs bG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCgpOworCisgICAgLy8gSWYgd2UncmUgcHJvY2Vzc2lu ZyB0aGUgdGFpbCBmb3IgdGhpcyBub2RlIGFuZCBhbGwgb3V0cHV0cyBzaG91bGQgYmUgcHJvcGFn YXRpbmcgc2lsZW5jZSwgd2UKKyAgICAvLyBlbmQgdGFpbCBwcm9jZXNzaW5nLiBUaGUgY29ubmVj dGlvbiByZWYgdG8gb3Vyc2VsZiB3aWxsIGJlIHJlbW92ZWQsIGJhbGFuY2luZyB0aGUgcmVmZXJl bmNlCisgICAgLy8gYWRkZWQgaW4gYWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkuCisgICAg dm9pZCBlbmRUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCk7CisKKyAgICBib29sIGlzVGFpbFByb2Nl c3NpbmcoKSB7IHJldHVybiBtX2FsbG93VGFpbFByb2Nlc3Npbmc7IH0KKwogcHJvdGVjdGVkOgog ICAgIC8vIElucHV0cyBhbmQgb3V0cHV0cyBtdXN0IGJlIGNyZWF0ZWQgYmVmb3JlIHRoZSBBdWRp b05vZGUgaXMgaW5pdGlhbGl6ZWQuCiAgICAgdm9pZCBhZGRJbnB1dChQYXNzT3duUHRyPEF1ZGlv Tm9kZUlucHV0Pik7CkBAIC0xODMsNiArMTk2LDggQEAgcHJpdmF0ZToKICAgICBib29sIG1faXNN YXJrZWRGb3JEZWxldGlvbjsKICAgICBib29sIG1faXNEaXNhYmxlZDsKICAgICAKKyAgICBib29s IG1fYWxsb3dUYWlsUHJvY2Vzc2luZzsKKwogI2lmIERFQlVHX0FVRElPTk9ERV9SRUZFUkVOQ0VT CiAgICAgc3RhdGljIGJvb2wgc19pc05vZGVDb3VudEluaXRpYWxpemVkOwogICAgIHN0YXRpYyBp bnQgc19ub2RlQ291bnRbTm9kZVR5cGVFbmRdOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCmluZGV4IDRkMGFkMTguLjkzZDlmYTYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJO b2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVy Tm9kZS5jcHAKQEAgLTkxLDcgKzkxLDcgQEAgdm9pZCBBdWRpb1Bhbm5lck5vZGU6OnByb2Nlc3Mo c2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKIHsKICAgICBBdWRpb0J1cyogZGVzdGluYXRpb24gPSBv dXRwdXQoMCktPmJ1cygpOwogCi0gICAgaWYgKCFpc0luaXRpYWxpemVkKCkgfHwgIWlucHV0KDAp LT5pc0Nvbm5lY3RlZCgpIHx8ICFtX3Bhbm5lci5nZXQoKSkgeworICAgIGlmICghaXNJbml0aWFs aXplZCgpIHx8ICFtX3Bhbm5lci5nZXQoKSkgewogICAgICAgICBkZXN0aW5hdGlvbi0+emVybygp OwogICAgICAgICByZXR1cm47CiAgICAgfQo= 149457 2012-06-25 22:40:34 -0700 2012-06-25 22:40:34 -0700 WIP bug-77224-20120625224034.patch text/plain 26618 rtoy U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxMTI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODkzNTg3ZTBlMWViNTNh MmE0NTA4YzE4ZjI4M2M5ZjNmNDUxMzQyNS4uMzM5YmYwZDc0N2VhMjhjZGFjZDk1YzU3M2ZmZmNl ODc1NDM4NjhiNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDEyLTA2LTI1ICBSYXlt b25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5PbiBpcyB0b28g bG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcy MjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIChPT1BTISkKKworICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9CdWZm ZXJTb3VyY2VOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVmZmVyU291cmNlTm9k ZTo6cmVuZGVyRnJvbUJ1ZmZlcik6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb0Nv bnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjpBdWRpb0NvbnRleHQp OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0Ojp1bmluaXRpYWxpemUpOgorICAgICAg ICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0OjpyZWZOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1 ZGlvQ29udGV4dDo6ZGVyZWZVbmZpbmlzaGVkU291cmNlTm9kZXMpOgorICAgICAgICAoV2ViQ29y ZTo6QXVkaW9Db250ZXh0Ojpsb2NrKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ29udGV4dDo6 YWRkRGVmZXJyZWREZXJlZk5vZGUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkUmVmTm9kZSk6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RSZW5kZXJUYXNrcyk6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkRGVyZWZOb2Rlcyk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkUmVmTm9kZXMpOgorICAgICAgICAoV2Vi Q29yZTo6QXVkaW9Db250ZXh0OjptYXJrRm9yRGVsZXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9Db250ZXh0OjpzY2hlZHVsZU5vZGVEZWxldGlvbik6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0NvbnRleHQ6OmRlbGV0ZU1hcmtlZE5vZGVzRGlzcGF0Y2gpOgorICAgICAgICAoV2ViQ29y ZTo6QXVkaW9Db250ZXh0OjpkZWxldGVPbmVNYXJrZWROb2RlKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQ29udGV4dDo6ZGVsZXRlU2NoZWR1bGVkTm9kZXMpOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9Db250ZXh0OjpkZWxldGVBbGxNYXJrZWROb2Rlcyk6CisgICAgICAgICogTW9kdWxlcy93 ZWJhdWRpby9BdWRpb0NvbnRleHQuaDoKKyAgICAgICAgKEF1ZGlvQ29udGV4dCk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OnVwZGF0ZURlbGV0aW9uQ291bnQpOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9Db250ZXh0Ojpub2RlRGVsZXRpb25Db3VudCk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb0NvbnRleHQ6Om5vZGVzVG9EZWxldGVTaXplKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQ29udGV4dDo6ZGVmZXJyZWREZXJlZk5vZGVTaXplKToKKyAgICAgICAgKiBNb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OkF1 ZGlvTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OnByb2Nlc3NJZk5lY2Vzc2Fy eSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OmRpc2FibGVPdXRwdXRzSWZOZWNlc3Nh cnkpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpkZXJlZik6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmFsbG93VGFpbFByb2Nlc3NpbmdJZk5lZWRlZCk6CisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvTm9kZTo6ZW5kVGFpbFByb2Nlc3NpbmdJ Zk5lZWRlZCk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuaDoKKyAgICAg ICAgKEF1ZGlvTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6OmlzRGlzYWJsZWQp OgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlSW5wdXQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6QXVkaW9Ob2RlSW5wdXQ6OmRpc2Nvbm5lY3QpOgorICAgICAgICAqIE1vZHVs ZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlv UGFubmVyTm9kZTo6cHJvY2Vzcyk6CisKIDIwMTItMDYtMjQgIFNoZXJpZmYgQm90ICA8d2Via2l0 LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0 IHIxMjExMDYuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1 ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L0F1ZGlvQnVmZmVyU291cmNlTm9kZS5jcHAKaW5kZXggNDQyNTdiNjM5NzI1ZjRiMzczYmU2OGUw NTIzNDUwNDMzNWI3YjQ2MS4uZmZmNjYyM2IxYTczMWFmNjZmYWM2ZjZkYWMxZTNmZjdmZTI1NDlm NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0J1ZmZl clNvdXJjZU5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVk aW9CdWZmZXJTb3VyY2VOb2RlLmNwcApAQCAtMjA0LDExICsyMDQsNiBAQCB2b2lkIEF1ZGlvQnVm ZmVyU291cmNlTm9kZTo6cmVuZGVyRnJvbUJ1ZmZlcihBdWRpb0J1cyogYnVzLCB1bnNpZ25lZCBk ZXN0aW5hdGlvbgogICAgIAogICAgIHVuc2lnbmVkIGRlbHRhRnJhbWVzID0gZW5kRnJhbWUgLSBz dGFydEZyYW1lOwogICAgIAotICAgIC8vIFRoaXMgaXMgYSBIQUNLIHRvIGFsbG93IGZvciBIUlRG IHRhaWwtdGltZSAtIGF2b2lkcyBnbGl0Y2ggYXQgZW5kLgotICAgIC8vIEZJWE1FOiBpbXBsZW1l bnQgdGFpbFRpbWUgZm9yIGVhY2ggQXVkaW9Ob2RlIGZvciBhIG1vcmUgZ2VuZXJhbCBzb2x1dGlv biB0byB0aGlzIHByb2JsZW0uCi0gICAgaWYgKG1faXNHcmFpbikKLSAgICAgICAgZW5kRnJhbWUg Kz0gNTEyOwotCiAgICAgLy8gRG8gc29tZSBzYW5pdHkgY2hlY2tpbmcuCiAgICAgaWYgKHN0YXJ0 RnJhbWUgPj0gYnVmZmVyTGVuZ3RoKQogICAgICAgICBzdGFydEZyYW1lID0gIWJ1ZmZlckxlbmd0 aCA/IDAgOiBidWZmZXJMZW5ndGggLSAxOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwCmluZGV4IDlhY2U5NTFhN2NkNjc4NDAwODZkYTYzZDIw N2FjMDhkNjE5ODgxNGQuLjAyNWY0NDM2YzkxM2Y4Y2M2MTExMmEwZmM4N2JkNzNmZTdiNDY1MzEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5j cHAKQEAgLTE0MCw2ICsxNDAsNyBAQCBBdWRpb0NvbnRleHQ6OkF1ZGlvQ29udGV4dChEb2N1bWVu dCogZG9jdW1lbnQpCiAgICAgLCBtX2RvY3VtZW50KGRvY3VtZW50KQogICAgICwgbV9kZXN0aW5h dGlvbk5vZGUoMCkKICAgICAsIG1faXNEZWxldGlvblNjaGVkdWxlZChmYWxzZSkKKyAgICAsIG1f bm9kZURlbGV0aW9uQ291bnQoMCkKICAgICAsIG1fYXV0b21hdGljUHVsbE5vZGVzTmVlZFVwZGF0 aW5nKGZhbHNlKQogICAgICwgbV9jb25uZWN0aW9uQ291bnQoMCkKICAgICAsIG1fYXVkaW9UaHJl YWQoMCkKQEAgLTE2NSw2ICsxNjYsNyBAQCBBdWRpb0NvbnRleHQ6OkF1ZGlvQ29udGV4dChEb2N1 bWVudCogZG9jdW1lbnQsIHVuc2lnbmVkIG51bWJlck9mQ2hhbm5lbHMsIHNpemVfdAogICAgICwg bV9pc0F1ZGlvVGhyZWFkRmluaXNoZWQoZmFsc2UpCiAgICAgLCBtX2RvY3VtZW50KGRvY3VtZW50 KQogICAgICwgbV9kZXN0aW5hdGlvbk5vZGUoMCkKKyAgICAsIG1fbm9kZURlbGV0aW9uQ291bnQo MCkKICAgICAsIG1fYXV0b21hdGljUHVsbE5vZGVzTmVlZFVwZGF0aW5nKGZhbHNlKQogICAgICwg bV9jb25uZWN0aW9uQ291bnQoMCkKICAgICAsIG1fYXVkaW9UaHJlYWQoMCkKQEAgLTI1NSw3ICsy NTcsNyBAQCB2b2lkIEF1ZGlvQ29udGV4dDo6dW5pbml0aWFsaXplKCkKICAgICAgICAgLy8gR2V0 IHJpZCBvZiB0aGUgc291cmNlcyB3aGljaCBtYXkgc3RpbGwgYmUgcGxheWluZy4KICAgICAgICAg ZGVyZWZVbmZpbmlzaGVkU291cmNlTm9kZXMoKTsKIAotICAgICAgICBkZWxldGVNYXJrZWROb2Rl cygpOworICAgICAgICBkZWxldGVBbGxNYXJrZWROb2RlcygpOwogCiAgICAgICAgIG1faXNJbml0 aWFsaXplZCA9IGZhbHNlOwogICAgIH0KQEAgLTU2MCw3ICs1NjIsNyBAQCB2b2lkIEF1ZGlvQ29u dGV4dDo6ZGVyZWZGaW5pc2hlZFNvdXJjZU5vZGVzKCkKIAogdm9pZCBBdWRpb0NvbnRleHQ6OnJl Zk5vZGUoQXVkaW9Ob2RlKiBub2RlKQogewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpIHx8IChpc0F1ZGlvVGhyZWFkKCkgJiYgaXNHcmFwaE93 bmVyKCkpKTsKICAgICBBdXRvTG9ja2VyIGxvY2tlcih0aGlzKTsKICAgICAKICAgICBub2RlLT5y ZWYoQXVkaW9Ob2RlOjpSZWZUeXBlQ29ubmVjdGlvbik7CkBAIC01ODQsNiArNTg2LDcgQEAgdm9p ZCBBdWRpb0NvbnRleHQ6OmRlcmVmTm9kZShBdWRpb05vZGUqIG5vZGUpCiB2b2lkIEF1ZGlvQ29u dGV4dDo6ZGVyZWZVbmZpbmlzaGVkU291cmNlTm9kZXMoKQogewogICAgIEFTU0VSVChpc01haW5U aHJlYWQoKSAmJiBpc0F1ZGlvVGhyZWFkRmluaXNoZWQoKSk7CisKICAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbV9yZWZlcmVuY2VkTm9kZXMuc2l6ZSgpOyArK2kpCiAgICAgICAgIG1fcmVm ZXJlbmNlZE5vZGVzW2ldLT5kZXJlZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsKIApA QCAtNTkzLDcgKzU5Niw3IEBAIHZvaWQgQXVkaW9Db250ZXh0OjpkZXJlZlVuZmluaXNoZWRTb3Vy Y2VOb2RlcygpCiB2b2lkIEF1ZGlvQ29udGV4dDo6bG9jayhib29sJiBtdXN0UmVsZWFzZUxvY2sp CiB7CiAgICAgLy8gRG9uJ3QgYWxsb3cgcmVndWxhciBsb2NrIGluIHJlYWwtdGltZSBhdWRpbyB0 aHJlYWQuCi0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkgfHwgKGlzQXVkaW9UaHJlYWQoKSAmJiBpc0dyYXBoT3duZXIoKSkpOwogCiAgICAgVGhy ZWFkSWRlbnRpZmllciB0aGlzVGhyZWFkID0gY3VycmVudFRocmVhZCgpOwogCkBAIC02NTksMTAg KzY2MiwxNiBAQCBib29sIEF1ZGlvQ29udGV4dDo6aXNHcmFwaE93bmVyKCkgY29uc3QKICAgICBy ZXR1cm4gY3VycmVudFRocmVhZCgpID09IG1fZ3JhcGhPd25lclRocmVhZDsKIH0KIAotdm9pZCBB dWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRmluaXNoRGVyZWYoQXVkaW9Ob2RlKiBub2RlKQordm9p ZCBBdWRpb0NvbnRleHQ6OmFkZERlZmVycmVkRGVyZWZOb2RlKEF1ZGlvTm9kZSogbm9kZSkKK3sK KyAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKKyAgICBtX2RlZmVycmVkRGVyZWZOb2RlTGlz dC5hcHBlbmQobm9kZSk7Cit9CisKK3ZvaWQgQXVkaW9Db250ZXh0OjphZGREZWZlcnJlZFJlZk5v ZGUoQXVkaW9Ob2RlKiBub2RlKQogewogICAgIEFTU0VSVChpc0F1ZGlvVGhyZWFkKCkpOwotICAg IG1fZGVmZXJyZWRGaW5pc2hEZXJlZkxpc3QuYXBwZW5kKG5vZGUpOworICAgIG1fZGVmZXJyZWRS ZWZMaXN0LmFwcGVuZChub2RlKTsKIH0KIAogdm9pZCBBdWRpb0NvbnRleHQ6OmhhbmRsZVByZVJl bmRlclRhc2tzKCkKQEAgLTY5MywyMCArNzAyLDIzIEBAIHZvaWQgQXVkaW9Db250ZXh0OjpoYW5k bGVQb3N0UmVuZGVyVGFza3MoKQogICAgIC8vIGZyb20gdGhlIHJlbmRlciBncmFwaCAoaW4gd2hp Y2ggY2FzZSB0aGV5J2xsIHJlbmRlciBzaWxlbmNlKS4KICAgICBib29sIG11c3RSZWxlYXNlTG9j azsKICAgICBpZiAodHJ5TG9jayhtdXN0UmVsZWFzZUxvY2spKSB7CisgICAgICAgIC8vIFRha2Ug Y2FyZSBvZiBhbnkgZGVmZXJyZWQgcmVmTm9kZXMgdGhhdCB3ZXJlIGFkZGVkLgorICAgICAgICBo YW5kbGVEZWZlcnJlZFJlZk5vZGVzKCk7CisgICAgICAgCiAgICAgICAgIC8vIFRha2UgY2FyZSBv ZiBmaW5pc2hpbmcgYW55IGRlcmVmcyB3aGVyZSB0aGUgdHJ5TG9jaygpIGZhaWxlZCBwcmV2aW91 c2x5LgotICAgICAgICBoYW5kbGVEZWZlcnJlZEZpbmlzaERlcmVmcygpOworICAgICAgICBoYW5k bGVEZWZlcnJlZERlcmVmTm9kZXMoKTsKIAogICAgICAgICAvLyBEeW5hbWljYWxseSBjbGVhbiB1 cCBub2RlcyB3aGljaCBhcmUgbm8gbG9uZ2VyIG5lZWRlZC4KICAgICAgICAgZGVyZWZGaW5pc2hl ZFNvdXJjZU5vZGVzKCk7CiAKLSAgICAgICAgLy8gRG9uJ3QgZGVsZXRlIGluIHRoZSByZWFsLXRp bWUgdGhyZWFkLiBMZXQgdGhlIG1haW4gdGhyZWFkIGRvIGl0LgotICAgICAgICAvLyBSZWYtY291 bnRlZCBvYmplY3RzIGhlbGQgYnkgY2VydGFpbiBBdWRpb05vZGVzIG1heSBub3QgYmUgdGhyZWFk LXNhZmUuCi0gICAgICAgIHNjaGVkdWxlTm9kZURlbGV0aW9uKCk7Ci0KICAgICAgICAgLy8gRml4 dXAgdGhlIHN0YXRlIG9mIGFueSBkaXJ0eSBBdWRpb1N1bW1pbmdKdW5jdGlvbnMgYW5kIEF1ZGlv Tm9kZU91dHB1dHMuCiAgICAgICAgIGhhbmRsZURpcnR5QXVkaW9TdW1taW5nSnVuY3Rpb25zKCk7 CiAgICAgICAgIGhhbmRsZURpcnR5QXVkaW9Ob2RlT3V0cHV0cygpOwogCisgICAgICAgIC8vIERv bid0IGRlbGV0ZSBpbiB0aGUgcmVhbC10aW1lIHRocmVhZC4gTGV0IHRoZSBtYWluIHRocmVhZCBk byBpdC4KKyAgICAgICAgLy8gUmVmLWNvdW50ZWQgb2JqZWN0cyBoZWxkIGJ5IGNlcnRhaW4gQXVk aW9Ob2RlcyBtYXkgbm90IGJlIHRocmVhZC1zYWZlLgorICAgICAgICBzY2hlZHVsZU5vZGVEZWxl dGlvbigpOworCiAgICAgICAgIHVwZGF0ZUF1dG9tYXRpY1B1bGxOb2RlcygpOwogCiAgICAgICAg IGlmIChtdXN0UmVsZWFzZUxvY2spCkBAIC03MTQsMjAgKzcyNiwzMyBAQCB2b2lkIEF1ZGlvQ29u dGV4dDo6aGFuZGxlUG9zdFJlbmRlclRhc2tzKCkKICAgICB9CiB9CiAKLXZvaWQgQXVkaW9Db250 ZXh0OjpoYW5kbGVEZWZlcnJlZEZpbmlzaERlcmVmcygpCit2b2lkIEF1ZGlvQ29udGV4dDo6aGFu ZGxlRGVmZXJyZWREZXJlZk5vZGVzKCkKIHsKICAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpICYm IGlzR3JhcGhPd25lcigpKTsKLSAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9kZWZlcnJl ZEZpbmlzaERlcmVmTGlzdC5zaXplKCk7ICsraSkgewotICAgICAgICBBdWRpb05vZGUqIG5vZGUg PSBtX2RlZmVycmVkRmluaXNoRGVyZWZMaXN0W2ldOwotICAgICAgICBub2RlLT5maW5pc2hEZXJl ZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAw OyBpIDwgbV9kZWZlcnJlZERlcmVmTm9kZUxpc3Quc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgQXVk aW9Ob2RlKiBub2RlID0gbV9kZWZlcnJlZERlcmVmTm9kZUxpc3RbaV07CisgICAgICAgIGRlcmVm Tm9kZShub2RlKTsKICAgICB9CiAgICAgCi0gICAgbV9kZWZlcnJlZEZpbmlzaERlcmVmTGlzdC5j bGVhcigpOworICAgIG1fZGVmZXJyZWREZXJlZk5vZGVMaXN0LmNsZWFyKCk7Cit9CisKK3ZvaWQg QXVkaW9Db250ZXh0OjpoYW5kbGVEZWZlcnJlZFJlZk5vZGVzKCkKK3sKKyAgICBBU1NFUlQoaXNB dWRpb1RocmVhZCgpICYmIGlzR3JhcGhPd25lcigpKTsKKworICAgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBtX2RlZmVycmVkUmVmTGlzdC5zaXplKCk7ICsraSkgeworICAgICAgICBBdWRpb05v ZGUqIG5vZGUgPSBtX2RlZmVycmVkUmVmTGlzdFtpXTsKKyAgICAgICAgLy8gQWRkIGEgcmVmZXJl bmNlIHRvIG5vZGUgdG8gdGVsbCB0aGUgY29udGV4dCB0aGF0IHRoaXMgbm9kZSBpcyBzdGlsbCBh bGl2ZS4KKyAgICAgICAgcmVmTm9kZShub2RlKTsKKyAgICB9CisgICAgbV9kZWZlcnJlZFJlZkxp c3QuY2xlYXIoKTsKIH0KIAogdm9pZCBBdWRpb0NvbnRleHQ6Om1hcmtGb3JEZWxldGlvbihBdWRp b05vZGUqIG5vZGUpCiB7CiAgICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKKwogICAgIG1fbm9k ZXNUb0RlbGV0ZS5hcHBlbmQobm9kZSk7CiAKICAgICAvLyBUaGlzIGlzIHByb2JhYmx5IHRoZSBi ZXN0IHRpbWUgZm9yIHVzIHRvIHJlbW92ZSB0aGUgbm9kZSBmcm9tIGF1dG9tYXRpYyBwdWxsIGxp c3QsCkBAIC03NDQsOCArNzY5LDE4IEBAIHZvaWQgQXVkaW9Db250ZXh0OjpzY2hlZHVsZU5vZGVE ZWxldGlvbigpCiAgICAgaWYgKCFpc0dvb2QpCiAgICAgICAgIHJldHVybjsKIAorICAgIGlmICht X25vZGVzVG9EZWxldGUuc2l6ZSgpID4gMCkgeworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIiVz OiAgcHJldmlvdXMgY291bnQgPSAlbHUsIG5ldyA9ICVsdVxuIiwKKyAgICAgICAgICAgICAgICBf X0ZVTkNUSU9OX18sIG1fbm9kZURlbGV0aW9uQ291bnQsIG1fbm9kZXNUb0RlbGV0ZS5zaXplKCkp OworICAgIH0KKworICAgIC8vIFVwZGF0ZSB0aGUgbnVtYmVyIG9mIG5vZGVzIHRvIGJlIGRlbGV0 ZWQuIFdlIGRvbid0IGRlbGV0ZSBldmVyeSBub2RlIGluIG1fbm9kZXNUb0RlbGV0ZQorICAgIC8v IGJlY2F1c2UgdGhhdCBjYW4gZ3JvdyBiZXR3ZWVuIHRoZSB0aW1lIHdlIHNjaGVkdWxlIHRoZSBk ZWxldGlvbiBhbmQgdGhlIGFjdHVhbCBkZWxldGlvbi4KKyAgICAvLyBUaG9zZSBuZXcgbm9kZXMg aGF2ZW4ndCBiZWVuIHByb3Blcmx5IHByb2Nlc3NlZCBieSB0aGUgcHJlIGFuZCBwb3N0IHJlbmRl ciB0YXNrLgorICAgIHVwZGF0ZURlbGV0aW9uQ291bnQoKTsKKwogICAgIC8vIE1ha2Ugc3VyZSB0 byBjYWxsIGRlbGV0ZU1hcmtlZE5vZGVzKCkgb24gbWFpbiB0aHJlYWQuICAgIAotICAgIGlmICht X25vZGVzVG9EZWxldGUuc2l6ZSgpICYmICFtX2lzRGVsZXRpb25TY2hlZHVsZWQpIHsKKyAgICBp ZiAobV9ub2RlRGVsZXRpb25Db3VudCAmJiAhbV9pc0RlbGV0aW9uU2NoZWR1bGVkKSB7CiAgICAg ICAgIG1faXNEZWxldGlvblNjaGVkdWxlZCA9IHRydWU7CiAKICAgICAgICAgLy8gRG9uJ3QgbGV0 IG91cnNlbGYgZ2V0IGRlbGV0ZWQgYmVmb3JlIHRoZSBjYWxsYmFjay4KQEAgLTc2MiwzOCArNzk3 LDcwIEBAIHZvaWQgQXVkaW9Db250ZXh0OjpkZWxldGVNYXJrZWROb2Rlc0Rpc3BhdGNoKHZvaWQq IHVzZXJEYXRhKQogICAgIGlmICghY29udGV4dCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgY29u dGV4dC0+ZGVsZXRlTWFya2VkTm9kZXMoKTsKKyAgICBjb250ZXh0LT5kZWxldGVTY2hlZHVsZWRO b2RlcygpOwogICAgIGNvbnRleHQtPmRlcmVmKCk7CiB9CiAKLXZvaWQgQXVkaW9Db250ZXh0Ojpk ZWxldGVNYXJrZWROb2RlcygpCit2b2lkIEF1ZGlvQ29udGV4dDo6ZGVsZXRlT25lTWFya2VkTm9k ZShBdWRpb05vZGUqIG5vZGUpCit7CisgICAgLy8gQmVmb3JlIGRlbGV0aW5nIHRoZSBub2RlLCBj bGVhciBvdXQgYW55IEF1ZGlvTm9kZUlucHV0cyBmcm9tIG1fZGlydHlTdW1taW5nSnVuY3Rpb25z LgorICAgIHVuc2lnbmVkIG51bWJlck9mSW5wdXRzID0gbm9kZS0+bnVtYmVyT2ZJbnB1dHMoKTsK KyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbnVtYmVyT2ZJbnB1dHM7ICsraSkKKyAgICAg ICAgbV9kaXJ0eVN1bW1pbmdKdW5jdGlvbnMucmVtb3ZlKG5vZGUtPmlucHV0KGkpKTsKKworICAg IC8vIEJlZm9yZSBkZWxldGluZyB0aGUgbm9kZSwgY2xlYXIgb3V0IGFueSBBdWRpb05vZGVPdXRw dXRzIGZyb20gbV9kaXJ0eUF1ZGlvTm9kZU91dHB1dHMuCisgICAgdW5zaWduZWQgbnVtYmVyT2ZP dXRwdXRzID0gbm9kZS0+bnVtYmVyT2ZPdXRwdXRzKCk7CisgICAgZm9yICh1bnNpZ25lZCBpID0g MDsgaSA8IG51bWJlck9mT3V0cHV0czsgKytpKQorICAgICAgICBtX2RpcnR5QXVkaW9Ob2RlT3V0 cHV0cy5yZW1vdmUobm9kZS0+b3V0cHV0KGkpKTsKKworICAgIC8vIEZpbmFsbHksIGRlbGV0ZSBp dC4KKyAgICBkZWxldGUgbm9kZTsKK30KKwordm9pZCBBdWRpb0NvbnRleHQ6OmRlbGV0ZVNjaGVk dWxlZE5vZGVzKCkKIHsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogCiAgICAgQXV0b0xv Y2tlciBsb2NrZXIodGhpcyk7Ci0gICAgCi0gICAgLy8gTm90ZTogZGVsZXRpbmcgYW4gQXVkaW9O b2RlIGNhbiBjYXVzZSBtX25vZGVzVG9EZWxldGUgdG8gZ3Jvdy4KLSAgICB3aGlsZSAoc2l6ZV90 IG4gPSBtX25vZGVzVG9EZWxldGUuc2l6ZSgpKSB7Ci0gICAgICAgIEF1ZGlvTm9kZSogbm9kZSA9 IG1fbm9kZXNUb0RlbGV0ZVtuIC0gMV07Ci0gICAgICAgIG1fbm9kZXNUb0RlbGV0ZS5yZW1vdmVM YXN0KCk7CiAKLSAgICAgICAgLy8gQmVmb3JlIGRlbGV0aW5nIHRoZSBub2RlLCBjbGVhciBvdXQg YW55IEF1ZGlvTm9kZUlucHV0cyBmcm9tIG1fZGlydHlTdW1taW5nSnVuY3Rpb25zLgotICAgICAg ICB1bnNpZ25lZCBudW1iZXJPZklucHV0cyA9IG5vZGUtPm51bWJlck9mSW5wdXRzKCk7Ci0gICAg ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZklucHV0czsgKytpKQotICAgICAg ICAgICAgbV9kaXJ0eVN1bW1pbmdKdW5jdGlvbnMucmVtb3ZlKG5vZGUtPmlucHV0KGkpKTsKKyAg ICBBU1NFUlQobV9ub2RlRGVsZXRpb25Db3VudCA8PSBtX25vZGVzVG9EZWxldGUuc2l6ZSgpKTsK KworICAgIGZvciAoc2l6ZV90IGsgPSAwOyBrIDwgbV9ub2RlRGVsZXRpb25Db3VudDsgKytrKSB7 CisgICAgICAgIEF1ZGlvTm9kZSogbm9kZSA9IG1fbm9kZXNUb0RlbGV0ZVtrXTsKKyAgICAgICAg ZGVsZXRlT25lTWFya2VkTm9kZShub2RlKTsKKyAgICB9CiAKLSAgICAgICAgLy8gQmVmb3JlIGRl bGV0aW5nIHRoZSBub2RlLCBjbGVhciBvdXQgYW55IEF1ZGlvTm9kZU91dHB1dHMgZnJvbSBtX2Rp cnR5QXVkaW9Ob2RlT3V0cHV0cy4KLSAgICAgICAgdW5zaWduZWQgbnVtYmVyT2ZPdXRwdXRzID0g bm9kZS0+bnVtYmVyT2ZPdXRwdXRzKCk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBudW1iZXJPZk91dHB1dHM7ICsraSkKLSAgICAgICAgICAgIG1fZGlydHlBdWRpb05vZGVPdXRw dXRzLnJlbW92ZShub2RlLT5vdXRwdXQoaSkpOworICAgIC8vIENvcHkgYW55IHJlbWFpbmluZyBu b2RlcyB0byB0aGUgZnJvbnQgYW5kIHJlc2l6ZS4KIAotICAgICAgICAvLyBGaW5hbGx5LCBkZWxl dGUgaXQuCi0gICAgICAgIGRlbGV0ZSBub2RlOworICAgIGludCBqID0gMDsKKyAgICBmb3IgKHNp emVfdCBrID0gbV9ub2RlRGVsZXRpb25Db3VudDsgayA8IG1fbm9kZXNUb0RlbGV0ZS5zaXplKCk7 ICsraykgeworICAgICAgICBtX25vZGVzVG9EZWxldGVbal0gPSBtX25vZGVzVG9EZWxldGVba107 CisgICAgICAgICsrajsKICAgICB9Ci0gICAgCisgICAgbV9ub2Rlc1RvRGVsZXRlLnJlc2l6ZSht X25vZGVzVG9EZWxldGUuc2l6ZSgpIC0gbV9ub2RlRGVsZXRpb25Db3VudCk7CisgICAgbV9ub2Rl RGVsZXRpb25Db3VudCA9IDA7CisKICAgICBtX2lzRGVsZXRpb25TY2hlZHVsZWQgPSBmYWxzZTsK IH0KIAordm9pZCBBdWRpb0NvbnRleHQ6OmRlbGV0ZUFsbE1hcmtlZE5vZGVzKCkKK3sKKyAgICBB U1NFUlQoaXNNYWluVGhyZWFkKCkpOworCisgICAgQXV0b0xvY2tlciBsb2NrZXIodGhpcyk7CisK KyAgICBzaXplX3QgayA9IDA7CisgICAgc2l6ZV90IHN0YXJ0ID0gbV9ub2Rlc1RvRGVsZXRlLnNp emUoKTsKKworICAgIC8vIE5vdGU6IGRlbGV0aW5nIGFuIEF1ZGlvTm9kZSBjYW4gY2F1c2UgbV9u b2Rlc1RvRGVsZXRlIHRvIGdyb3cuCisgICAgd2hpbGUgKHNpemVfdCBuID0gbV9ub2Rlc1RvRGVs ZXRlLnNpemUoKSkgeworICAgICAgICBBdWRpb05vZGUqIG5vZGUgPSBtX25vZGVzVG9EZWxldGVb biAtIDFdOworICAgICAgICBtX25vZGVzVG9EZWxldGUucmVtb3ZlTGFzdCgpOworICAgICAgICAr K2s7CisgICAgICAgIGRlbGV0ZU9uZU1hcmtlZE5vZGUobm9kZSk7CisgICAgfQorfQorCiB2b2lk IEF1ZGlvQ29udGV4dDo6bWFya1N1bW1pbmdKdW5jdGlvbkRpcnR5KEF1ZGlvU3VtbWluZ0p1bmN0 aW9uKiBzdW1taW5nSnVuY3Rpb24pCiB7CiAgICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsgICAg CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4 dC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuaAppbmRl eCA2NjgwNmE2MmJmMGFmYjU2ZmNjOWQ0MDk5OThjOTFkOThkMmQwYThmLi5hODU1Y2Q2MDgxOWYw ODc4MmE5Nzk1NTZkNTM1ODZiNTBlYmQwNWIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKQEAgLTE0OCw3ICsxNDgsOCBAQCBwdWJsaWM6CiAK ICAgICAvLyBXZSBzY2hlZHVsZSBkZWxldGlvbiBvZiBhbGwgbWFya2VkIG5vZGVzIGF0IHRoZSBl bmQgb2YgZWFjaCByZWFsdGltZSByZW5kZXIgcXVhbnR1bS4KICAgICB2b2lkIG1hcmtGb3JEZWxl dGlvbihBdWRpb05vZGUqKTsKLSAgICB2b2lkIGRlbGV0ZU1hcmtlZE5vZGVzKCk7CisgICAgdm9p ZCBkZWxldGVBbGxNYXJrZWROb2RlcygpOworICAgIHZvaWQgZGVsZXRlU2NoZWR1bGVkTm9kZXMo KTsKIAogICAgIC8vIEF1ZGlvQ29udGV4dCBjYW4gcHVsbCBub2RlKHMpIGF0IHRoZSBlbmQgb2Yg ZWFjaCByZW5kZXIgcXVhbnR1bSBldmVuIHdoZW4gdGhleSBhcmUgbm90IGNvbm5lY3RlZCB0byBh bnkgZG93bnN0cmVhbSBub2Rlcy4KICAgICAvLyBUaGVzZSB0d28gbWV0aG9kcyBhcmUgY2FsbGVk IGJ5IHRoZSBub2RlcyB3aG8gd2FudCB0byBhZGQvcmVtb3ZlIHRoZW1zZWx2ZXMgaW50by9mcm9t IHRoZSBhdXRvbWF0aWMgcHVsbCBsaXN0cy4KQEAgLTIxMywxMCArMjE0LDE4IEBAIHB1YmxpYzoK ICAgICB9OwogICAgIAogICAgIC8vIEluIEF1ZGlvTm9kZTo6ZGVyZWYoKSBhIHRyeUxvY2soKSBp cyB1c2VkIGZvciBjYWxsaW5nIGZpbmlzaERlcmVmKCksIGJ1dCBpZiBpdCBmYWlscyBrZWVwIHRy YWNrIGhlcmUuCi0gICAgdm9pZCBhZGREZWZlcnJlZEZpbmlzaERlcmVmKEF1ZGlvTm9kZSopOwor ICAgIHZvaWQgYWRkRGVmZXJyZWREZXJlZk5vZGUoQXVkaW9Ob2RlKik7CiAKLSAgICAvLyBJbiB0 aGUgYXVkaW8gdGhyZWFkIGF0IHRoZSBzdGFydCBvZiBlYWNoIHJlbmRlciBjeWNsZSwgd2UnbGwg Y2FsbCBoYW5kbGVEZWZlcnJlZEZpbmlzaERlcmVmcygpLgotICAgIHZvaWQgaGFuZGxlRGVmZXJy ZWRGaW5pc2hEZXJlZnMoKTsKKyAgICAvLyBBZGQgYXVkaW8gbm9kZSB0byBsaXN0IG9mIG5vZGVz IHRoYXQgd2Ugd2FudCB0byBjYWxsIHJlZk5vZGUoKSBvbi4gVGhlcmUgbXVzdCBldmVudHVhbGx5 IGJlIGEKKyAgICAvLyBjYWxsIHRvIGFkZERlZmVycmVkRGVyZWZOb2RlKCkgZm9yIHRoZSBzYW1l IG5vZGUuCisgICAgdm9pZCBhZGREZWZlcnJlZFJlZk5vZGUoQXVkaW9Ob2RlKik7CisKKyAgICAv LyBJbiB0aGUgYXVkaW8gdGhyZWFkIGF0IHRoZSBzdGFydCBvZiBlYWNoIHJlbmRlciBjeWNsZSwg d2UnbGwgY2FsbCBoYW5kbGVEZWZlcnJlZERlcmVmTm9kZXMoKS4KKyAgICB2b2lkIGhhbmRsZURl ZmVycmVkRGVyZWZOb2RlcygpOworCisgICAgLy8gRHVyaW5nIHBvc3QgcmVuZGVyIHByb2Nlc3Np bmcsIGFsbCB0aGUgbm9kZXMgYWRkZWQgYnkgYWRkRGVmZXJyZWRSZWZOb2RlcygpIHdpbGwgYmUg YWRkZWQgdG8KKyAgICAvLyBtX3JlZmVyZW5jZWROb2RlcyBsaXN0IHRvIHRlbGwgdGhlIGNvbnRl eHQgdGhhdCB0aGVzZSBub2RlcyBhcmUgc3RpbGwgYWxpdmUuCisgICAgdm9pZCBoYW5kbGVEZWZl cnJlZFJlZk5vZGVzKCk7CiAKICAgICAvLyBPbmx5IGFjY2Vzc2VkIHdoZW4gdGhlIGdyYXBoIGxv Y2sgaXMgaGVsZC4KICAgICB2b2lkIG1hcmtTdW1taW5nSnVuY3Rpb25EaXJ0eShBdWRpb1N1bW1p bmdKdW5jdGlvbiopOwpAQCAtMjM5LDkgKzI0OCwxNCBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN0 YXJ0UmVuZGVyaW5nKCk7CiAgICAgdm9pZCBmaXJlQ29tcGxldGlvbkV2ZW50KCk7Ci0gICAgCisK KyAgICB2b2lkIHVwZGF0ZURlbGV0aW9uQ291bnQoKSB7IG1fbm9kZURlbGV0aW9uQ291bnQgPSBt X25vZGVzVG9EZWxldGUuc2l6ZSgpOyB9CisKICAgICBzdGF0aWMgdW5zaWduZWQgc19oYXJkd2Fy ZUNvbnRleHRDb3VudDsKLSAgICAKKworICAgIHNpemVfdCBub2RlRGVsZXRpb25Db3VudCgpIHsg cmV0dXJuIG1fbm9kZURlbGV0aW9uQ291bnQ7IH0KKyAgICBzaXplX3Qgbm9kZXNUb0RlbGV0ZVNp emUoKSB7IHJldHVybiBtX25vZGVzVG9EZWxldGUuc2l6ZSgpOyB9CisgICAgc2l6ZV90IGRlZmVy cmVkRGVyZWZOb2RlU2l6ZSgpIHsgcmV0dXJuIG1fZGVmZXJyZWREZXJlZk5vZGVMaXN0LnNpemUo KTsgfQogcHJpdmF0ZToKICAgICBBdWRpb0NvbnRleHQoRG9jdW1lbnQqKTsKICAgICBBdWRpb0Nv bnRleHQoRG9jdW1lbnQqLCB1bnNpZ25lZCBudW1iZXJPZkNoYW5uZWxzLCBzaXplX3QgbnVtYmVy T2ZGcmFtZXMsIGZsb2F0IHNhbXBsZVJhdGUpOwpAQCAtMjUzLDcgKzI2Nyw4IEBAIHByaXZhdGU6 CiAKICAgICB2b2lkIHNjaGVkdWxlTm9kZURlbGV0aW9uKCk7CiAgICAgc3RhdGljIHZvaWQgZGVs ZXRlTWFya2VkTm9kZXNEaXNwYXRjaCh2b2lkKiB1c2VyRGF0YSk7Ci0gICAgCisgICAgdm9pZCBk ZWxldGVPbmVNYXJrZWROb2RlKEF1ZGlvTm9kZSopOworCiAgICAgYm9vbCBtX2lzSW5pdGlhbGl6 ZWQ7CiAgICAgYm9vbCBtX2lzQXVkaW9UaHJlYWRGaW5pc2hlZDsKIApAQCAtMjg2LDYgKzMwMSw5 IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPEF1ZGlvTm9kZSo+IG1fbm9kZXNUb0RlbGV0ZTsKICAg ICBib29sIG1faXNEZWxldGlvblNjaGVkdWxlZDsKIAorICAgIC8vIEFjdHVhbCBudW1iZXIgb2Yg bm9kZXMgdG8gZGVsZXRlZC4KKyAgICBzaXplX3QgbV9ub2RlRGVsZXRpb25Db3VudDsKKwogICAg IC8vIE9ubHkgYWNjZXNzZWQgd2hlbiB0aGUgZ3JhcGggbG9jayBpcyBoZWxkLgogICAgIEhhc2hT ZXQ8QXVkaW9TdW1taW5nSnVuY3Rpb24qPiBtX2RpcnR5U3VtbWluZ0p1bmN0aW9uczsKICAgICBI YXNoU2V0PEF1ZGlvTm9kZU91dHB1dCo+IG1fZGlydHlBdWRpb05vZGVPdXRwdXRzOwpAQCAtMzA4 LDggKzMyNiwxMSBAQCBwcml2YXRlOgogICAgIHZvbGF0aWxlIFRocmVhZElkZW50aWZpZXIgbV9n cmFwaE93bmVyVGhyZWFkOyAvLyBpZiB0aGUgbG9jayBpcyBoZWxkIHRoZW4gdGhpcyBpcyB0aGUg dGhyZWFkIHdoaWNoIG93bnMgaXQsIG90aGVyd2lzZSA9PSBVbmRlZmluZWRUaHJlYWRJZGVudGlm aWVyCiAgICAgCiAgICAgLy8gT25seSBhY2Nlc3NlZCBpbiB0aGUgYXVkaW8gdGhyZWFkLgotICAg IFZlY3RvcjxBdWRpb05vZGUqPiBtX2RlZmVycmVkRmluaXNoRGVyZWZMaXN0OwotICAgIAorICAg IFZlY3RvcjxBdWRpb05vZGUqPiBtX2RlZmVycmVkRGVyZWZOb2RlTGlzdDsKKworICAgIC8vIExp c3Qgb2Ygbm9kZXMgdGhhdCB3ZSB3YW50IHRvIGNhbGwgcmVmTm9kZSgpIG9uIHRvIHRlbGwgdGhl IGNvbnRleHQgdGhhdCB0aGUgbm9kZSBpcyBzdGlsbCBhY3RpdmUuCisgICAgVmVjdG9yPEF1ZGlv Tm9kZSo+IG1fZGVmZXJyZWRSZWZMaXN0OworCiAgICAgLy8gSFJURiBEYXRhYmFzZSBsb2FkZXIK ICAgICBSZWZQdHI8SFJURkRhdGFiYXNlTG9hZGVyPiBtX2hydGZEYXRhYmFzZUxvYWRlcjsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3Bw IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCmluZGV4IDBl MzI5YzJiOTE5YmMzZjEyZTYwNjRkZDZjNGM4ZDkwYjAzNTg3YzkuLmMyNDUyM2I4NmI3YTVmYmI1 ZjU4MDkzNmQ4ZGRhZTMyZGU3Nzc4YjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvTm9kZS5jcHAKQEAgLTQ5LDYgKzQ5LDcgQEAgQXVkaW9Ob2RlOjpBdWRpb05v ZGUoQXVkaW9Db250ZXh0KiBjb250ZXh0LCBmbG9hdCBzYW1wbGVSYXRlKQogICAgICwgbV9jb25u ZWN0aW9uUmVmQ291bnQoMCkKICAgICAsIG1faXNNYXJrZWRGb3JEZWxldGlvbihmYWxzZSkKICAg ICAsIG1faXNEaXNhYmxlZChmYWxzZSkKKyAgICAsIG1fYWxsb3dUYWlsUHJvY2Vzc2luZyhmYWxz ZSkKIHsKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwogICAgIGlmICghc19pc05vZGVD b3VudEluaXRpYWxpemVkKSB7CkBAIC0yMDksOSArMjEwLDEyIEBAIHZvaWQgQXVkaW9Ob2RlOjpw cm9jZXNzSWZOZWNlc3Nhcnkoc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKICAgICAgICAgaWYgKCFz aWxlbnRJbnB1dHMpCiAgICAgICAgICAgICBtX2xhc3ROb25TaWxlbnRUaW1lID0gKGNvbnRleHQo KS0+Y3VycmVudFNhbXBsZUZyYW1lKCkgKyBmcmFtZXNUb1Byb2Nlc3MpIC8gc3RhdGljX2Nhc3Q8 ZG91YmxlPihtX3NhbXBsZVJhdGUpOwogCi0gICAgICAgIGlmIChzaWxlbnRJbnB1dHMgJiYgcHJv cGFnYXRlc1NpbGVuY2UoKSkKKyAgICAgICAgaWYgKHNpbGVudElucHV0cyAmJiBwcm9wYWdhdGVz U2lsZW5jZSgpKSB7CisgICAgICAgICAgICAvLyBUYWlsIHByb2Nlc3NpbmcgY2FuIGVuZCBub3cg YmVjYXVzZSB3ZSBhcmUgcHJvcGFnYXRpbmcgc2lsZW5jZS4KKyAgICAgICAgICAgIGVuZFRhaWxQ cm9jZXNzaW5nSWZOZWVkZWQoKTsKICAgICAgICAgICAgIHNpbGVuY2VPdXRwdXRzKCk7Ci0gICAg ICAgIGVsc2UgeworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgYWxsb3dUYWlsUHJvY2Vz c2luZ0lmTmVlZGVkKCk7CiAgICAgICAgICAgICBwcm9jZXNzKGZyYW1lc1RvUHJvY2Vzcyk7CiAg ICAgICAgICAgICB1bnNpbGVuY2VPdXRwdXRzKCk7CiAgICAgICAgIH0KQEAgLTI5MCwxNSArMjk0 LDkgQEAgdm9pZCBBdWRpb05vZGU6OmRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkoKQogICAgICAg ICAvLyBCdXQgaW50ZXJuYWxseSBvdXIgb3V0cHV0cyBzaG91bGQgYmUgZGlzYWJsZWQgZnJvbSB0 aGUgaW5wdXRzIHRoZXkncmUgY29ubmVjdGVkIHRvLgogICAgICAgICAvLyBkaXNhYmxlKCkgY2Fu IHJlY3Vyc2l2ZWx5IGRlcmVmIGNvbm5lY3Rpb25zIChhbmQgY2FsbCBkaXNhYmxlKCkpIGRvd24g YSB3aG9sZSBjaGFpbiBvZiBjb25uZWN0ZWQgbm9kZXMuCiAKLSAgICAgICAgLy8gRklYTUU6IHdl IHNwZWNpYWwgY2FzZSB0aGUgY29udm9sdmVyIGFuZCBkZWxheSBzaW5jZSB0aGV5IGhhdmUgYSBz aWduaWZpY2FudCB0YWlsLXRpbWUgYW5kIHNob3VsZG4ndCBiZSBkaXNjb25uZWN0ZWQgc2ltcGx5 Ci0gICAgICAgIC8vIGJlY2F1c2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkgaW5wdXQgY29ubmVj dGlvbnMuIFRoaXMgbmVlZHMgdG8gYmUgaGFuZGxlZCBtb3JlIGdlbmVyYWxseSB3aGVyZSBBdWRp b05vZGVzIGhhdmUKLSAgICAgICAgLy8gYSB0YWlsVGltZSBhdHRyaWJ1dGUuIFRoZW4gdGhlIEF1 ZGlvTm9kZSBvbmx5IG5lZWRzIHRvIHJlbWFpbiAiYWN0aXZlIiBmb3IgdGFpbFRpbWUgc2Vjb25k cyBhZnRlciB0aGVyZSBhcmUgbm8KLSAgICAgICAgLy8gbG9uZ2VyIGFueSBhY3RpdmUgY29ubmVj dGlvbnMuCi0gICAgICAgIGlmIChub2RlVHlwZSgpICE9IE5vZGVUeXBlQ29udm9sdmVyICYmIG5v ZGVUeXBlKCkgIT0gTm9kZVR5cGVEZWxheSkgewotICAgICAgICAgICAgbV9pc0Rpc2FibGVkID0g dHJ1ZTsKLSAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBtX291dHB1dHMuc2l6 ZSgpOyArK2kpCi0gICAgICAgICAgICAgICAgb3V0cHV0KGkpLT5kaXNhYmxlKCk7Ci0gICAgICAg IH0KKyAgICAgICAgbV9pc0Rpc2FibGVkID0gdHJ1ZTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBp ID0gMDsgaSA8IG1fb3V0cHV0cy5zaXplKCk7ICsraSkKKyAgICAgICAgICAgIG91dHB1dChpKS0+ ZGlzYWJsZSgpOwogICAgIH0KIH0KIApAQCAtMzUxLDE0ICszNDksMTQgQEAgdm9pZCBBdWRpb05v ZGU6OmRlcmVmKFJlZlR5cGUgcmVmVHlwZSkKICAgICAgICAgLy8gV2Ugd2VyZSB1bmFibGUgdG8g Z2V0IHRoZSBsb2NrLCBzbyBwdXQgdGhpcyBpbiBhIGxpc3QgdG8gZmluaXNoIHVwIGxhdGVyLgog ICAgICAgICBBU1NFUlQoY29udGV4dCgpLT5pc0F1ZGlvVGhyZWFkKCkpOwogICAgICAgICBBU1NF UlQocmVmVHlwZSA9PSBSZWZUeXBlQ29ubmVjdGlvbik7Ci0gICAgICAgIGNvbnRleHQoKS0+YWRk RGVmZXJyZWRGaW5pc2hEZXJlZih0aGlzKTsKKyAgICAgICAgY29udGV4dCgpLT5hZGREZWZlcnJl ZERlcmVmTm9kZSh0aGlzKTsKICAgICB9CiAKICAgICAvLyBPbmNlIEF1ZGlvQ29udGV4dDo6dW5p bml0aWFsaXplKCkgaXMgY2FsbGVkIHRoZXJlJ3Mgbm8gbW9yZSBjaGFuY2VzIGZvciBkZWxldGVN YXJrZWROb2RlcygpIHRvIGdldCBjYWxsZWQsIHNvIHdlIGNhbGwgaGVyZS4KICAgICAvLyBXZSBj YW4ndCBjYWxsIGluIEF1ZGlvQ29udGV4dDo6fkF1ZGlvQ29udGV4dCgpIHNpbmNlIGl0IHdpbGwg bmV2ZXIgYmUgY2FsbGVkIGFzIGxvbmcgYXMgYW55IEF1ZGlvTm9kZSBpcyBhbGl2ZQogICAgIC8v IGJlY2F1c2UgQXVkaW9Ob2RlcyBrZWVwIGEgcmVmZXJlbmNlIHRvIHRoZSBjb250ZXh0LgogICAg IGlmIChjb250ZXh0KCktPmlzQXVkaW9UaHJlYWRGaW5pc2hlZCgpKQotICAgICAgICBjb250ZXh0 KCktPmRlbGV0ZU1hcmtlZE5vZGVzKCk7CisgICAgICAgIGNvbnRleHQoKS0+ZGVsZXRlQWxsTWFy a2VkTm9kZXMoKTsKIH0KIAogdm9pZCBBdWRpb05vZGU6OmZpbmlzaERlcmVmKFJlZlR5cGUgcmVm VHlwZSkKQEAgLTM5OCw2ICszOTYsMzAgQEAgdm9pZCBBdWRpb05vZGU6OmZpbmlzaERlcmVmKFJl ZlR5cGUgcmVmVHlwZSkKICAgICB9CiB9CiAKK3ZvaWQgQXVkaW9Ob2RlOjphbGxvd1RhaWxQcm9j ZXNzaW5nSWZOZWVkZWQoKQoreworICAgIGlmICghbV9hbGxvd1RhaWxQcm9jZXNzaW5nICYmIChs YXRlbmN5VGltZSgpICsgdGFpbFRpbWUoKSA+IDApKSB7CisgICAgICAgIC8vIEVzdGFibGlzaCBh IHJlZiB0byBvdXJzZWxmIGlmIHdlIGhhdmVuJ3QgYWxyZWFkeSBzbyB3ZSBkb24ndCBnZXQgcmVt b3ZlZCB3aGVuIGFsbCBub2RlcworICAgICAgICAvLyBoYXZlIGRpc2Nvbm5lY3RlZCBmcm9tIHVz LiBXZSBob2xkIHRoaXMgcmVmIGR1cmluZyB0aGUgdGltZSB3aGVuIHdlIGFyZSByZWNlaXZpbmcK KyAgICAgICAgLy8gbm9uLXNpbGVudCBpbnB1dCwgb3IgZHVyaW5nIHRoZSB0aW1lIGFmdGVyIGZp cnN0IHJlY2VpdmluZyBzaWxlbnQgaW5wdXQgd2hlbiB3ZSBlbXB0eSB0aGUKKyAgICAgICAgLy8g cHJvY2Vzc2luZyBwaXBlbGluZSB0byBhY2NvdW50IGZvciBsYXRlbmN5IGFuZCB0YWlsLgorICAg ICAgICBtX2FsbG93VGFpbFByb2Nlc3NpbmcgPSB0cnVlOworICAgICAgICBjb250ZXh0KCktPmFk ZERlZmVycmVkUmVmTm9kZSh0aGlzKTsKKyAgICB9Cit9CisKK3ZvaWQgQXVkaW9Ob2RlOjplbmRU YWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkKK3sKKyAgICBBU1NFUlQocHJvcGFnYXRlc1NpbGVuY2Uo KSk7CisgICAgCisgICAgaWYgKG1fYWxsb3dUYWlsUHJvY2Vzc2luZykgeworICAgICAgICAvLyBT dG9wIHRhaWwgcHJvY2Vzc2luZy4gSnVzdCBuZWVkIHRvIGRlcmVmIG91cnNlbGYsIGJ1dCB3ZSBj YW4ndCBkbyB0aGF0IHdoaWxlIHRoZSBncmFwaAorICAgICAgICAvLyBpcyBiZWluZyByZW5kZXJl ZC4gU2NoZWR1bGUgdGhlIGRlcmVmIHRvIGhhcHBlbiBkdXJpbmcgdGhlIHBvc3QtcmVuZGVyaW5n IHBoYXNlLgorICAgICAgICBtX2FsbG93VGFpbFByb2Nlc3NpbmcgPSBmYWxzZTsKKyAgICAgICAg Y29udGV4dCgpLT5hZGREZWZlcnJlZERlcmVmTm9kZSh0aGlzKTsKKyAgICB9Cit9CisKICNpZiBE RUJVR19BVURJT05PREVfUkVGRVJFTkNFUwogCiBib29sIEF1ZGlvTm9kZTo6c19pc05vZGVDb3Vu dEluaXRpYWxpemVkID0gZmFsc2U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb05vZGUuaAppbmRleCBiZWU3OGY3ZTgzNjBmYTVmYmNlNjdjZDI5ZTQ1YjM1OTlkOTYzZTY2 Li42NjRiMDFhYmJhMzE2N2Y5YTMzYjgyNTZlM2Y1ZTEwZDFkYjkyZDYzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKQEAgLTE1NSw2ICsxNTUsMTkgQEAg cHVibGljOgogCiAgICAgdm9pZCBlbmFibGVPdXRwdXRzSWZOZWNlc3NhcnkoKTsKICAgICB2b2lk IGRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkoKTsKKworICAgIC8vIEFsbG93IHRhaWwgcHJvY2Vz c2luZyBmb3Igbm9kZXMgdGhhdCBoYXZlIHRhaWwgb3IgbGF0ZW5jeSB0aW1lLiBUaGlzIHdpbGwg Y3JlYXRlIGFuCisgICAgLy8gYWRkaXRpb25hbCBjb25uZWN0aW9uIHJlZiB0byBvdXJzZWxmIHNv IHdlIGRvbid0IGdldCByZW1vdmVkIGZyb20gdGhlIGdyYXBoIGJlZm9yZSB0aGUgdGFpbAorICAg IC8vIGhhcyBiZWVuIHByb2Nlc3NlZC4KKyAgICB2b2lkIGFsbG93VGFpbFByb2Nlc3NpbmdJZk5l ZWRlZCgpOworCisgICAgLy8gSWYgd2UncmUgcHJvY2Vzc2luZyB0aGUgdGFpbCBmb3IgdGhpcyBu b2RlIGFuZCBhbGwgb3V0cHV0cyBzaG91bGQgYmUgcHJvcGFnYXRpbmcgc2lsZW5jZSwgd2UKKyAg ICAvLyBlbmQgdGFpbCBwcm9jZXNzaW5nLiBUaGUgY29ubmVjdGlvbiByZWYgdG8gb3Vyc2VsZiB3 aWxsIGJlIHJlbW92ZWQsIGJhbGFuY2luZyB0aGUgcmVmZXJlbmNlCisgICAgLy8gYWRkZWQgaW4g YWxsb3dUYWlsUHJvY2Vzc2luZ0lmTmVlZGVkKCkuCisgICAgdm9pZCBlbmRUYWlsUHJvY2Vzc2lu Z0lmTmVlZGVkKCk7CisKKyAgICBib29sIGlzRGlzYWJsZWQoKSB7IHJldHVybiBtX2lzRGlzYWJs ZWQ7IH0KKwogcHJvdGVjdGVkOgogICAgIC8vIElucHV0cyBhbmQgb3V0cHV0cyBtdXN0IGJlIGNy ZWF0ZWQgYmVmb3JlIHRoZSBBdWRpb05vZGUgaXMgaW5pdGlhbGl6ZWQuCiAgICAgdm9pZCBhZGRJ bnB1dChQYXNzT3duUHRyPEF1ZGlvTm9kZUlucHV0Pik7CkBAIC0xODMsNiArMTk2LDggQEAgcHJp dmF0ZToKICAgICBib29sIG1faXNNYXJrZWRGb3JEZWxldGlvbjsKICAgICBib29sIG1faXNEaXNh YmxlZDsKICAgICAKKyAgICBib29sIG1fYWxsb3dUYWlsUHJvY2Vzc2luZzsKKwogI2lmIERFQlVH X0FVRElPTk9ERV9SRUZFUkVOQ0VTCiAgICAgc3RhdGljIGJvb2wgc19pc05vZGVDb3VudEluaXRp YWxpemVkOwogICAgIHN0YXRpYyBpbnQgc19ub2RlQ291bnRbTm9kZVR5cGVFbmRdOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGVJbnB1dC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcAppbmRl eCBmM2Y0OGJlODQxOWM0ODM4NTRlMGVlODA1NjQ5MTMzYWUxYTI2MGMzLi42ZjdkNzAxODIzOTZj ODUyODE1NmZlMGM1NzVkNTZkZWYwY2M2MTU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZUlucHV0LmNwcApAQCAtODUsNiArODUsNyBAQCB2b2lk IEF1ZGlvTm9kZUlucHV0OjpkaXNjb25uZWN0KEF1ZGlvTm9kZU91dHB1dCogb3V0cHV0KQogICAg IC8vIE90aGVyd2lzZSwgdHJ5IHRvIGRpc2Nvbm5lY3QgZnJvbSBkaXNhYmxlZCBjb25uZWN0aW9u cy4KICAgICBpZiAobV9kaXNhYmxlZE91dHB1dHMuY29udGFpbnMob3V0cHV0KSkgewogICAgICAg ICBtX2Rpc2FibGVkT3V0cHV0cy5yZW1vdmUob3V0cHV0KTsKKyAgICAgICAgY2hhbmdlZE91dHB1 dHMoKTsKICAgICAgICAgb3V0cHV0LT5yZW1vdmVJbnB1dCh0aGlzKTsKICAgICAgICAgbm9kZSgp LT5kZXJlZihBdWRpb05vZGU6OlJlZlR5cGVDb25uZWN0aW9uKTsgLy8gTm90ZTogaXQncyBpbXBv cnRhbnQgdG8gcmV0dXJuIGltbWVkaWF0ZWx5IGFmdGVyIGFsbCBkZXJlZigpIGNhbGxzIHNpbmNl IHRoZSBub2RlIG1heSBiZSBkZWxldGVkLgogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUGFubmVyTm9kZS5jcHAKaW5kZXggNGQw YWQxODljNjA4MjJhMTkwNDI3Mjc5N2QyNTUyYzVmZGRlZmU1My4uOTNkOWZhNjhiYWIxZTA0ODZl ZWQyODhmYzNkY2I2MzExY2E0OTU0YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9BdWRpb1Bhbm5lck5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vQXVkaW9QYW5uZXJOb2RlLmNwcApAQCAtOTEsNyArOTEsNyBAQCB2b2lkIEF1 ZGlvUGFubmVyTm9kZTo6cHJvY2VzcyhzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQogewogICAgIEF1 ZGlvQnVzKiBkZXN0aW5hdGlvbiA9IG91dHB1dCgwKS0+YnVzKCk7CiAKLSAgICBpZiAoIWlzSW5p dGlhbGl6ZWQoKSB8fCAhaW5wdXQoMCktPmlzQ29ubmVjdGVkKCkgfHwgIW1fcGFubmVyLmdldCgp KSB7CisgICAgaWYgKCFpc0luaXRpYWxpemVkKCkgfHwgIW1fcGFubmVyLmdldCgpKSB7CiAgICAg ICAgIGRlc3RpbmF0aW9uLT56ZXJvKCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg YzM2ZWRkZjZmMDU1OWNhYzgyOGM0OTQ3NDFmOWZlYTQyMzVhYzM2Ni4uMGY3ZjhjNGQ3M2Q0NzE5 OGZhOWZlYzUzODhkMWM0NGZjYTczNTU1ZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEyLTA2 LTI1ICBSYXltb25kIFRveSAgPHJ0b3lAZ29vZ2xlLmNvbT4KKworICAgICAgICBub3RlR3JhaW5P biBpcyB0b28gbG9uZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NzcyMjQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIHdlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanM6CisgICAg ICAgIChjcmVhdGVTaWduYWxCdWZmZXIpOgorICAgICAgICAodmVyaWZ5U3RhcnRBbmRFbmRGcmFt ZXMpOgorCiAyMDEyLTA2LTI0ICBPbGkgTGFuICA8b2xpbGFuQGNocm9taXVtLm9yZz4KIAogICAg ICAgICBBZnRlciBFZGl0b3I6OnNldENvbXBvc2l0aW9uIGlzIGNhbGxlZCwgaW5wdXQgc2hvdWxk IHNjcm9sbCB0byB0aGUgZW5kIG9mIHRoZSBjb21wb3NpdGlvbi4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL3dlYmF1ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMgYi9MYXlv dXRUZXN0cy93ZWJhdWRpby9yZXNvdXJjZXMvbm90ZS1ncmFpbi1vbi10ZXN0aW5nLmpzCmluZGV4 IDQ1ZGQ3MmZjYWFkYjI4NDdkOWQyZTRiNThjYzFiNGMwNmJhNWNlOTkuLmQyYWMzNWQzMjUwOGM4 MzdkM2NiODczNzAwZjM4MTVjMWM5YjU3MWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3dlYmF1 ZGlvL3Jlc291cmNlcy9ub3RlLWdyYWluLW9uLXRlc3RpbmcuanMKKysrIGIvTGF5b3V0VGVzdHMv d2ViYXVkaW8vcmVzb3VyY2VzL25vdGUtZ3JhaW4tb24tdGVzdGluZy5qcwpAQCAtMSwxMSArMSw1 IEBACiB2YXIgc2FtcGxlUmF0ZSA9IDQ0MTAwLjA7CiAKLS8vIEhSVEYgZXh0cmEgZnJhbWVzLiAg VGhpcyBpcyBhIG1hZ2ljIGNvbnN0YW50IGN1cnJlbnRseSBpbgotLy8gQXVkaW9CdWZmZXJTb3Vy Y2VOb2RlOjpwcm9jZXNzIHRoYXQgYWx3YXlzIGV4dGVuZHMgdGhlCi0vLyBkdXJhdGlvbiBieSB0 aGlzIG51bWJlciBvZiBzYW1wbGVzLiAgU2VlIGJ1ZyA3NzIyNAotLy8gKGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzIyNCkuCi12YXIgZXh0cmFGcmFtZXNIUlRGID0g NTEyOwotCiAvLyBIb3cgbWFueSBncmFpbnMgdG8gcGxheS4KIHZhciBudW1iZXJPZlRlc3RzID0g MTAwOwogCkBAIC0xMyw5ICs3LDggQEAgdmFyIG51bWJlck9mVGVzdHMgPSAxMDA7CiB2YXIgZHVy YXRpb24gPSAwLjAxOwogCiAvLyBUaW1lIHN0ZXAgYmV0d2VlbiB0aGUgc3RhcnQgb2YgZWFjaCBn cmFpbi4gIFdlIG5lZWQgdG8gYWRkIGEgbGl0dGxlCi0vLyBiaXQgb2Ygc2lsZW5jZSBzbyB3ZSBj YW4gZGV0ZWN0IGdyYWluIGJvdW5kYXJpZXMgYW5kIGFsc28gYWNjb3VudAotLy8gZm9yIHRoZSBl eHRyYSBmcmFtZXMgZm9yIEhSVEYuCi12YXIgdGltZVN0ZXAgPSBkdXJhdGlvbiArIC4wMDUgKyBl eHRyYUZyYW1lc0hSVEYgLyBzYW1wbGVSYXRlOworLy8gYml0IG9mIHNpbGVuY2Ugc28gd2UgY2Fu IGRldGVjdCBncmFpbiBib3VuZGFyaWVzLgordmFyIHRpbWVTdGVwID0gZHVyYXRpb24gKyAuMDA1 OwogCiAvLyBUaW1lIHN0ZXAgYmV0d2VlbiB0aGUgc3RhcnQgZm9yIGVhY2ggZ3JhaW4uCiB2YXIg Z3JhaW5PZmZzZXRTdGVwID0gMC4wMDE7CkBAIC0zMCwxMCArMjMsOSBAQCB2YXIgcmVuZGVyZWRE YXRhOwogLy8gcmV0dXJucyB0aGUgZGVzaXJlZCB2YWx1ZSBhdCBzYW1wbGUgZnJhbWUgay4KIGZ1 bmN0aW9uIGNyZWF0ZVNpZ25hbEJ1ZmZlcihjb250ZXh0LCBmKSB7CiAKLSAgICAvLyBNYWtlIHN1 cmUgdGhlIGJ1ZmZlciBoYXMgZW5vdWdoIGRhdGEgZm9yIGFsbCBvZiB0aGUgcG9zc2libGUKLSAg ICAvLyBncmFpbiBvZmZzZXRzIGFuZCBkdXJhdGlvbnMuICBOZWVkIHRvIGluY2x1ZGUgdGhlIGV4 dHJhIGZyYW1lcwotICAgIC8vIGZvciBIUlRGLiAgVGhlIGFkZGl0aW9uYWwgMSBpcyBmb3IgYW55 IHJvdW5kLW9mZiBlcnJvcnMuCi0gICAgdmFyIHNpZ25hbExlbmd0aCA9IE1hdGguZmxvb3IoMSAr IGV4dHJhRnJhbWVzSFJURiArIHNhbXBsZVJhdGUgKiAobnVtYmVyT2ZUZXN0cyAqIGdyYWluT2Zm c2V0U3RlcCArIGR1cmF0aW9uKSk7CisgICAgLy8gTWFrZSBzdXJlIHRoZSBidWZmZXIgaGFzIGVu b3VnaCBkYXRhIGZvciBhbGwgb2YgdGhlIHBvc3NpYmxlIGdyYWluIG9mZnNldHMgYW5kIGR1cmF0 aW9ucy4gVGhlCisgICAgLy8gYWRkaXRpb25hbCAxIGlzIGZvciBhbnkgcm91bmQtb2ZmIGVycm9y cy4KKyAgICB2YXIgc2lnbmFsTGVuZ3RoID0gTWF0aC5mbG9vcigxICsgc2FtcGxlUmF0ZSAqIChu dW1iZXJPZlRlc3RzICogZ3JhaW5PZmZzZXRTdGVwICsgZHVyYXRpb24pKTsKIAogICAgIHZhciBi dWZmZXIgPSBjb250ZXh0LmNyZWF0ZUJ1ZmZlcigyLCBzaWduYWxMZW5ndGgsIHNhbXBsZVJhdGUp OwogICAgIHZhciBkYXRhID0gYnVmZmVyLmdldENoYW5uZWxEYXRhKDApOwpAQCAtMTMzLDkgKzEy NSw4IEBAIGZ1bmN0aW9uIHZlcmlmeVN0YXJ0QW5kRW5kRnJhbWVzKHN0YXJ0RW5kRnJhbWVzKSB7 CiAgICAgLy8gZXhwZWN0YXRpb25zLgogICAgIGZvciAodmFyIGsgPSAwOyBrIDwgc3RhcnRGcmFt ZXMubGVuZ3RoOyArK2spIHsKICAgICAgICAgdmFyIGV4cGVjdGVkU3RhcnQgPSB0aW1lVG9TYW1w bGVGcmFtZShrICogdGltZVN0ZXAsIHNhbXBsZVJhdGUpOwotICAgICAgICAvLyBUaGUgZW5kIHBv aW50IGlzIHRoZSBkdXJhdGlvbiwgcGx1cyB0aGUgZXh0cmEgZnJhbWVzCi0gICAgICAgIC8vIGZv ciBIUlRGLgotICAgICAgICB2YXIgZXhwZWN0ZWRFbmQgPSBleHRyYUZyYW1lc0hSVEYgKyBleHBl Y3RlZFN0YXJ0ICsgZ3JhaW5MZW5ndGhJblNhbXBsZUZyYW1lcyhrICogZ3JhaW5PZmZzZXRTdGVw LCBkdXJhdGlvbiwgc2FtcGxlUmF0ZSk7CisgICAgICAgIC8vIFRoZSBlbmQgcG9pbnQgaXMgdGhl IGR1cmF0aW9uCisgICAgICAgIHZhciBleHBlY3RlZEVuZCA9IGV4cGVjdGVkU3RhcnQgKyBncmFp bkxlbmd0aEluU2FtcGxlRnJhbWVzKGsgKiBncmFpbk9mZnNldFN0ZXAsIGR1cmF0aW9uLCBzYW1w bGVSYXRlKTsKIAogICAgICAgICBpZiAoc3RhcnRGcmFtZXNba10gIT0gZXhwZWN0ZWRTdGFydCkg ewogICAgICAgICAgICAgdGVzdEZhaWxlZCgiUHVsc2UgIiArIGsgKyAiIHN0YXJ0ZWQgYXQgIiAr IHN0YXJ0RnJhbWVzW2tdICsgIiBidXQgZXhwZWN0ZWQgYXQgIiArIGV4cGVjdGVkU3RhcnQpOwo=