224987 2021-04-23 10:53:11 -0700 experiment with averaging sampling colors across the top of the page as the scroll area background 2021-05-18 16:45:32 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 225167 225942 1 hi hi bdakin cdumez changseok darin esprehn+autocc ews-watchlist fred.wang glenn hi kangil.han kondapallykalyan pdr sam simon.fraser thorton webkit-bug-importer wenson_hsieh oldest_to_newest 1753641 0 hi 2021-04-23 10:53:11 -0700 instead of relying on the CSS `background-color` of the `<html>`/`<body>` we maybe might want to sample colors from the top of the page, such as for if the page has an image/gradient background 1753642 1 hi 2021-04-23 10:53:31 -0700 <rdar://problem/76251889> 1753652 2 426926 hi 2021-04-23 11:03:10 -0700 Created attachment 426926 Patch 1753654 3 426928 hi 2021-04-23 11:06:39 -0700 Created attachment 426928 Patch fix style issue 1753700 4 426928 darin 2021-04-23 13:16:44 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review > Source/WebCore/dom/Document.cpp:3913 > + IntSize size(1, 1); Not sure that 1x1 is the best way to do this. We want to use actual pixels, which are not necessarily 1x1. On a 2x display this rectangle covers 4 device pixels. Is this what we want? > Source/WebCore/dom/Document.cpp:3917 > + constexpr OptionSet<HitTestRequest::RequestType> hitTestRequestTypes { HitTestRequest::ReadOnly, HitTestRequest::DisallowUserAgentShadowContent }; > + HitTestResult hitTestResult(location); > + hitTest(hitTestRequestTypes, hitTestResult); Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. > Source/WebCore/dom/Document.cpp:3927 > + auto snapshotData = snapshot->getImageData(AlphaPremultiplication::Unpremultiplied, IntRect(IntPoint::zero(), size)); The getImageData API is designed for use from JavaScript, with quite a bit of inefficiency just to be compatible with JavaScript idioms. Here internally in WebKit I am sure we can come up with something simpler that doesn’t require memory allocation. 1753825 5 426928 hi 2021-04-23 20:24:42 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review >> Source/WebCore/dom/Document.cpp:3913 >> + IntSize size(1, 1); > > Not sure that 1x1 is the best way to do this. We want to use actual pixels, which are not necessarily 1x1. On a 2x display this rectangle covers 4 device pixels. Is this what we want? Good point. I would like to just keep it as single physical pixels, as I'm not looking at more than one pixel. I'll look into if I can make `snapshotFrameRect` take a `FloatRect` instead :) >> Source/WebCore/dom/Document.cpp:3917 >> + hitTest(hitTestRequestTypes, hitTestResult); > > Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. > > If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. >> Source/WebCore/dom/Document.cpp:3927 >> + auto snapshotData = snapshot->getImageData(AlphaPremultiplication::Unpremultiplied, IntRect(IntPoint::zero(), size)); > > The getImageData API is designed for use from JavaScript, with quite a bit of inefficiency just to be compatible with JavaScript idioms. Here internally in WebKit I am sure we can come up with something simpler that doesn’t require memory allocation. I was hoping there was a better way than using `ImageData`. Do you happen to know of one of these better ways? I'm thinking that maybe `ImageBuffer::toBGRAData` might be an option. 1754002 6 426928 darin 2021-04-25 08:48:05 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review I’m OK with this as-is, but I think there is a lot that can be done to improve the implementation here. > Source/WebCore/dom/Document.cpp:3911 > + auto getPixelColorAtTopX = [&] (int x) -> Optional<SRGBA<uint8_t>> { We don’t use "get" in the names of these kinds of functions in WebKit. >>> Source/WebCore/dom/Document.cpp:3917 >>> + hitTest(hitTestRequestTypes, hitTestResult); >> >> Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. >> >> If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. > > Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. I suggest you factor this into a separate function with a name like isInFirstPartyFrame or something along those lines, to document more clearly what it’s doing. The hit testing won’t necessarily exactly match the painting, so it’s a tempting, but flawed concept on how to do this. I think there’s an alternative, more robust and fool proof approach where we pass arguments in that alter the behavior of the painting code rather than relying on the connection between painting code and hit testing code. The question in my mind is what we want to do instead of painting these third party frames into the single pixel we are trying to sample. Would we just not paint those frames? Then we might get the value of pixels the user would never see that would normally be covered by a third party frame. We could paint them in a special indicator color to help us know not to use the pixels. >>> Source/WebCore/dom/Document.cpp:3927 >>> + auto snapshotData = snapshot->getImageData(AlphaPremultiplication::Unpremultiplied, IntRect(IntPoint::zero(), size)); >> >> The getImageData API is designed for use from JavaScript, with quite a bit of inefficiency just to be compatible with JavaScript idioms. Here internally in WebKit I am sure we can come up with something simpler that doesn’t require memory allocation. > > I was hoping there was a better way than using `ImageData`. Do you happen to know of one of these better ways? I'm thinking that maybe `ImageBuffer::toBGRAData` might be an option. What we want is similar to what Image::singlePixelSolidColor does. That function is designed to detect an image that happens to be a single pixel solid color. Here we are intentionally creating an image buffer (intrinsically opaque, which is what "solid" means) that contains a single pixel and would like to know its color. I suppose ImageBuffer may be the only platform-independent interface we have for making GraphicsContext with a buffer that you can draw into. And certainly "drawing" is the way we find out the color of a pixel on the webpage. To reuse the code we already have maybe we would use use ImageBuffer::sinkIntoImage and then call Image:: singlePixelSolidColor on that image. If we want to optimize this further we could write an ImageBuffer::singlePixelColor function and have it do the sinkIntoImage/singlePixelSolidColor operations. This would make it easier to optimize later for specific types of ImageBuffer by making this a virtual function if needed. We could specialize it so it can do the work without necessarily creating an Image. But all of this seems a bit inefficient when repeated five times. Maybe we’d want to paint once into a buffer that was not a single pixel, and then sample the five pixels out of it? Anyway, I’m OK with the current code but I think these are worth considering. > Source/WebCore/dom/Document.cpp:3971 > + double redPercentDifference = fabs(snapshots[i].red - snapshots[i - 1].red) / 255.0; > + double greenPercentDifference = fabs(snapshots[i].green - snapshots[i - 1].green) / 255.0; > + double bluePercentDifference = fabs(snapshots[i].blue - snapshots[i - 1].blue) / 255.0; > + double alphaPercentDifference = fabs(snapshots[i].alpha - snapshots[i - 1].alpha) / 255.0; > + percentageDifferences[i - 1] = redPercentDifference + greenPercentDifference + bluePercentDifference + alphaPercentDifference; This is another example of something that needs a helper function. Writing it out like this without a named function doesn’t seem good. We’d want a function that takes two colors and returns the percentageDifference rather than 5 lines of code that does the math. I’m not sure why we call this "percent" since there is no 100 involved here. The word "percent" should really be reserved for things in the range of 0-100. Should think further on what the correct terminology for this is. Maybe discuss with Sam who has been thinking a lot about color terminology lately. > Source/WebCore/dom/Document.cpp:4000 > + uint32_t averageRed = 0; It’s strange to name something that will contain the sum of red channels "average". Typically "average" would refer to a mean, not to a sum. I would call this total, or sum. > Source/WebCore/dom/Document.cpp:4003 > + uint32_t averageAlpha = 0; I don’t think this will actually work. First of all, I’m not sure we have the right kind of code to actually draw into a buffer and give us alpha values. I’m pretty sure that the buffer starts with an opaque background and so the alpha will always be 1. If it wasn’t, not sure that a mean is the way we’d want to blend the alphas together. > Source/WebCore/dom/Document.cpp:4013 > + auto validSnapshotCount = nonMatchingColorIndex == numSnapshots + 1 ? numSnapshots : numSnapshots - 1; Would be clearer to make this count by incrementing each time we add in to the sums. But also, I suggest we write a separate function that computes the mean of a set of colors rather than writing it in-line here in this function. We can remove the non-matching color index from the array (and yes, move the items down to compact), and then pass this array of colors in to that function and let it do the work. That’s the kind of thing that makes the code readable. > Source/WebCore/dom/Document.cpp:4014 > + float convertToDecimal = validSnapshotCount * 255; We don’t want to use a verb to name a variable. I know this is a number we plan to use to divide to convert a sum into a float mean, but that doesn’t mean the number should be named "convert". If we are going to use this 4 times it’s better to make it something that we can use to multiply rather than divide, since multiplication is significantly more efficient than dividing. So it would be better to have this be: float multiplier = 1.0f / (validSnapshotCount * 255). > Source/WebCore/dom/Document.cpp:4015 > + m_sampledPageTopColor = makeFromComponentsClamping<SRGBA<float>>(averageRed / convertToDecimal, averageGreen / convertToDecimal, averageBlue / convertToDecimal, averageAlpha / convertToDecimal); We are doing the math correctly here, so no clamping is necessary. There’s no way that these mean color channel values will somehow be outside the 0-1 range. 1754004 7 darin 2021-04-25 08:49:15 -0700 Wait, where’s the testing for this new function? Please don’t land all this code without any tests! 1754005 8 426928 darin 2021-04-25 09:05:58 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review >>>> Source/WebCore/dom/Document.cpp:3917 >>>> + hitTest(hitTestRequestTypes, hitTestResult); >>> >>> Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. >>> >>> If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. >> >> Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. > > I suggest you factor this into a separate function with a name like isInFirstPartyFrame or something along those lines, to document more clearly what it’s doing. > > > The hit testing won’t necessarily exactly match the painting, so it’s a tempting, but flawed concept on how to do this. > > I think there’s an alternative, more robust and fool proof approach where we pass arguments in that alter the behavior of the painting code rather than relying on the connection between painting code and hit testing code. The question in my mind is what we want to do instead of painting these third party frames into the single pixel we are trying to sample. Would we just not paint those frames? Then we might get the value of pixels the user would never see that would normally be covered by a third party frame. We could paint them in a special indicator color to help us know not to use the pixels. Looking into third-party frame painting, I found mechanism that already exists (actually more than one, but this seemed the best) that could be used to do this with a little bit of refactoring and rearranging. There’s already something called SecurityOriginPaintPolicy that is passed in to FrameView::paintContents, but FrameView::paintContentsForSnapshot always passes SecurityOriginPaintPolicy::AnyOrigin. We could probably get what we want, omitting the third party frames, if we can get the policy to be to be SecurityOriginPaintPolicy::AccessibleOriginOnly. Maybe do this by adding a SnapshotOptions flag, and also adding an argument to paintContentsForSnapshot. Unfortunately, because we are using SnapshotOptionsInViewCoordinates, which sends us down a different code path, it might be a little bit harder to support that. But maybe that flag is not quite right. I think we want the top of the document, not the top of the view, and we don’t want to include things like scrollbars. 1754427 9 426928 hi 2021-04-26 16:30:29 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review >>>>> Source/WebCore/dom/Document.cpp:3917 >>>>> + hitTest(hitTestRequestTypes, hitTestResult); >>>> >>>> Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. >>>> >>>> If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. >>> >>> Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. >> >> I suggest you factor this into a separate function with a name like isInFirstPartyFrame or something along those lines, to document more clearly what it’s doing. >> >> >> The hit testing won’t necessarily exactly match the painting, so it’s a tempting, but flawed concept on how to do this. >> >> I think there’s an alternative, more robust and fool proof approach where we pass arguments in that alter the behavior of the painting code rather than relying on the connection between painting code and hit testing code. The question in my mind is what we want to do instead of painting these third party frames into the single pixel we are trying to sample. Would we just not paint those frames? Then we might get the value of pixels the user would never see that would normally be covered by a third party frame. We could paint them in a special indicator color to help us know not to use the pixels. > > Looking into third-party frame painting, I found mechanism that already exists (actually more than one, but this seemed the best) that could be used to do this with a little bit of refactoring and rearranging. There’s already something called SecurityOriginPaintPolicy that is passed in to FrameView::paintContents, but FrameView::paintContentsForSnapshot always passes SecurityOriginPaintPolicy::AnyOrigin. We could probably get what we want, omitting the third party frames, if we can get the policy to be to be SecurityOriginPaintPolicy::AccessibleOriginOnly. Maybe do this by adding a SnapshotOptions flag, and also adding an argument to paintContentsForSnapshot. > > Unfortunately, because we are using SnapshotOptionsInViewCoordinates, which sends us down a different code path, it might be a little bit harder to support that. But maybe that flag is not quite right. I think we want the top of the document, not the top of the view, and we don’t want to include things like scrollbars. The idea behind this is to completely bail if the snapshot were to happen inside a 3rd party `<iframe>` as in that situation we don't have a solid (or close to it) color across the top of the page (it is possible for the 3rd party `<iframe>` to have the same color as the rest of the page, but IMO if we allowed for that scenario that would blur the line of "what is page content and what isn't"). We don't want to get the color underneath because, as you said, that's not something the user would ever see. I totally forgot about `SnapshotOptionsInViewCoordinates`! I'd added that in there when first trying to get this to work as a "I wonder if this would make a difference". I'll remove it. >>>> Source/WebCore/dom/Document.cpp:3927 >>>> + auto snapshotData = snapshot->getImageData(AlphaPremultiplication::Unpremultiplied, IntRect(IntPoint::zero(), size)); >>> >>> The getImageData API is designed for use from JavaScript, with quite a bit of inefficiency just to be compatible with JavaScript idioms. Here internally in WebKit I am sure we can come up with something simpler that doesn’t require memory allocation. >> >> I was hoping there was a better way than using `ImageData`. Do you happen to know of one of these better ways? I'm thinking that maybe `ImageBuffer::toBGRAData` might be an option. > > What we want is similar to what Image::singlePixelSolidColor does. That function is designed to detect an image that happens to be a single pixel solid color. Here we are intentionally creating an image buffer (intrinsically opaque, which is what "solid" means) that contains a single pixel and would like to know its color. > > I suppose ImageBuffer may be the only platform-independent interface we have for making GraphicsContext with a buffer that you can draw into. And certainly "drawing" is the way we find out the color of a pixel on the webpage. To reuse the code we already have maybe we would use use ImageBuffer::sinkIntoImage and then call Image:: singlePixelSolidColor on that image. > > If we want to optimize this further we could write an ImageBuffer::singlePixelColor function and have it do the sinkIntoImage/singlePixelSolidColor operations. This would make it easier to optimize later for specific types of ImageBuffer by making this a virtual function if needed. We could specialize it so it can do the work without necessarily creating an Image. > > But all of this seems a bit inefficient when repeated five times. Maybe we’d want to paint once into a buffer that was not a single pixel, and then sample the five pixels out of it? > > Anyway, I’m OK with the current code but I think these are worth considering. Yeah it'd be nice if there was a simpler way to say "get the color of the pixel at this location". I did some testing and `ImageBuffer::toBGRAData` appears to work as an alternative. I'm currently trying to change this to use `WebCore::Color` instead with something like ``` auto image = ImageBuffer::sinkIntoImage(WTFMove(snapshot)); return image->singlePixelSolidColor(); ``` to see whether that code would be easier to read and to maybe/hopefully leverage more of the existing code around `Color`. >> Source/WebCore/dom/Document.cpp:3971 >> + percentageDifferences[i - 1] = redPercentDifference + greenPercentDifference + bluePercentDifference + alphaPercentDifference; > > This is another example of something that needs a helper function. Writing it out like this without a named function doesn’t seem good. > > We’d want a function that takes two colors and returns the percentageDifference rather than 5 lines of code that does the math. I’m not sure why we call this "percent" since there is no 100 involved here. The word "percent" should really be reserved for things in the range of 0-100. Should think further on what the correct terminology for this is. Maybe discuss with Sam who has been thinking a lot about color terminology lately. Yeah I agree that "percent" isn't the best word here. IMO it sounded better than "Ratio" (e.g. `SampledPageTopColorAdjacentRatioMaxDifference`) or "Fractional" (e.g. `SampledPageTopColorMaxAdjacentFractionalDifference`). My only "defense" of using "percent" is that it fits when discussing the logic verbally (e.g. "the colors are 2% different" even though it's expressed as a decimal). I'll reach out to Sam and see if he has any ideas. In the meantime, do you have any suggestions? >> Source/WebCore/dom/Document.cpp:4003 >> + uint32_t averageAlpha = 0; > > I don’t think this will actually work. First of all, I’m not sure we have the right kind of code to actually draw into a buffer and give us alpha values. I’m pretty sure that the buffer starts with an opaque background and so the alpha will always be 1. If it wasn’t, not sure that a mean is the way we’d want to blend the alphas together. Oh wow yeah good points. I'll remove the logic around alpha. >> Source/WebCore/dom/Document.cpp:4013 >> + auto validSnapshotCount = nonMatchingColorIndex == numSnapshots + 1 ? numSnapshots : numSnapshots - 1; > > Would be clearer to make this count by incrementing each time we add in to the sums. > > But also, I suggest we write a separate function that computes the mean of a set of colors rather than writing it in-line here in this function. We can remove the non-matching color index from the array (and yes, move the items down to compact), and then pass this array of colors in to that function and let it do the work. That’s the kind of thing that makes the code readable. I was trying to avoid having to do a move/copy, but if it makes the code easier to read I could just use a `Vector`. > Tools/TestWebKitAPI/Tests/WebKitCocoa/SampledPageTopColor.mm:125 > +TEST(SampledPageTopColor, ZeroMaxPercentDifference) (In reply to Darin Adler from comment #7) > Wait, where’s the testing for this new function? > > Please don’t land all this code without any tests! These are the API tests I added for this new code. 1754439 10 426928 darin 2021-04-26 16:48:35 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review >>> Source/WebCore/dom/Document.cpp:4013 >>> + auto validSnapshotCount = nonMatchingColorIndex == numSnapshots + 1 ? numSnapshots : numSnapshots - 1; >> >> Would be clearer to make this count by incrementing each time we add in to the sums. >> >> But also, I suggest we write a separate function that computes the mean of a set of colors rather than writing it in-line here in this function. We can remove the non-matching color index from the array (and yes, move the items down to compact), and then pass this array of colors in to that function and let it do the work. That’s the kind of thing that makes the code readable. > > I was trying to avoid having to do a move/copy, but if it makes the code easier to read I could just use a `Vector`. Sorry, please don’t use Vector. I was thinking more the classes for dealing with color components. For a fixed size thing it would be std::array, but I wasn’t suggesting that. I don’t think "avoiding copying" is important enough to make the code this confusing. Instead I think you should do the remove operation in the array. My idea is that the mean function would be like this: Color meanColor(const Color colors[], unsigned numColors) But details and types might be different. Not even sure that "mean" is the right way to average together a set of pixels. 1754444 11 426928 darin 2021-04-26 16:50:40 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review >>>>>> Source/WebCore/dom/Document.cpp:3917 >>>>>> + hitTest(hitTestRequestTypes, hitTestResult); >>>>> >>>>> Do we really need to do hit testing? I am a bit perplexed. This seems an indirect way to protect against reading colors across domains: What if hit testing is not 100% consistent with painting? Normally that would be harmless. >>>>> >>>>> If we are not trying to protect against riding colors across domains, then I am unclear on why a hit test is helpful. >>>> >>>> Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. >>> >>> I suggest you factor this into a separate function with a name like isInFirstPartyFrame or something along those lines, to document more clearly what it’s doing. >>> >>> >>> The hit testing won’t necessarily exactly match the painting, so it’s a tempting, but flawed concept on how to do this. >>> >>> I think there’s an alternative, more robust and fool proof approach where we pass arguments in that alter the behavior of the painting code rather than relying on the connection between painting code and hit testing code. The question in my mind is what we want to do instead of painting these third party frames into the single pixel we are trying to sample. Would we just not paint those frames? Then we might get the value of pixels the user would never see that would normally be covered by a third party frame. We could paint them in a special indicator color to help us know not to use the pixels. >> >> Looking into third-party frame painting, I found mechanism that already exists (actually more than one, but this seemed the best) that could be used to do this with a little bit of refactoring and rearranging. There’s already something called SecurityOriginPaintPolicy that is passed in to FrameView::paintContents, but FrameView::paintContentsForSnapshot always passes SecurityOriginPaintPolicy::AnyOrigin. We could probably get what we want, omitting the third party frames, if we can get the policy to be to be SecurityOriginPaintPolicy::AccessibleOriginOnly. Maybe do this by adding a SnapshotOptions flag, and also adding an argument to paintContentsForSnapshot. >> >> Unfortunately, because we are using SnapshotOptionsInViewCoordinates, which sends us down a different code path, it might be a little bit harder to support that. But maybe that flag is not quite right. I think we want the top of the document, not the top of the view, and we don’t want to include things like scrollbars. > > The idea behind this is to completely bail if the snapshot were to happen inside a 3rd party `<iframe>` as in that situation we don't have a solid (or close to it) color across the top of the page (it is possible for the 3rd party `<iframe>` to have the same color as the rest of the page, but IMO if we allowed for that scenario that would blur the line of "what is page content and what isn't"). We don't want to get the color underneath because, as you said, that's not something the user would ever see. > > I totally forgot about `SnapshotOptionsInViewCoordinates`! I'd added that in there when first trying to get this to work as a "I wonder if this would make a difference". I'll remove it. Doing 5 different hit tests just smells like the wrong solution to me, for this problem. I think it’s worth doing more thinking about how to achieve the goal (don't use the color of an embedded website) to avoid the hit testing. I’m not even sure that the check for HTMLIFrameElement is the correct rule. 1754458 12 426928 sam 2021-04-26 17:37:23 -0700 Comment on attachment 426928 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426928&action=review > Source/WebCore/dom/Document.cpp:3896 > + auto maxPercentDifference = page->settings().sampledPageTopColorMaxPercentDifference(); This should just be settings()->sampledPageTopColorMaxPercentDifference() > Source/WebCore/dom/Document.cpp:3955 > + auto snapshot = getPixelColorAtTopX(frameWidth * i / (numSnapshots - 1)); This seems pretty inefficient since snapshots will cause a FrameView::paintContentsForSnapshot(), paintContents(), etc. I think you are better off doing a single snapshot if can? generally, it seems a bit worrisome to be doing this many paints here. >>> Source/WebCore/dom/Document.cpp:3971 >>> + percentageDifferences[i - 1] = redPercentDifference + greenPercentDifference + bluePercentDifference + alphaPercentDifference; >> >> This is another example of something that needs a helper function. Writing it out like this without a named function doesn’t seem good. >> >> We’d want a function that takes two colors and returns the percentageDifference rather than 5 lines of code that does the math. I’m not sure why we call this "percent" since there is no 100 involved here. The word "percent" should really be reserved for things in the range of 0-100. Should think further on what the correct terminology for this is. Maybe discuss with Sam who has been thinking a lot about color terminology lately. > > Yeah I agree that "percent" isn't the best word here. IMO it sounded better than "Ratio" (e.g. `SampledPageTopColorAdjacentRatioMaxDifference`) or "Fractional" (e.g. `SampledPageTopColorMaxAdjacentFractionalDifference`). My only "defense" of using "percent" is that it fits when discussing the logic verbally (e.g. "the colors are 2% different" even though it's expressed as a decimal). > > I'll reach out to Sam and see if he has any ideas. In the meantime, do you have any suggestions? If you want a sRGB pixel in 0-1, I recommend converting. auto ithSnapshot = convertColor<SRGBA<float>>(snapshots[i]); auto ithMinusOneSnapshot = convertColor<SRGBA<float>>(snapshots[i - 1]); // Or you could add an operator- to ColorComponents. auto difference = mapColorComponents([] (auto a, auto b) { return a - b }, asColorComponents(ithSnapshot), asColorComponents(ithMinusOneSnapshot)); That said, I would recommend using a color space like Lab to do differences, as getting the difference between colors is a known problem (look up "Delta E" for more), and sRGB is not a great color space for it. In general, it would be good to avoid using sRGB directly anywhere in WebCore. I am working to remove existing usages, as they all represent code that doesn't work correctly with larger gamuts (e.g. P3, etc). >> Source/WebCore/dom/Document.cpp:4015 >> + m_sampledPageTopColor = makeFromComponentsClamping<SRGBA<float>>(averageRed / convertToDecimal, averageGreen / convertToDecimal, averageBlue / convertToDecimal, averageAlpha / convertToDecimal); > > We are doing the math correctly here, so no clamping is necessary. There’s no way that these mean color channel values will somehow be outside the 0-1 range. You can just do m_sampledPageTopColor = SRGBA<uint8_t> { averageRed, averageGreen, ... }. There doesn't seem to be a compelling reason to convert to float manually here. 1754459 13 sam 2021-04-26 17:39:55 -0700 > Yes the purpose of this is to avoid 3rd-party <iframe>, such as for sites that have a banner ad across the top of the page. Seems like the render tree walk done in the paint should handle this rather than doing both a hit test and paint. Perhaps a new PaintBehavior bit if we don't have one already. 1754460 14 darin 2021-04-26 17:41:44 -0700 (In reply to Sam Weinig from comment #12) > That said, I would recommend using a color space like Lab to do differences, > as getting the difference between colors is a known problem (look up "Delta > E" for more), and sRGB is not a great color space for it. Hooray, that is such a great suggestion. Devin may need tips on how to do that correctly. > You can just do m_sampledPageTopColor = SRGBA<uint8_t> { averageRed, > averageGreen, ... }. There doesn't seem to be a compelling reason to convert > to float manually here. There seems a small benefit to using float: probably gives us rounding instead of truncating? But we can also do the integer average computation in a way that does rounding. 1755201 15 427301 hi 2021-04-28 15:55:34 -0700 Created attachment 427301 Patch Thanks for all the feedback! I've switched to using `Lab<float>`, but I wasn't able to get end-to-end usage of it as AFAICT it doesn't seem like `snapshotFrameRect` supports outputting to a non-sRGB `ImageBuffer`. Since this is an off-by-default feature that we're currently experimenting with, I'm going to land it with FIXMEs for <https://webkit.org/b/225167> (Sampled Page Top Color: hook into painting logic instead of taking snapshots) and tackle the issues around hit testing not being consistent with painting and supporting non-sRGB colors there (assuming that we do in fact want to do this, i.e. un-experimentialize). 1755210 16 427302 hi 2021-04-28 16:09:58 -0700 Created attachment 427302 Patch oops forgot to update ChangeLog 1755262 17 ews-feeder 2021-04-28 17:51:57 -0700 Committed r276744 (237144@main): <https://commits.webkit.org/237144@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 427302. 1755263 18 webkit-bug-importer 2021-04-28 17:52:16 -0700 <rdar://problem/77294992> 1755388 19 427302 darin 2021-04-29 08:16:24 -0700 Comment on attachment 427302 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427302&action=review I have some comments that should not block landing this patch, but I think this still has significant room for improvement. > Source/WebCore/dom/Document.cpp:3282 > + determineSampledPageTopColor(); It does not seem even remotely OK to add this side effect to a function named enqueuePaintTimingEntryIfNeeded! We should figure out how and when the loading process should trigger this sampling. It’s really rubbing me the wrong way to build this into the Document class, by the way. Not right for the separation of responsibilities. > Source/WebCore/dom/Document.cpp:3909 > +void Document::determineSampledPageTopColor() We should see what we can do to move this out of document. This includes all sorts of high level stuff like snapshotting that doesn’t belong as a member function of Document itself. The one benefit this gets from being a member of Document is storing the color inside the document. But I’m not sure that benefit is good enough to justify putting all the code here. I think we should look for a better place to put it. > Source/WebCore/dom/Document.cpp:3933 > + IntPoint location(x, 0); > + IntSize size(1, 1); I suggest we just use an IntRect for this instead of two separate locals. What happened to the research we wanted to do about how scale factor affects this? > Source/WebCore/dom/Document.cpp:3956 > + // Bail if the non-matching color is not the first or last snapshot, or there already is an non-matching color. What’s the rationale for allowing only 1 non-matching color of 5, and requiring that it be the first or last of the 5? I don’t see anything here that explains how we chose that. I hope we’re not designing our algorithm around not wanting to delete an item from the middle of an array of 5! > Source/WebCore/dom/Document.cpp:8749 > +bool Document::isHitTestLocationThirdPartyFrame(const HitTestLocation& location) This helper should just be a function that takes a document, not a member function of Document. It should be grouped with other hit testing functions, not in the Document class itself. Doing this is following a path that just makes Document more and more into a "god class" if we add general purpose functions like this at the document level. > Source/WebCore/dom/Document.cpp:8757 > + if (!hitTestNode) > + return false; This isn’t needed. The is<> function already checks for null. > Source/WebCore/dom/Document.cpp:8762 > + return areRegistrableDomainsEqual(downcast<HTMLIFrameElement>(*hitTestNode).location(), m_url); I would have expected this to use a SecurityOrigin function instead of calling areRegistrableDomainsEqual directly. 426926 2021-04-23 11:03:10 -0700 2021-04-23 11:06:39 -0700 Patch 76251889.diff text/plain 51314 hi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggNzczNThhM2ZlYTAzLi44OTg4Y2RmZDdmZGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIw MjEtMDQtMjMgIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4 cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9m IHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlcy55YW1sOgorICAg ICAgICBBZGQgYSBgU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlYCBzZXR0 aW5nIHRoYXQgY29udHJvbHMgYm90aCB3aGV0aGVyIG9yIG5vdCB0bworICAgICAgICBzYW1wbGUg Y29sb3JzIGZyb20gdGhlIHRvcCBvZiB0aGUgcGFnZSAob25seSBpZiB2YWx1ZSA+IDApIGFuZCB0 aGUgbWF4IHBlcmNlbnQgZGlmZmVyZW5jZQorICAgICAgICBhbGxvd2VkIGFjcm9zcyBhbGwgc2Ft cGxlcy4KKworICAgICAgICAqIFNjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRl cm5hbC55YW1sOgorICAgICAgICBBZGQgYSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9s bEFyZWFCYWNrZ3JvdW5kQ29sb3JgIGludGVybmFsIHNldHRpbmcgdGhhdCBjb250cm9scworICAg ICAgICB3aGV0aGVyIHRoZSBzYW1wbGVkIHBhZ2UgdG9wIGNvbG9yIGNhbiBiZSB1c2VkIGFzIHRo ZSBvdmVyc2Nyb2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvci4KKwogMjAyMS0wNC0yMCAgQnJlbnQg RnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbQ29jb2FdIFByZXZlbnQg R1BVIGFuZCBXZWJDb250ZW50IHByb2Nlc3NlcyBmcm9tIGF0dGVtcHRpbmcgdG8gY29ubmVjdCB0 byB0aGUgQXBwU1NPIHNlcnZpY2UgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJl ZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMueWFtbCBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJl bmNlcy9XZWJQcmVmZXJlbmNlcy55YW1sCmluZGV4IDU2YzQyNjc4ZGY1MC4uZWM1YWNlNWNmZDFj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5j ZXMueWFtbAorKysgYi9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5j ZXMueWFtbApAQCAtMTgyMyw2ICsxODIzLDE2IEBAIFNhZmVCcm93c2luZ0VuYWJsZWQ6CiAgICAg V2ViS2l0OgogICAgICAgZGVmYXVsdDogdHJ1ZQogCitTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVy Y2VudERpZmZlcmVuY2U6CisgIHR5cGU6IGRvdWJsZQorICBkZWZhdWx0VmFsdWU6CisgICAgV2Vi S2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDogMAorICAgIFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6 IDAKKyAgICBXZWJDb3JlOgorICAgICAgZGVmYXVsdDogMAorCiBTYW5zU2VyaWZGb250RmFtaWx5 OgogICB0eXBlOiBTdHJpbmcKICAgd2ViS2l0TGVnYWN5UHJlZmVyZW5jZUtleTogV2ViS2l0U2Fu c1NlcmlmRm9udApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dl YlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbCBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNl cy9XZWJQcmVmZXJlbmNlc0ludGVybmFsLnlhbWwKaW5kZXggOGEzYTRjMDdjZjk2Li5iZDIzNDU4 NWM2YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVm ZXJlbmNlc0ludGVybmFsLnlhbWwKKysrIGIvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2Vz L1dlYlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbApAQCAtNzUwLDYgKzc1MCwxOCBAQCBVc2VHUFVQ cm9jZXNzRm9yV2ViR0xFbmFibGVkOgogICAgIFdlYktpdDoKICAgICAgIGRlZmF1bHQ6IGRlZmF1 bHRVc2VHUFVQcm9jZXNzRm9yV2ViR0xFbmFibGVkKCkKIAorVXNlU2FtcGxlZFBhZ2VUb3BDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6CisgIHR5cGU6IGJvb2wKKyAgaHVtYW5SZWFk YWJsZU5hbWU6ICJVc2Ugc2FtcGxlZCBwYWdlIHRvcCBjb2xvciBmb3Igc2Nyb2xsIGFyZWEgYmFj a2dyb3VuZCBjb2xvciIKKyAgaHVtYW5SZWFkYWJsZURlc2NyaXB0aW9uOiAiVXNlIHNhbXBsZWQg cGFnZSB0b3AgY29sb3IgZm9yIHNjcm9sbCBhcmVhIGJhY2tncm91bmQgY29sb3IiCisgIGRlZmF1 bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAgIFdl YktpdDoKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViQ29yZToKKyAgICAgIGRlZmF1bHQ6 IGZhbHNlCisKIFVzZVRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOgogICB0 eXBlOiBib29sCiAgIGh1bWFuUmVhZGFibGVOYW1lOiAiVXNlIHRoZW1lLWNvbG9yIGZvciBzY3Jv bGwgYXJlYSBiYWNrZ3JvdW5kIGNvbG9yIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDM4MjA1NDc0YWJjNi4uMWI2 YzgwOTRjOTAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDggQEAKKzIwMjEtMDQtMjMgIERldmlu IFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4cGVyaW1lbnQgd2l0aCBh dmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9mIHRoZSBwYWdlIGFzIHRo ZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzc2MjUxODg5 PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3Rz OiBTYW1wbGVkUGFnZVRvcENvbG9yLlplcm9NYXhQZXJjZW50RGlmZmVyZW5jZQorICAgICAgICAg ICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xvci5OZWdhdGl2ZU1heFBlcmNlbnREaWZmZXJlbmNlCisg ICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLlNvbGlkQ29sb3IKKyAgICAgICAgICAg ICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aG91dE91dGxpZXJCZWxv d01heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9y LkRpZmZlcmVudENvbG9yc1dpdGhMZWZ0T3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UK KyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aE1p ZGRsZU91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1w bGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhSaWdodE91dGxpZXJBYm92ZU1heFBl cmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZl cmVudENvbG9yc0luZGl2aWR1YWxseUFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UKKyAgICAgICAg ICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzQ3VtdWxhdGl2ZWx5QWJv dmVNYXhQZXJjZW50RGlmZmVyZW5jZQorICAgICAgICAgICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xv ci5FeHBlcmltZW50YWxVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91 bmRDb2xvcgorCisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpE b2N1bWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvciBjb25zdCk6IEFkZGVkLgorICAgICAgICAqIGRv bS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZW5xdWV1ZVBhaW50 VGltaW5nRW50cnlJZk5lZWRlZCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGV0ZXJt aW5lU2FtcGxlZFBhZ2VUb3BDb2xvcik6IEFkZGVkLgorICAgICAgICBXYWl0IHVudGlsIHRoZSBm aXJzdCBjb250ZW50ZnVsIHBhaW50IGJlZm9yZSBzYW1wbGluZy4gRG9uJ3Qgc2FtcGxlIGlmIHRo YXQgbG9jYXRpb24gd291bGQKKyAgICAgICAgZmFsbCBpbnRvIGEgM3JkLXBhcnR5IGA8aWZyYW1l PmAuIEN1cnJlbnRseSB1c2UgNSBzbmFwc2hvdHMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2Us CisgICAgICAgIGFsbG93aW5nIGZvciBvbmUgb2YgZWl0aGVyIHRoZSBmaXJzdCBvciBsYXN0IHNu YXBzaG90IHRvIGJlIGFuIG91dGxpZXIsIHdoaWNoIGlzIG5vdAorICAgICAgICBpbmNsdWRlZCBp biB0aGUgYXZlcmFnZSBvZiB0aGUgb3RoZXIgc25hcHNob3RzIHRoYXQncyB1c2VkIGFzIHRoZSBm aW5hbCBjb2xvciB2YWx1ZS4gSWYgdGhlCisgICAgICAgIHBlcmNlbnRhZ2UgZGlmZmVyZW5jZSBi ZXR3ZWVuIGFueSB0d28gc25hcHNob3RzICh1bmxlc3MgaXQncyB0aGUgZmlyc3Qgb3IgbGFzdCBz bmFwc2hvdCBhcworICAgICAgICBkZXNjcmliZWQgYWJvdmUpIG9yIGFjcm9zcyBhbGwgdGhlIChu b24tb3V0bGllcikgc25hcHNob3RzIGlzIHRvbyBsYXJnZSwgYmFpbC4gT25seSBlbmFibGVkCisg ICAgICAgIGlmIHRoZSBgU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlYCBz ZXR0aW5nIGlzIGdyZWF0ZXIgdGhhbiAwLgorCisgICAgICAgICogcGFnZS9QYWdlLmg6CisgICAg ICAgICogcGFnZS9QYWdlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhZ2U6OnNhbXBsZWRQYWdl VG9wQ29sb3IgY29uc3QpOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL0Nocm9tZUNsaWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6Q2hyb21lQ2xpZW50OjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IgY29u c3QpOiBBZGRlZC4KKyAgICAgICAgUGFzcyBhbG9uZyB0aGUgYHNhbXBsZWRQYWdlVG9wQ29sb3Jg IHRvIHRoZSBVSVByb2Nlc3MgYWZ0ZXIgaXQncyBkZXRlcm1pbmVkIG9yIGlmIHRoZSBhYm92ZQor ICAgICAgICBsb2dpYyBiYWlscyAoc28gdGhhdCB0aGUgYFdLV2ViVmlld2AgY2FuIGFkanVzdCBg X3NhbXBsZWRQYWdlVG9wQ29sb3JgIHRvIGBuaWxgKS4KKworICAgICAgICAqIHJlbmRlcmluZy9S ZW5kZXJMYXllckNvbXBvc2l0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXJD b21wb3NpdG9yOjpyb290QmFja2dyb3VuZENvbG9yT3JUcmFuc3BhcmVuY3lDaGFuZ2VkKToKKyAg ICAgICAgVXNlIHRoZSBgc2FtcGxlZFBhZ2VUb3BDb2xvcmAgaWYgdGhlIGBVc2VTYW1wbGVkUGFn ZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcmAKKyAgICAgICAgaW50ZXJuYWwg cHJlZmVyZW5jZSBpcyBlbmFibGVkIGluc3RlYWQgb2YgdGhlIENTUyBgYmFja2dyb3VuZC1jb2xv cmAgb2YgdGhlIGA8aHRtbD5gL2A8Ym9keT5gLgorCiAyMDIxLTA0LTIwICBCYXN1a2UgU3V6dWtp ICA8YmFzdWtlLnN1enVraUBzb255LmNvbT4KIAogICAgICAgICBbY2xhbmddIFJlbW92ZSBpbXBs aWNpdCBjYXN0IHJlbGF0ZWQgd2FybmluZ3MuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRleCA0 ZThhNzk2ZTFjYjEuLmQ0Y2UyOWU1OGI2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC04 Miw2ICs4Miw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCisjaW5jbHVkZSAiRnJhbWVTbmFwc2hv dHRpbmcuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJGdWxsc2NyZWVuTWFu YWdlci5oIgogI2luY2x1ZGUgIkdDUmVhY2hhYmxlUmVmLmgiCkBAIC0xMjMsNiArMTI0LDggQEAK ICNpbmNsdWRlICJJREJPcGVuREJSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiSWRsZUNhbGxiYWNrQ29u dHJvbGxlci5oIgogI2luY2x1ZGUgIkltYWdlQml0bWFwUmVuZGVyaW5nQ29udGV4dC5oIgorI2lu Y2x1ZGUgIkltYWdlQnVmZmVyLmgiCisjaW5jbHVkZSAiSW1hZ2VEYXRhLmgiCiAjaW5jbHVkZSAi SW1hZ2VMb2FkZXIuaCIKICNpbmNsdWRlICJJbWFnZU92ZXJsYXlDb250cm9sbGVyLmgiCiAjaW5j bHVkZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCkBAIC0zMjc2LDYgKzMyNzksOCBAQCB2 b2lkIERvY3VtZW50OjplbnF1ZXVlUGFpbnRUaW1pbmdFbnRyeUlmTmVlZGVkKCkKIAogICAgIGRv bVdpbmRvdygpLT5wZXJmb3JtYW5jZSgpLnJlcG9ydEZpcnN0Q29udGVudGZ1bFBhaW50KCk7CiAg ICAgbV9kaWRFbnF1ZXVlRmlyc3RDb250ZW50ZnVsUGFpbnQgPSB0cnVlOworCisgICAgZGV0ZXJt aW5lU2FtcGxlZFBhZ2VUb3BDb2xvcigpOwogfQogCiBFeGNlcHRpb25Pcjx2b2lkPiBEb2N1bWVu dDo6d3JpdGUoRG9jdW1lbnQqIHJlc3BvbnNpYmxlRG9jdW1lbnQsIFNlZ21lbnRlZFN0cmluZyYm IHRleHQpCkBAIC0zODc5LDYgKzM4ODQsMTM3IEBAIHZvaWQgRG9jdW1lbnQ6OnRoZW1lQ29sb3JD aGFuZ2VkKCkKICNlbmRpZiAvLyBFTkFCTEUoUlVCQkVSX0JBTkRJTkcpCiB9CiAKK3ZvaWQgRG9j dW1lbnQ6OmRldGVybWluZVNhbXBsZWRQYWdlVG9wQ29sb3IoKQoreworICAgIGlmIChtX3NhbXBs ZWRQYWdlVG9wQ29sb3IuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvKiBw YWdlID0gdGhpcy0+cGFnZSgpOworICAgIGlmICghcGFnZSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgYXV0byBtYXhQZXJjZW50RGlmZmVyZW5jZSA9IHBhZ2UtPnNldHRpbmdzKCkuc2FtcGxlZFBh Z2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKCk7CisgICAgaWYgKG1heFBlcmNlbnREaWZm ZXJlbmNlIDw9IDApCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghaXNUb3BEb2N1bWVudCgp KQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvKiBmcmFtZVZpZXcgPSB2aWV3KCk7CisgICAg aWYgKCFmcmFtZVZpZXcpCisgICAgICAgIHJldHVybjsKKworICAgIGF1dG8gbm90aWZ5RGlkU2Ft cGxlUGFnZVRvcENvbG9yT25TY29wZUV4aXQgPSBtYWtlU2NvcGVFeGl0KFsmXSB7CisgICAgICAg IHBhZ2UtPmNocm9tZSgpLmNsaWVudCgpLmRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpOworICAgIH0p OworCisgICAgYXV0byBnZXRQaXhlbENvbG9yQXRUb3BYID0gWyZdIChpbnQgeCkgLT4gT3B0aW9u YWw8U1JHQkE8dWludDhfdD4+IHsKKyAgICAgICAgSW50UG9pbnQgbG9jYXRpb24oeCwgMCk7Cisg ICAgICAgIEludFNpemUgc2l6ZSgxLCAxKTsKKworICAgICAgICBjb25zdGV4cHIgT3B0aW9uU2V0 PEhpdFRlc3RSZXF1ZXN0OjpSZXF1ZXN0VHlwZT4gaGl0VGVzdFJlcXVlc3RUeXBlcyB7IEhpdFRl c3RSZXF1ZXN0OjpSZWFkT25seSwgSGl0VGVzdFJlcXVlc3Q6OkRpc2FsbG93VXNlckFnZW50U2hh ZG93Q29udGVudCB9OworICAgICAgICBIaXRUZXN0UmVzdWx0IGhpdFRlc3RSZXN1bHQobG9jYXRp b24pOworICAgICAgICBoaXRUZXN0KGhpdFRlc3RSZXF1ZXN0VHlwZXMsIGhpdFRlc3RSZXN1bHQp OworICAgICAgICBpZiAoYXV0byBoaXRUZXN0Tm9kZSA9IG1ha2VSZWZQdHIoaGl0VGVzdFJlc3Vs dC5pbm5lck5vZGUoKSkpIHsKKyAgICAgICAgICAgIGlmIChpczxIVE1MSUZyYW1lRWxlbWVudD4o aGl0VGVzdE5vZGUpICYmICFhcmVSZWdpc3RyYWJsZURvbWFpbnNFcXVhbChkb3duY2FzdDxIVE1M SUZyYW1lRWxlbWVudD4oKmhpdFRlc3ROb2RlKS5sb2NhdGlvbigpLCBtX3VybCkpCisgICAgICAg ICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICAgICAgfQorCisgICAgICAgIGF1dG8g c25hcHNob3QgPSBzbmFwc2hvdEZyYW1lUmVjdChmcmFtZVZpZXctPmZyYW1lKCksIEludFJlY3Qo bG9jYXRpb24sIHNpemUpLCBTbmFwc2hvdE9wdGlvbnNFeGNsdWRlU2VsZWN0aW9uSGlnaGxpZ2h0 aW5nIHwgU25hcHNob3RPcHRpb25zSW5WaWV3Q29vcmRpbmF0ZXMgfCBTbmFwc2hvdE9wdGlvbnNQ YWludEV2ZXJ5dGhpbmdFeGNsdWRpbmdTZWxlY3Rpb24pOworICAgICAgICBpZiAoIXNuYXBzaG90 KQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBhdXRvIHNuYXBz aG90RGF0YSA9IHNuYXBzaG90LT5nZXRJbWFnZURhdGEoQWxwaGFQcmVtdWx0aXBsaWNhdGlvbjo6 VW5wcmVtdWx0aXBsaWVkLCBJbnRSZWN0KEludFBvaW50Ojp6ZXJvKCksIHNpemUpKTsKKyAgICAg ICAgaWYgKCFzbmFwc2hvdERhdGEpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0Owor CisgICAgICAgIGF1dG8qIHBpeGVsQXJyYXkgPSBzbmFwc2hvdERhdGEtPmRhdGEoKTsKKyAgICAg ICAgcmV0dXJuIFNSR0JBPHVpbnQ4X3Q+IHsgcGl4ZWxBcnJheS0+aXRlbSgwKSwgcGl4ZWxBcnJh eS0+aXRlbSgxKSwgcGl4ZWxBcnJheS0+aXRlbSgyKSwgcGl4ZWxBcnJheS0+aXRlbSgzKSB9Owor ICAgIH07CisKKyAgICAvLyBEZWNyZWFzZSB0aGUgd2lkdGggYnkgb25lIHBpeGVsIHNvIHRoYXQg dGhlIGxhc3Qgc25hcHNob3QgaXMgd2l0aGluIGJvdW5kcyBhbmQgbm90IG9mZi1ieS1vbmUuCisg ICAgYXV0byBmcmFtZVdpZHRoID0gZnJhbWVWaWV3LT5jb250ZW50c1dpZHRoKCkgLSAxOworCisg ICAgY29uc3RleHByIGF1dG8gbnVtU25hcHNob3RzID0gNTsKKyAgICBzaXplX3Qgbm9uTWF0Y2hp bmdDb2xvckluZGV4ID0gbnVtU25hcHNob3RzICsgMTsKKworICAgIFNSR0JBPHVpbnQ4X3Q+IHNu YXBzaG90c1tudW1TbmFwc2hvdHNdOworICAgIGRvdWJsZSBwZXJjZW50YWdlRGlmZmVyZW5jZXNb bnVtU25hcHNob3RzIC0gMV07CisKKyAgICBhdXRvIHNob3VsZFN0b3BBZnRlckZpbmRpbmdOb25N YXRjaGluZ0NvbG9yID0gWyZdIChzaXplX3QgaSkgLT4gYm9vbCB7CisgICAgICAgIC8vIEJhaWwg aWYgdGhlIG5vbi1tYXRjaGluZyBjb2xvciBpcyBub3QgdGhlIGZpcnN0IG9yIGxhc3Qgc25hcHNo b3QsIG9yIHRoZXJlIGFscmVhZHkgaXMgYW4gbm9uLW1hdGNoaW5nIGNvbG9yLgorICAgICAgICBp ZiAoKGkgPiAwICYmIGkgPCBudW1TbmFwc2hvdHMgLSAxKSB8fCBub25NYXRjaGluZ0NvbG9ySW5k ZXggIT0gbnVtU25hcHNob3RzICsgMSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAg ICAgIG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9IGk7CisgICAgICAgIEFTU0VSVCghbm9uTWF0Y2hp bmdDb2xvckluZGV4IHx8IG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9PSBudW1TbmFwc2hvdHMgLSAx KTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH07CisKKyAgICBmb3IgKHNpemVfdCBpID0g MDsgaSA8IG51bVNuYXBzaG90czsgKytpKSB7CisgICAgICAgIGF1dG8gc25hcHNob3QgPSBnZXRQ aXhlbENvbG9yQXRUb3BYKGZyYW1lV2lkdGggKiBpIC8gKG51bVNuYXBzaG90cyAtIDEpKTsKKyAg ICAgICAgaWYgKCFzbmFwc2hvdCAmJiAhc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNoaW5n Q29sb3IoaSkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgc25hcHNob3RzW2ldID0g KnNuYXBzaG90OworCisgICAgICAgIGlmIChpKSB7CisgICAgICAgICAgICAvLyBFYWNoIGBwZXJj ZW50YWdlRGlmZmVyZW5jZWAgY29tcGFyZXMgYGlgIHdpdGggYGkgLSAxYCBzbyBpZiB0aGUgZmly c3QgY29tcGFyaXNvbiAoYGkgPT0gMWApCisgICAgICAgICAgICAvLyBpcyB0b28gbGFyZ2Ugb2Yg YSBkaWZmZXJlbmNlLCB3ZSBzaG91bGQgdHJlYXQgYGkgLSAxYCAoaS5lLiBgMGApIGFzIHRoZSBw cm9ibGVtIHNpbmNlCisgICAgICAgICAgICAvLyB3ZSBvbmx5IGFsbG93IGZvciBub24tbWF0Y2hp bmcgY29sb3JzIGJlaW5nIHRoZSBmaXJzdCBvciBsYXN0IHNhbXBsZWQgY29sb3IuCisgICAgICAg ICAgICBhdXRvIGVmZmVjdGl2ZU5vbk1hdGNoaW5nQ29sb3JJbmRleCA9IGkgPT0gMSA/IDAgOiBp OworCisgICAgICAgICAgICBkb3VibGUgcmVkUGVyY2VudERpZmZlcmVuY2UgPSBmYWJzKHNuYXBz aG90c1tpXS5yZWQgLSBzbmFwc2hvdHNbaSAtIDFdLnJlZCkgLyAyNTUuMDsKKyAgICAgICAgICAg IGRvdWJsZSBncmVlblBlcmNlbnREaWZmZXJlbmNlID0gZmFicyhzbmFwc2hvdHNbaV0uZ3JlZW4g LSBzbmFwc2hvdHNbaSAtIDFdLmdyZWVuKSAvIDI1NS4wOworICAgICAgICAgICAgZG91YmxlIGJs dWVQZXJjZW50RGlmZmVyZW5jZSA9IGZhYnMoc25hcHNob3RzW2ldLmJsdWUgLSBzbmFwc2hvdHNb aSAtIDFdLmJsdWUpIC8gMjU1LjA7CisgICAgICAgICAgICBkb3VibGUgYWxwaGFQZXJjZW50RGlm ZmVyZW5jZSA9IGZhYnMoc25hcHNob3RzW2ldLmFscGhhIC0gc25hcHNob3RzW2kgLSAxXS5hbHBo YSkgLyAyNTUuMDsKKyAgICAgICAgICAgIHBlcmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPSBy ZWRQZXJjZW50RGlmZmVyZW5jZSArIGdyZWVuUGVyY2VudERpZmZlcmVuY2UgKyBibHVlUGVyY2Vu dERpZmZlcmVuY2UgKyBhbHBoYVBlcmNlbnREaWZmZXJlbmNlOworICAgICAgICAgICAgaWYgKHBl cmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPj0gbWF4UGVyY2VudERpZmZlcmVuY2UpIHsKKyAg ICAgICAgICAgICAgICBpZiAoc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNoaW5nQ29sb3Io ZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4KSkKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorCisgICAgICAg ICAgICBkb3VibGUgY3VtdWx1YXRpdmVQZXJjZW50RGlmZmVyZW5jZSA9IDA7CisgICAgICAgICAg ICBmb3IgKHNpemVfdCBqID0gMDsgaiA8IGk7ICsraikgeworICAgICAgICAgICAgICAgIGlmIChq ID09IG5vbk1hdGNoaW5nQ29sb3JJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgICAgICAgICAgY3VtdWx1YXRpdmVQZXJjZW50RGlmZmVyZW5jZSArPSBwZXJjZW50 YWdlRGlmZmVyZW5jZXNbal07CisgICAgICAgICAgICB9CisgICAgICAgICAgICBpZiAoY3VtdWx1 YXRpdmVQZXJjZW50RGlmZmVyZW5jZSA+PSBtYXhQZXJjZW50RGlmZmVyZW5jZSkgeworICAgICAg ICAgICAgICAgIGlmIChzaG91bGRTdG9wQWZ0ZXJGaW5kaW5nTm9uTWF0Y2hpbmdDb2xvcihlZmZl Y3RpdmVOb25NYXRjaGluZ0NvbG9ySW5kZXgpKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIElm IHdlIGhhdmVuJ3QgYWxyZWFkeSBpZGVudGlmaWVkIGEgbm9uLW1hdGNoaW5nIHNuYXBzaG90IGFu ZCB0aGUgcGVyY2VudCBkaWZmZXJlbmNlIGJldHdlZW4gdGhlCisgICAgICAgICAgICAgICAgICAg IC8vIGZpcnN0IGFuZCBzZWNvbmQgc25hcHNob3RzIG9yIHRoZSBzZWNvbmQtdG8tbGFzdCBhbmQg bGFzdCBzbmFwc2hvdHMgaXMgbGVzcyB0aGFuIHRoZSBtYXhpbXVtLCBtYXJrCisgICAgICAgICAg ICAgICAgICAgIC8vIHRoZSBmaXJzdC9sYXN0IHNuYXBzaG90IGFzIG5vbi1tYXRjaGluZyB0byBn aXZlIGEgY2hhbmNlIGZvciB0aGUgcmVzdCBvZiB0aGUgc25hcHNob3RzIHRvIG1hdGNoLgorICAg ICAgICAgICAgICAgICAgICBpZiAobm9uTWF0Y2hpbmdDb2xvckluZGV4ID09IG51bVNuYXBzaG90 cyArIDEgJiYgKCFpIHx8IGkgPT0gbnVtU25hcHNob3RzIC0gMSkgJiYgY3VtdWx1YXRpdmVQZXJj ZW50RGlmZmVyZW5jZSAtIHBlcmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPCBtYXhQZXJjZW50 RGlmZmVyZW5jZSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbm9uTWF0Y2hpbmdDb2xvcklu ZGV4ID0gZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4OworICAgICAgICAgICAgICAgICAg ICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKworICAgIHVpbnQzMl90IGF2ZXJhZ2VS ZWQgPSAwOworICAgIHVpbnQzMl90IGF2ZXJhZ2VHcmVlbiA9IDA7CisgICAgdWludDMyX3QgYXZl cmFnZUJsdWUgPSAwOworICAgIHVpbnQzMl90IGF2ZXJhZ2VBbHBoYSA9IDA7CisgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPCBudW1TbmFwc2hvdHM7ICsraSkgeworICAgICAgICBpZiAoaSA9PSBu b25NYXRjaGluZ0NvbG9ySW5kZXgpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBh dmVyYWdlUmVkICs9IHNuYXBzaG90c1tpXS5yZWQ7CisgICAgICAgIGF2ZXJhZ2VHcmVlbiArPSBz bmFwc2hvdHNbaV0uZ3JlZW47CisgICAgICAgIGF2ZXJhZ2VCbHVlICs9IHNuYXBzaG90c1tpXS5i bHVlOworICAgICAgICBhdmVyYWdlQWxwaGEgKz0gc25hcHNob3RzW2ldLmFscGhhOworICAgIH0K KyAgICBhdXRvIHZhbGlkU25hcHNob3RDb3VudCA9IG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9PSBu dW1TbmFwc2hvdHMgKyAxID8gbnVtU25hcHNob3RzIDogbnVtU25hcHNob3RzIC0gMTsKKyAgICBm bG9hdCBjb252ZXJ0VG9EZWNpbWFsID0gdmFsaWRTbmFwc2hvdENvdW50ICogMjU1OworICAgIG1f c2FtcGxlZFBhZ2VUb3BDb2xvciA9IG1ha2VGcm9tQ29tcG9uZW50c0NsYW1waW5nPFNSR0JBPGZs b2F0Pj4oYXZlcmFnZVJlZCAvIGNvbnZlcnRUb0RlY2ltYWwsIGF2ZXJhZ2VHcmVlbiAvIGNvbnZl cnRUb0RlY2ltYWwsIGF2ZXJhZ2VCbHVlIC8gY29udmVydFRvRGVjaW1hbCwgYXZlcmFnZUFscGhh IC8gY29udmVydFRvRGVjaW1hbCk7Cit9CisKICNpZiBFTkFCTEUoREFSS19NT0RFX0NTUykKIHN0 YXRpYyB2b2lkIHByb2Nlc3NDb2xvclNjaGVtZVN0cmluZyhTdHJpbmdWaWV3IGNvbG9yU2NoZW1l LCBjb25zdCBXVEY6OkZ1bmN0aW9uPHZvaWQoU3RyaW5nVmlldyBrZXkpPiYgY2FsbGJhY2spCiB7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJD b3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGUyNTdlYWQzYzk0NS4uM2I3YTM2ZmQ0N2Q4IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuaApAQCAtNzQzLDYgKzc0Myw4IEBAIHB1YmxpYzoKIAogICAgIGNvbnN0 IENvbG9yJiB0aGVtZUNvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9tZXRhRWxlbWVudFRoZW1lQ29s b3IuaXNWYWxpZCgpID8gbV9tZXRhRWxlbWVudFRoZW1lQ29sb3IgOiBtX2FwcGxpY2F0aW9uTWFu aWZlc3RUaGVtZUNvbG9yOyB9CiAKKyAgICBjb25zdCBDb2xvciYgc2FtcGxlZFBhZ2VUb3BDb2xv cigpIGNvbnN0IHsgcmV0dXJuIG1fc2FtcGxlZFBhZ2VUb3BDb2xvcjsgfQorCiAgICAgdm9pZCBz ZXRUZXh0Q29sb3IoY29uc3QgQ29sb3ImIGNvbG9yKSB7IG1fdGV4dENvbG9yID0gY29sb3I7IH0K ICAgICBjb25zdCBDb2xvciYgdGV4dENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0Q29sb3I7 IH0KIApAQCAtMTY3Nyw2ICsxNjc5LDggQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgdGhlbWVDb2xv ckNoYW5nZWQoKTsKIAorICAgIHZvaWQgZGV0ZXJtaW5lU2FtcGxlZFBhZ2VUb3BDb2xvcigpOwor CiAgICAgdm9pZCBpbnZhbGlkYXRlQWNjZXNzS2V5Q2FjaGVTbG93Q2FzZSgpOwogICAgIHZvaWQg YnVpbGRBY2Nlc3NLZXlDYWNoZSgpOwogCkBAIC0xODAwLDYgKzE4MDQsOCBAQCBwcml2YXRlOgog ICAgIENvbG9yIG1fbWV0YUVsZW1lbnRUaGVtZUNvbG9yOwogICAgIENvbG9yIG1fYXBwbGljYXRp b25NYW5pZmVzdFRoZW1lQ29sb3I7CiAKKyAgICBDb2xvciBtX3NhbXBsZWRQYWdlVG9wQ29sb3I7 CisKICAgICBDb2xvciBtX3RleHRDb2xvciB7IENvbG9yOjpibGFjayB9OwogICAgIENvbG9yIG1f bGlua0NvbG9yOwogICAgIENvbG9yIG1fdmlzaXRlZExpbmtDb2xvcjsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvQ2hyb21lQ2xpZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0No cm9tZUNsaWVudC5oCmluZGV4IGNmMTZhZTZlYTQ3NS4uZWQ4Y2Y0MDMyMTBlIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvQ2hyb21lQ2xpZW50LmgKQEAgLTIzMyw2ICsyMzMsNyBAQCBwdWJsaWM6CiAKICAgICB2 aXJ0dWFsIHZvaWQgdGhlbWVDb2xvckNoYW5nZWQoKSBjb25zdCB7IH0KICAgICB2aXJ0dWFsIHZv aWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCkgY29uc3QgeyB9CisgICAg dmlydHVhbCB2b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpIGNvbnN0IHsgfQogCiAgICAgdmly dHVhbCB2b2lkIGV4Y2VlZGVkRGF0YWJhc2VRdW90YShGcmFtZSYsIGNvbnN0IFN0cmluZyYgZGF0 YWJhc2VOYW1lLCBEYXRhYmFzZURldGFpbHMpID0gMDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9QYWdlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKaW5kZXgg Y2RiZmZhMGM2YTA1Li44ZmMyYWEyNTA5ODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcApAQCAtMjU1Myw2 ICsyNTUzLDE1IEBAIENvbG9yIFBhZ2U6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNv bnN0CiAgICAgcmV0dXJuIHJlbmRlclZpZXctPmNvbXBvc2l0b3IoKS5yb290RXh0ZW5kZWRCYWNr Z3JvdW5kQ29sb3IoKTsKIH0KIAorQ29sb3IgUGFnZTo6c2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNv bnN0Cit7CisgICAgYXV0byogZG9jdW1lbnQgPSBtYWluRnJhbWUoKS5kb2N1bWVudCgpOworICAg IGlmICghZG9jdW1lbnQpCisgICAgICAgIHJldHVybiB7IH07CisKKyAgICByZXR1cm4gZG9jdW1l bnQtPnNhbXBsZWRQYWdlVG9wQ29sb3IoKTsKK30KKwogLy8gVGhlc2UgYXJlIG1hZ2ljYWwgY29u c3RhbnRzIHRoYXQgbWlnaHQgYmUgdHdlYWtlZCBvdmVyIHRpbWUuCiBzdGF0aWMgY29uc3QgZG91 YmxlIGdNaW5pbXVtUGFpbnRlZEFyZWFSYXRpbyA9IDAuMTsKIHN0YXRpYyBjb25zdCBkb3VibGUg Z01heGltdW1VbnBhaW50ZWRBcmVhUmF0aW8gPSAwLjA0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9QYWdlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaAppbmRleCA2Yjc2 Y2MxMTU4YzMuLjNiZjAzOGE3ZWQzMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q YWdlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmgKQEAgLTYyMSw2ICs2MjEsNyBA QCBwdWJsaWM6CiAKICAgICBXRUJDT1JFX0VYUE9SVCBDb2xvciB0aGVtZUNvbG9yKCkgY29uc3Q7 CiAgICAgV0VCQ09SRV9FWFBPUlQgQ29sb3IgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKCkg Y29uc3Q7CisgICAgV0VCQ09SRV9FWFBPUlQgQ29sb3Igc2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNv bnN0OwogCiAgICAgYm9vbCBpc0NvdW50aW5nUmVsZXZhbnRSZXBhaW50ZWRPYmplY3RzKCkgY29u c3Q7CiAgICAgdm9pZCBzZXRJc0NvdW50aW5nUmVsZXZhbnRSZXBhaW50ZWRPYmplY3RzKGJvb2wg aXNDb3VudGluZykgeyBtX2lzQ291bnRpbmdSZWxldmFudFJlcGFpbnRlZE9iamVjdHMgPSBpc0Nv dW50aW5nOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5 ZXJDb21wb3NpdG9yLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllckNv bXBvc2l0b3IuY3BwCmluZGV4IDE3NDYzNjNiM2VlYy4uYzk4ZGVkYjRlYjE5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcApAQCAt MzkyNiw2ICszOTI2LDggQEAgdm9pZCBSZW5kZXJMYXllckNvbXBvc2l0b3I6OnVwZGF0ZUxheWVy Rm9yT3ZlcmhhbmdBcmVhc0JhY2tncm91bmRDb2xvcigpCiAgICAgQ29sb3IgYmFja2dyb3VuZENv bG9yOwogICAgIGlmIChwYWdlKCkuc2V0dGluZ3MoKS51c2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJl YUJhY2tncm91bmRDb2xvcigpKQogICAgICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkudGhl bWVDb2xvcigpOworICAgIGlmIChwYWdlKCkuc2V0dGluZ3MoKS51c2VTYW1wbGVkUGFnZVRvcENv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcigpICYmICFiYWNrZ3JvdW5kQ29sb3IuaXNW YWxpZCgpKQorICAgICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkuc2FtcGxlZFBhZ2VUb3BD b2xvcigpOwogICAgIGlmICghYmFja2dyb3VuZENvbG9yLmlzVmFsaWQoKSkKICAgICAgICAgYmFj a2dyb3VuZENvbG9yID0gbV9yb290RXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3I7CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5k ZXggOWQ5NzczY2E5ZmRmLi40ZWMxMjdhNzBkZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTAgQEAK KzIwMjEtMDQtMjMgIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAg IGV4cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9w IG9mIHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6 Ly9wcm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQu aDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNsaWVudC5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYkNocm9tZUNsaWVudDo6ZGlkU2FtcGxlUGFnZVRvcENv bG9yIGNvbnN0KTogQWRkZWQuCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2Uu aDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2U6OmRpZFNhbXBsZVBhZ2VUb3BDb2xvcik6IEFkZGVkLgorICAgICAgICBQ YXNzIGFsb25nIHRoZSBgc2FtcGxlZFBhZ2VUb3BDb2xvcmAgdG8gdGhlIFVJUHJvY2Vzcy4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW46CisgICAgICAgICog VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OnNhbXBsZWRQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzY3JvbGxBcmVhQmFj a2dyb3VuZENvbG9yIGNvbnN0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpkaWRT YW1wbGVQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAgVXNlIHRoZSBgc2FtcGxlZFBhZ2VU b3BDb2xvcmAgaWYgdGhlIGBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tn cm91bmRDb2xvcmAKKyAgICAgICAgaW50ZXJuYWwgcHJlZmVyZW5jZSBpcyBlbmFibGVkIGluc3Rl YWQgb2YgdGhlIENTUyBgYmFja2dyb3VuZC1jb2xvcmAgb2YgdGhlIGA8aHRtbD5gL2A8Ym9keT5g LgorCisgICAgICAgICogVUlQcm9jZXNzL1BhZ2VDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6 UGFnZUNsaWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UpOiBBZGRlZC4KKyAgICAg ICAgKFdlYktpdDo6UGFnZUNsaWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvckRpZENoYW5nZSk6IEFk ZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLmg6Cisg ICAgICAgICogVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW06CisgICAgICAg IChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsQ29jb2E6OnNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hh bmdlKTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsQ29jb2E6OnNhbXBs ZWRQYWdlVG9wQ29sb3JEaWRDaGFuZ2UpOiBBZGRlZC4KKyAgICAgICAgQWRkIE9iakMgS1ZPIHN1 cHBvcnQgZm9yIGAtW1dLV2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl1gLgorCisgICAgICAg ICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmg6CisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW06CisgICAgICAgICgtW1dLV2ViVmlldyBfc2V0 dXBQYWdlQ29uZmlndXJhdGlvbjpdKToKKyAgICAgICAgKC1bV0tXZWJWaWV3IF9zYW1wbGVkUGFn ZVRvcENvbG9yXSk6IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJW aWV3Q29uZmlndXJhdGlvblByaXZhdGUuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29h L1dLV2ViVmlld0NvbmZpZ3VyYXRpb24ubW06CisgICAgICAgICgtW1dLV2ViVmlld0NvbmZpZ3Vy YXRpb24gaW5pdF0pOgorICAgICAgICAoLVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIGNvcHlXaXRo Wm9uZTpdKToKKyAgICAgICAgKC1bV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBfc2V0U2FtcGxlZFBh Z2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlOl0pOiBBZGRlZC4KKyAgICAgICAgKC1bV0tX ZWJWaWV3Q29uZmlndXJhdGlvbiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJl bmNlXSk6IEFkZGVkLgorICAgICAgICBQcm92aWRlIFNQSSB0byBjb25maWd1cmUgdGhlIGBTYW1w bGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2VgIHByZWZlcmVuY2Ugd2hlbgorICAg ICAgICBjcmVhdGluZyB0aGUgYFdLV2ViVmlld2AuIEV4cG9zZSB0aGUgcmVzdWx0IGFzIGBfc2Ft cGxlZFBhZ2VUb3BDb2xvcmAgU1BJLgorCiAyMDIxLTA0LTIwICBJYW4gR2lsYmVydCAgPGlhbmdA YXBwbGUuY29tPgogCiAgICAgICAgIENyYXNoIGR1ZSB0byBWZWN0b3JCdWZmZXIgcHJlLWFsbG9j YXRpb24gZmFpbHVyZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0Nv Y29hL1dLV2ViVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dl YlZpZXcubW0KaW5kZXggNmRmOGE2MDkzNzViLi5kNjQ0OTg1MjVkNDYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW0KKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlldy5tbQpAQCAtNTU4LDYgKzU1OCw4 IEBAIC0gKHZvaWQpX3NldHVwUGFnZUNvbmZpZ3VyYXRpb246KFJlZjxBUEk6OlBhZ2VDb25maWd1 cmF0aW9uPiYpcGFnZUNvbmZpZ3VyYXRpb24KICAgICBwYWdlQ29uZmlndXJhdGlvbi0+cHJlZmVy ZW5jZXMoKS0+c2V0U2VydmljZVdvcmtlckVudGl0bGVtZW50RGlzYWJsZWRGb3JUZXN0aW5nKCEh W19jb25maWd1cmF0aW9uIHByZWZlcmVuY2VzXS5fc2VydmljZVdvcmtlckVudGl0bGVtZW50RGlz YWJsZWRGb3JUZXN0aW5nKTsKICNlbmRpZgogCisgICAgcGFnZUNvbmZpZ3VyYXRpb24tPnByZWZl cmVuY2VzKCktPnNldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZShbX2Nv bmZpZ3VyYXRpb24gX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZV0pOwor CiAgICAgaWYgKCFsaW5rZWRPbk9yQWZ0ZXIoV2ViQ29yZTo6U0RLVmVyc2lvbjo6Rmlyc3RXaGVy ZVNpdGVTcGVjaWZpY1F1aXJrc0FyZUVuYWJsZWRCeURlZmF1bHQpKQogICAgICAgICBwYWdlQ29u ZmlndXJhdGlvbi0+cHJlZmVyZW5jZXMoKS0+c2V0TmVlZHNTaXRlU3BlY2lmaWNRdWlya3MoZmFs c2UpOwogfQpAQCAtMzAwMyw2ICszMDA1LDE0IEBAIC0gKENvY29hQ29sb3IgKilfcGFnZUV4dGVu ZGVkQmFja2dyb3VuZENvbG9yCiAgICAgcmV0dXJuIFdlYkNvcmU6OnBsYXRmb3JtQ29sb3IocGFn ZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKTsKIH0KIAorLSAoQ29jb2FDb2xvciAqKV9zYW1wbGVk UGFnZVRvcENvbG9yCit7CisgICAgYXV0byBzYW1wbGVkUGFnZVRvcENvbG9yID0gX3BhZ2UtPnNh bXBsZWRQYWdlVG9wQ29sb3IoKTsKKyAgICBpZiAoIXNhbXBsZWRQYWdlVG9wQ29sb3IuaXNWYWxp ZCgpKQorICAgICAgICByZXR1cm4gbmlsOworICAgIHJldHVybiBXZWJDb3JlOjpwbGF0Zm9ybUNv bG9yKHNhbXBsZWRQYWdlVG9wQ29sb3IpOworfQorCiAtIChpZCA8X1dLSW5wdXREZWxlZ2F0ZT4p X2lucHV0RGVsZWdhdGUKIHsKICAgICByZXR1cm4gX2lucHV0RGVsZWdhdGUuZ2V0QXV0b3JlbGVh c2VkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tX ZWJWaWV3Q29uZmlndXJhdGlvbi5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tCmluZGV4IGM1MDA5YjY4ODZmMy4uMDhiMTAxZDVh NjdiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJW aWV3Q29uZmlndXJhdGlvbi5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29j b2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvbi5tbQpAQCAtMTc3LDYgKzE3Nyw3IEBAIEBpbXBsZW1l bnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIHsKICNpZiBFTkFCTEUoQVBQX0hJR0hMSUdI VFMpCiAgICAgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQ7CiAjZW5kaWYKKyAgICBkb3VibGUg X3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZTsKIAogICAgIFJldGFpblB0 cjxOU1N0cmluZz4gX21lZGlhQ29udGVudFR5cGVzUmVxdWlyaW5nSGFyZHdhcmVTdXBwb3J0Owog ICAgIFJldGFpblB0cjxOU0FycmF5PE5TU3RyaW5nICo+PiBfYWRkaXRpb25hbFN1cHBvcnRlZElt YWdlVHlwZXM7CkBAIC0yNzUsNiArMjc2LDkgQEAgLSAoaW5zdGFuY2V0eXBlKWluaXQKICNpZiBF TkFCTEUoQVBQX0hJR0hMSUdIVFMpCiAgICAgX2FwcEhpZ2hsaWdodHNFbmFibGVkID0gREVGQVVM VF9WQUxVRV9GT1JfQXBwSGlnaGxpZ2h0c0VuYWJsZWQ7CiAjZW5kaWYKKworICAgIF9zYW1wbGVk UGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UgPSBERUZBVUxUX1ZBTFVFX0ZPUl9TYW1w bGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2U7CisKICAgICByZXR1cm4gc2VsZjsK IH0KIApAQCAtNDUzLDYgKzQ1Nyw4IEBAIC0gKGlkKWNvcHlXaXRoWm9uZTooTlNab25lICopem9u ZQogICAgIGNvbmZpZ3VyYXRpb24tPl9hcHBIaWdobGlnaHRzRW5hYmxlZCA9IHNlbGYtPl9hcHBI aWdobGlnaHRzRW5hYmxlZDsKICNlbmRpZgogCisgICAgY29uZmlndXJhdGlvbi0+X3NhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSA9IHNlbGYtPl9zYW1wbGVkUGFnZVRvcENv bG9yTWF4UGVyY2VudERpZmZlcmVuY2U7CisKICAgICByZXR1cm4gY29uZmlndXJhdGlvbjsKIH0K IApAQCAtMTI3Myw2ICsxMjc5LDE2IEBAIC0gKHZvaWQpX3NldFByb2Nlc3NEaXNwbGF5TmFtZToo TlNTdHJpbmcgKilsc0Rpc3BsYXlOYW1lCiAgICAgX3BhZ2VDb25maWd1cmF0aW9uLT5zZXRQcm9j ZXNzRGlzcGxheU5hbWUobHNEaXNwbGF5TmFtZSk7CiB9CiAKKy0gKHZvaWQpX3NldFNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZTooZG91YmxlKXZhbHVlCit7CisgICAgX3Nh bXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSA9IHZhbHVlOworfQorCistIChk b3VibGUpX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZQoreworICAgIHJl dHVybiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlOworfQorCiBAZW5k CiAKIEBpbXBsZW1lbnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIChXS0RlcHJlY2F0ZWQp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3 Q29uZmlndXJhdGlvblByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCmluZGV4IGVmNGQ0ZTIwYzE0ZC4uYTM2 ODUxYjIwNjliIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tXZWJWaWV3Q29uZmlndXJhdGlvblByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvblByaXZhdGUuaApAQCAtMTIzLDYg KzEyMyw5IEBAIHR5cGVkZWYgTlNfRU5VTShOU1VJbnRlZ2VyLCBfV0tEcmFnTGlmdERlbGF5KSB7 CiAKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCBzZXR0ZXI9X3NldEFwcEhpZ2hsaWdodHNFbmFibGVk OikgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19N QUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKIAorLy8gRXhwZWN0cyB2YWx1ZXMgWzAsIDFdIHdo ZXJlIDAgbWVhbnMgZGlzYWJsaW5nIHBhZ2UgdG9wIGNvbG9yIHNhbXBsaW5nIGVudGlyZWx5Lgor QHByb3BlcnR5IChub25hdG9taWMsIHNldHRlcj1fc2V0U2FtcGxlZFBhZ2VUb3BDb2xvck1heFBl cmNlbnREaWZmZXJlbmNlOikgZG91YmxlIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERp ZmZlcmVuY2UgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19U QkEpKTsKKwogQGVuZAogCiAjaWYgVEFSR0VUX09TX0lQSE9ORQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmgKaW5kZXggNzQwZTA2 Y2IyMzUwLi5lMWNlMjM1N2QyNGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaApAQCAtMzgzLDYgKzM4MywxMyBAQCBmb3Ig dGhpcyBwcm9wZXJ0eS4KIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSkgTlNDb2xvciAq X3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKICNlbmRpZgogCisvLyBPbmx5IHNldCBpZiBg LVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERp ZmZlcmVuY2VdYCBpcyBhIHBvc2l0aXZlIG51bWJlci4KKyNpZiBUQVJHRVRfT1NfSVBIT05FCitA cHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHkpIFVJQ29sb3IgKl9zYW1wbGVkUGFnZVRvcENv bG9yIFdLX0FQSV9BVkFJTEFCTEUoaW9zKFdLX0lPU19UQkEpKTsKKyNlbHNlCitAcHJvcGVydHkg KG5vbmF0b21pYywgcmVhZG9ubHkpIE5TQ29sb3IgKl9zYW1wbGVkUGFnZVRvcENvbG9yIFdLX0FQ SV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RCQSkpOworI2VuZGlmCisKIC0gKHZvaWQpX2dyYW50 QWNjZXNzVG9Bc3NldFNlcnZpY2VzIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RCQSks IGlvcygxNC4wKSk7CiAtICh2b2lkKV9yZXZva2VBY2Nlc3NUb0Fzc2V0U2VydmljZXMgV0tfQVBJ X0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKDE0LjApKTsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCmluZGV4IDI2 ZWM4YzBkYzQzZS4uNTU4ZmQ4YzcwMzBlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCkBAIC01NSw2ICs1NSw4IEBAIHB1Ymxp YzoKICAgICB2b2lkIHRoZW1lQ29sb3JEaWRDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIHBhZ2VF eHRlbmRlZEJhY2tncm91bmRDb2xvcldpbGxDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIHBhZ2VF eHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpIGZpbmFsOworICAgIHZvaWQgc2FtcGxl ZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKSBmaW5hbDsKKyAgICB2b2lkIHNhbXBsZWRQYWdlVG9w Q29sb3JEaWRDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIGlzUGxheWluZ0F1ZGlvV2lsbENoYW5n ZSgpIGZpbmFsOwogICAgIHZvaWQgaXNQbGF5aW5nQXVkaW9EaWRDaGFuZ2UoKSBmaW5hbDsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxD b2NvYS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29j b2EubW0KaW5kZXggYWFlMjkwYjY0NTA0Li43OTJmMGNlOTVjZjcgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW0KKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5tbQpAQCAtNjYs NiArNjYsMTYgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpwYWdlRXh0ZW5kZWRCYWNrZ3Jv dW5kQ29sb3JEaWRDaGFuZ2UoKQogICAgIFttX3dlYlZpZXcgZGlkQ2hhbmdlVmFsdWVGb3JLZXk6 QCJfcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yIl07CiB9CiAKK3ZvaWQgUGFnZUNsaWVudElt cGxDb2NvYTo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKQoreworICAgIFttX3dlYlZp ZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQYWdlVG9wQ29sb3IiXTsKK30KKwor dm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCkK K3sKKyAgICBbbV93ZWJWaWV3IGRpZENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQYWdlVG9w Q29sb3IiXTsKK30KKwogdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjppc1BsYXlpbmdBdWRpb1dp bGxDaGFuZ2UoKQogewogICAgIFttX3dlYlZpZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5Ok5TU3Ry aW5nRnJvbVNlbGVjdG9yKEBzZWxlY3RvcihfaXNQbGF5aW5nQXVkaW8pKV07CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9QYWdlQ2xpZW50LmgKaW5kZXggMTQzOWZkMDA2ODEwLi45NzA4YjgxNjU5MTEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKQEAgLTUwOSw2ICs1MDksOCBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCB2b2lkIHRoZW1lQ29sb3JEaWRDaGFuZ2UoKSB7IH0KICAgICB2aXJ0 dWFsIHZvaWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yV2lsbENoYW5nZSgpIHsgfQogICAg IHZpcnR1YWwgdm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSB7IH0K KyAgICB2aXJ0dWFsIHZvaWQgc2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKSB7IH0KKyAg ICB2aXJ0dWFsIHZvaWQgc2FtcGxlZFBhZ2VUb3BDb2xvckRpZENoYW5nZSgpIHsgfQogICAgIHZp cnR1YWwgdm9pZCBkaWRDaGFuZ2VCYWNrZ3JvdW5kQ29sb3IoKSA9IDA7CiAgICAgdmlydHVhbCB2 b2lkIGlzUGxheWluZ0F1ZGlvV2lsbENoYW5nZSgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgaXNQ bGF5aW5nQXVkaW9EaWRDaGFuZ2UoKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcAppbmRleCA4YzRhNzY3ZmI0YzYuLmY1ZWFkZmY4YjFjNSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xOTE3LDYgKzE5MTcsOSBAQCBDb2xv ciBXZWJQYWdlUHJveHk6OnNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IoKSBjb25zdAogICAgIGlm IChtX3ByZWZlcmVuY2VzLT51c2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xv cigpICYmIG1fdGhlbWVDb2xvci5pc1ZhbGlkKCkpCiAgICAgICAgIHJldHVybiBtX3RoZW1lQ29s b3I7CiAKKyAgICBpZiAobV9wcmVmZXJlbmNlcy0+dXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IoKSAmJiBtX3NhbXBsZWRQYWdlVG9wQ29sb3IuaXNWYWxp ZCgpKQorICAgICAgICByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9yOworCiAgICAgcmV0dXJu IG1fcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yOwogfQogCkBAIC04NTE1LDYgKzg1MTgsMTYg QEAgdm9pZCBXZWJQYWdlUHJveHk6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5n ZShjb25zdCBDb2xvciYgcGFnZUV4dGVuZGUKICAgICBwYWdlQ2xpZW50KCkucGFnZUV4dGVuZGVk QmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCk7CiB9CiAKK3ZvaWQgV2ViUGFnZVByb3h5OjpkaWRT YW1wbGVQYWdlVG9wQ29sb3IoY29uc3QgQ29sb3ImIHNhbXBsZWRQYWdlVG9wQ29sb3IpCit7Cisg ICAgaWYgKG1fc2FtcGxlZFBhZ2VUb3BDb2xvciA9PSBzYW1wbGVkUGFnZVRvcENvbG9yKQorICAg ICAgICByZXR1cm47CisKKyAgICBwYWdlQ2xpZW50KCkuc2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxD aGFuZ2UoKTsKKyAgICBtX3NhbXBsZWRQYWdlVG9wQ29sb3IgPSBzYW1wbGVkUGFnZVRvcENvbG9y OworICAgIHBhZ2VDbGllbnQoKS5zYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCk7Cit9CisK ICNpZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQSSkKIHZvaWQgV2ViUGFnZVByb3h5OjpkaWRG YWlsVG9Jbml0aWFsaXplUGx1Z2luKGNvbnN0IFN0cmluZyYgbWltZVR5cGUsIGNvbnN0IFN0cmlu ZyYgZnJhbWVVUkxTdHJpbmcsIGNvbnN0IFN0cmluZyYgcGFnZVVSTFN0cmluZykKIHsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggYjdkNGEwNTg1MThkLi5jYTk3NTY5 N2JhMDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCkBAIC02NjUsNiAr NjY1LDggQEAgcHVibGljOgogICAgIC8vIHRoZSBtZXNzYWdlIGVudGlyZWx5LgogICAgIFdlYkNv cmU6OkNvbG9yIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNvbnN0IHsgcmV0dXJuIG1f cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yOyB9CiAKKyAgICBXZWJDb3JlOjpDb2xvciBzYW1w bGVkUGFnZVRvcENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9yOyB9 CisKICAgICBXZWJDb3JlOjpDb2xvciBzY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgY29uc3Q7 CiAKICAgICB2b2lkIHZpZXdXaWxsU3RhcnRMaXZlUmVzaXplKCk7CkBAIC0yMDk2LDYgKzIwOTgs NyBAQCBwcml2YXRlOgogICAgIHZvaWQgZGlkQ2hhbmdlUGFnZUNvdW50KHVuc2lnbmVkKTsKICAg ICB2b2lkIHRoZW1lQ29sb3JDaGFuZ2VkKGNvbnN0IFdlYkNvcmU6OkNvbG9yJik7CiAgICAgdm9p ZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoY29uc3QgV2ViQ29yZTo6Q29s b3ImKTsKKyAgICB2b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcihjb25zdCBXZWJDb3JlOjpDb2xv ciYpOwogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVHSU5fQVBJKQogICAgIHZvaWQgZGlkRmFpbFRv SW5pdGlhbGl6ZVBsdWdpbihjb25zdCBTdHJpbmcmIG1pbWVUeXBlLCBjb25zdCBTdHJpbmcmIGZy YW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBhZ2VVUkxTdHJpbmcpOwogICAgIHZvaWQgZGlk QmxvY2tJbnNlY3VyZVBsdWdpblZlcnNpb24oY29uc3QgU3RyaW5nJiBtaW1lVHlwZSwgY29uc3Qg U3RyaW5nJiBwbHVnaW5VUkxTdHJpbmcsIGNvbnN0IFN0cmluZyYgZnJhbWVVUkxTdHJpbmcsIGNv bnN0IFN0cmluZyYgcGFnZVVSTFN0cmluZywgYm9vbCByZXBsYWNlbWVudE9ic2N1cmVkKTsKQEAg LTI2NDEsNiArMjY0NCw3IEBAIHByaXZhdGU6CiAgICAgV2ViQ29yZTo6Q29sb3IgbV90aGVtZUNv bG9yOwogICAgIFdlYkNvcmU6OkNvbG9yIG1fdW5kZXJsYXlDb2xvcjsKICAgICBXZWJDb3JlOjpD b2xvciBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKKyAgICBXZWJDb3JlOjpDb2xvciBt X3NhbXBsZWRQYWdlVG9wQ29sb3I7CiAKICAgICBib29sIG1fdXNlRml4ZWRMYXlvdXQgeyBmYWxz ZSB9OwogICAgIFdlYkNvcmU6OkludFNpemUgbV9maXhlZExheW91dFNpemU7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4gYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KaW5kZXggMTJiMTQ3 MWQ0ZjIzLi5iMTU2ODE5ODFkOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KQEAgLTc5LDYgKzc5LDcgQEAgbWVzc2FnZXMgLT4gV2Vi UGFnZVByb3h5IHsKICAgICBEaWRDaGFuZ2VQYWdlQ291bnQodW5zaWduZWQgcGFnZUNvdW50KQog ICAgIFRoZW1lQ29sb3JDaGFuZ2VkKFdlYkNvcmU6OkNvbG9yIHRoZW1lQ29sb3IpCiAgICAgUGFn ZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKFdlYkNvcmU6OkNvbG9yIGJhY2tncm91 bmRDb2xvcikKKyAgICBEaWRTYW1wbGVQYWdlVG9wQ29sb3IoV2ViQ29yZTo6Q29sb3Igc2FtcGxl ZFBhZ2VUb3BDb2xvcikKICNpZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQSSkKICAgICBEaWRG YWlsVG9Jbml0aWFsaXplUGx1Z2luKFN0cmluZyBtaW1lVHlwZSwgU3RyaW5nIGZyYW1lVVJMU3Ry aW5nLCBTdHJpbmcgcGFnZVVSTFN0cmluZykKICAgICBEaWRCbG9ja0luc2VjdXJlUGx1Z2luVmVy c2lvbihTdHJpbmcgbWltZVR5cGUsIFN0cmluZyBwbHVnaW5VUkxTdHJpbmcsIFN0cmluZyBmcmFt ZVVSTFN0cmluZywgU3RyaW5nIHBhZ2VVUkxTdHJpbmcsIGJvb2wgcmVwbGFjZW1lbnRPYnNjdXJl ZCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJDaHJvbWVDbGllbnQuY3BwIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L1dlYkNocm9tZUNsaWVudC5jcHAKaW5kZXggM2Y1YjYwM2MyY2NjLi5hMzFlZTcyM2RlYjEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJD aHJvbWVDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3Vw cG9ydC9XZWJDaHJvbWVDbGllbnQuY3BwCkBAIC0xMTY0LDYgKzExNjQsMTEgQEAgdm9pZCBXZWJD aHJvbWVDbGllbnQ6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpIGNvbnN0 CiAgICAgbV9wYWdlLnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpOwogfQog Cit2b2lkIFdlYkNocm9tZUNsaWVudDo6ZGlkU2FtcGxlUGFnZVRvcENvbG9yKCkgY29uc3QKK3sK KyAgICBtX3BhZ2UuZGlkU2FtcGxlUGFnZVRvcENvbG9yKCk7Cit9CisKIHZvaWQgV2ViQ2hyb21l Q2xpZW50Ojp3aGVlbEV2ZW50SGFuZGxlcnNDaGFuZ2VkKGJvb2wgaGFzSGFuZGxlcnMpCiB7CiAg ICAgbV9wYWdlLndoZWVsRXZlbnRIYW5kbGVyc0NoYW5nZWQoaGFzSGFuZGxlcnMpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNs aWVudC5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9t ZUNsaWVudC5oCmluZGV4IDFlMzYwZTMwZDM0YS4uZjBjYWQ1YzhlZWNkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmgK KysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNs aWVudC5oCkBAIC0zMzAsNiArMzMwLDcgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgdGhlbWVDb2xv ckNoYW5nZWQoKSBjb25zdCBmaW5hbDsKICAgICB2b2lkIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRD b2xvckRpZENoYW5nZSgpIGNvbnN0IGZpbmFsOworICAgIHZvaWQgZGlkU2FtcGxlUGFnZVRvcENv bG9yKCkgY29uc3QgZmluYWw7CiAgICAgCiAgICAgdm9pZCB3aGVlbEV2ZW50SGFuZGxlcnNDaGFu Z2VkKGJvb2wpIGZpbmFsOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dl YlBhZ2UuY3BwCmluZGV4IGNkOWMyYzA4NDE4ZS4uZWM2ZWUxNWJiZDczIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcApAQCAtNjQ0MCw2ICs2NDQwLDEx IEBAIHZvaWQgV2ViUGFnZTo6Zmx1c2hQZW5kaW5nUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9y Q2hhbmdlKCkKICAgICBzZW5kKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlBhZ2VFeHRlbmRlZEJh Y2tncm91bmRDb2xvckRpZENoYW5nZShtX3BhZ2UtPnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xv cigpKSk7CiB9CiAKK3ZvaWQgV2ViUGFnZTo6ZGlkU2FtcGxlUGFnZVRvcENvbG9yKCkKK3sKKyAg ICBzZW5kKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkRpZFNhbXBsZVBhZ2VUb3BDb2xvcihtX3Bh Z2UtPnNhbXBsZWRQYWdlVG9wQ29sb3IoKSkpOworfQorCiB2b2lkIFdlYlBhZ2U6OmZsdXNoUGVu ZGluZ0VkaXRvclN0YXRlVXBkYXRlKCkKIHsKICAgICBpZiAoIW1faGFzUGVuZGluZ0VkaXRvclN0 YXRlVXBkYXRlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViUGFnZS5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCmlu ZGV4IDUxNDY0OWFiNDRmNC4uYjc5YjhlODBkMDY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCkBAIC0xMjQwLDYgKzEyNDAsOCBAQCBwdWJsaWM6CiAgICAg dm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSB7IG1fcGVuZGluZ1Bh Z2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckNoYW5nZSA9IHRydWU7IH0KICAgICB2b2lkIGZsdXNo UGVuZGluZ1BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckNoYW5nZSgpOwogCisgICAgdm9pZCBk aWRTYW1wbGVQYWdlVG9wQ29sb3IoKTsKKwogICAgIHZvaWQgZmx1c2hQZW5kaW5nRWRpdG9yU3Rh dGVVcGRhdGUoKTsKIAogI2lmIEVOQUJMRShSRVNPVVJDRV9MT0FEX1NUQVRJU1RJQ1MpCmRpZmYg LS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTAxYTk0OTUx ODg2Li5lOTI1YmYwZGJhYTEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29s cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAyMS0wNC0yMyAgRGV2aW4gUm91c3NvICA8 ZHJvdXNzb0BhcHBsZS5jb20+CisKKyAgICAgICAgZXhwZXJpbWVudCB3aXRoIGF2ZXJhZ2luZyBz YW1wbGluZyBjb2xvcnMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2UgYXMgdGhlIHNjcm9sbCBh cmVhIGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIyNDk4NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNzYyNTE4ODk+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW06IEFkZGVkLgorICAgICAg ICAoLVtUZXN0S1ZPV3JhcHBlciBpbml0V2l0aE9ic2VydmFibGU6a2V5UGF0aDpjYWxsYmFjazpd KToKKyAgICAgICAgKC1bVGVzdEtWT1dyYXBwZXIgZGVhbGxvY10pOgorICAgICAgICAoLVtUZXN0 S1ZPV3JhcHBlciBvYnNlcnZlVmFsdWVGb3JLZXlQYXRoOm9mT2JqZWN0OmNoYW5nZTpjb250ZXh0 Ol0pOgorICAgICAgICAoY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVy Y2VudERpZmZlcmVuY2UpOgorICAgICAgICAod2FpdEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0No YW5nZUZvckhUTUwpOgorICAgICAgICAoY3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMp OgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLlplcm9NYXhQZXJjZW50RGlmZmVy ZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuTmVnYXRpdmVNYXhQZXJj ZW50RGlmZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuU29saWRD b2xvcik6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3Jz V2l0aG91dE91dGxpZXJCZWxvd01heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1Qu U2FtcGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJlbnRDb2xvcnNXaXRoTGVmdE91dGxpZXJBYm92ZU1h eFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5E aWZmZXJlbnRDb2xvcnNXaXRoTWlkZGxlT3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2Up OgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhS aWdodE91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2Ft cGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJlbnRDb2xvcnNJbmRpdmlkdWFsbHlBYm92ZU1heFBlcmNl bnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJl bnRDb2xvcnNDdW11bGF0aXZlbHlBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAg KFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5FeHBlcmltZW50YWxVc2VTYW1wbGVkUGFnZVRvcENv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcik6CisKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKwogMjAyMS0wNC0y MCAgRGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+CiAKICAgICAgICAgUGFyc2UgYHRo ZW1lX2NvbG9yYCBpbiB3ZWIgYXBwbGljYXRpb24gbWFuaWZlc3RzIGFuZCBwYXNzIGl0IGFsb25n IHRvIGAtW1dLV2ViVmlldyB0aGVtZUNvbG9yXWAKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg YjRmYjFhZjdhNTU1Li4yNTk5OGZlNDE3OWQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC04 NjQsNiArODY0LDcgQEAKIAkJOTNGNTZEQTcxRTVGOTE3NDAwM0VERTg0IC8qIGxpYmljdWNvcmUu ZHlsaWIgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 QzgzRTAzMzFEMEE1RjI3MDBGRUJDRjMgLyogbGliaWN1Y29yZS5keWxpYiAqLzsgfTsKIAkJOTNG NTZEQTkxRTVGOTE5RDAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTNGNTZEQTgxRTVGOTE4MTAwM0VE RTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tICovOyB9OwogCQk5M0Y3RTg2RjE0REM4RTVDMDBD ODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVzX0J1bmRsZS5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0Y3RTg2RTE0 REM4RTVCMDBDODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVzX0J1 bmRsZS5jcHAgKi87IH07CisJCTk1MDk1RjIwMjYyRkZGQTUwMDAwRDkyMCAvKiBTYW1wbGVkUGFn ZVRvcENvbG9yLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gOTUwOTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3IubW0gKi87 IH07CiAJCTk1MEU0Q0MxMjUyRTc1MjQwMDcxNjU5RiAvKiBpT1NTdHlsdXNTdXBwb3J0Lm1tIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTUwRTRDQzAyNTJF NzUyMzAwNzE2NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi87IH07CiAJCTk1M0FCQjM1MjVD MEQ2ODIwMDRDOEI3MyAvKiBQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IubW0gaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5NTNBQkIzNDI1QzBENjgxMDA0 QzhCNzMgLyogUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yLm1tICovOyB9OwogCQk5NUE1MjQ5 NTI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5tbSBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1QTUyNDk0MjU4MUExMEQwMDQ2MUZF OSAvKiBXS1dlYlZpZXdUaGVtZUNvbG9yLm1tICovOyB9OwpAQCAtMjU1Miw2ICsyNTUzLDcgQEAK IAkJOTNGNTZEQTgxRTVGOTE4MTAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV0tXZWJWaWV3U25hcHNob3QubW07 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzRjdFODZCMTREQzhFNEQwMEM4NEE5OSAv KiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXRGcmFtZXMuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJh bWVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTNGN0U4NkUxNERDOEU1QjAw Qzg0QTk5IC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1lc19CdW5kbGUuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmlyc3RWaXN1YWxseU5v bkVtcHR5TGF5b3V0RnJhbWVzX0J1bmRsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTk1MDk1RjFGMjYyRkZGQTUwMDAwRDkyMCAvKiBTYW1wbGVkUGFnZVRvcENvbG9yLm1tICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gU2FtcGxlZFBhZ2VUb3BDb2xv ci5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTUwRTRDQzAyNTJFNzUyMzAwNzE2 NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpj cHA7IHBhdGggPSBpT1NTdHlsdXNTdXBwb3J0Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk5NTNBQkIzNDI1QzBENjgxMDA0QzhCNzMgLyogUGFnZUV4dGVuZGVkQmFja2dyb3VuZENv bG9yLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUGFnZUV4dGVu ZGVkQmFja2dyb3VuZENvbG9yLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5NUE1 MjQ5NDI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5tbSAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdLV2ViVmlld1RoZW1lQ29sb3IubW07IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zNTIxLDYgKzM1MjMsNyBAQAogCQkJCUExODBD MEY5MUVFNjdERjAwMDQ2OEY0NyAvKiBSdW5PcGVuUGFuZWwubW0gKi8sCiAJCQkJRjREMjk4NkQy MEZFRTczNzAwOTJENjM2IC8qIFJ1blNjcmlwdEFmdGVyRG9jdW1lbnRMb2FkLm1tICovLAogCQkJ CTVDQTk4NTUxMjExM0NCOEMwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0gKi8sCisJCQkJOTUw OTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3IubW0gKi8sCiAJCQkJ Q0UwOTQ3MzYyMDYzMjIzQjAwM0M5QkEwIC8qIFNjaGVtZVJlZ2lzdHJ5Lm1tICovLAogCQkJCTUx RUIxMjkzMUZERjA1MDUwMEE1QTFCRCAvKiBTZXJ2aWNlV29ya2VyQmFzaWMubW0gKi8sCiAJCQkJ NUM2ODM0NzEyMzVBQ0M3QzAwNDFFNkIxIC8qIFNlcnZpY2VXb3JrZXJUQ1BTZXJ2ZXIuaCAqLywK QEAgLTU2MzAsNiArNTYzMyw3IEBACiAJCQkJQTE4MEMwRkExRUU2N0RGMDAwNDY4RjQ3IC8qIFJ1 bk9wZW5QYW5lbC5tbSBpbiBTb3VyY2VzICovLAogCQkJCUY0RDI5ODZFMjBGRUU3MzcwMDkyRDYz NiAvKiBSdW5TY3JpcHRBZnRlckRvY3VtZW50TG9hZC5tbSBpbiBTb3VyY2VzICovLAogCQkJCTVD QTk4NTUzMjExM0NGNzgwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0gaW4gU291cmNlcyAqLywK KwkJCQk5NTA5NUYyMDI2MkZGRkE1MDAwMEQ5MjAgLyogU2FtcGxlZFBhZ2VUb3BDb2xvci5tbSBp biBTb3VyY2VzICovLAogCQkJCUNEQ0ZBN0FBMUU0NTE4MzIwMEMyNDMzRCAvKiBTYW1wbGVNYXAu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0UwOTQ3MzcyMDYzMjIzQjAwM0M5QkEwIC8qIFNjaGVt ZVJlZ2lzdHJ5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0RDMDkzMkIyMUM4NzJDMTAwMzBDNEIw IC8qIFNjcm9sbGluZ0RvZXNOb3RQYXVzZU1lZGlhLm1tIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9w Q29sb3IubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQ YWdlVG9wQ29sb3IubW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5l OGIyYmYyNDNkYzAKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW0KQEAgLTAsMCArMSwyOTIgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMjEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBB TkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaW1wb3J0ICJjb25maWcuaCIKKworI2ltcG9ydCAiVGVzdENvY29hLmgiCisj aW1wb3J0ICJUZXN0V0tXZWJWaWV3LmgiCisjaW1wb3J0ICJVdGlsaXRpZXMuaCIKKyNpbXBvcnQg PFdlYktpdC9XS1ByZWZlcmVuY2VzUHJpdmF0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L1dLV2ViVmll d0NvbmZpZ3VyYXRpb25Qcml2YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3UHJpdmF0 ZS5oPgorI2ltcG9ydCA8V2ViS2l0L19XS0ludGVybmFsRGVidWdGZWF0dXJlLmg+CisjaW1wb3J0 IDx3dGYvRnVuY3Rpb24uaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0 Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKworI2RlZmluZSBFWFBFQ1RfSU5fUkFOR0UoYWN0dWFs LCBtaW4sIG1heCkgXAorICAgIEVYUEVDVF9HRShhY3R1YWwsIG1pbik7IFwKKyAgICBFWFBFQ1Rf TEUoYWN0dWFsLCBtYXgpOworCitjb25zdGV4cHIgQ0dGbG9hdCByZWRDb2xvckNvbXBvbmVudHNb NF0gPSB7IDEsIDAsIDAsIDEgfTsKKworQGludGVyZmFjZSBUZXN0S1ZPV3JhcHBlciA6IE5TT2Jq ZWN0CisKKy0gKGluc3RhbmNldHlwZSlpbml0V2l0aE9ic2VydmFibGU6KE5TT2JqZWN0ICopb2Jz ZXJ2YWJsZSBrZXlQYXRoOihOU1N0cmluZyAqKWtleVBhdGggY2FsbGJhY2s6KEZ1bmN0aW9uPHZv aWQoKT4mJiljYWxsYmFjazsKKworQGVuZAorCitAaW1wbGVtZW50YXRpb24gVGVzdEtWT1dyYXBw ZXIgeworICAgIFJldGFpblB0cjxOU09iamVjdCAqPiBfb2JzZXJ2YWJsZTsKKyAgICBSZXRhaW5Q dHI8TlNTdHJpbmc+IF9rZXlQYXRoOworICAgIEZ1bmN0aW9uPHZvaWQoKT4gX2NhbGxiYWNrOwor fQorCistIChpbnN0YW5jZXR5cGUpaW5pdFdpdGhPYnNlcnZhYmxlOihOU09iamVjdCAqKW9ic2Vy dmFibGUga2V5UGF0aDooTlNTdHJpbmcgKilrZXlQYXRoIGNhbGxiYWNrOihGdW5jdGlvbjx2b2lk KCk+JiYpY2FsbGJhY2sKK3sKKyAgICBpZiAoIShzZWxmID0gW3N1cGVyIGluaXRdKSkKKyAgICAg ICAgcmV0dXJuIG5pbDsKKworICAgIF9vYnNlcnZhYmxlID0gb2JzZXJ2YWJsZTsKKyAgICBfa2V5 UGF0aCA9IGtleVBhdGg7CisgICAgX2NhbGxiYWNrID0gV1RGTW92ZShjYWxsYmFjayk7CisKKyAg ICBbX29ic2VydmFibGUgYWRkT2JzZXJ2ZXI6c2VsZiBmb3JLZXlQYXRoOl9rZXlQYXRoLmdldCgp IG9wdGlvbnM6MCBjb250ZXh0Om5pbF07CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9p ZClkZWFsbG9jCit7CisgICAgW19vYnNlcnZhYmxlIHJlbW92ZU9ic2VydmVyOnNlbGYgZm9yS2V5 UGF0aDpfa2V5UGF0aC5nZXQoKSBjb250ZXh0Om51bGxwdHJdOworCisgICAgW3N1cGVyIGRlYWxs b2NdOworfQorCistICh2b2lkKW9ic2VydmVWYWx1ZUZvcktleVBhdGg6KE5TU3RyaW5nICopa2V5 UGF0aCBvZk9iamVjdDooaWQpb2JqZWN0IGNoYW5nZTooTlNEaWN0aW9uYXJ5ICopY2hhbmdlIGNv bnRleHQ6KHZvaWQgKiljb250ZXh0Cit7CisgICAgX2NhbGxiYWNrKCk7Cit9CisKK0BlbmQKKwor ZW51bSBjbGFzcyBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvciA6IGJvb2wgeyBZZXMsIE5vIH07CitzdGF0aWMgUmV0YWluUHRyPFRlc3RXS1dlYlZpZXc+ IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNl KGRvdWJsZSBzYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UsIFVzZVNhbXBs ZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHVzZVNhbXBsZWRQYWdl VG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yID0gVXNlU2FtcGxlZFBhZ2VUb3BD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6Ok5vKQoreworICAgIGF1dG8gY29uZmln dXJhdGlvbiA9IGFkb3B0TlMoW1tXS1dlYlZpZXdDb25maWd1cmF0aW9uIGFsbG9jXSBpbml0XSk7 CisgICAgW2NvbmZpZ3VyYXRpb24gX3NldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlm ZmVyZW5jZTpzYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2VdOworCisgICAg Zm9yIChfV0tJbnRlcm5hbERlYnVnRmVhdHVyZSAqZmVhdHVyZSBpbiBbV0tQcmVmZXJlbmNlcyBf aW50ZXJuYWxEZWJ1Z0ZlYXR1cmVzXSkgeworICAgICAgICBpZiAoW2ZlYXR1cmUua2V5IGlzRXF1 YWxUb1N0cmluZzpAIlVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3Vu ZENvbG9yIl0pIHsKKyAgICAgICAgICAgIFtbY29uZmlndXJhdGlvbiBwcmVmZXJlbmNlc10gX3Nl dEVuYWJsZWQ6KHVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENv bG9yID09IFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9y OjpZZXMpIGZvckludGVybmFsRGVidWdGZWF0dXJlOmZlYXR1cmVdOworICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gYWRvcHROUyhbW1Rlc3RXS1dlYlZp ZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0TWFrZSgwLCAwLCA4MDAsIDYwMCkgY29uZmln dXJhdGlvbjpjb25maWd1cmF0aW9uLmdldCgpXSk7Cit9CisKK3N0YXRpYyB2b2lkIHdhaXRGb3JT YW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKFRlc3RXS1dlYlZpZXcgKndlYlZpZXcs IFN0cmluZyYmIGh0bWwpCit7CisgICAgYm9vbCBkb25lID0gZmFsc2U7CisgICAgYXV0byBzYW1w bGVkUGFnZVRvcENvbG9yT2JzZXJ2ZXIgPSBhZG9wdE5TKFtbVGVzdEtWT1dyYXBwZXIgYWxsb2Nd IGluaXRXaXRoT2JzZXJ2YWJsZTp3ZWJWaWV3IGtleVBhdGg6QCJfc2FtcGxlZFBhZ2VUb3BDb2xv ciIgY2FsbGJhY2s6WyZdIHsKKyAgICAgICAgZG9uZSA9IHRydWU7CisgICAgfV0pOworICAgIFt3 ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0 ZUNoaWxkRnJhbWVzUGFpbnQ6V1RGTW92ZShodG1sKV07CisgICAgVGVzdFdlYktpdEFQSTo6VXRp bDo6cnVuKCZkb25lKTsKK30KKworc3RhdGljIFN0cmluZyBjcmVhdGVIVE1MR3JhZGllbnRXaXRo Q29sb3JTdG9wcyhWZWN0b3I8U3RyaW5nPiYmIGNvbG9yU3RvcHMpCit7CisgICAgRVhQRUNUX0dF KGNvbG9yU3RvcHMuc2l6ZSgpLCAyVUwpOworCisgICAgU3RyaW5nQnVpbGRlciBncmFkaWVudEJ1 aWxkZXI7CisgICAgZ3JhZGllbnRCdWlsZGVyLmFwcGVuZCgiPGJvZHkgc3R5bGU9XCJiYWNrZ3Jv dW5kLWltYWdlOiBsaW5lYXItZ3JhZGllbnQodG8gcmlnaHQiX3MpOworICAgIGZvciAoYXV0byYm IGNvbG9yU3RvcCA6IFdURk1vdmUoY29sb3JTdG9wcykpIHsKKyAgICAgICAgZ3JhZGllbnRCdWls ZGVyLmFwcGVuZCgiLCAiX3MpOworICAgICAgICBncmFkaWVudEJ1aWxkZXIuYXBwZW5kKFdURk1v dmUoY29sb3JTdG9wKSk7CisgICAgfQorICAgIGdyYWRpZW50QnVpbGRlci5hcHBlbmQoIilcIj5U ZXN0Il9zKTsKKyAgICByZXR1cm4gZ3JhZGllbnRCdWlsZGVyLnRvU3RyaW5nKCk7Cit9CisKK1RF U1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgWmVyb01heFBlcmNlbnREaWZmZXJlbmNlKQoreworICAg IGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBl cmNlbnREaWZmZXJlbmNlKDAuMCk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVk UGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJp bmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFk aWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pXTsKKyAgICBFWFBFQ1RfVFJVRSgh W3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRv cENvbG9yLCBOZWdhdGl2ZU1heFBlcmNlbnREaWZmZXJlbmNlKQoreworICAgIGF1dG8gd2ViVmll dyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJl bmNlKC0wLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29s b3JdKTsKKworICAgIFt3ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRV bnRpbEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENv bG9yU3RvcHMoeyAicmVkIiwgInJlZCIgfSldOworICAgIEVYUEVDVF9UUlVFKCFbd2ViVmlldyBf c2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIFNv bGlkQ29sb3IpCit7CisgICAgYXV0byBzUkdCQ29sb3JTcGFjZSA9IGFkb3B0Q0YoQ0dDb2xvclNw YWNlQ3JlYXRlV2l0aE5hbWUoa0NHQ29sb3JTcGFjZVNSR0IpKTsKKyAgICBhdXRvIHJlZENvbG9y ID0gYWRvcHRDRihDR0NvbG9yQ3JlYXRlKHNSR0JDb2xvclNwYWNlLmdldCgpLCByZWRDb2xvckNv bXBvbmVudHMpKTsKKworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxl ZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKDAuMDUpOworICAgIEVYUEVDVF9UUlVF KCFbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgd2FpdEZvclNhbXBsZWRQ YWdlVG9wQ29sb3JUb0NoYW5nZUZvckhUTUwod2ViVmlldy5nZXQoKSwgY3JlYXRlSFRNTEdyYWRp ZW50V2l0aENvbG9yU3RvcHMoeyAicmVkIiwgInJlZCIgfSkpOworICAgIEVYUEVDVF9UUlVFKENH Q29sb3JFcXVhbFRvQ29sb3IoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3Is IHJlZENvbG9yLmdldCgpKSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVy ZW50Q29sb3JzV2l0aG91dE91dGxpZXJCZWxvd01heFBlcmNlbnREaWZmZXJlbmNlKQoreworICAg IGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBl cmNlbnREaWZmZXJlbmNlKDAuMDUpOworICAgIEVYUEVDVF9UUlVFKCFbd2ViVmlldyBfc2FtcGxl ZFBhZ2VUb3BDb2xvcl0pOworCisgICAgd2FpdEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0NoYW5n ZUZvckhUTUwod2ViVmlldy5nZXQoKSwgY3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMo eworICAgICAgICAiY29sb3Ioc3JnYiAwLjUxIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdi IDAuNTIgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41MyAxIDEpIl9zLAorICAgICAg ICAiY29sb3Ioc3JnYiAwLjU0IDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTUgMSAx KSJfcywKKyAgICB9KSk7CisKKyAgICBhdXRvIGNvbXBvbmVudHMgPSBDR0NvbG9yR2V0Q29tcG9u ZW50cyhbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0uQ0dDb2xvcik7CisgICAgRVhQRUNU X0lOX1JBTkdFKGNvbXBvbmVudHNbMF0sIDAuNTI1LCAwLjUzNSk7CisgICAgRVhQRUNUX0VRKGNv bXBvbmVudHNbMV0sIDEpOworICAgIEVYUEVDVF9FUShjb21wb25lbnRzWzJdLCAxKTsKKyAgICBF WFBFQ1RfRVEoY29tcG9uZW50c1szXSwgMSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xv ciwgRGlmZmVyZW50Q29sb3JzV2l0aExlZnRPdXRsaWVyQWJvdmVNYXhQZXJjZW50RGlmZmVyZW5j ZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9w Q29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZp ZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENv bG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhD b2xvclN0b3BzKHsKKyAgICAgICAgImNvbG9yKHNyZ2IgMC4wMCAxIDEpIl9zLCAvLyBvdXRsaWVy CisgICAgICAgICJjb2xvcihzcmdiIDAuNTEgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2Ig MC41MiAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjUzIDEgMSkiX3MsCisgICAgICAg ICJjb2xvcihzcmdiIDAuNTQgMSAxKSJfcywKKyAgICB9KSk7CisKKyAgICBhdXRvIGNvbXBvbmVu dHMgPSBDR0NvbG9yR2V0Q29tcG9uZW50cyhbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0u Q0dDb2xvcik7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMF0sIDAuNTIsIDAuNTMp OworICAgIEVYUEVDVF9FUShjb21wb25lbnRzWzFdLCAxKTsKKyAgICBFWFBFQ1RfRVEoY29tcG9u ZW50c1syXSwgMSk7CisgICAgRVhQRUNUX0VRKGNvbXBvbmVudHNbM10sIDEpOworfQorCitURVNU KFNhbXBsZWRQYWdlVG9wQ29sb3IsIERpZmZlcmVudENvbG9yc1dpdGhNaWRkbGVPdXRsaWVyQWJv dmVNYXhQZXJjZW50RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJW aWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAg ICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3 ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0 ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMoeworICAg ICAgICAiY29sb3Ioc3JnYiAwLjUxIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTIg MSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC4wMCAxIDEpIl9zLCAvLyBvdXRsaWVyCisg ICAgICAgICJjb2xvcihzcmdiIDAuNTMgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41 NCAxIDEpIl9zLAorICAgIH0pXTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQ YWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBEaWZmZXJlbnRD b2xvcnNXaXRoUmlnaHRPdXRsaWVyQWJvdmVNYXhQZXJjZW50RGlmZmVyZW5jZSkKK3sKKyAgICBh dXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJj ZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQ YWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VG b3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsK KyAgICAgICAgImNvbG9yKHNyZ2IgMC41MSAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAw LjUyIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTMgMSAxKSJfcywKKyAgICAgICAg ImNvbG9yKHNyZ2IgMC41NCAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjAwIDEgMSki X3MsIC8vIG91dGxpZXIKKyAgICB9KSk7CisKKyAgICBhdXRvIGNvbXBvbmVudHMgPSBDR0NvbG9y R2V0Q29tcG9uZW50cyhbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0uQ0dDb2xvcik7Cisg ICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMF0sIDAuNTIsIDAuNTMpOworICAgIEVYUEVD VF9FUShjb21wb25lbnRzWzFdLCAxKTsKKyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1syXSwgMSk7 CisgICAgRVhQRUNUX0VRKGNvbXBvbmVudHNbM10sIDEpOworfQorCitURVNUKFNhbXBsZWRQYWdl VG9wQ29sb3IsIERpZmZlcmVudENvbG9yc0luZGl2aWR1YWxseUFib3ZlTWF4UGVyY2VudERpZmZl cmVuY2UpCit7CisgICAgYXV0byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFn ZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UoMC4wNSk7CisgICAgRVhQRUNUX1RSVUUoIVt3 ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91 c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50 OmNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAgICAgImNvbG9yKHNyZ2Ig MC41IDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNiAxIDEpIl9zLAorICAgICAgICAi Y29sb3Ioc3JnYiAwLjcgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC44IDEgMSkiX3Ms CisgICAgICAgICJjb2xvcihzcmdiIDAuOSAxIDEpIl9zLAorICAgIH0pXTsKKyAgICBFWFBFQ1Rf VFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVk UGFnZVRvcENvbG9yLCBEaWZmZXJlbnRDb2xvcnNDdW11bGF0aXZlbHlBYm92ZU1heFBlcmNlbnRE aWZmZXJlbmNlKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxl ZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKDAuMDUpOworICAgIEVYUEVDVF9UUlVF KCFbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXcgc3luY2hy b25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQ YWludDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7CisgICAgICAgICJjb2xvcihz cmdiIDAuNTEgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41MyAxIDEpIl9zLAorICAg ICAgICAiY29sb3Ioc3JnYiAwLjU1IDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTcg MSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41OSAxIDEpIl9zLAorICAgIH0pXTsKKyAg ICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworI2lm IFBMQVRGT1JNKElPU19GQU1JTFkpCisKKy8vIFRoZXJlJ3Mgbm8gQVBJL1NQSSB0byBnZXQgdGhl IGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNjcm9sbCBhcmVhIG9uIG1hY09TLgorCitURVNUKFdL V2ViVmlld1RoZW1lQ29sb3IsIEV4cGVyaW1lbnRhbFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JT Y3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKQoreworICAgIGF1dG8gc1JHQkNvbG9yU3BhY2UgPSBh ZG9wdENGKENHQ29sb3JTcGFjZUNyZWF0ZVdpdGhOYW1lKGtDR0NvbG9yU3BhY2VTUkdCKSk7Cisg ICAgYXV0byByZWRDb2xvciA9IGFkb3B0Q0YoQ0dDb2xvckNyZWF0ZShzUkdCQ29sb3JTcGFjZS5n ZXQoKSwgcmVkQ29sb3JDb21wb25lbnRzKSk7CisKKyAgICBhdXRvIHdlYlZpZXdXaXRob3V0VGhl bWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgPSBjcmVhdGVXZWJWaWV3V2l0aFNh bXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSgwLjA1LCBVc2VTYW1wbGVkUGFn ZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcjo6Tm8pOworICAgIEVYUEVDVF9U UlVFKCFbd2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xv ciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5n QW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGll bnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOworICAgIEVYUEVDVF9UUlVFKCFb d2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBfc2Ft cGxlZFBhZ2VUb3BDb2xvcl0pOworICAgIEVYUEVDVF9UUlVFKCFbd2ViVmlld1dpdGhvdXRUaGVt ZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBzY3JvbGxWaWV3XSk7CisKKyAgICB3 YWl0Rm9yU2FtcGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRNTCh3ZWJWaWV3V2l0aG91dFRo ZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yLmdldCgpLCBjcmVhdGVIVE1MR3Jh ZGllbnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAicmVkIiB9KSk7CisgICAgRVhQRUNUX1RSVUUo Q0dDb2xvckVxdWFsVG9Db2xvcihbd2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJl YUJhY2tncm91bmRDb2xvciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0uQ0dDb2xvciwgcmVkQ29sb3Iu Z2V0KCkpKTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Nyb2xsVmlld10pOworCisgICAgYXV0byB3ZWJWaWV3 V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yID0gY3JlYXRlV2ViVmll d1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UoMC4wNSwgVXNlU2Ft cGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6Olllcyk7CisgICAg RVhQRUNUX1RSVUUoIVt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3Vu ZENvbG9yIF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2ViVmlld1dpdGhvdXRUaGVt ZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBzeW5jaHJvbm91c2x5TG9hZEhUTUxT dHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxH cmFkaWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJibHVlIiB9KV07CisgICAgRVhQRUNUX1RS VUUoIVt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIF9z YW1wbGVkUGFnZVRvcENvbG9yXSk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3V2l0aFRoZW1l Q29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9sbFZpZXddKTsKKworICAgIHdh aXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXdXaXRob3V0VGhl bWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IuZ2V0KCksIGNyZWF0ZUhUTUxHcmFk aWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1RfVFJVRShD R0NvbG9yRXF1YWxUb0NvbG9yKFt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFj a2dyb3VuZENvbG9yIF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0NvbG9yLCByZWRDb2xvci5nZXQo KSkpOworICAgIEVYUEVDVF9UUlVFKENHQ29sb3JFcXVhbFRvQ29sb3IoW3dlYlZpZXdXaXRoVGhl bWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Nyb2xsVmlld10uYmFja2dyb3Vu ZENvbG9yLkNHQ29sb3IsIHJlZENvbG9yLmdldCgpKSk7Cit9CisKKyNlbmRpZiAvLyBQTEFURk9S TShJT1NfRkFNSUxZKQo= 426928 2021-04-23 11:06:39 -0700 2021-04-28 15:55:34 -0700 Patch 76251889.diff text/plain 51312 hi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggNzczNThhM2ZlYTAzLi44OTg4Y2RmZDdmZGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIw MjEtMDQtMjMgIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4 cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9m IHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlcy55YW1sOgorICAg ICAgICBBZGQgYSBgU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlYCBzZXR0 aW5nIHRoYXQgY29udHJvbHMgYm90aCB3aGV0aGVyIG9yIG5vdCB0bworICAgICAgICBzYW1wbGUg Y29sb3JzIGZyb20gdGhlIHRvcCBvZiB0aGUgcGFnZSAob25seSBpZiB2YWx1ZSA+IDApIGFuZCB0 aGUgbWF4IHBlcmNlbnQgZGlmZmVyZW5jZQorICAgICAgICBhbGxvd2VkIGFjcm9zcyBhbGwgc2Ft cGxlcy4KKworICAgICAgICAqIFNjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRl cm5hbC55YW1sOgorICAgICAgICBBZGQgYSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9s bEFyZWFCYWNrZ3JvdW5kQ29sb3JgIGludGVybmFsIHNldHRpbmcgdGhhdCBjb250cm9scworICAg ICAgICB3aGV0aGVyIHRoZSBzYW1wbGVkIHBhZ2UgdG9wIGNvbG9yIGNhbiBiZSB1c2VkIGFzIHRo ZSBvdmVyc2Nyb2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvci4KKwogMjAyMS0wNC0yMCAgQnJlbnQg RnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbQ29jb2FdIFByZXZlbnQg R1BVIGFuZCBXZWJDb250ZW50IHByb2Nlc3NlcyBmcm9tIGF0dGVtcHRpbmcgdG8gY29ubmVjdCB0 byB0aGUgQXBwU1NPIHNlcnZpY2UgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJl ZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMueWFtbCBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJl bmNlcy9XZWJQcmVmZXJlbmNlcy55YW1sCmluZGV4IDU2YzQyNjc4ZGY1MC4uZWM1YWNlNWNmZDFj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5j ZXMueWFtbAorKysgYi9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5j ZXMueWFtbApAQCAtMTgyMyw2ICsxODIzLDE2IEBAIFNhZmVCcm93c2luZ0VuYWJsZWQ6CiAgICAg V2ViS2l0OgogICAgICAgZGVmYXVsdDogdHJ1ZQogCitTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVy Y2VudERpZmZlcmVuY2U6CisgIHR5cGU6IGRvdWJsZQorICBkZWZhdWx0VmFsdWU6CisgICAgV2Vi S2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDogMAorICAgIFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6 IDAKKyAgICBXZWJDb3JlOgorICAgICAgZGVmYXVsdDogMAorCiBTYW5zU2VyaWZGb250RmFtaWx5 OgogICB0eXBlOiBTdHJpbmcKICAgd2ViS2l0TGVnYWN5UHJlZmVyZW5jZUtleTogV2ViS2l0U2Fu c1NlcmlmRm9udApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dl YlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbCBiL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNl cy9XZWJQcmVmZXJlbmNlc0ludGVybmFsLnlhbWwKaW5kZXggOGEzYTRjMDdjZjk2Li5iZDIzNDU4 NWM2YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVm ZXJlbmNlc0ludGVybmFsLnlhbWwKKysrIGIvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2Vz L1dlYlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbApAQCAtNzUwLDYgKzc1MCwxOCBAQCBVc2VHUFVQ cm9jZXNzRm9yV2ViR0xFbmFibGVkOgogICAgIFdlYktpdDoKICAgICAgIGRlZmF1bHQ6IGRlZmF1 bHRVc2VHUFVQcm9jZXNzRm9yV2ViR0xFbmFibGVkKCkKIAorVXNlU2FtcGxlZFBhZ2VUb3BDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6CisgIHR5cGU6IGJvb2wKKyAgaHVtYW5SZWFk YWJsZU5hbWU6ICJVc2Ugc2FtcGxlZCBwYWdlIHRvcCBjb2xvciBmb3Igc2Nyb2xsIGFyZWEgYmFj a2dyb3VuZCBjb2xvciIKKyAgaHVtYW5SZWFkYWJsZURlc2NyaXB0aW9uOiAiVXNlIHNhbXBsZWQg cGFnZSB0b3AgY29sb3IgZm9yIHNjcm9sbCBhcmVhIGJhY2tncm91bmQgY29sb3IiCisgIGRlZmF1 bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAgIFdl YktpdDoKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisgICAgV2ViQ29yZToKKyAgICAgIGRlZmF1bHQ6 IGZhbHNlCisKIFVzZVRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOgogICB0 eXBlOiBib29sCiAgIGh1bWFuUmVhZGFibGVOYW1lOiAiVXNlIHRoZW1lLWNvbG9yIGZvciBzY3Jv bGwgYXJlYSBiYWNrZ3JvdW5kIGNvbG9yIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDM4MjA1NDc0YWJjNi4uMWI2 YzgwOTRjOTAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDggQEAKKzIwMjEtMDQtMjMgIERldmlu IFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4cGVyaW1lbnQgd2l0aCBh dmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9mIHRoZSBwYWdlIGFzIHRo ZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzc2MjUxODg5 PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3Rz OiBTYW1wbGVkUGFnZVRvcENvbG9yLlplcm9NYXhQZXJjZW50RGlmZmVyZW5jZQorICAgICAgICAg ICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xvci5OZWdhdGl2ZU1heFBlcmNlbnREaWZmZXJlbmNlCisg ICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLlNvbGlkQ29sb3IKKyAgICAgICAgICAg ICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aG91dE91dGxpZXJCZWxv d01heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9y LkRpZmZlcmVudENvbG9yc1dpdGhMZWZ0T3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UK KyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aE1p ZGRsZU91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1w bGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhSaWdodE91dGxpZXJBYm92ZU1heFBl cmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZl cmVudENvbG9yc0luZGl2aWR1YWxseUFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UKKyAgICAgICAg ICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzQ3VtdWxhdGl2ZWx5QWJv dmVNYXhQZXJjZW50RGlmZmVyZW5jZQorICAgICAgICAgICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xv ci5FeHBlcmltZW50YWxVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91 bmRDb2xvcgorCisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpE b2N1bWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvciBjb25zdCk6IEFkZGVkLgorICAgICAgICAqIGRv bS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZW5xdWV1ZVBhaW50 VGltaW5nRW50cnlJZk5lZWRlZCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGV0ZXJt aW5lU2FtcGxlZFBhZ2VUb3BDb2xvcik6IEFkZGVkLgorICAgICAgICBXYWl0IHVudGlsIHRoZSBm aXJzdCBjb250ZW50ZnVsIHBhaW50IGJlZm9yZSBzYW1wbGluZy4gRG9uJ3Qgc2FtcGxlIGlmIHRo YXQgbG9jYXRpb24gd291bGQKKyAgICAgICAgZmFsbCBpbnRvIGEgM3JkLXBhcnR5IGA8aWZyYW1l PmAuIEN1cnJlbnRseSB1c2UgNSBzbmFwc2hvdHMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2Us CisgICAgICAgIGFsbG93aW5nIGZvciBvbmUgb2YgZWl0aGVyIHRoZSBmaXJzdCBvciBsYXN0IHNu YXBzaG90IHRvIGJlIGFuIG91dGxpZXIsIHdoaWNoIGlzIG5vdAorICAgICAgICBpbmNsdWRlZCBp biB0aGUgYXZlcmFnZSBvZiB0aGUgb3RoZXIgc25hcHNob3RzIHRoYXQncyB1c2VkIGFzIHRoZSBm aW5hbCBjb2xvciB2YWx1ZS4gSWYgdGhlCisgICAgICAgIHBlcmNlbnRhZ2UgZGlmZmVyZW5jZSBi ZXR3ZWVuIGFueSB0d28gc25hcHNob3RzICh1bmxlc3MgaXQncyB0aGUgZmlyc3Qgb3IgbGFzdCBz bmFwc2hvdCBhcworICAgICAgICBkZXNjcmliZWQgYWJvdmUpIG9yIGFjcm9zcyBhbGwgdGhlIChu b24tb3V0bGllcikgc25hcHNob3RzIGlzIHRvbyBsYXJnZSwgYmFpbC4gT25seSBlbmFibGVkCisg ICAgICAgIGlmIHRoZSBgU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlYCBz ZXR0aW5nIGlzIGdyZWF0ZXIgdGhhbiAwLgorCisgICAgICAgICogcGFnZS9QYWdlLmg6CisgICAg ICAgICogcGFnZS9QYWdlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhZ2U6OnNhbXBsZWRQYWdl VG9wQ29sb3IgY29uc3QpOiBBZGRlZC4KKyAgICAgICAgKiBwYWdlL0Nocm9tZUNsaWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6Q2hyb21lQ2xpZW50OjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IgY29u c3QpOiBBZGRlZC4KKyAgICAgICAgUGFzcyBhbG9uZyB0aGUgYHNhbXBsZWRQYWdlVG9wQ29sb3Jg IHRvIHRoZSBVSVByb2Nlc3MgYWZ0ZXIgaXQncyBkZXRlcm1pbmVkIG9yIGlmIHRoZSBhYm92ZQor ICAgICAgICBsb2dpYyBiYWlscyAoc28gdGhhdCB0aGUgYFdLV2ViVmlld2AgY2FuIGFkanVzdCBg X3NhbXBsZWRQYWdlVG9wQ29sb3JgIHRvIGBuaWxgKS4KKworICAgICAgICAqIHJlbmRlcmluZy9S ZW5kZXJMYXllckNvbXBvc2l0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXJD b21wb3NpdG9yOjpyb290QmFja2dyb3VuZENvbG9yT3JUcmFuc3BhcmVuY3lDaGFuZ2VkKToKKyAg ICAgICAgVXNlIHRoZSBgc2FtcGxlZFBhZ2VUb3BDb2xvcmAgaWYgdGhlIGBVc2VTYW1wbGVkUGFn ZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcmAKKyAgICAgICAgaW50ZXJuYWwg cHJlZmVyZW5jZSBpcyBlbmFibGVkIGluc3RlYWQgb2YgdGhlIENTUyBgYmFja2dyb3VuZC1jb2xv cmAgb2YgdGhlIGA8aHRtbD5gL2A8Ym9keT5gLgorCiAyMDIxLTA0LTIwICBCYXN1a2UgU3V6dWtp ICA8YmFzdWtlLnN1enVraUBzb255LmNvbT4KIAogICAgICAgICBbY2xhbmddIFJlbW92ZSBpbXBs aWNpdCBjYXN0IHJlbGF0ZWQgd2FybmluZ3MuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAppbmRleCA0 ZThhNzk2ZTFjYjEuLmQ0Y2UyOWU1OGI2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC04 Miw2ICs4Miw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCisjaW5jbHVkZSAiRnJhbWVTbmFwc2hv dHRpbmcuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJGdWxsc2NyZWVuTWFu YWdlci5oIgogI2luY2x1ZGUgIkdDUmVhY2hhYmxlUmVmLmgiCkBAIC0xMjMsNiArMTI0LDggQEAK ICNpbmNsdWRlICJJREJPcGVuREJSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiSWRsZUNhbGxiYWNrQ29u dHJvbGxlci5oIgogI2luY2x1ZGUgIkltYWdlQml0bWFwUmVuZGVyaW5nQ29udGV4dC5oIgorI2lu Y2x1ZGUgIkltYWdlQnVmZmVyLmgiCisjaW5jbHVkZSAiSW1hZ2VEYXRhLmgiCiAjaW5jbHVkZSAi SW1hZ2VMb2FkZXIuaCIKICNpbmNsdWRlICJJbWFnZU92ZXJsYXlDb250cm9sbGVyLmgiCiAjaW5j bHVkZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCkBAIC0zMjc2LDYgKzMyNzksOCBAQCB2 b2lkIERvY3VtZW50OjplbnF1ZXVlUGFpbnRUaW1pbmdFbnRyeUlmTmVlZGVkKCkKIAogICAgIGRv bVdpbmRvdygpLT5wZXJmb3JtYW5jZSgpLnJlcG9ydEZpcnN0Q29udGVudGZ1bFBhaW50KCk7CiAg ICAgbV9kaWRFbnF1ZXVlRmlyc3RDb250ZW50ZnVsUGFpbnQgPSB0cnVlOworCisgICAgZGV0ZXJt aW5lU2FtcGxlZFBhZ2VUb3BDb2xvcigpOwogfQogCiBFeGNlcHRpb25Pcjx2b2lkPiBEb2N1bWVu dDo6d3JpdGUoRG9jdW1lbnQqIHJlc3BvbnNpYmxlRG9jdW1lbnQsIFNlZ21lbnRlZFN0cmluZyYm IHRleHQpCkBAIC0zODc5LDYgKzM4ODQsMTM3IEBAIHZvaWQgRG9jdW1lbnQ6OnRoZW1lQ29sb3JD aGFuZ2VkKCkKICNlbmRpZiAvLyBFTkFCTEUoUlVCQkVSX0JBTkRJTkcpCiB9CiAKK3ZvaWQgRG9j dW1lbnQ6OmRldGVybWluZVNhbXBsZWRQYWdlVG9wQ29sb3IoKQoreworICAgIGlmIChtX3NhbXBs ZWRQYWdlVG9wQ29sb3IuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvKiBw YWdlID0gdGhpcy0+cGFnZSgpOworICAgIGlmICghcGFnZSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgYXV0byBtYXhQZXJjZW50RGlmZmVyZW5jZSA9IHBhZ2UtPnNldHRpbmdzKCkuc2FtcGxlZFBh Z2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKCk7CisgICAgaWYgKG1heFBlcmNlbnREaWZm ZXJlbmNlIDw9IDApCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghaXNUb3BEb2N1bWVudCgp KQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvKiBmcmFtZVZpZXcgPSB2aWV3KCk7CisgICAg aWYgKCFmcmFtZVZpZXcpCisgICAgICAgIHJldHVybjsKKworICAgIGF1dG8gbm90aWZ5RGlkU2Ft cGxlUGFnZVRvcENvbG9yT25TY29wZUV4aXQgPSBtYWtlU2NvcGVFeGl0KFsmXSB7CisgICAgICAg IHBhZ2UtPmNocm9tZSgpLmNsaWVudCgpLmRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpOworICAgIH0p OworCisgICAgYXV0byBnZXRQaXhlbENvbG9yQXRUb3BYID0gWyZdIChpbnQgeCkgLT4gT3B0aW9u YWw8U1JHQkE8dWludDhfdD4+IHsKKyAgICAgICAgSW50UG9pbnQgbG9jYXRpb24oeCwgMCk7Cisg ICAgICAgIEludFNpemUgc2l6ZSgxLCAxKTsKKworICAgICAgICBjb25zdGV4cHIgT3B0aW9uU2V0 PEhpdFRlc3RSZXF1ZXN0OjpSZXF1ZXN0VHlwZT4gaGl0VGVzdFJlcXVlc3RUeXBlcyB7IEhpdFRl c3RSZXF1ZXN0OjpSZWFkT25seSwgSGl0VGVzdFJlcXVlc3Q6OkRpc2FsbG93VXNlckFnZW50U2hh ZG93Q29udGVudCB9OworICAgICAgICBIaXRUZXN0UmVzdWx0IGhpdFRlc3RSZXN1bHQobG9jYXRp b24pOworICAgICAgICBoaXRUZXN0KGhpdFRlc3RSZXF1ZXN0VHlwZXMsIGhpdFRlc3RSZXN1bHQp OworICAgICAgICBpZiAoYXV0byBoaXRUZXN0Tm9kZSA9IG1ha2VSZWZQdHIoaGl0VGVzdFJlc3Vs dC5pbm5lck5vZGUoKSkpIHsKKyAgICAgICAgICAgIGlmIChpczxIVE1MSUZyYW1lRWxlbWVudD4o aGl0VGVzdE5vZGUpICYmICFhcmVSZWdpc3RyYWJsZURvbWFpbnNFcXVhbChkb3duY2FzdDxIVE1M SUZyYW1lRWxlbWVudD4oKmhpdFRlc3ROb2RlKS5sb2NhdGlvbigpLCBtX3VybCkpCisgICAgICAg ICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICAgICAgfQorCisgICAgICAgIGF1dG8g c25hcHNob3QgPSBzbmFwc2hvdEZyYW1lUmVjdChmcmFtZVZpZXctPmZyYW1lKCksIEludFJlY3Qo bG9jYXRpb24sIHNpemUpLCBTbmFwc2hvdE9wdGlvbnNFeGNsdWRlU2VsZWN0aW9uSGlnaGxpZ2h0 aW5nIHwgU25hcHNob3RPcHRpb25zSW5WaWV3Q29vcmRpbmF0ZXMgfCBTbmFwc2hvdE9wdGlvbnNQ YWludEV2ZXJ5dGhpbmdFeGNsdWRpbmdTZWxlY3Rpb24pOworICAgICAgICBpZiAoIXNuYXBzaG90 KQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBhdXRvIHNuYXBz aG90RGF0YSA9IHNuYXBzaG90LT5nZXRJbWFnZURhdGEoQWxwaGFQcmVtdWx0aXBsaWNhdGlvbjo6 VW5wcmVtdWx0aXBsaWVkLCBJbnRSZWN0KEludFBvaW50Ojp6ZXJvKCksIHNpemUpKTsKKyAgICAg ICAgaWYgKCFzbmFwc2hvdERhdGEpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0Owor CisgICAgICAgIGF1dG8qIHBpeGVsQXJyYXkgPSBzbmFwc2hvdERhdGEtPmRhdGEoKTsKKyAgICAg ICAgcmV0dXJuIFNSR0JBPHVpbnQ4X3Q+IHsgcGl4ZWxBcnJheS0+aXRlbSgwKSwgcGl4ZWxBcnJh eS0+aXRlbSgxKSwgcGl4ZWxBcnJheS0+aXRlbSgyKSwgcGl4ZWxBcnJheS0+aXRlbSgzKSB9Owor ICAgIH07CisKKyAgICAvLyBEZWNyZWFzZSB0aGUgd2lkdGggYnkgb25lIHBpeGVsIHNvIHRoYXQg dGhlIGxhc3Qgc25hcHNob3QgaXMgd2l0aGluIGJvdW5kcyBhbmQgbm90IG9mZi1ieS1vbmUuCisg ICAgYXV0byBmcmFtZVdpZHRoID0gZnJhbWVWaWV3LT5jb250ZW50c1dpZHRoKCkgLSAxOworCisg ICAgY29uc3RleHByIGF1dG8gbnVtU25hcHNob3RzID0gNTsKKyAgICBzaXplX3Qgbm9uTWF0Y2hp bmdDb2xvckluZGV4ID0gbnVtU25hcHNob3RzICsgMTsKKworICAgIFNSR0JBPHVpbnQ4X3Q+IHNu YXBzaG90c1tudW1TbmFwc2hvdHNdOworICAgIGRvdWJsZSBwZXJjZW50YWdlRGlmZmVyZW5jZXNb bnVtU25hcHNob3RzIC0gMV07CisKKyAgICBhdXRvIHNob3VsZFN0b3BBZnRlckZpbmRpbmdOb25N YXRjaGluZ0NvbG9yID0gWyZdIChzaXplX3QgaSkgLT4gYm9vbCB7CisgICAgICAgIC8vIEJhaWwg aWYgdGhlIG5vbi1tYXRjaGluZyBjb2xvciBpcyBub3QgdGhlIGZpcnN0IG9yIGxhc3Qgc25hcHNo b3QsIG9yIHRoZXJlIGFscmVhZHkgaXMgYW4gbm9uLW1hdGNoaW5nIGNvbG9yLgorICAgICAgICBp ZiAoKGkgPiAwICYmIGkgPCBudW1TbmFwc2hvdHMgLSAxKSB8fCBub25NYXRjaGluZ0NvbG9ySW5k ZXggIT0gbnVtU25hcHNob3RzICsgMSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAg ICAgIG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9IGk7CisgICAgICAgIEFTU0VSVCghbm9uTWF0Y2hp bmdDb2xvckluZGV4IHx8IG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9PSBudW1TbmFwc2hvdHMgLSAx KTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH07CisKKyAgICBmb3IgKHNpemVfdCBpID0g MDsgaSA8IG51bVNuYXBzaG90czsgKytpKSB7CisgICAgICAgIGF1dG8gc25hcHNob3QgPSBnZXRQ aXhlbENvbG9yQXRUb3BYKGZyYW1lV2lkdGggKiBpIC8gKG51bVNuYXBzaG90cyAtIDEpKTsKKyAg ICAgICAgaWYgKCFzbmFwc2hvdCAmJiAhc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNoaW5n Q29sb3IoaSkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgc25hcHNob3RzW2ldID0g KnNuYXBzaG90OworCisgICAgICAgIGlmIChpKSB7CisgICAgICAgICAgICAvLyBFYWNoIGBwZXJj ZW50YWdlRGlmZmVyZW5jZWAgY29tcGFyZXMgYGlgIHdpdGggYGkgLSAxYCBzbyBpZiB0aGUgZmly c3QgY29tcGFyaXNvbiAoYGkgPT0gMWApCisgICAgICAgICAgICAvLyBpcyB0b28gbGFyZ2Ugb2Yg YSBkaWZmZXJlbmNlLCB3ZSBzaG91bGQgdHJlYXQgYGkgLSAxYCAoaS5lLiBgMGApIGFzIHRoZSBw cm9ibGVtIHNpbmNlCisgICAgICAgICAgICAvLyB3ZSBvbmx5IGFsbG93IGZvciBub24tbWF0Y2hp bmcgY29sb3JzIGJlaW5nIHRoZSBmaXJzdCBvciBsYXN0IHNhbXBsZWQgY29sb3IuCisgICAgICAg ICAgICBhdXRvIGVmZmVjdGl2ZU5vbk1hdGNoaW5nQ29sb3JJbmRleCA9IGkgPT0gMSA/IDAgOiBp OworCisgICAgICAgICAgICBkb3VibGUgcmVkUGVyY2VudERpZmZlcmVuY2UgPSBmYWJzKHNuYXBz aG90c1tpXS5yZWQgLSBzbmFwc2hvdHNbaSAtIDFdLnJlZCkgLyAyNTUuMDsKKyAgICAgICAgICAg IGRvdWJsZSBncmVlblBlcmNlbnREaWZmZXJlbmNlID0gZmFicyhzbmFwc2hvdHNbaV0uZ3JlZW4g LSBzbmFwc2hvdHNbaSAtIDFdLmdyZWVuKSAvIDI1NS4wOworICAgICAgICAgICAgZG91YmxlIGJs dWVQZXJjZW50RGlmZmVyZW5jZSA9IGZhYnMoc25hcHNob3RzW2ldLmJsdWUgLSBzbmFwc2hvdHNb aSAtIDFdLmJsdWUpIC8gMjU1LjA7CisgICAgICAgICAgICBkb3VibGUgYWxwaGFQZXJjZW50RGlm ZmVyZW5jZSA9IGZhYnMoc25hcHNob3RzW2ldLmFscGhhIC0gc25hcHNob3RzW2kgLSAxXS5hbHBo YSkgLyAyNTUuMDsKKyAgICAgICAgICAgIHBlcmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPSBy ZWRQZXJjZW50RGlmZmVyZW5jZSArIGdyZWVuUGVyY2VudERpZmZlcmVuY2UgKyBibHVlUGVyY2Vu dERpZmZlcmVuY2UgKyBhbHBoYVBlcmNlbnREaWZmZXJlbmNlOworICAgICAgICAgICAgaWYgKHBl cmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPj0gbWF4UGVyY2VudERpZmZlcmVuY2UpIHsKKyAg ICAgICAgICAgICAgICBpZiAoc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNoaW5nQ29sb3Io ZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4KSkKKyAgICAgICAgICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorCisgICAgICAg ICAgICBkb3VibGUgY3VtdWx1YXRpdmVQZXJjZW50RGlmZmVyZW5jZSA9IDA7CisgICAgICAgICAg ICBmb3IgKHNpemVfdCBqID0gMDsgaiA8IGk7ICsraikgeworICAgICAgICAgICAgICAgIGlmIChq ID09IG5vbk1hdGNoaW5nQ29sb3JJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgICAgICAgICAgY3VtdWx1YXRpdmVQZXJjZW50RGlmZmVyZW5jZSArPSBwZXJjZW50 YWdlRGlmZmVyZW5jZXNbal07CisgICAgICAgICAgICB9CisgICAgICAgICAgICBpZiAoY3VtdWx1 YXRpdmVQZXJjZW50RGlmZmVyZW5jZSA+PSBtYXhQZXJjZW50RGlmZmVyZW5jZSkgeworICAgICAg ICAgICAgICAgIGlmIChzaG91bGRTdG9wQWZ0ZXJGaW5kaW5nTm9uTWF0Y2hpbmdDb2xvcihlZmZl Y3RpdmVOb25NYXRjaGluZ0NvbG9ySW5kZXgpKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIElm IHdlIGhhdmVuJ3QgYWxyZWFkeSBpZGVudGlmaWVkIGEgbm9uLW1hdGNoaW5nIHNuYXBzaG90IGFu ZCB0aGUgcGVyY2VudCBkaWZmZXJlbmNlIGJldHdlZW4gdGhlCisgICAgICAgICAgICAgICAgICAg IC8vIGZpcnN0IGFuZCBzZWNvbmQgc25hcHNob3RzIG9yIHRoZSBzZWNvbmQtdG8tbGFzdCBhbmQg bGFzdCBzbmFwc2hvdHMgaXMgbGVzcyB0aGFuIHRoZSBtYXhpbXVtLCBtYXJrCisgICAgICAgICAg ICAgICAgICAgIC8vIHRoZSBmaXJzdC9sYXN0IHNuYXBzaG90IGFzIG5vbi1tYXRjaGluZyB0byBn aXZlIGEgY2hhbmNlIGZvciB0aGUgcmVzdCBvZiB0aGUgc25hcHNob3RzIHRvIG1hdGNoLgorICAg ICAgICAgICAgICAgICAgICBpZiAobm9uTWF0Y2hpbmdDb2xvckluZGV4ID09IG51bVNuYXBzaG90 cyArIDEgJiYgKCFpIHx8IGkgPT0gbnVtU25hcHNob3RzIC0gMSkgJiYgY3VtdWx1YXRpdmVQZXJj ZW50RGlmZmVyZW5jZSAtIHBlcmNlbnRhZ2VEaWZmZXJlbmNlc1tpIC0gMV0gPCBtYXhQZXJjZW50 RGlmZmVyZW5jZSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbm9uTWF0Y2hpbmdDb2xvcklu ZGV4ID0gZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4OworICAgICAgICAgICAgICAgICAg ICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBjb250aW51ZTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKworICAgIHVpbnQzMl90IGF2ZXJhZ2VS ZWQgPSAwOworICAgIHVpbnQzMl90IGF2ZXJhZ2VHcmVlbiA9IDA7CisgICAgdWludDMyX3QgYXZl cmFnZUJsdWUgPSAwOworICAgIHVpbnQzMl90IGF2ZXJhZ2VBbHBoYSA9IDA7CisgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPCBudW1TbmFwc2hvdHM7ICsraSkgeworICAgICAgICBpZiAoaSA9PSBu b25NYXRjaGluZ0NvbG9ySW5kZXgpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBh dmVyYWdlUmVkICs9IHNuYXBzaG90c1tpXS5yZWQ7CisgICAgICAgIGF2ZXJhZ2VHcmVlbiArPSBz bmFwc2hvdHNbaV0uZ3JlZW47CisgICAgICAgIGF2ZXJhZ2VCbHVlICs9IHNuYXBzaG90c1tpXS5i bHVlOworICAgICAgICBhdmVyYWdlQWxwaGEgKz0gc25hcHNob3RzW2ldLmFscGhhOworICAgIH0K KyAgICBhdXRvIHZhbGlkU25hcHNob3RDb3VudCA9IG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9PSBu dW1TbmFwc2hvdHMgKyAxID8gbnVtU25hcHNob3RzIDogbnVtU25hcHNob3RzIC0gMTsKKyAgICBm bG9hdCBjb252ZXJ0VG9EZWNpbWFsID0gdmFsaWRTbmFwc2hvdENvdW50ICogMjU1OworICAgIG1f c2FtcGxlZFBhZ2VUb3BDb2xvciA9IG1ha2VGcm9tQ29tcG9uZW50c0NsYW1waW5nPFNSR0JBPGZs b2F0Pj4oYXZlcmFnZVJlZCAvIGNvbnZlcnRUb0RlY2ltYWwsIGF2ZXJhZ2VHcmVlbiAvIGNvbnZl cnRUb0RlY2ltYWwsIGF2ZXJhZ2VCbHVlIC8gY29udmVydFRvRGVjaW1hbCwgYXZlcmFnZUFscGhh IC8gY29udmVydFRvRGVjaW1hbCk7Cit9CisKICNpZiBFTkFCTEUoREFSS19NT0RFX0NTUykKIHN0 YXRpYyB2b2lkIHByb2Nlc3NDb2xvclNjaGVtZVN0cmluZyhTdHJpbmdWaWV3IGNvbG9yU2NoZW1l LCBjb25zdCBXVEY6OkZ1bmN0aW9uPHZvaWQoU3RyaW5nVmlldyBrZXkpPiYgY2FsbGJhY2spCiB7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJD b3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGUyNTdlYWQzYzk0NS4uM2I3YTM2ZmQ0N2Q4IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuaApAQCAtNzQzLDYgKzc0Myw4IEBAIHB1YmxpYzoKIAogICAgIGNvbnN0 IENvbG9yJiB0aGVtZUNvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9tZXRhRWxlbWVudFRoZW1lQ29s b3IuaXNWYWxpZCgpID8gbV9tZXRhRWxlbWVudFRoZW1lQ29sb3IgOiBtX2FwcGxpY2F0aW9uTWFu aWZlc3RUaGVtZUNvbG9yOyB9CiAKKyAgICBjb25zdCBDb2xvciYgc2FtcGxlZFBhZ2VUb3BDb2xv cigpIGNvbnN0IHsgcmV0dXJuIG1fc2FtcGxlZFBhZ2VUb3BDb2xvcjsgfQorCiAgICAgdm9pZCBz ZXRUZXh0Q29sb3IoY29uc3QgQ29sb3ImIGNvbG9yKSB7IG1fdGV4dENvbG9yID0gY29sb3I7IH0K ICAgICBjb25zdCBDb2xvciYgdGV4dENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0Q29sb3I7 IH0KIApAQCAtMTY3Nyw2ICsxNjc5LDggQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgdGhlbWVDb2xv ckNoYW5nZWQoKTsKIAorICAgIHZvaWQgZGV0ZXJtaW5lU2FtcGxlZFBhZ2VUb3BDb2xvcigpOwor CiAgICAgdm9pZCBpbnZhbGlkYXRlQWNjZXNzS2V5Q2FjaGVTbG93Q2FzZSgpOwogICAgIHZvaWQg YnVpbGRBY2Nlc3NLZXlDYWNoZSgpOwogCkBAIC0xODAwLDYgKzE4MDQsOCBAQCBwcml2YXRlOgog ICAgIENvbG9yIG1fbWV0YUVsZW1lbnRUaGVtZUNvbG9yOwogICAgIENvbG9yIG1fYXBwbGljYXRp b25NYW5pZmVzdFRoZW1lQ29sb3I7CiAKKyAgICBDb2xvciBtX3NhbXBsZWRQYWdlVG9wQ29sb3I7 CisKICAgICBDb2xvciBtX3RleHRDb2xvciB7IENvbG9yOjpibGFjayB9OwogICAgIENvbG9yIG1f bGlua0NvbG9yOwogICAgIENvbG9yIG1fdmlzaXRlZExpbmtDb2xvcjsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvQ2hyb21lQ2xpZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0No cm9tZUNsaWVudC5oCmluZGV4IGNmMTZhZTZlYTQ3NS4uZWQ4Y2Y0MDMyMTBlIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Nocm9tZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvQ2hyb21lQ2xpZW50LmgKQEAgLTIzMyw2ICsyMzMsNyBAQCBwdWJsaWM6CiAKICAgICB2 aXJ0dWFsIHZvaWQgdGhlbWVDb2xvckNoYW5nZWQoKSBjb25zdCB7IH0KICAgICB2aXJ0dWFsIHZv aWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCkgY29uc3QgeyB9CisgICAg dmlydHVhbCB2b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpIGNvbnN0IHsgfQogCiAgICAgdmly dHVhbCB2b2lkIGV4Y2VlZGVkRGF0YWJhc2VRdW90YShGcmFtZSYsIGNvbnN0IFN0cmluZyYgZGF0 YWJhc2VOYW1lLCBEYXRhYmFzZURldGFpbHMpID0gMDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9QYWdlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKaW5kZXgg Y2RiZmZhMGM2YTA1Li44ZmMyYWEyNTA5ODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcApAQCAtMjU1Myw2 ICsyNTUzLDE1IEBAIENvbG9yIFBhZ2U6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNv bnN0CiAgICAgcmV0dXJuIHJlbmRlclZpZXctPmNvbXBvc2l0b3IoKS5yb290RXh0ZW5kZWRCYWNr Z3JvdW5kQ29sb3IoKTsKIH0KIAorQ29sb3IgUGFnZTo6c2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNv bnN0Cit7CisgICAgYXV0byogZG9jdW1lbnQgPSBtYWluRnJhbWUoKS5kb2N1bWVudCgpOworICAg IGlmICghZG9jdW1lbnQpCisgICAgICAgIHJldHVybiB7IH07CisKKyAgICByZXR1cm4gZG9jdW1l bnQtPnNhbXBsZWRQYWdlVG9wQ29sb3IoKTsKK30KKwogLy8gVGhlc2UgYXJlIG1hZ2ljYWwgY29u c3RhbnRzIHRoYXQgbWlnaHQgYmUgdHdlYWtlZCBvdmVyIHRpbWUuCiBzdGF0aWMgY29uc3QgZG91 YmxlIGdNaW5pbXVtUGFpbnRlZEFyZWFSYXRpbyA9IDAuMTsKIHN0YXRpYyBjb25zdCBkb3VibGUg Z01heGltdW1VbnBhaW50ZWRBcmVhUmF0aW8gPSAwLjA0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGFnZS9QYWdlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaAppbmRleCA2Yjc2 Y2MxMTU4YzMuLjNiZjAzOGE3ZWQzMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q YWdlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmgKQEAgLTYyMSw2ICs2MjEsNyBA QCBwdWJsaWM6CiAKICAgICBXRUJDT1JFX0VYUE9SVCBDb2xvciB0aGVtZUNvbG9yKCkgY29uc3Q7 CiAgICAgV0VCQ09SRV9FWFBPUlQgQ29sb3IgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKCkg Y29uc3Q7CisgICAgV0VCQ09SRV9FWFBPUlQgQ29sb3Igc2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNv bnN0OwogCiAgICAgYm9vbCBpc0NvdW50aW5nUmVsZXZhbnRSZXBhaW50ZWRPYmplY3RzKCkgY29u c3Q7CiAgICAgdm9pZCBzZXRJc0NvdW50aW5nUmVsZXZhbnRSZXBhaW50ZWRPYmplY3RzKGJvb2wg aXNDb3VudGluZykgeyBtX2lzQ291bnRpbmdSZWxldmFudFJlcGFpbnRlZE9iamVjdHMgPSBpc0Nv dW50aW5nOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5 ZXJDb21wb3NpdG9yLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllckNv bXBvc2l0b3IuY3BwCmluZGV4IDE3NDYzNjNiM2VlYy4uYzk4ZGVkYjRlYjE5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcApAQCAt MzkyNiw2ICszOTI2LDggQEAgdm9pZCBSZW5kZXJMYXllckNvbXBvc2l0b3I6OnVwZGF0ZUxheWVy Rm9yT3ZlcmhhbmdBcmVhc0JhY2tncm91bmRDb2xvcigpCiAgICAgQ29sb3IgYmFja2dyb3VuZENv bG9yOwogICAgIGlmIChwYWdlKCkuc2V0dGluZ3MoKS51c2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJl YUJhY2tncm91bmRDb2xvcigpKQogICAgICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkudGhl bWVDb2xvcigpOworICAgIGlmIChwYWdlKCkuc2V0dGluZ3MoKS51c2VTYW1wbGVkUGFnZVRvcENv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcigpICYmICFiYWNrZ3JvdW5kQ29sb3IuaXNW YWxpZCgpKQorICAgICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkuc2FtcGxlZFBhZ2VUb3BD b2xvcigpOwogICAgIGlmICghYmFja2dyb3VuZENvbG9yLmlzVmFsaWQoKSkKICAgICAgICAgYmFj a2dyb3VuZENvbG9yID0gbV9yb290RXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3I7CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5k ZXggOWQ5NzczY2E5ZmRmLi40ZWMxMjdhNzBkZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTAgQEAK KzIwMjEtMDQtMjMgIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAg IGV4cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9w IG9mIHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6 Ly9wcm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQu aDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNsaWVudC5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYkNocm9tZUNsaWVudDo6ZGlkU2FtcGxlUGFnZVRvcENv bG9yIGNvbnN0KTogQWRkZWQuCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2Uu aDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2U6OmRpZFNhbXBsZVBhZ2VUb3BDb2xvcik6IEFkZGVkLgorICAgICAgICBQ YXNzIGFsb25nIHRoZSBgc2FtcGxlZFBhZ2VUb3BDb2xvcmAgdG8gdGhlIFVJUHJvY2Vzcy4KKwor ICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW46CisgICAgICAgICog VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OnNhbXBsZWRQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzY3JvbGxBcmVhQmFj a2dyb3VuZENvbG9yIGNvbnN0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpkaWRT YW1wbGVQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAgVXNlIHRoZSBgc2FtcGxlZFBhZ2VU b3BDb2xvcmAgaWYgdGhlIGBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tn cm91bmRDb2xvcmAKKyAgICAgICAgaW50ZXJuYWwgcHJlZmVyZW5jZSBpcyBlbmFibGVkIGluc3Rl YWQgb2YgdGhlIENTUyBgYmFja2dyb3VuZC1jb2xvcmAgb2YgdGhlIGA8aHRtbD5gL2A8Ym9keT5g LgorCisgICAgICAgICogVUlQcm9jZXNzL1BhZ2VDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6 UGFnZUNsaWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UpOiBBZGRlZC4KKyAgICAg ICAgKFdlYktpdDo6UGFnZUNsaWVudDo6c2FtcGxlZFBhZ2VUb3BDb2xvckRpZENoYW5nZSk6IEFk ZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLmg6Cisg ICAgICAgICogVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW06CisgICAgICAg IChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsQ29jb2E6OnNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hh bmdlKTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsQ29jb2E6OnNhbXBs ZWRQYWdlVG9wQ29sb3JEaWRDaGFuZ2UpOiBBZGRlZC4KKyAgICAgICAgQWRkIE9iakMgS1ZPIHN1 cHBvcnQgZm9yIGAtW1dLV2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl1gLgorCisgICAgICAg ICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmg6CisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW06CisgICAgICAgICgtW1dLV2ViVmlldyBfc2V0 dXBQYWdlQ29uZmlndXJhdGlvbjpdKToKKyAgICAgICAgKC1bV0tXZWJWaWV3IF9zYW1wbGVkUGFn ZVRvcENvbG9yXSk6IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJW aWV3Q29uZmlndXJhdGlvblByaXZhdGUuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29h L1dLV2ViVmlld0NvbmZpZ3VyYXRpb24ubW06CisgICAgICAgICgtW1dLV2ViVmlld0NvbmZpZ3Vy YXRpb24gaW5pdF0pOgorICAgICAgICAoLVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIGNvcHlXaXRo Wm9uZTpdKToKKyAgICAgICAgKC1bV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBfc2V0U2FtcGxlZFBh Z2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlOl0pOiBBZGRlZC4KKyAgICAgICAgKC1bV0tX ZWJWaWV3Q29uZmlndXJhdGlvbiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJl bmNlXSk6IEFkZGVkLgorICAgICAgICBQcm92aWRlIFNQSSB0byBjb25maWd1cmUgdGhlIGBTYW1w bGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2VgIHByZWZlcmVuY2Ugd2hlbgorICAg ICAgICBjcmVhdGluZyB0aGUgYFdLV2ViVmlld2AuIEV4cG9zZSB0aGUgcmVzdWx0IGFzIGBfc2Ft cGxlZFBhZ2VUb3BDb2xvcmAgU1BJLgorCiAyMDIxLTA0LTIwICBJYW4gR2lsYmVydCAgPGlhbmdA YXBwbGUuY29tPgogCiAgICAgICAgIENyYXNoIGR1ZSB0byBWZWN0b3JCdWZmZXIgcHJlLWFsbG9j YXRpb24gZmFpbHVyZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0Nv Y29hL1dLV2ViVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dl YlZpZXcubW0KaW5kZXggNmRmOGE2MDkzNzViLi5kNjQ0OTg1MjVkNDYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW0KKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlldy5tbQpAQCAtNTU4LDYgKzU1OCw4 IEBAIC0gKHZvaWQpX3NldHVwUGFnZUNvbmZpZ3VyYXRpb246KFJlZjxBUEk6OlBhZ2VDb25maWd1 cmF0aW9uPiYpcGFnZUNvbmZpZ3VyYXRpb24KICAgICBwYWdlQ29uZmlndXJhdGlvbi0+cHJlZmVy ZW5jZXMoKS0+c2V0U2VydmljZVdvcmtlckVudGl0bGVtZW50RGlzYWJsZWRGb3JUZXN0aW5nKCEh W19jb25maWd1cmF0aW9uIHByZWZlcmVuY2VzXS5fc2VydmljZVdvcmtlckVudGl0bGVtZW50RGlz YWJsZWRGb3JUZXN0aW5nKTsKICNlbmRpZgogCisgICAgcGFnZUNvbmZpZ3VyYXRpb24tPnByZWZl cmVuY2VzKCktPnNldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZShbX2Nv bmZpZ3VyYXRpb24gX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZV0pOwor CiAgICAgaWYgKCFsaW5rZWRPbk9yQWZ0ZXIoV2ViQ29yZTo6U0RLVmVyc2lvbjo6Rmlyc3RXaGVy ZVNpdGVTcGVjaWZpY1F1aXJrc0FyZUVuYWJsZWRCeURlZmF1bHQpKQogICAgICAgICBwYWdlQ29u ZmlndXJhdGlvbi0+cHJlZmVyZW5jZXMoKS0+c2V0TmVlZHNTaXRlU3BlY2lmaWNRdWlya3MoZmFs c2UpOwogfQpAQCAtMzAwMyw2ICszMDA1LDE0IEBAIC0gKENvY29hQ29sb3IgKilfcGFnZUV4dGVu ZGVkQmFja2dyb3VuZENvbG9yCiAgICAgcmV0dXJuIFdlYkNvcmU6OnBsYXRmb3JtQ29sb3IocGFn ZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKTsKIH0KIAorLSAoQ29jb2FDb2xvciAqKV9zYW1wbGVk UGFnZVRvcENvbG9yCit7CisgICAgYXV0byBzYW1wbGVkUGFnZVRvcENvbG9yID0gX3BhZ2UtPnNh bXBsZWRQYWdlVG9wQ29sb3IoKTsKKyAgICBpZiAoIXNhbXBsZWRQYWdlVG9wQ29sb3IuaXNWYWxp ZCgpKQorICAgICAgICByZXR1cm4gbmlsOworICAgIHJldHVybiBXZWJDb3JlOjpwbGF0Zm9ybUNv bG9yKHNhbXBsZWRQYWdlVG9wQ29sb3IpOworfQorCiAtIChpZCA8X1dLSW5wdXREZWxlZ2F0ZT4p X2lucHV0RGVsZWdhdGUKIHsKICAgICByZXR1cm4gX2lucHV0RGVsZWdhdGUuZ2V0QXV0b3JlbGVh c2VkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tX ZWJWaWV3Q29uZmlndXJhdGlvbi5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tCmluZGV4IGM1MDA5YjY4ODZmMy4uMDhiMTAxZDVh NjdiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJW aWV3Q29uZmlndXJhdGlvbi5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29j b2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvbi5tbQpAQCAtMTc3LDYgKzE3Nyw3IEBAIEBpbXBsZW1l bnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIHsKICNpZiBFTkFCTEUoQVBQX0hJR0hMSUdI VFMpCiAgICAgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQ7CiAjZW5kaWYKKyAgICBkb3VibGUg X3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZTsKIAogICAgIFJldGFpblB0 cjxOU1N0cmluZz4gX21lZGlhQ29udGVudFR5cGVzUmVxdWlyaW5nSGFyZHdhcmVTdXBwb3J0Owog ICAgIFJldGFpblB0cjxOU0FycmF5PE5TU3RyaW5nICo+PiBfYWRkaXRpb25hbFN1cHBvcnRlZElt YWdlVHlwZXM7CkBAIC0yNzUsNiArMjc2LDkgQEAgLSAoaW5zdGFuY2V0eXBlKWluaXQKICNpZiBF TkFCTEUoQVBQX0hJR0hMSUdIVFMpCiAgICAgX2FwcEhpZ2hsaWdodHNFbmFibGVkID0gREVGQVVM VF9WQUxVRV9GT1JfQXBwSGlnaGxpZ2h0c0VuYWJsZWQ7CiAjZW5kaWYKKworICAgIF9zYW1wbGVk UGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UgPSBERUZBVUxUX1ZBTFVFX0ZPUl9TYW1w bGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2U7CisKICAgICByZXR1cm4gc2VsZjsK IH0KIApAQCAtNDUzLDYgKzQ1Nyw4IEBAIC0gKGlkKWNvcHlXaXRoWm9uZTooTlNab25lICopem9u ZQogICAgIGNvbmZpZ3VyYXRpb24tPl9hcHBIaWdobGlnaHRzRW5hYmxlZCA9IHNlbGYtPl9hcHBI aWdobGlnaHRzRW5hYmxlZDsKICNlbmRpZgogCisgICAgY29uZmlndXJhdGlvbi0+X3NhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSA9IHNlbGYtPl9zYW1wbGVkUGFnZVRvcENv bG9yTWF4UGVyY2VudERpZmZlcmVuY2U7CisKICAgICByZXR1cm4gY29uZmlndXJhdGlvbjsKIH0K IApAQCAtMTI3Myw2ICsxMjc5LDE2IEBAIC0gKHZvaWQpX3NldFByb2Nlc3NEaXNwbGF5TmFtZToo TlNTdHJpbmcgKilsc0Rpc3BsYXlOYW1lCiAgICAgX3BhZ2VDb25maWd1cmF0aW9uLT5zZXRQcm9j ZXNzRGlzcGxheU5hbWUobHNEaXNwbGF5TmFtZSk7CiB9CiAKKy0gKHZvaWQpX3NldFNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZTooZG91YmxlKXZhbHVlCit7CisgICAgX3Nh bXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSA9IHZhbHVlOworfQorCistIChk b3VibGUpX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZQoreworICAgIHJl dHVybiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlOworfQorCiBAZW5k CiAKIEBpbXBsZW1lbnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIChXS0RlcHJlY2F0ZWQp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3 Q29uZmlndXJhdGlvblByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCmluZGV4IGVmNGQ0ZTIwYzE0ZC4uYTM2 ODUxYjIwNjliIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tXZWJWaWV3Q29uZmlndXJhdGlvblByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvblByaXZhdGUuaApAQCAtMTIzLDYg KzEyMyw5IEBAIHR5cGVkZWYgTlNfRU5VTShOU1VJbnRlZ2VyLCBfV0tEcmFnTGlmdERlbGF5KSB7 CiAKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCBzZXR0ZXI9X3NldEFwcEhpZ2hsaWdodHNFbmFibGVk OikgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19N QUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKIAorLy8gRXhwZWN0cyB2YWx1ZXMgWzAsIDFdIHdo ZXJlIDAgbWVhbnMgZGlzYWJsaW5nIHBhZ2UgdG9wIGNvbG9yIHNhbXBsaW5nIGVudGlyZWx5Lgor QHByb3BlcnR5IChub25hdG9taWMsIHNldHRlcj1fc2V0U2FtcGxlZFBhZ2VUb3BDb2xvck1heFBl cmNlbnREaWZmZXJlbmNlOikgZG91YmxlIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERp ZmZlcmVuY2UgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19U QkEpKTsKKwogQGVuZAogCiAjaWYgVEFSR0VUX09TX0lQSE9ORQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmgKaW5kZXggNzQwZTA2 Y2IyMzUwLi5lMWNlMjM1N2QyNGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaApAQCAtMzgzLDYgKzM4MywxMyBAQCBmb3Ig dGhpcyBwcm9wZXJ0eS4KIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSkgTlNDb2xvciAq X3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKICNlbmRpZgogCisvLyBPbmx5IHNldCBpZiBg LVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERp ZmZlcmVuY2VdYCBpcyBhIHBvc2l0aXZlIG51bWJlci4KKyNpZiBUQVJHRVRfT1NfSVBIT05FCitA cHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHkpIFVJQ29sb3IgKl9zYW1wbGVkUGFnZVRvcENv bG9yIFdLX0FQSV9BVkFJTEFCTEUoaW9zKFdLX0lPU19UQkEpKTsKKyNlbHNlCitAcHJvcGVydHkg KG5vbmF0b21pYywgcmVhZG9ubHkpIE5TQ29sb3IgKl9zYW1wbGVkUGFnZVRvcENvbG9yIFdLX0FQ SV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RCQSkpOworI2VuZGlmCisKIC0gKHZvaWQpX2dyYW50 QWNjZXNzVG9Bc3NldFNlcnZpY2VzIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RCQSks IGlvcygxNC4wKSk7CiAtICh2b2lkKV9yZXZva2VBY2Nlc3NUb0Fzc2V0U2VydmljZXMgV0tfQVBJ X0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKDE0LjApKTsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCmluZGV4IDI2 ZWM4YzBkYzQzZS4uNTU4ZmQ4YzcwMzBlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCkBAIC01NSw2ICs1NSw4IEBAIHB1Ymxp YzoKICAgICB2b2lkIHRoZW1lQ29sb3JEaWRDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIHBhZ2VF eHRlbmRlZEJhY2tncm91bmRDb2xvcldpbGxDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIHBhZ2VF eHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpIGZpbmFsOworICAgIHZvaWQgc2FtcGxl ZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKSBmaW5hbDsKKyAgICB2b2lkIHNhbXBsZWRQYWdlVG9w Q29sb3JEaWRDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIGlzUGxheWluZ0F1ZGlvV2lsbENoYW5n ZSgpIGZpbmFsOwogICAgIHZvaWQgaXNQbGF5aW5nQXVkaW9EaWRDaGFuZ2UoKSBmaW5hbDsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxD b2NvYS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29j b2EubW0KaW5kZXggYWFlMjkwYjY0NTA0Li43OTJmMGNlOTVjZjcgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW0KKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5tbQpAQCAtNjYs NiArNjYsMTYgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpwYWdlRXh0ZW5kZWRCYWNrZ3Jv dW5kQ29sb3JEaWRDaGFuZ2UoKQogICAgIFttX3dlYlZpZXcgZGlkQ2hhbmdlVmFsdWVGb3JLZXk6 QCJfcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yIl07CiB9CiAKK3ZvaWQgUGFnZUNsaWVudElt cGxDb2NvYTo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKQoreworICAgIFttX3dlYlZp ZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQYWdlVG9wQ29sb3IiXTsKK30KKwor dm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCkK K3sKKyAgICBbbV93ZWJWaWV3IGRpZENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQYWdlVG9w Q29sb3IiXTsKK30KKwogdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjppc1BsYXlpbmdBdWRpb1dp bGxDaGFuZ2UoKQogewogICAgIFttX3dlYlZpZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5Ok5TU3Ry aW5nRnJvbVNlbGVjdG9yKEBzZWxlY3RvcihfaXNQbGF5aW5nQXVkaW8pKV07CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9QYWdlQ2xpZW50LmgKaW5kZXggMTQzOWZkMDA2ODEwLi45NzA4YjgxNjU5MTEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKQEAgLTUwOSw2ICs1MDksOCBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCB2b2lkIHRoZW1lQ29sb3JEaWRDaGFuZ2UoKSB7IH0KICAgICB2aXJ0 dWFsIHZvaWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yV2lsbENoYW5nZSgpIHsgfQogICAg IHZpcnR1YWwgdm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSB7IH0K KyAgICB2aXJ0dWFsIHZvaWQgc2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKSB7IH0KKyAg ICB2aXJ0dWFsIHZvaWQgc2FtcGxlZFBhZ2VUb3BDb2xvckRpZENoYW5nZSgpIHsgfQogICAgIHZp cnR1YWwgdm9pZCBkaWRDaGFuZ2VCYWNrZ3JvdW5kQ29sb3IoKSA9IDA7CiAgICAgdmlydHVhbCB2 b2lkIGlzUGxheWluZ0F1ZGlvV2lsbENoYW5nZSgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgaXNQ bGF5aW5nQXVkaW9EaWRDaGFuZ2UoKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcAppbmRleCA4YzRhNzY3ZmI0YzYuLmY1ZWFkZmY4YjFjNSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xOTE3LDYgKzE5MTcsOSBAQCBDb2xv ciBXZWJQYWdlUHJveHk6OnNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IoKSBjb25zdAogICAgIGlm IChtX3ByZWZlcmVuY2VzLT51c2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xv cigpICYmIG1fdGhlbWVDb2xvci5pc1ZhbGlkKCkpCiAgICAgICAgIHJldHVybiBtX3RoZW1lQ29s b3I7CiAKKyAgICBpZiAobV9wcmVmZXJlbmNlcy0+dXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IoKSAmJiBtX3NhbXBsZWRQYWdlVG9wQ29sb3IuaXNWYWxp ZCgpKQorICAgICAgICByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9yOworCiAgICAgcmV0dXJu IG1fcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yOwogfQogCkBAIC04NTE1LDYgKzg1MTgsMTYg QEAgdm9pZCBXZWJQYWdlUHJveHk6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5n ZShjb25zdCBDb2xvciYgcGFnZUV4dGVuZGUKICAgICBwYWdlQ2xpZW50KCkucGFnZUV4dGVuZGVk QmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCk7CiB9CiAKK3ZvaWQgV2ViUGFnZVByb3h5OjpkaWRT YW1wbGVQYWdlVG9wQ29sb3IoY29uc3QgQ29sb3ImIHNhbXBsZWRQYWdlVG9wQ29sb3IpCit7Cisg ICAgaWYgKG1fc2FtcGxlZFBhZ2VUb3BDb2xvciA9PSBzYW1wbGVkUGFnZVRvcENvbG9yKQorICAg ICAgICByZXR1cm47CisKKyAgICBwYWdlQ2xpZW50KCkuc2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxD aGFuZ2UoKTsKKyAgICBtX3NhbXBsZWRQYWdlVG9wQ29sb3IgPSBzYW1wbGVkUGFnZVRvcENvbG9y OworICAgIHBhZ2VDbGllbnQoKS5zYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCk7Cit9CisK ICNpZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQSSkKIHZvaWQgV2ViUGFnZVByb3h5OjpkaWRG YWlsVG9Jbml0aWFsaXplUGx1Z2luKGNvbnN0IFN0cmluZyYgbWltZVR5cGUsIGNvbnN0IFN0cmlu ZyYgZnJhbWVVUkxTdHJpbmcsIGNvbnN0IFN0cmluZyYgcGFnZVVSTFN0cmluZykKIHsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggYjdkNGEwNTg1MThkLi5jYTk3NTY5 N2JhMDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCkBAIC02NjUsNiAr NjY1LDggQEAgcHVibGljOgogICAgIC8vIHRoZSBtZXNzYWdlIGVudGlyZWx5LgogICAgIFdlYkNv cmU6OkNvbG9yIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNvbnN0IHsgcmV0dXJuIG1f cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yOyB9CiAKKyAgICBXZWJDb3JlOjpDb2xvciBzYW1w bGVkUGFnZVRvcENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9yOyB9 CisKICAgICBXZWJDb3JlOjpDb2xvciBzY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgY29uc3Q7 CiAKICAgICB2b2lkIHZpZXdXaWxsU3RhcnRMaXZlUmVzaXplKCk7CkBAIC0yMDk2LDYgKzIwOTgs NyBAQCBwcml2YXRlOgogICAgIHZvaWQgZGlkQ2hhbmdlUGFnZUNvdW50KHVuc2lnbmVkKTsKICAg ICB2b2lkIHRoZW1lQ29sb3JDaGFuZ2VkKGNvbnN0IFdlYkNvcmU6OkNvbG9yJik7CiAgICAgdm9p ZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoY29uc3QgV2ViQ29yZTo6Q29s b3ImKTsKKyAgICB2b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcihjb25zdCBXZWJDb3JlOjpDb2xv ciYpOwogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVHSU5fQVBJKQogICAgIHZvaWQgZGlkRmFpbFRv SW5pdGlhbGl6ZVBsdWdpbihjb25zdCBTdHJpbmcmIG1pbWVUeXBlLCBjb25zdCBTdHJpbmcmIGZy YW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBhZ2VVUkxTdHJpbmcpOwogICAgIHZvaWQgZGlk QmxvY2tJbnNlY3VyZVBsdWdpblZlcnNpb24oY29uc3QgU3RyaW5nJiBtaW1lVHlwZSwgY29uc3Qg U3RyaW5nJiBwbHVnaW5VUkxTdHJpbmcsIGNvbnN0IFN0cmluZyYgZnJhbWVVUkxTdHJpbmcsIGNv bnN0IFN0cmluZyYgcGFnZVVSTFN0cmluZywgYm9vbCByZXBsYWNlbWVudE9ic2N1cmVkKTsKQEAg LTI2NDEsNiArMjY0NCw3IEBAIHByaXZhdGU6CiAgICAgV2ViQ29yZTo6Q29sb3IgbV90aGVtZUNv bG9yOwogICAgIFdlYkNvcmU6OkNvbG9yIG1fdW5kZXJsYXlDb2xvcjsKICAgICBXZWJDb3JlOjpD b2xvciBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKKyAgICBXZWJDb3JlOjpDb2xvciBt X3NhbXBsZWRQYWdlVG9wQ29sb3I7CiAKICAgICBib29sIG1fdXNlRml4ZWRMYXlvdXQgeyBmYWxz ZSB9OwogICAgIFdlYkNvcmU6OkludFNpemUgbV9maXhlZExheW91dFNpemU7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4gYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KaW5kZXggMTJiMTQ3 MWQ0ZjIzLi5iMTU2ODE5ODFkOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KQEAgLTc5LDYgKzc5LDcgQEAgbWVzc2FnZXMgLT4gV2Vi UGFnZVByb3h5IHsKICAgICBEaWRDaGFuZ2VQYWdlQ291bnQodW5zaWduZWQgcGFnZUNvdW50KQog ICAgIFRoZW1lQ29sb3JDaGFuZ2VkKFdlYkNvcmU6OkNvbG9yIHRoZW1lQ29sb3IpCiAgICAgUGFn ZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKFdlYkNvcmU6OkNvbG9yIGJhY2tncm91 bmRDb2xvcikKKyAgICBEaWRTYW1wbGVQYWdlVG9wQ29sb3IoV2ViQ29yZTo6Q29sb3Igc2FtcGxl ZFBhZ2VUb3BDb2xvcikKICNpZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQSSkKICAgICBEaWRG YWlsVG9Jbml0aWFsaXplUGx1Z2luKFN0cmluZyBtaW1lVHlwZSwgU3RyaW5nIGZyYW1lVVJMU3Ry aW5nLCBTdHJpbmcgcGFnZVVSTFN0cmluZykKICAgICBEaWRCbG9ja0luc2VjdXJlUGx1Z2luVmVy c2lvbihTdHJpbmcgbWltZVR5cGUsIFN0cmluZyBwbHVnaW5VUkxTdHJpbmcsIFN0cmluZyBmcmFt ZVVSTFN0cmluZywgU3RyaW5nIHBhZ2VVUkxTdHJpbmcsIGJvb2wgcmVwbGFjZW1lbnRPYnNjdXJl ZCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJDaHJvbWVDbGllbnQuY3BwIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L1dlYkNocm9tZUNsaWVudC5jcHAKaW5kZXggM2Y1YjYwM2MyY2NjLi5hMzFlZTcyM2RlYjEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJD aHJvbWVDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3Vw cG9ydC9XZWJDaHJvbWVDbGllbnQuY3BwCkBAIC0xMTY0LDYgKzExNjQsMTEgQEAgdm9pZCBXZWJD aHJvbWVDbGllbnQ6OnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpIGNvbnN0 CiAgICAgbV9wYWdlLnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpOwogfQog Cit2b2lkIFdlYkNocm9tZUNsaWVudDo6ZGlkU2FtcGxlUGFnZVRvcENvbG9yKCkgY29uc3QKK3sK KyAgICBtX3BhZ2UuZGlkU2FtcGxlUGFnZVRvcENvbG9yKCk7Cit9CisKIHZvaWQgV2ViQ2hyb21l Q2xpZW50Ojp3aGVlbEV2ZW50SGFuZGxlcnNDaGFuZ2VkKGJvb2wgaGFzSGFuZGxlcnMpCiB7CiAg ICAgbV9wYWdlLndoZWVsRXZlbnRIYW5kbGVyc0NoYW5nZWQoaGFzSGFuZGxlcnMpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNs aWVudC5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9t ZUNsaWVudC5oCmluZGV4IDFlMzYwZTMwZDM0YS4uZjBjYWQ1YzhlZWNkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmgK KysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNs aWVudC5oCkBAIC0zMzAsNiArMzMwLDcgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgdGhlbWVDb2xv ckNoYW5nZWQoKSBjb25zdCBmaW5hbDsKICAgICB2b2lkIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRD b2xvckRpZENoYW5nZSgpIGNvbnN0IGZpbmFsOworICAgIHZvaWQgZGlkU2FtcGxlUGFnZVRvcENv bG9yKCkgY29uc3QgZmluYWw7CiAgICAgCiAgICAgdm9pZCB3aGVlbEV2ZW50SGFuZGxlcnNDaGFu Z2VkKGJvb2wpIGZpbmFsOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dl YlBhZ2UuY3BwCmluZGV4IGNkOWMyYzA4NDE4ZS4uZWM2ZWUxNWJiZDczIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcApAQCAtNjQ0MCw2ICs2NDQwLDEx IEBAIHZvaWQgV2ViUGFnZTo6Zmx1c2hQZW5kaW5nUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9y Q2hhbmdlKCkKICAgICBzZW5kKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlBhZ2VFeHRlbmRlZEJh Y2tncm91bmRDb2xvckRpZENoYW5nZShtX3BhZ2UtPnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xv cigpKSk7CiB9CiAKK3ZvaWQgV2ViUGFnZTo6ZGlkU2FtcGxlUGFnZVRvcENvbG9yKCkKK3sKKyAg ICBzZW5kKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkRpZFNhbXBsZVBhZ2VUb3BDb2xvcihtX3Bh Z2UtPnNhbXBsZWRQYWdlVG9wQ29sb3IoKSkpOworfQorCiB2b2lkIFdlYlBhZ2U6OmZsdXNoUGVu ZGluZ0VkaXRvclN0YXRlVXBkYXRlKCkKIHsKICAgICBpZiAoIW1faGFzUGVuZGluZ0VkaXRvclN0 YXRlVXBkYXRlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViUGFnZS5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCmlu ZGV4IDUxNDY0OWFiNDRmNC4uYjc5YjhlODBkMDY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCkBAIC0xMjQwLDYgKzEyNDAsOCBAQCBwdWJsaWM6CiAgICAg dm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSB7IG1fcGVuZGluZ1Bh Z2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckNoYW5nZSA9IHRydWU7IH0KICAgICB2b2lkIGZsdXNo UGVuZGluZ1BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckNoYW5nZSgpOwogCisgICAgdm9pZCBk aWRTYW1wbGVQYWdlVG9wQ29sb3IoKTsKKwogICAgIHZvaWQgZmx1c2hQZW5kaW5nRWRpdG9yU3Rh dGVVcGRhdGUoKTsKIAogI2lmIEVOQUJMRShSRVNPVVJDRV9MT0FEX1NUQVRJU1RJQ1MpCmRpZmYg LS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTAxYTk0OTUx ODg2Li5lOTI1YmYwZGJhYTEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29s cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAyMS0wNC0yMyAgRGV2aW4gUm91c3NvICA8 ZHJvdXNzb0BhcHBsZS5jb20+CisKKyAgICAgICAgZXhwZXJpbWVudCB3aXRoIGF2ZXJhZ2luZyBz YW1wbGluZyBjb2xvcnMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2UgYXMgdGhlIHNjcm9sbCBh cmVhIGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIyNDk4NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNzYyNTE4ODk+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW06IEFkZGVkLgorICAgICAg ICAoLVtUZXN0S1ZPV3JhcHBlciBpbml0V2l0aE9ic2VydmFibGU6a2V5UGF0aDpjYWxsYmFjazpd KToKKyAgICAgICAgKC1bVGVzdEtWT1dyYXBwZXIgZGVhbGxvY10pOgorICAgICAgICAoLVtUZXN0 S1ZPV3JhcHBlciBvYnNlcnZlVmFsdWVGb3JLZXlQYXRoOm9mT2JqZWN0OmNoYW5nZTpjb250ZXh0 Ol0pOgorICAgICAgICAoY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVy Y2VudERpZmZlcmVuY2UpOgorICAgICAgICAod2FpdEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0No YW5nZUZvckhUTUwpOgorICAgICAgICAoY3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMp OgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLlplcm9NYXhQZXJjZW50RGlmZmVy ZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuTmVnYXRpdmVNYXhQZXJj ZW50RGlmZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuU29saWRD b2xvcik6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3Jz V2l0aG91dE91dGxpZXJCZWxvd01heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1Qu U2FtcGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJlbnRDb2xvcnNXaXRoTGVmdE91dGxpZXJBYm92ZU1h eFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5E aWZmZXJlbnRDb2xvcnNXaXRoTWlkZGxlT3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2Up OgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhS aWdodE91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2Ft cGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJlbnRDb2xvcnNJbmRpdmlkdWFsbHlBYm92ZU1heFBlcmNl bnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5EaWZmZXJl bnRDb2xvcnNDdW11bGF0aXZlbHlBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAg KFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5FeHBlcmltZW50YWxVc2VTYW1wbGVkUGFnZVRvcENv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcik6CisKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKwogMjAyMS0wNC0y MCAgRGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+CiAKICAgICAgICAgUGFyc2UgYHRo ZW1lX2NvbG9yYCBpbiB3ZWIgYXBwbGljYXRpb24gbWFuaWZlc3RzIGFuZCBwYXNzIGl0IGFsb25n IHRvIGAtW1dLV2ViVmlldyB0aGVtZUNvbG9yXWAKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg YjRmYjFhZjdhNTU1Li4yNTk5OGZlNDE3OWQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC04 NjQsNiArODY0LDcgQEAKIAkJOTNGNTZEQTcxRTVGOTE3NDAwM0VERTg0IC8qIGxpYmljdWNvcmUu ZHlsaWIgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 QzgzRTAzMzFEMEE1RjI3MDBGRUJDRjMgLyogbGliaWN1Y29yZS5keWxpYiAqLzsgfTsKIAkJOTNG NTZEQTkxRTVGOTE5RDAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTNGNTZEQTgxRTVGOTE4MTAwM0VE RTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tICovOyB9OwogCQk5M0Y3RTg2RjE0REM4RTVDMDBD ODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVzX0J1bmRsZS5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0Y3RTg2RTE0 REM4RTVCMDBDODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVzX0J1 bmRsZS5jcHAgKi87IH07CisJCTk1MDk1RjIwMjYyRkZGQTUwMDAwRDkyMCAvKiBTYW1wbGVkUGFn ZVRvcENvbG9yLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gOTUwOTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3IubW0gKi87 IH07CiAJCTk1MEU0Q0MxMjUyRTc1MjQwMDcxNjU5RiAvKiBpT1NTdHlsdXNTdXBwb3J0Lm1tIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTUwRTRDQzAyNTJF NzUyMzAwNzE2NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi87IH07CiAJCTk1M0FCQjM1MjVD MEQ2ODIwMDRDOEI3MyAvKiBQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IubW0gaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5NTNBQkIzNDI1QzBENjgxMDA0 QzhCNzMgLyogUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yLm1tICovOyB9OwogCQk5NUE1MjQ5 NTI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5tbSBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1QTUyNDk0MjU4MUExMEQwMDQ2MUZF OSAvKiBXS1dlYlZpZXdUaGVtZUNvbG9yLm1tICovOyB9OwpAQCAtMjU1Miw2ICsyNTUzLDcgQEAK IAkJOTNGNTZEQTgxRTVGOTE4MTAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV0tXZWJWaWV3U25hcHNob3QubW07 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzRjdFODZCMTREQzhFNEQwMEM4NEE5OSAv KiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXRGcmFtZXMuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJh bWVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTNGN0U4NkUxNERDOEU1QjAw Qzg0QTk5IC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1lc19CdW5kbGUuY3Bw ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmlyc3RWaXN1YWxseU5v bkVtcHR5TGF5b3V0RnJhbWVzX0J1bmRsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTk1MDk1RjFGMjYyRkZGQTUwMDAwRDkyMCAvKiBTYW1wbGVkUGFnZVRvcENvbG9yLm1tICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gU2FtcGxlZFBhZ2VUb3BDb2xv ci5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTUwRTRDQzAyNTJFNzUyMzAwNzE2 NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpj cHA7IHBhdGggPSBpT1NTdHlsdXNTdXBwb3J0Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk5NTNBQkIzNDI1QzBENjgxMDA0QzhCNzMgLyogUGFnZUV4dGVuZGVkQmFja2dyb3VuZENv bG9yLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUGFnZUV4dGVu ZGVkQmFja2dyb3VuZENvbG9yLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5NUE1 MjQ5NDI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5tbSAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdLV2ViVmlld1RoZW1lQ29sb3IubW07IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zNTIxLDYgKzM1MjMsNyBAQAogCQkJCUExODBD MEY5MUVFNjdERjAwMDQ2OEY0NyAvKiBSdW5PcGVuUGFuZWwubW0gKi8sCiAJCQkJRjREMjk4NkQy MEZFRTczNzAwOTJENjM2IC8qIFJ1blNjcmlwdEFmdGVyRG9jdW1lbnRMb2FkLm1tICovLAogCQkJ CTVDQTk4NTUxMjExM0NCOEMwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0gKi8sCisJCQkJOTUw OTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3IubW0gKi8sCiAJCQkJ Q0UwOTQ3MzYyMDYzMjIzQjAwM0M5QkEwIC8qIFNjaGVtZVJlZ2lzdHJ5Lm1tICovLAogCQkJCTUx RUIxMjkzMUZERjA1MDUwMEE1QTFCRCAvKiBTZXJ2aWNlV29ya2VyQmFzaWMubW0gKi8sCiAJCQkJ NUM2ODM0NzEyMzVBQ0M3QzAwNDFFNkIxIC8qIFNlcnZpY2VXb3JrZXJUQ1BTZXJ2ZXIuaCAqLywK QEAgLTU2MzAsNiArNTYzMyw3IEBACiAJCQkJQTE4MEMwRkExRUU2N0RGMDAwNDY4RjQ3IC8qIFJ1 bk9wZW5QYW5lbC5tbSBpbiBTb3VyY2VzICovLAogCQkJCUY0RDI5ODZFMjBGRUU3MzcwMDkyRDYz NiAvKiBSdW5TY3JpcHRBZnRlckRvY3VtZW50TG9hZC5tbSBpbiBTb3VyY2VzICovLAogCQkJCTVD QTk4NTUzMjExM0NGNzgwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0gaW4gU291cmNlcyAqLywK KwkJCQk5NTA5NUYyMDI2MkZGRkE1MDAwMEQ5MjAgLyogU2FtcGxlZFBhZ2VUb3BDb2xvci5tbSBp biBTb3VyY2VzICovLAogCQkJCUNEQ0ZBN0FBMUU0NTE4MzIwMEMyNDMzRCAvKiBTYW1wbGVNYXAu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0UwOTQ3MzcyMDYzMjIzQjAwM0M5QkEwIC8qIFNjaGVt ZVJlZ2lzdHJ5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0RDMDkzMkIyMUM4NzJDMTAwMzBDNEIw IC8qIFNjcm9sbGluZ0RvZXNOb3RQYXVzZU1lZGlhLm1tIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9w Q29sb3IubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQ YWdlVG9wQ29sb3IubW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5l OGIyYmYyNDNkYzAKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW0KQEAgLTAsMCArMSwyOTIgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMjEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBB TkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaW1wb3J0ICJjb25maWcuaCIKKworI2ltcG9ydCAiVGVzdENvY29hLmgiCisj aW1wb3J0ICJUZXN0V0tXZWJWaWV3LmgiCisjaW1wb3J0ICJVdGlsaXRpZXMuaCIKKyNpbXBvcnQg PFdlYktpdC9XS1ByZWZlcmVuY2VzUHJpdmF0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L1dLV2ViVmll d0NvbmZpZ3VyYXRpb25Qcml2YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3UHJpdmF0 ZS5oPgorI2ltcG9ydCA8V2ViS2l0L19XS0ludGVybmFsRGVidWdGZWF0dXJlLmg+CisjaW1wb3J0 IDx3dGYvRnVuY3Rpb24uaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0 Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKworI2RlZmluZSBFWFBFQ1RfSU5fUkFOR0UoYWN0dWFs LCBtaW4sIG1heCkgXAorICAgIEVYUEVDVF9HRShhY3R1YWwsIG1pbik7IFwKKyAgICBFWFBFQ1Rf TEUoYWN0dWFsLCBtYXgpOworCitjb25zdGV4cHIgQ0dGbG9hdCByZWRDb2xvckNvbXBvbmVudHNb NF0gPSB7IDEsIDAsIDAsIDEgfTsKKworQGludGVyZmFjZSBUZXN0S1ZPV3JhcHBlciA6IE5TT2Jq ZWN0CisKKy0gKGluc3RhbmNldHlwZSlpbml0V2l0aE9ic2VydmFibGU6KE5TT2JqZWN0ICopb2Jz ZXJ2YWJsZSBrZXlQYXRoOihOU1N0cmluZyAqKWtleVBhdGggY2FsbGJhY2s6KEZ1bmN0aW9uPHZv aWQoKT4mJiljYWxsYmFjazsKKworQGVuZAorCitAaW1wbGVtZW50YXRpb24gVGVzdEtWT1dyYXBw ZXIgeworICAgIFJldGFpblB0cjxOU09iamVjdD4gX29ic2VydmFibGU7CisgICAgUmV0YWluUHRy PE5TU3RyaW5nPiBfa2V5UGF0aDsKKyAgICBGdW5jdGlvbjx2b2lkKCk+IF9jYWxsYmFjazsKK30K KworLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoT2JzZXJ2YWJsZTooTlNPYmplY3QgKilvYnNlcnZh YmxlIGtleVBhdGg6KE5TU3RyaW5nICopa2V5UGF0aCBjYWxsYmFjazooRnVuY3Rpb248dm9pZCgp PiYmKWNhbGxiYWNrCit7CisgICAgaWYgKCEoc2VsZiA9IFtzdXBlciBpbml0XSkpCisgICAgICAg IHJldHVybiBuaWw7CisKKyAgICBfb2JzZXJ2YWJsZSA9IG9ic2VydmFibGU7CisgICAgX2tleVBh dGggPSBrZXlQYXRoOworICAgIF9jYWxsYmFjayA9IFdURk1vdmUoY2FsbGJhY2spOworCisgICAg W19vYnNlcnZhYmxlIGFkZE9ic2VydmVyOnNlbGYgZm9yS2V5UGF0aDpfa2V5UGF0aC5nZXQoKSBv cHRpb25zOjAgY29udGV4dDpuaWxdOworCisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQp ZGVhbGxvYworeworICAgIFtfb2JzZXJ2YWJsZSByZW1vdmVPYnNlcnZlcjpzZWxmIGZvcktleVBh dGg6X2tleVBhdGguZ2V0KCkgY29udGV4dDpudWxscHRyXTsKKworICAgIFtzdXBlciBkZWFsbG9j XTsKK30KKworLSAodm9pZClvYnNlcnZlVmFsdWVGb3JLZXlQYXRoOihOU1N0cmluZyAqKWtleVBh dGggb2ZPYmplY3Q6KGlkKW9iamVjdCBjaGFuZ2U6KE5TRGljdGlvbmFyeSAqKWNoYW5nZSBjb250 ZXh0Oih2b2lkICopY29udGV4dAoreworICAgIF9jYWxsYmFjaygpOworfQorCitAZW5kCisKK2Vu dW0gY2xhc3MgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29s b3IgOiBib29sIHsgWWVzLCBObyB9Oworc3RhdGljIFJldGFpblB0cjxUZXN0V0tXZWJWaWV3PiBj cmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZShk b3VibGUgc2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlLCBVc2VTYW1wbGVk UGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciB1c2VTYW1wbGVkUGFnZVRv cENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciA9IFVzZVNhbXBsZWRQYWdlVG9wQ29s b3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOjpObykKK3sKKyAgICBhdXRvIGNvbmZpZ3Vy YXRpb24gPSBhZG9wdE5TKFtbV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBhbGxvY10gaW5pdF0pOwor ICAgIFtjb25maWd1cmF0aW9uIF9zZXRTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZl cmVuY2U6c2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlXTsKKworICAgIGZv ciAoX1dLSW50ZXJuYWxEZWJ1Z0ZlYXR1cmUgKmZlYXR1cmUgaW4gW1dLUHJlZmVyZW5jZXMgX2lu dGVybmFsRGVidWdGZWF0dXJlc10pIHsKKyAgICAgICAgaWYgKFtmZWF0dXJlLmtleSBpc0VxdWFs VG9TdHJpbmc6QCJVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvciJdKSB7CisgICAgICAgICAgICBbW2NvbmZpZ3VyYXRpb24gcHJlZmVyZW5jZXNdIF9zZXRF bmFibGVkOih1c2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xv ciA9PSBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcjo6 WWVzKSBmb3JJbnRlcm5hbERlYnVnRmVhdHVyZTpmZWF0dXJlXTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIGFkb3B0TlMoW1tUZXN0V0tXZWJWaWV3 IGFsbG9jXSBpbml0V2l0aEZyYW1lOkNHUmVjdE1ha2UoMCwgMCwgODAwLCA2MDApIGNvbmZpZ3Vy YXRpb246Y29uZmlndXJhdGlvbi5nZXQoKV0pOworfQorCitzdGF0aWMgdm9pZCB3YWl0Rm9yU2Ft cGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRNTChUZXN0V0tXZWJWaWV3ICp3ZWJWaWV3LCBT dHJpbmcmJiBodG1sKQoreworICAgIGJvb2wgZG9uZSA9IGZhbHNlOworICAgIGF1dG8gc2FtcGxl ZFBhZ2VUb3BDb2xvck9ic2VydmVyID0gYWRvcHROUyhbW1Rlc3RLVk9XcmFwcGVyIGFsbG9jXSBp bml0V2l0aE9ic2VydmFibGU6d2ViVmlldyBrZXlQYXRoOkAiX3NhbXBsZWRQYWdlVG9wQ29sb3Ii IGNhbGxiYWNrOlsmXSB7CisgICAgICAgIGRvbmUgPSB0cnVlOworICAgIH1dKTsKKyAgICBbd2Vi VmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVD aGlsZEZyYW1lc1BhaW50OldURk1vdmUoaHRtbCldOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6 OnJ1bigmZG9uZSk7Cit9CisKK3N0YXRpYyBTdHJpbmcgY3JlYXRlSFRNTEdyYWRpZW50V2l0aENv bG9yU3RvcHMoVmVjdG9yPFN0cmluZz4mJiBjb2xvclN0b3BzKQoreworICAgIEVYUEVDVF9HRShj b2xvclN0b3BzLnNpemUoKSwgMlVMKTsKKworICAgIFN0cmluZ0J1aWxkZXIgZ3JhZGllbnRCdWls ZGVyOworICAgIGdyYWRpZW50QnVpbGRlci5hcHBlbmQoIjxib2R5IHN0eWxlPVwiYmFja2dyb3Vu ZC1pbWFnZTogbGluZWFyLWdyYWRpZW50KHRvIHJpZ2h0Il9zKTsKKyAgICBmb3IgKGF1dG8mJiBj b2xvclN0b3AgOiBXVEZNb3ZlKGNvbG9yU3RvcHMpKSB7CisgICAgICAgIGdyYWRpZW50QnVpbGRl ci5hcHBlbmQoIiwgIl9zKTsKKyAgICAgICAgZ3JhZGllbnRCdWlsZGVyLmFwcGVuZChXVEZNb3Zl KGNvbG9yU3RvcCkpOworICAgIH0KKyAgICBncmFkaWVudEJ1aWxkZXIuYXBwZW5kKCIpXCI+VGVz dCJfcyk7CisgICAgcmV0dXJuIGdyYWRpZW50QnVpbGRlci50b1N0cmluZygpOworfQorCitURVNU KFNhbXBsZWRQYWdlVG9wQ29sb3IsIFplcm9NYXhQZXJjZW50RGlmZmVyZW5jZSkKK3sKKyAgICBh dXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJj ZW50RGlmZmVyZW5jZSgwLjApOworICAgIEVYUEVDVF9UUlVFKCFbd2ViVmlldyBfc2FtcGxlZFBh Z2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5n QW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGll bnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAicmVkIiB9KV07CisgICAgRVhQRUNUX1RSVUUoIVt3 ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BD b2xvciwgTmVnYXRpdmVNYXhQZXJjZW50RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcg PSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5j ZSgtMC4wNSk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9y XSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50 aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xv clN0b3BzKHsgInJlZCIsICJyZWQiIH0pXTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3Nh bXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBTb2xp ZENvbG9yKQoreworICAgIGF1dG8gc1JHQkNvbG9yU3BhY2UgPSBhZG9wdENGKENHQ29sb3JTcGFj ZUNyZWF0ZVdpdGhOYW1lKGtDR0NvbG9yU3BhY2VTUkdCKSk7CisgICAgYXV0byByZWRDb2xvciA9 IGFkb3B0Q0YoQ0dDb2xvckNyZWF0ZShzUkdCQ29sb3JTcGFjZS5nZXQoKSwgcmVkQ29sb3JDb21w b25lbnRzKSk7CisKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSgh W3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFn ZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVu dFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1RfVFJVRShDR0Nv bG9yRXF1YWxUb0NvbG9yKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0NvbG9yLCBy ZWRDb2xvci5nZXQoKSkpOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIERpZmZlcmVu dENvbG9yc1dpdGhvdXRPdXRsaWVyQmVsb3dNYXhQZXJjZW50RGlmZmVyZW5jZSkKK3sKKyAgICBh dXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJj ZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXcgX3NhbXBsZWRQ YWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VG b3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsK KyAgICAgICAgImNvbG9yKHNyZ2IgMC41MSAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAw LjUyIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTMgMSAxKSJfcywKKyAgICAgICAg ImNvbG9yKHNyZ2IgMC41NCAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjU1IDEgMSki X3MsCisgICAgfSkpOworCisgICAgYXV0byBjb21wb25lbnRzID0gQ0dDb2xvckdldENvbXBvbmVu dHMoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IpOworICAgIEVYUEVDVF9J Tl9SQU5HRShjb21wb25lbnRzWzBdLCAwLjUyNSwgMC41MzUpOworICAgIEVYUEVDVF9FUShjb21w b25lbnRzWzFdLCAxKTsKKyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1syXSwgMSk7CisgICAgRVhQ RUNUX0VRKGNvbXBvbmVudHNbM10sIDEpOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3Is IERpZmZlcmVudENvbG9yc1dpdGhMZWZ0T3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2Up Cit7CisgICAgYXV0byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENv bG9yTWF4UGVyY2VudERpZmZlcmVuY2UoMC4wNSk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3 IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICB3YWl0Rm9yU2FtcGxlZFBhZ2VUb3BDb2xv clRvQ2hhbmdlRm9ySFRNTCh3ZWJWaWV3LmdldCgpLCBjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29s b3JTdG9wcyh7CisgICAgICAgICJjb2xvcihzcmdiIDAuMDAgMSAxKSJfcywgLy8gb3V0bGllcgor ICAgICAgICAiY29sb3Ioc3JnYiAwLjUxIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAu NTIgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41MyAxIDEpIl9zLAorICAgICAgICAi Y29sb3Ioc3JnYiAwLjU0IDEgMSkiX3MsCisgICAgfSkpOworCisgICAgYXV0byBjb21wb25lbnRz ID0gQ0dDb2xvckdldENvbXBvbmVudHMoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNH Q29sb3IpOworICAgIEVYUEVDVF9JTl9SQU5HRShjb21wb25lbnRzWzBdLCAwLjUyLCAwLjUzKTsK KyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1sxXSwgMSk7CisgICAgRVhQRUNUX0VRKGNvbXBvbmVu dHNbMl0sIDEpOworICAgIEVYUEVDVF9FUShjb21wb25lbnRzWzNdLCAxKTsKK30KKworVEVTVChT YW1wbGVkUGFnZVRvcENvbG9yLCBEaWZmZXJlbnRDb2xvcnNXaXRoTWlkZGxlT3V0bGllckFib3Zl TWF4UGVyY2VudERpZmZlcmVuY2UpCit7CisgICAgYXV0byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmll d1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UoMC4wNSk7CisgICAg RVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2Vi VmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVD aGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAg ICAgImNvbG9yKHNyZ2IgMC41MSAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjUyIDEg MSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuMDAgMSAxKSJfcywgLy8gb3V0bGllcgorICAg ICAgICAiY29sb3Ioc3JnYiAwLjUzIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTQg MSAxKSJfcywKKyAgICB9KV07CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFn ZVRvcENvbG9yXSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVyZW50Q29s b3JzV2l0aFJpZ2h0T3V0bGllckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UpCit7CisgICAgYXV0 byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2Vu dERpZmZlcmVuY2UoMC4wNSk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFn ZVRvcENvbG9yXSk7CisKKyAgICB3YWl0Rm9yU2FtcGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9y SFRNTCh3ZWJWaWV3LmdldCgpLCBjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7Cisg ICAgICAgICJjb2xvcihzcmdiIDAuNTEgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC41 MiAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjUzIDEgMSkiX3MsCisgICAgICAgICJj b2xvcihzcmdiIDAuNTQgMSAxKSJfcywKKyAgICAgICAgImNvbG9yKHNyZ2IgMC4wMCAxIDEpIl9z LCAvLyBvdXRsaWVyCisgICAgfSkpOworCisgICAgYXV0byBjb21wb25lbnRzID0gQ0dDb2xvckdl dENvbXBvbmVudHMoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IpOworICAg IEVYUEVDVF9JTl9SQU5HRShjb21wb25lbnRzWzBdLCAwLjUyLCAwLjUzKTsKKyAgICBFWFBFQ1Rf RVEoY29tcG9uZW50c1sxXSwgMSk7CisgICAgRVhQRUNUX0VRKGNvbXBvbmVudHNbMl0sIDEpOwor ICAgIEVYUEVDVF9FUShjb21wb25lbnRzWzNdLCAxKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRv cENvbG9yLCBEaWZmZXJlbnRDb2xvcnNJbmRpdmlkdWFsbHlBYm92ZU1heFBlcmNlbnREaWZmZXJl bmNlKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VU b3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKDAuMDUpOworICAgIEVYUEVDVF9UUlVFKCFbd2Vi VmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXcgc3luY2hyb25vdXNs eUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpj cmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7CisgICAgICAgICJjb2xvcihzcmdiIDAu NSAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjYgMSAxKSJfcywKKyAgICAgICAgImNv bG9yKHNyZ2IgMC43IDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuOCAxIDEpIl9zLAor ICAgICAgICAiY29sb3Ioc3JnYiAwLjkgMSAxKSJfcywKKyAgICB9KV07CisgICAgRVhQRUNUX1RS VUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7Cit9CisKK1RFU1QoU2FtcGxlZFBh Z2VUb3BDb2xvciwgRGlmZmVyZW50Q29sb3JzQ3VtdWxhdGl2ZWx5QWJvdmVNYXhQZXJjZW50RGlm ZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhQZXJjZW50RGlmZmVyZW5jZSgwLjA1KTsKKyAgICBFWFBFQ1RfVFJVRSgh W3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3ZWJWaWV3IHN5bmNocm9u b3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVzUGFp bnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMoeworICAgICAgICAiY29sb3Ioc3Jn YiAwLjUxIDEgMSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTMgMSAxKSJfcywKKyAgICAg ICAgImNvbG9yKHNyZ2IgMC41NSAxIDEpIl9zLAorICAgICAgICAiY29sb3Ioc3JnYiAwLjU3IDEg MSkiX3MsCisgICAgICAgICJjb2xvcihzcmdiIDAuNTkgMSAxKSJfcywKKyAgICB9KV07CisgICAg RVhQRUNUX1RSVUUoIVt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7Cit9CisKKyNpZiBQ TEFURk9STShJT1NfRkFNSUxZKQorCisvLyBUaGVyZSdzIG5vIEFQSS9TUEkgdG8gZ2V0IHRoZSBi YWNrZ3JvdW5kIGNvbG9yIG9mIHRoZSBzY3JvbGwgYXJlYSBvbiBtYWNPUy4KKworVEVTVChXS1dl YlZpZXdUaGVtZUNvbG9yLCBFeHBlcmltZW50YWxVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Ny b2xsQXJlYUJhY2tncm91bmRDb2xvcikKK3sKKyAgICBhdXRvIHNSR0JDb2xvclNwYWNlID0gYWRv cHRDRihDR0NvbG9yU3BhY2VDcmVhdGVXaXRoTmFtZShrQ0dDb2xvclNwYWNlU1JHQikpOworICAg IGF1dG8gcmVkQ29sb3IgPSBhZG9wdENGKENHQ29sb3JDcmVhdGUoc1JHQkNvbG9yU3BhY2UuZ2V0 KCksIHJlZENvbG9yQ29tcG9uZW50cykpOworCisgICAgYXV0byB3ZWJWaWV3V2l0aG91dFRoZW1l Q29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yID0gY3JlYXRlV2ViVmlld1dpdGhTYW1w bGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2UoMC4wNSwgVXNlU2FtcGxlZFBhZ2VU b3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6Ok5vKTsKKyAgICBFWFBFQ1RfVFJV RSghW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Ig X3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3ZWJWaWV3V2l0aG91dFRoZW1lQ29sb3JG b3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0Fu ZFdhaXRVbnRpbEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50 V2l0aENvbG9yU3RvcHMoeyAicmVkIiwgImJsdWUiIH0pXTsKKyAgICBFWFBFQ1RfVFJVRSghW3dl YlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgX3NhbXBs ZWRQYWdlVG9wQ29sb3JdKTsKKyAgICBFWFBFQ1RfVFJVRSghW3dlYlZpZXdXaXRob3V0VGhlbWVD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Nyb2xsVmlld10pOworCisgICAgd2Fp dEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0NoYW5nZUZvckhUTUwod2ViVmlld1dpdGhvdXRUaGVt ZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvci5nZXQoKSwgY3JlYXRlSFRNTEdyYWRp ZW50V2l0aENvbG9yU3RvcHMoeyAicmVkIiwgInJlZCIgfSkpOworICAgIEVYUEVDVF9UUlVFKENH Q29sb3JFcXVhbFRvQ29sb3IoW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFC YWNrZ3JvdW5kQ29sb3IgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IsIHJlZENvbG9yLmdl dCgpKSk7CisgICAgRVhQRUNUX1RSVUUoIVt3ZWJWaWV3V2l0aG91dFRoZW1lQ29sb3JGb3JTY3Jv bGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9sbFZpZXddKTsKKworICAgIGF1dG8gd2ViVmlld1dp dGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciA9IGNyZWF0ZVdlYlZpZXdX aXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKDAuMDUsIFVzZVNhbXBs ZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOjpZZXMpOworICAgIEVY UEVDVF9UUlVFKCFbd2ViVmlld1dpdGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXdXaXRob3V0VGhlbWVD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25vdXNseUxvYWRIVE1MU3Ry aW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3Jh ZGllbnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOworICAgIEVYUEVDVF9UUlVF KCFbd2ViVmlld1dpdGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBfc2Ft cGxlZFBhZ2VUb3BDb2xvcl0pOworICAgIEVYUEVDVF9UUlVFKCFbd2ViVmlld1dpdGhUaGVtZUNv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBzY3JvbGxWaWV3XSk7CisKKyAgICB3YWl0 Rm9yU2FtcGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRNTCh3ZWJWaWV3V2l0aG91dFRoZW1l Q29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yLmdldCgpLCBjcmVhdGVIVE1MR3JhZGll bnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAicmVkIiB9KSk7CisgICAgRVhQRUNUX1RSVUUoQ0dD b2xvckVxdWFsVG9Db2xvcihbd2ViVmlld1dpdGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tn cm91bmRDb2xvciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0uQ0dDb2xvciwgcmVkQ29sb3IuZ2V0KCkp KTsKKyAgICBFWFBFQ1RfVFJVRShDR0NvbG9yRXF1YWxUb0NvbG9yKFt3ZWJWaWV3V2l0aFRoZW1l Q29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9sbFZpZXddLmJhY2tncm91bmRD b2xvci5DR0NvbG9yLCByZWRDb2xvci5nZXQoKSkpOworfQorCisjZW5kaWYgLy8gUExBVEZPUk0o SU9TX0ZBTUlMWSkK 427301 2021-04-28 15:55:34 -0700 2021-04-28 16:09:55 -0700 Patch 224987.diff text/plain 52090 hi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggNzA0YzcyMDZlY2MxLi45OGU4MmU3ZTE1MDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIw MjEtMDQtMjggIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4 cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9m IHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgorCisg ICAgICAgICogU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlcy55YW1sOgorICAgICAg ICBBZGQgYSBgU2FtcGxlZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlYCBzZXR0aW5n IHRoYXQgY29udHJvbHMgYm90aCB3aGV0aGVyIG9yIG5vdCB0bworICAgICAgICBzYW1wbGUgY29s b3JzIGZyb20gdGhlIHRvcCBvZiB0aGUgcGFnZSAob25seSBpZiB2YWx1ZSA+IDApIGFuZCB0aGUg bWF4IHBlcmNlbnQgZGlmZmVyZW5jZQorICAgICAgICBhbGxvd2VkIGFjcm9zcyBhbGwgc2FtcGxl cy4KKworICAgICAgICAqIFNjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRlcm5h bC55YW1sOgorICAgICAgICBBZGQgYSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFy ZWFCYWNrZ3JvdW5kQ29sb3JgIGludGVybmFsIHNldHRpbmcgdGhhdCBjb250cm9scworICAgICAg ICB3aGV0aGVyIHRoZSBzYW1wbGVkIHBhZ2UgdG9wIGNvbG9yIGNhbiBiZSB1c2VkIGFzIHRoZSBv dmVyc2Nyb2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvci4KKwogMjAyMS0wNC0yNiAgS2VpdGggTWls bGVyICA8a2VpdGhfbWlsbGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBDb2RlQmxvY2sgc2hvdWxk IGRvIGEgYmV0dGVyIGpvYiBhY2NvdW50aW5nIGZvciBleHRyYSBtZW1vcnkgaXQgYWxsb2NhdGVz LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVu Y2VzLnlhbWwgYi9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMu eWFtbAppbmRleCA1NmM0MjY3OGRmNTAuLmM0MTc4ZjliNTNmOSAxMDA2NDQKLS0tIGEvU291cmNl L1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzLnlhbWwKKysrIGIvU291cmNl L1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzLnlhbWwKQEAgLTE4MjMsNiAr MTgyMywxNiBAQCBTYWZlQnJvd3NpbmdFbmFibGVkOgogICAgIFdlYktpdDoKICAgICAgIGRlZmF1 bHQ6IHRydWUKIAorU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2U6CisgIHR5cGU6IGRv dWJsZQorICBkZWZhdWx0VmFsdWU6CisgICAgV2ViS2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDog MAorICAgIFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6IDAKKyAgICBXZWJDb3JlOgorICAgICAgZGVm YXVsdDogMAorCiBTYW5zU2VyaWZGb250RmFtaWx5OgogICB0eXBlOiBTdHJpbmcKICAgd2ViS2l0 TGVnYWN5UHJlZmVyZW5jZUtleTogV2ViS2l0U2Fuc1NlcmlmRm9udApkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbCBi L1NvdXJjZS9XVEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlc0ludGVybmFsLnlh bWwKaW5kZXggMjA1ZjMyYTRjN2ExLi45ZjQ4MTE3ZWVhOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvU2NyaXB0cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlc0ludGVybmFsLnlhbWwKKysrIGIv U291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzSW50ZXJuYWwueWFt bApAQCAtNzUwLDYgKzc1MCwxOCBAQCBVc2VHUFVQcm9jZXNzRm9yV2ViR0xFbmFibGVkOgogICAg IFdlYktpdDoKICAgICAgIGRlZmF1bHQ6IGRlZmF1bHRVc2VHUFVQcm9jZXNzRm9yV2ViR0xFbmFi bGVkKCkKIAorVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29s b3I6CisgIHR5cGU6IGJvb2wKKyAgaHVtYW5SZWFkYWJsZU5hbWU6ICJVc2Ugc2FtcGxlZCBwYWdl IHRvcCBjb2xvciBmb3Igc2Nyb2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvciIKKyAgaHVtYW5SZWFk YWJsZURlc2NyaXB0aW9uOiAiVXNlIHNhbXBsZWQgcGFnZSB0b3AgY29sb3IgZm9yIHNjcm9sbCBh cmVhIGJhY2tncm91bmQgY29sb3IiCisgIGRlZmF1bHRWYWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6 CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAgIFdlYktpdDoKKyAgICAgIGRlZmF1bHQ6IGZhbHNl CisgICAgV2ViQ29yZToKKyAgICAgIGRlZmF1bHQ6IGZhbHNlCisKIFVzZVRoZW1lQ29sb3JGb3JT Y3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOgogICB0eXBlOiBib29sCiAgIGh1bWFuUmVhZGFibGVO YW1lOiAiVXNlIHRoZW1lLWNvbG9yIGZvciBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kIGNvbG9yIgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGNhOThhNDVkMGYxYS4uNzdjMDE0NzgxYWYwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsNDkgQEAKKzIwMjEtMDQtMjggIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29t PgorCisgICAgICAgIGV4cGVyaW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFj cm9zcyB0aGUgdG9wIG9mIHRoZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAg ICAgICAgPHJkYXI6Ly9wcm9ibGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IERh cmluIEFkbGVyLgorCisgICAgICAgIFRlc3RzOiBTYW1wbGVkUGFnZVRvcENvbG9yLlplcm9NYXhQ ZXJjZW50RGlmZmVyZW5jZQorICAgICAgICAgICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xvci5OZWdh dGl2ZU1heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENv bG9yLlNvbGlkQ29sb3IKKyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVy ZW50Q29sb3JzV2l0aG91dE91dGxpZXJCZWxvd01heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAg ICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhMZWZ0T3V0bGll ckFib3ZlTWF4UGVyY2VudERpZmZlcmVuY2UKKyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9w Q29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aE1pZGRsZU91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZm ZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9y c1dpdGhSaWdodE91dGxpZXJBYm92ZU1heFBlcmNlbnREaWZmZXJlbmNlCisgICAgICAgICAgICAg ICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc0luZGl2aWR1YWxseUFib3ZlTWF4 UGVyY2VudERpZmZlcmVuY2UKKyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlm ZmVyZW50Q29sb3JzQ3VtdWxhdGl2ZWx5QWJvdmVNYXhQZXJjZW50RGlmZmVyZW5jZQorICAgICAg ICAgICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xvci5EaXNwbGF5UDMKKyAgICAgICAgICAgICAgIFNh bXBsZWRQYWdlVG9wQ29sb3IuRXhwZXJpbWVudGFsVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IKKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAg ICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNhbXBsZWRQYWdlVG9wQ29sb3IgY29uc3QpOiBBZGRl ZC4KKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1l bnQ6OmVucXVldWVQYWludFRpbWluZ0VudHJ5SWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnQ6OmRldGVybWluZVNhbXBsZWRQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAg V2FpdCB1bnRpbCB0aGUgZmlyc3QgY29udGVudGZ1bCBwYWludCBiZWZvcmUgc2FtcGxpbmcuIERv bid0IHNhbXBsZSBpZiB0aGF0IGxvY2F0aW9uIHdvdWxkCisgICAgICAgIGZhbGwgaW50byBhIDNy ZC1wYXJ0eSBgPGlmcmFtZT5gLiBDdXJyZW50bHkgdXNlIDUgc25hcHNob3RzIGFjcm9zcyB0aGUg dG9wIG9mIHRoZSBwYWdlLAorICAgICAgICBhbGxvd2luZyBmb3Igb25lIG9mIGVpdGhlciB0aGUg Zmlyc3Qgb3IgbGFzdCBzbmFwc2hvdCB0byBiZSBhbiBvdXRsaWVyLCB3aGljaCBpcyBub3QKKyAg ICAgICAgaW5jbHVkZWQgaW4gdGhlIGF2ZXJhZ2Ugb2YgdGhlIG90aGVyIHNuYXBzaG90cyB0aGF0 J3MgdXNlZCBhcyB0aGUgZmluYWwgY29sb3IgdmFsdWUuIElmIHRoZQorICAgICAgICBwZXJjZW50 YWdlIGRpZmZlcmVuY2UgYmV0d2VlbiBhbnkgdHdvIHNuYXBzaG90cyAodW5sZXNzIGl0J3MgdGhl IGZpcnN0IG9yIGxhc3Qgc25hcHNob3QgYXMKKyAgICAgICAgZGVzY3JpYmVkIGFib3ZlKSBvciBh Y3Jvc3MgYWxsIHRoZSAobm9uLW91dGxpZXIpIHNuYXBzaG90cyBpcyB0b28gbGFyZ2UsIGJhaWwu IE9ubHkgZW5hYmxlZAorICAgICAgICBpZiB0aGUgYFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhQZXJj ZW50RGlmZmVyZW5jZWAgc2V0dGluZyBpcyBncmVhdGVyIHRoYW4gMC4KKworICAgICAgICAqIHBh Z2UvUGFnZS5oOgorICAgICAgICAqIHBhZ2UvUGFnZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQ YWdlOjpzYW1wbGVkUGFnZVRvcENvbG9yIGNvbnN0KTogQWRkZWQuCisgICAgICAgICogcGFnZS9D aHJvbWVDbGllbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OkNocm9tZUNsaWVudDo6ZGlkU2FtcGxl UGFnZVRvcENvbG9yIGNvbnN0KTogQWRkZWQuCisgICAgICAgIFBhc3MgYWxvbmcgdGhlIGBzYW1w bGVkUGFnZVRvcENvbG9yYCB0byB0aGUgVUlQcm9jZXNzIGFmdGVyIGl0J3MgZGV0ZXJtaW5lZCBv ciBpZiB0aGUgYWJvdmUKKyAgICAgICAgbG9naWMgYmFpbHMgKHNvIHRoYXQgdGhlIGBXS1dlYlZp ZXdgIGNhbiBhZGp1c3QgYF9zYW1wbGVkUGFnZVRvcENvbG9yYCB0byBgbmlsYCkuCisKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlckxheWVyQ29tcG9zaXRvcjo6cm9vdEJhY2tncm91bmRDb2xvck9yVHJhbnNwYXJl bmN5Q2hhbmdlZCk6CisgICAgICAgIFVzZSB0aGUgYHNhbXBsZWRQYWdlVG9wQ29sb3JgIGlmIHRo ZSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3JgCisg ICAgICAgIGludGVybmFsIHByZWZlcmVuY2UgaXMgZW5hYmxlZCBpbnN0ZWFkIG9mIHRoZSBDU1Mg YGJhY2tncm91bmQtY29sb3JgIG9mIHRoZSBgPGh0bWw+YC9gPGJvZHk+YC4KKwogMjAyMS0wNC0y NiAgRnVqaWkgSGlyb25vcmkgIDxIaXJvbm9yaS5GdWppaUBzb255LmNvbT4KIAogICAgICAgICBS RUdSRVNTSU9OKHIyNzIzNzkpIFtXaW5dIFNvbWUgZW1vamlzIGFyZSBwYWludGVkIHdpdGggYSBi bGFuayBzcXVhcmUgb24gdGhlIHJpZ2h0IHNpZGUgb2YgaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3Bw CmluZGV4IDJhZTNjM2RlYjkxMC4uNDgyMjI1YmYyY2FjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAKQEAgLTgyLDYgKzgyLDcgQEAKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1l TG9hZGVyLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlICJGcmFt ZVNuYXBzaG90dGluZy5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkZ1bGxz Y3JlZW5NYW5hZ2VyLmgiCiAjaW5jbHVkZSAiR0NSZWFjaGFibGVSZWYuaCIKQEAgLTEyMyw2ICsx MjQsNyBAQAogI2luY2x1ZGUgIklEQk9wZW5EQlJlcXVlc3QuaCIKICNpbmNsdWRlICJJZGxlQ2Fs bGJhY2tDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiSW1hZ2VCaXRtYXBSZW5kZXJpbmdDb250ZXh0 LmgiCisjaW5jbHVkZSAiSW1hZ2VCdWZmZXIuaCIKICNpbmNsdWRlICJJbWFnZUxvYWRlci5oIgog I2luY2x1ZGUgIkltYWdlT3ZlcmxheUNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JJ bnN0cnVtZW50YXRpb24uaCIKQEAgLTMyNzYsNiArMzI3OCw4IEBAIHZvaWQgRG9jdW1lbnQ6OmVu cXVldWVQYWludFRpbWluZ0VudHJ5SWZOZWVkZWQoKQogCiAgICAgZG9tV2luZG93KCktPnBlcmZv cm1hbmNlKCkucmVwb3J0Rmlyc3RDb250ZW50ZnVsUGFpbnQoKTsKICAgICBtX2RpZEVucXVldWVG aXJzdENvbnRlbnRmdWxQYWludCA9IHRydWU7CisKKyAgICBkZXRlcm1pbmVTYW1wbGVkUGFnZVRv cENvbG9yKCk7CiB9CiAKIEV4Y2VwdGlvbk9yPHZvaWQ+IERvY3VtZW50Ojp3cml0ZShEb2N1bWVu dCogcmVzcG9uc2libGVEb2N1bWVudCwgU2VnbWVudGVkU3RyaW5nJiYgdGV4dCkKQEAgLTM4Nzks NiArMzg4MywxNDAgQEAgdm9pZCBEb2N1bWVudDo6dGhlbWVDb2xvckNoYW5nZWQoKQogI2VuZGlm IC8vIEVOQUJMRShSVUJCRVJfQkFORElORykKIH0KIAorc3RhdGljIGRvdWJsZSBjb2xvckRpc3Rh bmNlKExhYjxmbG9hdD4mIGxocywgTGFiPGZsb2F0PiYgcmhzKQoreworICAgIHJldHVybiBzcXJ0 KHBvdyhyaHMubGlnaHRuZXNzIC0gbGhzLmxpZ2h0bmVzcywgMikgKyBwb3cocmhzLmEgLSBsaHMu YSwgMikgKyBwb3cocmhzLmIgLSBsaHMuYiwgMikpOworfQorCitzdGF0aWMgTGFiPGZsb2F0PiBh dmVyYWdlQ29sb3IoTGFiPGZsb2F0PiBjb2xvcnNbXSwgc2l6ZV90IGNvdW50KQoreworICAgIGZs b2F0IHRvdGFsTGlnaHRuZXNzID0gMDsKKyAgICBmbG9hdCB0b3RhbEEgPSAwOworICAgIGZsb2F0 IHRvdGFsQiA9IDA7CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7Cisg ICAgICAgIHRvdGFsTGlnaHRuZXNzICs9IGNvbG9yc1tpXS5saWdodG5lc3M7CisgICAgICAgIHRv dGFsQSArPSBjb2xvcnNbaV0uYTsKKyAgICAgICAgdG90YWxCICs9IGNvbG9yc1tpXS5iOworICAg IH0KKyAgICByZXR1cm4geworICAgICAgICB0b3RhbExpZ2h0bmVzcyAvIGNvdW50LAorICAgICAg ICB0b3RhbEEgLyBjb3VudCwKKyAgICAgICAgdG90YWxCIC8gY291bnQsCisgICAgICAgIDEsCisg ICAgfTsKK30KKwordm9pZCBEb2N1bWVudDo6ZGV0ZXJtaW5lU2FtcGxlZFBhZ2VUb3BDb2xvcigp Cit7CisgICAgaWYgKG1fc2FtcGxlZFBhZ2VUb3BDb2xvci5pc1ZhbGlkKCkpCisgICAgICAgIHJl dHVybjsKKworICAgIGF1dG8gbWF4RGlmZmVyZW5jZSA9IHNldHRpbmdzKCkuc2FtcGxlZFBhZ2VU b3BDb2xvck1heERpZmZlcmVuY2UoKTsKKyAgICBpZiAobWF4RGlmZmVyZW5jZSA8PSAwKQorICAg ICAgICByZXR1cm47CisKKyAgICBpZiAoIWlzVG9wRG9jdW1lbnQoKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgYXV0byogZnJhbWVWaWV3ID0gdmlldygpOworICAgIGlmICghZnJhbWVWaWV3KQor ICAgICAgICByZXR1cm47CisKKyAgICBhdXRvIG5vdGlmeURpZFNhbXBsZVBhZ2VUb3BDb2xvck9u U2NvcGVFeGl0ID0gbWFrZVNjb3BlRXhpdChbJl0geworICAgICAgICBpZiAoYXV0byogcGFnZSA9 IHRoaXMtPnBhZ2UoKSkKKyAgICAgICAgICAgIHBhZ2UtPmNocm9tZSgpLmNsaWVudCgpLmRpZFNh bXBsZVBhZ2VUb3BDb2xvcigpOworICAgIH0pOworCisgICAgLy8gRklYTUU6IDxodHRwczovL3dl YmtpdC5vcmcvYi8yMjUxNjc+IChTYW1wbGVkIFBhZ2UgVG9wIENvbG9yOiBob29rIGludG8gcGFp bnRpbmcgbG9naWMgaW5zdGVhZCBvZiB0YWtpbmcgc25hcHNob3RzKQorICAgIGF1dG8gcGl4ZWxD b2xvckF0VG9wWCA9IFsmXSAoaW50IHgpIC0+IE9wdGlvbmFsPExhYjxmbG9hdD4+IHsKKyAgICAg ICAgSW50UG9pbnQgbG9jYXRpb24oeCwgMCk7CisgICAgICAgIEludFNpemUgc2l6ZSgxLCAxKTsK KworICAgICAgICBpZiAoaXNIaXRUZXN0TG9jYXRpb25UaGlyZFBhcnR5RnJhbWUoTGF5b3V0UG9p bnQobG9jYXRpb24pKSkKKyAgICAgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAg ICAgYXV0byBzbmFwc2hvdCA9IHNuYXBzaG90RnJhbWVSZWN0KGZyYW1lVmlldy0+ZnJhbWUoKSwg SW50UmVjdChsb2NhdGlvbiwgc2l6ZSksIFNuYXBzaG90T3B0aW9uc0V4Y2x1ZGVTZWxlY3Rpb25I aWdobGlnaHRpbmcgfCBTbmFwc2hvdE9wdGlvbnNQYWludEV2ZXJ5dGhpbmdFeGNsdWRpbmdTZWxl Y3Rpb24pOworICAgICAgICBpZiAoIXNuYXBzaG90KQorICAgICAgICAgICAgcmV0dXJuIFdURjo6 bnVsbG9wdDsKKworICAgICAgICBhdXRvIHNuYXBzaG90RGF0YSA9IHNuYXBzaG90LT50b0JHUkFE YXRhKCk7CisgICAgICAgIHJldHVybiBjb252ZXJ0Q29sb3I8TGFiPGZsb2F0Pj4oU1JHQkE8dWlu dDhfdD4geyBzbmFwc2hvdERhdGFbMl0sIHNuYXBzaG90RGF0YVsxXSwgc25hcHNob3REYXRhWzBd LCBzbmFwc2hvdERhdGFbM10gfSk7CisgICAgfTsKKworICAgIC8vIERlY3JlYXNlIHRoZSB3aWR0 aCBieSBvbmUgcGl4ZWwgc28gdGhhdCB0aGUgbGFzdCBzbmFwc2hvdCBpcyB3aXRoaW4gYm91bmRz IGFuZCBub3Qgb2ZmLWJ5LW9uZS4KKyAgICBhdXRvIGZyYW1lV2lkdGggPSBmcmFtZVZpZXctPmNv bnRlbnRzV2lkdGgoKSAtIDE7CisKKyAgICBjb25zdGV4cHIgYXV0byBudW1TbmFwc2hvdHMgPSA1 OworICAgIHNpemVfdCBub25NYXRjaGluZ0NvbG9ySW5kZXggPSBudW1TbmFwc2hvdHM7CisKKyAg ICBMYWI8ZmxvYXQ+IHNuYXBzaG90c1tudW1TbmFwc2hvdHNdOworICAgIGRvdWJsZSBkaWZmZXJl bmNlc1tudW1TbmFwc2hvdHMgLSAxXTsKKworICAgIGF1dG8gc2hvdWxkU3RvcEFmdGVyRmluZGlu Z05vbk1hdGNoaW5nQ29sb3IgPSBbJl0gKHNpemVfdCBpKSAtPiBib29sIHsKKyAgICAgICAgLy8g QmFpbCBpZiB0aGUgbm9uLW1hdGNoaW5nIGNvbG9yIGlzIG5vdCB0aGUgZmlyc3Qgb3IgbGFzdCBz bmFwc2hvdCwgb3IgdGhlcmUgYWxyZWFkeSBpcyBhbiBub24tbWF0Y2hpbmcgY29sb3IuCisgICAg ICAgIGlmICgoaSAmJiBpIDwgbnVtU25hcHNob3RzIC0gMSkgfHwgbm9uTWF0Y2hpbmdDb2xvcklu ZGV4ICE9IG51bVNuYXBzaG90cykKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAgICAg IG5vbk1hdGNoaW5nQ29sb3JJbmRleCA9IGk7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9 OworCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBudW1TbmFwc2hvdHM7ICsraSkgeworICAg ICAgICBhdXRvIHNuYXBzaG90ID0gcGl4ZWxDb2xvckF0VG9wWChmcmFtZVdpZHRoICogaSAvIChu dW1TbmFwc2hvdHMgLSAxKSk7CisgICAgICAgIGlmICghc25hcHNob3QgJiYgIXNob3VsZFN0b3BB ZnRlckZpbmRpbmdOb25NYXRjaGluZ0NvbG9yKGkpKQorICAgICAgICAgICAgcmV0dXJuOworCisg ICAgICAgIHNuYXBzaG90c1tpXSA9ICpzbmFwc2hvdDsKKworICAgICAgICBpZiAoaSkgeworICAg ICAgICAgICAgLy8gRWFjaCBgZGlmZmVyZW5jZWAgaXRlbSBjb21wYXJlcyBgaWAgd2l0aCBgaSAt IDFgIHNvIGlmIHRoZSBmaXJzdCBjb21wYXJpc29uIChgaSA9PSAxYCkKKyAgICAgICAgICAgIC8v IGlzIHRvbyBsYXJnZSBvZiBhIGRpZmZlcmVuY2UsIHdlIHNob3VsZCB0cmVhdCBgaSAtIDFgIChp LmUuIGAwYCkgYXMgdGhlIHByb2JsZW0gc2luY2UKKyAgICAgICAgICAgIC8vIHdlIG9ubHkgYWxs b3cgZm9yIG5vbi1tYXRjaGluZyBjb2xvcnMgYmVpbmcgdGhlIGZpcnN0IG9yIGxhc3Qgc2FtcGxl ZCBjb2xvci4KKyAgICAgICAgICAgIGF1dG8gZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4 ID0gaSA9PSAxID8gMCA6IGk7CisKKyAgICAgICAgICAgIGRpZmZlcmVuY2VzW2kgLSAxXSA9IGNv bG9yRGlzdGFuY2Uoc25hcHNob3RzW2kgLSAxXSwgc25hcHNob3RzW2ldKTsKKyAgICAgICAgICAg IGlmIChkaWZmZXJlbmNlc1tpIC0gMV0gPiBtYXhEaWZmZXJlbmNlKSB7CisgICAgICAgICAgICAg ICAgaWYgKHNob3VsZFN0b3BBZnRlckZpbmRpbmdOb25NYXRjaGluZ0NvbG9yKGVmZmVjdGl2ZU5v bk1hdGNoaW5nQ29sb3JJbmRleCkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAg ICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgZG91Ymxl IGN1bXVsdWF0aXZlRGlmZmVyZW5jZSA9IDA7CisgICAgICAgICAgICBmb3IgKHNpemVfdCBqID0g MDsgaiA8IGk7ICsraikgeworICAgICAgICAgICAgICAgIGlmIChqID09IG5vbk1hdGNoaW5nQ29s b3JJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAg Y3VtdWx1YXRpdmVEaWZmZXJlbmNlICs9IGRpZmZlcmVuY2VzW2pdOworICAgICAgICAgICAgfQor ICAgICAgICAgICAgaWYgKGN1bXVsdWF0aXZlRGlmZmVyZW5jZSA+IG1heERpZmZlcmVuY2UpIHsK KyAgICAgICAgICAgICAgICBpZiAoc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNoaW5nQ29s b3IoZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4KSkgeworICAgICAgICAgICAgICAgICAg ICAvLyBJZiB3ZSBoYXZlbid0IGFscmVhZHkgaWRlbnRpZmllZCBhIG5vbi1tYXRjaGluZyBzbmFw c2hvdCBhbmQgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgZmlyc3QKKyAgICAgICAgICAgICAg ICAgICAgLy8gYW5kIHNlY29uZCBzbmFwc2hvdHMgb3IgdGhlIHNlY29uZC10by1sYXN0IGFuZCBs YXN0IHNuYXBzaG90cyBpcyBsZXNzIHRoYW4gdGhlIG1heGltdW0sIG1hcmsKKyAgICAgICAgICAg ICAgICAgICAgLy8gdGhlIGZpcnN0L2xhc3Qgc25hcHNob3QgYXMgbm9uLW1hdGNoaW5nIHRvIGdp dmUgYSBjaGFuY2UgZm9yIHRoZSByZXN0IG9mIHRoZSBzbmFwc2hvdHMgdG8gbWF0Y2guCisgICAg ICAgICAgICAgICAgICAgIGlmIChub25NYXRjaGluZ0NvbG9ySW5kZXggPT0gbnVtU25hcHNob3Rz ICYmICghaSB8fCBpID09IG51bVNuYXBzaG90cyAtIDEpICYmIGN1bXVsdWF0aXZlRGlmZmVyZW5j ZSAtIGRpZmZlcmVuY2VzW2kgLSAxXSA8PSBtYXhEaWZmZXJlbmNlKSB7CisgICAgICAgICAgICAg ICAgICAgICAgICBub25NYXRjaGluZ0NvbG9ySW5kZXggPSBlZmZlY3RpdmVOb25NYXRjaGluZ0Nv bG9ySW5kZXg7CisgICAgICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAgICAgICB9Cisg ICAgfQorCisgICAgYXV0byBzbmFwc2hvdHNUb0F2ZXJhZ2UgPSBzbmFwc2hvdHM7CisgICAgYXV0 byB2YWxpZFNuYXBzaG90Q291bnQgPSBudW1TbmFwc2hvdHM7CisgICAgaWYgKCFub25NYXRjaGlu Z0NvbG9ySW5kZXgpIHsKKyAgICAgICAgLy8gU2tpcCB0aGUgZmlyc3Qgc25hcHNob3QgYnkgbW92 aW5nIHRoZSBwb2ludGVyIHRoYXQgaW5kaWNhdGVzIHdoZXJlIHRoZSBzbmFwc2hvdCBhcnJheQor ICAgICAgICAvLyBzdGFydHMgYW5kIGRlY3JlYXNpbmcgdGhlIGNvdW50IG9mIHNuYXBzaG90cyB0 byBhdmVyYWdlLgorICAgICAgICArK3NuYXBzaG90c1RvQXZlcmFnZTsKKyAgICAgICAgLS12YWxp ZFNuYXBzaG90Q291bnQ7CisgICAgfSBlbHNlIGlmIChub25NYXRjaGluZ0NvbG9ySW5kZXggPT0g bnVtU25hcHNob3RzIC0gMSkgeworICAgICAgICAvLyBTa2lwIHRoZSBsYXN0IHNuYXBzaG90IGJ5 IGRlY3JlYXNpbmcgdGhlIGNvdW50IG9mIHNuYXBzaG90cyB0byBhdmVyYWdlLgorICAgICAgICAt LXZhbGlkU25hcHNob3RDb3VudDsKKyAgICB9CisgICAgbV9zYW1wbGVkUGFnZVRvcENvbG9yID0g YXZlcmFnZUNvbG9yKHNuYXBzaG90c1RvQXZlcmFnZSwgdmFsaWRTbmFwc2hvdENvdW50KTsKK30K KwogI2lmIEVOQUJMRShEQVJLX01PREVfQ1NTKQogc3RhdGljIHZvaWQgcHJvY2Vzc0NvbG9yU2No ZW1lU3RyaW5nKFN0cmluZ1ZpZXcgY29sb3JTY2hlbWUsIGNvbnN0IFdURjo6RnVuY3Rpb248dm9p ZChTdHJpbmdWaWV3IGtleSk+JiBjYWxsYmFjaykKIHsKQEAgLTg2MDgsNiArODc0NiwyMiBAQCBi b29sIERvY3VtZW50OjpoaXRUZXN0KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiByZXF1ZXN0LCBjb25z dCBIaXRUZXN0TG9jYXRpb24mIGxvYwogICAgIHJldHVybiByZXN1bHRMYXllcjsKIH0KIAorYm9v bCBEb2N1bWVudDo6aXNIaXRUZXN0TG9jYXRpb25UaGlyZFBhcnR5RnJhbWUoY29uc3QgSGl0VGVz dExvY2F0aW9uJiBsb2NhdGlvbikKK3sKKyAgICBjb25zdGV4cHIgT3B0aW9uU2V0PEhpdFRlc3RS ZXF1ZXN0OjpSZXF1ZXN0VHlwZT4gaGl0VGVzdFJlcXVlc3RUeXBlcyB7IEhpdFRlc3RSZXF1ZXN0 OjpSZWFkT25seSwgSGl0VGVzdFJlcXVlc3Q6OkRpc2FsbG93VXNlckFnZW50U2hhZG93Q29udGVu dCB9OworICAgIEhpdFRlc3RSZXN1bHQgaGl0VGVzdFJlc3VsdChsb2NhdGlvbik7CisgICAgaGl0 VGVzdChoaXRUZXN0UmVxdWVzdFR5cGVzLCBoaXRUZXN0UmVzdWx0KTsKKworICAgIGF1dG8gaGl0 VGVzdE5vZGUgPSBtYWtlUmVmUHRyKGhpdFRlc3RSZXN1bHQuaW5uZXJOb2RlKCkpOworICAgIGlm ICghaGl0VGVzdE5vZGUpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICghaXM8SFRN TElGcmFtZUVsZW1lbnQ+KGhpdFRlc3ROb2RlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgcmV0dXJuIGFyZVJlZ2lzdHJhYmxlRG9tYWluc0VxdWFsKGRvd25jYXN0PEhUTUxJRnJhbWVF bGVtZW50PigqaGl0VGVzdE5vZGUpLmxvY2F0aW9uKCksIG1fdXJsKTsKK30KKwogRWxlbWVudElk ZW50aWZpZXIgRG9jdW1lbnQ6OmlkZW50aWZpZXJGb3JFbGVtZW50KEVsZW1lbnQmIGVsZW1lbnQp CiB7CiAgICAgQVNTRVJUKCZlbGVtZW50LmRvY3VtZW50KCkgPT0gdGhpcyk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5oCmluZGV4IDA4ZjBhMDU2ZDE4NS4uMjI3NWNjNWZkZTE0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuaApAQCAtNzQzLDYgKzc0Myw4IEBAIHB1YmxpYzoKIAogICAgIGNvbnN0IENvbG9yJiB0aGVt ZUNvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9tZXRhRWxlbWVudFRoZW1lQ29sb3IuaXNWYWxpZCgp ID8gbV9tZXRhRWxlbWVudFRoZW1lQ29sb3IgOiBtX2FwcGxpY2F0aW9uTWFuaWZlc3RUaGVtZUNv bG9yOyB9CiAKKyAgICBjb25zdCBDb2xvciYgc2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNvbnN0IHsg cmV0dXJuIG1fc2FtcGxlZFBhZ2VUb3BDb2xvcjsgfQorCiAgICAgdm9pZCBzZXRUZXh0Q29sb3Io Y29uc3QgQ29sb3ImIGNvbG9yKSB7IG1fdGV4dENvbG9yID0gY29sb3I7IH0KICAgICBjb25zdCBD b2xvciYgdGV4dENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0Q29sb3I7IH0KIApAQCAtMTU2 Niw2ICsxNTY4LDcgQEAgcHVibGljOgogCiAgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBoaXRUZXN0 KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiwgSGl0VGVzdFJlc3VsdCYpOwogICAgIGJvb2wgaGl0VGVz dChjb25zdCBIaXRUZXN0UmVxdWVzdCYsIGNvbnN0IEhpdFRlc3RMb2NhdGlvbiYsIEhpdFRlc3RS ZXN1bHQmKTsKKyAgICBib29sIGlzSGl0VGVzdExvY2F0aW9uVGhpcmRQYXJ0eUZyYW1lKGNvbnN0 IEhpdFRlc3RMb2NhdGlvbiYpOwogI2lmIEFTU0VSVF9FTkFCTEVECiAgICAgYm9vbCBpbkhpdFRl c3RpbmcoKSBjb25zdCB7IHJldHVybiBtX2luSGl0VGVzdGluZzsgfQogI2VuZGlmCkBAIC0xNjc3 LDYgKzE2ODAsOCBAQCBwcml2YXRlOgogCiAgICAgdm9pZCB0aGVtZUNvbG9yQ2hhbmdlZCgpOwog CisgICAgdm9pZCBkZXRlcm1pbmVTYW1wbGVkUGFnZVRvcENvbG9yKCk7CisKICAgICB2b2lkIGlu dmFsaWRhdGVBY2Nlc3NLZXlDYWNoZVNsb3dDYXNlKCk7CiAgICAgdm9pZCBidWlsZEFjY2Vzc0tl eUNhY2hlKCk7CiAKQEAgLTE4MDAsNiArMTgwNSw4IEBAIHByaXZhdGU6CiAgICAgQ29sb3IgbV9t ZXRhRWxlbWVudFRoZW1lQ29sb3I7CiAgICAgQ29sb3IgbV9hcHBsaWNhdGlvbk1hbmlmZXN0VGhl bWVDb2xvcjsKIAorICAgIENvbG9yIG1fc2FtcGxlZFBhZ2VUb3BDb2xvcjsKKwogICAgIENvbG9y IG1fdGV4dENvbG9yIHsgQ29sb3I6OmJsYWNrIH07CiAgICAgQ29sb3IgbV9saW5rQ29sb3I7CiAg ICAgQ29sb3IgbV92aXNpdGVkTGlua0NvbG9yOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9DaHJvbWVDbGllbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2hyb21lQ2xpZW50LmgK aW5kZXggY2YxNmFlNmVhNDc1Li5lZDhjZjQwMzIxMGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BhZ2UvQ2hyb21lQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9DaHJvbWVD bGllbnQuaApAQCAtMjMzLDYgKzIzMyw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCB0 aGVtZUNvbG9yQ2hhbmdlZCgpIGNvbnN0IHsgfQogICAgIHZpcnR1YWwgdm9pZCBwYWdlRXh0ZW5k ZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSBjb25zdCB7IH0KKyAgICB2aXJ0dWFsIHZvaWQg ZGlkU2FtcGxlUGFnZVRvcENvbG9yKCkgY29uc3QgeyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgZXhj ZWVkZWREYXRhYmFzZVF1b3RhKEZyYW1lJiwgY29uc3QgU3RyaW5nJiBkYXRhYmFzZU5hbWUsIERh dGFiYXNlRGV0YWlscykgPSAwOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bh Z2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcAppbmRleCA3OWJhYTgzYjQ5Nzcu LjMzYzM5NGFkNzk4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCkBAIC0yNTU0LDYgKzI1NTQsMTUgQEAg Q29sb3IgUGFnZTo6cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKCkgY29uc3QKICAgICByZXR1 cm4gcmVuZGVyVmlldy0+Y29tcG9zaXRvcigpLnJvb3RFeHRlbmRlZEJhY2tncm91bmRDb2xvcigp OwogfQogCitDb2xvciBQYWdlOjpzYW1wbGVkUGFnZVRvcENvbG9yKCkgY29uc3QKK3sKKyAgICBh dXRvKiBkb2N1bWVudCA9IG1haW5GcmFtZSgpLmRvY3VtZW50KCk7CisgICAgaWYgKCFkb2N1bWVu dCkKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAgIHJldHVybiBkb2N1bWVudC0+c2FtcGxlZFBh Z2VUb3BDb2xvcigpOworfQorCiAvLyBUaGVzZSBhcmUgbWFnaWNhbCBjb25zdGFudHMgdGhhdCBt aWdodCBiZSB0d2Vha2VkIG92ZXIgdGltZS4KIHN0YXRpYyBjb25zdCBkb3VibGUgZ01pbmltdW1Q YWludGVkQXJlYVJhdGlvID0gMC4xOwogc3RhdGljIGNvbnN0IGRvdWJsZSBnTWF4aW11bVVucGFp bnRlZEFyZWFSYXRpbyA9IDAuMDQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bh Z2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCmluZGV4IDZiNzZjYzExNThjMy4uM2Jm MDM4YTdlZDMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuaApAQCAtNjIxLDYgKzYyMSw3IEBAIHB1YmxpYzoKIAog ICAgIFdFQkNPUkVfRVhQT1JUIENvbG9yIHRoZW1lQ29sb3IoKSBjb25zdDsKICAgICBXRUJDT1JF X0VYUE9SVCBDb2xvciBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IoKSBjb25zdDsKKyAgICBX RUJDT1JFX0VYUE9SVCBDb2xvciBzYW1wbGVkUGFnZVRvcENvbG9yKCkgY29uc3Q7CiAKICAgICBi b29sIGlzQ291bnRpbmdSZWxldmFudFJlcGFpbnRlZE9iamVjdHMoKSBjb25zdDsKICAgICB2b2lk IHNldElzQ291bnRpbmdSZWxldmFudFJlcGFpbnRlZE9iamVjdHMoYm9vbCBpc0NvdW50aW5nKSB7 IG1faXNDb3VudGluZ1JlbGV2YW50UmVwYWludGVkT2JqZWN0cyA9IGlzQ291bnRpbmc7IH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMYXllckNvbXBvc2l0b3Iu Y3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyQ29tcG9zaXRvci5jcHAK aW5kZXggYjQyM2IxOTE3Zjc3Li5mODc3NDU3MmI0YjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllckNvbXBvc2l0b3IuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJMYXllckNvbXBvc2l0b3IuY3BwCkBAIC0zOTI2LDYgKzM5MjYs OCBAQCB2b2lkIFJlbmRlckxheWVyQ29tcG9zaXRvcjo6dXBkYXRlTGF5ZXJGb3JPdmVyaGFuZ0Fy ZWFzQmFja2dyb3VuZENvbG9yKCkKICAgICBDb2xvciBiYWNrZ3JvdW5kQ29sb3I7CiAgICAgaWYg KHBhZ2UoKS5zZXR0aW5ncygpLnVzZVRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENv bG9yKCkpCiAgICAgICAgIGJhY2tncm91bmRDb2xvciA9IHBhZ2UoKS50aGVtZUNvbG9yKCk7Cisg ICAgaWYgKHBhZ2UoKS5zZXR0aW5ncygpLnVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxB cmVhQmFja2dyb3VuZENvbG9yKCkgJiYgIWJhY2tncm91bmRDb2xvci5pc1ZhbGlkKCkpCisgICAg ICAgIGJhY2tncm91bmRDb2xvciA9IHBhZ2UoKS5zYW1wbGVkUGFnZVRvcENvbG9yKCk7CiAgICAg aWYgKCFiYWNrZ3JvdW5kQ29sb3IuaXNWYWxpZCgpKQogICAgICAgICBiYWNrZ3JvdW5kQ29sb3Ig PSBtX3Jvb3RFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCA5MWVkOWNmNTRj M2UuLmRjNDRkOTA1NGY3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MCBAQAorMjAyMS0wNC0yOCAg RGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+CisKKyAgICAgICAgZXhwZXJpbWVudCB3 aXRoIGF2ZXJhZ2luZyBzYW1wbGluZyBjb2xvcnMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2Ug YXMgdGhlIHNjcm9sbCBhcmVhIGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNDk4NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNzYy NTE4ODk+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgKiBX ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNsaWVudC5oOgorICAgICAgICAqIFdl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcDoKKyAgICAgICAgKFdl YktpdDo6V2ViQ2hyb21lQ2xpZW50OjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IgY29uc3QpOiBBZGRl ZC4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oOgorICAgICAgICAqIFdl YlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6 ZGlkU2FtcGxlUGFnZVRvcENvbG9yKTogQWRkZWQuCisgICAgICAgIFBhc3MgYWxvbmcgdGhlIGBz YW1wbGVkUGFnZVRvcENvbG9yYCB0byB0aGUgVUlQcm9jZXNzLgorCisgICAgICAgICogVUlQcm9j ZXNzL1dlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbjoKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFn ZVByb3h5Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6c2FtcGxlZFBhZ2VUb3BD b2xvcik6IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgY29u c3QpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmRpZFNhbXBsZVBhZ2VUb3BDb2xv cik6IEFkZGVkLgorICAgICAgICBVc2UgdGhlIGBzYW1wbGVkUGFnZVRvcENvbG9yYCBpZiB0aGUg YFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yYAorICAg ICAgICBpbnRlcm5hbCBwcmVmZXJlbmNlIGlzIGVuYWJsZWQgaW5zdGVhZCBvZiB0aGUgQ1NTIGBi YWNrZ3JvdW5kLWNvbG9yYCBvZiB0aGUgYDxodG1sPmAvYDxib2R5PmAuCisKKyAgICAgICAgKiBV SVByb2Nlc3MvUGFnZUNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50OjpzYW1w bGVkUGFnZVRvcENvbG9yV2lsbENoYW5nZSk6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpQYWdl Q2xpZW50OjpzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKTogQWRkZWQuCisgICAgICAgICog VUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EuaDoKKyAgICAgICAgKiBVSVByb2Nl c3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5tbToKKyAgICAgICAgKFdlYktpdDo6UGFnZUNs aWVudEltcGxDb2NvYTo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UpOiBBZGRlZC4KKyAg ICAgICAgKFdlYktpdDo6UGFnZUNsaWVudEltcGxDb2NvYTo6c2FtcGxlZFBhZ2VUb3BDb2xvckRp ZENoYW5nZSk6IEFkZGVkLgorICAgICAgICBBZGQgT2JqQyBLVk8gc3VwcG9ydCBmb3IgYC1bV0tX ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXWAuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29h L1dLV2ViVmlldy5tbToKKyAgICAgICAgKC1bV0tXZWJWaWV3IF9zZXR1cFBhZ2VDb25maWd1cmF0 aW9uOl0pOgorICAgICAgICAoLVtXS1dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTogQWRk ZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9u UHJpdmF0ZS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Q29uZmln dXJhdGlvbi5tbToKKyAgICAgICAgKC1bV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBpbml0XSk6Cisg ICAgICAgICgtW1dLV2ViVmlld0NvbmZpZ3VyYXRpb24gY29weVdpdGhab25lOl0pOgorICAgICAg ICAoLVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIF9zZXRTYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVy Y2VudERpZmZlcmVuY2U6XSk6IEFkZGVkLgorICAgICAgICAoLVtXS1dlYlZpZXdDb25maWd1cmF0 aW9uIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4UGVyY2VudERpZmZlcmVuY2VdKTogQWRkZWQuCisg ICAgICAgIFByb3ZpZGUgU1BJIHRvIGNvbmZpZ3VyZSB0aGUgYFNhbXBsZWRQYWdlVG9wQ29sb3JN YXhQZXJjZW50RGlmZmVyZW5jZWAgcHJlZmVyZW5jZSB3aGVuCisgICAgICAgIGNyZWF0aW5nIHRo ZSBgV0tXZWJWaWV3YC4gRXhwb3NlIHRoZSByZXN1bHQgYXMgYF9zYW1wbGVkUGFnZVRvcENvbG9y YCBTUEkuCisKIDIwMjEtMDQtMjYgIEFkaXR5YSBLZWVydGhpICA8YWtlZXJ0aGlAYXBwbGUuY29t PgogCiAgICAgICAgIFJFR1JFU1NJT04gKHIyNzE4NjEpOiBbaU9TXSBBY2Nlc3NvcnkgYmFyIG5h dmlnYXRpb24gdG8gZWxlbWVudHMgb3V0c2lkZSB0aGUgdmlld3BvcnQgZmFpbHMKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW0gYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Lm1tCmluZGV4IDEzMzc5M2Y0 MTI5MS4uNTRjODVlZDU0YTZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvQ29jb2EvV0tXZWJWaWV3Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9D b2NvYS9XS1dlYlZpZXcubW0KQEAgLTU1OSw2ICs1NTksOCBAQCAtICh2b2lkKV9zZXR1cFBhZ2VD b25maWd1cmF0aW9uOihSZWY8QVBJOjpQYWdlQ29uZmlndXJhdGlvbj4mKXBhZ2VDb25maWd1cmF0 aW9uCiAgICAgcGFnZUNvbmZpZ3VyYXRpb24tPnByZWZlcmVuY2VzKCktPnNldFNlcnZpY2VXb3Jr ZXJFbnRpdGxlbWVudERpc2FibGVkRm9yVGVzdGluZyghIVtfY29uZmlndXJhdGlvbiBwcmVmZXJl bmNlc10uX3NlcnZpY2VXb3JrZXJFbnRpdGxlbWVudERpc2FibGVkRm9yVGVzdGluZyk7CiAjZW5k aWYKIAorICAgIHBhZ2VDb25maWd1cmF0aW9uLT5wcmVmZXJlbmNlcygpLT5zZXRTYW1wbGVkUGFn ZVRvcENvbG9yTWF4RGlmZmVyZW5jZShbX2NvbmZpZ3VyYXRpb24gX3NhbXBsZWRQYWdlVG9wQ29s b3JNYXhEaWZmZXJlbmNlXSk7CisKICAgICBpZiAoIWxpbmtlZE9uT3JBZnRlcihXZWJDb3JlOjpT REtWZXJzaW9uOjpGaXJzdFdoZXJlU2l0ZVNwZWNpZmljUXVpcmtzQXJlRW5hYmxlZEJ5RGVmYXVs dCkpCiAgICAgICAgIHBhZ2VDb25maWd1cmF0aW9uLT5wcmVmZXJlbmNlcygpLT5zZXROZWVkc1Np dGVTcGVjaWZpY1F1aXJrcyhmYWxzZSk7CiB9CkBAIC0zMDMwLDYgKzMwMzIsMTQgQEAgLSAoQ29j b2FDb2xvciAqKV9wYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IKICAgICByZXR1cm4gV2ViQ29y ZTo6cGxhdGZvcm1Db2xvcihwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IpOwogfQogCistIChD b2NvYUNvbG9yICopX3NhbXBsZWRQYWdlVG9wQ29sb3IKK3sKKyAgICBhdXRvIHNhbXBsZWRQYWdl VG9wQ29sb3IgPSBfcGFnZS0+c2FtcGxlZFBhZ2VUb3BDb2xvcigpOworICAgIGlmICghc2FtcGxl ZFBhZ2VUb3BDb2xvci5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybiBuaWw7CisgICAgcmV0dXJu IFdlYkNvcmU6OnBsYXRmb3JtQ29sb3Ioc2FtcGxlZFBhZ2VUb3BDb2xvcik7Cit9CisKIC0gKGlk IDxfV0tJbnB1dERlbGVnYXRlPilfaW5wdXREZWxlZ2F0ZQogewogICAgIHJldHVybiBfaW5wdXRE ZWxlZ2F0ZS5nZXRBdXRvcmVsZWFzZWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld0NvbmZpZ3VyYXRpb24ubW0KaW5kZXggYzUw MDliNjg4NmYzLi4xZWU5MzI1ZmVkOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tCkBAIC0xNzcs NiArMTc3LDcgQEAgQGltcGxlbWVudGF0aW9uIFdLV2ViVmlld0NvbmZpZ3VyYXRpb24gewogI2lm IEVOQUJMRShBUFBfSElHSExJR0hUUykKICAgICBCT09MIF9hcHBIaWdobGlnaHRzRW5hYmxlZDsK ICNlbmRpZgorICAgIGRvdWJsZSBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2U7CiAK ICAgICBSZXRhaW5QdHI8TlNTdHJpbmc+IF9tZWRpYUNvbnRlbnRUeXBlc1JlcXVpcmluZ0hhcmR3 YXJlU3VwcG9ydDsKICAgICBSZXRhaW5QdHI8TlNBcnJheTxOU1N0cmluZyAqPj4gX2FkZGl0aW9u YWxTdXBwb3J0ZWRJbWFnZVR5cGVzOwpAQCAtMjc1LDYgKzI3Niw5IEBAIC0gKGluc3RhbmNldHlw ZSlpbml0CiAjaWYgRU5BQkxFKEFQUF9ISUdITElHSFRTKQogICAgIF9hcHBIaWdobGlnaHRzRW5h YmxlZCA9IERFRkFVTFRfVkFMVUVfRk9SX0FwcEhpZ2hsaWdodHNFbmFibGVkOwogI2VuZGlmCisK KyAgICBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UgPSBERUZBVUxUX1ZBTFVFX0ZP Ul9TYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZTsKKwogICAgIHJldHVybiBzZWxmOwog fQogCkBAIC00NTMsNiArNDU3LDggQEAgLSAoaWQpY29weVdpdGhab25lOihOU1pvbmUgKil6b25l CiAgICAgY29uZmlndXJhdGlvbi0+X2FwcEhpZ2hsaWdodHNFbmFibGVkID0gc2VsZi0+X2FwcEhp Z2hsaWdodHNFbmFibGVkOwogI2VuZGlmCiAKKyAgICBjb25maWd1cmF0aW9uLT5fc2FtcGxlZFBh Z2VUb3BDb2xvck1heERpZmZlcmVuY2UgPSBzZWxmLT5fc2FtcGxlZFBhZ2VUb3BDb2xvck1heERp ZmZlcmVuY2U7CisKICAgICByZXR1cm4gY29uZmlndXJhdGlvbjsKIH0KIApAQCAtMTI3Myw2ICsx Mjc5LDE2IEBAIC0gKHZvaWQpX3NldFByb2Nlc3NEaXNwbGF5TmFtZTooTlNTdHJpbmcgKilsc0Rp c3BsYXlOYW1lCiAgICAgX3BhZ2VDb25maWd1cmF0aW9uLT5zZXRQcm9jZXNzRGlzcGxheU5hbWUo bHNEaXNwbGF5TmFtZSk7CiB9CiAKKy0gKHZvaWQpX3NldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhE aWZmZXJlbmNlOihkb3VibGUpdmFsdWUKK3sKKyAgICBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERp ZmZlcmVuY2UgPSB2YWx1ZTsKK30KKworLSAoZG91YmxlKV9zYW1wbGVkUGFnZVRvcENvbG9yTWF4 RGlmZmVyZW5jZQoreworICAgIHJldHVybiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVu Y2U7Cit9CisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdLV2ViVmlld0NvbmZpZ3VyYXRpb24g KFdLRGVwcmVjYXRlZCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9D b2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld0NvbmZpZ3VyYXRpb25Qcml2YXRlLmgKaW5kZXggZWY0 ZDRlMjBjMTRkLi4zMzIwNjEzYWExNjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCisrKyBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0 ZS5oCkBAIC0xMjMsNiArMTIzLDEwIEBAIHR5cGVkZWYgTlNfRU5VTShOU1VJbnRlZ2VyLCBfV0tE cmFnTGlmdERlbGF5KSB7CiAKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCBzZXR0ZXI9X3NldEFwcEhp Z2hsaWdodHNFbmFibGVkOikgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQgV0tfQVBJX0FWQUlM QUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKIAorLy8gVGhlIG1heGlt dW0gTGFiIGNvbG9yIGRpc3RhbmNlIGFsbG93ZWQgYmV0d2VlbiB0d28gY29uc2VjdXRpdmUgcGFn ZSB0b3Agc25hcHNob3RzLgorLy8gRXhwZWN0cyAwIChkaXNhYmxlcyBwYWdlIHRvcCBjb2xvciBz YW1wbGluZyBlbnRpcmVseSkgb3IgYW55IHBvc2l0aXZlIG51bWJlci4KK0Bwcm9wZXJ0eSAobm9u YXRvbWljLCBzZXR0ZXI9X3NldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlOikgZG91 YmxlIF9zYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZSBXS19BUElfQVZBSUxBQkxFKG1h Y29zKFdLX01BQ19UQkEpLCBpb3MoV0tfSU9TX1RCQSkpOworCiBAZW5kCiAKICNpZiBUQVJHRVRf T1NfSVBIT05FCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tXZWJWaWV3UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dL V2ViVmlld1ByaXZhdGUuaAppbmRleCA1NWQwMTlkZWFmYjIuLmI3NTliODdkNGFhMSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUu aAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3UHJpdmF0 ZS5oCkBAIC0zODQsNiArMzg0LDEzIEBAIGZvciB0aGlzIHByb3BlcnR5LgogQHByb3BlcnR5IChu b25hdG9taWMsIHJlYWRvbmx5KSBOU0NvbG9yICpfcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9y OwogI2VuZGlmCiAKKy8vIE9ubHkgc2V0IGlmIGAtW1dLV2ViVmlld0NvbmZpZ3VyYXRpb24gX3Nh bXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlXWAgaXMgYSBwb3NpdGl2ZSBudW1iZXIuCisj aWYgVEFSR0VUX09TX0lQSE9ORQorQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5KSBVSUNv bG9yICpfc2FtcGxlZFBhZ2VUb3BDb2xvciBXS19BUElfQVZBSUxBQkxFKGlvcyhXS19JT1NfVEJB KSk7CisjZWxzZQorQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5KSBOU0NvbG9yICpfc2Ft cGxlZFBhZ2VUb3BDb2xvciBXS19BUElfQVZBSUxBQkxFKG1hY29zKFdLX01BQ19UQkEpKTsKKyNl bmRpZgorCiAtICh2b2lkKV9ncmFudEFjY2Vzc1RvQXNzZXRTZXJ2aWNlcyBXS19BUElfQVZBSUxB QkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoMTQuMCkpOwogLSAodm9pZClfcmV2b2tlQWNjZXNz VG9Bc3NldFNlcnZpY2VzIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RCQSksIGlvcygx NC4wKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VD bGllbnRJbXBsQ29jb2EuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGll bnRJbXBsQ29jb2EuaAppbmRleCAzZWZjNjhhMTZiODUuLmM4OGEzZDQyMzM5MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCisr KyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EuaApA QCAtNTUsNiArNTUsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCB0aGVtZUNvbG9yRGlkQ2hhbmdlKCkg ZmluYWw7CiAgICAgdm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JXaWxsQ2hhbmdlKCkg ZmluYWw7CiAgICAgdm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSBm aW5hbDsKKyAgICB2b2lkIHNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hhbmdlKCkgZmluYWw7Cisg ICAgdm9pZCBzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCkgZmluYWw7CiAgICAgdm9pZCBp c1BsYXlpbmdBdWRpb1dpbGxDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIGlzUGxheWluZ0F1ZGlv RGlkQ2hhbmdlKCkgZmluYWw7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9D b2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLm1tCmluZGV4IDI0NjhkYWNhN2YyMC4uYmRmNDNjYjdl NjQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50 SW1wbENvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGll bnRJbXBsQ29jb2EubW0KQEAgLTY2LDYgKzY2LDE2IEBAIHZvaWQgUGFnZUNsaWVudEltcGxDb2Nv YTo6cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCkKICAgICBbbV93ZWJWaWV3 IGRpZENoYW5nZVZhbHVlRm9yS2V5OkAiX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvciJdOwog fQogCit2b2lkIFBhZ2VDbGllbnRJbXBsQ29jb2E6OnNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hh bmdlKCkKK3sKKyAgICBbbV93ZWJWaWV3IHdpbGxDaGFuZ2VWYWx1ZUZvcktleTpAIl9zYW1wbGVk UGFnZVRvcENvbG9yIl07Cit9CisKK3ZvaWQgUGFnZUNsaWVudEltcGxDb2NvYTo6c2FtcGxlZFBh Z2VUb3BDb2xvckRpZENoYW5nZSgpCit7CisgICAgW21fd2ViVmlldyBkaWRDaGFuZ2VWYWx1ZUZv cktleTpAIl9zYW1wbGVkUGFnZVRvcENvbG9yIl07Cit9CisKIHZvaWQgUGFnZUNsaWVudEltcGxD b2NvYTo6aXNQbGF5aW5nQXVkaW9XaWxsQ2hhbmdlKCkKIHsKICAgICBbbV93ZWJWaWV3IHdpbGxD aGFuZ2VWYWx1ZUZvcktleTpOU1N0cmluZ0Zyb21TZWxlY3RvcihAc2VsZWN0b3IoX2lzUGxheWlu Z0F1ZGlvKSldOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUGFnZUNsaWVu dC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCmluZGV4IDg2MDBiNzI5 NDdjZC4uOWE5MzNlY2VkMDIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Q YWdlQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCkBA IC01MDksNiArNTA5LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCB0aGVtZUNvbG9yRGlk Q2hhbmdlKCkgeyB9CiAgICAgdmlydHVhbCB2b2lkIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xv cldpbGxDaGFuZ2UoKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgcGFnZUV4dGVuZGVkQmFja2dyb3Vu ZENvbG9yRGlkQ2hhbmdlKCkgeyB9CisgICAgdmlydHVhbCB2b2lkIHNhbXBsZWRQYWdlVG9wQ29s b3JXaWxsQ2hhbmdlKCkgeyB9CisgICAgdmlydHVhbCB2b2lkIHNhbXBsZWRQYWdlVG9wQ29sb3JE aWRDaGFuZ2UoKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlQmFja2dyb3VuZENvbG9y KCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBpc1BsYXlpbmdBdWRpb1dpbGxDaGFuZ2UoKSA9IDA7 CiAgICAgdmlydHVhbCB2b2lkIGlzUGxheWluZ0F1ZGlvRGlkQ2hhbmdlKCkgPSAwOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggNGMxMzJmODE5MmE0Li41MTZj NzNkNTgxOGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAt MTkxNyw2ICsxOTE3LDkgQEAgQ29sb3IgV2ViUGFnZVByb3h5OjpzY3JvbGxBcmVhQmFja2dyb3Vu ZENvbG9yKCkgY29uc3QKICAgICBpZiAobV9wcmVmZXJlbmNlcy0+dXNlVGhlbWVDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IoKSAmJiBtX3RoZW1lQ29sb3IuaXNWYWxpZCgpKQogICAg ICAgICByZXR1cm4gbV90aGVtZUNvbG9yOwogCisgICAgaWYgKG1fcHJlZmVyZW5jZXMtPnVzZVNh bXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgJiYgbV9zYW1w bGVkUGFnZVRvcENvbG9yLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIG1fc2FtcGxlZFBhZ2VU b3BDb2xvcjsKKwogICAgIHJldHVybiBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKIH0K IApAQCAtODUyMiw2ICs4NTI1LDE2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpwYWdlRXh0ZW5kZWRC YWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoY29uc3QgQ29sb3ImIHBhZ2VFeHRlbmRlCiAgICAgcGFn ZUNsaWVudCgpLnBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpOwogfQogCit2 b2lkIFdlYlBhZ2VQcm94eTo6ZGlkU2FtcGxlUGFnZVRvcENvbG9yKGNvbnN0IENvbG9yJiBzYW1w bGVkUGFnZVRvcENvbG9yKQoreworICAgIGlmIChtX3NhbXBsZWRQYWdlVG9wQ29sb3IgPT0gc2Ft cGxlZFBhZ2VUb3BDb2xvcikKKyAgICAgICAgcmV0dXJuOworCisgICAgcGFnZUNsaWVudCgpLnNh bXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hhbmdlKCk7CisgICAgbV9zYW1wbGVkUGFnZVRvcENvbG9y ID0gc2FtcGxlZFBhZ2VUb3BDb2xvcjsKKyAgICBwYWdlQ2xpZW50KCkuc2FtcGxlZFBhZ2VUb3BD b2xvckRpZENoYW5nZSgpOworfQorCiAjaWYgRU5BQkxFKE5FVFNDQVBFX1BMVUdJTl9BUEkpCiB2 b2lkIFdlYlBhZ2VQcm94eTo6ZGlkRmFpbFRvSW5pdGlhbGl6ZVBsdWdpbihjb25zdCBTdHJpbmcm IG1pbWVUeXBlLCBjb25zdCBTdHJpbmcmIGZyYW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBh Z2VVUkxTdHJpbmcpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4 IDc1NmVhNTMxMGVmNS4uMGZiYTgyZTg3YWNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuaApAQCAtNjY1LDYgKzY2NSw4IEBAIHB1YmxpYzoKICAgICAvLyB0aGUgbWVzc2Fn ZSBlbnRpcmVseS4KICAgICBXZWJDb3JlOjpDb2xvciBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29s b3IoKSBjb25zdCB7IHJldHVybiBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsgfQogCisg ICAgV2ViQ29yZTo6Q29sb3Igc2FtcGxlZFBhZ2VUb3BDb2xvcigpIGNvbnN0IHsgcmV0dXJuIG1f c2FtcGxlZFBhZ2VUb3BDb2xvcjsgfQorCiAgICAgV2ViQ29yZTo6Q29sb3Igc2Nyb2xsQXJlYUJh Y2tncm91bmRDb2xvcigpIGNvbnN0OwogCiAgICAgdm9pZCB2aWV3V2lsbFN0YXJ0TGl2ZVJlc2l6 ZSgpOwpAQCAtMjA5Niw2ICsyMDk4LDcgQEAgcHJpdmF0ZToKICAgICB2b2lkIGRpZENoYW5nZVBh Z2VDb3VudCh1bnNpZ25lZCk7CiAgICAgdm9pZCB0aGVtZUNvbG9yQ2hhbmdlZChjb25zdCBXZWJD b3JlOjpDb2xvciYpOwogICAgIHZvaWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hh bmdlKGNvbnN0IFdlYkNvcmU6OkNvbG9yJik7CisgICAgdm9pZCBkaWRTYW1wbGVQYWdlVG9wQ29s b3IoY29uc3QgV2ViQ29yZTo6Q29sb3ImKTsKICNpZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQ SSkKICAgICB2b2lkIGRpZEZhaWxUb0luaXRpYWxpemVQbHVnaW4oY29uc3QgU3RyaW5nJiBtaW1l VHlwZSwgY29uc3QgU3RyaW5nJiBmcmFtZVVSTFN0cmluZywgY29uc3QgU3RyaW5nJiBwYWdlVVJM U3RyaW5nKTsKICAgICB2b2lkIGRpZEJsb2NrSW5zZWN1cmVQbHVnaW5WZXJzaW9uKGNvbnN0IFN0 cmluZyYgbWltZVR5cGUsIGNvbnN0IFN0cmluZyYgcGx1Z2luVVJMU3RyaW5nLCBjb25zdCBTdHJp bmcmIGZyYW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBhZ2VVUkxTdHJpbmcsIGJvb2wgcmVw bGFjZW1lbnRPYnNjdXJlZCk7CkBAIC0yNjQxLDYgKzI2NDQsNyBAQCBwcml2YXRlOgogICAgIFdl YkNvcmU6OkNvbG9yIG1fdGhlbWVDb2xvcjsKICAgICBXZWJDb3JlOjpDb2xvciBtX3VuZGVybGF5 Q29sb3I7CiAgICAgV2ViQ29yZTo6Q29sb3IgbV9wYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3I7 CisgICAgV2ViQ29yZTo6Q29sb3IgbV9zYW1wbGVkUGFnZVRvcENvbG9yOwogCiAgICAgYm9vbCBt X3VzZUZpeGVkTGF5b3V0IHsgZmFsc2UgfTsKICAgICBXZWJDb3JlOjpJbnRTaXplIG1fZml4ZWRM YXlvdXRTaXplOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5Lm1lc3NhZ2VzLmluIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1l c3NhZ2VzLmluCmluZGV4IDM2ZTFmNDVlNzk2MC4uYjFiNWE2ZjRlZDhkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluCkBAIC03OSw2ICs3 OSw3IEBAIG1lc3NhZ2VzIC0+IFdlYlBhZ2VQcm94eSB7CiAgICAgRGlkQ2hhbmdlUGFnZUNvdW50 KHVuc2lnbmVkIHBhZ2VDb3VudCkKICAgICBUaGVtZUNvbG9yQ2hhbmdlZChXZWJDb3JlOjpDb2xv ciB0aGVtZUNvbG9yKQogICAgIFBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZShX ZWJDb3JlOjpDb2xvciBiYWNrZ3JvdW5kQ29sb3IpCisgICAgRGlkU2FtcGxlUGFnZVRvcENvbG9y KFdlYkNvcmU6OkNvbG9yIHNhbXBsZWRQYWdlVG9wQ29sb3IpCiAjaWYgRU5BQkxFKE5FVFNDQVBF X1BMVUdJTl9BUEkpCiAgICAgRGlkRmFpbFRvSW5pdGlhbGl6ZVBsdWdpbihTdHJpbmcgbWltZVR5 cGUsIFN0cmluZyBmcmFtZVVSTFN0cmluZywgU3RyaW5nIHBhZ2VVUkxTdHJpbmcpCiAgICAgRGlk QmxvY2tJbnNlY3VyZVBsdWdpblZlcnNpb24oU3RyaW5nIG1pbWVUeXBlLCBTdHJpbmcgcGx1Z2lu VVJMU3RyaW5nLCBTdHJpbmcgZnJhbWVVUkxTdHJpbmcsIFN0cmluZyBwYWdlVVJMU3RyaW5nLCBi b29sIHJlcGxhY2VtZW50T2JzY3VyZWQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQuY3BwCmluZGV4IDNmNWI2 MDNjMmNjYy4uYTMxZWU3MjNkZWIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcApAQCAtMTE2NCw2 ICsxMTY0LDExIEBAIHZvaWQgV2ViQ2hyb21lQ2xpZW50OjpwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5k Q29sb3JEaWRDaGFuZ2UoKSBjb25zdAogICAgIG1fcGFnZS5wYWdlRXh0ZW5kZWRCYWNrZ3JvdW5k Q29sb3JEaWRDaGFuZ2UoKTsKIH0KIAordm9pZCBXZWJDaHJvbWVDbGllbnQ6OmRpZFNhbXBsZVBh Z2VUb3BDb2xvcigpIGNvbnN0Cit7CisgICAgbV9wYWdlLmRpZFNhbXBsZVBhZ2VUb3BDb2xvcigp OworfQorCiB2b2lkIFdlYkNocm9tZUNsaWVudDo6d2hlZWxFdmVudEhhbmRsZXJzQ2hhbmdlZChi b29sIGhhc0hhbmRsZXJzKQogewogICAgIG1fcGFnZS53aGVlbEV2ZW50SGFuZGxlcnNDaGFuZ2Vk KGhhc0hhbmRsZXJzKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJD b3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQuaAppbmRleCAxZTM2MGUzMGQzNGEuLmYwY2Fk NWM4ZWVjZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L1dlYkNocm9tZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJD b3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQuaApAQCAtMzMwLDYgKzMzMCw3IEBAIHByaXZhdGU6 CiAKICAgICB2b2lkIHRoZW1lQ29sb3JDaGFuZ2VkKCkgY29uc3QgZmluYWw7CiAgICAgdm9pZCBw YWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSBjb25zdCBmaW5hbDsKKyAgICB2 b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpIGNvbnN0IGZpbmFsOwogICAgIAogICAgIHZvaWQg d2hlZWxFdmVudEhhbmRsZXJzQ2hhbmdlZChib29sKSBmaW5hbDsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAgYi9Tb3VyY2UvV2ViS2l0 L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcAppbmRleCAwZjZmOTg1Y2M1YTkuLjNiNjNi MWI2ODU4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2Vi UGFnZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5j cHAKQEAgLTY0NTMsNiArNjQ1MywxMSBAQCB2b2lkIFdlYlBhZ2U6OmZsdXNoUGVuZGluZ1BhZ2VF eHRlbmRlZEJhY2tncm91bmRDb2xvckNoYW5nZSgpCiAgICAgc2VuZChNZXNzYWdlczo6V2ViUGFn ZVByb3h5OjpQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UobV9wYWdlLT5wYWdl RXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3IoKSkpOwogfQogCit2b2lkIFdlYlBhZ2U6OmRpZFNhbXBs ZVBhZ2VUb3BDb2xvcigpCit7CisgICAgc2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpEaWRT YW1wbGVQYWdlVG9wQ29sb3IobV9wYWdlLT5zYW1wbGVkUGFnZVRvcENvbG9yKCkpKTsKK30KKwog dm9pZCBXZWJQYWdlOjpmbHVzaFBlbmRpbmdFZGl0b3JTdGF0ZVVwZGF0ZSgpCiB7CiAgICAgaWYg KCFtX2hhc1BlbmRpbmdFZGl0b3JTdGF0ZVVwZGF0ZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2UuaAppbmRleCAyZDcyODJmOTU2MzguLmYyNTk2YjE4MzJhOCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCisrKyBi L1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaApAQCAtMTI0MCw2ICsx MjQwLDggQEAgcHVibGljOgogICAgIHZvaWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlk Q2hhbmdlKCkgeyBtX3BlbmRpbmdQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JDaGFuZ2UgPSB0 cnVlOyB9CiAgICAgdm9pZCBmbHVzaFBlbmRpbmdQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JD aGFuZ2UoKTsKIAorICAgIHZvaWQgZGlkU2FtcGxlUGFnZVRvcENvbG9yKCk7CisKICAgICB2b2lk IGZsdXNoUGVuZGluZ0VkaXRvclN0YXRlVXBkYXRlKCk7CiAKICNpZiBFTkFCTEUoUkVTT1VSQ0Vf TE9BRF9TVEFUSVNUSUNTKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hh bmdlTG9nCmluZGV4IGM5M2U0MGNhMWY1Yi4uNTRmNWI3ODc5N2U1IDEwMDY0NAotLS0gYS9Ub29s cy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMjEt MDQtMjggIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgorCisgICAgICAgIGV4cGVy aW1lbnQgd2l0aCBhdmVyYWdpbmcgc2FtcGxpbmcgY29sb3JzIGFjcm9zcyB0aGUgdG9wIG9mIHRo ZSBwYWdlIGFzIHRoZSBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ5ODcKKyAgICAgICAgPHJkYXI6Ly9wcm9i bGVtLzc2MjUxODg5PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgorCisgICAg ICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9TYW1wbGVkUGFnZVRvcENvbG9y Lm1tOiBBZGRlZC4KKyAgICAgICAgKC1bVGVzdEtWT1dyYXBwZXIgaW5pdFdpdGhPYnNlcnZhYmxl OmtleVBhdGg6Y2FsbGJhY2s6XSk6CisgICAgICAgICgtW1Rlc3RLVk9XcmFwcGVyIGRlYWxsb2Nd KToKKyAgICAgICAgKC1bVGVzdEtWT1dyYXBwZXIgb2JzZXJ2ZVZhbHVlRm9yS2V5UGF0aDpvZk9i amVjdDpjaGFuZ2U6Y29udGV4dDpdKToKKyAgICAgICAgKGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxl ZFBhZ2VUb3BDb2xvck1heFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKHdhaXRGb3JTYW1w bGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKToKKyAgICAgICAgKGNyZWF0ZUhUTUxHcmFk aWVudFdpdGhDb2xvclN0b3BzKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5a ZXJvTWF4UGVyY2VudERpZmZlcmVuY2UpOgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENv bG9yLk5lZ2F0aXZlTWF4UGVyY2VudERpZmZlcmVuY2UpOgorICAgICAgICAoVEVTVC5TYW1wbGVk UGFnZVRvcENvbG9yLlNvbGlkQ29sb3IpOgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENv bG9yLkRpZmZlcmVudENvbG9yc1dpdGhvdXRPdXRsaWVyQmVsb3dNYXhQZXJjZW50RGlmZmVyZW5j ZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0 aExlZnRPdXRsaWVyQWJvdmVNYXhQZXJjZW50RGlmZmVyZW5jZSk6CisgICAgICAgIChURVNULlNh bXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aE1pZGRsZU91dGxpZXJBYm92ZU1h eFBlcmNlbnREaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5E aWZmZXJlbnRDb2xvcnNXaXRoUmlnaHRPdXRsaWVyQWJvdmVNYXhQZXJjZW50RGlmZmVyZW5jZSk6 CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzSW5kaXZp ZHVhbGx5QWJvdmVNYXhQZXJjZW50RGlmZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQ YWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzQ3VtdWxhdGl2ZWx5QWJvdmVNYXhQZXJjZW50RGlm ZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlzcGxheVAzKToK KyAgICAgICAgKFRFU1QuU2FtcGxlZFBhZ2VUb3BDb2xvci5FeHBlcmltZW50YWxVc2VTYW1wbGVk UGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcik6CisKKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKwog MjAyMS0wNC0yNiAgRG9uIE9sbXN0ZWFkICA8ZG9uLm9sbXN0ZWFkQHNvbnkuY29tPgogCiAgICAg ICAgIFtDTWFrZV0gTW9kZXJuaXplIFdlYktpdCBHTGliIHRlc3RpbmcKZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKaW5kZXggN2IwNmJhZDNkOTRmLi4zN2RiOWEyZmFmYmUgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisr KyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCkBAIC04NjUsNiArODY1LDcgQEAKIAkJOTNGNTZEQTcxRTVGOTE3NDAwM0VERTg0IC8q IGxpYmljdWNvcmUuZHlsaWIgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA3QzgzRTAzMzFEMEE1RjI3MDBGRUJDRjMgLyogbGliaWN1Y29yZS5keWxpYiAq LzsgfTsKIAkJOTNGNTZEQTkxRTVGOTE5RDAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1t IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTNGNTZEQTgx RTVGOTE4MTAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBzaG90Lm1tICovOyB9OwogCQk5M0Y3RTg2 RjE0REM4RTVDMDBDODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVz X0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA5M0Y3RTg2RTE0REM4RTVCMDBDODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5 b3V0RnJhbWVzX0J1bmRsZS5jcHAgKi87IH07CisJCTk1MDk1RjIwMjYyRkZGQTUwMDAwRDkyMCAv KiBTYW1wbGVkUGFnZVRvcENvbG9yLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gOTUwOTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9w Q29sb3IubW0gKi87IH07CiAJCTk1MEU0Q0MxMjUyRTc1MjQwMDcxNjU5RiAvKiBpT1NTdHlsdXNT dXBwb3J0Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g OTUwRTRDQzAyNTJFNzUyMzAwNzE2NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi87IH07CiAJ CTk1M0FCQjM1MjVDMEQ2ODIwMDRDOEI3MyAvKiBQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3Iu bW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5NTNBQkIz NDI1QzBENjgxMDA0QzhCNzMgLyogUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yLm1tICovOyB9 OwogCQk5NUE1MjQ5NTI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5tbSBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1QTUyNDk0MjU4 MUExMEQwMDQ2MUZFOSAvKiBXS1dlYlZpZXdUaGVtZUNvbG9yLm1tICovOyB9OwpAQCAtMjU1NSw2 ICsyNTU2LDcgQEAKIAkJOTNGNTZEQTgxRTVGOTE4MTAwM0VERTg0IC8qIFdLV2ViVmlld1NuYXBz aG90Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV0tXZWJWaWV3 U25hcHNob3QubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzRjdFODZCMTREQzhF NEQwMEM4NEE5OSAvKiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXRGcmFtZXMuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmlyc3RWaXN1YWxseU5vbkVt cHR5TGF5b3V0RnJhbWVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTNGN0U4 NkUxNERDOEU1QjAwQzg0QTk5IC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1l c19CdW5kbGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gTmV3Rmly c3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0RnJhbWVzX0J1bmRsZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCTk1MDk1RjFGMjYyRkZGQTUwMDAwRDkyMCAvKiBTYW1wbGVkUGFnZVRv cENvbG9yLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gU2FtcGxl ZFBhZ2VUb3BDb2xvci5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTUwRTRDQzAy NTJFNzUyMzAwNzE2NTlGIC8qIGlPU1N0eWx1c1N1cHBvcnQubW0gKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5vYmpjcHA7IHBhdGggPSBpT1NTdHlsdXNTdXBwb3J0Lm1tOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk5NTNBQkIzNDI1QzBENjgxMDA0QzhCNzMgLyogUGFnZUV4dGVuZGVk QmFja2dyb3VuZENvbG9yLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRo ID0gUGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk5NUE1MjQ5NDI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVDb2xvci5t bSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdLV2ViVmlld1RoZW1l Q29sb3IubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zNTI1LDYgKzM1MjcsNyBA QAogCQkJCUExODBDMEY5MUVFNjdERjAwMDQ2OEY0NyAvKiBSdW5PcGVuUGFuZWwubW0gKi8sCiAJ CQkJRjREMjk4NkQyMEZFRTczNzAwOTJENjM2IC8qIFJ1blNjcmlwdEFmdGVyRG9jdW1lbnRMb2Fk Lm1tICovLAogCQkJCTVDQTk4NTUxMjExM0NCOEMwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0g Ki8sCisJCQkJOTUwOTVGMUYyNjJGRkZBNTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3Iu bW0gKi8sCiAJCQkJQ0UwOTQ3MzYyMDYzMjIzQjAwM0M5QkEwIC8qIFNjaGVtZVJlZ2lzdHJ5Lm1t ICovLAogCQkJCTUxRUIxMjkzMUZERjA1MDUwMEE1QTFCRCAvKiBTZXJ2aWNlV29ya2VyQmFzaWMu bW0gKi8sCiAJCQkJNUM2ODM0NzEyMzVBQ0M3QzAwNDFFNkIxIC8qIFNlcnZpY2VXb3JrZXJUQ1BT ZXJ2ZXIuaCAqLywKQEAgLTU2MzYsNiArNTYzOSw3IEBACiAJCQkJQTE4MEMwRkExRUU2N0RGMDAw NDY4RjQ3IC8qIFJ1bk9wZW5QYW5lbC5tbSBpbiBTb3VyY2VzICovLAogCQkJCUY0RDI5ODZFMjBG RUU3MzcwMDkyRDYzNiAvKiBSdW5TY3JpcHRBZnRlckRvY3VtZW50TG9hZC5tbSBpbiBTb3VyY2Vz ICovLAogCQkJCTVDQTk4NTUzMjExM0NGNzgwMDU3RUI2QiAvKiBTYWZlQnJvd3NpbmcubW0gaW4g U291cmNlcyAqLywKKwkJCQk5NTA5NUYyMDI2MkZGRkE1MDAwMEQ5MjAgLyogU2FtcGxlZFBhZ2VU b3BDb2xvci5tbSBpbiBTb3VyY2VzICovLAogCQkJCUNEQ0ZBN0FBMUU0NTE4MzIwMEMyNDMzRCAv KiBTYW1wbGVNYXAuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0UwOTQ3MzcyMDYzMjIzQjAwM0M5 QkEwIC8qIFNjaGVtZVJlZ2lzdHJ5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0RDMDkzMkIyMUM4 NzJDMTAwMzBDNEIwIC8qIFNjcm9sbGluZ0RvZXNOb3RQYXVzZU1lZGlhLm1tIGluIFNvdXJjZXMg Ki8sCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1Nh bXBsZWRQYWdlVG9wQ29sb3IubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENv Y29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi4wNzI1MDE0ZDc1NjMKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW0KQEAgLTAsMCAr MSwzMDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjEgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S CisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgor ICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJjb25maWcuaCIKKworI2ltcG9ydCAiVGVz dENvY29hLmgiCisjaW1wb3J0ICJUZXN0V0tXZWJWaWV3LmgiCisjaW1wb3J0ICJVdGlsaXRpZXMu aCIKKyNpbXBvcnQgPFdlYkNvcmUvQ29sb3IuaD4KKyNpbXBvcnQgPFdlYktpdC9XS1ByZWZlcmVu Y2VzUHJpdmF0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L1dLV2ViVmlld0NvbmZpZ3VyYXRpb25Qcml2 YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3UHJpdmF0ZS5oPgorI2ltcG9ydCA8V2Vi S2l0L19XS0ludGVybmFsRGVidWdGZWF0dXJlLmg+CisjaW1wb3J0IDx3dGYvRnVuY3Rpb24uaD4K KyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0Zi90ZXh0L1N0cmluZ0J1aWxk ZXIuaD4KKworI2RlZmluZSBFWFBFQ1RfSU5fUkFOR0UoYWN0dWFsLCBtaW4sIG1heCkgXAorICAg IEVYUEVDVF9HRShhY3R1YWwsIG1pbik7IFwKKyAgICBFWFBFQ1RfTEUoYWN0dWFsLCBtYXgpOwor CitAaW50ZXJmYWNlIFRlc3RLVk9XcmFwcGVyIDogTlNPYmplY3QKKworLSAoaW5zdGFuY2V0eXBl KWluaXRXaXRoT2JzZXJ2YWJsZTooTlNPYmplY3QgKilvYnNlcnZhYmxlIGtleVBhdGg6KE5TU3Ry aW5nICopa2V5UGF0aCBjYWxsYmFjazooRnVuY3Rpb248dm9pZCgpPiYmKWNhbGxiYWNrOworCitA ZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBUZXN0S1ZPV3JhcHBlciB7CisgICAgUmV0YWluUHRyPE5T T2JqZWN0PiBfb2JzZXJ2YWJsZTsKKyAgICBSZXRhaW5QdHI8TlNTdHJpbmc+IF9rZXlQYXRoOwor ICAgIEZ1bmN0aW9uPHZvaWQoKT4gX2NhbGxiYWNrOworfQorCistIChpbnN0YW5jZXR5cGUpaW5p dFdpdGhPYnNlcnZhYmxlOihOU09iamVjdCAqKW9ic2VydmFibGUga2V5UGF0aDooTlNTdHJpbmcg KilrZXlQYXRoIGNhbGxiYWNrOihGdW5jdGlvbjx2b2lkKCk+JiYpY2FsbGJhY2sKK3sKKyAgICBp ZiAoIShzZWxmID0gW3N1cGVyIGluaXRdKSkKKyAgICAgICAgcmV0dXJuIG5pbDsKKworICAgIF9v YnNlcnZhYmxlID0gb2JzZXJ2YWJsZTsKKyAgICBfa2V5UGF0aCA9IGtleVBhdGg7CisgICAgX2Nh bGxiYWNrID0gV1RGTW92ZShjYWxsYmFjayk7CisKKyAgICBbX29ic2VydmFibGUgYWRkT2JzZXJ2 ZXI6c2VsZiBmb3JLZXlQYXRoOl9rZXlQYXRoLmdldCgpIG9wdGlvbnM6MCBjb250ZXh0Om5pbF07 CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9pZClkZWFsbG9jCit7CisgICAgW19vYnNl cnZhYmxlIHJlbW92ZU9ic2VydmVyOnNlbGYgZm9yS2V5UGF0aDpfa2V5UGF0aC5nZXQoKSBjb250 ZXh0Om51bGxwdHJdOworCisgICAgW3N1cGVyIGRlYWxsb2NdOworfQorCistICh2b2lkKW9ic2Vy dmVWYWx1ZUZvcktleVBhdGg6KE5TU3RyaW5nICopa2V5UGF0aCBvZk9iamVjdDooaWQpb2JqZWN0 IGNoYW5nZTooTlNEaWN0aW9uYXJ5ICopY2hhbmdlIGNvbnRleHQ6KHZvaWQgKiljb250ZXh0Cit7 CisgICAgX2NhbGxiYWNrKCk7Cit9CisKK0BlbmQKKworZW51bSBjbGFzcyBVc2VTYW1wbGVkUGFn ZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciA6IGJvb2wgeyBZZXMsIE5vIH07 CitzdGF0aWMgUmV0YWluUHRyPFRlc3RXS1dlYlZpZXc+IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxl ZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoZG91YmxlIHNhbXBsZWRQYWdlVG9wQ29sb3JNYXhE aWZmZXJlbmNlLCBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvciB1c2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciA9 IFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOjpObykK K3sKKyAgICBhdXRvIGNvbmZpZ3VyYXRpb24gPSBhZG9wdE5TKFtbV0tXZWJWaWV3Q29uZmlndXJh dGlvbiBhbGxvY10gaW5pdF0pOworICAgIFtjb25maWd1cmF0aW9uIF9zZXRTYW1wbGVkUGFnZVRv cENvbG9yTWF4RGlmZmVyZW5jZTpzYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZV07CisK KyAgICBmb3IgKF9XS0ludGVybmFsRGVidWdGZWF0dXJlICpmZWF0dXJlIGluIFtXS1ByZWZlcmVu Y2VzIF9pbnRlcm5hbERlYnVnRmVhdHVyZXNdKSB7CisgICAgICAgIGlmIChbZmVhdHVyZS5rZXkg aXNFcXVhbFRvU3RyaW5nOkAiVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNr Z3JvdW5kQ29sb3IiXSkgeworICAgICAgICAgICAgW1tjb25maWd1cmF0aW9uIHByZWZlcmVuY2Vz XSBfc2V0RW5hYmxlZDoodXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3Jv dW5kQ29sb3IgPT0gVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5k Q29sb3I6OlllcykgZm9ySW50ZXJuYWxEZWJ1Z0ZlYXR1cmU6ZmVhdHVyZV07CisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBhZG9wdE5TKFtbVGVzdFdL V2ViVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpDR1JlY3RNYWtlKDAsIDAsIDgwMCwgNjAwKSBj b25maWd1cmF0aW9uOmNvbmZpZ3VyYXRpb24uZ2V0KCldKTsKK30KKworc3RhdGljIHZvaWQgd2Fp dEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0NoYW5nZUZvckhUTUwoVGVzdFdLV2ViVmlldyAqd2Vi VmlldywgU3RyaW5nJiYgaHRtbCkKK3sKKyAgICBib29sIGRvbmUgPSBmYWxzZTsKKyAgICBhdXRv IHNhbXBsZWRQYWdlVG9wQ29sb3JPYnNlcnZlciA9IGFkb3B0TlMoW1tUZXN0S1ZPV3JhcHBlciBh bGxvY10gaW5pdFdpdGhPYnNlcnZhYmxlOndlYlZpZXcga2V5UGF0aDpAIl9zYW1wbGVkUGFnZVRv cENvbG9yIiBjYWxsYmFjazpbJl0geworICAgICAgICBkb25lID0gdHJ1ZTsKKyAgICB9XSk7Cisg ICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1t ZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpXVEZNb3ZlKGh0bWwpXTsKKyAgICBUZXN0V2ViS2l0QVBJ OjpVdGlsOjpydW4oJmRvbmUpOworfQorCitzdGF0aWMgU3RyaW5nIGNyZWF0ZUhUTUxHcmFkaWVu dFdpdGhDb2xvclN0b3BzKFZlY3RvcjxTdHJpbmc+JiYgY29sb3JTdG9wcykKK3sKKyAgICBFWFBF Q1RfR0UoY29sb3JTdG9wcy5zaXplKCksIDJVTCk7CisKKyAgICBTdHJpbmdCdWlsZGVyIGdyYWRp ZW50QnVpbGRlcjsKKyAgICBncmFkaWVudEJ1aWxkZXIuYXBwZW5kKCI8Ym9keSBzdHlsZT1cImJh Y2tncm91bmQtaW1hZ2U6IGxpbmVhci1ncmFkaWVudCh0byByaWdodCJfcyk7CisgICAgZm9yIChh dXRvJiYgY29sb3JTdG9wIDogV1RGTW92ZShjb2xvclN0b3BzKSkgeworICAgICAgICBncmFkaWVu dEJ1aWxkZXIuYXBwZW5kKCIsICJfcyk7CisgICAgICAgIGdyYWRpZW50QnVpbGRlci5hcHBlbmQo V1RGTW92ZShjb2xvclN0b3ApKTsKKyAgICB9CisgICAgZ3JhZGllbnRCdWlsZGVyLmFwcGVuZCgi KVwiPlRlc3QiX3MpOworICAgIHJldHVybiBncmFkaWVudEJ1aWxkZXIudG9TdHJpbmcoKTsKK30K KworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBaZXJvTWF4RGlmZmVyZW5jZSkKK3sKKyAgICBh dXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZm ZXJlbmNlKDApOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9y XSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50 aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xv clN0b3BzKHsgInJlZCIsICJyZWQiIH0pXTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlldyBfc2Ft cGxlZFBhZ2VUb3BDb2xvcl0pOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIE5lZ2F0 aXZlTWF4RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0 aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlKC01KTsKKyAgICBFWFBFQ1RfTlVMTChb d2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXcgc3luY2hyb25v dXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWlu dDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAicmVkIiB9KV07Cisg ICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworVEVT VChTYW1wbGVkUGFnZVRvcENvbG9yLCBTb2xpZENvbG9yKQoreworICAgIGF1dG8gd2ViVmlldyA9 IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7Cisg ICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIHdh aXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNy ZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBF WFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNH Q29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVkKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENv bG9yLCBEaWZmZXJlbnRDb2xvcnNXaXRob3V0T3V0bGllckJlbG93TWF4RGlmZmVyZW5jZSkKK3sK KyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JN YXhEaWZmZXJlbmNlKDUpOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRv cENvbG9yXSk7CisKKyAgICB3YWl0Rm9yU2FtcGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRN TCh3ZWJWaWV3LmdldCgpLCBjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7CisgICAg ICAgICJsYWIoMSUgMCAwKSJfcywKKyAgICAgICAgImxhYigyJSAwIDApIl9zLAorICAgICAgICAi bGFiKDMlIDAgMCkiX3MsCisgICAgICAgICJsYWIoNCUgMCAwKSJfcywKKyAgICAgICAgImxhYig1 JSAwIDApIl9zLAorICAgIH0pKTsKKworICAgIGF1dG8gY29tcG9uZW50cyA9IENHQ29sb3JHZXRD b21wb25lbnRzKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0NvbG9yKTsKKyAgICBF WFBFQ1RfSU5fUkFOR0UoY29tcG9uZW50c1swXSwgMC4wNCwgMC4wNSk7CisgICAgRVhQRUNUX0lO X1JBTkdFKGNvbXBvbmVudHNbMV0sIDAuMDQsIDAuMDUpOworICAgIEVYUEVDVF9JTl9SQU5HRShj b21wb25lbnRzWzJdLCAwLjA0LCAwLjA1KTsKKyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1szXSwg MSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVyZW50Q29sb3JzV2l0aExl ZnRPdXRsaWVyQWJvdmVNYXhEaWZmZXJlbmNlKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0 ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7CisgICAgRVhQ RUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JT YW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhU TUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAgICAgImxhYigxMDAlIDAgMCkiX3MsIC8v IG91dGxpZXIKKyAgICAgICAgImxhYigxJSAwIDApIl9zLAorICAgICAgICAibGFiKDIlIDAgMCki X3MsCisgICAgICAgICJsYWIoMyUgMCAwKSJfcywKKyAgICAgICAgImxhYig0JSAwIDApIl9zLAor ICAgIH0pKTsKKworICAgIGF1dG8gY29tcG9uZW50cyA9IENHQ29sb3JHZXRDb21wb25lbnRzKFt3 ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0NvbG9yKTsKKyAgICBFWFBFQ1RfSU5fUkFO R0UoY29tcG9uZW50c1swXSwgMC4wMywgMC4wNCk7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBv bmVudHNbMV0sIDAuMDMsIDAuMDQpOworICAgIEVYUEVDVF9JTl9SQU5HRShjb21wb25lbnRzWzJd LCAwLjAzLCAwLjA0KTsKKyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1szXSwgMSk7Cit9CisKK1RF U1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVyZW50Q29sb3JzV2l0aE1pZGRsZU91dGxpZXJB Ym92ZU1heERpZmZlcmVuY2UpCit7CisgICAgYXV0byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dp dGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZSg1KTsKKyAgICBFWFBFQ1RfTlVMTChb d2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXcgc3luY2hyb25v dXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWlu dDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7CisgICAgICAgICJsYWIoMSUgMCAw KSJfcywKKyAgICAgICAgImxhYigyJSAwIDApIl9zLAorICAgICAgICAibGFiKDEwMCUgMCAwKSJf cywgLy8gb3V0bGllcgorICAgICAgICAibGFiKDMlIDAgMCkiX3MsCisgICAgICAgICJsYWIoNCUg MCAwKSJfcywKKyAgICB9KV07CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdl VG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBEaWZmZXJlbnRDb2xv cnNXaXRoUmlnaHRPdXRsaWVyQWJvdmVNYXhEaWZmZXJlbmNlKQoreworICAgIGF1dG8gd2ViVmll dyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7 CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAg IHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCks IGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAgICAgImxhYigxJSAwIDAp Il9zLAorICAgICAgICAibGFiKDIlIDAgMCkiX3MsCisgICAgICAgICJsYWIoMyUgMCAwKSJfcywK KyAgICAgICAgImxhYig0JSAwIDApIl9zLAorICAgICAgICAibGFiKDEwMCUgMCAwKSJfcywgLy8g b3V0bGllcgorICAgIH0pKTsKKworICAgIGF1dG8gY29tcG9uZW50cyA9IENHQ29sb3JHZXRDb21w b25lbnRzKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0NvbG9yKTsKKyAgICBFWFBF Q1RfSU5fUkFOR0UoY29tcG9uZW50c1swXSwgMC4wMywgMC4wNCk7CisgICAgRVhQRUNUX0lOX1JB TkdFKGNvbXBvbmVudHNbMV0sIDAuMDMsIDAuMDQpOworICAgIEVYUEVDVF9JTl9SQU5HRShjb21w b25lbnRzWzJdLCAwLjAzLCAwLjA0KTsKKyAgICBFWFBFQ1RfRVEoY29tcG9uZW50c1szXSwgMSk7 Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVyZW50Q29sb3JzSW5kaXZpZHVh bGx5QWJvdmVNYXhEaWZmZXJlbmNlKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZp ZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7CisgICAgRVhQRUNUX05V TEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3ZWJWaWV3IHN5bmNo cm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVz UGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMoeworICAgICAgICAibGFiKDEw JSAwIDApIl9zLAorICAgICAgICAibGFiKDIwJSAwIDApIl9zLAorICAgICAgICAibGFiKDMwJSAw IDApIl9zLAorICAgICAgICAibGFiKDQwJSAwIDApIl9zLAorICAgICAgICAibGFiKDUwJSAwIDAp Il9zLAorICAgIH0pXTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BD b2xvcl0pOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIERpZmZlcmVudENvbG9yc0N1 bXVsYXRpdmVseUFib3ZlTWF4RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVh dGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlKDUpOworICAgIEVY UEVDVF9OVUxMKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2ViVmll dyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVDaGls ZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAgICAg ImxhYigxJSAwIDApIl9zLAorICAgICAgICAibGFiKDMlIDAgMCkiX3MsCisgICAgICAgICJsYWIo NSUgMCAwKSJfcywKKyAgICAgICAgImxhYig3JSAwIDApIl9zLAorICAgICAgICAibGFiKDklIDAg MCkiX3MsCisgICAgfSldOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRv cENvbG9yXSk7Cit9CisKKy8vIEZJWE1FOiA8aHR0cHM6Ly93ZWJraXQub3JnL2IvMjI1MTY3PiAo U2FtcGxlZCBQYWdlIFRvcCBDb2xvcjogaG9vayBpbnRvIHBhaW50aW5nIGxvZ2ljIGluc3RlYWQg b2YgdGFraW5nIHNuYXBzaG90cykKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRElTQUJMRURf RGlzcGxheVAzKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxl ZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcg X3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2Fk SFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRl SFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMoeworICAgICAgICAiY29sb3IoZGlzcGxheS1wMyAw Ljk5IDAgMCkiX3MsCisgICAgICAgICJjb2xvcihkaXNwbGF5LXAzIDAuOTggMCAwKSJfcywKKyAg ICAgICAgImNvbG9yKGRpc3BsYXktcDMgMC45NyAwIDApIl9zLAorICAgICAgICAiY29sb3IoZGlz cGxheS1wMyAwLjk2IDAgMCkiX3MsCisgICAgICAgICJjb2xvcihkaXNwbGF5LXAzIDAuOTUgMCAw KSJfcywKKyAgICB9KV07CisKKyAgICBhdXRvIGNvbXBvbmVudHMgPSBDR0NvbG9yR2V0Q29tcG9u ZW50cyhbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0uQ0dDb2xvcik7CisgICAgRVhQRUNU X0lOX1JBTkdFKGNvbXBvbmVudHNbMF0sIDAuMywgMC40KTsKKyAgICBFWFBFQ1RfSU5fUkFOR0Uo Y29tcG9uZW50c1sxXSwgMS4wMCwgMS4wMSk7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVu dHNbMl0sIDEuMDAsIDEuMDEpOworICAgIEVYUEVDVF9FUShjb21wb25lbnRzWzNdLCAxKTsKK30K KworI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCisKKy8vIFRoZXJlJ3Mgbm8gQVBJL1NQSSB0byBn ZXQgdGhlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNjcm9sbCBhcmVhIG9uIG1hY09TLgorCitU RVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIEV4cGVyaW1lbnRhbFVzZVNhbXBsZWRQYWdlVG9wQ29s b3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKQoreworICAgIGF1dG8gd2ViVmlld1dpdGhv dXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciA9IGNyZWF0ZVdlYlZpZXdX aXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSwgVXNlU2FtcGxlZFBhZ2VUb3BD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6Ok5vKTsKKyAgICBFWFBFQ1RfTlVMTChb d2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBfc2Ft cGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNj cm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2Fp dFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGllbnRXaXRo Q29sb3JTdG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3 V2l0aG91dFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIF9zYW1wbGVkUGFn ZVRvcENvbG9yXSk7CisgICAgRVhQRUNUX0VRKFdlYkNvcmU6OkNvbG9yKFt3ZWJWaWV3V2l0aG91 dFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9sbFZpZXddLmJhY2tn cm91bmRDb2xvci5DR0NvbG9yKSwgV2ViQ29yZTo6Q29sb3I6OndoaXRlKTsKKworICAgIHdhaXRG b3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXdXaXRob3V0VGhlbWVD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVu dFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29y ZTo6Q29sb3IoW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5k Q29sb3IgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVk KTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Nyb2xsVmlld10uYmFja2dyb3VuZENvbG9y LkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6d2hpdGUpOworCisgICAgYXV0byB3ZWJWaWV3V2l0 aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yID0gY3JlYXRlV2ViVmlld1dp dGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZSg1LCBVc2VTYW1wbGVkUGFnZVRvcENv bG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcjo6WWVzKTsKKyAgICBFWFBFQ1RfTlVMTChb d2ViVmlld1dpdGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciBfc2FtcGxl ZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXdXaXRoVGhlbWVDb2xvckZvclNjcm9sbEFy ZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGls QWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JT dG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3V2l0aFRo ZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIF9zYW1wbGVkUGFnZVRvcENvbG9y XSk7CisgICAgRVhQRUNUX0VRKFdlYkNvcmU6OkNvbG9yKFt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JG b3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9sbFZpZXddLmJhY2tncm91bmRDb2xvci5D R0NvbG9yKSwgV2ViQ29yZTo6Q29sb3I6OndoaXRlKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFn ZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXdXaXRoVGhlbWVDb2xvckZvclNjcm9sbEFy ZWFCYWNrZ3JvdW5kQ29sb3IuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3Bz KHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZp ZXdXaXRoVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgX3NhbXBsZWRQYWdl VG9wQ29sb3JdLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVkKTsKKyAgICBFWFBFQ1RfRVEo V2ViQ29yZTo6Q29sb3IoW3dlYlZpZXdXaXRoVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3Jv dW5kQ29sb3Igc2Nyb2xsVmlld10uYmFja2dyb3VuZENvbG9yLkNHQ29sb3IpLCBXZWJDb3JlOjpD b2xvcjo6cmVkKTsKK30KKworI2VuZGlmIC8vIFBMQVRGT1JNKElPU19GQU1JTFkpCg== 427302 2021-04-28 16:09:58 -0700 2021-04-29 08:16:48 -0700 Patch bug-224987-20210428170956.patch text/plain 53596 hi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggNzA0YzcyMDZlY2MxYzBiOWEzMjBkMWIzNjE3NDliZDRiMjdlYzVhZC4uODc1NGYzODE2 NTE4MDhmNzY5YTJjMWM0OGE0OWVlMzc4N2YyMjQ4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9D aGFuZ2VMb2cKKysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAy MS0wNC0yOCAgRGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+CisKKyAgICAgICAgZXhw ZXJpbWVudCB3aXRoIGF2ZXJhZ2luZyBzYW1wbGluZyBjb2xvcnMgYWNyb3NzIHRoZSB0b3Agb2Yg dGhlIHBhZ2UgYXMgdGhlIHNjcm9sbCBhcmVhIGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNDk4NworICAgICAgICA8cmRhcjovL3By b2JsZW0vNzYyNTE4ODk+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAg ICAgICAgKiBTY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzLnlhbWw6CisgICAgICAg IEFkZCBhIGBTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZWAgc2V0dGluZyB0aGF0IGNv bnRyb2xzIGJvdGggd2hldGhlciBvciBub3QgdG8gc2FtcGxlCisgICAgICAgIGNvbG9ycyBmcm9t IHRoZSB0b3Agb2YgdGhlIHBhZ2UgKG9ubHkgaWYgdmFsdWUgPiAwKSBhbmQgdGhlIG1heCBMYWIg Y29sb3IgZGlmZmVyZW5jZSBhbGxvd2VkCisgICAgICAgIGFjcm9zcyBhbGwgc2FtcGxlcy4KKwor ICAgICAgICAqIFNjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRlcm5hbC55YW1s OgorICAgICAgICBBZGQgYSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNr Z3JvdW5kQ29sb3JgIGludGVybmFsIHNldHRpbmcgdGhhdCBjb250cm9scworICAgICAgICB3aGV0 aGVyIHRoZSBzYW1wbGVkIHBhZ2UgdG9wIGNvbG9yIGNhbiBiZSB1c2VkIGFzIHRoZSBvdmVyc2Ny b2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvci4KKwogMjAyMS0wNC0yNiAgS2VpdGggTWlsbGVyICA8 a2VpdGhfbWlsbGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBDb2RlQmxvY2sgc2hvdWxkIGRvIGEg YmV0dGVyIGpvYiBhY2NvdW50aW5nIGZvciBleHRyYSBtZW1vcnkgaXQgYWxsb2NhdGVzLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IGNhOThhNDVkMGYxYWQxNjYwNjNkNTJjMTMwZjkzOWUzNzAyMDI1ZTYuLmYyMjVm NTU0YTFiMWNiMWJmMzJiNDJhNjE4ZjY3NjRhOThiODkzZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSw1MSBAQAorMjAyMS0wNC0yOCAgRGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+CisK KyAgICAgICAgZXhwZXJpbWVudCB3aXRoIGF2ZXJhZ2luZyBzYW1wbGluZyBjb2xvcnMgYWNyb3Nz IHRoZSB0b3Agb2YgdGhlIHBhZ2UgYXMgdGhlIHNjcm9sbCBhcmVhIGJhY2tncm91bmQKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNDk4NworICAgICAg ICA8cmRhcjovL3Byb2JsZW0vNzYyNTE4ODk+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g QWRsZXIuCisKKyAgICAgICAgVGVzdHM6IFNhbXBsZWRQYWdlVG9wQ29sb3IuWmVyb01heERpZmZl cmVuY2UKKyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuTmVnYXRpdmVNYXhEaWZm ZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLlNvbGlkQ29sb3IKKyAg ICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aG91dE91 dGxpZXJCZWxvd01heERpZmZlcmVuY2UKKyAgICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29s b3IuRGlmZmVyZW50Q29sb3JzV2l0aExlZnRPdXRsaWVyQWJvdmVNYXhEaWZmZXJlbmNlCisgICAg ICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc1dpdGhNaWRkbGVP dXRsaWVyQWJvdmVNYXhEaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENv bG9yLkRpZmZlcmVudENvbG9yc1dpdGhSaWdodE91dGxpZXJBYm92ZU1heERpZmZlcmVuY2UKKyAg ICAgICAgICAgICAgIFNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzSW5kaXZpZHVh bGx5QWJvdmVNYXhEaWZmZXJlbmNlCisgICAgICAgICAgICAgICBTYW1wbGVkUGFnZVRvcENvbG9y LkRpZmZlcmVudENvbG9yc0N1bXVsYXRpdmVseUFib3ZlTWF4RGlmZmVyZW5jZQorICAgICAgICAg ICAgICAgU2FtcGxlZFBhZ2VUb3BDb2xvci5EaXNwbGF5UDMKKyAgICAgICAgICAgICAgIFNhbXBs ZWRQYWdlVG9wQ29sb3IuRXhwZXJpbWVudGFsVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9s bEFyZWFCYWNrZ3JvdW5kQ29sb3IKKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OnNhbXBsZWRQYWdlVG9wQ29sb3IgY29uc3QpOiBBZGRlZC4K KyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6 OmVucXVldWVQYWludFRpbWluZ0VudHJ5SWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6Y29s b3JEaWZmZXJlbmNlKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjphdmVyYWdlQ29sb3IpOiBB ZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpkZXRlcm1pbmVTYW1wbGVkUGFnZVRv cENvbG9yKTogQWRkZWQuCisgICAgICAgIFdhaXQgdW50aWwgdGhlIGZpcnN0IGNvbnRlbnRmdWwg cGFpbnQgYmVmb3JlIHNhbXBsaW5nLiBEb24ndCBzYW1wbGUgaWYgdGhhdCBsb2NhdGlvbiB3b3Vs ZAorICAgICAgICBmYWxsIGludG8gYSAzcmQtcGFydHkgYDxpZnJhbWU+YC4gQ3VycmVudGx5IHVz ZSA1IHNuYXBzaG90cyBhY3Jvc3MgdGhlIHRvcCBvZiB0aGUgcGFnZSwKKyAgICAgICAgYWxsb3dp bmcgZm9yIG9uZSBvZiBlaXRoZXIgdGhlIGZpcnN0IG9yIGxhc3Qgc25hcHNob3QgdG8gYmUgYW4g b3V0bGllciwgd2hpY2ggaXMgbm90CisgICAgICAgIGluY2x1ZGVkIGluIHRoZSBhdmVyYWdlIG9m IHRoZSBvdGhlciBzbmFwc2hvdHMgdGhhdCdzIHVzZWQgYXMgdGhlIGZpbmFsIGNvbG9yIHZhbHVl LiBJZiB0aGUKKyAgICAgICAgTGFiIGNvbG9yIGRpZmZlcmVuY2UgYmV0d2VlbiBhbnkgdHdvIHNu YXBzaG90cyAodW5sZXNzIGl0J3MgdGhlIGZpcnN0IG9yIGxhc3Qgc25hcHNob3QgYXMKKyAgICAg ICAgZGVzY3JpYmVkIGFib3ZlKSBvciBhY3Jvc3MgYWxsIHRoZSAobm9uLW91dGxpZXIpIHNuYXBz aG90cyBpcyB0b28gbGFyZ2UsIGJhaWwuIE9ubHkgZW5hYmxlZAorICAgICAgICBpZiB0aGUgYFNh bXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlYCBzZXR0aW5nIGlzIGdyZWF0ZXIgdGhhbiAw LgorCisgICAgICAgICogcGFnZS9QYWdlLmg6CisgICAgICAgICogcGFnZS9QYWdlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlBhZ2U6OnNhbXBsZWRQYWdlVG9wQ29sb3IgY29uc3QpOiBBZGRlZC4K KyAgICAgICAgKiBwYWdlL0Nocm9tZUNsaWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6Q2hyb21l Q2xpZW50OjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IgY29uc3QpOiBBZGRlZC4KKyAgICAgICAgUGFz cyBhbG9uZyB0aGUgYHNhbXBsZWRQYWdlVG9wQ29sb3JgIHRvIHRoZSBVSVByb2Nlc3MgYWZ0ZXIg aXQncyBkZXRlcm1pbmVkIG9yIGlmIHRoZSBhYm92ZQorICAgICAgICBsb2dpYyBiYWlscyAoc28g dGhhdCB0aGUgYFdLV2ViVmlld2AgY2FuIGFkanVzdCBgX3NhbXBsZWRQYWdlVG9wQ29sb3JgIHRv IGBuaWxgKS4KKworICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMYXllckNvbXBvc2l0b3IuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTGF5ZXJDb21wb3NpdG9yOjpyb290QmFja2dyb3Vu ZENvbG9yT3JUcmFuc3BhcmVuY3lDaGFuZ2VkKToKKyAgICAgICAgVXNlIHRoZSBgc2FtcGxlZFBh Z2VUb3BDb2xvcmAgaWYgdGhlIGBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJh Y2tncm91bmRDb2xvcmAKKyAgICAgICAgaW50ZXJuYWwgcHJlZmVyZW5jZSBpcyBlbmFibGVkIGlu c3RlYWQgb2YgdGhlIENTUyBgYmFja2dyb3VuZC1jb2xvcmAgb2YgdGhlIGA8aHRtbD5gL2A8Ym9k eT5gLgorCiAyMDIxLTA0LTI2ICBGdWppaSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnku Y29tPgogCiAgICAgICAgIFJFR1JFU1NJT04ocjI3MjM3OSkgW1dpbl0gU29tZSBlbW9qaXMgYXJl IHBhaW50ZWQgd2l0aCBhIGJsYW5rIHNxdWFyZSBvbiB0aGUgcmlnaHQgc2lkZSBvZiBpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxv ZwppbmRleCA5MWVkOWNmNTRjM2VjMmNhMTE1YTdhZTgxMWFiZjdmMThmOGJmMjU0Li4xZGQ4N2Jk NWI1ZTI3OGYxYmVmNGQzMWU5MGNmYTcyODEwNjUxMzBkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDUw IEBACisyMDIxLTA0LTI4ICBEZXZpbiBSb3Vzc28gIDxkcm91c3NvQGFwcGxlLmNvbT4KKworICAg ICAgICBleHBlcmltZW50IHdpdGggYXZlcmFnaW5nIHNhbXBsaW5nIGNvbG9ycyBhY3Jvc3MgdGhl IHRvcCBvZiB0aGUgcGFnZSBhcyB0aGUgc2Nyb2xsIGFyZWEgYmFja2dyb3VuZAorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI0OTg3CisgICAgICAgIDxy ZGFyOi8vcHJvYmxlbS83NjI1MTg4OT4KKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxl ci4KKworICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50 Lmg6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVDbGllbnQu Y3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJDaHJvbWVDbGllbnQ6OmRpZFNhbXBsZVBhZ2VUb3BD b2xvciBjb25zdCk6IEFkZGVkLgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdl Lmg6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlOjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IpOiBBZGRlZC4KKyAgICAgICAg UGFzcyBhbG9uZyB0aGUgYHNhbXBsZWRQYWdlVG9wQ29sb3JgIHRvIHRoZSBVSVByb2Nlc3MuCisK KyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluOgorICAgICAgICAq IFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5 OjpzYW1wbGVkUGFnZVRvcENvbG9yKTogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL1dlYlBh Z2VQcm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6c2Nyb2xsQXJlYUJh Y2tncm91bmRDb2xvciBjb25zdCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6ZGlk U2FtcGxlUGFnZVRvcENvbG9yKTogQWRkZWQuCisgICAgICAgIFVzZSB0aGUgYHNhbXBsZWRQYWdl VG9wQ29sb3JgIGlmIHRoZSBgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNr Z3JvdW5kQ29sb3JgCisgICAgICAgIGludGVybmFsIHByZWZlcmVuY2UgaXMgZW5hYmxlZCBpbnN0 ZWFkIG9mIHRoZSBDU1MgYGJhY2tncm91bmQtY29sb3JgIG9mIHRoZSBgPGh0bWw+YC9gPGJvZHk+ YC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9QYWdlQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQ6 OlBhZ2VDbGllbnQ6OnNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hhbmdlKTogQWRkZWQuCisgICAg ICAgIChXZWJLaXQ6OlBhZ2VDbGllbnQ6OnNhbXBsZWRQYWdlVG9wQ29sb3JEaWRDaGFuZ2UpOiBB ZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oOgor ICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLm1tOgorICAgICAg ICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbENvY29hOjpzYW1wbGVkUGFnZVRvcENvbG9yV2lsbENo YW5nZSk6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbENvY29hOjpzYW1w bGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKTogQWRkZWQuCisgICAgICAgIEFkZCBPYmpDIEtWTyBz dXBwb3J0IGZvciBgLVtXS1dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdYC4KKworICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3UHJpdmF0ZS5oOgorICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Lm1tOgorICAgICAgICAoLVtXS1dlYlZpZXcgX3Nl dHVwUGFnZUNvbmZpZ3VyYXRpb246XSk6CisgICAgICAgICgtW1dLV2ViVmlldyBfc2FtcGxlZFBh Z2VUb3BDb2xvcl0pOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29hL1dLV2Vi Vmlld0NvbmZpZ3VyYXRpb25Qcml2YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uLm1tOgorICAgICAgICAoLVtXS1dlYlZpZXdDb25maWd1 cmF0aW9uIGluaXRdKToKKyAgICAgICAgKC1bV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBjb3B5V2l0 aFpvbmU6XSk6CisgICAgICAgICgtW1dLV2ViVmlld0NvbmZpZ3VyYXRpb24gX3NldFNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlOl0pOiBBZGRlZC4KKyAgICAgICAgKC1bV0tXZWJWaWV3 Q29uZmlndXJhdGlvbiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2VdKTogQWRkZWQu CisgICAgICAgIFByb3ZpZGUgU1BJIHRvIGNvbmZpZ3VyZSB0aGUgYFNhbXBsZWRQYWdlVG9wQ29s b3JNYXhEaWZmZXJlbmNlYCBwcmVmZXJlbmNlIHdoZW4KKyAgICAgICAgY3JlYXRpbmcgdGhlIGBX S1dlYlZpZXdgLiBFeHBvc2UgdGhlIHJlc3VsdCBhcyBgX3NhbXBsZWRQYWdlVG9wQ29sb3JgIFNQ SS4KKwogMjAyMS0wNC0yNiAgQWRpdHlhIEtlZXJ0aGkgIDxha2VlcnRoaUBhcHBsZS5jb20+CiAK ICAgICAgICAgUkVHUkVTU0lPTiAocjI3MTg2MSk6IFtpT1NdIEFjY2Vzc29yeSBiYXIgbmF2aWdh dGlvbiB0byBlbGVtZW50cyBvdXRzaWRlIHRoZSB2aWV3cG9ydCBmYWlscwpkaWZmIC0tZ2l0IGEv U291cmNlL1dURi9TY3JpcHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzLnlhbWwgYi9Tb3Vy Y2UvV1RGL1NjcmlwdHMvUHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMueWFtbAppbmRleCA1NmM0 MjY3OGRmNTBiN2I5MjhiZDA2NjU1MjRhZjgzZDE2YjgxODU5Li5jNDE3OGY5YjUzZjk0YWJmZTkw YTFkMGM5NGFiZmM3N2E1ZDQyZDA0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJl ZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMueWFtbAorKysgYi9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJl ZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXMueWFtbApAQCAtMTgyMyw2ICsxODIzLDE2IEBAIFNhZmVC cm93c2luZ0VuYWJsZWQ6CiAgICAgV2ViS2l0OgogICAgICAgZGVmYXVsdDogdHJ1ZQogCitTYW1w bGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZToKKyAgdHlwZTogZG91YmxlCisgIGRlZmF1bHRW YWx1ZToKKyAgICBXZWJLaXRMZWdhY3k6CisgICAgICBkZWZhdWx0OiAwCisgICAgV2ViS2l0Ogor ICAgICAgZGVmYXVsdDogMAorICAgIFdlYkNvcmU6CisgICAgICBkZWZhdWx0OiAwCisKIFNhbnNT ZXJpZkZvbnRGYW1pbHk6CiAgIHR5cGU6IFN0cmluZwogICB3ZWJLaXRMZWdhY3lQcmVmZXJlbmNl S2V5OiBXZWJLaXRTYW5zU2VyaWZGb250CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1NjcmlwdHMv UHJlZmVyZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRlcm5hbC55YW1sIGIvU291cmNlL1dURi9TY3Jp cHRzL1ByZWZlcmVuY2VzL1dlYlByZWZlcmVuY2VzSW50ZXJuYWwueWFtbAppbmRleCAyMDVmMzJh NGM3YTFlN2VmY2VmNjBkYzZjNzM5NmYwNTE1YjZkNTBiLi45ZjQ4MTE3ZWVhOGM2MzBkZGI2YjI3 MDFlZGI5MmMwODFlNjQwNTI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1NjcmlwdHMvUHJlZmVy ZW5jZXMvV2ViUHJlZmVyZW5jZXNJbnRlcm5hbC55YW1sCisrKyBiL1NvdXJjZS9XVEYvU2NyaXB0 cy9QcmVmZXJlbmNlcy9XZWJQcmVmZXJlbmNlc0ludGVybmFsLnlhbWwKQEAgLTc1MCw2ICs3NTAs MTggQEAgVXNlR1BVUHJvY2Vzc0ZvcldlYkdMRW5hYmxlZDoKICAgICBXZWJLaXQ6CiAgICAgICBk ZWZhdWx0OiBkZWZhdWx0VXNlR1BVUHJvY2Vzc0ZvcldlYkdMRW5hYmxlZCgpCiAKK1VzZVNhbXBs ZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yOgorICB0eXBlOiBib29s CisgIGh1bWFuUmVhZGFibGVOYW1lOiAiVXNlIHNhbXBsZWQgcGFnZSB0b3AgY29sb3IgZm9yIHNj cm9sbCBhcmVhIGJhY2tncm91bmQgY29sb3IiCisgIGh1bWFuUmVhZGFibGVEZXNjcmlwdGlvbjog IlVzZSBzYW1wbGVkIHBhZ2UgdG9wIGNvbG9yIGZvciBzY3JvbGwgYXJlYSBiYWNrZ3JvdW5kIGNv bG9yIgorICBkZWZhdWx0VmFsdWU6CisgICAgV2ViS2l0TGVnYWN5OgorICAgICAgZGVmYXVsdDog ZmFsc2UKKyAgICBXZWJLaXQ6CisgICAgICBkZWZhdWx0OiBmYWxzZQorICAgIFdlYkNvcmU6Cisg ICAgICBkZWZhdWx0OiBmYWxzZQorCiBVc2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91 bmRDb2xvcjoKICAgdHlwZTogYm9vbAogICBodW1hblJlYWRhYmxlTmFtZTogIlVzZSB0aGVtZS1j b2xvciBmb3Igc2Nyb2xsIGFyZWEgYmFja2dyb3VuZCBjb2xvciIKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQu Y3BwCmluZGV4IDJhZTNjM2RlYjkxMGExN2NmYjg5N2ZlZTBmNzRkYmYxOWVhYWE2N2MuLmI0MjJh YjZkMTlhYWEwMDIyMzFiMGQxZmE3MzE1YjA2ZmNjN2Y1MDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmNwcApAQCAtODIsNiArODIsNyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJh bWVMb2FkZXIuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5oIgorI2luY2x1ZGUgIkZy YW1lU25hcHNob3R0aW5nLmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCiAjaW5jbHVkZSAiRnVs bHNjcmVlbk1hbmFnZXIuaCIKICNpbmNsdWRlICJHQ1JlYWNoYWJsZVJlZi5oIgpAQCAtMTIzLDYg KzEyNCw3IEBACiAjaW5jbHVkZSAiSURCT3BlbkRCUmVxdWVzdC5oIgogI2luY2x1ZGUgIklkbGVD YWxsYmFja0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJJbWFnZUJpdG1hcFJlbmRlcmluZ0NvbnRl eHQuaCIKKyNpbmNsdWRlICJJbWFnZUJ1ZmZlci5oIgogI2luY2x1ZGUgIkltYWdlTG9hZGVyLmgi CiAjaW5jbHVkZSAiSW1hZ2VPdmVybGF5Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIkluc3BlY3Rv ckluc3RydW1lbnRhdGlvbi5oIgpAQCAtMzI3Niw2ICszMjc4LDggQEAgdm9pZCBEb2N1bWVudDo6 ZW5xdWV1ZVBhaW50VGltaW5nRW50cnlJZk5lZWRlZCgpCiAKICAgICBkb21XaW5kb3coKS0+cGVy Zm9ybWFuY2UoKS5yZXBvcnRGaXJzdENvbnRlbnRmdWxQYWludCgpOwogICAgIG1fZGlkRW5xdWV1 ZUZpcnN0Q29udGVudGZ1bFBhaW50ID0gdHJ1ZTsKKworICAgIGRldGVybWluZVNhbXBsZWRQYWdl VG9wQ29sb3IoKTsKIH0KIAogRXhjZXB0aW9uT3I8dm9pZD4gRG9jdW1lbnQ6OndyaXRlKERvY3Vt ZW50KiByZXNwb25zaWJsZURvY3VtZW50LCBTZWdtZW50ZWRTdHJpbmcmJiB0ZXh0KQpAQCAtMzg3 OSw2ICszODgzLDE0MCBAQCB2b2lkIERvY3VtZW50Ojp0aGVtZUNvbG9yQ2hhbmdlZCgpCiAjZW5k aWYgLy8gRU5BQkxFKFJVQkJFUl9CQU5ESU5HKQogfQogCitzdGF0aWMgZG91YmxlIGNvbG9yRGlm ZmVyZW5jZShMYWI8ZmxvYXQ+JiBsaHMsIExhYjxmbG9hdD4mIHJocykKK3sKKyAgICByZXR1cm4g c3FydChwb3cocmhzLmxpZ2h0bmVzcyAtIGxocy5saWdodG5lc3MsIDIpICsgcG93KHJocy5hIC0g bGhzLmEsIDIpICsgcG93KHJocy5iIC0gbGhzLmIsIDIpKTsKK30KKworc3RhdGljIExhYjxmbG9h dD4gYXZlcmFnZUNvbG9yKExhYjxmbG9hdD4gY29sb3JzW10sIHNpemVfdCBjb3VudCkKK3sKKyAg ICBmbG9hdCB0b3RhbExpZ2h0bmVzcyA9IDA7CisgICAgZmxvYXQgdG90YWxBID0gMDsKKyAgICBm bG9hdCB0b3RhbEIgPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkg eworICAgICAgICB0b3RhbExpZ2h0bmVzcyArPSBjb2xvcnNbaV0ubGlnaHRuZXNzOworICAgICAg ICB0b3RhbEEgKz0gY29sb3JzW2ldLmE7CisgICAgICAgIHRvdGFsQiArPSBjb2xvcnNbaV0uYjsK KyAgICB9CisgICAgcmV0dXJuIHsKKyAgICAgICAgdG90YWxMaWdodG5lc3MgLyBjb3VudCwKKyAg ICAgICAgdG90YWxBIC8gY291bnQsCisgICAgICAgIHRvdGFsQiAvIGNvdW50LAorICAgICAgICAx LAorICAgIH07Cit9CisKK3ZvaWQgRG9jdW1lbnQ6OmRldGVybWluZVNhbXBsZWRQYWdlVG9wQ29s b3IoKQoreworICAgIGlmIChtX3NhbXBsZWRQYWdlVG9wQ29sb3IuaXNWYWxpZCgpKQorICAgICAg ICByZXR1cm47CisKKyAgICBhdXRvIG1heERpZmZlcmVuY2UgPSBzZXR0aW5ncygpLnNhbXBsZWRQ YWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlKCk7CisgICAgaWYgKG1heERpZmZlcmVuY2UgPD0gMCkK KyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFpc1RvcERvY3VtZW50KCkpCisgICAgICAgIHJl dHVybjsKKworICAgIGF1dG8qIGZyYW1lVmlldyA9IHZpZXcoKTsKKyAgICBpZiAoIWZyYW1lVmll dykKKyAgICAgICAgcmV0dXJuOworCisgICAgYXV0byBub3RpZnlEaWRTYW1wbGVQYWdlVG9wQ29s b3JPblNjb3BlRXhpdCA9IG1ha2VTY29wZUV4aXQoWyZdIHsKKyAgICAgICAgaWYgKGF1dG8qIHBh Z2UgPSB0aGlzLT5wYWdlKCkpCisgICAgICAgICAgICBwYWdlLT5jaHJvbWUoKS5jbGllbnQoKS5k aWRTYW1wbGVQYWdlVG9wQ29sb3IoKTsKKyAgICB9KTsKKworICAgIC8vIEZJWE1FOiA8aHR0cHM6 Ly93ZWJraXQub3JnL2IvMjI1MTY3PiAoU2FtcGxlZCBQYWdlIFRvcCBDb2xvcjogaG9vayBpbnRv IHBhaW50aW5nIGxvZ2ljIGluc3RlYWQgb2YgdGFraW5nIHNuYXBzaG90cykKKyAgICBhdXRvIHBp eGVsQ29sb3JBdFRvcFggPSBbJl0gKGludCB4KSAtPiBPcHRpb25hbDxMYWI8ZmxvYXQ+PiB7Cisg ICAgICAgIEludFBvaW50IGxvY2F0aW9uKHgsIDApOworICAgICAgICBJbnRTaXplIHNpemUoMSwg MSk7CisKKyAgICAgICAgaWYgKGlzSGl0VGVzdExvY2F0aW9uVGhpcmRQYXJ0eUZyYW1lKExheW91 dFBvaW50KGxvY2F0aW9uKSkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisg ICAgICAgIGF1dG8gc25hcHNob3QgPSBzbmFwc2hvdEZyYW1lUmVjdChmcmFtZVZpZXctPmZyYW1l KCksIEludFJlY3QobG9jYXRpb24sIHNpemUpLCBTbmFwc2hvdE9wdGlvbnNFeGNsdWRlU2VsZWN0 aW9uSGlnaGxpZ2h0aW5nIHwgU25hcHNob3RPcHRpb25zUGFpbnRFdmVyeXRoaW5nRXhjbHVkaW5n U2VsZWN0aW9uKTsKKyAgICAgICAgaWYgKCFzbmFwc2hvdCkKKyAgICAgICAgICAgIHJldHVybiBX VEY6Om51bGxvcHQ7CisKKyAgICAgICAgYXV0byBzbmFwc2hvdERhdGEgPSBzbmFwc2hvdC0+dG9C R1JBRGF0YSgpOworICAgICAgICByZXR1cm4gY29udmVydENvbG9yPExhYjxmbG9hdD4+KFNSR0JB PHVpbnQ4X3Q+IHsgc25hcHNob3REYXRhWzJdLCBzbmFwc2hvdERhdGFbMV0sIHNuYXBzaG90RGF0 YVswXSwgc25hcHNob3REYXRhWzNdIH0pOworICAgIH07CisKKyAgICAvLyBEZWNyZWFzZSB0aGUg d2lkdGggYnkgb25lIHBpeGVsIHNvIHRoYXQgdGhlIGxhc3Qgc25hcHNob3QgaXMgd2l0aGluIGJv dW5kcyBhbmQgbm90IG9mZi1ieS1vbmUuCisgICAgYXV0byBmcmFtZVdpZHRoID0gZnJhbWVWaWV3 LT5jb250ZW50c1dpZHRoKCkgLSAxOworCisgICAgY29uc3RleHByIGF1dG8gbnVtU25hcHNob3Rz ID0gNTsKKyAgICBzaXplX3Qgbm9uTWF0Y2hpbmdDb2xvckluZGV4ID0gbnVtU25hcHNob3RzOwor CisgICAgTGFiPGZsb2F0PiBzbmFwc2hvdHNbbnVtU25hcHNob3RzXTsKKyAgICBkb3VibGUgZGlm ZmVyZW5jZXNbbnVtU25hcHNob3RzIC0gMV07CisKKyAgICBhdXRvIHNob3VsZFN0b3BBZnRlckZp bmRpbmdOb25NYXRjaGluZ0NvbG9yID0gWyZdIChzaXplX3QgaSkgLT4gYm9vbCB7CisgICAgICAg IC8vIEJhaWwgaWYgdGhlIG5vbi1tYXRjaGluZyBjb2xvciBpcyBub3QgdGhlIGZpcnN0IG9yIGxh c3Qgc25hcHNob3QsIG9yIHRoZXJlIGFscmVhZHkgaXMgYW4gbm9uLW1hdGNoaW5nIGNvbG9yLgor ICAgICAgICBpZiAoKGkgJiYgaSA8IG51bVNuYXBzaG90cyAtIDEpIHx8IG5vbk1hdGNoaW5nQ29s b3JJbmRleCAhPSBudW1TbmFwc2hvdHMpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAg ICAgICBub25NYXRjaGluZ0NvbG9ySW5kZXggPSBpOworICAgICAgICByZXR1cm4gZmFsc2U7Cisg ICAgfTsKKworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbnVtU25hcHNob3RzOyArK2kpIHsK KyAgICAgICAgYXV0byBzbmFwc2hvdCA9IHBpeGVsQ29sb3JBdFRvcFgoZnJhbWVXaWR0aCAqIGkg LyAobnVtU25hcHNob3RzIC0gMSkpOworICAgICAgICBpZiAoIXNuYXBzaG90ICYmICFzaG91bGRT dG9wQWZ0ZXJGaW5kaW5nTm9uTWF0Y2hpbmdDb2xvcihpKSkKKyAgICAgICAgICAgIHJldHVybjsK KworICAgICAgICBzbmFwc2hvdHNbaV0gPSAqc25hcHNob3Q7CisKKyAgICAgICAgaWYgKGkpIHsK KyAgICAgICAgICAgIC8vIEVhY2ggYGRpZmZlcmVuY2VgIGl0ZW0gY29tcGFyZXMgYGlgIHdpdGgg YGkgLSAxYCBzbyBpZiB0aGUgZmlyc3QgY29tcGFyaXNvbiAoYGkgPT0gMWApCisgICAgICAgICAg ICAvLyBpcyB0b28gbGFyZ2Ugb2YgYSBkaWZmZXJlbmNlLCB3ZSBzaG91bGQgdHJlYXQgYGkgLSAx YCAoaS5lLiBgMGApIGFzIHRoZSBwcm9ibGVtIHNpbmNlCisgICAgICAgICAgICAvLyB3ZSBvbmx5 IGFsbG93IGZvciBub24tbWF0Y2hpbmcgY29sb3JzIGJlaW5nIHRoZSBmaXJzdCBvciBsYXN0IHNh bXBsZWQgY29sb3IuCisgICAgICAgICAgICBhdXRvIGVmZmVjdGl2ZU5vbk1hdGNoaW5nQ29sb3JJ bmRleCA9IGkgPT0gMSA/IDAgOiBpOworCisgICAgICAgICAgICBkaWZmZXJlbmNlc1tpIC0gMV0g PSBjb2xvckRpZmZlcmVuY2Uoc25hcHNob3RzW2kgLSAxXSwgc25hcHNob3RzW2ldKTsKKyAgICAg ICAgICAgIGlmIChkaWZmZXJlbmNlc1tpIC0gMV0gPiBtYXhEaWZmZXJlbmNlKSB7CisgICAgICAg ICAgICAgICAgaWYgKHNob3VsZFN0b3BBZnRlckZpbmRpbmdOb25NYXRjaGluZ0NvbG9yKGVmZmVj dGl2ZU5vbk1hdGNoaW5nQ29sb3JJbmRleCkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAg ZG91YmxlIGN1bXVsdWF0aXZlRGlmZmVyZW5jZSA9IDA7CisgICAgICAgICAgICBmb3IgKHNpemVf dCBqID0gMDsgaiA8IGk7ICsraikgeworICAgICAgICAgICAgICAgIGlmIChqID09IG5vbk1hdGNo aW5nQ29sb3JJbmRleCkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAg ICAgICAgY3VtdWx1YXRpdmVEaWZmZXJlbmNlICs9IGRpZmZlcmVuY2VzW2pdOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgaWYgKGN1bXVsdWF0aXZlRGlmZmVyZW5jZSA+IG1heERpZmZlcmVu Y2UpIHsKKyAgICAgICAgICAgICAgICBpZiAoc2hvdWxkU3RvcEFmdGVyRmluZGluZ05vbk1hdGNo aW5nQ29sb3IoZWZmZWN0aXZlTm9uTWF0Y2hpbmdDb2xvckluZGV4KSkgeworICAgICAgICAgICAg ICAgICAgICAvLyBJZiB3ZSBoYXZlbid0IGFscmVhZHkgaWRlbnRpZmllZCBhIG5vbi1tYXRjaGlu ZyBzbmFwc2hvdCBhbmQgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgZmlyc3QKKyAgICAgICAg ICAgICAgICAgICAgLy8gYW5kIHNlY29uZCBzbmFwc2hvdHMgb3IgdGhlIHNlY29uZC10by1sYXN0 IGFuZCBsYXN0IHNuYXBzaG90cyBpcyBsZXNzIHRoYW4gdGhlIG1heGltdW0sIG1hcmsKKyAgICAg ICAgICAgICAgICAgICAgLy8gdGhlIGZpcnN0L2xhc3Qgc25hcHNob3QgYXMgbm9uLW1hdGNoaW5n IHRvIGdpdmUgYSBjaGFuY2UgZm9yIHRoZSByZXN0IG9mIHRoZSBzbmFwc2hvdHMgdG8gbWF0Y2gu CisgICAgICAgICAgICAgICAgICAgIGlmIChub25NYXRjaGluZ0NvbG9ySW5kZXggPT0gbnVtU25h cHNob3RzICYmICghaSB8fCBpID09IG51bVNuYXBzaG90cyAtIDEpICYmIGN1bXVsdWF0aXZlRGlm ZmVyZW5jZSAtIGRpZmZlcmVuY2VzW2kgLSAxXSA8PSBtYXhEaWZmZXJlbmNlKSB7CisgICAgICAg ICAgICAgICAgICAgICAgICBub25NYXRjaGluZ0NvbG9ySW5kZXggPSBlZmZlY3RpdmVOb25NYXRj aGluZ0NvbG9ySW5kZXg7CisgICAgICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAgICAg ICB9CisgICAgfQorCisgICAgYXV0byBzbmFwc2hvdHNUb0F2ZXJhZ2UgPSBzbmFwc2hvdHM7Cisg ICAgYXV0byB2YWxpZFNuYXBzaG90Q291bnQgPSBudW1TbmFwc2hvdHM7CisgICAgaWYgKCFub25N YXRjaGluZ0NvbG9ySW5kZXgpIHsKKyAgICAgICAgLy8gU2tpcCB0aGUgZmlyc3Qgc25hcHNob3Qg YnkgbW92aW5nIHRoZSBwb2ludGVyIHRoYXQgaW5kaWNhdGVzIHdoZXJlIHRoZSBzbmFwc2hvdCBh cnJheQorICAgICAgICAvLyBzdGFydHMgYW5kIGRlY3JlYXNpbmcgdGhlIGNvdW50IG9mIHNuYXBz aG90cyB0byBhdmVyYWdlLgorICAgICAgICArK3NuYXBzaG90c1RvQXZlcmFnZTsKKyAgICAgICAg LS12YWxpZFNuYXBzaG90Q291bnQ7CisgICAgfSBlbHNlIGlmIChub25NYXRjaGluZ0NvbG9ySW5k ZXggPT0gbnVtU25hcHNob3RzIC0gMSkgeworICAgICAgICAvLyBTa2lwIHRoZSBsYXN0IHNuYXBz aG90IGJ5IGRlY3JlYXNpbmcgdGhlIGNvdW50IG9mIHNuYXBzaG90cyB0byBhdmVyYWdlLgorICAg ICAgICAtLXZhbGlkU25hcHNob3RDb3VudDsKKyAgICB9CisgICAgbV9zYW1wbGVkUGFnZVRvcENv bG9yID0gYXZlcmFnZUNvbG9yKHNuYXBzaG90c1RvQXZlcmFnZSwgdmFsaWRTbmFwc2hvdENvdW50 KTsKK30KKwogI2lmIEVOQUJMRShEQVJLX01PREVfQ1NTKQogc3RhdGljIHZvaWQgcHJvY2Vzc0Nv bG9yU2NoZW1lU3RyaW5nKFN0cmluZ1ZpZXcgY29sb3JTY2hlbWUsIGNvbnN0IFdURjo6RnVuY3Rp b248dm9pZChTdHJpbmdWaWV3IGtleSk+JiBjYWxsYmFjaykKIHsKQEAgLTg2MDgsNiArODc0Niwy MiBAQCBib29sIERvY3VtZW50OjpoaXRUZXN0KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiByZXF1ZXN0 LCBjb25zdCBIaXRUZXN0TG9jYXRpb24mIGxvYwogICAgIHJldHVybiByZXN1bHRMYXllcjsKIH0K IAorYm9vbCBEb2N1bWVudDo6aXNIaXRUZXN0TG9jYXRpb25UaGlyZFBhcnR5RnJhbWUoY29uc3Qg SGl0VGVzdExvY2F0aW9uJiBsb2NhdGlvbikKK3sKKyAgICBjb25zdGV4cHIgT3B0aW9uU2V0PEhp dFRlc3RSZXF1ZXN0OjpSZXF1ZXN0VHlwZT4gaGl0VGVzdFJlcXVlc3RUeXBlcyB7IEhpdFRlc3RS ZXF1ZXN0OjpSZWFkT25seSwgSGl0VGVzdFJlcXVlc3Q6OkRpc2FsbG93VXNlckFnZW50U2hhZG93 Q29udGVudCB9OworICAgIEhpdFRlc3RSZXN1bHQgaGl0VGVzdFJlc3VsdChsb2NhdGlvbik7Cisg ICAgaGl0VGVzdChoaXRUZXN0UmVxdWVzdFR5cGVzLCBoaXRUZXN0UmVzdWx0KTsKKworICAgIGF1 dG8gaGl0VGVzdE5vZGUgPSBtYWtlUmVmUHRyKGhpdFRlc3RSZXN1bHQuaW5uZXJOb2RlKCkpOwor ICAgIGlmICghaGl0VGVzdE5vZGUpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICgh aXM8SFRNTElGcmFtZUVsZW1lbnQ+KGhpdFRlc3ROb2RlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNl OworCisgICAgcmV0dXJuIGFyZVJlZ2lzdHJhYmxlRG9tYWluc0VxdWFsKGRvd25jYXN0PEhUTUxJ RnJhbWVFbGVtZW50PigqaGl0VGVzdE5vZGUpLmxvY2F0aW9uKCksIG1fdXJsKTsKK30KKwogRWxl bWVudElkZW50aWZpZXIgRG9jdW1lbnQ6OmlkZW50aWZpZXJGb3JFbGVtZW50KEVsZW1lbnQmIGVs ZW1lbnQpCiB7CiAgICAgQVNTRVJUKCZlbGVtZW50LmRvY3VtZW50KCkgPT0gdGhpcyk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9Eb2N1bWVudC5oCmluZGV4IDA4ZjBhMDU2ZDE4NTE0MWRhZDM2YjY1Y2Q5YmQzY2I0NmUwOTcz M2MuLjIyNzVjYzVmZGUxNDcxOWE0MzM4ZmYxOTJlYTYyODk5ODE0MDBmYmYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5oCkBAIC03NDMsNiArNzQzLDggQEAgcHVibGljOgogCiAgICAgY29uc3QgQ29sb3Im IHRoZW1lQ29sb3IoKSBjb25zdCB7IHJldHVybiBtX21ldGFFbGVtZW50VGhlbWVDb2xvci5pc1Zh bGlkKCkgPyBtX21ldGFFbGVtZW50VGhlbWVDb2xvciA6IG1fYXBwbGljYXRpb25NYW5pZmVzdFRo ZW1lQ29sb3I7IH0KIAorICAgIGNvbnN0IENvbG9yJiBzYW1wbGVkUGFnZVRvcENvbG9yKCkgY29u c3QgeyByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9yOyB9CisKICAgICB2b2lkIHNldFRleHRD b2xvcihjb25zdCBDb2xvciYgY29sb3IpIHsgbV90ZXh0Q29sb3IgPSBjb2xvcjsgfQogICAgIGNv bnN0IENvbG9yJiB0ZXh0Q29sb3IoKSBjb25zdCB7IHJldHVybiBtX3RleHRDb2xvcjsgfQogCkBA IC0xNTY2LDYgKzE1NjgsNyBAQCBwdWJsaWM6CiAKICAgICBXRUJDT1JFX0VYUE9SVCBib29sIGhp dFRlc3QoY29uc3QgSGl0VGVzdFJlcXVlc3QmLCBIaXRUZXN0UmVzdWx0Jik7CiAgICAgYm9vbCBo aXRUZXN0KGNvbnN0IEhpdFRlc3RSZXF1ZXN0JiwgY29uc3QgSGl0VGVzdExvY2F0aW9uJiwgSGl0 VGVzdFJlc3VsdCYpOworICAgIGJvb2wgaXNIaXRUZXN0TG9jYXRpb25UaGlyZFBhcnR5RnJhbWUo Y29uc3QgSGl0VGVzdExvY2F0aW9uJik7CiAjaWYgQVNTRVJUX0VOQUJMRUQKICAgICBib29sIGlu SGl0VGVzdGluZygpIGNvbnN0IHsgcmV0dXJuIG1faW5IaXRUZXN0aW5nOyB9CiAjZW5kaWYKQEAg LTE2NzcsNiArMTY4MCw4IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHRoZW1lQ29sb3JDaGFuZ2Vk KCk7CiAKKyAgICB2b2lkIGRldGVybWluZVNhbXBsZWRQYWdlVG9wQ29sb3IoKTsKKwogICAgIHZv aWQgaW52YWxpZGF0ZUFjY2Vzc0tleUNhY2hlU2xvd0Nhc2UoKTsKICAgICB2b2lkIGJ1aWxkQWNj ZXNzS2V5Q2FjaGUoKTsKIApAQCAtMTgwMCw2ICsxODA1LDggQEAgcHJpdmF0ZToKICAgICBDb2xv ciBtX21ldGFFbGVtZW50VGhlbWVDb2xvcjsKICAgICBDb2xvciBtX2FwcGxpY2F0aW9uTWFuaWZl c3RUaGVtZUNvbG9yOwogCisgICAgQ29sb3IgbV9zYW1wbGVkUGFnZVRvcENvbG9yOworCiAgICAg Q29sb3IgbV90ZXh0Q29sb3IgeyBDb2xvcjo6YmxhY2sgfTsKICAgICBDb2xvciBtX2xpbmtDb2xv cjsKICAgICBDb2xvciBtX3Zpc2l0ZWRMaW5rQ29sb3I7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0Nocm9tZUNsaWVudC5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9DaHJvbWVDbGll bnQuaAppbmRleCBjZjE2YWU2ZWE0NzViYmZjNmI1OWU0NDMyNzQ0YjM5NTBiODFhMDg2Li5lZDhj ZjQwMzIxMGUxMGVhNmQ3NGQ4N2I1OTY5ZTM3MjZkZmFhNzVjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0Nocm9tZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2hy b21lQ2xpZW50LmgKQEAgLTIzMyw2ICsyMzMsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZv aWQgdGhlbWVDb2xvckNoYW5nZWQoKSBjb25zdCB7IH0KICAgICB2aXJ0dWFsIHZvaWQgcGFnZUV4 dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCkgY29uc3QgeyB9CisgICAgdmlydHVhbCB2 b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpIGNvbnN0IHsgfQogCiAgICAgdmlydHVhbCB2b2lk IGV4Y2VlZGVkRGF0YWJhc2VRdW90YShGcmFtZSYsIGNvbnN0IFN0cmluZyYgZGF0YWJhc2VOYW1l LCBEYXRhYmFzZURldGFpbHMpID0gMDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFn ZS9QYWdlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKaW5kZXggNzliYWE4M2I0 OTc3ZDJhN2Q4Zjg5NGEyN2MyZmI2YWQyM2IyMDg0YS4uMzNjMzk0YWQ3OTgyNjQ4N2U0Njc0YjAz N2YxNDk0ODU4ZjlkYmM3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCkBAIC0yNTU0LDYgKzI1NTQsMTUg QEAgQ29sb3IgUGFnZTo6cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yKCkgY29uc3QKICAgICBy ZXR1cm4gcmVuZGVyVmlldy0+Y29tcG9zaXRvcigpLnJvb3RFeHRlbmRlZEJhY2tncm91bmRDb2xv cigpOwogfQogCitDb2xvciBQYWdlOjpzYW1wbGVkUGFnZVRvcENvbG9yKCkgY29uc3QKK3sKKyAg ICBhdXRvKiBkb2N1bWVudCA9IG1haW5GcmFtZSgpLmRvY3VtZW50KCk7CisgICAgaWYgKCFkb2N1 bWVudCkKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAgIHJldHVybiBkb2N1bWVudC0+c2FtcGxl ZFBhZ2VUb3BDb2xvcigpOworfQorCiAvLyBUaGVzZSBhcmUgbWFnaWNhbCBjb25zdGFudHMgdGhh dCBtaWdodCBiZSB0d2Vha2VkIG92ZXIgdGltZS4KIHN0YXRpYyBjb25zdCBkb3VibGUgZ01pbmlt dW1QYWludGVkQXJlYVJhdGlvID0gMC4xOwogc3RhdGljIGNvbnN0IGRvdWJsZSBnTWF4aW11bVVu cGFpbnRlZEFyZWFSYXRpbyA9IDAuMDQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdl L1BhZ2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCmluZGV4IDZiNzZjYzExNThjM2Y2 YTQ0MDg3MDQwOWYxM2YwZjcyMjE5ODMyMzQuLjNiZjAzOGE3ZWQzMGQ0OTg4MzUyOTU4YTkwNjAw NmQxYzMyNjBjZWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5oCkBAIC02MjEsNiArNjIxLDcgQEAgcHVibGljOgog CiAgICAgV0VCQ09SRV9FWFBPUlQgQ29sb3IgdGhlbWVDb2xvcigpIGNvbnN0OwogICAgIFdFQkNP UkVfRVhQT1JUIENvbG9yIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNvbnN0OworICAg IFdFQkNPUkVfRVhQT1JUIENvbG9yIHNhbXBsZWRQYWdlVG9wQ29sb3IoKSBjb25zdDsKIAogICAg IGJvb2wgaXNDb3VudGluZ1JlbGV2YW50UmVwYWludGVkT2JqZWN0cygpIGNvbnN0OwogICAgIHZv aWQgc2V0SXNDb3VudGluZ1JlbGV2YW50UmVwYWludGVkT2JqZWN0cyhib29sIGlzQ291bnRpbmcp IHsgbV9pc0NvdW50aW5nUmVsZXZhbnRSZXBhaW50ZWRPYmplY3RzID0gaXNDb3VudGluZzsgfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxheWVyQ29tcG9zaXRv ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNw cAppbmRleCBiNDIzYjE5MTdmNzc5MWI2ZjU5Zjg5ZjI4NmM0NDg5YTIzNTQ4OTAwLi5mODc3NDU3 MmI0YjUyZTRhYTc5MWZjODdiZjg1MmIwNmZjYzJlMjFjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyTGF5ZXJDb21wb3NpdG9yLmNwcApAQCAtMzkyNiw2ICszOTI2 LDggQEAgdm9pZCBSZW5kZXJMYXllckNvbXBvc2l0b3I6OnVwZGF0ZUxheWVyRm9yT3ZlcmhhbmdB cmVhc0JhY2tncm91bmRDb2xvcigpCiAgICAgQ29sb3IgYmFja2dyb3VuZENvbG9yOwogICAgIGlm IChwYWdlKCkuc2V0dGluZ3MoKS51c2VUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvcigpKQogICAgICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkudGhlbWVDb2xvcigpOwor ICAgIGlmIChwYWdlKCkuc2V0dGluZ3MoKS51c2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xs QXJlYUJhY2tncm91bmRDb2xvcigpICYmICFiYWNrZ3JvdW5kQ29sb3IuaXNWYWxpZCgpKQorICAg ICAgICBiYWNrZ3JvdW5kQ29sb3IgPSBwYWdlKCkuc2FtcGxlZFBhZ2VUb3BDb2xvcigpOwogICAg IGlmICghYmFja2dyb3VuZENvbG9yLmlzVmFsaWQoKSkKICAgICAgICAgYmFja2dyb3VuZENvbG9y ID0gbV9yb290RXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3I7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXcubW0gYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3Lm1tCmluZGV4IDEzMzc5M2Y0MTI5MTAzNjcwNjdl NjRlMjM3YzcxNzc0ZjQyMzM3ODQuLjU0Yzg1ZWQ1NGE2YTJhZjAwM2RhY2Y0MDQ2ZGZhOWZhY2Nj Y2UwYTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dl YlZpZXcubW0KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmll dy5tbQpAQCAtNTU5LDYgKzU1OSw4IEBAIC0gKHZvaWQpX3NldHVwUGFnZUNvbmZpZ3VyYXRpb246 KFJlZjxBUEk6OlBhZ2VDb25maWd1cmF0aW9uPiYpcGFnZUNvbmZpZ3VyYXRpb24KICAgICBwYWdl Q29uZmlndXJhdGlvbi0+cHJlZmVyZW5jZXMoKS0+c2V0U2VydmljZVdvcmtlckVudGl0bGVtZW50 RGlzYWJsZWRGb3JUZXN0aW5nKCEhW19jb25maWd1cmF0aW9uIHByZWZlcmVuY2VzXS5fc2Vydmlj ZVdvcmtlckVudGl0bGVtZW50RGlzYWJsZWRGb3JUZXN0aW5nKTsKICNlbmRpZgogCisgICAgcGFn ZUNvbmZpZ3VyYXRpb24tPnByZWZlcmVuY2VzKCktPnNldFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhE aWZmZXJlbmNlKFtfY29uZmlndXJhdGlvbiBfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVu Y2VdKTsKKwogICAgIGlmICghbGlua2VkT25PckFmdGVyKFdlYkNvcmU6OlNES1ZlcnNpb246OkZp cnN0V2hlcmVTaXRlU3BlY2lmaWNRdWlya3NBcmVFbmFibGVkQnlEZWZhdWx0KSkKICAgICAgICAg cGFnZUNvbmZpZ3VyYXRpb24tPnByZWZlcmVuY2VzKCktPnNldE5lZWRzU2l0ZVNwZWNpZmljUXVp cmtzKGZhbHNlKTsKIH0KQEAgLTMwMzAsNiArMzAzMiwxNCBAQCAtIChDb2NvYUNvbG9yICopX3Bh Z2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcgogICAgIHJldHVybiBXZWJDb3JlOjpwbGF0Zm9ybUNv bG9yKHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcik7CiB9CiAKKy0gKENvY29hQ29sb3IgKilf c2FtcGxlZFBhZ2VUb3BDb2xvcgoreworICAgIGF1dG8gc2FtcGxlZFBhZ2VUb3BDb2xvciA9IF9w YWdlLT5zYW1wbGVkUGFnZVRvcENvbG9yKCk7CisgICAgaWYgKCFzYW1wbGVkUGFnZVRvcENvbG9y LmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIG5pbDsKKyAgICByZXR1cm4gV2ViQ29yZTo6cGxh dGZvcm1Db2xvcihzYW1wbGVkUGFnZVRvcENvbG9yKTsKK30KKwogLSAoaWQgPF9XS0lucHV0RGVs ZWdhdGU+KV9pbnB1dERlbGVnYXRlCiB7CiAgICAgcmV0dXJuIF9pbnB1dERlbGVnYXRlLmdldEF1 dG9yZWxlYXNlZCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0Nv Y29hL1dLV2ViVmlld0NvbmZpZ3VyYXRpb24ubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvQ29jb2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvbi5tbQppbmRleCBjNTAwOWI2ODg2ZjMxNmUw NGY4ZDg0YjgxNzY5ZmU4NTRmZGRkNTFkLi4xZWU5MzI1ZmVkOTBkOTI4ZDczZTJkYTkzYTRjNWQy MDcxNjg0YWZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tXZWJWaWV3Q29uZmlndXJhdGlvbi5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvQ29jb2EvV0tXZWJWaWV3Q29uZmlndXJhdGlvbi5tbQpAQCAtMTc3LDYgKzE3Nyw3IEBAIEBp bXBsZW1lbnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIHsKICNpZiBFTkFCTEUoQVBQX0hJ R0hMSUdIVFMpCiAgICAgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQ7CiAjZW5kaWYKKyAgICBk b3VibGUgX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlOwogCiAgICAgUmV0YWluUHRy PE5TU3RyaW5nPiBfbWVkaWFDb250ZW50VHlwZXNSZXF1aXJpbmdIYXJkd2FyZVN1cHBvcnQ7CiAg ICAgUmV0YWluUHRyPE5TQXJyYXk8TlNTdHJpbmcgKj4+IF9hZGRpdGlvbmFsU3VwcG9ydGVkSW1h Z2VUeXBlczsKQEAgLTI3NSw2ICsyNzYsOSBAQCAtIChpbnN0YW5jZXR5cGUpaW5pdAogI2lmIEVO QUJMRShBUFBfSElHSExJR0hUUykKICAgICBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQgPSBERUZBVUxU X1ZBTFVFX0ZPUl9BcHBIaWdobGlnaHRzRW5hYmxlZDsKICNlbmRpZgorCisgICAgX3NhbXBsZWRQ YWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlID0gREVGQVVMVF9WQUxVRV9GT1JfU2FtcGxlZFBhZ2VU b3BDb2xvck1heERpZmZlcmVuY2U7CisKICAgICByZXR1cm4gc2VsZjsKIH0KIApAQCAtNDUzLDYg KzQ1Nyw4IEBAIC0gKGlkKWNvcHlXaXRoWm9uZTooTlNab25lICopem9uZQogICAgIGNvbmZpZ3Vy YXRpb24tPl9hcHBIaWdobGlnaHRzRW5hYmxlZCA9IHNlbGYtPl9hcHBIaWdobGlnaHRzRW5hYmxl ZDsKICNlbmRpZgogCisgICAgY29uZmlndXJhdGlvbi0+X3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhE aWZmZXJlbmNlID0gc2VsZi0+X3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlOworCiAg ICAgcmV0dXJuIGNvbmZpZ3VyYXRpb247CiB9CiAKQEAgLTEyNzMsNiArMTI3OSwxNiBAQCAtICh2 b2lkKV9zZXRQcm9jZXNzRGlzcGxheU5hbWU6KE5TU3RyaW5nICopbHNEaXNwbGF5TmFtZQogICAg IF9wYWdlQ29uZmlndXJhdGlvbi0+c2V0UHJvY2Vzc0Rpc3BsYXlOYW1lKGxzRGlzcGxheU5hbWUp OwogfQogCistICh2b2lkKV9zZXRTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZTooZG91 YmxlKXZhbHVlCit7CisgICAgX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlID0gdmFs dWU7Cit9CisKKy0gKGRvdWJsZSlfc2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UKK3sK KyAgICByZXR1cm4gX3NhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlOworfQorCiBAZW5k CiAKIEBpbXBsZW1lbnRhdGlvbiBXS1dlYlZpZXdDb25maWd1cmF0aW9uIChXS0RlcHJlY2F0ZWQp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3 Q29uZmlndXJhdGlvblByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCmluZGV4IGVmNGQ0ZTIwYzE0ZGIyMTMz MzVhYTc2YjEzZDQ2YWE0NjY4YWM1MjIuLmYyOTc5ODA2NTk3ZDM5ZjBmMGE4N2E5NDcxOTFkNjQ0 NjE0OWUwMTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9X S1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdDb25maWd1cmF0aW9uUHJpdmF0ZS5oCkBAIC0xMjMsNiAr MTIzLDEwIEBAIHR5cGVkZWYgTlNfRU5VTShOU1VJbnRlZ2VyLCBfV0tEcmFnTGlmdERlbGF5KSB7 CiAKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCBzZXR0ZXI9X3NldEFwcEhpZ2hsaWdodHNFbmFibGVk OikgQk9PTCBfYXBwSGlnaGxpZ2h0c0VuYWJsZWQgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19N QUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKIAorLy8gVGhlIG1heGltdW0gTGFiIGNvbG9yIGRp ZmZlcmVuY2UgYWxsb3dlZCBiZXR3ZWVuIHR3byBjb25zZWN1dGl2ZSBwYWdlIHRvcCBzbmFwc2hv dHMuCisvLyBFeHBlY3RzIDAgKGRpc2FibGVzIHBhZ2UgdG9wIGNvbG9yIHNhbXBsaW5nIGVudGly ZWx5KSBvciBhbnkgcG9zaXRpdmUgbnVtYmVyLgorQHByb3BlcnR5IChub25hdG9taWMsIHNldHRl cj1fc2V0U2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2U6KSBkb3VibGUgX3NhbXBsZWRQ YWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoV0tfTUFDX1RC QSksIGlvcyhXS19JT1NfVEJBKSk7CisKIEBlbmQKIAogI2lmIFRBUkdFVF9PU19JUEhPTkUKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2 YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tXZWJWaWV3UHJpdmF0 ZS5oCmluZGV4IDU1ZDAxOWRlYWZiMmQyYmJhNDM3NGQ2MzUyZmU2NzM1NWJiMWY1NDguLmI3NTli ODdkNGFhMTRmYmQ5ODA5YmZhYTk1YzQ3M2E5OTJkNjRkMjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1dlYlZpZXdQcml2YXRlLmgKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLV2ViVmlld1ByaXZhdGUuaApAQCAtMzg0LDYg KzM4NCwxMyBAQCBmb3IgdGhpcyBwcm9wZXJ0eS4KIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFk b25seSkgTlNDb2xvciAqX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKICNlbmRpZgogCisv LyBPbmx5IHNldCBpZiBgLVtXS1dlYlZpZXdDb25maWd1cmF0aW9uIF9zYW1wbGVkUGFnZVRvcENv bG9yTWF4RGlmZmVyZW5jZV1gIGlzIGEgcG9zaXRpdmUgbnVtYmVyLgorI2lmIFRBUkdFVF9PU19J UEhPTkUKK0Bwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSkgVUlDb2xvciAqX3NhbXBsZWRQ YWdlVG9wQ29sb3IgV0tfQVBJX0FWQUlMQUJMRShpb3MoV0tfSU9TX1RCQSkpOworI2Vsc2UKK0Bw cm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSkgTlNDb2xvciAqX3NhbXBsZWRQYWdlVG9wQ29s b3IgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSk7CisjZW5kaWYKKwogLSAodm9p ZClfZ3JhbnRBY2Nlc3NUb0Fzc2V0U2VydmljZXMgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19N QUNfVEJBKSwgaW9zKDE0LjApKTsKIC0gKHZvaWQpX3Jldm9rZUFjY2Vzc1RvQXNzZXRTZXJ2aWNl cyBXS19BUElfQVZBSUxBQkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoMTQuMCkpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29h LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50SW1wbENvY29hLmgK aW5kZXggM2VmYzY4YTE2Yjg1ZDQ5MGU0OWU4YWVmM2MzYzMwZjMwYTY3MDFlNS4uYzg4YTNkNDIz MzkzMmZkMzU0MDNhNzAxNzMyYWJhNTJmZmRlYTliNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5oCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EuaApAQCAtNTUsNiArNTUsOCBA QCBwdWJsaWM6CiAgICAgdm9pZCB0aGVtZUNvbG9yRGlkQ2hhbmdlKCkgZmluYWw7CiAgICAgdm9p ZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JXaWxsQ2hhbmdlKCkgZmluYWw7CiAgICAgdm9p ZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSBmaW5hbDsKKyAgICB2b2lk IHNhbXBsZWRQYWdlVG9wQ29sb3JXaWxsQ2hhbmdlKCkgZmluYWw7CisgICAgdm9pZCBzYW1wbGVk UGFnZVRvcENvbG9yRGlkQ2hhbmdlKCkgZmluYWw7CiAgICAgdm9pZCBpc1BsYXlpbmdBdWRpb1dp bGxDaGFuZ2UoKSBmaW5hbDsKICAgICB2b2lkIGlzUGxheWluZ0F1ZGlvRGlkQ2hhbmdlKCkgZmlu YWw7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGll bnRJbXBsQ29jb2EubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9QYWdlQ2xpZW50 SW1wbENvY29hLm1tCmluZGV4IDI0NjhkYWNhN2YyMGRkOTY3ZWQ3MGQ0NTQ4OThmMGU4YWZhZWFj MzYuLmJkZjQzY2I3ZTY0MDdiZjcyY2E2NzdiYzliYjA3ZjAwNzFjNzZmNTUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1BhZ2VDbGllbnRJbXBsQ29jb2EubW0KKysr IGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvUGFnZUNsaWVudEltcGxDb2NvYS5tbQpA QCAtNjYsNiArNjYsMTYgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpwYWdlRXh0ZW5kZWRC YWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKQogICAgIFttX3dlYlZpZXcgZGlkQ2hhbmdlVmFsdWVG b3JLZXk6QCJfcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yIl07CiB9CiAKK3ZvaWQgUGFnZUNs aWVudEltcGxDb2NvYTo6c2FtcGxlZFBhZ2VUb3BDb2xvcldpbGxDaGFuZ2UoKQoreworICAgIFtt X3dlYlZpZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQYWdlVG9wQ29sb3IiXTsK K30KKwordm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjpzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hh bmdlKCkKK3sKKyAgICBbbV93ZWJWaWV3IGRpZENoYW5nZVZhbHVlRm9yS2V5OkAiX3NhbXBsZWRQ YWdlVG9wQ29sb3IiXTsKK30KKwogdm9pZCBQYWdlQ2xpZW50SW1wbENvY29hOjppc1BsYXlpbmdB dWRpb1dpbGxDaGFuZ2UoKQogewogICAgIFttX3dlYlZpZXcgd2lsbENoYW5nZVZhbHVlRm9yS2V5 Ok5TU3RyaW5nRnJvbVNlbGVjdG9yKEBzZWxlY3RvcihfaXNQbGF5aW5nQXVkaW8pKV07CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmggYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKaW5kZXggODYwMGI3Mjk0N2NkNTc5YTZmMTc2ZjQ2 YmYwOGNlMTgxN2ZhMDAzNC4uOWE5MzNlY2VkMDIxOTk0OWQxNWQxYWViZDliMThmYzk0MGEyOTVk MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCisrKyBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaApAQCAtNTA5LDYgKzUwOSw4IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgdGhlbWVDb2xvckRpZENoYW5nZSgpIHsgfQogICAg IHZpcnR1YWwgdm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JXaWxsQ2hhbmdlKCkgeyB9 CiAgICAgdmlydHVhbCB2b2lkIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgp IHsgfQorICAgIHZpcnR1YWwgdm9pZCBzYW1wbGVkUGFnZVRvcENvbG9yV2lsbENoYW5nZSgpIHsg fQorICAgIHZpcnR1YWwgdm9pZCBzYW1wbGVkUGFnZVRvcENvbG9yRGlkQ2hhbmdlKCkgeyB9CiAg ICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZUJhY2tncm91bmRDb2xvcigpID0gMDsKICAgICB2aXJ0 dWFsIHZvaWQgaXNQbGF5aW5nQXVkaW9XaWxsQ2hhbmdlKCkgPSAwOwogICAgIHZpcnR1YWwgdm9p ZCBpc1BsYXlpbmdBdWRpb0RpZENoYW5nZSgpID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkuY3BwCmluZGV4IDRjMTMyZjgxOTJhNGU1MTIwNDIyMzMzMjhmOWYyNmFiYzc5 MmNiYjMuLjUxNmM3M2Q1ODE4YmFhNGUxNjAxNWM0NTg2NDM4YzcwMTkzYzlkNTQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtMTkxNyw2ICsxOTE3LDkgQEAg Q29sb3IgV2ViUGFnZVByb3h5OjpzY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgY29uc3QKICAg ICBpZiAobV9wcmVmZXJlbmNlcy0+dXNlVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5k Q29sb3IoKSAmJiBtX3RoZW1lQ29sb3IuaXNWYWxpZCgpKQogICAgICAgICByZXR1cm4gbV90aGVt ZUNvbG9yOwogCisgICAgaWYgKG1fcHJlZmVyZW5jZXMtPnVzZVNhbXBsZWRQYWdlVG9wQ29sb3JG b3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgJiYgbV9zYW1wbGVkUGFnZVRvcENvbG9yLmlz VmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIG1fc2FtcGxlZFBhZ2VUb3BDb2xvcjsKKwogICAgIHJl dHVybiBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKIH0KIApAQCAtODUyMiw2ICs4NTI1 LDE2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRD aGFuZ2UoY29uc3QgQ29sb3ImIHBhZ2VFeHRlbmRlCiAgICAgcGFnZUNsaWVudCgpLnBhZ2VFeHRl bmRlZEJhY2tncm91bmRDb2xvckRpZENoYW5nZSgpOwogfQogCit2b2lkIFdlYlBhZ2VQcm94eTo6 ZGlkU2FtcGxlUGFnZVRvcENvbG9yKGNvbnN0IENvbG9yJiBzYW1wbGVkUGFnZVRvcENvbG9yKQor eworICAgIGlmIChtX3NhbXBsZWRQYWdlVG9wQ29sb3IgPT0gc2FtcGxlZFBhZ2VUb3BDb2xvcikK KyAgICAgICAgcmV0dXJuOworCisgICAgcGFnZUNsaWVudCgpLnNhbXBsZWRQYWdlVG9wQ29sb3JX aWxsQ2hhbmdlKCk7CisgICAgbV9zYW1wbGVkUGFnZVRvcENvbG9yID0gc2FtcGxlZFBhZ2VUb3BD b2xvcjsKKyAgICBwYWdlQ2xpZW50KCkuc2FtcGxlZFBhZ2VUb3BDb2xvckRpZENoYW5nZSgpOwor fQorCiAjaWYgRU5BQkxFKE5FVFNDQVBFX1BMVUdJTl9BUEkpCiB2b2lkIFdlYlBhZ2VQcm94eTo6 ZGlkRmFpbFRvSW5pdGlhbGl6ZVBsdWdpbihjb25zdCBTdHJpbmcmIG1pbWVUeXBlLCBjb25zdCBT dHJpbmcmIGZyYW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBhZ2VVUkxTdHJpbmcpCiB7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaCBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IDc1NmVhNTMxMGVmNWVhMGE5 Njc1NmQyMWFkNDUwOTJlZjc4MjBkMDUuLjBmYmE4MmU4N2FjZWI3NzdiYjhiNzA5MmFkNTliMGY1 M2Y5NmFjZTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCkBAIC02NjUs NiArNjY1LDggQEAgcHVibGljOgogICAgIC8vIHRoZSBtZXNzYWdlIGVudGlyZWx5LgogICAgIFdl YkNvcmU6OkNvbG9yIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcigpIGNvbnN0IHsgcmV0dXJu IG1fcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yOyB9CiAKKyAgICBXZWJDb3JlOjpDb2xvciBz YW1wbGVkUGFnZVRvcENvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9zYW1wbGVkUGFnZVRvcENvbG9y OyB9CisKICAgICBXZWJDb3JlOjpDb2xvciBzY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKCkgY29u c3Q7CiAKICAgICB2b2lkIHZpZXdXaWxsU3RhcnRMaXZlUmVzaXplKCk7CkBAIC0yMDk2LDYgKzIw OTgsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgZGlkQ2hhbmdlUGFnZUNvdW50KHVuc2lnbmVkKTsK ICAgICB2b2lkIHRoZW1lQ29sb3JDaGFuZ2VkKGNvbnN0IFdlYkNvcmU6OkNvbG9yJik7CiAgICAg dm9pZCBwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoY29uc3QgV2ViQ29yZTo6 Q29sb3ImKTsKKyAgICB2b2lkIGRpZFNhbXBsZVBhZ2VUb3BDb2xvcihjb25zdCBXZWJDb3JlOjpD b2xvciYpOwogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVHSU5fQVBJKQogICAgIHZvaWQgZGlkRmFp bFRvSW5pdGlhbGl6ZVBsdWdpbihjb25zdCBTdHJpbmcmIG1pbWVUeXBlLCBjb25zdCBTdHJpbmcm IGZyYW1lVVJMU3RyaW5nLCBjb25zdCBTdHJpbmcmIHBhZ2VVUkxTdHJpbmcpOwogICAgIHZvaWQg ZGlkQmxvY2tJbnNlY3VyZVBsdWdpblZlcnNpb24oY29uc3QgU3RyaW5nJiBtaW1lVHlwZSwgY29u c3QgU3RyaW5nJiBwbHVnaW5VUkxTdHJpbmcsIGNvbnN0IFN0cmluZyYgZnJhbWVVUkxTdHJpbmcs IGNvbnN0IFN0cmluZyYgcGFnZVVSTFN0cmluZywgYm9vbCByZXBsYWNlbWVudE9ic2N1cmVkKTsK QEAgLTI2NDEsNiArMjY0NCw3IEBAIHByaXZhdGU6CiAgICAgV2ViQ29yZTo6Q29sb3IgbV90aGVt ZUNvbG9yOwogICAgIFdlYkNvcmU6OkNvbG9yIG1fdW5kZXJsYXlDb2xvcjsKICAgICBXZWJDb3Jl OjpDb2xvciBtX3BhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvcjsKKyAgICBXZWJDb3JlOjpDb2xv ciBtX3NhbXBsZWRQYWdlVG9wQ29sb3I7CiAKICAgICBib29sIG1fdXNlRml4ZWRMYXlvdXQgeyBm YWxzZSB9OwogICAgIFdlYkNvcmU6OkludFNpemUgbV9maXhlZExheW91dFNpemU7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4gYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4KaW5kZXggMzZl MWY0NWU3OTYwNGQ1NjRlMmU4ODUwNWRkZDNiMzdhNDUzOGFlMC4uYjFiNWE2ZjRlZDhkYThmN2Iw MjlhYjdjYmFhMDA4NTJjM2UzZGJjMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbgpAQCAtNzksNiArNzksNyBAQCBtZXNzYWdlcyAtPiBX ZWJQYWdlUHJveHkgewogICAgIERpZENoYW5nZVBhZ2VDb3VudCh1bnNpZ25lZCBwYWdlQ291bnQp CiAgICAgVGhlbWVDb2xvckNoYW5nZWQoV2ViQ29yZTo6Q29sb3IgdGhlbWVDb2xvcikKICAgICBQ YWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoV2ViQ29yZTo6Q29sb3IgYmFja2dy b3VuZENvbG9yKQorICAgIERpZFNhbXBsZVBhZ2VUb3BDb2xvcihXZWJDb3JlOjpDb2xvciBzYW1w bGVkUGFnZVRvcENvbG9yKQogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVHSU5fQVBJKQogICAgIERp ZEZhaWxUb0luaXRpYWxpemVQbHVnaW4oU3RyaW5nIG1pbWVUeXBlLCBTdHJpbmcgZnJhbWVVUkxT dHJpbmcsIFN0cmluZyBwYWdlVVJMU3RyaW5nKQogICAgIERpZEJsb2NrSW5zZWN1cmVQbHVnaW5W ZXJzaW9uKFN0cmluZyBtaW1lVHlwZSwgU3RyaW5nIHBsdWdpblVSTFN0cmluZywgU3RyaW5nIGZy YW1lVVJMU3RyaW5nLCBTdHJpbmcgcGFnZVVSTFN0cmluZywgYm9vbCByZXBsYWNlbWVudE9ic2N1 cmVkKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkNocm9tZUNsaWVudC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1 cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcAppbmRleCAzZjViNjAzYzJjY2M4ZDE0YTMxYzEzNzQx NmZjZGE2ZWJjM2MxMjBmLi5hMzFlZTcyM2RlYjFkODcyNWRjODQ5Y2RlZDNiMjg0NGEzMmJlNzI3 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2Vi Q2hyb21lQ2xpZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1 cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmNwcApAQCAtMTE2NCw2ICsxMTY0LDExIEBAIHZvaWQgV2Vi Q2hyb21lQ2xpZW50OjpwYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKSBjb25z dAogICAgIG1fcGFnZS5wYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JEaWRDaGFuZ2UoKTsKIH0K IAordm9pZCBXZWJDaHJvbWVDbGllbnQ6OmRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpIGNvbnN0Cit7 CisgICAgbV9wYWdlLmRpZFNhbXBsZVBhZ2VUb3BDb2xvcigpOworfQorCiB2b2lkIFdlYkNocm9t ZUNsaWVudDo6d2hlZWxFdmVudEhhbmRsZXJzQ2hhbmdlZChib29sIGhhc0hhbmRsZXJzKQogewog ICAgIG1fcGFnZS53aGVlbEV2ZW50SGFuZGxlcnNDaGFuZ2VkKGhhc0hhbmRsZXJzKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJvbWVD bGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJDaHJv bWVDbGllbnQuaAppbmRleCAxZTM2MGUzMGQzNGE2MTI1MDJkYWI3YjIxNmIzNmU4ZTFiM2I5NjMy Li5mMGNhZDVjOGVlY2Q4NmRiM2U3MGE4MWMzYTU3YjljYzYwMDM1NjVmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViQ2hyb21lQ2xpZW50LmgK KysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkNocm9tZUNs aWVudC5oCkBAIC0zMzAsNiArMzMwLDcgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgdGhlbWVDb2xv ckNoYW5nZWQoKSBjb25zdCBmaW5hbDsKICAgICB2b2lkIHBhZ2VFeHRlbmRlZEJhY2tncm91bmRD b2xvckRpZENoYW5nZSgpIGNvbnN0IGZpbmFsOworICAgIHZvaWQgZGlkU2FtcGxlUGFnZVRvcENv bG9yKCkgY29uc3QgZmluYWw7CiAgICAgCiAgICAgdm9pZCB3aGVlbEV2ZW50SGFuZGxlcnNDaGFu Z2VkKGJvb2wpIGZpbmFsOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dl YlBhZ2UuY3BwCmluZGV4IDBmNmY5ODVjYzVhOWRiZmI4MDlkZmNlYzA0YjNkODliMjVmZGJkMWMu LjNiNjNiMWI2ODU4MGMwNDUwZDg3YjA0NzVmMDlkNWU1N2UxZDI2ZjQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCkBAIC02NDUzLDYgKzY0NTMsMTEg QEAgdm9pZCBXZWJQYWdlOjpmbHVzaFBlbmRpbmdQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JD aGFuZ2UoKQogICAgIHNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6UGFnZUV4dGVuZGVkQmFj a2dyb3VuZENvbG9yRGlkQ2hhbmdlKG1fcGFnZS0+cGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9y KCkpKTsKIH0KIAordm9pZCBXZWJQYWdlOjpkaWRTYW1wbGVQYWdlVG9wQ29sb3IoKQoreworICAg IHNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGlkU2FtcGxlUGFnZVRvcENvbG9yKG1fcGFn ZS0+c2FtcGxlZFBhZ2VUb3BDb2xvcigpKSk7Cit9CisKIHZvaWQgV2ViUGFnZTo6Zmx1c2hQZW5k aW5nRWRpdG9yU3RhdGVVcGRhdGUoKQogewogICAgIGlmICghbV9oYXNQZW5kaW5nRWRpdG9yU3Rh dGVVcGRhdGUpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9X ZWJQYWdlLmggYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgKaW5k ZXggMmQ3MjgyZjk1NjM4ZjE1MzQ4NjE0NTA1Y2ZjYzJmZGNiZjMzMDY0MC4uZjI1OTZiMTgzMmE4 NGU4ZGM0NTkyZjAxZjVlN2Q5NWUyNWIzOWFjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9X ZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2UuaApAQCAtMTI0MCw2ICsxMjQwLDggQEAgcHVibGljOgogICAgIHZv aWQgcGFnZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yRGlkQ2hhbmdlKCkgeyBtX3BlbmRpbmdQYWdl RXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JDaGFuZ2UgPSB0cnVlOyB9CiAgICAgdm9pZCBmbHVzaFBl bmRpbmdQYWdlRXh0ZW5kZWRCYWNrZ3JvdW5kQ29sb3JDaGFuZ2UoKTsKIAorICAgIHZvaWQgZGlk U2FtcGxlUGFnZVRvcENvbG9yKCk7CisKICAgICB2b2lkIGZsdXNoUGVuZGluZ0VkaXRvclN0YXRl VXBkYXRlKCk7CiAKICNpZiBFTkFCTEUoUkVTT1VSQ0VfTE9BRF9TVEFUSVNUSUNTKQpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGM5M2U0MGNhMWY1 YmY0YzM2NDRlYmZmMGZhZGI4NDRmNDMyNmYwNWIuLjcwMGVmMDUyMDJiNDMwNGNmNTU4OTA4MzNh YjY0MjYyMWFmYzE2NjggMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAyMS0wNC0yOCAgRGV2aW4gUm91c3NvICA8ZHJv dXNzb0BhcHBsZS5jb20+CisKKyAgICAgICAgZXhwZXJpbWVudCB3aXRoIGF2ZXJhZ2luZyBzYW1w bGluZyBjb2xvcnMgYWNyb3NzIHRoZSB0b3Agb2YgdGhlIHBhZ2UgYXMgdGhlIHNjcm9sbCBhcmVh IGJhY2tncm91bmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIyNDk4NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNzYyNTE4ODk+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdENvY29hL1NhbXBsZWRQYWdlVG9wQ29sb3IubW06IEFkZGVkLgorICAgICAgICAoLVtU ZXN0S1ZPV3JhcHBlciBpbml0V2l0aE9ic2VydmFibGU6a2V5UGF0aDpjYWxsYmFjazpdKToKKyAg ICAgICAgKC1bVGVzdEtWT1dyYXBwZXIgZGVhbGxvY10pOgorICAgICAgICAoLVtUZXN0S1ZPV3Jh cHBlciBvYnNlcnZlVmFsdWVGb3JLZXlQYXRoOm9mT2JqZWN0OmNoYW5nZTpjb250ZXh0Ol0pOgor ICAgICAgICAoY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5j ZSk6CisgICAgICAgICh3YWl0Rm9yU2FtcGxlZFBhZ2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRNTCk6 CisgICAgICAgIChjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyk6CisgICAgICAgIChU RVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuWmVyb01heERpZmZlcmVuY2UpOgorICAgICAgICAoVEVT VC5TYW1wbGVkUGFnZVRvcENvbG9yLk5lZ2F0aXZlTWF4RGlmZmVyZW5jZSk6CisgICAgICAgIChU RVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuU29saWRDb2xvcik6CisgICAgICAgIChURVNULlNhbXBs ZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aG91dE91dGxpZXJCZWxvd01heERpZmZl cmVuY2UpOgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9y c1dpdGhMZWZ0T3V0bGllckFib3ZlTWF4RGlmZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBs ZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29sb3JzV2l0aE1pZGRsZU91dGxpZXJBYm92ZU1heERp ZmZlcmVuY2UpOgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENv bG9yc1dpdGhSaWdodE91dGxpZXJBYm92ZU1heERpZmZlcmVuY2UpOgorICAgICAgICAoVEVTVC5T YW1wbGVkUGFnZVRvcENvbG9yLkRpZmZlcmVudENvbG9yc0luZGl2aWR1YWxseUFib3ZlTWF4RGlm ZmVyZW5jZSk6CisgICAgICAgIChURVNULlNhbXBsZWRQYWdlVG9wQ29sb3IuRGlmZmVyZW50Q29s b3JzQ3VtdWxhdGl2ZWx5QWJvdmVNYXhEaWZmZXJlbmNlKToKKyAgICAgICAgKFRFU1QuU2FtcGxl ZFBhZ2VUb3BDb2xvci5EaXNwbGF5UDMpOgorICAgICAgICAoVEVTVC5TYW1wbGVkUGFnZVRvcENv bG9yLkV4cGVyaW1lbnRhbFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dy b3VuZENvbG9yKToKKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qOgorCiAyMDIxLTA0LTI2ICBEb24gT2xtc3RlYWQgIDxkb24u b2xtc3RlYWRAc29ueS5jb20+CiAKICAgICAgICAgW0NNYWtlXSBNb2Rlcm5pemUgV2ViS2l0IEdM aWIgdGVzdGluZwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJL aXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3YjA2YmFkM2Q5NGZjMWU3ZDNm YTEwZGQ2N2NhMWEzMDA2ZjNjMmQxLi4zN2RiOWEyZmFmYmUyMDI0M2E3MDRlMDY1NjViMjUyZjAz OWE2M2E4IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJL aXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtODY1LDYgKzg2NSw3IEBACiAJCTkz RjU2REE3MUU1RjkxNzQwMDNFREU4NCAvKiBsaWJpY3Vjb3JlLmR5bGliIGluIEZyYW1ld29ya3Mg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0M4M0UwMzMxRDBBNUYyNzAwRkVC Q0YzIC8qIGxpYmljdWNvcmUuZHlsaWIgKi87IH07CiAJCTkzRjU2REE5MUU1RjkxOUQwMDNFREU4 NCAvKiBXS1dlYlZpZXdTbmFwc2hvdC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzRjU2REE4MUU1RjkxODEwMDNFREU4NCAvKiBXS1dlYlZpZXdTbmFw c2hvdC5tbSAqLzsgfTsKIAkJOTNGN0U4NkYxNERDOEU1QzAwQzg0QTk5IC8qIE5ld0ZpcnN0Vmlz dWFsbHlOb25FbXB0eUxheW91dEZyYW1lc19CdW5kbGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTNGN0U4NkUxNERDOEU1QjAwQzg0QTk5IC8qIE5l d0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1lc19CdW5kbGUuY3BwICovOyB9OworCQk5 NTA5NUYyMDI2MkZGRkE1MDAwMEQ5MjAgLyogU2FtcGxlZFBhZ2VUb3BDb2xvci5tbSBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1MDk1RjFGMjYyRkZGQTUw MDAwRDkyMCAvKiBTYW1wbGVkUGFnZVRvcENvbG9yLm1tICovOyB9OwogCQk5NTBFNENDMTI1MkU3 NTI0MDA3MTY1OUYgLyogaU9TU3R5bHVzU3VwcG9ydC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1MEU0Q0MwMjUyRTc1MjMwMDcxNjU5RiAvKiBpT1NT dHlsdXNTdXBwb3J0Lm1tICovOyB9OwogCQk5NTNBQkIzNTI1QzBENjgyMDA0QzhCNzMgLyogUGFn ZUV4dGVuZGVkQmFja2dyb3VuZENvbG9yLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gOTUzQUJCMzQyNUMwRDY4MTAwNEM4QjczIC8qIFBhZ2VFeHRlbmRl ZEJhY2tncm91bmRDb2xvci5tbSAqLzsgfTsKIAkJOTVBNTI0OTUyNTgxQTEwRDAwNDYxRkU5IC8q IFdLV2ViVmlld1RoZW1lQ29sb3IubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA5NUE1MjQ5NDI1ODFBMTBEMDA0NjFGRTkgLyogV0tXZWJWaWV3VGhlbWVD b2xvci5tbSAqLzsgfTsKQEAgLTI1NTUsNiArMjU1Niw3IEBACiAJCTkzRjU2REE4MUU1RjkxODEw MDNFREU4NCAvKiBXS1dlYlZpZXdTbmFwc2hvdC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw Lm9iamNwcDsgcGF0aCA9IFdLV2ViVmlld1NuYXBzaG90Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk5M0Y3RTg2QjE0REM4RTREMDBDODRBOTkgLyogTmV3Rmlyc3RWaXN1YWxseU5v bkVtcHR5TGF5b3V0RnJhbWVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1lcy5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTkzRjdFODZFMTREQzhFNUIwMEM4NEE5OSAvKiBOZXdGaXJzdFZp c3VhbGx5Tm9uRW1wdHlMYXlvdXRGcmFtZXNfQnVuZGxlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZyYW1lc19C dW5kbGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5NTA5NUYxRjI2MkZGRkE1 MDAwMEQ5MjAgLyogU2FtcGxlZFBhZ2VUb3BDb2xvci5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLm9iamNwcDsgcGF0aCA9IFNhbXBsZWRQYWdlVG9wQ29sb3IubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTk1MEU0Q0MwMjUyRTc1MjMwMDcxNjU5RiAvKiBpT1NTdHlsdXNTdXBw b3J0Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gaU9TU3R5bHVz U3VwcG9ydC5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTUzQUJCMzQyNUMwRDY4 MTAwNEM4QjczIC8qIFBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvci5tbSAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFBhZ2VFeHRlbmRlZEJhY2tncm91bmRDb2xvci5t bTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTVBNTI0OTQyNTgxQTEwRDAwNDYxRkU5 IC8qIFdLV2ViVmlld1RoZW1lQ29sb3IubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpj cHA7IHBhdGggPSBXS1dlYlZpZXdUaGVtZUNvbG9yLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwpAQCAtMzUyNSw2ICszNTI3LDcgQEAKIAkJCQlBMTgwQzBGOTFFRTY3REYwMDA0NjhGNDcg LyogUnVuT3BlblBhbmVsLm1tICovLAogCQkJCUY0RDI5ODZEMjBGRUU3MzcwMDkyRDYzNiAvKiBS dW5TY3JpcHRBZnRlckRvY3VtZW50TG9hZC5tbSAqLywKIAkJCQk1Q0E5ODU1MTIxMTNDQjhDMDA1 N0VCNkIgLyogU2FmZUJyb3dzaW5nLm1tICovLAorCQkJCTk1MDk1RjFGMjYyRkZGQTUwMDAwRDky MCAvKiBTYW1wbGVkUGFnZVRvcENvbG9yLm1tICovLAogCQkJCUNFMDk0NzM2MjA2MzIyM0IwMDND OUJBMCAvKiBTY2hlbWVSZWdpc3RyeS5tbSAqLywKIAkJCQk1MUVCMTI5MzFGREYwNTA1MDBBNUEx QkQgLyogU2VydmljZVdvcmtlckJhc2ljLm1tICovLAogCQkJCTVDNjgzNDcxMjM1QUNDN0MwMDQx RTZCMSAvKiBTZXJ2aWNlV29ya2VyVENQU2VydmVyLmggKi8sCkBAIC01NjM2LDYgKzU2MzksNyBA QAogCQkJCUExODBDMEZBMUVFNjdERjAwMDQ2OEY0NyAvKiBSdW5PcGVuUGFuZWwubW0gaW4gU291 cmNlcyAqLywKIAkJCQlGNEQyOTg2RTIwRkVFNzM3MDA5MkQ2MzYgLyogUnVuU2NyaXB0QWZ0ZXJE b2N1bWVudExvYWQubW0gaW4gU291cmNlcyAqLywKIAkJCQk1Q0E5ODU1MzIxMTNDRjc4MDA1N0VC NkIgLyogU2FmZUJyb3dzaW5nLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJOTUwOTVGMjAyNjJGRkZB NTAwMDBEOTIwIC8qIFNhbXBsZWRQYWdlVG9wQ29sb3IubW0gaW4gU291cmNlcyAqLywKIAkJCQlD RENGQTdBQTFFNDUxODMyMDBDMjQzM0QgLyogU2FtcGxlTWFwLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCUNFMDk0NzM3MjA2MzIyM0IwMDNDOUJBMCAvKiBTY2hlbWVSZWdpc3RyeS5tbSBpbiBTb3Vy Y2VzICovLAogCQkJCUNEQzA5MzJCMjFDODcyQzEwMDMwQzRCMCAvKiBTY3JvbGxpbmdEb2VzTm90 UGF1c2VNZWRpYS5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9TYW1wbGVkUGFnZVRvcENvbG9yLm1tIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9TYW1wbGVkUGFnZVRvcENvbG9yLm1tCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjA3MjUwMTRkNzU2MzQ2OTViMDVkZWI0NmM1YzdlOGVmZTY2NDQzZjEKLS0tIC9kZXYv bnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL1NhbXBsZWRQ YWdlVG9wQ29sb3IubW0KQEAgLTAsMCArMSwzMDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MjEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJj b25maWcuaCIKKworI2ltcG9ydCAiVGVzdENvY29hLmgiCisjaW1wb3J0ICJUZXN0V0tXZWJWaWV3 LmgiCisjaW1wb3J0ICJVdGlsaXRpZXMuaCIKKyNpbXBvcnQgPFdlYkNvcmUvQ29sb3IuaD4KKyNp bXBvcnQgPFdlYktpdC9XS1ByZWZlcmVuY2VzUHJpdmF0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L1dL V2ViVmlld0NvbmZpZ3VyYXRpb25Qcml2YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3 UHJpdmF0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L19XS0ludGVybmFsRGVidWdGZWF0dXJlLmg+Cisj aW1wb3J0IDx3dGYvRnVuY3Rpb24uaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBv cnQgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKworI2RlZmluZSBFWFBFQ1RfSU5fUkFOR0Uo YWN0dWFsLCBtaW4sIG1heCkgXAorICAgIEVYUEVDVF9HRShhY3R1YWwsIG1pbik7IFwKKyAgICBF WFBFQ1RfTEUoYWN0dWFsLCBtYXgpOworCitAaW50ZXJmYWNlIFRlc3RLVk9XcmFwcGVyIDogTlNP YmplY3QKKworLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoT2JzZXJ2YWJsZTooTlNPYmplY3QgKilv YnNlcnZhYmxlIGtleVBhdGg6KE5TU3RyaW5nICopa2V5UGF0aCBjYWxsYmFjazooRnVuY3Rpb248 dm9pZCgpPiYmKWNhbGxiYWNrOworCitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBUZXN0S1ZPV3Jh cHBlciB7CisgICAgUmV0YWluUHRyPE5TT2JqZWN0PiBfb2JzZXJ2YWJsZTsKKyAgICBSZXRhaW5Q dHI8TlNTdHJpbmc+IF9rZXlQYXRoOworICAgIEZ1bmN0aW9uPHZvaWQoKT4gX2NhbGxiYWNrOwor fQorCistIChpbnN0YW5jZXR5cGUpaW5pdFdpdGhPYnNlcnZhYmxlOihOU09iamVjdCAqKW9ic2Vy dmFibGUga2V5UGF0aDooTlNTdHJpbmcgKilrZXlQYXRoIGNhbGxiYWNrOihGdW5jdGlvbjx2b2lk KCk+JiYpY2FsbGJhY2sKK3sKKyAgICBpZiAoIShzZWxmID0gW3N1cGVyIGluaXRdKSkKKyAgICAg ICAgcmV0dXJuIG5pbDsKKworICAgIF9vYnNlcnZhYmxlID0gb2JzZXJ2YWJsZTsKKyAgICBfa2V5 UGF0aCA9IGtleVBhdGg7CisgICAgX2NhbGxiYWNrID0gV1RGTW92ZShjYWxsYmFjayk7CisKKyAg ICBbX29ic2VydmFibGUgYWRkT2JzZXJ2ZXI6c2VsZiBmb3JLZXlQYXRoOl9rZXlQYXRoLmdldCgp IG9wdGlvbnM6MCBjb250ZXh0Om5pbF07CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9p ZClkZWFsbG9jCit7CisgICAgW19vYnNlcnZhYmxlIHJlbW92ZU9ic2VydmVyOnNlbGYgZm9yS2V5 UGF0aDpfa2V5UGF0aC5nZXQoKSBjb250ZXh0Om51bGxwdHJdOworCisgICAgW3N1cGVyIGRlYWxs b2NdOworfQorCistICh2b2lkKW9ic2VydmVWYWx1ZUZvcktleVBhdGg6KE5TU3RyaW5nICopa2V5 UGF0aCBvZk9iamVjdDooaWQpb2JqZWN0IGNoYW5nZTooTlNEaWN0aW9uYXJ5ICopY2hhbmdlIGNv bnRleHQ6KHZvaWQgKiljb250ZXh0Cit7CisgICAgX2NhbGxiYWNrKCk7Cit9CisKK0BlbmQKKwor ZW51bSBjbGFzcyBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRD b2xvciA6IGJvb2wgeyBZZXMsIE5vIH07CitzdGF0aWMgUmV0YWluUHRyPFRlc3RXS1dlYlZpZXc+ IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoZG91Ymxl IHNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlLCBVc2VTYW1wbGVkUGFnZVRvcENvbG9y Rm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvciB1c2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Ny b2xsQXJlYUJhY2tncm91bmRDb2xvciA9IFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxB cmVhQmFja2dyb3VuZENvbG9yOjpObykKK3sKKyAgICBhdXRvIGNvbmZpZ3VyYXRpb24gPSBhZG9w dE5TKFtbV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBhbGxvY10gaW5pdF0pOworICAgIFtjb25maWd1 cmF0aW9uIF9zZXRTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5jZTpzYW1wbGVkUGFnZVRv cENvbG9yTWF4RGlmZmVyZW5jZV07CisKKyAgICBmb3IgKF9XS0ludGVybmFsRGVidWdGZWF0dXJl ICpmZWF0dXJlIGluIFtXS1ByZWZlcmVuY2VzIF9pbnRlcm5hbERlYnVnRmVhdHVyZXNdKSB7Cisg ICAgICAgIGlmIChbZmVhdHVyZS5rZXkgaXNFcXVhbFRvU3RyaW5nOkAiVXNlU2FtcGxlZFBhZ2VU b3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IiXSkgeworICAgICAgICAgICAgW1tj b25maWd1cmF0aW9uIHByZWZlcmVuY2VzXSBfc2V0RW5hYmxlZDoodXNlU2FtcGxlZFBhZ2VUb3BD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgPT0gVXNlU2FtcGxlZFBhZ2VUb3BDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6OlllcykgZm9ySW50ZXJuYWxEZWJ1Z0ZlYXR1 cmU6ZmVhdHVyZV07CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgIH0KKworICAg IHJldHVybiBhZG9wdE5TKFtbVGVzdFdLV2ViVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpDR1Jl Y3RNYWtlKDAsIDAsIDgwMCwgNjAwKSBjb25maWd1cmF0aW9uOmNvbmZpZ3VyYXRpb24uZ2V0KCld KTsKK30KKworc3RhdGljIHZvaWQgd2FpdEZvclNhbXBsZWRQYWdlVG9wQ29sb3JUb0NoYW5nZUZv ckhUTUwoVGVzdFdLV2ViVmlldyAqd2ViVmlldywgU3RyaW5nJiYgaHRtbCkKK3sKKyAgICBib29s IGRvbmUgPSBmYWxzZTsKKyAgICBhdXRvIHNhbXBsZWRQYWdlVG9wQ29sb3JPYnNlcnZlciA9IGFk b3B0TlMoW1tUZXN0S1ZPV3JhcHBlciBhbGxvY10gaW5pdFdpdGhPYnNlcnZhYmxlOndlYlZpZXcg a2V5UGF0aDpAIl9zYW1wbGVkUGFnZVRvcENvbG9yIiBjYWxsYmFjazpbJl0geworICAgICAgICBk b25lID0gdHJ1ZTsKKyAgICB9XSk7CisgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1M U3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpXVEZNb3ZlKGh0 bWwpXTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmRvbmUpOworfQorCitzdGF0aWMg U3RyaW5nIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKFZlY3RvcjxTdHJpbmc+JiYg Y29sb3JTdG9wcykKK3sKKyAgICBFWFBFQ1RfR0UoY29sb3JTdG9wcy5zaXplKCksIDJVTCk7CisK KyAgICBTdHJpbmdCdWlsZGVyIGdyYWRpZW50QnVpbGRlcjsKKyAgICBncmFkaWVudEJ1aWxkZXIu YXBwZW5kKCI8Ym9keSBzdHlsZT1cImJhY2tncm91bmQtaW1hZ2U6IGxpbmVhci1ncmFkaWVudCh0 byByaWdodCJfcyk7CisgICAgZm9yIChhdXRvJiYgY29sb3JTdG9wIDogV1RGTW92ZShjb2xvclN0 b3BzKSkgeworICAgICAgICBncmFkaWVudEJ1aWxkZXIuYXBwZW5kKCIsICJfcyk7CisgICAgICAg IGdyYWRpZW50QnVpbGRlci5hcHBlbmQoV1RGTW92ZShjb2xvclN0b3ApKTsKKyAgICB9CisgICAg Z3JhZGllbnRCdWlsZGVyLmFwcGVuZCgiKVwiPlRlc3QiX3MpOworICAgIHJldHVybiBncmFkaWVu dEJ1aWxkZXIudG9TdHJpbmcoKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBaZXJv TWF4RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNh bXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlKDApOworICAgIEVYUEVDVF9OVUxMKFt3ZWJW aWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5 TG9hZEhUTUxTdHJpbmdBbmRXYWl0VW50aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNy ZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pXTsKKyAgICBF WFBFQ1RfTlVMTChbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworfQorCitURVNUKFNh bXBsZWRQYWdlVG9wQ29sb3IsIE5lZ2F0aXZlTWF4RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdl YlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNl KC01KTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOwor CisgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxs SW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9w cyh7ICJyZWQiLCAicmVkIiB9KV07CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQ YWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBTb2xpZENvbG9y KQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BD b2xvck1heERpZmZlcmVuY2UoNSk7CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQ YWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VG b3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsg InJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXcg X3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVkKTsKK30K KworVEVTVChTYW1wbGVkUGFnZVRvcENvbG9yLCBEaWZmZXJlbnRDb2xvcnNXaXRob3V0T3V0bGll ckJlbG93TWF4RGlmZmVyZW5jZSkKK3sKKyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3 V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JNYXhEaWZmZXJlbmNlKDUpOworICAgIEVYUEVDVF9OVUxM KFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisKKyAgICB3YWl0Rm9yU2FtcGxlZFBh Z2VUb3BDb2xvclRvQ2hhbmdlRm9ySFRNTCh3ZWJWaWV3LmdldCgpLCBjcmVhdGVIVE1MR3JhZGll bnRXaXRoQ29sb3JTdG9wcyh7CisgICAgICAgICJsYWIoMSUgMCAwKSJfcywKKyAgICAgICAgImxh YigyJSAwIDApIl9zLAorICAgICAgICAibGFiKDMlIDAgMCkiX3MsCisgICAgICAgICJsYWIoNCUg MCAwKSJfcywKKyAgICAgICAgImxhYig1JSAwIDApIl9zLAorICAgIH0pKTsKKworICAgIGF1dG8g Y29tcG9uZW50cyA9IENHQ29sb3JHZXRDb21wb25lbnRzKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRv cENvbG9yXS5DR0NvbG9yKTsKKyAgICBFWFBFQ1RfSU5fUkFOR0UoY29tcG9uZW50c1swXSwgMC4w NCwgMC4wNSk7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMV0sIDAuMDQsIDAuMDUp OworICAgIEVYUEVDVF9JTl9SQU5HRShjb21wb25lbnRzWzJdLCAwLjA0LCAwLjA1KTsKKyAgICBF WFBFQ1RfRVEoY29tcG9uZW50c1szXSwgMSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xv ciwgRGlmZmVyZW50Q29sb3JzV2l0aExlZnRPdXRsaWVyQWJvdmVNYXhEaWZmZXJlbmNlKQorewor ICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1h eERpZmZlcmVuY2UoNSk7CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9w Q29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1M KHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsKKyAgICAg ICAgImxhYigxMDAlIDAgMCkiX3MsIC8vIG91dGxpZXIKKyAgICAgICAgImxhYigxJSAwIDApIl9z LAorICAgICAgICAibGFiKDIlIDAgMCkiX3MsCisgICAgICAgICJsYWIoMyUgMCAwKSJfcywKKyAg ICAgICAgImxhYig0JSAwIDApIl9zLAorICAgIH0pKTsKKworICAgIGF1dG8gY29tcG9uZW50cyA9 IENHQ29sb3JHZXRDb21wb25lbnRzKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXS5DR0Nv bG9yKTsKKyAgICBFWFBFQ1RfSU5fUkFOR0UoY29tcG9uZW50c1swXSwgMC4wMywgMC4wNCk7Cisg ICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMV0sIDAuMDMsIDAuMDQpOworICAgIEVYUEVD VF9JTl9SQU5HRShjb21wb25lbnRzWzJdLCAwLjAzLCAwLjA0KTsKKyAgICBFWFBFQ1RfRVEoY29t cG9uZW50c1szXSwgMSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwgRGlmZmVyZW50 Q29sb3JzV2l0aE1pZGRsZU91dGxpZXJBYm92ZU1heERpZmZlcmVuY2UpCit7CisgICAgYXV0byB3 ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5j ZSg1KTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOwor CisgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxs SW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9w cyh7CisgICAgICAgICJsYWIoMSUgMCAwKSJfcywKKyAgICAgICAgImxhYigyJSAwIDApIl9zLAor ICAgICAgICAibGFiKDEwMCUgMCAwKSJfcywgLy8gb3V0bGllcgorICAgICAgICAibGFiKDMlIDAg MCkiX3MsCisgICAgICAgICJsYWIoNCUgMCAwKSJfcywKKyAgICB9KV07CisgICAgRVhQRUNUX05V TEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKK30KKworVEVTVChTYW1wbGVkUGFn ZVRvcENvbG9yLCBEaWZmZXJlbnRDb2xvcnNXaXRoUmlnaHRPdXRsaWVyQWJvdmVNYXhEaWZmZXJl bmNlKQoreworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VU b3BDb2xvck1heERpZmZlcmVuY2UoNSk7CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBs ZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFu Z2VGb3JIVE1MKHdlYlZpZXcuZ2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3Bz KHsKKyAgICAgICAgImxhYigxJSAwIDApIl9zLAorICAgICAgICAibGFiKDIlIDAgMCkiX3MsCisg ICAgICAgICJsYWIoMyUgMCAwKSJfcywKKyAgICAgICAgImxhYig0JSAwIDApIl9zLAorICAgICAg ICAibGFiKDEwMCUgMCAwKSJfcywgLy8gb3V0bGllcgorICAgIH0pKTsKKworICAgIGF1dG8gY29t cG9uZW50cyA9IENHQ29sb3JHZXRDb21wb25lbnRzKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENv bG9yXS5DR0NvbG9yKTsKKyAgICBFWFBFQ1RfSU5fUkFOR0UoY29tcG9uZW50c1swXSwgMC4wMywg MC4wNCk7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMV0sIDAuMDMsIDAuMDQpOwor ICAgIEVYUEVDVF9JTl9SQU5HRShjb21wb25lbnRzWzJdLCAwLjAzLCAwLjA0KTsKKyAgICBFWFBF Q1RfRVEoY29tcG9uZW50c1szXSwgMSk7Cit9CisKK1RFU1QoU2FtcGxlZFBhZ2VUb3BDb2xvciwg RGlmZmVyZW50Q29sb3JzSW5kaXZpZHVhbGx5QWJvdmVNYXhEaWZmZXJlbmNlKQoreworICAgIGF1 dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZl cmVuY2UoNSk7CisgICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3Jd KTsKKworICAgIFt3ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRp bEFsbEltbWVkaWF0ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9y U3RvcHMoeworICAgICAgICAibGFiKDEwJSAwIDApIl9zLAorICAgICAgICAibGFiKDIwJSAwIDAp Il9zLAorICAgICAgICAibGFiKDMwJSAwIDApIl9zLAorICAgICAgICAibGFiKDQwJSAwIDApIl9z LAorICAgICAgICAibGFiKDUwJSAwIDApIl9zLAorICAgIH0pXTsKKyAgICBFWFBFQ1RfTlVMTChb d2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworfQorCitURVNUKFNhbXBsZWRQYWdlVG9w Q29sb3IsIERpZmZlcmVudENvbG9yc0N1bXVsYXRpdmVseUFib3ZlTWF4RGlmZmVyZW5jZSkKK3sK KyAgICBhdXRvIHdlYlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aFNhbXBsZWRQYWdlVG9wQ29sb3JN YXhEaWZmZXJlbmNlKDUpOworICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRv cENvbG9yXSk7CisKKyAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmdBbmRX YWl0VW50aWxBbGxJbW1lZGlhdGVDaGlsZEZyYW1lc1BhaW50OmNyZWF0ZUhUTUxHcmFkaWVudFdp dGhDb2xvclN0b3BzKHsKKyAgICAgICAgImxhYigxJSAwIDApIl9zLAorICAgICAgICAibGFiKDMl IDAgMCkiX3MsCisgICAgICAgICJsYWIoNSUgMCAwKSJfcywKKyAgICAgICAgImxhYig3JSAwIDAp Il9zLAorICAgICAgICAibGFiKDklIDAgMCkiX3MsCisgICAgfSldOworICAgIEVYUEVDVF9OVUxM KFt3ZWJWaWV3IF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7Cit9CisKKy8vIEZJWE1FOiA8aHR0cHM6 Ly93ZWJraXQub3JnL2IvMjI1MTY3PiAoU2FtcGxlZCBQYWdlIFRvcCBDb2xvcjogaG9vayBpbnRv IHBhaW50aW5nIGxvZ2ljIGluc3RlYWQgb2YgdGFraW5nIHNuYXBzaG90cykKK1RFU1QoU2FtcGxl ZFBhZ2VUb3BDb2xvciwgRElTQUJMRURfRGlzcGxheVAzKQoreworICAgIGF1dG8gd2ViVmlldyA9 IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVuY2UoNSk7Cisg ICAgRVhQRUNUX05VTEwoW3dlYlZpZXcgX3NhbXBsZWRQYWdlVG9wQ29sb3JdKTsKKworICAgIFt3 ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZ0FuZFdhaXRVbnRpbEFsbEltbWVkaWF0 ZUNoaWxkRnJhbWVzUGFpbnQ6Y3JlYXRlSFRNTEdyYWRpZW50V2l0aENvbG9yU3RvcHMoeworICAg ICAgICAiY29sb3IoZGlzcGxheS1wMyAwLjk5IDAgMCkiX3MsCisgICAgICAgICJjb2xvcihkaXNw bGF5LXAzIDAuOTggMCAwKSJfcywKKyAgICAgICAgImNvbG9yKGRpc3BsYXktcDMgMC45NyAwIDAp Il9zLAorICAgICAgICAiY29sb3IoZGlzcGxheS1wMyAwLjk2IDAgMCkiX3MsCisgICAgICAgICJj b2xvcihkaXNwbGF5LXAzIDAuOTUgMCAwKSJfcywKKyAgICB9KV07CisKKyAgICBhdXRvIGNvbXBv bmVudHMgPSBDR0NvbG9yR2V0Q29tcG9uZW50cyhbd2ViVmlldyBfc2FtcGxlZFBhZ2VUb3BDb2xv cl0uQ0dDb2xvcik7CisgICAgRVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMF0sIDAuMywgMC40 KTsKKyAgICBFWFBFQ1RfSU5fUkFOR0UoY29tcG9uZW50c1sxXSwgMS4wMCwgMS4wMSk7CisgICAg RVhQRUNUX0lOX1JBTkdFKGNvbXBvbmVudHNbMl0sIDEuMDAsIDEuMDEpOworICAgIEVYUEVDVF9F UShjb21wb25lbnRzWzNdLCAxKTsKK30KKworI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCisKKy8v IFRoZXJlJ3Mgbm8gQVBJL1NQSSB0byBnZXQgdGhlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIHNj cm9sbCBhcmVhIG9uIG1hY09TLgorCitURVNUKFNhbXBsZWRQYWdlVG9wQ29sb3IsIEV4cGVyaW1l bnRhbFVzZVNhbXBsZWRQYWdlVG9wQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yKQor eworICAgIGF1dG8gd2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91 bmRDb2xvciA9IGNyZWF0ZVdlYlZpZXdXaXRoU2FtcGxlZFBhZ2VUb3BDb2xvck1heERpZmZlcmVu Y2UoNSwgVXNlU2FtcGxlZFBhZ2VUb3BDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3I6 Ok5vKTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlld1dpdGhvdXRUaGVtZUNvbG9yRm9yU2Nyb2xs QXJlYUJhY2tncm91bmRDb2xvciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZp ZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25v dXNseUxvYWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWlu dDpjcmVhdGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOwor ICAgIEVYUEVDVF9OVUxMKFt3ZWJWaWV3V2l0aG91dFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFj a2dyb3VuZENvbG9yIF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisgICAgRVhQRUNUX0VRKFdlYkNv cmU6OkNvbG9yKFt3ZWJWaWV3V2l0aG91dFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3Vu ZENvbG9yIHNjcm9sbFZpZXddLmJhY2tncm91bmRDb2xvci5DR0NvbG9yKSwgV2ViQ29yZTo6Q29s b3I6OndoaXRlKTsKKworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JI VE1MKHdlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Iu Z2V0KCksIGNyZWF0ZUhUTUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0p KTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXdXaXRob3V0VGhlbWVDb2xv ckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29s b3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVkKTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3Io W3dlYlZpZXdXaXRob3V0VGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Ny b2xsVmlld10uYmFja2dyb3VuZENvbG9yLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6d2hpdGUp OworCisgICAgYXV0byB3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3Vu ZENvbG9yID0gY3JlYXRlV2ViVmlld1dpdGhTYW1wbGVkUGFnZVRvcENvbG9yTWF4RGlmZmVyZW5j ZSg1LCBVc2VTYW1wbGVkUGFnZVRvcENvbG9yRm9yU2Nyb2xsQXJlYUJhY2tncm91bmRDb2xvcjo6 WWVzKTsKKyAgICBFWFBFQ1RfTlVMTChbd2ViVmlld1dpdGhUaGVtZUNvbG9yRm9yU2Nyb2xsQXJl YUJhY2tncm91bmRDb2xvciBfc2FtcGxlZFBhZ2VUb3BDb2xvcl0pOworCisgICAgW3dlYlZpZXdX aXRoVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc3luY2hyb25vdXNseUxv YWRIVE1MU3RyaW5nQW5kV2FpdFVudGlsQWxsSW1tZWRpYXRlQ2hpbGRGcmFtZXNQYWludDpjcmVh dGVIVE1MR3JhZGllbnRXaXRoQ29sb3JTdG9wcyh7ICJyZWQiLCAiYmx1ZSIgfSldOworICAgIEVY UEVDVF9OVUxMKFt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENv bG9yIF9zYW1wbGVkUGFnZVRvcENvbG9yXSk7CisgICAgRVhQRUNUX0VRKFdlYkNvcmU6OkNvbG9y KFt3ZWJWaWV3V2l0aFRoZW1lQ29sb3JGb3JTY3JvbGxBcmVhQmFja2dyb3VuZENvbG9yIHNjcm9s bFZpZXddLmJhY2tncm91bmRDb2xvci5DR0NvbG9yKSwgV2ViQ29yZTo6Q29sb3I6OndoaXRlKTsK KworICAgIHdhaXRGb3JTYW1wbGVkUGFnZVRvcENvbG9yVG9DaGFuZ2VGb3JIVE1MKHdlYlZpZXdX aXRoVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3IuZ2V0KCksIGNyZWF0ZUhU TUxHcmFkaWVudFdpdGhDb2xvclN0b3BzKHsgInJlZCIsICJyZWQiIH0pKTsKKyAgICBFWFBFQ1Rf RVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXdXaXRoVGhlbWVDb2xvckZvclNjcm9sbEFyZWFCYWNr Z3JvdW5kQ29sb3IgX3NhbXBsZWRQYWdlVG9wQ29sb3JdLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xv cjo6cmVkKTsKKyAgICBFWFBFQ1RfRVEoV2ViQ29yZTo6Q29sb3IoW3dlYlZpZXdXaXRoVGhlbWVD b2xvckZvclNjcm9sbEFyZWFCYWNrZ3JvdW5kQ29sb3Igc2Nyb2xsVmlld10uYmFja2dyb3VuZENv bG9yLkNHQ29sb3IpLCBXZWJDb3JlOjpDb2xvcjo6cmVkKTsKK30KKworI2VuZGlmIC8vIFBMQVRG T1JNKElPU19GQU1JTFkpCg==