94541 2012-08-20 16:04:26 -0700 [chromium] Refactor CCLayerTreeHostCommon: merge calculateVisibleRect post-walk into the main calcDrawTransforms recursion 2012-10-05 19:30:55 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 94542 94663 95384 1 shawnsingh shawnsingh cc-bugs danakj enne epenner jamesr webkit.review.bot oldest_to_newest 700109 0 shawnsingh 2012-08-20 16:04:26 -0700 the "visibleLayerRect" of layers is currently computed in a post-walk through all layers that get scheduled to be drawn. In particular, the visibleLayerRect is computed as follows: // only makes a difference if the target surface actually clips the layer. (1) intersection of the layer bounds (in target surface space) with the target surface's contentRect. // further tighten the visible layer rect, which may have expanded due to enclosing the actual projection of the visible layer rect. (2) this rect is then projected back into layer's content space, and intersected with the layer's contentBounds again. It's worth noting that, even after these two steps, the visibleLayerRect is only an approximation, and not necessarily a nicely tight approximation. But still quite helpful, especially since most content with axis-aligned 2d transforms, it will be exact anyway. It should be possible to compute the same visible rect with the following refactorings: (1) remove CCLayerTreeHostCommon::calculateVisibleRects() functions (2) propagate the *approximate* clipRect across renderSurfaces (i.e. the enclosingIntRect of the inverse projection of the clipRect from parent targetSurface to the new surface's owning layer) (3) the drawableContentRectOfLayer, after being clipped, including the new clipRect that propagated from ancestor surfaces, will be the visibleLayerRect. And, because visibleLayerRect is technically (a) approximate and (b) in content space, not layer space, I would like to (4) re-name LayerChromium/CCLayerImpl visibleLayerRect property to "approximateVisibleRect" does this sound right? I'll give it a try and see what happens. To do this cleanly, I'll first add a bunch more visibleLayerRect tests first, in a separate patch. 700118 1 shawnsingh 2012-08-20 16:10:13 -0700 looks like my knowledge was a bit out-dated. It's already being called visibleContentRect =) would it still be OK with you guys if we re-name it to approximateVisibleContentRect ? 700121 2 danakj 2012-08-20 16:12:34 -0700 Re naming: I was about to say it's already named visibleContentRect now. :) I'm not sure about adding approximate to it.. it's a rect that bounds what may be visible. Perhaps visibleContentBoundingRect if you think it's super important to say something but idk really. I like the rest :) 700125 3 shawnsingh 2012-08-20 16:14:48 -0700 Yeah - thanks for the input. Personally I was thinking it may become important to acknowledge it's approximate (and possibly coarsely approximate) in case it made a difference to be aware of that when trying to prepaint stuff that is not yet visible. 700128 4 danakj 2012-08-20 16:16:19 -0700 I think I don't like approximate because it doesn't say how it may be wrong. If anything, bounding says it contains all visible stuff. 700131 5 danakj 2012-08-20 16:17:03 -0700 That said, everything inside it will be considered "visible" because it's the best knowledge we do have :) So I don't think it is necessarily worth distinguishing in the variable name. 700135 6 enne 2012-08-20 16:19:59 -0700 How about visibleContentRectValueMayBeApproximateButWeTriedOurBestReallyAndItMayGetBetterInTheFutureAfterSomeMoreRefactoring? visibleContentRect is fine. Leave a comment that says it's an approximation, but also that it will always enclose the "real" visibleContentRect. 700144 7 shawnsingh 2012-08-20 16:26:03 -0700 (In reply to comment #6) > How about visibleContentRectValueMayBeApproximateButWeTriedOurBestReallyAndItMayGetBetterInTheFutureAfterSomeMoreRefactoring? > > visibleContentRect is fine. Leave a comment that says it's an approximation, but also that it will always enclose the "real" visibleContentRect. alright alright... so be it =) I'll come back to this after 94542. 700183 8 shawnsingh 2012-08-20 16:53:48 -0700 (In reply to comment #7) > (In reply to comment #6) > > How about visibleContentRectValueMayBeApproximateButWeTriedOurBestReallyAndItMayGetBetterInTheFutureAfterSomeMoreRefactoring? > > > > visibleContentRect is fine. Leave a comment that says it's an approximation, but also that it will always enclose the "real" visibleContentRect. > > alright alright... so be it =) I'll come back to this after 94542. One last nit-picky naming point, for now... I think it might be appropriate to merge drawableContentRect and visibleContentRect after doing this refactor, since they are likely to end up being the same. And we did agree on re-naming drawableContentRect to clippedRectInTargetSpace... it might be appropriate to do that in this patch, anyway, so our naming discussion above was moot. Please let me know if you guys want to do something differently. 700187 9 shawnsingh 2012-08-20 16:56:14 -0700 Sorry for the noise; I just wanted to add one last thing for now - the reason I like this idea in comment #8 is because it avoids the word visible which could also be ambiguous for newcomers in the code. occluded things are technically not visible, but they would be part of this "visibleContentRect". so I think it's appropriate if it gets renamed to clippedRectInTargetSpace. 700195 10 danakj 2012-08-20 17:00:25 -0700 Hm, if I project it back to the layer's content, i now have "clippedRect". Does the clipped in clippedRectInTargetSpace refer to non-visible parts being subtracted, or refer to being clipped by the camera and expanded (ie result of CCMathUtil::mapClippedRect)? I've always used clipped to mean the latter. 700204 11 shawnsingh 2012-08-20 17:05:45 -0700 (In reply to comment #10) > Hm, if I project it back to the layer's content, i now have "clippedRect". > > Does the clipped in clippedRectInTargetSpace refer to non-visible parts being subtracted, or refer to being clipped by the camera and expanded (ie result of CCMathUtil::mapClippedRect)? > > I've always used clipped to mean the latter. TLDR; I think the conclusion here is that let's just postpone re-naming confusion and NOT do it in this patch =) The way I use "clipped", CCMathUtil clipping is unrelated to "clippedRect". I feel like we don't need to indicate that rects are clipped by w < 0; but rather we need to clearly indicate to ourselves that they are not exact. There are other more common reasons that such transforms would not be exact, anyway. The way I had been thinking of "clippedRect" meant that it was intersected with ancestor bounds if masksToBounds() or hasMaskLayer(). and, you're right about the targetSpace vs contentSpace... my mistake totally. So the proposed rename should probably be: clippedRectInTargetSpace (new name for drawableContentRect) clippedRectInContentSpace (new name for visibleContentRect) 700227 12 enne 2012-08-20 17:18:10 -0700 (In reply to comment #9) > Sorry for the noise; I just wanted to add one last thing for now - the reason I like this idea in comment #8 is because it avoids the word visible which could also be ambiguous for newcomers in the code. occluded things are technically not visible, but they would be part of this "visibleContentRect". so I think it's appropriate if it gets renamed to clippedRectInTargetSpace. There are plenty of variables in the compositor that we use that are loose in exactly one direction, especially when we are dealing with rects as a simplification for something more complex. Space outside the occlusion rect may actually occlude. Space inside the unocclusion rect may actually be occluded. Space outside the opaque rect may be opaque. Space inside the visible rect may actually not be visible. I appreciate that you want to make variables be more precise, but I don't think your proposed renamings meet the bar for increased clarity vs. increased churn. 702523 13 160036 shawnsingh 2012-08-22 16:54:34 -0700 Created attachment 160036 Finished patch, but should not land before unit tests--comment=passes manual testing and unit tests; layout tests are a bit noisy at the moment so I have to check more carefully, but they seem to be OK 702631 14 160036 epenner 2012-08-22 19:13:15 -0700 Comment on attachment 160036 Finished patch, but should not land before unit tests--comment=passes manual testing and unit tests; layout tests are a bit noisy at the moment so I have to check more carefully, but they seem to be OK View in context: https://bugs.webkit.org/attachment.cgi?id=160036&action=review > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:133 > + // There are three conditions where we can quickly return the full contentBounds of the layer: Does this depend on cases 1.) and 2.) to work properly? I like the idea of painting all animated layers, but we never came up with a solution to handle arbitrarily large layers that can't all fit into memory. We currently do some special logic to detect 'reasonable sized' layers and make this decision at paint time after we have already successfully allocated textures for the entire layer. Would it hurt to just remove the top two cases? Even if the exact transform isn't known, the visible rect from the approximate transform on the main thread is better than nothing. 702657 15 160036 epenner 2012-08-22 20:19:08 -0700 Comment on attachment 160036 Finished patch, but should not land before unit tests--comment=passes manual testing and unit tests; layout tests are a bit noisy at the moment so I have to check more carefully, but they seem to be OK View in context: https://bugs.webkit.org/attachment.cgi?id=160036&action=review >> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:133 >> + // There are three conditions where we can quickly return the full contentBounds of the layer: > > Does this depend on cases 1.) and 2.) to work properly? > > I like the idea of painting all animated layers, but we never came up with a solution to handle arbitrarily large layers that can't all fit into memory. We currently do some special logic to detect 'reasonable sized' layers and make this decision at paint time after we have already successfully allocated textures for the entire layer. Would it hurt to just remove the top two cases? Even if the exact transform isn't known, the visible rect from the approximate transform on the main thread is better than nothing. Now that I look again, case 3.) also seems like it could occur on an unbounded size layer which might OOM. This is where I don't see how we can do without propagated visibility info of some sort. 702677 16 shawnsingh 2012-08-22 21:34:11 -0700 (In reply to comment #15) > (From update of attachment 160036 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=160036&action=review > > >> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:133 > >> + // There are three conditions where we can quickly return the full contentBounds of the layer: > > > > Does this depend on cases 1.) and 2.) to work properly? > > > > I like the idea of painting all animated layers, but we never came up with a solution to handle arbitrarily large layers that can't all fit into memory. We currently do some special logic to detect 'reasonable sized' layers and make this decision at paint time after we have already successfully allocated textures for the entire layer. Would it hurt to just remove the top two cases? Even if the exact transform isn't known, the visible rect from the approximate transform on the main thread is better than nothing. > > Now that I look again, case 3.) also seems like it could occur on an unbounded size layer which might OOM. This is where I don't see how we can do without propagated visibility info of some sort. OK, sounds like we should discuss a little bit more offline with danakj and enne as well. In the meantime, personally I think this patch is a pretty good cleanup of the code anyway - do you think there's any reason we should actually not move forward with this? 702993 17 160036 danakj 2012-08-23 08:02:34 -0700 Comment on attachment 160036 Finished patch, but should not land before unit tests--comment=passes manual testing and unit tests; layout tests are a bit noisy at the moment so I have to check more carefully, but they seem to be OK View in context: https://bugs.webkit.org/attachment.cgi?id=160036&action=review >>>> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:133 >>>> + // There are three conditions where we can quickly return the full contentBounds of the layer: >>> >>> Does this depend on cases 1.) and 2.) to work properly? >>> >>> I like the idea of painting all animated layers, but we never came up with a solution to handle arbitrarily large layers that can't all fit into memory. We currently do some special logic to detect 'reasonable sized' layers and make this decision at paint time after we have already successfully allocated textures for the entire layer. Would it hurt to just remove the top two cases? Even if the exact transform isn't known, the visible rect from the approximate transform on the main thread is better than nothing. >> >> Now that I look again, case 3.) also seems like it could occur on an unbounded size layer which might OOM. This is where I don't see how we can do without propagated visibility info of some sort. > > OK, sounds like we should discuss a little bit more offline with danakj and enne as well. > > In the meantime, personally I think this patch is a pretty good cleanup of the code anyway - do you think there's any reason we should actually not move forward with this? Is its behaviour the same? These sound different than what used to happen at least. I don't like the whole "cannot assume" stuff really. I know I was the first one to bring that terminology into the compositor, but I've tried to get away from that. In CCLTHC I think we should use "unknown transform" stuff *only* for making decisions about (not) dropping layers out of the RSLL. Other than that we should produce a valid and correct frame with exact values for the time at which the frame is generated. I don't see why animation should do anything to the calculation on the impl thread, which happens here for 1. If you want to make the render surface texture stay the same size, I think it should not be done by changing the visibleContentRect of its owning layer (and how would that guarantee it didnt change anyway?). 703063 18 shawnsingh 2012-08-23 09:18:51 -0700 (In reply to comment #17) > (From update of attachment 160036 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=160036&action=review > > >>>> Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:133 > >>>> + // There are three conditions where we can quickly return the full contentBounds of the layer: > >>> > >>> Does this depend on cases 1.) and 2.) to work properly? > >>> > >>> I like the idea of painting all animated layers, but we never came up with a solution to handle arbitrarily large layers that can't all fit into memory. We currently do some special logic to detect 'reasonable sized' layers and make this decision at paint time after we have already successfully allocated textures for the entire layer. Would it hurt to just remove the top two cases? Even if the exact transform isn't known, the visible rect from the approximate transform on the main thread is better than nothing. > >> > >> Now that I look again, case 3.) also seems like it could occur on an unbounded size layer which might OOM. This is where I don't see how we can do without propagated visibility info of some sort. > > > > OK, sounds like we should discuss a little bit more offline with danakj and enne as well. > > > > In the meantime, personally I think this patch is a pretty good cleanup of the code anyway - do you think there's any reason we should actually not move forward with this? > > Is its behaviour the same? These sound different than what used to happen at least. > > I don't like the whole "cannot assume" stuff really. I know I was the first one to bring that terminology into the compositor, but I've tried to get away from that. In CCLTHC I think we should use "unknown transform" stuff *only* for making decisions about (not) dropping layers out of the RSLL. Other than that we should produce a valid and correct frame with exact values for the time at which the frame is generated. I don't see why animation should do anything to the calculation on the impl thread, which happens here for 1. > I'll look into this again. I think 1 & 2 were necessary because otherwise things don't get painted correctly when animating, because we think they are not visible. In the previous code, visibility was computed via the surface's contentRect, and that contentRect was not clipped (on the main thread) if the surface was animating. The difference, however, between these checks and the one dealing with surface's contentRect is that we are not necessarily at the exact point in recursion where all we need to do is check the layer's transformToParentIsKnown() helper. Instead, if we're further down in the recursion, the layer has to check if it's screen space transform is known. For the surface-is-animating check - yeah, it might need to be refined, or maybe it's already encompassed by the layer's transformToScreenIsKnown(). > If you want to make the render surface texture stay the same size, I think it should not be done by changing the visibleContentRect of its owning layer (and how would that guarantee it didnt change anyway?). Sorry I didn't understand this last part. The render surface size is determined by drawableContentRectOfSubtree, and if needed, the clipRect. So it has nothing to do with visibleContentRect? 703120 19 danakj 2012-08-23 10:24:19 -0700 (In reply to comment #18) > > If you want to make the render surface texture stay the same size, I think it should not be done by changing the visibleContentRect of its owning layer (and how would that guarantee it didnt change anyway?). > > Sorry I didn't understand this last part. The render surface size is determined by drawableContentRectOfSubtree, and if needed, the clipRect. So it has nothing to do with visibleContentRect? Oh okay. I just read some conversation about preserving surfaces sizes during animation, and was wondering if that was part of the reasoning here for checking if animations are happening. If not, then I think/hope there's less reason to worry about if animation is happening. Animating things that have visibleContentRect.isEmpty() have been getting prepainted based on their size. I think it should be the prepainting code's job to figure out what to paint appropriately, and the visibleContentRect should describe what is actually visible - regardless of animation. 703122 20 enne 2012-08-23 10:27:49 -0700 (In reply to comment #19) > > I think it should be the prepainting code's job to figure out what to paint appropriately, and the visibleContentRect should describe what is actually visible - regardless of animation. +1 The prepainting code definitely needs additional information to make better decisions, but visibleContentRect shouldn't lie to make that happen. 703177 21 shawnsingh 2012-08-23 11:25:09 -0700 (In reply to comment #20) > (In reply to comment #19) > > > > I think it should be the prepainting code's job to figure out what to paint appropriately, and the visibleContentRect should describe what is actually visible - regardless of animation. > > +1 > > The prepainting code definitely needs additional information to make better decisions, but visibleContentRect shouldn't lie to make that happen. Chalk it up to a brain fart on my part. It does work fine without those if statements, and I agree with both you guys' logic. So yes we should be able to just remove conditions #1 and #2. BUT... it looks like this refactor doesn't fit Eric's needs yet, since we still do need check #3, which seems to be problematic based on comment #15. So maybe we want the following middle-ground: (1) renderSurfaces and drawableContentRects compute their size the same way they do now, so they remain better cacheable. (2) visibleContentRects, however, always use clipRects the way that we were propagating them in https://bugs.webkit.org/show_bug.cgi?id=94663. This way they are always bounded. If we do this, there would be a nice relationship describing the meaning of drawableContentRect and visibleContentRect - and yes I might try to debate over renaming things some other day =) drawableContentRect --> the portion of the layer that contributes to the surface (not counting occlusion) visibleContentRect --> the portion of the layer that contributes to the screen (not counting occlusion) 703192 22 danakj 2012-08-23 11:37:21 -0700 I like it :) 703196 23 enne 2012-08-23 11:43:11 -0700 (In reply to comment #21) > If we do this, there would be a nice relationship describing the meaning of drawableContentRect and visibleContentRect - and yes I might try to debate over renaming things some other day =) > > drawableContentRect --> the portion of the layer that contributes to the surface (not counting occlusion) > visibleContentRect --> the portion of the layer that contributes to the screen (not counting occlusion) Wait, what? drawableContentRect --> the projection of a layer or contributing surface into its target space, bounded by the size of that target 703225 24 epenner 2012-08-23 12:05:03 -0700 > > drawableContentRect --> the portion of the layer that contributes to the surface (not counting occlusion) > > visibleContentRect --> the portion of the layer that contributes to the screen (not counting occlusion) > > Wait, what? > > drawableContentRect --> the projection of a layer or contributing surface into its target space, bounded by the size of that target Having these definitions as comments on LayerChromium would be ultra awesome! They might need maintenance as definitions change, but it's well worth it IMO. > BUT... it looks like this refactor doesn't fit Eric's needs yet, since we still do need check #3, which seems to be problematic based on comment #15. Regarding comment #15, is the layer size implicitly bounded in size because that clip is empty? If so then it's okay to use visible=bounds, but I couldn't tell if that was always the case. 703268 25 shawnsingh 2012-08-23 12:47:51 -0700 (In reply to comment #23) > Wait, what? > > drawableContentRect --> the projection of a layer or contributing surface into its target space, bounded by the size of that target Yes, I feel like that's the same thing I said, except you're wording acknowledges that the rect is described in target surface space (i.e. the projection part). I can be more careful about the wording in comments. (In reply to comment #24) > Regarding comment #15, is the layer size implicitly bounded in size because that clip is empty? If so then it's okay to use visible=bounds, but I couldn't tell if that was always the case. I'm a little unclear what you're asking... here's my understanding of the situation: In the current code, a huge unclipped layer: - has a huge drawableContentRect - causes its target renderSurface to grow to enclose the layer, so it becomes huge, too - has a huge visibleContentRect, which isn't helpful for intelligent prepainting. In future code, if we make the change, a huge unclipped layer: - (same) still has a huge drawableContentRect - (same) still causes the renderSurface to grow huge to enclose the layer - (new behavior) has a visibleContentRect that is well bounded, based on any ancestor clips, including the viewport. will that be useful for you? In this patch or a later patch, we could add a notion of "visibleContent" to renderSurfaces as well. 703374 26 enne 2012-08-23 14:27:47 -0700 Given how many bugs have come out of CCLayerTreeHostCommon refactoring, how about doing this in two parts: (1) Do what the bug title says and remove the post-walk for visible layer rect calculation, but leave the results of that calculation identical to before the patch. (2) Tighten up the visibleLayerRect calculation by projecting clipRects down through intermediate render surfaces. 703423 27 epenner 2012-08-23 14:56:02 -0700 > > Regarding comment #15, is the layer size implicitly bounded in size because that clip is empty? If so then it's okay to use visible=bounds, but I couldn't tell if that was always the case. > > I'm a little unclear what you're asking... here's my understanding of the situation: > > In the current code, a huge unclipped layer: > - has a huge drawableContentRect > - causes its target renderSurface to grow to enclose the layer, so it becomes huge, too > - has a huge visibleContentRect, which isn't helpful for intelligent prepainting. > Could 'huge' mean say 100,000x100,000? Or just 2048x2048 (max surface size). If we ever set a visibleRect to the former then that's a problem. However, if it was already a problem before then no need to fix it in this CL. 736173 28 shawnsingh 2012-10-05 19:30:55 -0700 This is now being worked on on the chromium side. https://codereview.chromium.org/11079012/ 160036 2012-08-22 16:54:34 -0700 2012-08-23 08:02:34 -0700 Finished patch, but should not land before unit tests--comment=passes manual testing and unit tests; layout tests are a bit noisy at the moment so I have to check more carefully, but they seem to be OK bug-94541-20120822165432.patch text/plain 27772 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogMTI2MzE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDA0MjczZWY4NjM3ZjQ5 ZTg2YWRhZGViNGUzZWZhZTBiNmNlNTg3My4uNTdjNWEwNThiMzI3NmQwM2VlYTUwYzg2ZjI2ZDNj ODZhZjdhZjAxNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTA4LTIyICBTaGF3 biBTaW5naCAgPHNoYXduc2luZ2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g UmVmYWN0b3IgQ0NMYXllclRyZWVIb3N0Q29tbW9uOiBtZXJnZSBjYWxjdWxhdGVWaXNpYmxlUmVj dCBwb3N0LXdhbGsgaW50byB0aGUgbWFpbiBjYWxjRHJhd3RyYW5zZm9ybXMgcmVjdXJzaW9uCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NDU0MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSB2aXNpYmxl UmVjdCBmb3IgZWFjaCBsYXllciB3YXMgYmVpbmcgY29tcHV0ZWQgb3V0c2lkZSBvZgorICAgICAg ICBjYWxjRHJhd1RyYW5zZm9ybXMsIGluIGEgc2VwYXJhdGUgd2FsayB0aHJvdWdoIHJlbmRlclBh c3Nlcy4gRm9yIGEKKyAgICAgICAgYmV0dGVyIGRlc2lnbiBvZiBpbnRlbGxpZ2VudCBwcmUtcGFp bnRpbmcsIGl0IHdhcyBoZWxwZnVsIHRvIG1lcmdlCisgICAgICAgIHRoaXMgaW50byB0aGUgbWFp biBjYWxjRHJhd1RyYW5zZm9ybXMgcmVjdXJzaW9uLgorCisgICAgICAgIEl0J3MgYSBuaWNlIGNs ZWFudXAgdG8gaGF2ZSBkb25lLCBhbnl3YXkuCisKKyAgICAgICAgVGVzdHMgdGhhdCBjb3ZlciB0 aGlzIGNoYW5nZSBuZWVkIHRvIGJlIGFkZGVkIGJlZm9yZSB0aGlzIHBhdGNoIGlzIGxhbmRlZC4K KyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 Q0NMYXllclRyZWVIb3N0Ojp1cGRhdGVMYXllcnMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdENvbW1vbi5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjYWxjdWxhdGVWaXNpYmxlQ29udGVudFJlY3QpOgorICAgICAgICAoV2ViQ29yZTo6Y2Fs Y3VsYXRlRHJhd1RyYW5zZm9ybXNJbnRlcm5hbCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0Q29tbW9uLmg6CisgICAgICAgIChDQ0xheWVy VHJlZUhvc3RDb21tb24pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDTGF5ZXJUcmVlSG9zdEltcGwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVI b3N0SW1wbDo6Y2FsY3VsYXRlUmVuZGVyU3VyZmFjZUxheWVyTGlzdCk6CisKIDIwMTItMDgtMjIg IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CiAKICAgICAgICAgVW5yZXZp ZXdlZCBidWlsZCBmaXguIE1pc3NpbmcgUEFOR09fQ0ZMQUdTLgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwppbmRleCA3ODA0ZWNkOTdmMTQ5YmYwODM0OTAzMjMwZTc3YjAwMTcyOTQxMjJmLi41YmEy OTllMDgyYTY5MWMzN2EyNmIwMDQ0ZWMwMDhhMjdjOGRlYTk2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTA4LTIyICBTaGF3biBTaW5naCAgPHNoYXdu c2luZ2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gUmVmYWN0b3IgQ0NMYXll clRyZWVIb3N0Q29tbW9uOiBtZXJnZSBjYWxjdWxhdGVWaXNpYmxlUmVjdCBwb3N0LXdhbGsgaW50 byB0aGUgbWFpbiBjYWxjRHJhd3RyYW5zZm9ybXMgcmVjdXJzaW9uCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NDU0MQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVuaXQgdGVzdHMgaGFkIHRvIGJlIHVwZGF0 ZWQgYmVjYXVzZSBjYWxjdWxhdGVWaXNpYmxlUmVjdHMoKQorICAgICAgICBmdW5jdGlvbiBubyBs b25nZXIgZXhpc3RzLgorCisgICAgICAgICogdGVzdHMvQ0NEYW1hZ2VUcmFja2VyVGVzdC5jcHA6 CisgICAgICAgIChXZWJLaXRUZXN0czo6ZXhlY3V0ZUNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zQW5k VmlzaWJpbGl0eSk6CisgICAgICAgICogdGVzdHMvQ0NMYXllckl0ZXJhdG9yVGVzdC5jcHA6Cisg ICAgICAgICogdGVzdHMvQ0NMYXllclRyZWVIb3N0Q29tbW9uVGVzdC5jcHA6CisgICAgICAgICog dGVzdHMvQ0NMYXllclRyZWVIb3N0SW1wbFRlc3QuY3BwOgorICAgICAgICAqIHRlc3RzL0NDT2Nj bHVzaW9uVHJhY2tlclRlc3QuY3BwOgorICAgICAgICAoV2ViS2l0VGVzdHM6OkNDT2NjbHVzaW9u VHJhY2tlclRlc3Q6OmNhbGNEcmF3RXRjKToKKwogMjAxMi0wOC0yMiAgU2hlcmlmZiBCb3QgIDx3 ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZC4gIFJvbGxl ZCBERVBTLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggMmUzYTdkZWIzZDE1 ZTUzMmU2Mzc4NTgwZTZkZDIxYzlhMDE0NmE0OS4uMTNiYTAzOTFiZDQ1ZWEwNWEyZTdjNDFlYzg3 YzE3MmQyNzc1OTQ0MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC00ODcs NyArNDg3LDYgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUxheWVycyhMYXllckNocm9t aXVtKiByb290TGF5ZXIsIENDVGV4dHVyZVVwZGF0ZVF1ZXUKICAgICB7CiAgICAgICAgIFRSQUNF X0VWRU5UMCgiY2MiLCAiQ0NMYXllclRyZWVIb3N0Ojp1cGRhdGVMYXllcnM6OmNhbGNEcmF3RXRj Iik7CiAgICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9y bXMocm9vdExheWVyLCBkZXZpY2VWaWV3cG9ydFNpemUoKSwgbV9kZXZpY2VTY2FsZUZhY3Rvciwg bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplLCB1cGRhdGVMaXN0KTsK LSAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHModXBk YXRlTGlzdCk7CiAgICAgfQogCiAgICAgLy8gUmVzZXQgcGFydGlhbCB0ZXh0dXJlIHVwZGF0ZSBy ZXF1ZXN0cy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdENvbW1vbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RDb21tb24uY3BwCmluZGV4 IDY4OThjOTc3OThmZjUwMzZjMWFjZDgxZDE2NWJiMTU4N2Q5OTBiN2EuLjQwNmUxNGY3MDE1NjRl NmIwMjNiNWQ1NjJlM2Y2ZDQxODVmOTM2YzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdENvbW1vbi5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0Q29tbW9uLmNwcApAQCAtMTI2LDE2ICsxMjYsMjcgQEAgc3RhdGljIEludFJlY3QgY2Fs Y3VsYXRlVmlzaWJsZUNvbnRlbnRSZWN0KExheWVyVHlwZSogbGF5ZXIpCiB7CiAgICAgQVNTRVJU KGxheWVyLT5yZW5kZXJUYXJnZXQoKSk7CiAKLSAgICBJbnRSZWN0IHRhcmdldFN1cmZhY2VSZWN0 ID0gbGF5ZXItPnJlbmRlclRhcmdldCgpLT5yZW5kZXJTdXJmYWNlKCktPmNvbnRlbnRSZWN0KCk7 CisgICAgLy8gTm90aGluZyBpcyB2aXNpYmxlIGlmIHRoZSBsYXllcidzIGJvdW5kcyBhcmUgZW1w dHkuCisgICAgaWYgKCFsYXllci0+ZHJhd3NDb250ZW50KCkgfHwgbGF5ZXItPmNvbnRlbnRCb3Vu ZHMoKS5pc0VtcHR5KCkgfHwgbGF5ZXItPmRyYXdhYmxlQ29udGVudFJlY3QoKS5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybiBJbnRSZWN0KCk7CisKKyAgICAvLyBUaGVyZSBhcmUgdGhyZWUgY29u ZGl0aW9ucyB3aGVyZSB3ZSBjYW4gcXVpY2tseSByZXR1cm4gdGhlIGZ1bGwgY29udGVudEJvdW5k cyBvZiB0aGUgbGF5ZXI6CisgICAgLy8gIDEuIGlmIHRoZSByZW5kZXJTdXJmYWNlIHRyYW5zZm9y bSBpcyBiZWluZyBhbmltYXRlZCwgd2UgY2Fubm90IGFzc3VtZSBhbnl0aGluZyBhYm91dCB3aGV0 aGVyIHRoZSBsYXllciBpcyBjbGlwcGVkCisgICAgLy8gIDIuIGlmIHRoZSBsYXllciBpdHNlbGYg aXMgYmVpbmcgYW5pbWF0ZWQsIHdlIGNhbm5vdCBhc3N1bWUgYW55dGhpbmcgYWJvdXQgd2hldGhl ciB0aGUgbGF5ZXIgaXMgY2xpcHBlZC4KKyAgICAvLyAgMy4gaWYgdGhlIHJlbmRlclN1cmZhY2Ug Y2xpcFJlY3Qgd2FzIGluYWN0aXZlLCB0aGVuIHdlIGtub3cgdGhlIGxheWVyIGlzIG5vdCBjbGlw cGVkIGJ5IHRoZSBzdXJmYWNlICh0aGlzIGNhc2UgaXMgZW5jb2RlZCBhcyBhbiBlbXB0eSBzdXJm YWNlIGNsaXBSZWN0KS4KKyAgICBpZiAobGF5ZXItPnJlbmRlclRhcmdldCgpLT5yZW5kZXJTdXJm YWNlKCktPnNjcmVlblNwYWNlVHJhbnNmb3Jtc0FyZUFuaW1hdGluZygpCisgICAgICAgIHx8ICF0 cmFuc2Zvcm1Ub1NjcmVlbklzS25vd24obGF5ZXIpCisgICAgICAgIHx8IGxheWVyLT5yZW5kZXJU YXJnZXQoKS0+cmVuZGVyU3VyZmFjZSgpLT5jbGlwUmVjdCgpLmlzRW1wdHkoKSkKKyAgICAgICAg cmV0dXJuIEludFJlY3QoSW50UG9pbnQoKSwgbGF5ZXItPmNvbnRlbnRCb3VuZHMoKSk7CiAKLSAg ICB0YXJnZXRTdXJmYWNlUmVjdC5pbnRlcnNlY3QobGF5ZXItPmRyYXdhYmxlQ29udGVudFJlY3Qo KSk7CisgICAgLy8gSGVyZSB3ZSBmaXJzdCBuZWVkIHRvIGNvbnZlcnQgdGhlIHN1cmZhY2UncyBj bGlwUmVjdCBmcm9tIHRoZSBhbmNlc3RvciBzdXJmYWNlIHNwYWNlIHRvIHRoZSBjdXJyZW50IHN1 cmZhY2Ugc3BhY2UuCisgICAgSW50UmVjdCB0YXJnZXRTdXJmYWNlQ2xpcFJlY3QgPSBlbmNsb3Np bmdJbnRSZWN0KENDTWF0aFV0aWw6OnByb2plY3RDbGlwcGVkUmVjdChsYXllci0+cmVuZGVyVGFy Z2V0KCktPnJlbmRlclN1cmZhY2UoKS0+ZHJhd1RyYW5zZm9ybSgpLmludmVyc2UoKSwgbGF5ZXIt PnJlbmRlclRhcmdldCgpLT5yZW5kZXJTdXJmYWNlKCktPmNsaXBSZWN0KCkpKTsKKyAgICB0YXJn ZXRTdXJmYWNlQ2xpcFJlY3QuaW50ZXJzZWN0KGxheWVyLT5kcmF3YWJsZUNvbnRlbnRSZWN0KCkp OwogCi0gICAgaWYgKHRhcmdldFN1cmZhY2VSZWN0LmlzRW1wdHkoKSB8fCBsYXllci0+Y29udGVu dEJvdW5kcygpLmlzRW1wdHkoKSkKKyAgICBpZiAodGFyZ2V0U3VyZmFjZUNsaXBSZWN0LmlzRW1w dHkoKSkKICAgICAgICAgcmV0dXJuIEludFJlY3QoKTsKIAotICAgIGNvbnN0IEludFJlY3QgY29u dGVudFJlY3QgPSBJbnRSZWN0KEludFBvaW50KCksIGxheWVyLT5jb250ZW50Qm91bmRzKCkpOwot ICAgIEludFJlY3QgdmlzaWJsZUNvbnRlbnRSZWN0ID0gQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpj YWxjdWxhdGVWaXNpYmxlUmVjdCh0YXJnZXRTdXJmYWNlUmVjdCwgY29udGVudFJlY3QsIGxheWVy LT5kcmF3VHJhbnNmb3JtKCkpOwotICAgIHJldHVybiB2aXNpYmxlQ29udGVudFJlY3Q7CisgICAg cmV0dXJuIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3QodGFyZ2V0 U3VyZmFjZUNsaXBSZWN0LCBJbnRSZWN0KEludFBvaW50KCksIGxheWVyLT5jb250ZW50Qm91bmRz KCkpLCBsYXllci0+ZHJhd1RyYW5zZm9ybSgpKTsKIH0KIAogc3RhdGljIGJvb2wgaXNTY2FsZU9y VHJhbnNsYXRpb24oY29uc3QgV2ViVHJhbnNmb3JtYXRpb25NYXRyaXgmIG0pCkBAIC01ODAsMTUg KzU5MSwyNSBAQCBzdGF0aWMgdm9pZCBjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0ludGVybmFsKExh eWVyVHlwZSogbGF5ZXIsIExheWVyVHlwZSogcm9vdExheQogICAgICAgICAvLyBjdXJyZW50IHRh cmdldCBzdXJmYWNlIHNwYWNlIHRoYXQgY291bGQgY2F1c2UgbW9yZSB3IDwgMCBoZWFkYWNoZXMu CiAgICAgICAgIHN1YnRyZWVTaG91bGRCZUNsaXBwZWQgPSBmYWxzZTsKIAotICAgICAgICBpZiAo bGF5ZXItPm1hc2tMYXllcigpKQorICAgICAgICBpZiAobGF5ZXItPm1hc2tMYXllcigpKSB7CiAg ICAgICAgICAgICBsYXllci0+bWFza0xheWVyKCktPnNldFJlbmRlclRhcmdldChsYXllcik7Cisg ICAgICAgICAgICBsYXllci0+bWFza0xheWVyKCktPnNldFZpc2libGVDb250ZW50UmVjdChJbnRS ZWN0KEludFBvaW50KCksIGxheWVyLT5jb250ZW50Qm91bmRzKCkpKTsKKyAgICAgICAgfQogCi0g ICAgICAgIGlmIChsYXllci0+cmVwbGljYUxheWVyKCkgJiYgbGF5ZXItPnJlcGxpY2FMYXllcigp LT5tYXNrTGF5ZXIoKSkKKyAgICAgICAgaWYgKGxheWVyLT5yZXBsaWNhTGF5ZXIoKSAmJiBsYXll ci0+cmVwbGljYUxheWVyKCktPm1hc2tMYXllcigpKSB7CiAgICAgICAgICAgICBsYXllci0+cmVw bGljYUxheWVyKCktPm1hc2tMYXllcigpLT5zZXRSZW5kZXJUYXJnZXQobGF5ZXIpOworICAgICAg ICAgICAgbGF5ZXItPnJlcGxpY2FMYXllcigpLT5tYXNrTGF5ZXIoKS0+c2V0VmlzaWJsZUNvbnRl bnRSZWN0KEludFJlY3QoSW50UG9pbnQoKSwgbGF5ZXItPmNvbnRlbnRCb3VuZHMoKSkpOworICAg ICAgICB9CiAKICAgICAgICAgaWYgKGxheWVyLT5maWx0ZXJzKCkuaGFzRmlsdGVyVGhhdE1vdmVz UGl4ZWxzKCkpCiAgICAgICAgICAgICBuZWFyZXN0QW5jZXN0b3JUaGF0TW92ZXNQaXhlbHMgPSBy ZW5kZXJTdXJmYWNlOwogCisgICAgICAgIC8vIFRoZSByZW5kZXIgc3VyZmFjZSBjbGlwUmVjdCBp cyBleHByZXNzZWQgaW4gdGhlIHNwYWNlIHdoZXJlIHRoaXMgc3VyZmFjZSBkcmF3cywgaS5lLiB0 aGUgc2FtZSBzcGFjZSBhcyBjbGlwUmVjdEZyb21BbmNlc3Rvci4KKyAgICAgICAgaWYgKGFuY2Vz dG9yQ2xpcHNTdWJ0cmVlKQorICAgICAgICAgICAgcmVuZGVyU3VyZmFjZS0+c2V0Q2xpcFJlY3Qo Y2xpcFJlY3RGcm9tQW5jZXN0b3IpOworICAgICAgICBlbHNlCisgICAgICAgICAgICByZW5kZXJT dXJmYWNlLT5zZXRDbGlwUmVjdChJbnRSZWN0KCkpOworCiAgICAgICAgIHJlbmRlclN1cmZhY2Ut PnNldE5lYXJlc3RBbmNlc3RvclRoYXRNb3Zlc1BpeGVscyhuZWFyZXN0QW5jZXN0b3JUaGF0TW92 ZXNQaXhlbHMpOwogCiAgICAgICAgIHJlbmRlclN1cmZhY2VMYXllckxpc3QuYXBwZW5kKGxheWVy KTsKQEAgLTY4MywxNyArNzA0LDE1IEBAIHN0YXRpYyB2b2lkIGNhbGN1bGF0ZURyYXdUcmFuc2Zv cm1zSW50ZXJuYWwoTGF5ZXJUeXBlKiBsYXllciwgTGF5ZXJUeXBlKiByb290TGF5CiAgICAgICAg IGRyYXdhYmxlQ29udGVudFJlY3RPZkxheWVyLmludGVyc2VjdChjbGlwUmVjdEZvclN1YnRyZWUp OwogICAgIGxheWVyLT5zZXREcmF3YWJsZUNvbnRlbnRSZWN0KGRyYXdhYmxlQ29udGVudFJlY3RP ZkxheWVyKTsKIAorICAgIC8vIENvbXB1dGUgdGhlIGxheWVyJ3MgdmlzaWJsZSBjb250ZW50IHJl Y3QgKHRoZSByZWN0IGlzIGluIGNvbnRlbnQgc3BhY2UpCisgICAgSW50UmVjdCB2aXNpYmxlQ29u dGVudFJlY3RPZkxheWVyID0gY2FsY3VsYXRlVmlzaWJsZUNvbnRlbnRSZWN0KGxheWVyKTsKKyAg ICBsYXllci0+c2V0VmlzaWJsZUNvbnRlbnRSZWN0KHZpc2libGVDb250ZW50UmVjdE9mTGF5ZXIp OworCiAgICAgLy8gQ29tcHV0ZSB0aGUgcmVtYWluaW5nIHByb3BlcnRpZXMgZm9yIHRoZSByZW5k ZXIgc3VyZmFjZSwgaWYgdGhlIGxheWVyIGhhcyBvbmUuCiAgICAgaWYgKGxheWVyLT5yZW5kZXJT dXJmYWNlKCkgJiYgbGF5ZXIgIT0gcm9vdExheWVyKSB7CiAgICAgICAgIFJlbmRlclN1cmZhY2VU eXBlKiByZW5kZXJTdXJmYWNlID0gbGF5ZXItPnJlbmRlclN1cmZhY2UoKTsKICAgICAgICAgSW50 UmVjdCBjbGlwcGVkQ29udGVudFJlY3QgPSBsb2NhbERyYXdhYmxlQ29udGVudFJlY3RPZlN1YnRy ZWU7CiAKLSAgICAgICAgLy8gVGhlIHJlbmRlciBzdXJmYWNlIGNsaXBSZWN0IGlzIGV4cHJlc3Nl ZCBpbiB0aGUgc3BhY2Ugd2hlcmUgdGhpcyBzdXJmYWNlIGRyYXdzLCBpLmUuIHRoZSBzYW1lIHNw YWNlIGFzIGNsaXBSZWN0RnJvbUFuY2VzdG9yLgotICAgICAgICBpZiAoYW5jZXN0b3JDbGlwc1N1 YnRyZWUpCi0gICAgICAgICAgICByZW5kZXJTdXJmYWNlLT5zZXRDbGlwUmVjdChjbGlwUmVjdEZy b21BbmNlc3Rvcik7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgIHJlbmRlclN1cmZhY2UtPnNl dENsaXBSZWN0KEludFJlY3QoKSk7Ci0KICAgICAgICAgLy8gRG9uJ3QgY2xpcCBpZiB0aGUgbGF5 ZXIgaXMgcmVmbGVjdGVkIGFzIHRoZSByZWZsZWN0aW9uIHNob3VsZG4ndCBiZQogICAgICAgICAv LyBjbGlwcGVkLiBJZiB0aGUgbGF5ZXIgaXMgYW5pbWF0aW5nLCB0aGVuIHRoZSBzdXJmYWNlJ3Mg dHJhbnNmb3JtIHRvCiAgICAgICAgIC8vIGl0cyB0YXJnZXQgaXMgbm90IGtub3duIG9uIHRoZSBt YWluIHRocmVhZCwgYW5kIHdlIHNob3VsZCBub3QgdXNlIGl0CkBAIC03NzEsMzEgKzc5MCw2IEBA IHN0YXRpYyB2b2lkIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zSW50ZXJuYWwoTGF5ZXJUeXBlKiBs YXllciwgTGF5ZXJUeXBlKiByb290TGF5CiAgICAgcmV0dXJuOwogfQogCi0vLyBGSVhNRTogSW5z dGVhZCBvZiB1c2luZyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRvIHNldCB2aXNpYmlsaXR5IHJl Y3RzIG9uIGEgc2Vjb25kCi0vLyB0cmVlIHBhc3MsIHJldmlzZSBjYWxjdWxhdGVWaXNpYmxlQ29u dGVudFJlY3QoKSBzbyB0aGF0IHRoaXMgY2FuIGJlIGRvbmUgaW4gYSBzaW5nbGUKLS8vIHBhc3Mg aW5zaWRlIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zSW50ZXJuYWw8PigpLgotdGVtcGxhdGU8dHlw ZW5hbWUgTGF5ZXJUeXBlLCB0eXBlbmFtZSBMYXllckxpc3QsIHR5cGVuYW1lIFJlbmRlclN1cmZh Y2VUeXBlPgotc3RhdGljIHZvaWQgY2FsY3VsYXRlVmlzaWJsZVJlY3RzSW50ZXJuYWwoY29uc3Qg TGF5ZXJMaXN0JiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KQotewotICAgIC8vIFVzZSBCYWNrVG9G cm9udCBzaW5jZSBpdCdzIGNoZWFwIGFuZCB0aGlzIGlzbid0IG9yZGVyLWRlcGVuZGVudC4KLSAg ICB0eXBlZGVmIENDTGF5ZXJJdGVyYXRvcjxMYXllclR5cGUsIExheWVyTGlzdCwgUmVuZGVyU3Vy ZmFjZVR5cGUsIENDTGF5ZXJJdGVyYXRvckFjdGlvbnM6OkJhY2tUb0Zyb250PiBDQ0xheWVySXRl cmF0b3JUeXBlOwotCi0gICAgQ0NMYXllckl0ZXJhdG9yVHlwZSBlbmQgPSBDQ0xheWVySXRlcmF0 b3JUeXBlOjplbmQoJnJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIGZvciAoQ0NMYXllckl0 ZXJhdG9yVHlwZSBpdCA9IENDTGF5ZXJJdGVyYXRvclR5cGU6OmJlZ2luKCZyZW5kZXJTdXJmYWNl TGF5ZXJMaXN0KTsgaXQgIT0gZW5kOyArK2l0KSB7Ci0gICAgICAgIGlmIChpdC5yZXByZXNlbnRz VGFyZ2V0UmVuZGVyU3VyZmFjZSgpKSB7Ci0gICAgICAgICAgICBMYXllclR5cGUqIG1hc2tMYXll ciA9IGl0LT5tYXNrTGF5ZXIoKTsKLSAgICAgICAgICAgIGlmIChtYXNrTGF5ZXIpCi0gICAgICAg ICAgICAgICAgbWFza0xheWVyLT5zZXRWaXNpYmxlQ29udGVudFJlY3QoSW50UmVjdChJbnRQb2lu dCgpLCBpdC0+Y29udGVudEJvdW5kcygpKSk7Ci0gICAgICAgICAgICBMYXllclR5cGUqIHJlcGxp Y2FNYXNrTGF5ZXIgPSBpdC0+cmVwbGljYUxheWVyKCkgPyBpdC0+cmVwbGljYUxheWVyKCktPm1h c2tMYXllcigpIDogMDsKLSAgICAgICAgICAgIGlmIChyZXBsaWNhTWFza0xheWVyKQotICAgICAg ICAgICAgICAgIHJlcGxpY2FNYXNrTGF5ZXItPnNldFZpc2libGVDb250ZW50UmVjdChJbnRSZWN0 KEludFBvaW50KCksIGl0LT5jb250ZW50Qm91bmRzKCkpKTsKLSAgICAgICAgfSBlbHNlIGlmIChp dC5yZXByZXNlbnRzSXRzZWxmKCkpIHsKLSAgICAgICAgICAgIEludFJlY3QgdmlzaWJsZUNvbnRl bnRSZWN0ID0gY2FsY3VsYXRlVmlzaWJsZUNvbnRlbnRSZWN0KCppdCk7Ci0gICAgICAgICAgICBp dC0+c2V0VmlzaWJsZUNvbnRlbnRSZWN0KHZpc2libGVDb250ZW50UmVjdCk7Ci0gICAgICAgIH0K LSAgICB9Ci19Ci0KIHZvaWQgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJh bnNmb3JtcyhMYXllckNocm9taXVtKiByb290TGF5ZXIsIGNvbnN0IEludFNpemUmIGRldmljZVZp ZXdwb3J0U2l6ZSwgZmxvYXQgZGV2aWNlU2NhbGVGYWN0b3IsIGludCBtYXhUZXh0dXJlU2l6ZSwg VmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+JiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KQog ewogICAgIEludFJlY3QgdG90YWxEcmF3YWJsZUNvbnRlbnRSZWN0OwpAQCAtODI0LDE2ICs4MTgs NiBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMo Q0NMYXllckltcGwqIHJvb3RMYXllciwgY29ucwogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJvb3RMYXllci0+cmVuZGVyU3VyZmFjZSgpLT5s YXllckxpc3QoKSwgbGF5ZXJTb3J0ZXIsIG1heFRleHR1cmVTaXplLCBkZXZpY2VTY2FsZUZhY3Rv ciwgdG90YWxEcmF3YWJsZUNvbnRlbnRSZWN0KTsKIH0KIAotdm9pZCBDQ0xheWVyVHJlZUhvc3RD b21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ ID4mIHJlbmRlclN1cmZhY2VMYXllckxpc3QpCi17Ci0gICAgY2FsY3VsYXRlVmlzaWJsZVJlY3Rz SW50ZXJuYWw8TGF5ZXJDaHJvbWl1bSwgVmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+LCBS ZW5kZXJTdXJmYWNlQ2hyb21pdW0+KHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotfQotCi12b2lk IENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKFZlY3RvcjxDQ0xh eWVySW1wbCo+JiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KQotewotICAgIGNhbGN1bGF0ZVZpc2li bGVSZWN0c0ludGVybmFsPENDTGF5ZXJJbXBsLCBWZWN0b3I8Q0NMYXllckltcGwqPiwgQ0NSZW5k ZXJTdXJmYWNlPihyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLX0KLQogc3RhdGljIGJvb2wgcG9p bnRIaXRzUmVjdChjb25zdCBJbnRQb2ludCYgdmlld3BvcnRQb2ludCwgY29uc3QgV2ViVHJhbnNm b3JtYXRpb25NYXRyaXgmIGxvY2FsU3BhY2VUb1NjcmVlblNwYWNlVHJhbnNmb3JtLCBGbG9hdFJl Y3QgbG9jYWxTcGFjZVJlY3QpCiB7CiAgICAgLy8gSWYgdGhlIHRyYW5zZm9ybSBpcyBub3QgaW52 ZXJ0aWJsZSwgdGhlbiBhc3N1bWUgdGhhdCB0aGlzIHBvaW50IGRvZXNuJ3QgaGl0IHRoaXMgcmVj dC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L2NjL0NDTGF5ZXJUcmVlSG9zdENvbW1vbi5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0Q29tbW9uLmgKaW5kZXggNGU5NjkwNGE2 Nzc3MjQ0NDQyMTMxZTI5ODc5YWZiNmNkZTNlZmFhYS4uYWE3NTEzYjI5NDc1ODMwMTg2OThiNWI3 MDVhODA5MTk2MTZkYTI3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0Q29tbW9uLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0Q29tbW9u LmgKQEAgLTQ0LDkgKzQ0LDYgQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIGNhbGN1bGF0ZURy YXdUcmFuc2Zvcm1zKExheWVyQ2hyb21pdW0qIHJvb3RMYXllciwgY29uc3QgSW50U2l6ZSYgZGV2 aWNlVmlld3BvcnRTaXplLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3RvciwgaW50IG1heFRleHR1cmVT aXplLCBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ID4mIHJlbmRlclN1cmZhY2VMYXllckxp c3QpOwogICAgIHN0YXRpYyB2b2lkIGNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zKENDTGF5ZXJJbXBs KiByb290TGF5ZXIsIGNvbnN0IEludFNpemUmIGRldmljZVZpZXdwb3J0U2l6ZSwgZmxvYXQgZGV2 aWNlU2NhbGVGYWN0b3IsIENDTGF5ZXJTb3J0ZXIqLCBpbnQgbWF4VGV4dHVyZVNpemUsIFZlY3Rv cjxDQ0xheWVySW1wbCo+JiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKIAotICAgIHN0YXRpYyB2 b2lkIGNhbGN1bGF0ZVZpc2libGVSZWN0cyhWZWN0b3I8Q0NMYXllckltcGwqPiYgcmVuZGVyU3Vy ZmFjZUxheWVyTGlzdCk7Ci0gICAgc3RhdGljIHZvaWQgY2FsY3VsYXRlVmlzaWJsZVJlY3RzKFZl Y3RvcjxSZWZQdHI8TGF5ZXJDaHJvbWl1bT4gPiYgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7Ci0K ICAgICAvLyBQZXJmb3JtcyBoaXQgdGVzdGluZyBmb3IgYSBnaXZlbiByZW5kZXJTdXJmYWNlTGF5 ZXJMaXN0LgogICAgIHN0YXRpYyBDQ0xheWVySW1wbCogZmluZExheWVyVGhhdElzSGl0QnlQb2lu dChjb25zdCBJbnRQb2ludCYgdmlld3BvcnRQb2ludCwgVmVjdG9yPENDTGF5ZXJJbXBsKj4mIHJl bmRlclN1cmZhY2VMYXllckxpc3QpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3RJbXBsLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdElt cGwuY3BwCmluZGV4IDQ2ZWRjYzBhODAxNDRlMmNjNzc0N2FhMTk2NmVlNzQ5YzU4YTkxZDQuLjhh YjExYzg4ZjUzMGY3NzY0NmFiODJkOTBhNjQwZmE0YzNiNDcyYTEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdElt cGwuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDTGF5ZXJUcmVlSG9zdEltcGwuY3BwCkBAIC0yNjAsNyArMjYwLDYgQEAgdm9pZCBDQ0xheWVy VHJlZUhvc3RJbXBsOjpjYWxjdWxhdGVSZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KENDTGF5ZXJMaXN0 JiByZW5kZXJTdXIKICAgICB7CiAgICAgICAgIFRSQUNFX0VWRU5UMCgiY2MiLCAiQ0NMYXllclRy ZWVIb3N0SW1wbDo6Y2FsY0RyYXdFdGMiKTsKICAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9u OjpjYWxjdWxhdGVEcmF3VHJhbnNmb3JtcyhtX3Jvb3RMYXllckltcGwuZ2V0KCksIGRldmljZVZp ZXdwb3J0U2l6ZSgpLCBtX2RldmljZVNjYWxlRmFjdG9yLCAmbV9sYXllclNvcnRlciwgbGF5ZXJS ZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNlTGF5ZXJM aXN0KTsKLSAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVj dHMocmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7CiAKICAgICAgICAgdHJhY2tEYW1hZ2VGb3JBbGxT dXJmYWNlcyhtX3Jvb3RMYXllckltcGwuZ2V0KCksIHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwog ICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NEYW1hZ2VU cmFja2VyVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDRGFtYWdlVHJh Y2tlclRlc3QuY3BwCmluZGV4IGY5ZWVjZGI3NTk3ZTUzOTE5MDM3OWI0NDc3ZWU4Njk3NDFjMjVl OTcuLjZhYjY3OGQyM2U0MDVhOWNhYzkxYWY0NzY0YWRjMjA2NDkxNDdiYTEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NEYW1hZ2VUcmFja2VyVGVzdC5jcHAKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0RhbWFnZVRyYWNrZXJUZXN0LmNwcApA QCAtNTUsNyArNTUsNiBAQCB2b2lkIGV4ZWN1dGVDYWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0FuZFZp c2liaWxpdHkoQ0NMYXllckltcGwqIHJvb3QsIFZlY3RvcjxDQ0xheQogICAgIEFTU0VSVF9GQUxT RShyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0LnNpemUoKSk7CiAKICAgICBDQ0xheWVyVHJlZUhvc3RD b21tb246OmNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zKHJvb3QsIHJvb3QtPmJvdW5kcygpLCAxLCAm bGF5ZXJTb3J0ZXIsIGR1bW15TWF4VGV4dHVyZVNpemUsIHJlbmRlclN1cmZhY2VMYXllckxpc3Qp OwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKHJlbmRl clN1cmZhY2VMYXllckxpc3QpOwogfQogCiB2b2lkIGNsZWFyRGFtYWdlRm9yQWxsU3VyZmFjZXMo Q0NMYXllckltcGwqIGxheWVyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9DQ0xheWVySXRlcmF0b3JUZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVz dHMvQ0NMYXllckl0ZXJhdG9yVGVzdC5jcHAKaW5kZXggYThkYjM2NzhmZjFjOWNiMDMyOWE5Yjhi ZTlkNDYyOWRhODcyYTU3OC4uZWUzNWE2NDYzMmQyNzAyYmM2MmU2NTIxNGUzMWZkODk4YjUxNGZj ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVySXRlcmF0 b3JUZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJJdGVy YXRvclRlc3QuY3BwCkBAIC0xNDgsNyArMTQ4LDYgQEAgVEVTVChDQ0xheWVySXRlcmF0b3JUZXN0 LCBzaW1wbGVUcmVlKQogCiAgICAgVmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+IHJlbmRl clN1cmZhY2VMYXllckxpc3Q7CiAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVE cmF3VHJhbnNmb3Jtcyhyb290TGF5ZXIuZ2V0KCksIHJvb3RMYXllci0+Ym91bmRzKCksIDEsIDI1 NiwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7Ci0gICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpj YWxjdWxhdGVWaXNpYmxlUmVjdHMocmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7CiAKICAgICBpdGVy YXRlQmFja1RvRnJvbnQoJnJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogICAgIEVYUEVDVF9DT1VO VChyb290TGF5ZXIsIDAsIC0xLCAxKTsKQEAgLTE5MSw3ICsxOTAsNiBAQCBURVNUKENDTGF5ZXJJ dGVyYXRvclRlc3QsIGNvbXBsZXhUcmVlKQogCiAgICAgVmVjdG9yPFJlZlB0cjxMYXllckNocm9t aXVtPiA+IHJlbmRlclN1cmZhY2VMYXllckxpc3Q7CiAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9u OjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtcyhyb290TGF5ZXIuZ2V0KCksIHJvb3RMYXllci0+Ym91 bmRzKCksIDEsIDI1NiwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7Ci0gICAgQ0NMYXllclRyZWVI b3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMocmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7 CiAKICAgICBpdGVyYXRlQmFja1RvRnJvbnQoJnJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogICAg IEVYUEVDVF9DT1VOVChyb290TGF5ZXIsIDAsIC0xLCAxKTsKQEAgLTI0Nyw3ICsyNDUsNiBAQCBU RVNUKENDTGF5ZXJJdGVyYXRvclRlc3QsIGNvbXBsZXhUcmVlTXVsdGlTdXJmYWNlKQogCiAgICAg VmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+IHJlbmRlclN1cmZhY2VMYXllckxpc3Q7CiAg ICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtcyhyb290TGF5 ZXIuZ2V0KCksIHJvb3RMYXllci0+Ym91bmRzKCksIDEsIDI1NiwgcmVuZGVyU3VyZmFjZUxheWVy TGlzdCk7Ci0gICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMo cmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7CiAKICAgICBpdGVyYXRlQmFja1RvRnJvbnQoJnJlbmRl clN1cmZhY2VMYXllckxpc3QpOwogICAgIEVYUEVDVF9DT1VOVChyb290TGF5ZXIsIDAsIC0xLCAx KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVI b3N0Q29tbW9uVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJU cmVlSG9zdENvbW1vblRlc3QuY3BwCmluZGV4IGFjMDRiNTA1ZWY5MTE5MTU4MGNmNWY1ZWIyNGQ1 ODQzN2M4OTA2ZTYuLjI3ZTdmNzUzMmUwOGY3ZGM4ZjYzN2E2MjA5NWI2ZDE5YTg3NWM0NmMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0Q29t bW9uVGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJl ZUhvc3RDb21tb25UZXN0LmNwcApAQCAtNzksNyArNzksNiBAQCB2b2lkIGV4ZWN1dGVDYWxjdWxh dGVEcmF3VHJhbnNmb3Jtc0FuZFZpc2liaWxpdHkoTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKQog ICAgIC8vIFdlIGFyZSBwcm9iYWJseSBub3QgdGVzdGluZyB3aGF0IGlzIGludGVuZGVkIGlmIHRo ZSByb290TGF5ZXIgYm91bmRzIGFyZSBlbXB0eS4KICAgICBBU1NFUlQoIXJvb3RMYXllci0+Ym91 bmRzKCkuaXNFbXB0eSgpKTsKICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZURy YXdUcmFuc2Zvcm1zKHJvb3RMYXllciwgcm9vdExheWVyLT5ib3VuZHMoKSwgMSwgZHVtbXlNYXhU ZXh0dXJlU2l6ZSwgZHVtbXlSZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLSAgICBDQ0xheWVyVHJl ZUhvc3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhkdW1teVJlbmRlclN1cmZhY2VMYXll ckxpc3QpOwogfQogCiB2b2lkIGV4ZWN1dGVDYWxjdWxhdGVEcmF3VHJhbnNmb3Jtc0FuZFZpc2li aWxpdHkoQ0NMYXllckltcGwqIHJvb3RMYXllcikKQEAgLTkzLDcgKzkyLDYgQEAgdm9pZCBleGVj dXRlQ2FsY3VsYXRlRHJhd1RyYW5zZm9ybXNBbmRWaXNpYmlsaXR5KENDTGF5ZXJJbXBsKiByb290 TGF5ZXIpCiAgICAgLy8gV2UgYXJlIHByb2JhYmx5IG5vdCB0ZXN0aW5nIHdoYXQgaXMgaW50ZW5k ZWQgaWYgdGhlIHJvb3RMYXllciBib3VuZHMgYXJlIGVtcHR5LgogICAgIEFTU0VSVCghcm9vdExh eWVyLT5ib3VuZHMoKS5pc0VtcHR5KCkpOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2Fs Y3VsYXRlRHJhd1RyYW5zZm9ybXMocm9vdExheWVyLCByb290TGF5ZXItPmJvdW5kcygpLCAxLCAw LCBkdW1teU1heFRleHR1cmVTaXplLCBkdW1teVJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAg IENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKGR1bW15UmVuZGVy U3VyZmFjZUxheWVyTGlzdCk7CiB9CiAKIFdlYlRyYW5zZm9ybWF0aW9uTWF0cml4IHJlbW92ZTNE Q29tcG9uZW50T2ZNYXRyaXgoY29uc3QgV2ViVHJhbnNmb3JtYXRpb25NYXRyaXgmIG1hdCkKQEAg LTY1Nyw3ICs2NTUsNiBAQCBURVNUKENDTGF5ZXJUcmVlSG9zdENvbW1vblRlc3QsIHZlcmlmeVJl bmRlclN1cmZhY2VMaXN0Rm9yUmVuZGVyU3VyZmFjZVdpdGhDbGlwcAogICAgIFZlY3RvcjxSZWZQ dHI8TGF5ZXJDaHJvbWl1bT4gPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1t eU1heFRleHR1cmVTaXplID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3Vs YXRlRHJhd1RyYW5zZm9ybXMocGFyZW50LmdldCgpLCBwYXJlbnQtPmJvdW5kcygpLCAxLCBkdW1t eU1heFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLSAgICBDQ0xheWVyVHJl ZUhvc3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0 KTsKIAogICAgIC8vIFRoZSBjaGlsZCBsYXllcidzIGNvbnRlbnQgaXMgZW50aXJlbHkgb3V0c2lk ZSB0aGUgcGFyZW50J3MgY2xpcCByZWN0LCBzbyB0aGUgaW50ZXJtZWRpYXRlCiAgICAgLy8gcmVu ZGVyIHN1cmZhY2Ugc2hvdWxkIG5vdCBiZSBsaXN0ZWQgaGVyZSwgZXZlbiBpZiBpdCB3YXMgZm9y Y2VkIHRvIGJlIGNyZWF0ZWQuIFJlbmRlciBzdXJmYWNlcyB3aXRob3V0IGNoaWxkcmVuIG9yIHZp c2libGUKQEAgLTY4NSw3ICs2ODIsNiBAQCBURVNUKENDTGF5ZXJUcmVlSG9zdENvbW1vblRlc3Qs IHZlcmlmeVJlbmRlclN1cmZhY2VMaXN0Rm9yVHJhbnNwYXJlbnRDaGlsZCkKICAgICBWZWN0b3I8 UmVmUHRyPExheWVyQ2hyb21pdW0+ID4gcmVuZGVyU3VyZmFjZUxheWVyTGlzdDsKICAgICBpbnQg ZHVtbXlNYXhUZXh0dXJlU2l6ZSA9IDUxMjsKICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNh bGN1bGF0ZURyYXdUcmFuc2Zvcm1zKHBhcmVudC5nZXQoKSwgcGFyZW50LT5ib3VuZHMoKSwgMSwg ZHVtbXlNYXhUZXh0dXJlU2l6ZSwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7Ci0gICAgQ0NMYXll clRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMocmVuZGVyU3VyZmFjZUxheWVy TGlzdCk7CiAKICAgICAvLyBTaW5jZSB0aGUgbGF5ZXIgaXMgdHJhbnNwYXJlbnQsIHJlbmRlclN1 cmZhY2UxLT5yZW5kZXJTdXJmYWNlKCkgc2hvdWxkIG5vdCBoYXZlIGdvdHRlbiBhZGRlZCBhbnl3 aGVyZS4KICAgICAvLyBBbHNvLCB0aGUgZHJhd2FibGUgY29udGVudCByZWN0IHNob3VsZCBub3Qg aGF2ZSBiZWVuIGV4dGVuZGVkIGJ5IHRoZSBjaGlsZHJlbi4KQEAgLTEzNDEsOCArMTMzNyw2IEBA IFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9uVGVzdCwgdmVyaWZ5Q2xpcFJlY3RDdWxsc1JlbmRl clN1cmZhY2VzKQogICAgIFZlY3RvcjxSZWZQdHI8TGF5ZXJDaHJvbWl1bT4gPiByZW5kZXJTdXJm YWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1teU1heFRleHR1cmVTaXplID0gNTEyOwogICAgIEND TGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMocGFyZW50LmdldCgp LCBwYXJlbnQtPmJvdW5kcygpLCAxLCBkdW1teU1heFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNl TGF5ZXJMaXN0KTsKLSAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVS ZWN0cyhyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLQogCiAgICAgQVNTRVJUX0VRKDJVLCByZW5k ZXJTdXJmYWNlTGF5ZXJMaXN0LnNpemUoKSk7CiAgICAgRVhQRUNUX0VRKHBhcmVudC0+aWQoKSwg cmVuZGVyU3VyZmFjZUxheWVyTGlzdFswXS0+aWQoKSk7CkBAIC0xNDU0LDcgKzE0NDgsNiBAQCBU RVNUKENDTGF5ZXJUcmVlSG9zdENvbW1vblRlc3QsIHZlcmlmeURyYXdhYmxlQ29udGVudFJlY3RG b3JMYXllcnMpCiAgICAgVmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+IHJlbmRlclN1cmZh Y2VMYXllckxpc3Q7CiAgICAgaW50IGR1bW15TWF4VGV4dHVyZVNpemUgPSA1MTI7CiAgICAgQ0NM YXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3JtcyhwYXJlbnQuZ2V0KCks IHBhcmVudC0+Ym91bmRzKCksIDEsIGR1bW15TWF4VGV4dHVyZVNpemUsIHJlbmRlclN1cmZhY2VM YXllckxpc3QpOwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJl Y3RzKHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogCiAgICAgRVhQRUNUX0lOVF9SRUNUX0VRKElu dFJlY3QoSW50UG9pbnQoNSwgNSksIEludFNpemUoMTAsIDEwKSksIGdyYW5kQ2hpbGQxLT5kcmF3 YWJsZUNvbnRlbnRSZWN0KCkpOwogICAgIEVYUEVDVF9JTlRfUkVDVF9FUShJbnRSZWN0KEludFBv aW50KDE1LCAxNSksIEludFNpemUoNSwgNSkpLCBncmFuZENoaWxkMy0+ZHJhd2FibGVDb250ZW50 UmVjdCgpKTsKQEAgLTE1MjAsNyArMTUxMyw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9u VGVzdCwgdmVyaWZ5Q2xpcFJlY3RJc1Byb3BhZ2F0ZWRDb3JyZWN0bHlUb1N1cmZhY2VzKQogICAg IFZlY3RvcjxSZWZQdHI8TGF5ZXJDaHJvbWl1bT4gPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0Owog ICAgIGludCBkdW1teU1heFRleHR1cmVTaXplID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENv bW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMocGFyZW50LmdldCgpLCBwYXJlbnQtPmJvdW5k cygpLCAxLCBkdW1teU1heFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLSAg ICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhyZW5kZXJTdXJm YWNlTGF5ZXJMaXN0KTsKIAogICAgIEFTU0VSVF9UUlVFKGdyYW5kQ2hpbGQxLT5yZW5kZXJTdXJm YWNlKCkpOwogICAgIEFTU0VSVF9UUlVFKGdyYW5kQ2hpbGQyLT5yZW5kZXJTdXJmYWNlKCkpOwpA QCAtMjE3MSw3ICsyMTYzLDYgQEAgVEVTVChDQ0xheWVyVHJlZUhvc3RDb21tb25UZXN0LCB2ZXJp ZnlCYWNrRmFjZUN1bGxpbmdXaXRoQW5pbWF0aW5nVHJhbnNmb3JtcykKICAgICBWZWN0b3I8UmVm UHRyPExheWVyQ2hyb21pdW0+ID4gcmVuZGVyU3VyZmFjZUxheWVyTGlzdDsKICAgICBpbnQgZHVt bXlNYXhUZXh0dXJlU2l6ZSA9IDUxMjsKICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1 bGF0ZURyYXdUcmFuc2Zvcm1zKHBhcmVudC5nZXQoKSwgcGFyZW50LT5ib3VuZHMoKSwgMSwgZHVt bXlNYXhUZXh0dXJlU2l6ZSwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7Ci0gICAgQ0NMYXllclRy ZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMocmVuZGVyU3VyZmFjZUxheWVyTGlz dCk7CiAKICAgICBFWFBFQ1RfRkFMU0UoY2hpbGQtPnJlbmRlclN1cmZhY2UoKSk7CiAgICAgRVhQ RUNUX1RSVUUoYW5pbWF0aW5nU3VyZmFjZS0+cmVuZGVyU3VyZmFjZSgpKTsKQEAgLTIyOTIsNyAr MjI4Myw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9uVGVzdCwgdmVyaWZ5SGl0VGVzdGlu Z0ZvclNpbmdsZUxheWVyKQogICAgIFZlY3RvcjxDQ0xheWVySW1wbCo+IHJlbmRlclN1cmZhY2VM YXllckxpc3Q7CiAgICAgaW50IGR1bW15TWF4VGV4dHVyZVNpemUgPSA1MTI7CiAgICAgQ0NMYXll clRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtcyhyb290LmdldCgpLCByb290 LT5ib3VuZHMoKSwgMSwgMCwgZHVtbXlNYXhUZXh0dXJlU2l6ZSwgcmVuZGVyU3VyZmFjZUxheWVy TGlzdCk7Ci0gICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMo cmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7CiAKICAgICAvLyBTYW5pdHkgY2hlY2sgdGhlIHNjZW5h cmlvIHdlIGp1c3QgY3JlYXRlZC4KICAgICBBU1NFUlRfRVEoMXUsIHJlbmRlclN1cmZhY2VMYXll ckxpc3Quc2l6ZSgpKTsKQEAgLTIzNDIsNyArMjMzMiw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0 Q29tbW9uVGVzdCwgdmVyaWZ5SGl0VGVzdGluZ0ZvclVuaW52ZXJ0aWJsZVRyYW5zZm9ybSkKICAg ICBWZWN0b3I8Q0NMYXllckltcGwqPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBk dW1teU1heFRleHR1cmVTaXplID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2Fs Y3VsYXRlRHJhd1RyYW5zZm9ybXMocm9vdC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEsIDAsIGR1 bW15TWF4VGV4dHVyZVNpemUsIHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIENDTGF5ZXJU cmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VMYXllckxp c3QpOwogCiAgICAgLy8gU2FuaXR5IGNoZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNyZWF0ZWQu CiAgICAgQVNTRVJUX0VRKDF1LCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0LnNpemUoKSk7CkBAIC0y Mzk3LDcgKzIzODYsNiBAQCBURVNUKENDTGF5ZXJUcmVlSG9zdENvbW1vblRlc3QsIHZlcmlmeUhp dFRlc3RpbmdGb3JTaW5nbGVQb3NpdGlvbmVkTGF5ZXIpCiAgICAgVmVjdG9yPENDTGF5ZXJJbXBs Kj4gcmVuZGVyU3VyZmFjZUxheWVyTGlzdDsKICAgICBpbnQgZHVtbXlNYXhUZXh0dXJlU2l6ZSA9 IDUxMjsKICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1z KHJvb3QuZ2V0KCksIHJvb3QtPmJvdW5kcygpLCAxLCAwLCBkdW1teU1heFRleHR1cmVTaXplLCBy ZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLSAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1 bGF0ZVZpc2libGVSZWN0cyhyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKIAogICAgIC8vIFNhbml0 eSBjaGVjayB0aGUgc2NlbmFyaW8gd2UganVzdCBjcmVhdGVkLgogICAgIEFTU0VSVF9FUSgxdSwg cmVuZGVyU3VyZmFjZUxheWVyTGlzdC5zaXplKCkpOwpAQCAtMjQ0NSw3ICsyNDMzLDYgQEAgVEVT VChDQ0xheWVyVHJlZUhvc3RDb21tb25UZXN0LCB2ZXJpZnlIaXRUZXN0aW5nRm9yU2luZ2xlUm90 YXRlZExheWVyKQogICAgIFZlY3RvcjxDQ0xheWVySW1wbCo+IHJlbmRlclN1cmZhY2VMYXllckxp c3Q7CiAgICAgaW50IGR1bW15TWF4VGV4dHVyZVNpemUgPSA1MTI7CiAgICAgQ0NMYXllclRyZWVI b3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNmb3Jtcyhyb290LmdldCgpLCByb290LT5ib3Vu ZHMoKSwgMSwgMCwgZHVtbXlNYXhUZXh0dXJlU2l6ZSwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdCk7 Ci0gICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVWaXNpYmxlUmVjdHMocmVuZGVy U3VyZmFjZUxheWVyTGlzdCk7CiAKICAgICAvLyBTYW5pdHkgY2hlY2sgdGhlIHNjZW5hcmlvIHdl IGp1c3QgY3JlYXRlZC4KICAgICBBU1NFUlRfRVEoMXUsIHJlbmRlclN1cmZhY2VMYXllckxpc3Qu c2l6ZSgpKTsKQEAgLTI1MDIsNyArMjQ4OSw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9u VGVzdCwgdmVyaWZ5SGl0VGVzdGluZ0ZvclNpbmdsZVBlcnNwZWN0aXZlTGF5ZXIpCiAgICAgVmVj dG9yPENDTGF5ZXJJbXBsKj4gcmVuZGVyU3VyZmFjZUxheWVyTGlzdDsKICAgICBpbnQgZHVtbXlN YXhUZXh0dXJlU2l6ZSA9IDUxMjsKICAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0 ZURyYXdUcmFuc2Zvcm1zKHJvb3QuZ2V0KCksIHJvb3QtPmJvdW5kcygpLCAxLCAwLCBkdW1teU1h eFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsKLSAgICBDQ0xheWVyVHJlZUhv c3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhyZW5kZXJTdXJmYWNlTGF5ZXJMaXN0KTsK IAogICAgIC8vIFNhbml0eSBjaGVjayB0aGUgc2NlbmFyaW8gd2UganVzdCBjcmVhdGVkLgogICAg IEFTU0VSVF9FUSgxdSwgcmVuZGVyU3VyZmFjZUxheWVyTGlzdC5zaXplKCkpOwpAQCAtMjU2Nyw3 ICsyNTUzLDYgQEAgVEVTVChDQ0xheWVyVHJlZUhvc3RDb21tb25UZXN0LCB2ZXJpZnlIaXRUZXN0 aW5nRm9yU2luZ2xlTGF5ZXJXaXRoU2NhbGVkQ29udGVudHMKICAgICBWZWN0b3I8Q0NMYXllcklt cGwqPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1teU1heFRleHR1cmVTaXpl ID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9y bXMocm9vdC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEsIDAsIGR1bW15TWF4VGV4dHVyZVNpemUs IHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2Fs Y3VsYXRlVmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogCiAgICAgLy8gU2Fu aXR5IGNoZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNyZWF0ZWQuCiAgICAgLy8gVGhlIHZpc2li bGVDb250ZW50UmVjdCBmb3IgdGVzdExheWVyIGlzIGFjdHVhbGx5IDEwMHgxMDAsIGV2ZW4gdGhv dWdoIGl0cyBsYXlvdXQgc2l6ZSBpcyA1MHg1MCwgcG9zaXRpb25lZCBhdCAyNXgyNS4KQEAgLTI2 MzIsNyArMjYxNyw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9uVGVzdCwgdmVyaWZ5SGl0 VGVzdGluZ0ZvclNpbXBsZUNsaXBwZWRMYXllcikKICAgICBWZWN0b3I8Q0NMYXllckltcGwqPiBy ZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1teU1heFRleHR1cmVTaXplID0gNTEy OwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMocm9v dC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEsIDAsIGR1bW15TWF4VGV4dHVyZVNpemUsIHJlbmRl clN1cmZhY2VMYXllckxpc3QpOwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRl VmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogCiAgICAgLy8gU2FuaXR5IGNo ZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNyZWF0ZWQuCiAgICAgQVNTRVJUX0VRKDF1LCByZW5k ZXJTdXJmYWNlTGF5ZXJMaXN0LnNpemUoKSk7CkBAIC0yNzIzLDcgKzI3MDcsNiBAQCBURVNUKEND TGF5ZXJUcmVlSG9zdENvbW1vblRlc3QsIHZlcmlmeUhpdFRlc3RpbmdGb3JNdWx0aUNsaXBwZWRS b3RhdGVkTGF5ZXIpCiAgICAgVmVjdG9yPENDTGF5ZXJJbXBsKj4gcmVuZGVyU3VyZmFjZUxheWVy TGlzdDsKICAgICBpbnQgZHVtbXlNYXhUZXh0dXJlU2l6ZSA9IDUxMjsKICAgICBDQ0xheWVyVHJl ZUhvc3RDb21tb246OmNhbGN1bGF0ZURyYXdUcmFuc2Zvcm1zKHJvb3QuZ2V0KCksIHJvb3QtPmJv dW5kcygpLCAxLCAwLCBkdW1teU1heFRleHR1cmVTaXplLCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0 KTsKLSAgICBDQ0xheWVyVHJlZUhvc3RDb21tb246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhyZW5k ZXJTdXJmYWNlTGF5ZXJMaXN0KTsKIAogICAgIC8vIFNhbml0eSBjaGVjayB0aGUgc2NlbmFyaW8g d2UganVzdCBjcmVhdGVkLgogICAgIC8vIFRoZSBncmFuZENoaWxkIGlzIGV4cGVjdGVkIHRvIGNy ZWF0ZSBhIHJlbmRlclN1cmZhY2UgYmVjYXVzZSBpdCBtYXNrc1RvQm91bmRzIGFuZCBpcyBub3Qg YXhpcyBhbGlnbmVkLgpAQCAtMjgwNiw3ICsyNzg5LDYgQEAgVEVTVChDQ0xheWVyVHJlZUhvc3RD b21tb25UZXN0LCB2ZXJpZnlIaXRUZXN0aW5nRm9yTm9uQ2xpcHBpbmdJbnRlcm1lZGlhdGVMYXll cikKICAgICBWZWN0b3I8Q0NMYXllckltcGwqPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAg IGludCBkdW1teU1heFRleHR1cmVTaXplID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1v bjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMocm9vdC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEs IDAsIGR1bW15TWF4VGV4dHVyZVNpemUsIHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIEND TGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VM YXllckxpc3QpOwogCiAgICAgLy8gU2FuaXR5IGNoZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNy ZWF0ZWQuCiAgICAgQVNTRVJUX0VRKDF1LCByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0LnNpemUoKSk7 CkBAIC0yODg3LDcgKzI4NjksNiBAQCBURVNUKENDTGF5ZXJUcmVlSG9zdENvbW1vblRlc3QsIHZl cmlmeUhpdFRlc3RpbmdGb3JNdWx0aXBsZUxheWVycykKICAgICBWZWN0b3I8Q0NMYXllckltcGwq PiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1teU1heFRleHR1cmVTaXplID0g NTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMo cm9vdC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEsIDAsIGR1bW15TWF4VGV4dHVyZVNpemUsIHJl bmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3Vs YXRlVmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogCiAgICAgLy8gU2FuaXR5 IGNoZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNyZWF0ZWQuCiAgICAgQVNTRVJUX1RSVUUoY2hp bGQxKTsKQEAgLTI5OTYsNyArMjk3Nyw2IEBAIFRFU1QoQ0NMYXllclRyZWVIb3N0Q29tbW9uVGVz dCwgdmVyaWZ5SGl0VGVzdGluZ0Zvck11bHRpcGxlTGF5ZXJMaXN0cykKICAgICBWZWN0b3I8Q0NM YXllckltcGwqPiByZW5kZXJTdXJmYWNlTGF5ZXJMaXN0OwogICAgIGludCBkdW1teU1heFRleHR1 cmVTaXplID0gNTEyOwogICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1Ry YW5zZm9ybXMocm9vdC5nZXQoKSwgcm9vdC0+Ym91bmRzKCksIDEsIDAsIGR1bW15TWF4VGV4dHVy ZVNpemUsIHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwotICAgIENDTGF5ZXJUcmVlSG9zdENvbW1v bjo6Y2FsY3VsYXRlVmlzaWJsZVJlY3RzKHJlbmRlclN1cmZhY2VMYXllckxpc3QpOwogCiAgICAg Ly8gU2FuaXR5IGNoZWNrIHRoZSBzY2VuYXJpbyB3ZSBqdXN0IGNyZWF0ZWQuCiAgICAgQVNTRVJU X1RSVUUoY2hpbGQxKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NPY2NsdXNpb25UcmFja2VyVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3Rz L0NDT2NjbHVzaW9uVHJhY2tlclRlc3QuY3BwCmluZGV4IDRlNWY5ZGM4OGYzZjgxNDk5MDVkNjhm YTQ3M2QyNjc0ODQ0ZGJjMTkuLjBmMDZjYjlmNWFhYjAzOTk5NGNkOWYzMGQxMWI3ZWZhN2I2ZmY3 N2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NPY2NsdXNpb25U cmFja2VyVGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ09jY2x1 c2lvblRyYWNrZXJUZXN0LmNwcApAQCAtMjYxLDcgKzI2MSw2IEBAIHByb3RlY3RlZDoKICAgICAg ICAgQVNTRVJUKCFyb290LT5yZW5kZXJTdXJmYWNlKCkpOwogCiAgICAgICAgIENDTGF5ZXJUcmVl SG9zdENvbW1vbjo6Y2FsY3VsYXRlRHJhd1RyYW5zZm9ybXMocm9vdCwgcm9vdC0+Ym91bmRzKCks IDEsICZsYXllclNvcnRlciwgZHVtbXlNYXhUZXh0dXJlU2l6ZSwgbV9yZW5kZXJTdXJmYWNlTGF5 ZXJMaXN0SW1wbCk7Ci0gICAgICAgIENDTGF5ZXJUcmVlSG9zdENvbW1vbjo6Y2FsY3VsYXRlVmlz aWJsZVJlY3RzKG1fcmVuZGVyU3VyZmFjZUxheWVyTGlzdEltcGwpOwogCiAgICAgICAgIG1fbGF5 ZXJJdGVyYXRvciA9IG1fbGF5ZXJJdGVyYXRvckJlZ2luID0gVHlwZXM6OkxheWVySXRlcmF0b3I6 OmJlZ2luKCZtX3JlbmRlclN1cmZhY2VMYXllckxpc3RJbXBsKTsKICAgICB9CkBAIC0yNzQsNyAr MjczLDYgQEAgcHJvdGVjdGVkOgogICAgICAgICBBU1NFUlQoIXJvb3QtPnJlbmRlclN1cmZhY2Uo KSk7CiAKICAgICAgICAgQ0NMYXllclRyZWVIb3N0Q29tbW9uOjpjYWxjdWxhdGVEcmF3VHJhbnNm b3Jtcyhyb290LCByb290LT5ib3VuZHMoKSwgMSwgZHVtbXlNYXhUZXh0dXJlU2l6ZSwgbV9yZW5k ZXJTdXJmYWNlTGF5ZXJMaXN0Q2hyb21pdW0pOwotICAgICAgICBDQ0xheWVyVHJlZUhvc3RDb21t b246OmNhbGN1bGF0ZVZpc2libGVSZWN0cyhtX3JlbmRlclN1cmZhY2VMYXllckxpc3RDaHJvbWl1 bSk7CiAKICAgICAgICAgbV9sYXllckl0ZXJhdG9yID0gbV9sYXllckl0ZXJhdG9yQmVnaW4gPSBU eXBlczo6TGF5ZXJJdGVyYXRvcjo6YmVnaW4oJm1fcmVuZGVyU3VyZmFjZUxheWVyTGlzdENocm9t aXVtKTsKICAgICB9Cg==