208464 2020-03-02 12:40:42 -0800 Lazily generate CGPaths for some simple types of paths, such as arcs and lines 2020-03-08 16:13:51 -0700 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh annulen benjamin cdumez cmarcelo darin dino ews-watchlist gyuyoung.kim ryuan.choi sabouhallawa sam sergio simon.fraser thorton webkit-bug-importer oldest_to_newest 1624675 0 wenson_hsieh 2020-03-02 12:40:42 -0800 The final entry in the "Make Paths Fast" trilogy. When creating certain types of paths such as arcs and lines, we can inline information about the path (e.g. the endpoints of a line segment, or the location and start/end angles of an arc) within the WebCore::Path itself. This achieves two things: 1. IPC encoding and decoding is faster, since we don’t have to ask CGPath for its individual elements and encode them all. 2. We’ll avoid creating CGPaths for WebCore::Paths created in the GPU Process until they’re actually needed for painting. This means that we won’t end up with 512 individual CGPaths sitting around after we finish decoding the display list’s drawing items. Combined, this gives us a roughly 36% improvement on Canvas Arcs, 13% improvement on Canvas Paths and 22% improvement on Canvas Lines when the GPU Process is used for canvas rendering. 1624677 1 webkit-bug-importer 2020-03-02 12:42:28 -0800 <rdar://problem/59963226> 1626331 2 392634 wenson_hsieh 2020-03-05 15:18:57 -0800 Created attachment 392634 Work in progress 1626402 3 392651 wenson_hsieh 2020-03-05 16:56:30 -0800 Created attachment 392651 Patch 1626430 4 392651 simon.fraser 2020-03-05 17:54:50 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review This feels like it's 40% of the way towards just storing paths in our own representation. Maybe we should just do the whole thing. > Source/WebCore/platform/graphics/Path.h:296 > + encoder << static_cast<uint8_t>(m_inlineDataType); Need to use the enum encoder. > Source/WebCore/platform/graphics/Path.h:357 > + path.m_inlineDataType = static_cast<InlineDataType>(inlineDataTypeValue); No, you have to use the enum decoder. > Source/WebCore/platform/graphics/cg/PathCG.cpp:68 > +static FloatRect rectContainingPoints(FloatPoint point1, FloatPoint point2) I would expect we have this elsewhere. if not, please put in GeometryUtils.h > Source/WebCore/platform/graphics/cg/PathCG.cpp:351 > + if (m_inlineDataType <= InlineDataType::Move) { There's an ordering dependency between the values of InlineDataType which is not apparent from its declaration. You should add a comment that makes that dependency super clear, or not rely on comparisons here. 1626434 5 392651 sam 2020-03-05 18:20:14 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review > Source/WebCore/platform/graphics/Path.h:155 > +#if USE(CG) > + WEBCORE_EXPORT bool isNull() const; > +#else > bool isNull() const { return !m_path; } > +#endif I don't think it's worth keeping this inline for the non-USE(CG) case. Seems cleaner to make them both out of line. 1626437 6 392651 sabouhallawa 2020-03-05 18:34:11 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review > Source/WebCore/ChangeLog:63 > + The new member m_inlineDataType is an enum flag that indicates what kind of information is stored in > + m_inlineData. When a Path is initialized (or after it is cleared), it starts off in Cleared state. Moving the > + path transitions it into Move and just sets the `MoveData` member of the inline data; calling `addLineTo` or > + `addArc` transitions it to either Line or Arc. > + > + If, at any point, the path changes in a different way (i.e. neither line, arc, nor move), we transition to > + the NotInline state and no longer attempt to store the path mutations as inline data on Path. This state machine is hard to follow especially the difference between Cleared and NotInline is very subtle. I have the following suggestion. If Path class has the following data PlatformPathStorageType m_path; Optional<InlinePathData> m_inlineData; Then we can have four states for these two members: m_path m_inlineData Meaning null null Initial state null not null Path is inline but is not applied to m_path not null null Path can't be inline not null not null Path is inline and it is applied to m_path > Source/WebCore/platform/graphics/Path.h:259 > + struct LineData { > + FloatPoint start; > + FloatPoint end; > + }; > + > + struct ArcData { > + FloatPoint offset; > + FloatPoint center; > + float radius { 0 }; > + float start { 0 }; > + float end { 0 }; > + bool clockwise { false }; > + bool hasOffset { false }; > + }; > + > + struct MoveData { > + FloatPoint location; > + }; I think these structures should also include methods for encoding, decoding and applying the data to m_path > Source/WebCore/platform/graphics/Path.h:285 > + InlineDataType m_inlineDataType { InlineDataType::Cleared }; I think this should be part of InlinePathData struct InlinePathData { InlineDataType inlineDataType; MoveData move; LineData line; ArcData arc; }; 1626447 7 392651 sabouhallawa 2020-03-05 18:59:15 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review >> Source/WebCore/platform/graphics/Path.h:285 >> + InlineDataType m_inlineDataType { InlineDataType::Cleared }; > > I think this should be part of InlinePathData > > struct InlinePathData { > InlineDataType inlineDataType; > MoveData move; > LineData line; > ArcData arc; > }; I mean struct InlinePathData { InlineDataType inlineDataType; union { MoveData move; LineData line; ArcData arc; }; }; 1626470 8 392651 wenson_hsieh 2020-03-05 19:53:38 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review >> Source/WebCore/ChangeLog:63 >> + the NotInline state and no longer attempt to store the path mutations as inline data on Path. > > This state machine is hard to follow especially the difference between Cleared and NotInline is very subtle. I have the following suggestion. If Path class has the following data > > PlatformPathStorageType m_path; > Optional<InlinePathData> m_inlineData; > > Then we can have four states for these two members: > > m_path m_inlineData Meaning > > null null Initial state > null not null Path is inline but is not applied to m_path > not null null Path can't be inline > not null not null Path is inline and it is applied to m_path Okay, I’ll give this a try. >> Source/WebCore/platform/graphics/Path.h:155 >> +#endif > > I don't think it's worth keeping this inline for the non-USE(CG) case. Seems cleaner to make them both out of line. 👍🏻 >> Source/WebCore/platform/graphics/Path.h:259 >> + }; > > I think these structures should also include methods for encoding, decoding and applying the data to m_path 👍🏻 >>> Source/WebCore/platform/graphics/Path.h:285 >>> + InlineDataType m_inlineDataType { InlineDataType::Cleared }; >> >> I think this should be part of InlinePathData >> >> struct InlinePathData { >> InlineDataType inlineDataType; >> MoveData move; >> LineData line; >> ArcData arc; >> }; > > I mean > > struct InlinePathData { > InlineDataType inlineDataType; > union { > MoveData move; > LineData line; > ArcData arc; > }; > }; This sounds good! I’ll change it to this: struct InlinePathData { InlineDataType type; union { MoveData move; LineData line; ArcData arc; }; }; (so that I can just use `m_inlineData.type` instead of `m_inlineData.inlineDataType`). >> Source/WebCore/platform/graphics/Path.h:296 >> + encoder << static_cast<uint8_t>(m_inlineDataType); > > Need to use the enum encoder. 👍🏻 >> Source/WebCore/platform/graphics/Path.h:357 >> + path.m_inlineDataType = static_cast<InlineDataType>(inlineDataTypeValue); > > No, you have to use the enum decoder. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:68 >> +static FloatRect rectContainingPoints(FloatPoint point1, FloatPoint point2) > > I would expect we have this elsewhere. if not, please put in GeometryUtils.h I couldn’t find it elsewhere, so I made a new helper on GeometryUtils >> Source/WebCore/platform/graphics/cg/PathCG.cpp:351 >> + if (m_inlineDataType <= InlineDataType::Move) { > > There's an ordering dependency between the values of InlineDataType which is not apparent from its declaration. You should add a comment that makes that dependency super clear, or not rely on comparisons here. Good call; I’ll change this to compare directly. 1626483 9 392651 dbates 2020-03-05 20:51:06 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review >>>> Source/WebCore/platform/graphics/Path.h:285 >>>> + InlineDataType m_inlineDataType { InlineDataType::Cleared }; >>> >>> I think this should be part of InlinePathData >>> >>> struct InlinePathData { >>> InlineDataType inlineDataType; >>> MoveData move; >>> LineData line; >>> ArcData arc; >>> }; >> >> I mean >> >> struct InlinePathData { >> InlineDataType inlineDataType; >> union { >> MoveData move; >> LineData line; >> ArcData arc; >> }; >> }; > > This sounds good! I’ll change it to this: > > struct InlinePathData { > InlineDataType type; > union { > MoveData move; > LineData line; > ArcData arc; > }; > }; > > (so that I can just use `m_inlineData.type` instead of `m_inlineData.inlineDataType`). This is ok as-is. No change is needed. A better solution is to use std::variant (or WTF::variant if that exists) for the union because: 1. It is the modern way to represent a tagged union. 2. Because of (1) no need for InlineDataType, just need a bool for NoInline or Cleared state <-- I don't know what either of these are to say which could be represent by the empty variant, but one of them can > Source/WebCore/platform/graphics/Path.h:298 > + if (m_inlineDataType == InlineDataType::Move) { This is ok as-is. No change is needed. The optimal solution is to implement support for encoding and decoding a variant that because: 1. Simplifies the code: variant encoder/decoder knows how to encode/decode each alternative. 2. Because of (1) can remove all the branches here. 3. Because of (1) it is type safe: compile failure if alternative has not defined encoder or decoder if in the future there is a new data type 1626487 10 392651 dbates 2020-03-05 20:57:25 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review >>> Source/WebCore/platform/graphics/cg/PathCG.cpp:68 >>> +static FloatRect rectContainingPoints(FloatPoint point1, FloatPoint point2) >> >> I would expect we have this elsewhere. if not, please put in GeometryUtils.h > > I couldn’t find it elsewhere, so I made a new helper on GeometryUtils This is ok as-is. No change is needed. This function duplicates what (FloatRect { }).fitToPoints(point1, point2) does. 1626495 11 392651 wenson_hsieh 2020-03-05 21:28:45 -0800 Comment on attachment 392651 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=392651&action=review >>> Source/WebCore/ChangeLog:63 >>> + the NotInline state and no longer attempt to store the path mutations as inline data on Path. >> >> This state machine is hard to follow especially the difference between Cleared and NotInline is very subtle. I have the following suggestion. If Path class has the following data >> >> PlatformPathStorageType m_path; >> Optional<InlinePathData> m_inlineData; >> >> Then we can have four states for these two members: >> >> m_path m_inlineData Meaning >> >> null null Initial state >> null not null Path is inline but is not applied to m_path >> not null null Path can't be inline >> not null not null Path is inline and it is applied to m_path > > Okay, I’ll give this a try. Note that this would increase path from 48 to 56 bytes since the two bools and the 8-bit enum flag no longer bit inside the padding after the union. (I think Variant will have the same effect as well). It’s slightly unfortunate, but probably not very impactful. >>>>> Source/WebCore/platform/graphics/Path.h:285 >>>>> + InlineDataType m_inlineDataType { InlineDataType::Cleared }; >>>> >>>> I think this should be part of InlinePathData >>>> >>>> struct InlinePathData { >>>> InlineDataType inlineDataType; >>>> MoveData move; >>>> LineData line; >>>> ArcData arc; >>>> }; >>> >>> I mean >>> >>> struct InlinePathData { >>> InlineDataType inlineDataType; >>> union { >>> MoveData move; >>> LineData line; >>> ArcData arc; >>> }; >>> }; >> >> This sounds good! I’ll change it to this: >> >> struct InlinePathData { >> InlineDataType type; >> union { >> MoveData move; >> LineData line; >> ArcData arc; >> }; >> }; >> >> (so that I can just use `m_inlineData.type` instead of `m_inlineData.inlineDataType`). > > This is ok as-is. No change is needed. A better solution is to use std::variant (or WTF::variant if that exists) for the union because: > > 1. It is the modern way to represent a tagged union. > 2. Because of (1) no need for InlineDataType, just need a bool for NoInline or Cleared state <-- I don't know what either of these are to say which could be represent by the empty variant, but one of them can Yeah, I’ll explore using WTF::Variant for this. >> Source/WebCore/platform/graphics/Path.h:298 >> + if (m_inlineDataType == InlineDataType::Move) { > > This is ok as-is. No change is needed. The optimal solution is to implement support for encoding and decoding a variant that because: > > 1. Simplifies the code: variant encoder/decoder knows how to encode/decode each alternative. > 2. Because of (1) can remove all the branches here. > 3. Because of (1) it is type safe: compile failure if alternative has not defined encoder or decoder if in the future there is a new data type Yes — will try to adopt WTF::Variant. >>>> Source/WebCore/platform/graphics/cg/PathCG.cpp:68 >>>> +static FloatRect rectContainingPoints(FloatPoint point1, FloatPoint point2) >>> >>> I would expect we have this elsewhere. if not, please put in GeometryUtils.h >> >> I couldn’t find it elsewhere, so I made a new helper on GeometryUtils > > This is ok as-is. No change is needed. This function duplicates what (FloatRect { }).fitToPoints(point1, point2) does. It seems a bit odd to have to create an empty FloatRect just to fit it to two points, but this seems a bit cleaner than doing the math myself. I’ll use this instead of adding the helper. 1626961 12 392801 wenson_hsieh 2020-03-06 16:28:41 -0800 Created attachment 392801 v2 1627249 13 392801 thorton 2020-03-07 11:07:59 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review > Source/WebCore/platform/graphics/Path.h:233 > + struct LineData { Feels weird that this is in USE(CG). Should it be in a ENABLE(PLATFORM_INDEPENDENT_PATHS) (probably not that name) that is only on in CG for now? I assume the reason that you didn't is that it still needs the platform path to fall back on if it's not one of the simple types? But even that could be true for the other graphics frameworks. 1627250 14 392801 thorton 2020-03-07 11:08:54 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review > Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 > - const Path m_path; > + mutable Path m_path; This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? 1627260 15 392801 darin 2020-03-07 11:29:21 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review I would like to see a refinement that puts more/most of this into the platform-independent source file, even if only used by CG at this time. > Source/WebCore/platform/graphics/Path.h:228 > + enum class NoInlineDataType : uint8_t { NoInlineData = 0 }; In many cases in other classes we std::nullptr_t for this. I don’t think "NoInlineData" is better than "nullptr". >> Source/WebCore/platform/graphics/Path.h:233 >> + struct LineData { > > Feels weird that this is in USE(CG). Should it be in a ENABLE(PLATFORM_INDEPENDENT_PATHS) (probably not that name) that is only on in CG for now? I assume the reason that you didn't is that it still needs the platform path to fall back on if it's not one of the simple types? But even that could be true for the other graphics frameworks. Related: I think it’s OK to define but not use cross-platform things like this that could be used later. This entire block could probably be unconditional even if at the moment it’s only used for CG. I feel that way even about the swap function. I’d like to see less of this inside #if USE(CG). > Source/WebCore/platform/graphics/Path.h:268 > + template <typename DataType> > + bool hasInlineDataOfType() const My preferred formatting for this is: template<typename DataType> bool hasInlineDataOfType() const Leaving out the space and line break that others often include in such cases. Would be nice to have a shorter name. Including "OfType" in the name seems inelegant. > Source/WebCore/platform/graphics/Path.h:276 > + bool hasInlineData() const > + { > + return !hasInlineDataOfType<NoInlineDataType>(); > + } Why inline in the class? How about putting this below with the other inlines? > Source/WebCore/platform/graphics/cg/PathCG.cpp:103 > + if (!m_path) > + m_path = adoptCF(CGPathCreateMutable()); This is the only platform-specfiic part. If we broke it out into a separate function the rest of this could be in Path.cpp. > Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1197 > + context.strokePath(std::exchange(m_path, { })); Is this for correctness or performance? If for performance then use WTFMove. If correctness, then std::exchange is fine. >> Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 >> + mutable Path m_path; > > This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? I agree completely. We should do that. Just make a couple more functions const and use mutable *inside* Path. 1627354 16 392801 wenson_hsieh 2020-03-07 16:24:22 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review >> Source/WebCore/platform/graphics/Path.h:228 >> + enum class NoInlineDataType : uint8_t { NoInlineData = 0 }; > > In many cases in other classes we std::nullptr_t for this. I don’t think "NoInlineData" is better than "nullptr". This is what I tried initially, but then I realized that std::nullptr_t isn’t currently supported when encoding/decoding. I’ve learned from Antti that I can just Monostate to represent the empty value in a Variant instead, so I think I’ll do that (and implement Encoder/Decoder support for it in ArgumentCoders). >>> Source/WebCore/platform/graphics/Path.h:233 >>> + struct LineData { >> >> Feels weird that this is in USE(CG). Should it be in a ENABLE(PLATFORM_INDEPENDENT_PATHS) (probably not that name) that is only on in CG for now? I assume the reason that you didn't is that it still needs the platform path to fall back on if it's not one of the simple types? But even that could be true for the other graphics frameworks. > > Related: I think it’s OK to define but not use cross-platform things like this that could be used later. This entire block could probably be unconditional even if at the moment it’s only used for CG. I feel that way even about the swap function. I’d like to see less of this inside #if USE(CG). Sounds good. I’ll move this into a separate (platform-independent) file, InlinePathData.h >> Source/WebCore/platform/graphics/Path.h:268 >> + bool hasInlineDataOfType() const > > My preferred formatting for this is: > > template<typename DataType> bool hasInlineDataOfType() const > > Leaving out the space and line break that others often include in such cases. Would be nice to have a shorter name. Including "OfType" in the name seems inelegant. Ah, this particular name choice was influenced by the -OfType suffix in childrenOfType/ancestorsOfType. I’ll contract it to just hasInlineData<Foo>(), and rename what is currently hasInlineData() to hasAnyInlineData(). >> Source/WebCore/platform/graphics/Path.h:276 >> + } > > Why inline in the class? How about putting this below with the other inlines? 👍🏻 Moved below. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:103 >> + m_path = adoptCF(CGPathCreateMutable()); > > This is the only platform-specfiic part. If we broke it out into a separate function the rest of this could be in Path.cpp. Okay, I’ll add new private helpers then: `static PlatformPathStorageType createPlatformPath();` (which returns a newly created path) `static void applyInlinePathData(const InlinePathData&, PlatformPathPtr);` (which applies inline data to a platform path pointer). …which I'll use in Path.cpp, to make this code platform-agnostic. >> Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1197 >> + context.strokePath(std::exchange(m_path, { })); > > Is this for correctness or performance? If for performance then use WTFMove. If correctness, then std::exchange is fine. It’s for performance, but if we’re going to keep `const Path m_path;`, then neither of these will work. I’ve instead added `void deletePlatformPath() const` method on Path, which I’m calling here after I’m done with the path. >>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 >>> + mutable Path m_path; >> >> This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? > > I agree completely. We should do that. Just make a couple more functions const and use mutable *inside* Path. Okay — I’ve added `void deletePlatformPath() const` instead. 1627383 17 392801 darin 2020-03-07 17:23:18 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review >>> Source/WebCore/platform/graphics/Path.h:268 >>> + bool hasInlineDataOfType() const >> >> My preferred formatting for this is: >> >> template<typename DataType> bool hasInlineDataOfType() const >> >> Leaving out the space and line break that others often include in such cases. Would be nice to have a shorter name. Including "OfType" in the name seems inelegant. > > Ah, this particular name choice was influenced by the -OfType suffix in childrenOfType/ancestorsOfType. > > I’ll contract it to just hasInlineData<Foo>(), and rename what is currently hasInlineData() to hasAnyInlineData(). Antti, originator of ancestorsOfType, recently suggested that I remove the "OfType" from that function’s name. Part of why we haven’t done it yet is that we are not sure that childrenOfType should be renamed to just children. >>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1197 >>> + context.strokePath(std::exchange(m_path, { })); >> >> Is this for correctness or performance? If for performance then use WTFMove. If correctness, then std::exchange is fine. > > It’s for performance, but if we’re going to keep `const Path m_path;`, then neither of these will work. > > I’ve instead added `void deletePlatformPath() const` method on Path, which I’m calling here after I’m done with the path. That sounds wrong. A secret "destroy this while pretending it’s const"? Consider if this was a unique_ptr; is that what we’d want to do? >>>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 >>>> + mutable Path m_path; >>> >>> This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? >> >> I agree completely. We should do that. Just make a couple more functions const and use mutable *inside* Path. > > Okay — I’ve added `void deletePlatformPath() const` instead. Now I regret making this suggestion! 1627387 18 392801 wenson_hsieh 2020-03-07 17:29:30 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review >>>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1197 >>>> + context.strokePath(std::exchange(m_path, { })); >>> >>> Is this for correctness or performance? If for performance then use WTFMove. If correctness, then std::exchange is fine. >> >> It’s for performance, but if we’re going to keep `const Path m_path;`, then neither of these will work. >> >> I’ve instead added `void deletePlatformPath() const` method on Path, which I’m calling here after I’m done with the path. > > That sounds wrong. A secret "destroy this while pretending it’s const"? Consider if this was a unique_ptr; is that what we’d want to do? Probably not! >>>>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 >>>>> + mutable Path m_path; >>>> >>>> This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? >>> >>> I agree completely. We should do that. Just make a couple more functions const and use mutable *inside* Path. >> >> Okay — I’ve added `void deletePlatformPath() const` instead. > > Now I regret making this suggestion! Yeah, I’m not sure how to best go about this :/ I agree that making m_path mutable in the display list item is weird; I also agree that adding the const “delete my platform path” method is strange. Maybe we could just make this `Path m_path`, and then change DisplayList::Item::apply() to be non-const (in other words, view individual display list items as disposable for the purposes of display list playback). In any case, would you be okay with just making this `mutable Path m_path` for now and WTFMove-ing in StrokePath::apply? 1627394 19 392801 darin 2020-03-07 17:52:36 -0800 Comment on attachment 392801 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=392801&action=review >>>>>> Source/WebCore/platform/graphics/displaylists/DisplayListItems.h:2528 >>>>>> + mutable Path m_path; >>>>> >>>>> This seems slightly unfortunate, I don't think we really expect display list items to mutate once created. Maybe we can hide the externally-invisible-mutability inside Path? >>>> >>>> I agree completely. We should do that. Just make a couple more functions const and use mutable *inside* Path. >>> >>> Okay — I’ve added `void deletePlatformPath() const` instead. >> >> Now I regret making this suggestion! > > Yeah, I’m not sure how to best go about this :/ I agree that making m_path mutable in the display list item is weird; I also agree that adding the const “delete my platform path” method is strange. > > Maybe we could just make this `Path m_path`, and then change DisplayList::Item::apply() to be non-const (in other words, view individual display list items as disposable for the purposes of display list playback). > > In any case, would you be okay with just making this `mutable Path m_path` for now and WTFMove-ing in StrokePath::apply? Yes. 1627399 20 392922 wenson_hsieh 2020-03-07 18:10:26 -0800 Created attachment 392922 v3 1627400 21 392923 wenson_hsieh 2020-03-07 18:14:34 -0800 Created attachment 392923 v3 (rebased on trunk) 1627402 22 392924 wenson_hsieh 2020-03-07 18:19:24 -0800 Created attachment 392924 v3 (fix GTK/WPE builds) 1627416 23 392930 wenson_hsieh 2020-03-07 19:20:09 -0800 Created attachment 392930 v3 1627460 24 392930 darin 2020-03-07 21:02:27 -0800 Comment on attachment 392930 v3 View in context: https://bugs.webkit.org/attachment.cgi?id=392930&action=review > Source/WebCore/platform/graphics/Path.cpp:209 > +#if ENABLE(INLINE_PATH_DATA) > + > +void Path::applyInlinePathDataIfNeeded() const > +{ > + if (!m_needsToApplyInlineData) > + return; > + > + m_needsToApplyInlineData = false; > + > + if (!hasAnyInlineData()) > + return; > + > + if (!m_path) > + m_path = createPlatformPath(); > + > + applyInlinePathData(m_inlineData, m_path.get()); > +} > + > +#endif // ENABLE(INLINE_PATH_DATA) I was wrong to say that this function is platform-independent. It’s not. It should be deleted. > Source/WebCore/platform/graphics/Path.h:252 > + mutable bool m_needsToApplyInlineData { false }; This boolean is redundant. When we have inline data and m_path is null, this is always true. When we have inline data and m_path is non-null, this is always false. This function will always return the same thing as this boolean: bool needsToApplyInlineData() const { return !m_path && hasAnyInlineData(); } So please get rid of this boolean and all the code that manages it. > Source/WebCore/platform/graphics/cg/PathCG.cpp:90 > +RetainPtr<CGMutablePathRef> Path::createPlatformPath() > +{ > + return adoptCF(CGPathCreateMutable()); > +} > + > +void Path::applyInlinePathData(const InlinePathData& data, CGMutablePathRef path) > +{ These functions should be merged into a single createPlatformPath function, a const function that does not take any arguments or return any values. It should start like this: if (m_path) return; m_path = adoptCF(CGPathCreateMutable()); WTF::switchOn(m_inlinePathData, [&](Monostate) { }, // Start with an empty path. > Source/WebCore/platform/graphics/cg/PathCG.cpp:92 > + [&](auto) { ASSERT_NOT_REACHED(); }, This seems really peculiar. We want to get a compiler error if there’s any type of data we fail to handle. But including this "auto" case means we won’t get that. This should just cover Monostate, I think, not auto. > Source/WebCore/platform/graphics/cg/PathCG.cpp:263 > + CGPathAddPath(path.get(), &transformCG, ensurePlatformPath()); This should be platformPath(), not ensurePlatformPath(). And we should explicitly set m_inlineData = Monostate { } after setting m_path below. > Source/WebCore/platform/graphics/cg/PathCG.cpp:265 > + auto path = adoptCF(CGPathCreateMutableCopyByTransformingPath(ensurePlatformPath(), &transformCG)); Ditto. > Source/WebCore/platform/graphics/cg/PathCG.cpp:274 > return CGRectZero; This should return { } rather than CGRectZero. I see no reason to make this different than the line below. > Source/WebCore/platform/graphics/cg/PathCG.cpp:295 > return CGRectZero; This should return { } rather than CGRectZero. I see no reason to make this different than the line below. > Source/WebCore/platform/graphics/cg/PathCG.cpp:308 > + CGRect bound = CGPathGetBoundingBox(platformPath()); > return CGRectIsNull(bound) ? CGRectZero : bound; Why do we have two different boundingRect functions? It seems that the boundingRect and fastBoundingRect function bodies are exactly the same. > Source/WebCore/platform/graphics/cg/PathCG.cpp:340 > + if (isNull() || hasInlineData<MoveData>()) { > + m_inlineData = MoveData { point }; > + m_needsToApplyInlineData = true; > + return; > + } This is the platform-independent code that I would like to share if possible. If we did that it means that the general case of moveTo needs to be renamed to something like moveToSlowCase or whatever we want to call the non-inline-data case. > Source/WebCore/platform/graphics/cg/PathCG.cpp:351 > + if (isNull() || hasInlineData<MoveData>()) { > + m_inlineData = LineData { hasAnyInlineData() ? WTF::get<MoveData>(m_inlineData).location : FloatPoint(), p }; > + m_needsToApplyInlineData = true; > + return; > + } Ditto. > Source/WebCore/platform/graphics/cg/PathCG.cpp:439 > + if (isNull() || hasInlineData<MoveData>()) { > + m_inlineData = ArcData { hasAnyInlineData() ? WTF::get<MoveData>(m_inlineData).location : FloatPoint(), p, radius, startAngle, endAngle, clockwise, hasAnyInlineData() }; > + m_needsToApplyInlineData = true; > + return; > + } Ditto. Probably have to share the workaround too. > Source/WebCore/platform/graphics/cg/PathCG.cpp:499 > + if (isNull()) > + return true; > + > + if (hasAnyInlineData()) > + return false; Would be nice to share this part. > Source/WebCore/platform/graphics/cg/PathCG.cpp:518 > if (isNull()) > - return FloatPoint(); > - return CGPathGetCurrentPoint(m_path.get()); > + return { }; > + > + if (hasInlineData<MoveData>()) > + return WTF::get<MoveData>(m_inlineData).location; > + > + if (hasInlineData<LineData>()) > + return WTF::get<LineData>(m_inlineData).end; Would be nice to share this part. > Source/WebCore/platform/graphics/cg/PathCG.cpp:572 > if (isNull()) > return; > > - CGPathApply(m_path.get(), (void*)&function, CGPathApplierToPathApplier); > + if (hasInlineData<MoveData>()) { > + PathElement element; > + element.type = PathElement::Type::MoveToPoint; > + element.points[0] = WTF::get<MoveData>(m_inlineData).location; > + function(element); > + return; > + } > + > + if (hasInlineData<LineData>()) { > + auto& line = WTF::get<LineData>(m_inlineData); > + PathElement element; > + element.type = PathElement::Type::MoveToPoint; > + element.points[0] = line.start; > + function(element); > + element.type = PathElement::Type::AddLineToPoint; > + element.points[0] = line.end; > + function(element); > + return; > + } Would be nice to share this part. > Source/WebCore/platform/graphics/cg/PathCG.cpp:585 > + if (hasInlineData<MoveData>()) > + return 1; > + > + if (hasInlineData<LineData>()) > + return 2; And this part. > Source/WebKit/Platform/IPC/ArgumentCoders.cpp:212 > +Optional<Monostate> ArgumentCoder<Monostate>::decode(Decoder& decoder) Should omit the argument name "decoder" since the value is unused. 1627465 25 392930 wenson_hsieh 2020-03-07 22:30:20 -0800 Comment on attachment 392930 v3 View in context: https://bugs.webkit.org/attachment.cgi?id=392930&action=review Thanks for the review! I’m partway through addressing your latest comments, and should have a v4 posted soon (I just need to pull some of this inlining logic into platform-agnostic methods in Path now, and add platform-y doFooSlowCase() versions of a few methods). Sorry for the back-and-forth. >> Source/WebCore/platform/graphics/Path.cpp:209 >> +#endif // ENABLE(INLINE_PATH_DATA) > > I was wrong to say that this function is platform-independent. It’s not. It should be deleted. Ok, deleted this. >> Source/WebCore/platform/graphics/Path.h:252 >> + mutable bool m_needsToApplyInlineData { false }; > > This boolean is redundant. When we have inline data and m_path is null, this is always true. When we have inline data and m_path is non-null, this is always false. This function will always return the same thing as this boolean: > > bool needsToApplyInlineData() const { return !m_path && hasAnyInlineData(); } > > So please get rid of this boolean and all the code that manages it. Good catch! Done. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:90 >> +{ > > These functions should be merged into a single createPlatformPath function, a const function that does not take any arguments or return any values. It should start like this: > > if (m_path) > return; > m_path = adoptCF(CGPathCreateMutable()); > WTF::switchOn(m_inlinePathData, > [&](Monostate) { }, // Start with an empty path. Okay. For clarity, where did you envision createPlatformPath() being used? This is currently being used in applyInlinePathDataIfNeeded(), but that’s going away based on your above comment. In my current WIP v4, I will be calling it in PathCG.cpp, in Path::platformPath() and Path::ensurePlatformPath(). >> Source/WebCore/platform/graphics/cg/PathCG.cpp:92 >> + [&](auto) { ASSERT_NOT_REACHED(); }, > > This seems really peculiar. We want to get a compiler error if there’s any type of data we fail to handle. But including this "auto" case means we won’t get that. This should just cover Monostate, I think, not auto. Okay, changed to `Monostate` instead of just auto. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:263 >> + CGPathAddPath(path.get(), &transformCG, ensurePlatformPath()); > > This should be platformPath(), not ensurePlatformPath(). And we should explicitly set m_inlineData = Monostate { } after setting m_path below. Done. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:265 >> + auto path = adoptCF(CGPathCreateMutableCopyByTransformingPath(ensurePlatformPath(), &transformCG)); > > Ditto. Done. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:274 >> return CGRectZero; > > This should return { } rather than CGRectZero. I see no reason to make this different than the line below. Ok. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:295 >> return CGRectZero; > > This should return { } rather than CGRectZero. I see no reason to make this different than the line below. Ok. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:308 >> return CGRectIsNull(bound) ? CGRectZero : bound; > > Why do we have two different boundingRect functions? It seems that the boundingRect and fastBoundingRect function bodies are exactly the same. Pulled this out into a helper function. >> Source/WebKit/Platform/IPC/ArgumentCoders.cpp:212 >> +Optional<Monostate> ArgumentCoder<Monostate>::decode(Decoder& decoder) > > Should omit the argument name "decoder" since the value is unused. Done. 1627474 26 392930 wenson_hsieh 2020-03-07 23:21:26 -0800 Comment on attachment 392930 v3 View in context: https://bugs.webkit.org/attachment.cgi?id=392930&action=review I also noticed that hasCurrentPoint() was implemented on all three platforms as !isEmpty(), so I also pulled that out into platform-agnostic code in Path.cpp while I was at it. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:340 >> + } > > This is the platform-independent code that I would like to share if possible. If we did that it means that the general case of moveTo needs to be renamed to something like moveToSlowCase or whatever we want to call the non-inline-data case. Done. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:351 >> + } > > Ditto. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:439 >> + } > > Ditto. Probably have to share the workaround too. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:499 >> + return false; > > Would be nice to share this part. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:518 >> + return WTF::get<LineData>(m_inlineData).end; > > Would be nice to share this part. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:572 >> + } > > Would be nice to share this part. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:585 >> + return 2; > > And this part. 👍🏻 1627476 27 392942 wenson_hsieh 2020-03-07 23:43:14 -0800 Created attachment 392942 v4 1627478 28 392930 wenson_hsieh 2020-03-07 23:58:11 -0800 Comment on attachment 392930 v3 View in context: https://bugs.webkit.org/attachment.cgi?id=392930&action=review >>> Source/WebCore/platform/graphics/cg/PathCG.cpp:308 >>> return CGRectIsNull(bound) ? CGRectZero : bound; >> >> Why do we have two different boundingRect functions? It seems that the boundingRect and fastBoundingRect function bodies are exactly the same. > > Pulled this out into a helper function. Oops, I just realized I misread your earlier comment. It seems there are two different bounding rect functions because they compute different things; fastBoundingRect is the bounding rect of the path, expanded to include the path’s control points, whereas boundingRect is the bounding rect of the path without necessarily including the control points. 1627518 29 392942 dbates 2020-03-08 10:39:04 -0700 Comment on attachment 392942 v4 View in context: https://bugs.webkit.org/attachment.cgi?id=392942&action=review This patch looks good. > Source/WebCore/platform/graphics/InlinePathData.h:48 > + float start { 0 }; This is ok as-is. No change is needed. A better name would be startAngle and endAngle for these fields with a comment that these are in radians or degrees or whatever unit because: 1. Makes it a tiny bit more clear what these are. 2. It breaks symmetry with LineData's identically named, but different purpose fields. <-- this is good because it matches intuition: different concepts should be given different names. > Source/WebCore/platform/graphics/InlinePathData.h:51 > + bool hasOffset { false }; This is ok as-is. No change is needed. The optimal solution is to use Optional<FloatPoint> for the offset because: 1. It is the modern C++ way 2. Can remove this bool (the Optional has one) 3. Because of (1) more likely a person will remember to check if offset is not nullopt over a separate bool due to API conveniences. This means less error prone to use this data. > Source/WebCore/platform/graphics/InlinePathData.h:74 > + return { data }; This is ok as-is. No change is needed. The braces are not needed. > Source/WebCore/platform/graphics/InlinePathData.h:92 > + return { WTFMove(data) }; This is ok as-is. No change is needed. The optimal solution is to just return data because: 1. Takes advantage of RVO > Source/WebCore/platform/graphics/InlinePathData.h:130 > + return { WTFMove(data) }; Ditto. > Source/WebCore/platform/graphics/Path.cpp:253 > + m_inlineData = ArcData { hasAnyInlineData() ? WTF::get<MoveData>(m_inlineData).location : FloatPoint(), point, radius, startAngle, endAngle, anticlockwise, hasAnyInlineData() }; This is ok-is. No change is needed. The optimal solution would be to initialize each struct member individually then move the struct into the the instance variable because: 1. The names of the fields are self describing so no need to ever have to consider argument order if in the future this struct is expanded. 2. Removes the need to EXPLICITLY initialize location if hasAnyInlineDate() is false. 3. There are many arguments to pass, which increases the chance of passing them in the wrong order in the future if the struct is expanded or layout changed. > Source/WebCore/platform/graphics/Path.h:322 > + return { WTFMove(path) }; This is ok as-is. No change needed. The optimal solution is to just return path for the same reasons outlined earlier in this patch. > Source/WebCore/platform/graphics/Path.h:386 > + return { WTFMove(path) }; Ditto. > Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1231 > + context.strokePath(WTFMove(m_path)); Is it OK to move this? If so, why? > Source/WebCore/platform/graphics/win/PathDirect2D.cpp:672 > + HRESULT hr = GraphicsContext::systemFactory()->CreateGeometryGroup(D2D1_FILL_MODE_WINDING, nullptr, 0, &m_path); This is ok as-is. No change needed. A better solution is to either: 1. Add inline comment to describe 0 Or 2. Define local with value 0 and pass it. Either one because it makes the purpose of the 0 clear. 1627519 30 392942 darin 2020-03-08 10:40:04 -0700 Comment on attachment 392942 v4 View in context: https://bugs.webkit.org/attachment.cgi?id=392942&action=review Looks great > Source/WebCore/platform/graphics/Path.cpp:196 > + applySlowCase(function); I think the paragraphing of all these functions with #if ENABLE(INLINE_PATH_DATA) sections works better if they have blank lines after #endif. > Source/WebCore/platform/graphics/Path.h:230 > + void createPlatformPath() const; I don’t think this is a cross-platform function. I suggest naming this createCGPath and making it CG-specific. The one for CG is quite different from the ones for Cairo and Direct2D. I believe those two aren’t called anywhere and also they don’t check m_path for null so they are not really the same kind of function. I know I keep harping on this, but the platformPath name is not really doing us any good. > Source/WebCore/platform/graphics/Path.h:233 > + static void applyInlinePathData(const InlinePathData&, PlatformPathPtr); Need to remove this. We don’t have this function any more. > Source/WebCore/platform/graphics/Path.h:234 > + template <typename DataType> bool hasInlineData() const; I prefer the format without a space after the word "template". > Source/WebCore/platform/graphics/Path.h:237 > + bool needsToApplyInlineData() const { return !m_path && hasAnyInlineData(); } Not sure we need this function. It’s called in only one place. > Source/WebCore/platform/graphics/cairo/PathCairo.cpp:450 > +void Path::createPlatformPath() const > +{ > + m_path = new CairoPath; > +} Dead code, lets not add this. > Source/WebCore/platform/graphics/cg/PathCG.cpp:94 > + CGPathMoveToPoint(m_path.get(), nullptr, move.location.x(), move.location.y()); This needs to be indented four more spaces. > Source/WebCore/platform/graphics/cg/PathCG.cpp:276 > // CGPathGetBoundingBox includes the path's control points, CGPathGetPathBoundingBox does not. Ah, I see the comment now. > Source/WebCore/platform/graphics/cg/PathCG.cpp:278 > + CGRect bound = CGPathGetPathBoundingBox(platformPath()); Seems like these functions could have used the "slow case" pattern. > Source/WebCore/platform/graphics/cg/PathCG.cpp:279 > return CGRectIsNull(bound) ? CGRectZero : bound; I think we should make a static inline helper function to do this to tidy up the two places we do it. Convert a CGRect to a FloatRect, converting null CGRect into zero floating rect. > Source/WebCore/platform/graphics/win/PathDirect2D.cpp:674 > +void Path::createPlatformPath() const > +{ > + HRESULT hr = GraphicsContext::systemFactory()->CreateGeometryGroup(D2D1_FILL_MODE_WINDING, nullptr, 0, &m_path); > + ASSERT(SUCCEEDED(hr)); > +} Dead code; lets not add this. 1627586 31 392942 wenson_hsieh 2020-03-08 14:52:07 -0700 Comment on attachment 392942 v4 View in context: https://bugs.webkit.org/attachment.cgi?id=392942&action=review >> Source/WebCore/platform/graphics/InlinePathData.h:48 >> + float start { 0 }; > > This is ok as-is. No change is needed. A better name would be startAngle and endAngle for these fields with a comment that these are in radians or degrees or whatever unit because: > > 1. Makes it a tiny bit more clear what these are. > 2. It breaks symmetry with LineData's identically named, but different purpose fields. <-- this is good because it matches intuition: different concepts should be given different names. Good point! Renamed to startAngle and endAngle. >> Source/WebCore/platform/graphics/InlinePathData.h:51 >> + bool hasOffset { false }; > > This is ok as-is. No change is needed. The optimal solution is to use Optional<FloatPoint> for the offset because: > > 1. It is the modern C++ way > 2. Can remove this bool (the Optional has one) > 3. Because of (1) more likely a person will remember to check if offset is not nullopt over a separate bool due to API conveniences. This means less error prone to use this data. Ah, so I tried this at some point (Optional<FloatPoint> offset;), but found that it bumped the size of Path up from 48 to 56 bytes :( With the optional: whsieh@Wenson-Desktop-2 OpenSource % dump-class-layout ~/Build/Release/WebCore.framework/WebCore Path +0 < 56> WebCore::Path +0 < 8> PlatformPathStorageType m_path +0 < 8> StorageType m_ptr +8 < 40> WebCore::InlinePathData m_inlineData +8 < 1> WTF::__variant_base<WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>, true> WTF::__variant_base<WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>, true> +8 < 36> WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>::__storage_type __storage +44 < 1> WTF::__discriminator_type<4, false, false, false>::__type __index +45 < 3> <PADDING: 3 bytes> +48 < 1> bool m_copyPathBeforeMutation +49 < 7> <PADDING: 7 bytes> Total byte size: 56 Total pad bytes: 10 Padding percentage: 17.86 % …and with the bool: whsieh@Wenson-Desktop-2 OpenSource % dump-class-layout ~/Build/Release/WebCore.framework/WebCore Path +0 < 48> WebCore::Path +0 < 8> PlatformPathStorageType m_path +0 < 8> StorageType m_ptr +8 < 36> WebCore::InlinePathData m_inlineData +8 < 1> WTF::__variant_base<WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>, true> WTF::__variant_base<WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>, true> +8 < 32> WTF::Variant<WTF::Monostate, WebCore::MoveData, WebCore::LineData, WebCore::ArcData>::__storage_type __storage +40 < 1> WTF::__discriminator_type<4, false, false, false>::__type __index +41 < 3> <PADDING: 3 bytes> +44 < 1> bool m_copyPathBeforeMutation +45 < 3> <PADDING: 3 bytes> Total byte size: 48 Total pad bytes: 6 Padding percentage: 12.50 % The problem seems to be that ArcData’s optional offset internally has 3 byte of padding, in which I unfortunately can’t fit any other members of the struct: +0 < 36> WebCore::ArcData +0 < 12> WTF::Optional<WebCore::FloatPoint> offset +0 < 12> WTF::OptionalBase<WebCore::FloatPoint> WTF::OptionalBase<WebCore::FloatPoint> +0 < 1> bool init_ +1 < 3> <PADDING: 3 bytes> +4 < 8> WTF::constexpr_storage_t<WebCore::FloatPoint> storage_ +12 < 8> WebCore::FloatPoint center +12 < 4> float m_x +16 < 4> float m_y +20 < 4> float radius +24 < 4> float startAngle +28 < 4> float endAngle +32 < 1> bool clockwise +33 < 3> <PADDING: 3 bytes> I certainly agree that the Optional is more idiomatic, and it’s possible an extra 8 bytes per Path isn’t going to have any noticeable effect. For the time being, I’ll stick with the bool and FloatPoint, but I’ll give this some more thought. >> Source/WebCore/platform/graphics/InlinePathData.h:74 >> + return { data }; > > This is ok as-is. No change is needed. The braces are not needed. Removed the braces. >> Source/WebCore/platform/graphics/InlinePathData.h:92 >> + return { WTFMove(data) }; > > This is ok as-is. No change is needed. The optimal solution is to just return data because: > > 1. Takes advantage of RVO Removed the braces and WTFMove. >> Source/WebCore/platform/graphics/InlinePathData.h:130 >> + return { WTFMove(data) }; > > Ditto. Removed the braces and WTFMove. >> Source/WebCore/platform/graphics/Path.cpp:196 >> + applySlowCase(function); > > I think the paragraphing of all these functions with #if ENABLE(INLINE_PATH_DATA) sections works better if they have blank lines after #endif. Sounds good! Added newlines after these #endifs >> Source/WebCore/platform/graphics/Path.cpp:253 >> + m_inlineData = ArcData { hasAnyInlineData() ? WTF::get<MoveData>(m_inlineData).location : FloatPoint(), point, radius, startAngle, endAngle, anticlockwise, hasAnyInlineData() }; > > This is ok-is. No change is needed. The optimal solution would be to initialize each struct member individually then move the struct into the the instance variable because: > > 1. The names of the fields are self describing so no need to ever have to consider argument order if in the future this struct is expanded. > 2. Removes the need to EXPLICITLY initialize location if hasAnyInlineDate() is false. > 3. There are many arguments to pass, which increases the chance of passing them in the wrong order in the future if the struct is expanded or layout changed. Fair point! Fixed. This also made me realize that there’s a naming discrepancy between the PathCG and the other platforms for the final argument to addArc (anticlockwise or clockwise). Before this patch, the last argument to addArc for CG ports is clockwise, whereas it is anticlockwise for Direct2D and Cairo. In this patch, I opted to not change any behavior and just plumb the flag through, but it looks like this should be followed up. I added a FIXME for this. >> Source/WebCore/platform/graphics/Path.h:230 >> + void createPlatformPath() const; > > I don’t think this is a cross-platform function. I suggest naming this createCGPath and making it CG-specific. The one for CG is quite different from the ones for Cairo and Direct2D. I believe those two aren’t called anywhere and also they don’t check m_path for null so they are not really the same kind of function. > > I know I keep harping on this, but the platformPath name is not really doing us any good. Ah, okay, that makes much more sense. Changed to createCGPath and make it only for USE(CG). I agree with the platformPath naming not being great, since nothing outside of Path.h uses platformPath without already knowing exactly what kind of path it’s going to be — I still intend to follow up with a cleanup patch for that! >> Source/WebCore/platform/graphics/Path.h:233 >> + static void applyInlinePathData(const InlinePathData&, PlatformPathPtr); > > Need to remove this. We don’t have this function any more. Whoops, good catch! Removed. >> Source/WebCore/platform/graphics/Path.h:234 >> + template <typename DataType> bool hasInlineData() const; > > I prefer the format without a space after the word "template". Fixed. >> Source/WebCore/platform/graphics/Path.h:237 >> + bool needsToApplyInlineData() const { return !m_path && hasAnyInlineData(); } > > Not sure we need this function. It’s called in only one place. Okay — removed the function. >> Source/WebCore/platform/graphics/Path.h:322 >> + return { WTFMove(path) }; > > This is ok as-is. No change needed. The optimal solution is to just return path for the same reasons outlined earlier in this patch. Okay, changed to just `return path;` >> Source/WebCore/platform/graphics/Path.h:386 >> + return { WTFMove(path) }; > > Ditto. Fixed. >> Source/WebCore/platform/graphics/cairo/PathCairo.cpp:450 >> +} > > Dead code, lets not add this. 👍🏻 >> Source/WebCore/platform/graphics/cg/PathCG.cpp:94 >> + CGPathMoveToPoint(m_path.get(), nullptr, move.location.x(), move.location.y()); > > This needs to be indented four more spaces. Whoops, fixed. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:278 >> + CGRect bound = CGPathGetPathBoundingBox(platformPath()); > > Seems like these functions could have used the "slow case" pattern. Sounds good — pulled the implementation of these into Path.cpp, with private -SlowCase methods per platform. >> Source/WebCore/platform/graphics/cg/PathCG.cpp:279 >> return CGRectIsNull(bound) ? CGRectZero : bound; > > I think we should make a static inline helper function to do this to tidy up the two places we do it. Convert a CGRect to a FloatRect, converting null CGRect into zero floating rect. Yep, pulled this out into a static inline helper. >> Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp:1231 >> + context.strokePath(WTFMove(m_path)); > > Is it OK to move this? If so, why? It’s okay to move this, because we don’t need the path anymore after applying the display list item. >> Source/WebCore/platform/graphics/win/PathDirect2D.cpp:672 >> + HRESULT hr = GraphicsContext::systemFactory()->CreateGeometryGroup(D2D1_FILL_MODE_WINDING, nullptr, 0, &m_path); > > This is ok as-is. No change needed. A better solution is to either: > 1. Add inline comment to describe 0 > > Or > > 2. Define local with value 0 and pass it. > > Either one because it makes the purpose of the 0 clear. Ah, I’ve removed this method altogether. >> Source/WebCore/platform/graphics/win/PathDirect2D.cpp:674 >> +} > > Dead code; lets not add this. Removed! 1627591 32 392991 wenson_hsieh 2020-03-08 15:11:16 -0700 Created attachment 392991 For EWS 1627608 33 wenson_hsieh 2020-03-08 16:13:51 -0700 Committed r258118: <https://trac.webkit.org/changeset/258118> 392634 2020-03-05 15:18:57 -0800 2020-03-05 16:56:29 -0800 Work in progress bug-208464-20200305151856.patch text/plain 18291 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3ODQyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOGRjYzNlODA1NjI0NGRm NDMzMDk5YTE4YTI5MTViMmFhYjBhODJiYi4uMmVkNDkzMWU4YTRkNzIwY2RlZjkxMmVjNDU4YmNk MGVhYmEzMTM3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDIwLTAzLTA1ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIExhemlseSBnZW5l cmF0ZSBDR1BhdGhzIGZvciBzb21lIHNpbXBsZSB0eXBlcyBvZiBwYXRocywgc3VjaCBhcyBhcmNz IGFuZCBsaW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjA4NDY0CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTk2MzIyNj4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXb3JrIGluIHByb2dyZXNzIHBh dGNoLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oOgorICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmRlY29k ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OnJlY3RDb250YWluaW5nUG9pbnRzKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6 OmFwcGx5SW5saW5lUGF0aERhdGEgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxh dGZvcm1QYXRoIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3Jt UGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6UGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpzd2FwKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OmNvbnRhaW5zIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OnRyYW5zZm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpib3VuZGluZ1JlY3Qg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZmFzdEJvdW5kaW5nUmVjdCBjb25zdCk6 CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjptb3ZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0 aDo6YWRkTGluZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc0VtcHR5 IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmN1cnJlbnRQb2ludCBjb25zdCk6Cisg ICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQ YXRoOjplbGVtZW50Q291bnQgY29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Rp c3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRpc3Bs YXlMaXN0OjpTdHJva2VQYXRoOjphcHBseSBjb25zdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaDoKKwogMjAyMC0wMy0wMiAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBPcHRpbWl6ZSBQ YXRoOjplbmNvZGUgb24gcGxhdGZvcm1zIHRoYXQgc3VwcG9ydCBDR1BhdGhHZXROdW1iZXJPZkVs ZW1lbnRzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRo LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKaW5kZXggN2ZhZGE2 MGQ4M2MyOTI1MGFjNGExNzQ4YTg5MjQwNzAyOTE5OWUxYi4uYjhkMmU4NGVjYTI0MjFhMGNiMTVi ZDE0ODNkNzVkNzMwNDEzODg3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Bh dGguaApAQCAtMTQ3LDcgKzE0Nyw3IEBAIHB1YmxpYzoKICAgICBGbG9hdFBvaW50IHBvaW50QXRM ZW5ndGgoZmxvYXQgbGVuZ3RoKSBjb25zdDsKIAogICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgY2xl YXIoKTsKLSAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICFtX3BhdGg7IH0KKyAgICBX RUJDT1JFX0VYUE9SVCBib29sIGlzTnVsbCgpIGNvbnN0OwogICAgIGJvb2wgaXNFbXB0eSgpIGNv bnN0OwogICAgIC8vIEdldHMgdGhlIGN1cnJlbnQgcG9pbnQgb2YgdGhlIGN1cnJlbnQgcGF0aCwg d2hpY2ggaXMgY29uY2VwdHVhbGx5IHRoZSBmaW5hbCBwb2ludCByZWFjaGVkIGJ5IHRoZSBwYXRo IHNvIGZhci4KICAgICAvLyBOb3RlIHRoZSBQYXRoIGNhbiBiZSBlbXB0eSAoaXNFbXB0eSgpID09 IHRydWUpIGFuZCBzdGlsbCBoYXZlIGEgY3VycmVudCBwb2ludC4KQEAgLTE4NSw3ICsxODUsNyBA QCBwdWJsaWM6CiAgICAgRmxvYXRSZWN0IGZhc3RCb3VuZGluZ1JlY3RGb3JTdHJva2UoY29uc3Qg UGxhdGZvcm1Db250ZXh0RGlyZWN0MkQmKSBjb25zdDsKICAgICBQbGF0Zm9ybVBhdGhQdHIgcGxh dGZvcm1QYXRoKCkgY29uc3QgeyByZXR1cm4gbV9wYXRoLmdldCgpOyB9CiAjZWxpZiBVU0UoQ0cp Ci0gICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0 aC5nZXQoKTsgfQorICAgIFdFQkNPUkVfRVhQT1JUIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBh dGgoKSBjb25zdDsKICNlbHNlCiAgICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNv bnN0IHsgcmV0dXJuIG1fcGF0aDsgfQogI2VuZGlmCkBAIC0yMjYsNiArMjI2LDQ0IEBAIHB1Ymxp YzoKIAogcHJpdmF0ZToKICNpZiBVU0UoQ0cpCisgICAgZW51bSBjbGFzcyBJbmxpbmVEYXRhVHlw ZSA6IHVpbnQ4X3QgeworICAgICAgICBDbGVhcmVkID0gMCwKKyAgICAgICAgTW92ZSwKKyAgICAg ICAgQXJjLAorICAgICAgICBMaW5lLAorICAgICAgICBDb21wbGV4CisgICAgfTsKKworICAgIHN0 cnVjdCBMaW5lRGF0YSB7CisgICAgICAgIEZsb2F0UG9pbnQgc3RhcnQ7CisgICAgICAgIEZsb2F0 UG9pbnQgZW5kOworICAgIH07CisKKyAgICBzdHJ1Y3QgQXJjRGF0YSB7CisgICAgICAgIEZsb2F0 UG9pbnQgb2Zmc2V0OworICAgICAgICBGbG9hdFBvaW50IGNlbnRlcjsKKyAgICAgICAgZmxvYXQg cmFkaXVzIHsgMCB9OworICAgICAgICBmbG9hdCBzdGFydCB7IDAgfTsKKyAgICAgICAgZmxvYXQg ZW5kIHsgMCB9OworICAgICAgICBib29sIGNsb2Nrd2lzZSB7IGZhbHNlIH07CisgICAgICAgIGJv b2wgaGFzT2Zmc2V0IHsgZmFsc2UgfTsKKyAgICB9OworCisgICAgc3RydWN0IE1vdmVEYXRhIHsK KyAgICAgICAgRmxvYXRQb2ludCBsb2NhdGlvbjsKKyAgICB9OworCisgICAgdW5pb24gSW5saW5l UGF0aERhdGEgeworICAgICAgICBJbmxpbmVQYXRoRGF0YSgpCisgICAgICAgICAgICA6IG1vdmUo eyBGbG9hdFBvaW50KCkgfSkKKyAgICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgTW92ZURh dGEgbW92ZTsKKyAgICAgICAgTGluZURhdGEgbGluZTsKKyAgICAgICAgQXJjRGF0YSBhcmM7Cisg ICAgfTsKKyAgICB2b2lkIGFwcGx5SW5saW5lUGF0aERhdGEoKSBjb25zdDsKICAgICB2b2lkIHN3 YXAoUGF0aCYpOwogI2VuZGlmCiAKQEAgLTIzOCwxNCArMjc2LDQzIEBAIHByaXZhdGU6CiAjZW5k aWYKIAogI2lmIFVTRShDRykKKyAgICBJbmxpbmVQYXRoRGF0YSBtX2lubGluZURhdGE7CisgICAg SW5saW5lRGF0YVR5cGUgbV9pbmxpbmVEYXRhVHlwZSB7IElubGluZURhdGFUeXBlOjpDbGVhcmVk IH07CiAgICAgbXV0YWJsZSBib29sIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiB7IGZhbHNlIH07 Ci0jZW5kaWYKKyAgICBtdXRhYmxlIGJvb2wgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhIHsgZmFs c2UgfTsKKyNlbmRpZiAvLyBVU0UoQ0cpCiB9OwogCiBXVEY6OlRleHRTdHJlYW0mIG9wZXJhdG9y PDwoV1RGOjpUZXh0U3RyZWFtJiwgY29uc3QgUGF0aCYpOwogCiB0ZW1wbGF0ZTxjbGFzcyBFbmNv ZGVyPiB2b2lkIFBhdGg6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAogeworI2lmIFVT RShDRykKKyAgICBlbmNvZGVyIDw8IHN0YXRpY19jYXN0PHVpbnQ4X3Q+KG1faW5saW5lRGF0YVR5 cGUpOworCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUp IHsKKyAgICAgICAgZW5jb2RlciA8PCBtX2lubGluZURhdGEubW92ZS5sb2NhdGlvbjsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElubGluZURh dGFUeXBlOjpMaW5lKSB7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLmxpbmUuc3Rh cnQ7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLmxpbmUuZW5kOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5 cGU6OkFyYykgeworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5hcmMub2Zmc2V0Owor ICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5hcmMuY2VudGVyOworICAgICAgICBlbmNv ZGVyIDw8IG1faW5saW5lRGF0YS5hcmMucmFkaXVzOworICAgICAgICBlbmNvZGVyIDw8IG1faW5s aW5lRGF0YS5hcmMuc3RhcnQ7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLmFyYy5l bmQ7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLmFyYy5jbG9ja3dpc2U7CisgICAg ICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLmFyYy5oYXNPZmZzZXQ7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisjZW5kaWYgLy8gVVNFKENHKQorCiAgICAgZW5jb2RlciA8PCBzdGF0aWNfY2Fz dDx1aW50NjRfdD4oZWxlbWVudENvdW50KCkpOwogCiAgICAgYXBwbHkoWyZdKGF1dG8mIGVsZW1l bnQpIHsKQEAgLTI3Niw2ICszNDMsNjAgQEAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQ YXRoOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHRlbXBsYXRlPGNsYXNzIERlY29k ZXI+IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQogewogICAg IFBhdGggcGF0aDsKKworI2lmIFVTRShDRykKKyAgICB1aW50OF90IGlubGluZURhdGFUeXBlVmFs dWU7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShpbmxpbmVEYXRhVHlwZVZhbHVlKSkKKyAgICAg ICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIHBhdGgubV9pbmxpbmVEYXRhVHlwZSA9IHN0 YXRpY19jYXN0PElubGluZURhdGFUeXBlPihpbmxpbmVEYXRhVHlwZVZhbHVlKTsKKworICAgIGlm IChwYXRoLm1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUpIHsKKyAgICAg ICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YS5tb3ZlLmxvY2F0aW9uKSkK KyAgICAgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAgcGF0aC5tX25lZWRz VG9BcHBseUlubGluZURhdGEgPSB0cnVlOworICAgICAgICByZXR1cm4gcGF0aDsKKyAgICB9CisK KyAgICBpZiAocGF0aC5tX2lubGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpMaW5lKSB7 CisgICAgICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGF0aC5tX2lubGluZURhdGEubGluZS5zdGFy dCkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIGlmICghZGVj b2Rlci5kZWNvZGUocGF0aC5tX2lubGluZURhdGEubGluZS5lbmQpKQorICAgICAgICAgICAgcmV0 dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBwYXRoLm1fbmVlZHNUb0FwcGx5SW5saW5lRGF0 YSA9IHRydWU7CisgICAgICAgIHJldHVybiBwYXRoOworICAgIH0KKworICAgIGlmIChwYXRoLm1f aW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6OkFyYykgeworICAgICAgICBpZiAoIWRl Y29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmFyYy5vZmZzZXQpKQorICAgICAgICAgICAg cmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgu bV9pbmxpbmVEYXRhLmFyYy5jZW50ZXIpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9w dDsKKworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmFyYy5y YWRpdXMpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBpZiAo IWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmFyYy5zdGFydCkpCisgICAgICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGF0 aC5tX2lubGluZURhdGEuYXJjLmVuZCkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGF0aC5tX2lubGluZURhdGEuYXJjLmNs b2Nrd2lzZSkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIGlm ICghZGVjb2Rlci5kZWNvZGUocGF0aC5tX2lubGluZURhdGEuYXJjLmhhc09mZnNldCkpCisgICAg ICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9uZWVkc1RvQXBw bHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHBhdGg7CisgICAgfQorI2VuZGlm IC8vIFVTRShDRykKKwogICAgIHVpbnQ2NF90IG51bVBvaW50czsKICAgICBpZiAoIWRlY29kZXIu ZGVjb2RlKG51bVBvaW50cykpCiAgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAppbmRleCA1MjFjMTU1 M2E5YTZhMzRhMzgxYzM0Zjk3ODYyNTRkZDVmMGM3MjZlLi41MGRiZjJkZjk4OGE3ZTJkMzIzNGU3 OTJiYTRhNzAyYjcwMDIwMzNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jZy9QYXRoQ0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NnL1BhdGhDRy5jcHAKQEAgLTY1LDYgKzY1LDE1IEBAIHN0YXRpYyBpbmxpbmUgQ0dDb250 ZXh0UmVmIHNjcmF0Y2hDb250ZXh0KCkKICAgICByZXR1cm4gY29udGV4dDsKIH0KIAorc3RhdGlj IEZsb2F0UmVjdCByZWN0Q29udGFpbmluZ1BvaW50cyhGbG9hdFBvaW50IHBvaW50MSwgRmxvYXRQ b2ludCBwb2ludDIpCit7CisgICAgYXV0byBtaW5YID0gc3RkOjptaW4ocG9pbnQxLngoKSwgcG9p bnQyLngoKSk7CisgICAgYXV0byBtaW5ZID0gc3RkOjptaW4ocG9pbnQxLnkoKSwgcG9pbnQyLnko KSk7CisgICAgYXV0byBtYXhYID0gc3RkOjptYXgocG9pbnQxLngoKSwgcG9pbnQyLngoKSk7Cisg ICAgYXV0byBtYXhZID0gc3RkOjptYXgocG9pbnQxLnkoKSwgcG9pbnQyLnkoKSk7CisgICAgcmV0 dXJuIHsgbWluWCwgbWluWSwgbWF4WCAtIG1pblgsIG1heFkgLSBtaW5ZIH07Cit9CisKIFBhdGgg UGF0aDo6cG9seWdvblBhdGhGcm9tUG9pbnRzKGNvbnN0IFZlY3RvcjxGbG9hdFBvaW50PiYgcG9p bnRzKQogewogICAgIFBhdGggcGF0aDsKQEAgLTg5LDYgKzk4LDQ3IEBAIFBhdGg6OlBhdGgoUmV0 YWluUHRyPENHTXV0YWJsZVBhdGhSZWY+JiYgcGF0aCkKIFBhdGg6OlBhdGgoKSA9IGRlZmF1bHQ7 CiBQYXRoOjp+UGF0aCgpID0gZGVmYXVsdDsKIAordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhE YXRhKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgc3dpdGNoIChtX2lubGluZURhdGFUeXBlKSB7CisgICAgY2FzZSBJ bmxpbmVEYXRhVHlwZTo6TW92ZTogeworICAgICAgICBpZiAoIW1fcGF0aCkKKyAgICAgICAgICAg IG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsKKyAgICAgICAgQ0dQYXRo TW92ZVRvUG9pbnQobV9wYXRoLmdldCgpLCBudWxscHRyLCBtX2lubGluZURhdGEubW92ZS5sb2Nh dGlvbi54KCksIG1faW5saW5lRGF0YS5tb3ZlLmxvY2F0aW9uLnkoKSk7CisgICAgICAgIGJyZWFr OworICAgIH0KKyAgICBjYXNlIElubGluZURhdGFUeXBlOjpMaW5lOiB7CisgICAgICAgIGlmICgh bV9wYXRoKQorICAgICAgICAgICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxl KCkpOworICAgICAgICBhdXRvJiBsaW5lID0gbV9pbmxpbmVEYXRhLmxpbmU7CisgICAgICAgIENH UGF0aE1vdmVUb1BvaW50KG1fcGF0aC5nZXQoKSwgbnVsbHB0ciwgbGluZS5zdGFydC54KCksIGxp bmUuc3RhcnQueSgpKTsKKyAgICAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQobV9wYXRoLmdldCgp LCBudWxscHRyLCBsaW5lLmVuZC54KCksIGxpbmUuZW5kLnkoKSk7CisgICAgICAgIGJyZWFrOwor ICAgIH0KKyAgICBjYXNlIElubGluZURhdGFUeXBlOjpBcmM6IHsKKyAgICAgICAgaWYgKCFtX3Bh dGgpCisgICAgICAgICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7 CisgICAgICAgIGF1dG8mIGFyYyA9IG1faW5saW5lRGF0YS5hcmM7CisgICAgICAgIGlmIChhcmMu aGFzT2Zmc2V0KQorICAgICAgICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQobV9wYXRoLmdldCgpLCBu dWxscHRyLCBhcmMub2Zmc2V0LngoKSwgYXJjLm9mZnNldC55KCkpOworICAgICAgICBDR1BhdGhB ZGRBcmMobV9wYXRoLmdldCgpLCBudWxscHRyLCBhcmMuY2VudGVyLngoKSwgYXJjLmNlbnRlci55 KCksIGFyYy5yYWRpdXMsIGFyYy5zdGFydCwgYXJjLmVuZCwgYXJjLmNsb2Nrd2lzZSk7CisgICAg ICAgIGJyZWFrOworICAgIH0KKyAgICBkZWZhdWx0OgorICAgICAgICBicmVhazsKKyAgICB9Cisg ICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gZmFsc2U7Cit9CisKK1BsYXRmb3JtUGF0aFB0 ciBQYXRoOjpwbGF0Zm9ybVBhdGgoKSBjb25zdAoreworICAgIGFwcGx5SW5saW5lUGF0aERhdGEo KTsKKyAgICByZXR1cm4gbV9wYXRoLmdldCgpOworfQorCiBQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6 ZW5zdXJlUGxhdGZvcm1QYXRoKCkKIHsKICAgICBpZiAoIW1fcGF0aCkKQEAgLTk4LDEyICsxNDgs MjIgQEAgUGxhdGZvcm1QYXRoUHRyIFBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCgpCiAgICAgICAg ICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG1fcGF0aC5nZXQo KSkpOwogICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKICAgICB9Cisg ICAgYXBwbHlJbmxpbmVQYXRoRGF0YSgpOworICAgIG1faW5saW5lRGF0YVR5cGUgPSBJbmxpbmVE YXRhVHlwZTo6Q29tcGxleDsKICAgICByZXR1cm4gbV9wYXRoLmdldCgpOwogfQogCitib29sIFBh dGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGggJiYgbV9pbmxpbmVEYXRh VHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6Q2xlYXJlZDsKK30KKwogUGF0aDo6UGF0aChjb25zdCBQ YXRoJiBvdGhlcikKIHsKICAgICBtX3BhdGggPSB7IG90aGVyLm1fcGF0aCB9OworICAgIG1faW5s aW5lRGF0YSA9IG90aGVyLm1faW5saW5lRGF0YTsKKyAgICBtX2lubGluZURhdGFUeXBlID0gb3Ro ZXIubV9pbmxpbmVEYXRhVHlwZTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBvdGhl ci5tX25lZWRzVG9BcHBseUlubGluZURhdGE7CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAgICBt X2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQYXRo QmVmb3JlTXV0YXRpb24gPSB0cnVlOwpAQCAtMTEyLDE0ICsxNzIsMjAgQEAgUGF0aDo6UGF0aChj b25zdCBQYXRoJiBvdGhlcikKIAogUGF0aDo6UGF0aChQYXRoJiYgb3RoZXIpCiAgICAgOiBtX3Bh dGgoc3RkOjpleGNoYW5nZShvdGhlci5tX3BhdGgsIG51bGxwdHIpKQorICAgICwgbV9pbmxpbmVE YXRhKFdURk1vdmUob3RoZXIubV9pbmxpbmVEYXRhKSkKKyAgICAsIG1faW5saW5lRGF0YVR5cGUo c3RkOjpleGNoYW5nZShvdGhlci5tX2lubGluZURhdGFUeXBlLCBJbmxpbmVEYXRhVHlwZTo6Q2xl YXJlZCkpCiAgICAgLCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24oc3RkOjpleGNoYW5nZShvdGhl ci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24sIGZhbHNlKSkKKyAgICAsIG1fbmVlZHNUb0FwcGx5 SW5saW5lRGF0YShzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSwg ZmFsc2UpKQogewogfQogCiB2b2lkIFBhdGg6OnN3YXAoUGF0aCYgb3RoZXJQYXRoKQogewogICAg IHN0ZDo6c3dhcChtX3BhdGgsIG90aGVyUGF0aC5tX3BhdGgpOworICAgIHN0ZDo6c3dhcChtX2lu bGluZURhdGEsIG90aGVyUGF0aC5tX2lubGluZURhdGEpOworICAgIHN0ZDo6c3dhcChtX2lubGlu ZURhdGFUeXBlLCBvdGhlclBhdGgubV9pbmxpbmVEYXRhVHlwZSk7CiAgICAgc3RkOjpzd2FwKG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbiwgb3RoZXJQYXRoLm1fY29weVBhdGhCZWZvcmVNdXRhdGlv bik7CisgICAgc3RkOjpzd2FwKG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSwgb3RoZXJQYXRoLm1f bmVlZHNUb0FwcGx5SW5saW5lRGF0YSk7CiB9CiAKIFBhdGgmIFBhdGg6Om9wZXJhdG9yPShjb25z dCBQYXRoJiBvdGhlcikKQEAgLTE3OSw3ICsyNDUsNyBAQCBib29sIFBhdGg6OmNvbnRhaW5zKGNv bnN0IEZsb2F0UG9pbnQgJnBvaW50LCBXaW5kUnVsZSBydWxlKSBjb25zdAogICAgICAgICByZXR1 cm4gZmFsc2U7CiAKICAgICAvLyBDR1BhdGhDb250YWluc1BvaW50IHJldHVybnMgZmFsc2UgZm9y IG5vbi1jbG9zZWQgcGF0aHMsIGFzIGEgd29yay1hcm91bmQsIHdlIGNvcHkgYW5kIGNsb3NlIHRo ZSBwYXRoIGZpcnN0LiAgUmFkYXIgNDc1ODk5OCBhc2tzIGZvciBhIGJldHRlciBDRyBBUEkgdG8g dXNlCi0gICAgYXV0byBwYXRoID0gYWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhzKG1f cGF0aC5nZXQoKSkpOworICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoY29weUNHUGF0aENsb3NpbmdT dWJwYXRocyhwbGF0Zm9ybVBhdGgoKSkpOwogICAgIGJvb2wgcmV0ID0gQ0dQYXRoQ29udGFpbnNQ b2ludChwYXRoLmdldCgpLCAwLCBwb2ludCwgcnVsZSA9PSBXaW5kUnVsZTo6RXZlbk9kZCA/IHRy dWUgOiBmYWxzZSk7CiAgICAgcmV0dXJuIHJldDsKIH0KQEAgLTIxNyw5ICsyODMsOSBAQCB2b2lk IFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSkKICAgICBD R0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm1DRyA9IHRyYW5zZm9ybTsKICNpZiBQTEFURk9STShX SU4pCiAgICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlKCkpOwotICAg IENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBtX3BhdGguZ2V0KCkpOwor ICAgIENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBlbnN1cmVQbGF0Zm9y bVBhdGgoKSk7CiAjZWxzZQotICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0 YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgobV9wYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0cpKTsK KyAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5QnlUcmFuc2Zv cm1pbmdQYXRoKGVuc3VyZVBsYXRmb3JtUGF0aCgpLCAmdHJhbnNmb3JtQ0cpKTsKICNlbmRpZgog ICAgIG1fcGF0aCA9IFdURk1vdmUocGF0aCk7CiAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9u ID0gZmFsc2U7CkBAIC0yMzAsOSArMjk2LDE1IEBAIEZsb2F0UmVjdCBQYXRoOjpib3VuZGluZ1Jl Y3QoKSBjb25zdAogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuIENHUmVjdFplcm87 CiAKKyAgICBpZiAobV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkKKyAg ICAgICAgcmV0dXJuIHsgfTsKKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElubGluZURh dGFUeXBlOjpMaW5lKQorICAgICAgICByZXR1cm4gcmVjdENvbnRhaW5pbmdQb2ludHMobV9pbmxp bmVEYXRhLmxpbmUuc3RhcnQsIG1faW5saW5lRGF0YS5saW5lLmVuZCk7CisKICAgICAvLyBDR1Bh dGhHZXRCb3VuZGluZ0JveCBpbmNsdWRlcyB0aGUgcGF0aCdzIGNvbnRyb2wgcG9pbnRzLCBDR1Bh dGhHZXRQYXRoQm91bmRpbmdCb3ggZG9lcyBub3QuCiAKLSAgICBDR1JlY3QgYm91bmQgPSBDR1Bh dGhHZXRQYXRoQm91bmRpbmdCb3gobV9wYXRoLmdldCgpKTsKKyAgICBDR1JlY3QgYm91bmQgPSBD R1BhdGhHZXRQYXRoQm91bmRpbmdCb3gocGxhdGZvcm1QYXRoKCkpOwogICAgIHJldHVybiBDR1Jl Y3RJc051bGwoYm91bmQpID8gQ0dSZWN0WmVybyA6IGJvdW5kOwogfQogCkBAIC0yNDAsNyArMzEy LDE0IEBAIEZsb2F0UmVjdCBQYXRoOjpmYXN0Qm91bmRpbmdSZWN0KCkgY29uc3QKIHsKICAgICBp ZiAoaXNOdWxsKCkpCiAgICAgICAgIHJldHVybiBDR1JlY3RaZXJvOwotICAgIENHUmVjdCBib3Vu ZCA9IENHUGF0aEdldEJvdW5kaW5nQm94KG1fcGF0aC5nZXQoKSk7CisKKyAgICBpZiAobV9pbmxp bmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkKKyAgICAgICAgcmV0dXJuIHsgfTsK KworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpMaW5lKQorICAg ICAgICByZXR1cm4gcmVjdENvbnRhaW5pbmdQb2ludHMobV9pbmxpbmVEYXRhLmxpbmUuc3RhcnQs IG1faW5saW5lRGF0YS5saW5lLmVuZCk7CisKKyAgICBDR1JlY3QgYm91bmQgPSBDR1BhdGhHZXRC b3VuZGluZ0JveChwbGF0Zm9ybVBhdGgoKSk7CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3Vu ZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7CiB9CiAKQEAgLTI2OSwxMSArMzQ4LDI1IEBAIEZsb2F0 UmVjdCBQYXRoOjpzdHJva2VCb3VuZGluZ1JlY3QoU3Ryb2tlU3R5bGVBcHBsaWVyKiBhcHBsaWVy KSBjb25zdAogCiB2b2lkIFBhdGg6Om1vdmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKIHsK KyAgICBpZiAobV9pbmxpbmVEYXRhVHlwZSA8PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkgeworICAg ICAgICBtX2lubGluZURhdGEubW92ZSA9IE1vdmVEYXRhIHsgcG9pbnQgfTsKKyAgICAgICAgbV9p bmxpbmVEYXRhVHlwZSA9IElubGluZURhdGFUeXBlOjpNb3ZlOworICAgICAgICBtX25lZWRzVG9B cHBseUlubGluZURhdGEgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQ YXRoTW92ZVRvUG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHBvaW50LngoKSwg cG9pbnQueSgpKTsKIH0KIAogdm9pZCBQYXRoOjphZGRMaW5lVG8oY29uc3QgRmxvYXRQb2ludCYg cCkKIHsKKyAgICBpZiAobV9pbmxpbmVEYXRhVHlwZSA8PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkg eworICAgICAgICBtX2lubGluZURhdGEubGluZSA9IExpbmVEYXRhIHsgbV9pbmxpbmVEYXRhLm1v dmUubG9jYXRpb24sIHAgfTsKKyAgICAgICAgbV9pbmxpbmVEYXRhVHlwZSA9IElubGluZURhdGFU eXBlOjpMaW5lOworICAgICAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSB0cnVlOworICAg ICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5zdXJlUGxh dGZvcm1QYXRoKCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSk7CiB9CiAKQEAgLTM1Niw2ICs0NDks MTMgQEAgdm9pZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQb2ludCYgcCwgZmxvYXQgcmFkaXVz LCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmQKICAgICBpZiAoIXN0ZDo6aXNmaW5pdGUoc3Rh cnRBbmdsZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUpKQogICAgICAgICByZXR1cm47CiAK KyAgICBpZiAobV9pbmxpbmVEYXRhVHlwZSA8PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkgeworICAg ICAgICBtX2lubGluZURhdGEuYXJjID0gQXJjRGF0YSB7IG1faW5saW5lRGF0YS5tb3ZlLmxvY2F0 aW9uLCBwLCByYWRpdXMsIHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UsIG1faW5saW5l RGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUgfTsKKyAgICAgICAgbV9pbmxpbmVEYXRh VHlwZSA9IElubGluZURhdGFUeXBlOjpBcmM7CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5l RGF0YSA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhBZGRBcmMo ZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSwgcmFkaXVzLCBzdGFy dEFuZ2xlLCBlbmRBbmdsZSwgY2xvY2t3aXNlKTsKIH0KIApAQCAtNDAzLDI0ICs1MDMsMzkgQEAg dm9pZCBQYXRoOjpjbGVhcigpCiAgICAgICAgIHJldHVybjsKIAogICAgIG1fcGF0aCA9IGFkb3B0 Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsKKyAgICBtX2lubGluZURhdGFUeXBlID0gSW5saW5l RGF0YVR5cGU6OkNsZWFyZWQ7CiAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7 CisgICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gZmFsc2U7CiB9CiAKIGJvb2wgUGF0aDo6 aXNFbXB0eSgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGlzTnVsbCgpIHx8IENHUGF0aElzRW1wdHko bV9wYXRoLmdldCgpKTsKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiB0cnVlOwor CisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUgfHwgbV9p bmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TGluZSB8fCBtX2lubGluZURhdGFUeXBl ID09IElubGluZURhdGFUeXBlOjpBcmMpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJl dHVybiBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQoKSk7CiB9CiAKIGJvb2wgUGF0aDo6aGFzQ3Vy cmVudFBvaW50KCkgY29uc3QKIHsKICAgICByZXR1cm4gIWlzRW1wdHkoKTsKIH0KLSAgICAKKwog RmxvYXRQb2ludCBQYXRoOjpjdXJyZW50UG9pbnQoKSBjb25zdCAKIHsKICAgICBpZiAoaXNOdWxs KCkpCi0gICAgICAgIHJldHVybiBGbG9hdFBvaW50KCk7Ci0gICAgcmV0dXJuIENHUGF0aEdldEN1 cnJlbnRQb2ludChtX3BhdGguZ2V0KCkpOworICAgICAgICByZXR1cm4geyB9OworCisgICAgaWYg KG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUpCisgICAgICAgIHJldHVy biBtX2lubGluZURhdGEubW92ZS5sb2NhdGlvbjsKKworICAgIGlmIChtX2lubGluZURhdGFUeXBl ID09IElubGluZURhdGFUeXBlOjpMaW5lKQorICAgICAgICByZXR1cm4gbV9pbmxpbmVEYXRhLmxp bmUuZW5kOworCisgICAgcmV0dXJuIENHUGF0aEdldEN1cnJlbnRQb2ludChwbGF0Zm9ybVBhdGgo KSk7CiB9CiAKIHN0YXRpYyB2b2lkIENHUGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKHZvaWQqIGlu Zm8sIGNvbnN0IENHUGF0aEVsZW1lbnQqIGVsZW1lbnQpCkBAIC00NTQsMTQgKzU2OSwzOSBAQCB2 b2lkIFBhdGg6OmFwcGx5KGNvbnN0IFBhdGhBcHBsaWVyRnVuY3Rpb24mIGZ1bmN0aW9uKSBjb25z dAogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgQ0dQYXRoQXBwbHko bV9wYXRoLmdldCgpLCAodm9pZCopJmZ1bmN0aW9uLCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGll cik7CisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUpIHsK KyAgICAgICAgUGF0aEVsZW1lbnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0 aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1BvaW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9 IG1faW5saW5lRGF0YS5tb3ZlLmxvY2F0aW9uOworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElu bGluZURhdGFUeXBlOjpMaW5lKSB7CisgICAgICAgIFBhdGhFbGVtZW50IGVsZW1lbnQ7CisgICAg ICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpUeXBlOjpNb3ZlVG9Qb2ludDsKKyAgICAg ICAgZWxlbWVudC5wb2ludHNbMF0gPSBtX2lubGluZURhdGEubGluZS5zdGFydDsKKyAgICAgICAg ZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpU eXBlOjpBZGRMaW5lVG9Qb2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBtX2lubGlu ZURhdGEubGluZS5lbmQ7CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1 cm47CisgICAgfQorCisgICAgQ0dQYXRoQXBwbHkocGxhdGZvcm1QYXRoKCksICh2b2lkKikmZnVu Y3Rpb24sIENHUGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKTsKIH0KIAogI2lmIEhBVkUoQ0dQQVRI X0dFVF9OVU1CRVJfT0ZfRUxFTUVOVFMpCiAKIHNpemVfdCBQYXRoOjplbGVtZW50Q291bnQoKSBj b25zdAogewotICAgIHJldHVybiBDR1BhdGhHZXROdW1iZXJPZkVsZW1lbnRzKG1fcGF0aCk7Cisg ICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Ok1vdmUpCisgICAgICAg IHJldHVybiAxOworCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6 OkxpbmUpCisgICAgICAgIHJldHVybiAyOworCisgICAgcmV0dXJuIENHUGF0aEdldE51bWJlck9m RWxlbWVudHMocGxhdGZvcm1QYXRoKCkpOwogfQogCiAjZW5kaWYgLy8gSEFWRShDR1BBVEhfR0VU X05VTUJFUl9PRl9FTEVNRU5UUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcApp bmRleCA5MWFiM2JmN2Q4N2IyNDdhYjYxOGQ5ODNkYjc1NGJjMmIyMTQwZTY0Li4zMTBhZDE5Njkz NmZhMDNkZmU5MmZlMGJlMjBhNDMzOTA5NDgwODMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlM aXN0SXRlbXMuY3BwCkBAIC0xMTk0LDcgKzExOTQsNyBAQCBPcHRpb25hbDxGbG9hdFJlY3Q+IFN0 cm9rZVBhdGg6OmxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNzQ29udGV4dCYgY29udGV4dCkgY29u cwogCiB2b2lkIFN0cm9rZVBhdGg6OmFwcGx5KEdyYXBoaWNzQ29udGV4dCYgY29udGV4dCkgY29u c3QKIHsKLSAgICBjb250ZXh0LnN0cm9rZVBhdGgobV9wYXRoKTsKKyAgICBjb250ZXh0LnN0cm9r ZVBhdGgoc3RkOjpleGNoYW5nZShtX3BhdGgsIHsgfSkpOwogfQogCiBzdGF0aWMgVGV4dFN0cmVh bSYgb3BlcmF0b3I8PChUZXh0U3RyZWFtJiB0cywgY29uc3QgU3Ryb2tlUGF0aCYgaXRlbSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9E aXNwbGF5TGlzdEl0ZW1zLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNw bGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oCmluZGV4IDk3ZmQwYTAwYTRkNGJjNmU3NjEyNzJk OTZlYjc0NjY3MzAyZjgwYTYuLjFmNDdhMTAwYjc3M2FmOWM0YmVmMzk0Yjk5M2ViMTYwZWU5N2Jl NWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXls aXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaApAQCAtMjUyNSw3ICsyNTI1LDcg QEAgcHJpdmF0ZToKICAgICB2b2lkIGFwcGx5KEdyYXBoaWNzQ29udGV4dCYpIGNvbnN0IG92ZXJy aWRlOwogICAgIE9wdGlvbmFsPEZsb2F0UmVjdD4gbG9jYWxCb3VuZHMoY29uc3QgR3JhcGhpY3ND b250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAKLSAgICBjb25zdCBQYXRoIG1fcGF0aDsKKyAgICBt dXRhYmxlIFBhdGggbV9wYXRoOwogfTsKIAogdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4K 392651 2020-03-05 16:56:30 -0800 2020-03-06 16:28:40 -0800 Patch bug-208464-20200305165629.patch text/plain 24260 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3OTMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGNhYWM0MjZiZTIxODU1 YmRiNDIxM2IzNzQ4ZTkxZGI4MTBhYmIzZi4uMDUyMmRjODUzOWY3MGQxNmI0MDJhNzEzMmI1MmEz NjQwZGVhNGJjZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEyMiBAQAorMjAyMC0wMy0wNSAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBMYXppbHkgZ2Vu ZXJhdGUgQ0dQYXRocyBmb3Igc29tZSBzaW1wbGUgdHlwZXMgb2YgcGF0aHMsIHN1Y2ggYXMgYXJj cyBhbmQgbGluZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwODQ2NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTk5NjMyMjY+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2hlbiB0aGUgR1BVIHByb2Nl c3MgaXMgZW5hYmxlZCBhbmQgdXNlZCB0byByZW5kZXIgdGhlIGNhbnZhcyBlbGVtZW50LCBzb21l IGNhbnZhcy1yZWxhdGVkIHN1YnRlc3RzIGluIHRoZQorICAgICAgICBNb3Rpb25NYXJrIHNlZSBz aWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNzaW9ucy4gT25lIG9mIHRoZSByZWFzb25zIGZv ciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mgb2YKKyAgICAgICAgZGVjb2RpbmcgZGlzcGxh eSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2ViQ29yZTo6UGF0aGBzIGluIHRoZSBHUFUgcHJv Y2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBuZXcgQ0dQYXRoCisgICAgICAgIGZvciBlYWNo IFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNhbGx5IGluY3JlYXNlcyBwYWdlIGRlbWFuZCBh bmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJvY2VzcyBpbiBjb250cmFzdAorICAgICAgICB0 byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUgZmFjdCB0aGF0IGFsbCBvZiB0aGVzZSBDR1Bh dGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11c3QgYWxsIGV4aXN0IHNvbWV3aGVyZQorICAg ICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5nIHRoZSBkaXNwbGF5IGxpc3QuCisKKyAgICAg ICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdlYktpdCwgZWFjaCBjYWxsIHRvIHN0cm9rZSB0 aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBpbnZva2luZworICAgICAgICBHcmFwaGljc0Nv bnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRlZCBieSBjbGVhcmluZyB0aGUgcGF0aCwgd2hp Y2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlCisgICAgICAgIFBh dGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVlZHMgdG8gYmUgY3JlYXRlZCwgQ29yZUdyYXBo aWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0aGUgbmV3IENHUGF0aCBhdCB0aGUKKyAgICAg ICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQYXRoIHdoaWNoIHdhcyBqdXN0IGRlc3Ryb3ll ZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0eWluZyBtb3JlIHBhZ2VzIHRoYW4KKyAgICAg ICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24gYWZmZWN0cyBtb3N0IG9mIHRoZSBjYW52YXMt cmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRvIHNvbWUgZGVncmVlLCB0aG91Z2ggdGhlCisg ICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFibGUgd2l0aCBDYW52YXMgTGluZXMuCisKKyAg ICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNpZ25pZmljYW50IHBvcnRpb24gb2YgdGltZSBp cyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBwbHkgYW5kIGNvbnZlcnRpbmcgdGhlIHJlc3Vs dGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBpbnRvIHNlcmlhbGl6YWJsZSBkYXRhIHdoZW4g ZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisKKyAgICAgICAgVG8gbWl0aWdhdGUgdGhlc2Ug dHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lucyB3ZSBnZXQgZnJvbSBtZW1vcnkgbG9jYWxp dHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdlCisgICAgICAgIHF1YW50aXRpZXMsIHdlIGNh bjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ugb2Ygc2ltcGxlIHBhdGhzLCBzdHVmZiBzb21l IGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBhdGggd2FzIGNyZWF0ZWQgYXMgaW5saW5lIGRh dGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBhdGggaXRzZWxmLCBhcyBhIG5ldyBkYXRhIG1l bWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29tcGFzc2VzIGxpbmVzLCBhcmNzLCBhbmQgbW92 ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBvbmx5IGBQYXRoOjptb3ZlVG9gIHdhcyBpbnZv a2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGluY2x1ZGUgZWxsaXBz ZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhpcyBhbGxvd3MgdXMgdG8gYWNoaWV2ZSB0d28g dGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVhcGVyIGJ5IG5vdCByZXF1aXJpbmcgYSB3YWxr IHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBDR1BhdGgncyBlbGVtZW50cywgYW5kIChiKSBt YWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBpbml0aWFsaXppbmcgdGhlIFBhdGggdXNpbmcg aW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBoYXZpbmcgdG8gY3JlYXRlIGEg bmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hlbiBwYWludGluZyB0aGUgU3Ryb2tlUGF0aCBk aXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJkIGBtX3BhdGhgIGFmdGVyIHdlJ3JlIGRvbmUg cGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAgIFRoaXMsIGluIGNvbmp1bmN0aW9uIHdpdGgg KDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZTo6UGF0aCBpbiB0 aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAgICAgICAgY3JlYXRlZCB3aGVuIHdlJ3JlIGp1 c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBjYWxsaW5nIGludG8gc3Ryb2tlUGF0aCgpKSwg YW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAgICAgICAgICAgd2UncmUgZG9uZSBwYWludGlu ZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxvdyBmb3IgZGV0YWlscy4gVGhlcmUgc2hvdWxk IGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L1BhdGguaDoKKworICAgICAgICBJbnRyb2R1Y2UgSW5saW5lUGF0aERhdGEsIGEgdW5pb24gb2Yg c2V2ZXJhbCBkaWZmZXJlbnQgaW5saW5lIGRhdGEgdHlwZXMsIGVhY2ggb2Ygd2hpY2ggcmVwcmVz ZW50IG9uZSBzaW1wbGUKKyAgICAgICAgcGF0aCB0eXBlIHRoYXQgbWF5IGJlIHJlcHJlc2VudGVk IHVzaW5nIG9ubHkgaW5saW5lIGRhdGEuIFRoaXMgaW5jbHVkZXMgbGluZSBzZWdtZW50cyAoYSBz dGFydCBwb2ludCBhbmQgYW4KKyAgICAgICAgZW5kIHBvaW50KSwgYXMgd2VsbCBhcyBhcmNzICh3 aGljaCwgaW4gYWRkaXRpb24gdG8gYSBjZW50ZXIgYW5kIHN0YXJ0IGFuZCBlbmQgYW5nbGVzKSBh bHNvIGluY2x1ZGVzIGFuIG9wdGlvbmFsCisgICAgICAgIG9mZnNldCwgd2hpY2ggcmVwcmVzZW50 cyB0aGUgY3VycmVudCBwb3NpdGlvbiBvZiB0aGUgcGF0aCBhdCB0aGUgdGltZSAiYWRkQXJjIiB3 YXMgY2FsbGVkLgorCisgICAgICAgIEZvciBpbnN0YW5jZSwgaW4gdGhlIGZvbGxvd2luZyBzY2Vu YXJpbywgdGhlIHBhdGggd291bGQgaGF2ZSBhbiBhcmMgdGhhdCBpcyBvZmZzZXQgYnkgKDEwMCwg MCk7IGlmIGZpbGxlZCwgaXQKKyAgICAgICAgd291bGQgcmVzdWx0IGluIGEgY29tcG9zaXRlIHNo YXBlIHJlc2VtYmxpbmcgYSBzZW1pY2lyY2xlIG9uIHRvcCBvZiBhIHRyaWFuZ2xlOgorCisgICAg ICAgIHBhdGgubW92ZVRvKDEwMCwgMCk7CisgICAgICAgIHBhdGguYWRkQXJjKDEwMCwgMTAwLCA1 MCwgMCwgUEksIGZhbHNlKTsKKyAgICAgICAgY29udGV4dC5maWxsKHBhdGgpOworCisgICAgICAg IFRoZSBuZXcgbWVtYmVyIG1faW5saW5lRGF0YVR5cGUgaXMgYW4gZW51bSBmbGFnIHRoYXQgaW5k aWNhdGVzIHdoYXQga2luZCBvZiBpbmZvcm1hdGlvbiBpcyBzdG9yZWQgaW4KKyAgICAgICAgbV9p bmxpbmVEYXRhLiBXaGVuIGEgUGF0aCBpcyBpbml0aWFsaXplZCAob3IgYWZ0ZXIgaXQgaXMgY2xl YXJlZCksIGl0IHN0YXJ0cyBvZmYgaW4gQ2xlYXJlZCBzdGF0ZS4gTW92aW5nIHRoZQorICAgICAg ICBwYXRoIHRyYW5zaXRpb25zIGl0IGludG8gTW92ZSBhbmQganVzdCBzZXRzIHRoZSBgTW92ZURh dGFgIG1lbWJlciBvZiB0aGUgaW5saW5lIGRhdGE7IGNhbGxpbmcgYGFkZExpbmVUb2Agb3IKKyAg ICAgICAgYGFkZEFyY2AgdHJhbnNpdGlvbnMgaXQgdG8gZWl0aGVyIExpbmUgb3IgQXJjLgorCisg ICAgICAgIElmLCBhdCBhbnkgcG9pbnQsIHRoZSBwYXRoIGNoYW5nZXMgaW4gYSBkaWZmZXJlbnQg d2F5IChpLmUuIG5laXRoZXIgbGluZSwgYXJjLCBub3IgbW92ZSksIHdlIHRyYW5zaXRpb24gdG8K KyAgICAgICAgdGhlIE5vdElubGluZSBzdGF0ZSBhbmQgbm8gbG9uZ2VyIGF0dGVtcHQgdG8gc3Rv cmUgdGhlIHBhdGggbXV0YXRpb25zIGFzIGlubGluZSBkYXRhIG9uIFBhdGguCisKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpk ZWNvZGUpOgorCisgICAgICAgIFRlYWNoIFBhdGg6OmVuY29kZSBhbmQgUGF0aDo6ZGVjb2RlIHRv IHJlc3BlY3RpdmVseSBzZXJpYWxpemUgYW5kIGRlc2VyaWFsaXplIFdlYkNvcmU6OlBhdGggYnkg Y29uc3VsdGluZyBvbmx5CisgICAgICAgIHRoZSBpbmxpbmUgZGF0YSwgaWYgaXQgaXMgcHJlc2Vu dC4gRm9yIHNpbXBsZSB0eXBlcyBvZiBwYXRocywgdGhpcyBkZWNyZWFzZXMgdGhlIGNvc3Qgb2Yg Ym90aCBJUEMgZW5jb2RpbmcgYW5kCisgICAgICAgIGRlY29kaW5nLCBidXQgYWRkcyBhIG5lZ2xp Z2libGUgYW1vdW50IG9mIG92ZXJoZWFkIGluIHRoZSBjYXNlIHdoZXJlIHRoZSBwYXRoIGlzIG5v bi1pbmxpbmUuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6cmVjdENvbnRhaW5pbmdQb2ludHMpOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6YXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkIGNvbnN0KToKKworICAgICAgICBB ZGQgYSBoZWxwZXIgbWV0aG9kIHRoYXQgaXMgaW52b2tlZCB3aGVuIHRoZSBQYXRoIGlzIGFza2Vk IGZvciBhIENHUGF0aC4gSW4gdGhpcyBjYXNlLCBldmVuIGlmIG1fcGF0aCBpcyBudWxsLAorICAg ICAgICB3ZSBuZWVkIHRvIGxhemlseSBjcmVhdGUgaXQgYW5kIGFwcGx5IGFueSBpbmxpbmUgcGF0 aCBkYXRhIHdlJ3ZlIGFjY3VtdWxhdGVkLiBPbmNlIHdlJ3JlIGRvbmUgYXBwbHlpbmcgdGhlCisg ICAgICAgIGlubGluZSBkYXRhLCBzZXQgYSBmbGFnIChtX25lZWRzVG9BcHBseUlubGluZURhdGEp IHRvIGZhbHNlIHRvIGF2b2lkIHJlLWFwcGx5aW5nIGlubGluZSBkYXRhIHRvIHRoZSBwYXRoLgor CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpwbGF0Zm9ybVBhdGggY29uc3QpOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKToKKworICAgICAgICBXaGVuIGVuc3Vy ZVBsYXRmb3JtUGF0aCBpcyBpbnZva2VkLCB3ZSBhcmUgYWJvdXQgdG8gbXV0YXRlIG91ciBDR1Bh dGggaW4gc3VjaCBhIHdheSB0aGF0IGl0IGNhbid0IGJlIGV4cHJlc3NlZAorICAgICAgICBpbiB0 ZXJtcyBvZiBpbmxpbmUgZGF0YSAoYXQgbGVhc3QsIG5vdCB3aXRoIHRoZSBjaGFuZ2VzIGluIHRo aXMgcGF0Y2gpLiBUcmFuc2l0aW9uIHRvIElubGluZURhdGFUeXBlOjpOb3RJbmxpbmUKKyAgICAg ICAgaW4gdGhpcyBjYXNlLCBhbmQgYXBwbHkgdGhlIENHUGF0aCBtdXRhdGlvbnMgdGhhdCB3ZXJl IHByZXZpb3VzbHkgc3Rhc2hlZCBhd2F5IGluIGlubGluZSBwYXRoIGRhdGEuCisKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6CisKKyAgICAgICAgQSBwYXRoIGlzIG5vdyBj b25zaWRlcmVkIG51bGwgaWYgaXQgaXMgbm90IG9ubHkgbWlzc2luZyBhIENHUGF0aCwgYnV0IGFs c28gZG9lcyBub3QgaGF2ZSBhbnkgaW5saW5lIHBhdGggZGF0YS4KKyAgICAgICAgVGhpcyBtYWlu dGFpbnMgdGhlIGludmFyaWFudCB0aGF0IGBpc051bGwoKWAgaXMgdHJ1ZSBpZmYgdGhhdCB0aGUg YHBsYXRmb3JtUGF0aCgpYCB3aWxsIHJldHVybiAweDAuCisKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OlBhdGgpOgorCisgICAgICAgIFVwZGF0ZSB0aGUgY29uc3RydWN0b3JzIGFuZCBgc3dhcGAg aGVscGVyIG1ldGhvZCAodXNlZCBieSBhc3NpZ25tZW50IG9wZXJhdG9ycykgdG8gYWNjb3VudCBm b3IgdGhlIG5ldyBtZW1iZXJzLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpzd2FwKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OmNvbnRhaW5zIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OnRyYW5zZm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpib3VuZGluZ1JlY3Qg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZmFzdEJvdW5kaW5nUmVjdCBjb25zdCk6 CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjptb3ZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0 aDo6YWRkTGluZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6CisKKyAgICAg ICAgSW4gdGhlIGNhc2Ugb2YgdGhlc2UgdGhyZWUgbWV0aG9kcyBmb3IgbXV0YXRpbmcgYSBwYXRo LCBpZiB3ZSd2ZSBlaXRoZXIgb25seSBtb3ZlZCB0aGUgcGF0aCBvciBoYXZlbid0IHRvdWNoZWQK KyAgICAgICAgaXQgYXQgYWxsLCB3ZSBjYW4gZ2V0IGF3YXkgd2l0aCBvbmx5IHVwZGF0aW5nIG91 ciBpbmxpbmUgcGF0aCBkYXRhLCBhbmQgYXZvaWQgY3JlYXRpbmcgYSBDR1BhdGguCisKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmNsZWFyKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzRW1w dHkgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVudFBvaW50IGNvbnN0KToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OmVsZW1lbnRDb3VudCBjb25zdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv ZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGlz cGxheUxpc3Q6OlN0cm9rZVBhdGg6OmFwcGx5IGNvbnN0KToKKworICAgICAgICBUaHJvdyBvdXQg dGhlIGN1cnJlbnQgV2ViQ29yZTo6UGF0aCBhZnRlciB3ZSdyZSBkb25lIHBhaW50aW5nIHdpdGgg aXQgKHNlZSAoMikgaW4gdGhlIGFib3ZlIENoYW5nZUxvZyBlbnRyeSkuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oOgorCiAyMDIw LTAzLTA1ICBLZW5uZXRoIFJ1c3NlbGwgIDxrYnJAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJF R1JFU1NJT046IFsgTWFjIF0gZmFzdC9jYW52YXMvd2ViZ2wvdGV4SW1hZ2UyRC12aWRlby1mbGlw WS1mYWxzZS5odG1sIGlzIFRpbWluZyBvdXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L1BhdGguaAppbmRleCA3ZmFkYTYwZDgzYzI5MjUwYWM0YTE3NDhhODkyNDA3MDI5MTk5ZTFiLi5h NmMyZjJjYzVjOTMwZmNkNGVjZDg3MTU1NDI1MTQ5OTgwYzhmNGE0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0xNDcsNyArMTQ3LDEyIEBAIHB1YmxpYzoKICAg ICBGbG9hdFBvaW50IHBvaW50QXRMZW5ndGgoZmxvYXQgbGVuZ3RoKSBjb25zdDsKIAogICAgIFdF QkNPUkVfRVhQT1JUIHZvaWQgY2xlYXIoKTsKKworI2lmIFVTRShDRykKKyAgICBXRUJDT1JFX0VY UE9SVCBib29sIGlzTnVsbCgpIGNvbnN0OworI2Vsc2UKICAgICBib29sIGlzTnVsbCgpIGNvbnN0 IHsgcmV0dXJuICFtX3BhdGg7IH0KKyNlbmRpZgogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0Owog ICAgIC8vIEdldHMgdGhlIGN1cnJlbnQgcG9pbnQgb2YgdGhlIGN1cnJlbnQgcGF0aCwgd2hpY2gg aXMgY29uY2VwdHVhbGx5IHRoZSBmaW5hbCBwb2ludCByZWFjaGVkIGJ5IHRoZSBwYXRoIHNvIGZh ci4KICAgICAvLyBOb3RlIHRoZSBQYXRoIGNhbiBiZSBlbXB0eSAoaXNFbXB0eSgpID09IHRydWUp IGFuZCBzdGlsbCBoYXZlIGEgY3VycmVudCBwb2ludC4KQEAgLTE4NSw3ICsxOTAsNyBAQCBwdWJs aWM6CiAgICAgRmxvYXRSZWN0IGZhc3RCb3VuZGluZ1JlY3RGb3JTdHJva2UoY29uc3QgUGxhdGZv cm1Db250ZXh0RGlyZWN0MkQmKSBjb25zdDsKICAgICBQbGF0Zm9ybVBhdGhQdHIgcGxhdGZvcm1Q YXRoKCkgY29uc3QgeyByZXR1cm4gbV9wYXRoLmdldCgpOyB9CiAjZWxpZiBVU0UoQ0cpCi0gICAg UGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0aC5nZXQo KTsgfQorICAgIFdFQkNPUkVfRVhQT1JUIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBj b25zdDsKICNlbHNlCiAgICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsg cmV0dXJuIG1fcGF0aDsgfQogI2VuZGlmCkBAIC0yMjYsNiArMjMxLDQ0IEBAIHB1YmxpYzoKIAog cHJpdmF0ZToKICNpZiBVU0UoQ0cpCisgICAgZW51bSBjbGFzcyBJbmxpbmVEYXRhVHlwZSA6IHVp bnQ4X3QgeworICAgICAgICBDbGVhcmVkID0gMCwKKyAgICAgICAgTW92ZSwKKyAgICAgICAgQXJj LAorICAgICAgICBMaW5lLAorICAgICAgICBOb3RJbmxpbmUKKyAgICB9OworCisgICAgc3RydWN0 IExpbmVEYXRhIHsKKyAgICAgICAgRmxvYXRQb2ludCBzdGFydDsKKyAgICAgICAgRmxvYXRQb2lu dCBlbmQ7CisgICAgfTsKKworICAgIHN0cnVjdCBBcmNEYXRhIHsKKyAgICAgICAgRmxvYXRQb2lu dCBvZmZzZXQ7CisgICAgICAgIEZsb2F0UG9pbnQgY2VudGVyOworICAgICAgICBmbG9hdCByYWRp dXMgeyAwIH07CisgICAgICAgIGZsb2F0IHN0YXJ0IHsgMCB9OworICAgICAgICBmbG9hdCBlbmQg eyAwIH07CisgICAgICAgIGJvb2wgY2xvY2t3aXNlIHsgZmFsc2UgfTsKKyAgICAgICAgYm9vbCBo YXNPZmZzZXQgeyBmYWxzZSB9OworICAgIH07CisKKyAgICBzdHJ1Y3QgTW92ZURhdGEgeworICAg ICAgICBGbG9hdFBvaW50IGxvY2F0aW9uOworICAgIH07CisKKyAgICB1bmlvbiBJbmxpbmVQYXRo RGF0YSB7CisgICAgICAgIElubGluZVBhdGhEYXRhKCkKKyAgICAgICAgICAgIDogbW92ZSh7IEZs b2F0UG9pbnQoKSB9KQorICAgICAgICB7CisgICAgICAgIH0KKworICAgICAgICBNb3ZlRGF0YSBt b3ZlOworICAgICAgICBMaW5lRGF0YSBsaW5lOworICAgICAgICBBcmNEYXRhIGFyYzsKKyAgICB9 OworICAgIHZvaWQgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkKCkgY29uc3Q7CiAgICAgdm9p ZCBzd2FwKFBhdGgmKTsKICNlbmRpZgogCkBAIC0yMzgsMTQgKzI4MSw0MyBAQCBwcml2YXRlOgog I2VuZGlmCiAKICNpZiBVU0UoQ0cpCisgICAgSW5saW5lUGF0aERhdGEgbV9pbmxpbmVEYXRhOwor ICAgIElubGluZURhdGFUeXBlIG1faW5saW5lRGF0YVR5cGUgeyBJbmxpbmVEYXRhVHlwZTo6Q2xl YXJlZCB9OwogICAgIG11dGFibGUgYm9vbCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24geyBmYWxz ZSB9OwotI2VuZGlmCisgICAgbXV0YWJsZSBib29sIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSB7 IGZhbHNlIH07CisjZW5kaWYgLy8gVVNFKENHKQogfTsKIAogV1RGOjpUZXh0U3RyZWFtJiBvcGVy YXRvcjw8KFdURjo6VGV4dFN0cmVhbSYsIGNvbnN0IFBhdGgmKTsKIAogdGVtcGxhdGU8Y2xhc3Mg RW5jb2Rlcj4gdm9pZCBQYXRoOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHsKKyNp ZiBVU0UoQ0cpCisgICAgZW5jb2RlciA8PCBzdGF0aWNfY2FzdDx1aW50OF90PihtX2lubGluZURh dGFUeXBlKTsKKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpN b3ZlKSB7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhLm1vdmUubG9jYXRpb247Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAobV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxp bmVEYXRhVHlwZTo6TGluZSkgeworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5saW5l LnN0YXJ0OworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5saW5lLmVuZDsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElubGluZURh dGFUeXBlOjpBcmMpIHsKKyAgICAgICAgZW5jb2RlciA8PCBtX2lubGluZURhdGEuYXJjLm9mZnNl dDsKKyAgICAgICAgZW5jb2RlciA8PCBtX2lubGluZURhdGEuYXJjLmNlbnRlcjsKKyAgICAgICAg ZW5jb2RlciA8PCBtX2lubGluZURhdGEuYXJjLnJhZGl1czsKKyAgICAgICAgZW5jb2RlciA8PCBt X2lubGluZURhdGEuYXJjLnN0YXJ0OworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5h cmMuZW5kOworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5hcmMuY2xvY2t3aXNlOwor ICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YS5hcmMuaGFzT2Zmc2V0OworICAgICAgICBy ZXR1cm47CisgICAgfQorI2VuZGlmIC8vIFVTRShDRykKKwogICAgIGVuY29kZXIgPDwgc3RhdGlj X2Nhc3Q8dWludDY0X3Q+KGVsZW1lbnRDb3VudCgpKTsKIAogICAgIGFwcGx5KFsmXShhdXRvJiBl bGVtZW50KSB7CkBAIC0yNzYsNiArMzQ4LDYwIEBAIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZv aWQgUGF0aDo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiB0ZW1wbGF0ZTxjbGFzcyBE ZWNvZGVyPiBPcHRpb25hbDxQYXRoPiBQYXRoOjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlcikKIHsK ICAgICBQYXRoIHBhdGg7CisKKyNpZiBVU0UoQ0cpCisgICAgdWludDhfdCBpbmxpbmVEYXRhVHlw ZVZhbHVlOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoaW5saW5lRGF0YVR5cGVWYWx1ZSkpCisg ICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBwYXRoLm1faW5saW5lRGF0YVR5cGUg PSBzdGF0aWNfY2FzdDxJbmxpbmVEYXRhVHlwZT4oaW5saW5lRGF0YVR5cGVWYWx1ZSk7CisKKyAg ICBpZiAocGF0aC5tX2lubGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpNb3ZlKSB7Cisg ICAgICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGF0aC5tX2lubGluZURhdGEubW92ZS5sb2NhdGlv bikpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9u ZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHBhdGg7CisgICAg fQorCisgICAgaWYgKHBhdGgubV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TGlu ZSkgeworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmxpbmUu c3RhcnQpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBpZiAo IWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmxpbmUuZW5kKSkKKyAgICAgICAgICAg IHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAgcGF0aC5tX25lZWRzVG9BcHBseUlubGlu ZURhdGEgPSB0cnVlOworICAgICAgICByZXR1cm4gcGF0aDsKKyAgICB9CisKKyAgICBpZiAocGF0 aC5tX2lubGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpBcmMpIHsKKyAgICAgICAgaWYg KCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YS5hcmMub2Zmc2V0KSkKKyAgICAgICAg ICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShw YXRoLm1faW5saW5lRGF0YS5hcmMuY2VudGVyKSkKKyAgICAgICAgICAgIHJldHVybiBXVEY6Om51 bGxvcHQ7CisKKyAgICAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YS5h cmMucmFkaXVzKSkKKyAgICAgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAg aWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YS5hcmMuc3RhcnQpKQorICAgICAg ICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KHBhdGgubV9pbmxpbmVEYXRhLmFyYy5lbmQpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVs bG9wdDsKKworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmFy Yy5jbG9ja3dpc2UpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAg ICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhLmFyYy5oYXNPZmZzZXQpKQor ICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgICAgICBwYXRoLm1fbmVlZHNU b0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAgICAgIHJldHVybiBwYXRoOworICAgIH0KKyNl bmRpZiAvLyBVU0UoQ0cpCisKICAgICB1aW50NjRfdCBudW1Qb2ludHM7CiAgICAgaWYgKCFkZWNv ZGVyLmRlY29kZShudW1Qb2ludHMpKQogICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKaW5kZXggNTIx YzE1NTNhOWE2YTM0YTM4MWMzNGY5Nzg2MjU0ZGQ1ZjBjNzI2ZS4uZjQyMTU0ZDAwNTUyNjllYTM0 ODU2YjNlYWYzNGIwYTA1OTg3YTY0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jZy9QYXRoQ0cuY3BwCkBAIC02NSw2ICs2NSwxNSBAQCBzdGF0aWMgaW5saW5lIENH Q29udGV4dFJlZiBzY3JhdGNoQ29udGV4dCgpCiAgICAgcmV0dXJuIGNvbnRleHQ7CiB9CiAKK3N0 YXRpYyBGbG9hdFJlY3QgcmVjdENvbnRhaW5pbmdQb2ludHMoRmxvYXRQb2ludCBwb2ludDEsIEZs b2F0UG9pbnQgcG9pbnQyKQoreworICAgIGF1dG8gbWluWCA9IHN0ZDo6bWluKHBvaW50MS54KCks IHBvaW50Mi54KCkpOworICAgIGF1dG8gbWluWSA9IHN0ZDo6bWluKHBvaW50MS55KCksIHBvaW50 Mi55KCkpOworICAgIGF1dG8gbWF4WCA9IHN0ZDo6bWF4KHBvaW50MS54KCksIHBvaW50Mi54KCkp OworICAgIGF1dG8gbWF4WSA9IHN0ZDo6bWF4KHBvaW50MS55KCksIHBvaW50Mi55KCkpOworICAg IHJldHVybiB7IG1pblgsIG1pblksIG1heFggLSBtaW5YLCBtYXhZIC0gbWluWSB9OworfQorCiBQ YXRoIFBhdGg6OnBvbHlnb25QYXRoRnJvbVBvaW50cyhjb25zdCBWZWN0b3I8RmxvYXRQb2ludD4m IHBvaW50cykKIHsKICAgICBQYXRoIHBhdGg7CkBAIC04OSw2ICs5OCw0NyBAQCBQYXRoOjpQYXRo KFJldGFpblB0cjxDR011dGFibGVQYXRoUmVmPiYmIHBhdGgpCiBQYXRoOjpQYXRoKCkgPSBkZWZh dWx0OwogUGF0aDo6flBhdGgoKSA9IGRlZmF1bHQ7CiAKK3ZvaWQgUGF0aDo6YXBwbHlJbmxpbmVQ YXRoRGF0YUlmTmVlZGVkKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fbmVlZHNUb0FwcGx5SW5saW5l RGF0YSkKKyAgICAgICAgcmV0dXJuOworCisgICAgc3dpdGNoIChtX2lubGluZURhdGFUeXBlKSB7 CisgICAgY2FzZSBJbmxpbmVEYXRhVHlwZTo6TW92ZTogeworICAgICAgICBpZiAoIW1fcGF0aCkK KyAgICAgICAgICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsKKyAg ICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQobV9wYXRoLmdldCgpLCBudWxscHRyLCBtX2lubGluZURh dGEubW92ZS5sb2NhdGlvbi54KCksIG1faW5saW5lRGF0YS5tb3ZlLmxvY2F0aW9uLnkoKSk7Cisg ICAgICAgIGJyZWFrOworICAgIH0KKyAgICBjYXNlIElubGluZURhdGFUeXBlOjpMaW5lOiB7Cisg ICAgICAgIGlmICghbV9wYXRoKQorICAgICAgICAgICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhD cmVhdGVNdXRhYmxlKCkpOworICAgICAgICBhdXRvJiBsaW5lID0gbV9pbmxpbmVEYXRhLmxpbmU7 CisgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KG1fcGF0aC5nZXQoKSwgbnVsbHB0ciwgbGluZS5z dGFydC54KCksIGxpbmUuc3RhcnQueSgpKTsKKyAgICAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQo bV9wYXRoLmdldCgpLCBudWxscHRyLCBsaW5lLmVuZC54KCksIGxpbmUuZW5kLnkoKSk7CisgICAg ICAgIGJyZWFrOworICAgIH0KKyAgICBjYXNlIElubGluZURhdGFUeXBlOjpBcmM6IHsKKyAgICAg ICAgaWYgKCFtX3BhdGgpCisgICAgICAgICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0 ZU11dGFibGUoKSk7CisgICAgICAgIGF1dG8mIGFyYyA9IG1faW5saW5lRGF0YS5hcmM7CisgICAg ICAgIGlmIChhcmMuaGFzT2Zmc2V0KQorICAgICAgICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQobV9w YXRoLmdldCgpLCBudWxscHRyLCBhcmMub2Zmc2V0LngoKSwgYXJjLm9mZnNldC55KCkpOworICAg ICAgICBDR1BhdGhBZGRBcmMobV9wYXRoLmdldCgpLCBudWxscHRyLCBhcmMuY2VudGVyLngoKSwg YXJjLmNlbnRlci55KCksIGFyYy5yYWRpdXMsIGFyYy5zdGFydCwgYXJjLmVuZCwgYXJjLmNsb2Nr d2lzZSk7CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICBkZWZhdWx0OgorICAgICAgICBicmVh azsKKyAgICB9CisgICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gZmFsc2U7Cit9CisKK1Bs YXRmb3JtUGF0aFB0ciBQYXRoOjpwbGF0Zm9ybVBhdGgoKSBjb25zdAoreworICAgIGFwcGx5SW5s aW5lUGF0aERhdGFJZk5lZWRlZCgpOworICAgIHJldHVybiBtX3BhdGguZ2V0KCk7Cit9CisKIFBs YXRmb3JtUGF0aFB0ciBQYXRoOjplbnN1cmVQbGF0Zm9ybVBhdGgoKQogewogICAgIGlmICghbV9w YXRoKQpAQCAtOTgsMTIgKzE0OCwyMiBAQCBQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6ZW5zdXJlUGxh dGZvcm1QYXRoKCkKICAgICAgICAgICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0 YWJsZUNvcHkobV9wYXRoLmdldCgpKSk7CiAgICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlv biA9IGZhbHNlOwogICAgIH0KKyAgICBhcHBseUlubGluZVBhdGhEYXRhSWZOZWVkZWQoKTsKKyAg ICBtX2lubGluZURhdGFUeXBlID0gSW5saW5lRGF0YVR5cGU6Ok5vdElubGluZTsKICAgICByZXR1 cm4gbV9wYXRoLmdldCgpOwogfQogCitib29sIFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAg cmV0dXJuICFtX3BhdGggJiYgbV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6Q2xl YXJlZDsKK30KKwogUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIHsKICAgICBtX3BhdGgg PSB7IG90aGVyLm1fcGF0aCB9OworICAgIG1faW5saW5lRGF0YSA9IG90aGVyLm1faW5saW5lRGF0 YTsKKyAgICBtX2lubGluZURhdGFUeXBlID0gb3RoZXIubV9pbmxpbmVEYXRhVHlwZTsKKyAgICBt X25lZWRzVG9BcHBseUlubGluZURhdGEgPSBvdGhlci5tX25lZWRzVG9BcHBseUlubGluZURhdGE7 CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0 cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOwpAQCAt MTEyLDE0ICsxNzIsMjAgQEAgUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIAogUGF0aDo6 UGF0aChQYXRoJiYgb3RoZXIpCiAgICAgOiBtX3BhdGgoc3RkOjpleGNoYW5nZShvdGhlci5tX3Bh dGgsIG51bGxwdHIpKQorICAgICwgbV9pbmxpbmVEYXRhKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9p bmxpbmVEYXRhLCB7IH0pKQorICAgICwgbV9pbmxpbmVEYXRhVHlwZShzdGQ6OmV4Y2hhbmdlKG90 aGVyLm1faW5saW5lRGF0YVR5cGUsIElubGluZURhdGFUeXBlOjpDbGVhcmVkKSkKICAgICAsIG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbihzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fY29weVBhdGhCZWZv cmVNdXRhdGlvbiwgZmFsc2UpKQorICAgICwgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKHN0ZDo6 ZXhjaGFuZ2Uob3RoZXIubV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBmYWxzZSkpCiB7CiB9CiAK IHZvaWQgUGF0aDo6c3dhcChQYXRoJiBvdGhlclBhdGgpCiB7CiAgICAgc3RkOjpzd2FwKG1fcGF0 aCwgb3RoZXJQYXRoLm1fcGF0aCk7CisgICAgc3RkOjpzd2FwKG1faW5saW5lRGF0YSwgb3RoZXJQ YXRoLm1faW5saW5lRGF0YSk7CisgICAgc3RkOjpzd2FwKG1faW5saW5lRGF0YVR5cGUsIG90aGVy UGF0aC5tX2lubGluZURhdGFUeXBlKTsKICAgICBzdGQ6OnN3YXAobV9jb3B5UGF0aEJlZm9yZU11 dGF0aW9uLCBvdGhlclBhdGgubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKTsKKyAgICBzdGQ6OnN3 YXAobV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBvdGhlclBhdGgubV9uZWVkc1RvQXBwbHlJbmxp bmVEYXRhKTsKIH0KIAogUGF0aCYgUGF0aDo6b3BlcmF0b3I9KGNvbnN0IFBhdGgmIG90aGVyKQpA QCAtMTc5LDcgKzI0NSw3IEBAIGJvb2wgUGF0aDo6Y29udGFpbnMoY29uc3QgRmxvYXRQb2ludCAm cG9pbnQsIFdpbmRSdWxlIHJ1bGUpIGNvbnN0CiAgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAg IC8vIENHUGF0aENvbnRhaW5zUG9pbnQgcmV0dXJucyBmYWxzZSBmb3Igbm9uLWNsb3NlZCBwYXRo cywgYXMgYSB3b3JrLWFyb3VuZCwgd2UgY29weSBhbmQgY2xvc2UgdGhlIHBhdGggZmlyc3QuICBS YWRhciA0NzU4OTk4IGFza3MgZm9yIGEgYmV0dGVyIENHIEFQSSB0byB1c2UKLSAgICBhdXRvIHBh dGggPSBhZG9wdENGKGNvcHlDR1BhdGhDbG9zaW5nU3VicGF0aHMobV9wYXRoLmdldCgpKSk7Cisg ICAgYXV0byBwYXRoID0gYWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhzKHBsYXRmb3Jt UGF0aCgpKSk7CiAgICAgYm9vbCByZXQgPSBDR1BhdGhDb250YWluc1BvaW50KHBhdGguZ2V0KCks IDAsIHBvaW50LCBydWxlID09IFdpbmRSdWxlOjpFdmVuT2RkID8gdHJ1ZSA6IGZhbHNlKTsKICAg ICByZXR1cm4gcmV0OwogfQpAQCAtMjE3LDkgKzI4Myw5IEBAIHZvaWQgUGF0aDo6dHJhbnNmb3Jt KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIENHQWZmaW5lVHJhbnNmb3Jt IHRyYW5zZm9ybUNHID0gdHJhbnNmb3JtOwogI2lmIFBMQVRGT1JNKFdJTikKICAgICBhdXRvIHBh dGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgQ0dQYXRoQWRkUGF0aChw YXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIG1fcGF0aC5nZXQoKSk7CisgICAgQ0dQYXRoQWRkUGF0 aChwYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIGVuc3VyZVBsYXRmb3JtUGF0aCgpKTsKICNlbHNl Ci0gICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weUJ5VHJhbnNm b3JtaW5nUGF0aChtX3BhdGguZ2V0KCksICZ0cmFuc2Zvcm1DRykpOworICAgIGF1dG8gcGF0aCA9 IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgoZW5zdXJl UGxhdGZvcm1QYXRoKCksICZ0cmFuc2Zvcm1DRykpOwogI2VuZGlmCiAgICAgbV9wYXRoID0gV1RG TW92ZShwYXRoKTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKQEAgLTIz MCw5ICsyOTYsMTUgQEAgRmxvYXRSZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgpIGNvbnN0CiAgICAg aWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm4gQ0dSZWN0WmVybzsKIAorICAgIGlmIChtX2lu bGluZURhdGFUeXBlID09IElubGluZURhdGFUeXBlOjpNb3ZlKQorICAgICAgICByZXR1cm4geyB9 OworCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6OkxpbmUpCisg ICAgICAgIHJldHVybiByZWN0Q29udGFpbmluZ1BvaW50cyhtX2lubGluZURhdGEubGluZS5zdGFy dCwgbV9pbmxpbmVEYXRhLmxpbmUuZW5kKTsKKwogICAgIC8vIENHUGF0aEdldEJvdW5kaW5nQm94 IGluY2x1ZGVzIHRoZSBwYXRoJ3MgY29udHJvbCBwb2ludHMsIENHUGF0aEdldFBhdGhCb3VuZGlu Z0JveCBkb2VzIG5vdC4KIAotICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3VuZGlu Z0JveChtX3BhdGguZ2V0KCkpOworICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3Vu ZGluZ0JveChwbGF0Zm9ybVBhdGgoKSk7CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkg PyBDR1JlY3RaZXJvIDogYm91bmQ7CiB9CiAKQEAgLTI0MCw3ICszMTIsMTQgQEAgRmxvYXRSZWN0 IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAogewogICAgIGlmIChpc051bGwoKSkKICAg ICAgICAgcmV0dXJuIENHUmVjdFplcm87Ci0gICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0Qm91 bmRpbmdCb3gobV9wYXRoLmdldCgpKTsKKworICAgIGlmIChtX2lubGluZURhdGFUeXBlID09IElu bGluZURhdGFUeXBlOjpNb3ZlKQorICAgICAgICByZXR1cm4geyB9OworCisgICAgaWYgKG1faW5s aW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6OkxpbmUpCisgICAgICAgIHJldHVybiByZWN0 Q29udGFpbmluZ1BvaW50cyhtX2lubGluZURhdGEubGluZS5zdGFydCwgbV9pbmxpbmVEYXRhLmxp bmUuZW5kKTsKKworICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldEJvdW5kaW5nQm94KHBsYXRm b3JtUGF0aCgpKTsKICAgICByZXR1cm4gQ0dSZWN0SXNOdWxsKGJvdW5kKSA/IENHUmVjdFplcm8g OiBib3VuZDsKIH0KIApAQCAtMjY5LDExICszNDgsMjUgQEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9r ZUJvdW5kaW5nUmVjdChTdHJva2VTdHlsZUFwcGxpZXIqIGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQg UGF0aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQogeworICAgIGlmIChtX2lubGlu ZURhdGFUeXBlIDw9IElubGluZURhdGFUeXBlOjpNb3ZlKSB7CisgICAgICAgIG1faW5saW5lRGF0 YS5tb3ZlID0gTW92ZURhdGEgeyBwb2ludCB9OworICAgICAgICBtX2lubGluZURhdGFUeXBlID0g SW5saW5lRGF0YVR5cGU6Ok1vdmU7CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9 IHRydWU7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhNb3ZlVG9Qb2ludChl bnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcG9pbnQueCgpLCBwb2ludC55KCkpOwogfQog CiB2b2lkIFBhdGg6OmFkZExpbmVUbyhjb25zdCBGbG9hdFBvaW50JiBwKQogeworICAgIGlmICht X2lubGluZURhdGFUeXBlIDw9IElubGluZURhdGFUeXBlOjpNb3ZlKSB7CisgICAgICAgIG1faW5s aW5lRGF0YS5saW5lID0gTGluZURhdGEgeyBtX2lubGluZURhdGEubW92ZS5sb2NhdGlvbiwgcCB9 OworICAgICAgICBtX2lubGluZURhdGFUeXBlID0gSW5saW5lRGF0YVR5cGU6OkxpbmU7CisgICAg ICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKICAgICBDR1BhdGhBZGRMaW5lVG9Qb2ludChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVs bHB0ciwgcC54KCksIHAueSgpKTsKIH0KIApAQCAtMzU2LDYgKzQ0OSwxMyBAQCB2b2lkIFBhdGg6 OmFkZEFyYyhjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByYWRpdXMsIGZsb2F0IHN0YXJ0QW5n bGUsIGZsb2F0IGVuZAogICAgIGlmICghc3RkOjppc2Zpbml0ZShzdGFydEFuZ2xlKSB8fCAhc3Rk Ojppc2Zpbml0ZShlbmRBbmdsZSkpCiAgICAgICAgIHJldHVybjsKIAorICAgIGlmIChtX2lubGlu ZURhdGFUeXBlIDw9IElubGluZURhdGFUeXBlOjpNb3ZlKSB7CisgICAgICAgIG1faW5saW5lRGF0 YS5hcmMgPSBBcmNEYXRhIHsgbV9pbmxpbmVEYXRhLm1vdmUubG9jYXRpb24sIHAsIHJhZGl1cywg c3RhcnRBbmdsZSwgZW5kQW5nbGUsIGNsb2Nrd2lzZSwgbV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxp bmVEYXRhVHlwZTo6TW92ZSB9OworICAgICAgICBtX2lubGluZURhdGFUeXBlID0gSW5saW5lRGF0 YVR5cGU6OkFyYzsKKyAgICAgICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIENHUGF0aEFkZEFyYyhlbnN1cmVQbGF0Zm9ybVBh dGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpLCByYWRpdXMsIHN0YXJ0QW5nbGUsIGVuZEFuZ2xl LCBjbG9ja3dpc2UpOwogfQogCkBAIC00MDMsMjQgKzUwMywzOSBAQCB2b2lkIFBhdGg6OmNsZWFy KCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVN dXRhYmxlKCkpOworICAgIG1faW5saW5lRGF0YVR5cGUgPSBJbmxpbmVEYXRhVHlwZTo6Q2xlYXJl ZDsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKKyAgICBtX25lZWRzVG9B cHBseUlubGluZURhdGEgPSBmYWxzZTsKIH0KIAogYm9vbCBQYXRoOjppc0VtcHR5KCkgY29uc3QK IHsKLSAgICByZXR1cm4gaXNOdWxsKCkgfHwgQ0dQYXRoSXNFbXB0eShtX3BhdGguZ2V0KCkpOwor ICAgIGlmIChpc051bGwoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAobV9pbmxp bmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSB8fCBtX2lubGluZURhdGFUeXBlID09 IElubGluZURhdGFUeXBlOjpMaW5lIHx8IG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5 cGU6OkFyYykKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIENHUGF0aElzRW1w dHkobV9wYXRoLmdldCgpKTsKIH0KIAogYm9vbCBQYXRoOjpoYXNDdXJyZW50UG9pbnQoKSBjb25z dAogewogICAgIHJldHVybiAhaXNFbXB0eSgpOwogfQotICAgIAorCiBGbG9hdFBvaW50IFBhdGg6 OmN1cnJlbnRQb2ludCgpIGNvbnN0IAogewogICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0 dXJuIEZsb2F0UG9pbnQoKTsKLSAgICByZXR1cm4gQ0dQYXRoR2V0Q3VycmVudFBvaW50KG1fcGF0 aC5nZXQoKSk7CisgICAgICAgIHJldHVybiB7IH07CisKKyAgICBpZiAobV9pbmxpbmVEYXRhVHlw ZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkKKyAgICAgICAgcmV0dXJuIG1faW5saW5lRGF0YS5t b3ZlLmxvY2F0aW9uOworCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5 cGU6OkxpbmUpCisgICAgICAgIHJldHVybiBtX2lubGluZURhdGEubGluZS5lbmQ7CisKKyAgICBy ZXR1cm4gQ0dQYXRoR2V0Q3VycmVudFBvaW50KHBsYXRmb3JtUGF0aCgpKTsKIH0KIAogc3RhdGlj IHZvaWQgQ0dQYXRoQXBwbGllclRvUGF0aEFwcGxpZXIodm9pZCogaW5mbywgY29uc3QgQ0dQYXRo RWxlbWVudCogZWxlbWVudCkKQEAgLTQ1NCwxNCArNTY5LDM5IEBAIHZvaWQgUGF0aDo6YXBwbHko Y29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24pIGNvbnN0CiAgICAgaWYgKGlzTnVs bCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBDR1BhdGhBcHBseShtX3BhdGguZ2V0KCksICh2 b2lkKikmZnVuY3Rpb24sIENHUGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKTsKKyAgICBpZiAobV9p bmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkgeworICAgICAgICBQYXRoRWxl bWVudCBlbGVtZW50OworICAgICAgICBlbGVtZW50LnR5cGUgPSBQYXRoRWxlbWVudDo6VHlwZTo6 TW92ZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQucG9pbnRzWzBdID0gbV9pbmxpbmVEYXRhLm1v dmUubG9jYXRpb247CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgaWYgKG1faW5saW5lRGF0YVR5cGUgPT0gSW5saW5lRGF0YVR5cGU6Okxp bmUpIHsKKyAgICAgICAgUGF0aEVsZW1lbnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVudC50eXBl ID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1BvaW50OworICAgICAgICBlbGVtZW50LnBvaW50 c1swXSA9IG1faW5saW5lRGF0YS5saW5lLnN0YXJ0OworICAgICAgICBmdW5jdGlvbihlbGVtZW50 KTsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6OkFkZExpbmVUb1Bv aW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9IG1faW5saW5lRGF0YS5saW5lLmVuZDsK KyAgICAgICAgZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAg ICBDR1BhdGhBcHBseShwbGF0Zm9ybVBhdGgoKSwgKHZvaWQqKSZmdW5jdGlvbiwgQ0dQYXRoQXBw bGllclRvUGF0aEFwcGxpZXIpOwogfQogCiAjaWYgSEFWRShDR1BBVEhfR0VUX05VTUJFUl9PRl9F TEVNRU5UUykKIAogc2l6ZV90IFBhdGg6OmVsZW1lbnRDb3VudCgpIGNvbnN0CiB7Ci0gICAgcmV0 dXJuIENHUGF0aEdldE51bWJlck9mRWxlbWVudHMobV9wYXRoKTsKKyAgICBpZiAobV9pbmxpbmVE YXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TW92ZSkKKyAgICAgICAgcmV0dXJuIDE7CisKKyAg ICBpZiAobV9pbmxpbmVEYXRhVHlwZSA9PSBJbmxpbmVEYXRhVHlwZTo6TGluZSkKKyAgICAgICAg cmV0dXJuIDI7CisKKyAgICByZXR1cm4gQ0dQYXRoR2V0TnVtYmVyT2ZFbGVtZW50cyhwbGF0Zm9y bVBhdGgoKSk7CiB9CiAKICNlbmRpZiAvLyBIQVZFKENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1F TlRTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxh eWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCmluZGV4IDkxYWIzYmY3ZDg3 YjI0N2FiNjE4ZDk4M2RiNzU0YmMyYjIxNDBlNjQuLjMxMGFkMTk2OTM2ZmEwM2RmZTkyZmUwYmUy MGE0MzM5MDk0ODA4MzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKQEAg LTExOTQsNyArMTE5NCw3IEBAIE9wdGlvbmFsPEZsb2F0UmVjdD4gU3Ryb2tlUGF0aDo6bG9jYWxC b3VuZHMoY29uc3QgR3JhcGhpY3NDb250ZXh0JiBjb250ZXh0KSBjb25zCiAKIHZvaWQgU3Ryb2tl UGF0aDo6YXBwbHkoR3JhcGhpY3NDb250ZXh0JiBjb250ZXh0KSBjb25zdAogewotICAgIGNvbnRl eHQuc3Ryb2tlUGF0aChtX3BhdGgpOworICAgIGNvbnRleHQuc3Ryb2tlUGF0aChzdGQ6OmV4Y2hh bmdlKG1fcGF0aCwgeyB9KSk7CiB9CiAKIHN0YXRpYyBUZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFRl eHRTdHJlYW0mIHRzLCBjb25zdCBTdHJva2VQYXRoJiBpdGVtKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMu aCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5 TGlzdEl0ZW1zLmgKaW5kZXggOTdmZDBhMDBhNGQ0YmM2ZTc2MTI3MmQ5NmViNzQ2NjczMDJmODBh Ni4uMWY0N2ExMDBiNzczYWY5YzRiZWYzOTRiOTkzZWIxNjBlZTk3YmU1ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0 SXRlbXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlz dHMvRGlzcGxheUxpc3RJdGVtcy5oCkBAIC0yNTI1LDcgKzI1MjUsNyBAQCBwcml2YXRlOgogICAg IHZvaWQgYXBwbHkoR3JhcGhpY3NDb250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAgICAgT3B0aW9u YWw8RmxvYXRSZWN0PiBsb2NhbEJvdW5kcyhjb25zdCBHcmFwaGljc0NvbnRleHQmKSBjb25zdCBv dmVycmlkZTsKIAotICAgIGNvbnN0IFBhdGggbV9wYXRoOworICAgIG11dGFibGUgUGF0aCBtX3Bh dGg7CiB9OwogCiB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPgo= 392801 2020-03-06 16:28:41 -0800 2020-03-07 18:10:25 -0800 v2 bug-208464-20200306162840.patch text/plain 26806 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3OTMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGNhYWM0MjZiZTIxODU1 YmRiNDIxM2IzNzQ4ZTkxZGI4MTBhYmIzZi4uNTc4OGJhMzI3ZTQ2MWFhYjNiYTRiYjNjYjA5YmFj YjI0NTIyNGQxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0MSBAQAorMjAyMC0wMy0wNiAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBMYXppbHkgZ2Vu ZXJhdGUgQ0dQYXRocyBmb3Igc29tZSBzaW1wbGUgdHlwZXMgb2YgcGF0aHMsIHN1Y2ggYXMgYXJj cyBhbmQgbGluZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwODQ2NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTk5NjMyMjY+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2hlbiB0aGUgR1BVIHByb2Nl c3MgaXMgZW5hYmxlZCBhbmQgdXNlZCB0byByZW5kZXIgdGhlIGNhbnZhcyBlbGVtZW50LCBzb21l IGNhbnZhcy1yZWxhdGVkIHN1YnRlc3RzIGluCisgICAgICAgIE1vdGlvbk1hcmsgc2VlIHNpZ25p ZmljYW50IHBlcmZvcm1hbmNlIHJlZ3Jlc3Npb25zLiBPbmUgb2YgdGhlIHJlYXNvbnMgZm9yIHRo aXMgaXMgdGhhdCBpbiB0aGUgcHJvY2VzcyBvZgorICAgICAgICBkZWNvZGluZyBkaXNwbGF5IGxp c3QgaXRlbXMgdGhhdCBjb250YWluIGBXZWJDb3JlOjpQYXRoYHMgaW4gdGhlIEdQVSBwcm9jZXNz LCB3ZSBlbmQgdXAgYWxsb2NhdGluZyBhIG5ldyBDR1BhdGgKKyAgICAgICAgZm9yIGVhY2ggV2Vi Q29yZTo6UGF0aC4gVGhpcyBkcmFtYXRpY2FsbHkgaW5jcmVhc2VzIHBhZ2UgZGVtYW5kIGFuZCBt ZW1vcnkgdXNhZ2UgaW4gdGhlIEdQVSBwcm9jZXNzIGluIGNvbnRyYXN0CisgICAgICAgIHRvIHNo aXBwaW5nIFdlYktpdCwgZHVlIHRvIHRoZSBmYWN0IHRoYXQgYWxsIG9mIHRoZXNlIENHUGF0aHMg YWxsb2NhdGVkIHVwLWZyb250LCBhbmQgbXVzdCBhbGwgZXhpc3Qgc29tZXdoZXJlCisgICAgICAg IGluIHRoZSBoZWFwIHVwb24gZGVjb2RpbmcgdGhlIGRpc3BsYXkgbGlzdC4KKworICAgICAgICBJ biBjb250cmFzdCwgaW4gc2hpcHBpbmcgV2ViS2l0LCBlYWNoIGNhbGwgdG8gc3Ryb2tlIHRoZSBj dXJyZW50IGNhbnZhcyBwYXRoIChpLmUuIGludm9raW5nCisgICAgICAgIEdyYXBoaWNzQ29udGV4 dDo6c3Ryb2tlUGF0aCkgaXMgc3VjY2VlZGVkIGJ5IGNsZWFyaW5nIHRoZSBwYXRoLCB3aGljaCBk ZWFsbG9jYXRlcyB0aGUgQ0dQYXRoIGJhY2tpbmcgdGhlIFdlYkNvcmUKKyAgICAgICAgUGF0aC4g VGhlIG5leHQgdGltZSBhIENHUGF0aCBuZWVkcyB0byBiZSBjcmVhdGVkLCBDb3JlR3JhcGhpY3Mg aXMgZnJlZSB0byB0aGVuIGFsbG9jYXRlIHRoZSBuZXcgQ0dQYXRoIGF0IHRoZQorICAgICAgICBh ZGRyZXNzIG9mIHRoZSBwcmV2aW91cyBDR1BhdGggd2hpY2ggd2FzIGp1c3QgZGVzdHJveWVkLCB3 aGljaCBwcmV2ZW50cyB1cyBmcm9tIGRpcnR5aW5nIG1vcmUgcGFnZXMgdGhhbgorICAgICAgICBu ZWNlc3NhcnkuIFRoaXMgcGhlbm9tZW5vbiBhZmZlY3RzIG1vc3Qgb2YgdGhlIGNhbnZhcy1yZWxh dGVkIE1vdGlvbk1hcmsgc3VidGVzdHMgdG8gc29tZSBkZWdyZWUsIHRob3VnaCB0aGUKKyAgICAg ICAgaW1wYWN0IGlzIG1vc3Qgbm90aWNlYWJsZSB3aXRoIENhbnZhcyBMaW5lcy4KKworICAgICAg ICBPbiB0b3Agb2YgYWxsIHRoaXMsIGEgc2lnbmlmaWNhbnQgcG9ydGlvbiBvZiB0aW1lIGlzIGFs c28gc3BlbnQgY2FsbGluZyBDR1BhdGhBcHBseSBhbmQgY29udmVydGluZyB0aGUgcmVzdWx0aW5n CisgICAgICAgIENHUGF0aEVsZW1lbnRzIGludG8gc2VyaWFsaXphYmxlIGRhdGEgd2hlbiBlbmNv ZGluZyBlYWNoIFdlYkNvcmUgUGF0aC4KKworICAgICAgICBUbyBtaXRpZ2F0ZSB0aGVzZSB0d28g aXNzdWVzIGFuZCByZXN0b3JlIHRoZSB3aW5zIHdlIGdldCBmcm9tIG1lbW9yeSBsb2NhbGl0eSB3 aGVuIGRyYXdpbmcgcGF0aHMgaW4gbGFyZ2UKKyAgICAgICAgcXVhbnRpdGllcywgd2UgY2FuOgor CisgICAgICAgIDEuICBJbiB0aGUgY2FzZSBvZiBzaW1wbGUgcGF0aHMsIHN0dWZmIHNvbWUgaW5m b3JtYXRpb24gYWJvdXQgaG93IGVhY2ggcGF0aCB3YXMgY3JlYXRlZCBhcyBpbmxpbmUgZGF0YSBv bgorICAgICAgICAgICAgV2ViQ29yZTo6UGF0aCBpdHNlbGYsIGFzIGEgbmV3IGRhdGEgbWVtYmVy LiBGb3Igbm93LCB0aGlzIG9ubHkgZW5jb21wYXNzZXMgbGluZXMsIGFyY3MsIGFuZCBtb3ZlcyAo UGF0aHMKKyAgICAgICAgICAgIHdoZXJlIG9ubHkgYFBhdGg6Om1vdmVUb2Agd2FzIGludm9rZWQp LCBidXQgbWF5IGJlIGV4cGFuZGVkIGluIHRoZSBmdXR1cmUgdG8gaW5jbHVkZSBlbGxpcHNlcyBh bmQgcmVjdHMuCisgICAgICAgICAgICBUaGlzIGFsbG93cyB1cyB0byBhY2hpZXZlIHR3byB0aGlu Z3M6IChhKSBtYWtlIGVuY29kaW5nIGNoZWFwZXIgYnkgbm90IHJlcXVpcmluZyBhIHdhbGsgdGhy b3VnaCBhbGwgb2YKKyAgICAgICAgICAgIENHUGF0aCdzIGVsZW1lbnRzLCBhbmQgKGIpIG1ha2Ug ZGVjb2RpbmcgY2hlYXBlciBieSBqdXN0IGluaXRpYWxpemluZyB0aGUgUGF0aCB1c2luZyBpbmxp bmUgZGF0YSwgcmF0aGVyCisgICAgICAgICAgICB0aGFuIGhhdmluZyB0byBjcmVhdGUgYSBuZXcg Q0dQYXRoLgorCisgICAgICAgIDIuICBXaGVuIHBhaW50aW5nIHRoZSBTdHJva2VQYXRoIGRpc3Bs YXkgbGlzdCBpdGVtLCBqdXN0IGRpc2NhcmQgYG1fcGF0aGAgYWZ0ZXIgd2UncmUgZG9uZSBwYWlu dGluZyB3aXRoIGl0LgorICAgICAgICAgICAgVGhpcywgaW4gY29uanVuY3Rpb24gd2l0aCAoMSks IG1lYW5zIHRoYXQgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlOjpQYXRoIGluIHRoZSBH UFUgcHJvY2VzcyBpcyBvbmx5CisgICAgICAgICAgICBjcmVhdGVkIHdoZW4gd2UncmUganVzdCBh Ym91dCB0byBwYWludCAoaS5lLiB3aGVuIGNhbGxpbmcgaW50byBzdHJva2VQYXRoKCkpLCBhbmQg ZGVzdHJveWVkIHJpZ2h0IGFmdGVyCisgICAgICAgICAgICB3ZSdyZSBkb25lIHBhaW50aW5nIHdp dGggaXQuCisKKyAgICAgICAgU2VlIGJlbG93IGZvciBkZXRhaWxzLiBUaGVyZSBzaG91bGQgYmUg bm8gY2hhbmdlIGluIGJlaGF2aW9yLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUGF0 aC5oOgorCisgICAgICAgIEludHJvZHVjZSBJbmxpbmVQYXRoRGF0YSwgYSBWYXJpYW50IG9mIHNl dmVyYWwgZGlmZmVyZW50IGlubGluZSBkYXRhIHR5cGVzLCBlYWNoIG9mIHdoaWNoIHJlcHJlc2Vu dHMgb25lIHNpbXBsZQorICAgICAgICBwYXRoIHR5cGUgdGhhdCBpcyBzdG9yZWQgdXNpbmcgb25s eSBpbmxpbmUgZGF0YS4gVGhpcyBpbmNsdWRlcyBsaW5lIHNlZ21lbnRzIChhIHN0YXJ0IHBvaW50 IGFuZCBhbiBlbmQgcG9pbnQpLAorICAgICAgICBhcyB3ZWxsIGFzIGFyY3MgKHdoaWNoLCBpbiBh ZGRpdGlvbiB0byBhIGNlbnRlciBhbmQgc3RhcnQgYW5kIGVuZCBhbmdsZXMpIGFsc28gaW5jbHVk ZXMgYW4gb3B0aW9uYWwgb2Zmc2V0LAorICAgICAgICB3aGljaCByZXByZXNlbnRzIHRoZSBjdXJy ZW50IHBvc2l0aW9uIG9mIHRoZSBwYXRoIGF0IHRoZSB0aW1lICJhZGRBcmMiIHdhcyBjYWxsZWQu CisKKyAgICAgICAgRm9yIGluc3RhbmNlLCBpbiB0aGUgZm9sbG93aW5nIHNjZW5hcmlvLCB0aGUg cGF0aCB3b3VsZCBoYXZlIGFuIGFyYyB0aGF0IGlzIG9mZnNldCBieSAoMTAwLCAwKTsgaWYgZmls bGVkLCBpdAorICAgICAgICB3b3VsZCByZXN1bHQgaW4gYSBjb21wb3NpdGUgc2hhcGUgcmVzZW1i bGluZyBhIHNlbWljaXJjbGUgb24gdG9wIG9mIGEgdHJpYW5nbGU6CisKKyAgICAgICAgcGF0aC5t b3ZlVG8oMTAwLCAwKTsKKyAgICAgICAgcGF0aC5hZGRBcmMoMTAwLCAxMDAsIDUwLCAwLCBQSSwg ZmFsc2UpOworICAgICAgICBjb250ZXh0LmZpbGwocGF0aCk7CisKKyAgICAgICAgV2hlbiBhIFBh dGggaXMgaW5pdGlhbGl6ZWQgKG9yIGFmdGVyIGl0IGlzIGNsZWFyZWQpLCBpdCBzdGFydHMgb2Zm IHdpdGggbmVpdGhlciBhIENHUGF0aCBub3IgaW5saW5lIGRhdGEuIE1vdmluZworICAgICAgICB0 aGUgcGF0aCBjYXVzZXMgaXQgdG8gc3RvcmUgaW5saW5lIE1vdmVEYXRhOyBjYWxsaW5nIGNhbGxp bmcgYGFkZExpbmVUb2Agb3IgYGFkZEFyY2AgdGhlbiByZXBsYWNlcyB0aGUgaW5saW5lCisgICAg ICAgIGRhdGEgd2l0aCBlaXRoZXIgTGluZURhdGEgb3IgQXJjRGF0YS4KKworICAgICAgICBJZiwg YXQgYW55IHBvaW50LCB0aGUgcGF0aCBjaGFuZ2VzIGluIGEgZGlmZmVyZW50IHdheSAoaS5lLiBu ZWl0aGVyIGxpbmUsIGFyYywgbm9yIG1vdmUpLCB3ZSBjbGVhciBvdXQgdGhlCisgICAgICAgIGlu bGluZSBkYXRhIGFuZCBmYWxsIGJhY2sgdG8ganVzdCByZXByZXNlbnRpbmcgdGhlIHBhdGggZGF0 YSB1c2luZyB0aGUgQ0dQYXRoIChtX3BhdGgpLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpo YXNJbmxpbmVEYXRhT2ZUeXBlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0lu bGluZURhdGEgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6TW92ZURhdGE6OmVuY29k ZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpNb3ZlRGF0YTo6ZGVjb2RlKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OkxpbmVEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6TGluZURhdGE6OmRlY29kZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRo OjpBcmNEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6QXJjRGF0 YTo6ZGVjb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuY29kZSBjb25zdCk6CisgICAg ICAgIChXZWJDb3JlOjpQYXRoOjpkZWNvZGUpOgorCisgICAgICAgIFRlYWNoIFBhdGg6OmVuY29k ZSBhbmQgUGF0aDo6ZGVjb2RlIHRvIHJlc3BlY3RpdmVseSBzZXJpYWxpemUgYW5kIGRlc2VyaWFs aXplIFdlYkNvcmU6OlBhdGggYnkgY29uc3VsdGluZyBvbmx5CisgICAgICAgIHRoZSBpbmxpbmUg ZGF0YSwgaWYgaXQgaXMgcHJlc2VudC4gRm9yIHNpbXBsZSB0eXBlcyBvZiBwYXRocywgdGhpcyBk ZWNyZWFzZXMgdGhlIGNvc3Qgb2YgYm90aCBJUEMgZW5jb2RpbmcgYW5kCisgICAgICAgIGRlY29k aW5nLCBidXQgYWRkcyBhIG5lZ2xpZ2libGUgYW1vdW50IG9mIG92ZXJoZWFkIGluIHRoZSBjYXNl IHdoZXJlIHRoZSBwYXRoIGlzIG5vbi1pbmxpbmUuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6 OmlzTnVsbCBjb25zdCk6IERlbGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vUGF0aENhaXJvLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6 CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCBjb25zdCk6CisKKyAgICAg ICAgQWRkIGEgaGVscGVyIG1ldGhvZCB0aGF0IGlzIGludm9rZWQgd2hlbiB0aGUgUGF0aCBpcyBh c2tlZCBmb3IgYSBDR1BhdGguIEluIHRoaXMgY2FzZSwgZXZlbiBpZiBtX3BhdGggaXMgbnVsbCwK KyAgICAgICAgd2UgbmVlZCB0byBsYXppbHkgY3JlYXRlIGl0IGFuZCBhcHBseSBhbnkgaW5saW5l IHBhdGggZGF0YSB3ZSd2ZSBhY2N1bXVsYXRlZC4gT25jZSB3ZSdyZSBkb25lIGFwcGx5aW5nIHRo ZQorICAgICAgICBpbmxpbmUgZGF0YSwgc2V0IGEgZmxhZyAobV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhKSB0byBmYWxzZSB0byBhdm9pZCByZS1hcHBseWluZyBpbmxpbmUgZGF0YSB0byB0aGUgcGF0 aC4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZvcm1QYXRoIGNvbnN0KToKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisKKyAgICAgICAgV2hlbiBl bnN1cmVQbGF0Zm9ybVBhdGggaXMgaW52b2tlZCwgd2UgYXJlIGFib3V0IHRvIG11dGF0ZSBvdXIg Q0dQYXRoIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBjYW4ndCBiZSBleHByZXNzZWQKKyAgICAgICAg aW4gdGVybXMgb2YgaW5saW5lIGRhdGEgKGF0IGxlYXN0LCBub3Qgd2l0aCB0aGUgY2hhbmdlcyBp biB0aGlzIHBhdGNoKS4gQ2xlYXIgb3V0IHRoZSBpbmxpbmUgcGF0aCBkYXRhIGluIHRoaXMKKyAg ICAgICAgY2FzZSwgYW5kIGFwcGx5IHRoZSBDR1BhdGggbXV0YXRpb25zIHRoYXQgd2VyZSBwcmV2 aW91c2x5IHN0YXNoZWQgYXdheSBpbiBpbmxpbmUgcGF0aCBkYXRhLgorCisgICAgICAgIChXZWJD b3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorCisgICAgICAgIEEgcGF0aCBpcyBub3cgY29uc2lk ZXJlZCBudWxsIGlmIGl0IGlzIG5vdCBvbmx5IG1pc3NpbmcgYSBDR1BhdGgsIGJ1dCBhbHNvIGRv ZXMgbm90IGhhdmUgYW55IGlubGluZSBwYXRoIGRhdGEuCisgICAgICAgIFRoaXMgbWFpbnRhaW5z IHRoZSBpbnZhcmlhbnQgdGhhdCBgaXNOdWxsKClgIGlzIHRydWUgaWZmIHRoZSBgcGxhdGZvcm1Q YXRoKClgIHJldHVybnMgMHgwLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpQYXRoKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OnN3YXApOgorCisgICAgICAgIFVwZGF0ZSB0aGUgY29uc3Ry dWN0b3JzIGFuZCBgc3dhcGAgaGVscGVyIG1ldGhvZCAodXNlZCBieSBhc3NpZ25tZW50IG9wZXJh dG9ycykgdG8gYWNjb3VudCBmb3IgdGhlIG5ldyBtZW1iZXJzLgorCisgICAgICAgIChXZWJDb3Jl OjpQYXRoOjpjb250YWlucyBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjp0cmFuc2Zv cm0pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0IGNvbnN0KToKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3QgY29uc3QpOgorICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6bW92ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZExpbmVUbyk6 CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmMpOgorCisgICAgICAgIEluIHRoZSBjYXNl IG9mIHRoZXNlIHRocmVlIG1ldGhvZHMgZm9yIG11dGF0aW5nIGEgcGF0aCwgaWYgd2UndmUgZWl0 aGVyIG9ubHkgbW92ZWQgdGhlIHBhdGggb3IgaGF2ZW4ndCB0b3VjaGVkCisgICAgICAgIGl0IGF0 IGFsbCwgd2UgY2FuIGdldCBhd2F5IHdpdGggb25seSB1cGRhdGluZyBvdXIgaW5saW5lIHBhdGgg ZGF0YSwgYW5kIGF2b2lkIGNyZWF0aW5nIGEgQ0dQYXRoLgorCisgICAgICAgIChXZWJDb3JlOjpQ YXRoOjpjbGVhcik6CisKKyAgICAgICAgV2hlbiBjbGVhcmluZyBQYXRoLCBpbnN0ZWFkIG9mIHNl dHRpbmcgYG1fcGF0aGAgdG8gYSBuZXdseSBhbGxvY2F0ZWQgQ0dQYXRoLCBzaW1wbHkgcmVzZXQg aXQgdG8gbnVsbC4gVGhpcworICAgICAgICBlbnN1cmVzIHRoYXQgaWYgd2UgdGhlbiBhcHBseSBz b21lIGNoYW5nZXMgdGhhdCBjYW4gYmUgZXhwcmVzc2VkIHVzaW5nIG9ubHkgaW5saW5lIHBhdGgg ZGF0YSwgd2UgYXZvaWQgaGF2aW5nIHRvCisgICAgICAgIHVwZGF0ZSB0aGUgQ0dQYXRoLCBhbmQg aW5zdGVhZCBqdXN0IHVwZGF0ZSB0aGUgaW5saW5lIHBhdGggZGF0YS4KKworICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJy ZW50UG9pbnQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHkgY29uc3QpOgor CisgICAgICAgIFRocm93IG91dCB0aGUgY3VycmVudCBXZWJDb3JlOjpQYXRoIGFmdGVyIHdlJ3Jl IGRvbmUgcGFpbnRpbmcgd2l0aCBpdCAoc2VlICgyKSBpbiB0aGUgYWJvdmUgQ2hhbmdlTG9nIGVu dHJ5KS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZWxlbWVudENvdW50IGNvbnN0KToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6Ok1vdmVEYXRhOjphcHBseSBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjpMaW5lRGF0YTo6YXBwbHkgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6 UGF0aDo6QXJjRGF0YTo6YXBwbHkgY29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRp c3BsYXlMaXN0OjpTdHJva2VQYXRoOjphcHBseSBjb25zdCk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaDoKKyAgICAgICAgKiBwbGF0 Zm9ybS9ncmFwaGljcy93aW4vUGF0aERpcmVjdDJELmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmlzTnVsbCBjb25zdCk6CisKIDIwMjAtMDMtMDUgIEtlbm5ldGggUnVzc2VsbCAgPGtickBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUkVHUkVTU0lPTjogWyBNYWMgXSBmYXN0L2NhbnZhcy93 ZWJnbC90ZXhJbWFnZTJELXZpZGVvLWZsaXBZLWZhbHNlLmh0bWwgaXMgVGltaW5nIG91dApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCmluZGV4IDdmYWRhNjBkODNjMjkyNTBh YzRhMTc0OGE4OTI0MDcwMjkxOTllMWIuLjNhNDY5YjNjZjQ0YThmZTc4OGYyZDlmY2YwZjgwNzk3 NDljMjZiNWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Bh dGguaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKQEAgLTI1 LDE0ICsyNSwxNCBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCiAgKi8KIAotI2lmbmRlZiBQYXRoX2gKLSNk ZWZpbmUgUGF0aF9oCisjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIkZsb2F0UmVjdC5oIgogI2lu Y2x1ZGUgIldpbmRSdWxlLmgiCiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KICNpbmNsdWRl IDx3dGYvRnVuY3Rpb24uaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0 Zi9WYXJpYW50Lmg+CiAKICNpZiBVU0UoQ0cpCiAKQEAgLTE0Nyw3ICsxNDcsNyBAQCBwdWJsaWM6 CiAgICAgRmxvYXRQb2ludCBwb2ludEF0TGVuZ3RoKGZsb2F0IGxlbmd0aCkgY29uc3Q7CiAKICAg ICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7Ci0gICAgYm9vbCBpc051bGwoKSBjb25zdCB7 IHJldHVybiAhbV9wYXRoOyB9CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBpc051bGwoKSBjb25z dDsKICAgICBib29sIGlzRW1wdHkoKSBjb25zdDsKICAgICAvLyBHZXRzIHRoZSBjdXJyZW50IHBv aW50IG9mIHRoZSBjdXJyZW50IHBhdGgsIHdoaWNoIGlzIGNvbmNlcHR1YWxseSB0aGUgZmluYWwg cG9pbnQgcmVhY2hlZCBieSB0aGUgcGF0aCBzbyBmYXIuCiAgICAgLy8gTm90ZSB0aGUgUGF0aCBj YW4gYmUgZW1wdHkgKGlzRW1wdHkoKSA9PSB0cnVlKSBhbmQgc3RpbGwgaGF2ZSBhIGN1cnJlbnQg cG9pbnQuCkBAIC0xODUsNyArMTg1LDcgQEAgcHVibGljOgogICAgIEZsb2F0UmVjdCBmYXN0Qm91 bmRpbmdSZWN0Rm9yU3Ryb2tlKGNvbnN0IFBsYXRmb3JtQ29udGV4dERpcmVjdDJEJikgY29uc3Q7 CiAgICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0 aC5nZXQoKTsgfQogI2VsaWYgVVNFKENHKQotICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBh dGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGguZ2V0KCk7IH0KKyAgICBXRUJDT1JFX0VYUE9SVCBQ bGF0Zm9ybVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3Q7CiAjZWxzZQogICAgIFBsYXRmb3Jt UGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGg7IH0KICNlbmRpZgpA QCAtMjI0LDEwICsyMjQsNjAgQEAgcHVibGljOgogICAgIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+ IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKICAgICB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVy PiBzdGF0aWMgT3B0aW9uYWw8UGF0aD4gZGVjb2RlKERlY29kZXImKTsKIAorI2lmIFVTRShDRykK KyAgICBlbnVtIGNsYXNzIE5vSW5saW5lRGF0YVR5cGUgOiB1aW50OF90IHsgTm9JbmxpbmVEYXRh ID0gMCB9OworI2VuZGlmCisKIHByaXZhdGU6CiAjaWYgVVNFKENHKQorICAgIHN0cnVjdCBMaW5l RGF0YSB7CisgICAgICAgIEZsb2F0UG9pbnQgc3RhcnQ7CisgICAgICAgIEZsb2F0UG9pbnQgZW5k OworCisgICAgICAgIHZvaWQgYXBwbHkoY29uc3QgUGF0aCYpIGNvbnN0OworCisgICAgICAgIHRl bXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKKyAgICAg ICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPExpbmVEYXRhPiBkZWNv ZGUoRGVjb2RlciYpOworICAgIH07CisKKyAgICBzdHJ1Y3QgQXJjRGF0YSB7CisgICAgICAgIEZs b2F0UG9pbnQgb2Zmc2V0OworICAgICAgICBGbG9hdFBvaW50IGNlbnRlcjsKKyAgICAgICAgZmxv YXQgcmFkaXVzIHsgMCB9OworICAgICAgICBmbG9hdCBzdGFydCB7IDAgfTsKKyAgICAgICAgZmxv YXQgZW5kIHsgMCB9OworICAgICAgICBib29sIGNsb2Nrd2lzZSB7IGZhbHNlIH07CisgICAgICAg IGJvb2wgaGFzT2Zmc2V0IHsgZmFsc2UgfTsKKworICAgICAgICB2b2lkIGFwcGx5KGNvbnN0IFBh dGgmKSBjb25zdDsKKworICAgICAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIGVuY29k ZShFbmNvZGVyJikgY29uc3Q7CisgICAgICAgIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+IHN0YXRp YyBPcHRpb25hbDxBcmNEYXRhPiBkZWNvZGUoRGVjb2RlciYpOworICAgIH07CisKKyAgICBzdHJ1 Y3QgTW92ZURhdGEgeworICAgICAgICBGbG9hdFBvaW50IGxvY2F0aW9uOworCisgICAgICAgIHZv aWQgYXBwbHkoY29uc3QgUGF0aCYpIGNvbnN0OworCisgICAgICAgIHRlbXBsYXRlPGNsYXNzIEVu Y29kZXI+IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKKyAgICAgICAgdGVtcGxhdGU8Y2xh c3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPE1vdmVEYXRhPiBkZWNvZGUoRGVjb2RlciYpOwor ICAgIH07CisKKyAgICB0ZW1wbGF0ZSA8dHlwZW5hbWUgRGF0YVR5cGU+CisgICAgYm9vbCBoYXNJ bmxpbmVEYXRhT2ZUeXBlKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBXVEY6OmhvbGRz X2FsdGVybmF0aXZlPERhdGFUeXBlPihtX2lubGluZURhdGEpOworICAgIH0KKworICAgIGJvb2wg aGFzSW5saW5lRGF0YSgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gIWhhc0lubGluZURh dGFPZlR5cGU8Tm9JbmxpbmVEYXRhVHlwZT4oKTsKKyAgICB9CisKKyAgICB2b2lkIGFwcGx5SW5s aW5lUGF0aERhdGFJZk5lZWRlZCgpIGNvbnN0OwogICAgIHZvaWQgc3dhcChQYXRoJik7Ci0jZW5k aWYKKyNlbmRpZiAvLyBVU0UoQ0cpCiAKICAgICBtdXRhYmxlIFBsYXRmb3JtUGF0aFN0b3JhZ2VU eXBlIG1fcGF0aDsKIApAQCAtMjM4LDE0ICsyODgsOTggQEAgcHJpdmF0ZToKICNlbmRpZgogCiAj aWYgVVNFKENHKQorICAgIFZhcmlhbnQ8Tm9JbmxpbmVEYXRhVHlwZSwgTW92ZURhdGEsIExpbmVE YXRhLCBBcmNEYXRhPiBtX2lubGluZURhdGEgeyBOb0lubGluZURhdGFUeXBlOjpOb0lubGluZURh dGEgfTsKICAgICBtdXRhYmxlIGJvb2wgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uIHsgZmFsc2Ug fTsKLSNlbmRpZgorICAgIG11dGFibGUgYm9vbCBtX25lZWRzVG9BcHBseUlubGluZURhdGEgeyBm YWxzZSB9OworI2VuZGlmIC8vIFVTRShDRykKIH07CiAKIFdURjo6VGV4dFN0cmVhbSYgb3BlcmF0 b3I8PChXVEY6OlRleHRTdHJlYW0mLCBjb25zdCBQYXRoJik7CiAKKyNpZiBVU0UoQ0cpCisKK3Rl bXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgUGF0aDo6TW92ZURhdGE6OmVuY29kZShFbmNvZGVy JiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIgPDwgbG9jYXRpb247Cit9CisKK3RlbXBs YXRlPGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPFBhdGg6Ok1vdmVEYXRhPiBQYXRoOjpNb3ZlRGF0 YTo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCit7CisgICAgUGF0aDo6TW92ZURhdGEgZGF0YTsK KyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEubG9jYXRpb24pKQorICAgICAgICByZXR1cm4g V1RGOjpudWxsb3B0OworICAgIHJldHVybiB7IGRhdGEgfTsKK30KKwordGVtcGxhdGU8Y2xhc3Mg RW5jb2Rlcj4gdm9pZCBQYXRoOjpMaW5lRGF0YTo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNv bnN0Cit7CisgICAgZW5jb2RlciA8PCBzdGFydDsKKyAgICBlbmNvZGVyIDw8IGVuZDsKK30KKwor dGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aDo6TGluZURhdGE+IFBhdGg6Okxp bmVEYXRhOjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlcikKK3sKKyAgICBQYXRoOjpMaW5lRGF0YSBk YXRhOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5zdGFydCkpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuZW5kKSkKKyAg ICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIHJldHVybiB7IFdURk1vdmUoZGF0YSkg fTsKK30KKwordGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRoOjpBcmNEYXRhOjplbmNv ZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVyIDw8IG9mZnNldDsKKyAg ICBlbmNvZGVyIDw8IGNlbnRlcjsKKyAgICBlbmNvZGVyIDw8IHJhZGl1czsKKyAgICBlbmNvZGVy IDw8IHN0YXJ0OworICAgIGVuY29kZXIgPDwgZW5kOworICAgIGVuY29kZXIgPDwgY2xvY2t3aXNl OworICAgIGVuY29kZXIgPDwgaGFzT2Zmc2V0OworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVy PiBPcHRpb25hbDxQYXRoOjpBcmNEYXRhPiBQYXRoOjpBcmNEYXRhOjpkZWNvZGUoRGVjb2RlciYg ZGVjb2RlcikKK3sKKyAgICBQYXRoOjpBcmNEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRl Y29kZShkYXRhLm9mZnNldCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBp ZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuY2VudGVyKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVs bG9wdDsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5yYWRpdXMpKQorICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnN0YXJ0 KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5kZWNv ZGUoZGF0YS5lbmQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFk ZWNvZGVyLmRlY29kZShkYXRhLmNsb2Nrd2lzZSkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxv cHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuaGFzT2Zmc2V0KSkKKyAgICAgICAg cmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIHJldHVybiB7IFdURk1vdmUoZGF0YSkgfTsKK30K KworI2VuZGlmIC8vIFVTRShDRykKKwogdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRo OjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHsKKyNpZiBVU0UoQ0cpCisgICAgYm9v bCBoYXNJbmxpbmVEYXRhID0gdGhpcy0+aGFzSW5saW5lRGF0YSgpOworICAgIGVuY29kZXIgPDwg aGFzSW5saW5lRGF0YTsKKyAgICBpZiAoaGFzSW5saW5lRGF0YSkgeworICAgICAgICBlbmNvZGVy IDw8IG1faW5saW5lRGF0YTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyNlbmRpZiAvLyBVU0Uo Q0cpCisKICAgICBlbmNvZGVyIDw8IHN0YXRpY19jYXN0PHVpbnQ2NF90PihlbGVtZW50Q291bnQo KSk7CiAKICAgICBhcHBseShbJl0oYXV0byYgZWxlbWVudCkgewpAQCAtMjc2LDYgKzQxMCwyMSBA QCB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIFBhdGg6OmVuY29kZShFbmNvZGVyJiBlbmNv ZGVyKSBjb25zdAogdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aD4gUGF0aDo6 ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCiB7CiAgICAgUGF0aCBwYXRoOworCisjaWYgVVNFKENH KQorICAgIGJvb2wgaGFzSW5saW5lRGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc0lu bGluZURhdGEpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKGhhc0lu bGluZURhdGEpIHsKKyAgICAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0 YSkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9u ZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHBhdGg7CisgICAg fQorI2VuZGlmCisKICAgICB1aW50NjRfdCBudW1Qb2ludHM7CiAgICAgaWYgKCFkZWNvZGVyLmRl Y29kZShudW1Qb2ludHMpKQogICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OwpAQCAtMzM5LDYg KzQ4OCwxNiBAQCB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBPcHRpb25hbDxQYXRoPiBQYXRoOjpk ZWNvZGUoRGVjb2RlciYgZGVjb2RlcikKICAgICByZXR1cm4gcGF0aDsKIH0KIAotfQorfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQogCi0jZW5kaWYKK25hbWVzcGFjZSBXVEYgeworCisjaWYgVVNFKENH KQorCit0ZW1wbGF0ZTw+IHN0cnVjdCBFbnVtVHJhaXRzPFdlYkNvcmU6OlBhdGg6Ok5vSW5saW5l RGF0YVR5cGU+IHsKKyAgICB1c2luZyB2YWx1ZXMgPSBFbnVtVmFsdWVzPFdlYkNvcmU6OlBhdGg6 Ok5vSW5saW5lRGF0YVR5cGUsIFdlYkNvcmU6OlBhdGg6Ok5vSW5saW5lRGF0YVR5cGU6Ok5vSW5s aW5lRGF0YT47Cit9OworCisjZW5kaWYgLy8gVVNFKENHKQorCit9IC8vIG5hbWVzcGFjZSBXVEYK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhD YWlyby5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fp cm8uY3BwCmluZGV4IGUxYjU1NGM4ODRjMTUyZDVhOThiMDRhOTdjYTQ3NzNmNTQ3Mzg2M2IuLmVh N2JkNzIzMmMyNzhhMmIxZDA3YTQ1YjNmNjZjODg3MWYzM2E3NTkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcApAQCAtNDU1 LDYgKzQ1NSwxMSBAQCB2b2lkIFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0m IHRyYW5zZm9ybSkKICAgICBjYWlyb190cmFuc2Zvcm0oY3IsICZtYXRyaXgpOwogfQogCitib29s IFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGg7Cit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIFVTRShDQUlSTykKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCmluZGV4IDUyMWMxNTUzYTlhNmEz NGEzODFjMzRmOTc4NjI1NGRkNWYwYzcyNmUuLjQ2OWFiNDJhMzAxZTA4MTkyOWQ2OTIzNWMyZTQ3 Y2IyY2Y1ZGE1NjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2NnL1BhdGhDRy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cv UGF0aENHLmNwcApAQCAtODksNiArODksMzMgQEAgUGF0aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRh YmxlUGF0aFJlZj4mJiBwYXRoKQogUGF0aDo6UGF0aCgpID0gZGVmYXVsdDsKIFBhdGg6On5QYXRo KCkgPSBkZWZhdWx0OwogCit2b2lkIFBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCgp IGNvbnN0Cit7CisgICAgaWYgKCFtX25lZWRzVG9BcHBseUlubGluZURhdGEpCisgICAgICAgIHJl dHVybjsKKworICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IGZhbHNlOworCisgICAgaWYg KCFoYXNJbmxpbmVEYXRhKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9wYXRoKQor ICAgICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7CisKKyAgICBX VEY6OnN3aXRjaE9uKG1faW5saW5lRGF0YSwKKyAgICAgICAgWyZdIChhdXRvKSB7IEFTU0VSVF9O T1RfUkVBQ0hFRCgpOyB9LAorICAgICAgICBbJl0gKGNvbnN0IE1vdmVEYXRhJiBtb3ZlKSB7IG1v dmUuYXBwbHkoKnRoaXMpOyB9LAorICAgICAgICBbJl0gKGNvbnN0IExpbmVEYXRhJiBsaW5lKSB7 IGxpbmUuYXBwbHkoKnRoaXMpOyB9LAorICAgICAgICBbJl0gKGNvbnN0IEFyY0RhdGEmIGFyYykg eyBhcmMuYXBwbHkoKnRoaXMpOyB9CisgICAgKTsKK30KKworUGxhdGZvcm1QYXRoUHRyIFBhdGg6 OnBsYXRmb3JtUGF0aCgpIGNvbnN0Cit7CisgICAgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVk KCk7CisgICAgcmV0dXJuIG1fcGF0aC5nZXQoKTsKK30KKwogUGxhdGZvcm1QYXRoUHRyIFBhdGg6 OmVuc3VyZVBsYXRmb3JtUGF0aCgpCiB7CiAgICAgaWYgKCFtX3BhdGgpCkBAIC05OCwxMiArMTI1 LDIxIEBAIFBsYXRmb3JtUGF0aFB0ciBQYXRoOjplbnN1cmVQbGF0Zm9ybVBhdGgoKQogICAgICAg ICAgICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weShtX3BhdGguZ2V0 KCkpKTsKICAgICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7CiAgICAgfQor ICAgIGFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCgpOworICAgIG1faW5saW5lRGF0YSA9IE5v SW5saW5lRGF0YVR5cGU6Ok5vSW5saW5lRGF0YTsKICAgICByZXR1cm4gbV9wYXRoLmdldCgpOwog fQogCitib29sIFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGggJiYg IWhhc0lubGluZURhdGEoKTsKK30KKwogUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIHsK ICAgICBtX3BhdGggPSB7IG90aGVyLm1fcGF0aCB9OworICAgIG1faW5saW5lRGF0YSA9IG90aGVy Lm1faW5saW5lRGF0YTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBvdGhlci5tX25l ZWRzVG9BcHBseUlubGluZURhdGE7CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAgICBtX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3Jl TXV0YXRpb24gPSB0cnVlOwpAQCAtMTEyLDE0ICsxNDgsMTggQEAgUGF0aDo6UGF0aChjb25zdCBQ YXRoJiBvdGhlcikKIAogUGF0aDo6UGF0aChQYXRoJiYgb3RoZXIpCiAgICAgOiBtX3BhdGgoc3Rk OjpleGNoYW5nZShvdGhlci5tX3BhdGgsIG51bGxwdHIpKQorICAgICwgbV9pbmxpbmVEYXRhKHN0 ZDo6ZXhjaGFuZ2Uob3RoZXIubV9pbmxpbmVEYXRhLCBOb0lubGluZURhdGFUeXBlOjpOb0lubGlu ZURhdGEpKQogICAgICwgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKHN0ZDo6ZXhjaGFuZ2Uob3Ro ZXIubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBmYWxzZSkpCisgICAgLCBtX25lZWRzVG9BcHBs eUlubGluZURhdGEoc3RkOjpleGNoYW5nZShvdGhlci5tX25lZWRzVG9BcHBseUlubGluZURhdGEs IGZhbHNlKSkKIHsKIH0KIAogdm9pZCBQYXRoOjpzd2FwKFBhdGgmIG90aGVyUGF0aCkKIHsKICAg ICBzdGQ6OnN3YXAobV9wYXRoLCBvdGhlclBhdGgubV9wYXRoKTsKKyAgICBzdGQ6OnN3YXAobV9p bmxpbmVEYXRhLCBvdGhlclBhdGgubV9pbmxpbmVEYXRhKTsKICAgICBzdGQ6OnN3YXAobV9jb3B5 UGF0aEJlZm9yZU11dGF0aW9uLCBvdGhlclBhdGgubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKTsK KyAgICBzdGQ6OnN3YXAobV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBvdGhlclBhdGgubV9uZWVk c1RvQXBwbHlJbmxpbmVEYXRhKTsKIH0KIAogUGF0aCYgUGF0aDo6b3BlcmF0b3I9KGNvbnN0IFBh dGgmIG90aGVyKQpAQCAtMTc5LDcgKzIxOSw3IEBAIGJvb2wgUGF0aDo6Y29udGFpbnMoY29uc3Qg RmxvYXRQb2ludCAmcG9pbnQsIFdpbmRSdWxlIHJ1bGUpIGNvbnN0CiAgICAgICAgIHJldHVybiBm YWxzZTsKIAogICAgIC8vIENHUGF0aENvbnRhaW5zUG9pbnQgcmV0dXJucyBmYWxzZSBmb3Igbm9u LWNsb3NlZCBwYXRocywgYXMgYSB3b3JrLWFyb3VuZCwgd2UgY29weSBhbmQgY2xvc2UgdGhlIHBh dGggZmlyc3QuICBSYWRhciA0NzU4OTk4IGFza3MgZm9yIGEgYmV0dGVyIENHIEFQSSB0byB1c2UK LSAgICBhdXRvIHBhdGggPSBhZG9wdENGKGNvcHlDR1BhdGhDbG9zaW5nU3VicGF0aHMobV9wYXRo LmdldCgpKSk7CisgICAgYXV0byBwYXRoID0gYWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBh dGhzKHBsYXRmb3JtUGF0aCgpKSk7CiAgICAgYm9vbCByZXQgPSBDR1BhdGhDb250YWluc1BvaW50 KHBhdGguZ2V0KCksIDAsIHBvaW50LCBydWxlID09IFdpbmRSdWxlOjpFdmVuT2RkID8gdHJ1ZSA6 IGZhbHNlKTsKICAgICByZXR1cm4gcmV0OwogfQpAQCAtMjE3LDkgKzI1Nyw5IEBAIHZvaWQgUGF0 aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIENHQWZm aW5lVHJhbnNmb3JtIHRyYW5zZm9ybUNHID0gdHJhbnNmb3JtOwogI2lmIFBMQVRGT1JNKFdJTikK ICAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgQ0dQ YXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIG1fcGF0aC5nZXQoKSk7CisgICAg Q0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIGVuc3VyZVBsYXRmb3JtUGF0 aCgpKTsKICNlbHNlCi0gICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxl Q29weUJ5VHJhbnNmb3JtaW5nUGF0aChtX3BhdGguZ2V0KCksICZ0cmFuc2Zvcm1DRykpOworICAg IGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWlu Z1BhdGgoZW5zdXJlUGxhdGZvcm1QYXRoKCksICZ0cmFuc2Zvcm1DRykpOwogI2VuZGlmCiAgICAg bV9wYXRoID0gV1RGTW92ZShwYXRoKTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBm YWxzZTsKQEAgLTIzMCw5ICsyNzAsMTkgQEAgRmxvYXRSZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgp IGNvbnN0CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm4gQ0dSZWN0WmVybzsKIAor ICAgIGlmIChoYXNJbmxpbmVEYXRhT2ZUeXBlPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4g eyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGFPZlR5cGU8TGluZURhdGE+KCkpIHsKKyAgICAg ICAgRmxvYXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGluZSA9IFdURjo6Z2V0PExpbmVE YXRhPihtX2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0VG9Qb2ludHMobGluZS5zdGFy dCwgbGluZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKwogICAgIC8vIENH UGF0aEdldEJvdW5kaW5nQm94IGluY2x1ZGVzIHRoZSBwYXRoJ3MgY29udHJvbCBwb2ludHMsIENH UGF0aEdldFBhdGhCb3VuZGluZ0JveCBkb2VzIG5vdC4KIAotICAgIENHUmVjdCBib3VuZCA9IENH UGF0aEdldFBhdGhCb3VuZGluZ0JveChtX3BhdGguZ2V0KCkpOworICAgIENHUmVjdCBib3VuZCA9 IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChwbGF0Zm9ybVBhdGgoKSk7CiAgICAgcmV0dXJuIENH UmVjdElzTnVsbChib3VuZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7CiB9CiAKQEAgLTI0MCw3ICsy OTAsMTggQEAgRmxvYXRSZWN0IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAogewogICAg IGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuIENHUmVjdFplcm87Ci0gICAgQ0dSZWN0IGJv dW5kID0gQ0dQYXRoR2V0Qm91bmRpbmdCb3gobV9wYXRoLmdldCgpKTsKKworICAgIGlmIChoYXNJ bmxpbmVEYXRhT2ZUeXBlPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4geyB9OworCisgICAg aWYgKGhhc0lubGluZURhdGFPZlR5cGU8TGluZURhdGE+KCkpIHsKKyAgICAgICAgRmxvYXRSZWN0 IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGluZSA9IFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGlu ZURhdGEpOworICAgICAgICByZXN1bHQuZml0VG9Qb2ludHMobGluZS5zdGFydCwgbGluZS5lbmQp OworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKworICAgIENHUmVjdCBib3VuZCA9IENH UGF0aEdldEJvdW5kaW5nQm94KHBsYXRmb3JtUGF0aCgpKTsKICAgICByZXR1cm4gQ0dSZWN0SXNO dWxsKGJvdW5kKSA/IENHUmVjdFplcm8gOiBib3VuZDsKIH0KIApAQCAtMjY5LDExICszMzAsMjMg QEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5nUmVjdChTdHJva2VTdHlsZUFwcGxpZXIq IGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHBv aW50KQogeworICAgIGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRhT2ZUeXBlPE1vdmVEYXRh PigpKSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9IE1vdmVEYXRhIHsgcG9pbnQgfTsKKyAgICAg ICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKwogICAgIENHUGF0aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRy LCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0 IEZsb2F0UG9pbnQmIHApCiB7CisgICAgaWYgKGlzTnVsbCgpIHx8IGhhc0lubGluZURhdGFPZlR5 cGU8TW92ZURhdGE+KCkpIHsKKyAgICAgICAgbV9pbmxpbmVEYXRhID0gTGluZURhdGEgeyBoYXNJ bmxpbmVEYXRhKCkgPyBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2NhdGlvbiA6 IEZsb2F0UG9pbnQoKSwgcCB9OworICAgICAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSB0 cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQo ZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSk7CiB9CiAKQEAgLTM1 Niw2ICs0MjksMTIgQEAgdm9pZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQb2ludCYgcCwgZmxv YXQgcmFkaXVzLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmQKICAgICBpZiAoIXN0ZDo6aXNm aW5pdGUoc3RhcnRBbmdsZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUpKQogICAgICAgICBy ZXR1cm47CiAKKyAgICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YU9mVHlwZTxNb3ZlRGF0 YT4oKSkgeworICAgICAgICBtX2lubGluZURhdGEgPSBBcmNEYXRhIHsgaGFzSW5saW5lRGF0YSgp ID8gV1RGOjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb24gOiBGbG9hdFBvaW50 KCksIHAsIHJhZGl1cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGNsb2Nrd2lzZSwgaGFzSW5saW5l RGF0YSgpIH07CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhBZGRBcmMoZW5zdXJlUGxhdGZvcm1QYXRo KCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSwgcmFkaXVzLCBzdGFydEFuZ2xlLCBlbmRBbmdsZSwg Y2xvY2t3aXNlKTsKIH0KIApAQCAtNDAyLDI1ICs0ODEsNDAgQEAgdm9pZCBQYXRoOjpjbGVhcigp CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX3BhdGggPSBhZG9w dENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7CisgICAgbV9wYXRoLmNsZWFyKCk7CisgICAgbV9p bmxpbmVEYXRhID0gTm9JbmxpbmVEYXRhVHlwZTo6Tm9JbmxpbmVEYXRhOwogICAgIG1fY29weVBh dGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOworICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9 IGZhbHNlOwogfQogCiBib29sIFBhdGg6OmlzRW1wdHkoKSBjb25zdAogewotICAgIHJldHVybiBp c051bGwoKSB8fCBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQoKSk7CisgICAgaWYgKGlzTnVsbCgp KQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhKCkpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQo KSk7CiB9CiAKIGJvb2wgUGF0aDo6aGFzQ3VycmVudFBvaW50KCkgY29uc3QKIHsKICAgICByZXR1 cm4gIWlzRW1wdHkoKTsKIH0KLSAgICAKLUZsb2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50KCkg Y29uc3QgCisKK0Zsb2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50KCkgY29uc3QKIHsKICAgICBp ZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybiBGbG9hdFBvaW50KCk7Ci0gICAgcmV0dXJuIENH UGF0aEdldEN1cnJlbnRQb2ludChtX3BhdGguZ2V0KCkpOworICAgICAgICByZXR1cm4geyB9Owor CisgICAgaWYgKGhhc0lubGluZURhdGFPZlR5cGU8TW92ZURhdGE+KCkpCisgICAgICAgIHJldHVy biBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2NhdGlvbjsKKworICAgIGlmICho YXNJbmxpbmVEYXRhT2ZUeXBlPExpbmVEYXRhPigpKQorICAgICAgICByZXR1cm4gV1RGOjpnZXQ8 TGluZURhdGE+KG1faW5saW5lRGF0YSkuZW5kOworCisgICAgcmV0dXJuIENHUGF0aEdldEN1cnJl bnRQb2ludChwbGF0Zm9ybVBhdGgoKSk7CiB9CiAKIHN0YXRpYyB2b2lkIENHUGF0aEFwcGxpZXJU b1BhdGhBcHBsaWVyKHZvaWQqIGluZm8sIGNvbnN0IENHUGF0aEVsZW1lbnQqIGVsZW1lbnQpCkBA IC00NTQsMTggKzU0OCw2MiBAQCB2b2lkIFBhdGg6OmFwcGx5KGNvbnN0IFBhdGhBcHBsaWVyRnVu Y3Rpb24mIGZ1bmN0aW9uKSBjb25zdAogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJu OwogCi0gICAgQ0dQYXRoQXBwbHkobV9wYXRoLmdldCgpLCAodm9pZCopJmZ1bmN0aW9uLCBDR1Bh dGhBcHBsaWVyVG9QYXRoQXBwbGllcik7CisgICAgaWYgKGhhc0lubGluZURhdGFPZlR5cGU8TW92 ZURhdGE+KCkpIHsKKyAgICAgICAgUGF0aEVsZW1lbnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVu dC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1BvaW50OworICAgICAgICBlbGVtZW50 LnBvaW50c1swXSA9IFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uOwor ICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAg IGlmIChoYXNJbmxpbmVEYXRhT2ZUeXBlPExpbmVEYXRhPigpKSB7CisgICAgICAgIGF1dG8mIGxp bmUgPSBXVEY6OmdldDxMaW5lRGF0YT4obV9pbmxpbmVEYXRhKTsKKyAgICAgICAgUGF0aEVsZW1l bnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1v dmVUb1BvaW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9IGxpbmUuc3RhcnQ7CisgICAg ICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICBlbGVtZW50LnR5cGUgPSBQYXRoRWxlbWVu dDo6VHlwZTo6QWRkTGluZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQucG9pbnRzWzBdID0gbGlu ZS5lbmQ7CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgQ0dQYXRoQXBwbHkocGxhdGZvcm1QYXRoKCksICh2b2lkKikmZnVuY3Rpb24sIENH UGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKTsKIH0KIAogI2lmIEhBVkUoQ0dQQVRIX0dFVF9OVU1C RVJfT0ZfRUxFTUVOVFMpCiAKIHNpemVfdCBQYXRoOjplbGVtZW50Q291bnQoKSBjb25zdAogewot ICAgIHJldHVybiBDR1BhdGhHZXROdW1iZXJPZkVsZW1lbnRzKG1fcGF0aCk7CisgICAgaWYgKGhh c0lubGluZURhdGFPZlR5cGU8TW92ZURhdGE+KCkpCisgICAgICAgIHJldHVybiAxOworCisgICAg aWYgKGhhc0lubGluZURhdGFPZlR5cGU8TGluZURhdGE+KCkpCisgICAgICAgIHJldHVybiAyOwor CisgICAgcmV0dXJuIENHUGF0aEdldE51bWJlck9mRWxlbWVudHMocGxhdGZvcm1QYXRoKCkpOwog fQogCiAjZW5kaWYgLy8gSEFWRShDR1BBVEhfR0VUX05VTUJFUl9PRl9FTEVNRU5UUykKIAordm9p ZCBQYXRoOjpNb3ZlRGF0YTo6YXBwbHkoY29uc3QgUGF0aCYgcGF0aCkgY29uc3QKK3sKKyAgICBD R1BhdGhNb3ZlVG9Qb2ludChwYXRoLm1fcGF0aC5nZXQoKSwgbnVsbHB0ciwgbG9jYXRpb24ueCgp LCBsb2NhdGlvbi55KCkpOworfQorCit2b2lkIFBhdGg6OkxpbmVEYXRhOjphcHBseShjb25zdCBQ YXRoJiBwYXRoKSBjb25zdAoreworICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgubV9wYXRoLmdl dCgpLCBudWxscHRyLCBzdGFydC54KCksIHN0YXJ0LnkoKSk7CisgICAgQ0dQYXRoQWRkTGluZVRv UG9pbnQocGF0aC5tX3BhdGguZ2V0KCksIG51bGxwdHIsIGVuZC54KCksIGVuZC55KCkpOwogfQog Cit2b2lkIFBhdGg6OkFyY0RhdGE6OmFwcGx5KGNvbnN0IFBhdGgmIHBhdGgpIGNvbnN0Cit7Cisg ICAgaWYgKGhhc09mZnNldCkKKyAgICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQocGF0aC5tX3BhdGgu Z2V0KCksIG51bGxwdHIsIG9mZnNldC54KCksIG9mZnNldC55KCkpOworICAgIENHUGF0aEFkZEFy YyhwYXRoLm1fcGF0aC5nZXQoKSwgbnVsbHB0ciwgY2VudGVyLngoKSwgY2VudGVyLnkoKSwgcmFk aXVzLCBzdGFydCwgZW5kLCBjbG9ja3dpc2UpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CisKICNlbmRpZiAvLyBVU0UoQ0cpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAK aW5kZXggOTFhYjNiZjdkODdiMjQ3YWI2MThkOTgzZGI3NTRiYzJiMjE0MGU2NC4uMzEwYWQxOTY5 MzZmYTAzZGZlOTJmZTBiZTIwYTQzMzkwOTQ4MDgzMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5 TGlzdEl0ZW1zLmNwcApAQCAtMTE5NCw3ICsxMTk0LDcgQEAgT3B0aW9uYWw8RmxvYXRSZWN0PiBT dHJva2VQYXRoOjpsb2NhbEJvdW5kcyhjb25zdCBHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNv bnMKIAogdm9pZCBTdHJva2VQYXRoOjphcHBseShHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNv bnN0CiB7Ci0gICAgY29udGV4dC5zdHJva2VQYXRoKG1fcGF0aCk7CisgICAgY29udGV4dC5zdHJv a2VQYXRoKHN0ZDo6ZXhjaGFuZ2UobV9wYXRoLCB7IH0pKTsKIH0KIAogc3RhdGljIFRleHRTdHJl YW0mIG9wZXJhdG9yPDwoVGV4dFN0cmVhbSYgdHMsIGNvbnN0IFN0cm9rZVBhdGgmIGl0ZW0pCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMv RGlzcGxheUxpc3RJdGVtcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlz cGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaAppbmRleCA5N2ZkMGEwMGE0ZDRiYzZlNzYxMjcy ZDk2ZWI3NDY2NzMwMmY4MGE2Li4xZjQ3YTEwMGI3NzNhZjljNGJlZjM5NGI5OTNlYjE2MGVlOTdi ZTVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5 bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKQEAgLTI1MjUsNyArMjUyNSw3 IEBAIHByaXZhdGU6CiAgICAgdm9pZCBhcHBseShHcmFwaGljc0NvbnRleHQmKSBjb25zdCBvdmVy cmlkZTsKICAgICBPcHRpb25hbDxGbG9hdFJlY3Q+IGxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNz Q29udGV4dCYpIGNvbnN0IG92ZXJyaWRlOwogCi0gICAgY29uc3QgUGF0aCBtX3BhdGg7CisgICAg bXV0YWJsZSBQYXRoIG1fcGF0aDsKIH07CiAKIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0aERpcmVjdDJE LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQu Y3BwCmluZGV4IGZmNjMwMTQzOTQwNGYwN2ZhNzBmOGEzYzY0N2E1OGQxYjRjYmJkNjUuLmY0MTQz YjdhMmRkZWYxMWU5M2I3ODM0NDg2OTQzZjM1OTAyNmJmZWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCkBAIC02NzYs NiArNjc2LDExIEBAIHZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYg ZnVuY3Rpb24pIGNvbnN0CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAorYm9vbCBQYXRoOjpp c051bGwoKSBjb25zdAoreworICAgIHJldHVybiAhbV9wYXRoOworfQorCiB9CiAKICNlbmRpZiAv LyBVU0UoRElSRUNUMkQpCg== 392922 2020-03-07 18:10:26 -0800 2020-03-07 18:14:32 -0800 v3 bug-208464-20200307181026.patch text/plain 38182 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDMwOGFkOGUxZWEyYmRkYjEwMjUyM2M5 NzMyZTYyODg0ZWI3YzBmY2IuLjNkM2NkMGIxNjZlMTQzZjA4YTE3OTIwYTY5NDdkMGM1NjRmNWI3 N2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGZlYXR1cmUgZmxhZyBmb3IgSU5MSU5FX1BBVEhf REFUQS4gVGhpcyBmZWF0dXJlIGZsYWcgZXhpc3RzIHRvIGVuc3VyZSB0aGF0IHdlIGNhbiBhdm9p ZCBoYXZpbmcKKyAgICAgICAgbV9pbmxpbmVEYXRhIG9uIFBhdGggaW4gcG9ydHMgdGhhdCBkb24n dCBpbXBsZW1lbnQgdGhlIG5lY2Vzc2FyeSBmYWNpbGl0aWVzIGZvciBpbmxpbmUgcGF0aCBkYXRh IHlldCwgc2luY2UgaXQKKyAgICAgICAgd291bGQganVzdCBlbmQgdXAgYmVpbmcgd2FzdGVkIG1l bW9yeS4KKworICAgICAgICAqIHd0Zi9QbGF0Zm9ybUVuYWJsZS5oOgorCiAyMDIwLTAzLTA2ICBQ ZW5nIExpdSAgPHBlbmcubGl1NkBhcHBsZS5jb20+CiAKICAgICAgICAgVXNlIHRoZSBmZWF0dXJl IGZsYWdzIG1lY2hhbmlzbSB0byBnaXZlIGRlZmF1bHQgZmVhdHVyZSBwcmVmZXJlbmNlIHZhbHVl cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDA2ZDc1MTI4MTYyNjljMzhiNGZkN2Y2NDAwMTk1ZmEwZWY5ZDIzZDQu LmUzZjllNTQ5Y2JiNGRjYWI1ZDRhYjhhZThlYzQyMmMzZTM3OTI4ZmEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNDQgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBh cHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2lt cGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6 Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFdoZW4gdGhlIEdQVSBwcm9jZXNzIGlzIGVuYWJsZWQgYW5kIHVzZWQgdG8g cmVuZGVyIHRoZSBjYW52YXMgZWxlbWVudCwgc29tZSBjYW52YXMtcmVsYXRlZCBzdWJ0ZXN0cyBp bgorICAgICAgICBNb3Rpb25NYXJrIHNlZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNz aW9ucy4gT25lIG9mIHRoZSByZWFzb25zIGZvciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mg b2YKKyAgICAgICAgZGVjb2RpbmcgZGlzcGxheSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2Vi Q29yZTo6UGF0aGBzIGluIHRoZSBHUFUgcHJvY2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBu ZXcgQ0dQYXRoCisgICAgICAgIGZvciBlYWNoIFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNh bGx5IGluY3JlYXNlcyBwYWdlIGRlbWFuZCBhbmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJv Y2VzcyBpbiBjb250cmFzdAorICAgICAgICB0byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUg ZmFjdCB0aGF0IGFsbCBvZiB0aGVzZSBDR1BhdGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11 c3QgYWxsIGV4aXN0IHNvbWV3aGVyZQorICAgICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5n IHRoZSBkaXNwbGF5IGxpc3QuCisKKyAgICAgICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdl YktpdCwgZWFjaCBjYWxsIHRvIHN0cm9rZSB0aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBp bnZva2luZworICAgICAgICBHcmFwaGljc0NvbnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRl ZCBieSBjbGVhcmluZyB0aGUgcGF0aCwgd2hpY2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNr aW5nIHRoZSBXZWJDb3JlCisgICAgICAgIFBhdGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVl ZHMgdG8gYmUgY3JlYXRlZCwgQ29yZUdyYXBoaWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0 aGUgbmV3IENHUGF0aCBhdCB0aGUKKyAgICAgICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQ YXRoIHdoaWNoIHdhcyBqdXN0IGRlc3Ryb3llZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0 eWluZyBtb3JlIHBhZ2VzIHRoYW4KKyAgICAgICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24g YWZmZWN0cyBtb3N0IG9mIHRoZSBjYW52YXMtcmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRv IHNvbWUgZGVncmVlLCB0aG91Z2ggdGhlCisgICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFi bGUgd2l0aCBDYW52YXMgTGluZXMuCisKKyAgICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNp Z25pZmljYW50IHBvcnRpb24gb2YgdGltZSBpcyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBw bHkgYW5kIGNvbnZlcnRpbmcgdGhlIHJlc3VsdGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBp bnRvIHNlcmlhbGl6YWJsZSBkYXRhIHdoZW4gZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisK KyAgICAgICAgVG8gbWl0aWdhdGUgdGhlc2UgdHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lu cyB3ZSBnZXQgZnJvbSBtZW1vcnkgbG9jYWxpdHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdl CisgICAgICAgIHF1YW50aXRpZXMsIHdlIGNhbjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ug b2Ygc2ltcGxlIHBhdGhzLCBzdHVmZiBzb21lIGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBh dGggd2FzIGNyZWF0ZWQgYXMgaW5saW5lIGRhdGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBh dGggaXRzZWxmLCBhcyBhIG5ldyBkYXRhIG1lbWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29t cGFzc2VzIGxpbmVzLCBhcmNzLCBhbmQgbW92ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBv bmx5IGBQYXRoOjptb3ZlVG9gIHdhcyBpbnZva2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0 aGUgZnV0dXJlIHRvIGluY2x1ZGUgZWxsaXBzZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhp cyBhbGxvd3MgdXMgdG8gYWNoaWV2ZSB0d28gdGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVh cGVyIGJ5IG5vdCByZXF1aXJpbmcgYSB3YWxrIHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBD R1BhdGgncyBlbGVtZW50cywgYW5kIChiKSBtYWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBp bml0aWFsaXppbmcgdGhlIFBhdGggdXNpbmcgaW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAg ICAgdGhhbiBoYXZpbmcgdG8gY3JlYXRlIGEgbmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hl biBwYWludGluZyB0aGUgU3Ryb2tlUGF0aCBkaXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJk IGBtX3BhdGhgIGFmdGVyIHdlJ3JlIGRvbmUgcGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAg IFRoaXMsIGluIGNvbmp1bmN0aW9uIHdpdGggKDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFj a2luZyB0aGUgV2ViQ29yZTo6UGF0aCBpbiB0aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAg ICAgICAgY3JlYXRlZCB3aGVuIHdlJ3JlIGp1c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBj YWxsaW5nIGludG8gc3Ryb2tlUGF0aCgpKSwgYW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAg ICAgICAgICAgd2UncmUgZG9uZSBwYWludGluZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxv dyBmb3IgZGV0YWlscy4gVGhlcmUgc2hvdWxkIGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKwor ICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9JbmxpbmVQYXRoRGF0YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmU6Ok1vdmVEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6TW92ZURhdGE6 OmRlY29kZSk6CisgICAgICAgIChXZWJDb3JlOjpMaW5lRGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAg ICAgICAgKFdlYkNvcmU6OkxpbmVEYXRhOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXJj RGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkFyY0RhdGE6OmRlY29kZSk6 CisKKyAgICAgICAgSW50cm9kdWNlIElubGluZVBhdGhEYXRhLCBhIFZhcmlhbnQgb2Ygc2V2ZXJh bCBkaWZmZXJlbnQgaW5saW5lIGRhdGEgdHlwZXMsIGVhY2ggb2Ygd2hpY2ggcmVwcmVzZW50cyBv bmUgc2ltcGxlCisgICAgICAgIHBhdGggdHlwZSB0aGF0IGlzIHN0b3JlZCB1c2luZyBvbmx5IGlu bGluZSBkYXRhLiBUaGlzIGluY2x1ZGVzIGxpbmUgc2VnbWVudHMgKGEgc3RhcnQgcG9pbnQgYW5k IGFuIGVuZCBwb2ludCksCisgICAgICAgIGFzIHdlbGwgYXMgYXJjcyAod2hpY2gsIGluIGFkZGl0 aW9uIHRvIGEgY2VudGVyIGFuZCBzdGFydCBhbmQgZW5kIGFuZ2xlcykgYWxzbyBpbmNsdWRlcyBh biBvcHRpb25hbCBvZmZzZXQsCisgICAgICAgIHdoaWNoIHJlcHJlc2VudHMgdGhlIGN1cnJlbnQg cG9zaXRpb24gb2YgdGhlIHBhdGggYXQgdGhlIHRpbWUgImFkZEFyYyIgd2FzIGNhbGxlZC4KKwor ICAgICAgICBGb3IgaW5zdGFuY2UsIGluIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW8sIHRoZSBwYXRo IHdvdWxkIGhhdmUgYW4gYXJjIHRoYXQgaXMgb2Zmc2V0IGJ5ICgxMDAsIDApOyBpZiBmaWxsZWQs IGl0CisgICAgICAgIHdvdWxkIHJlc3VsdCBpbiBhIGNvbXBvc2l0ZSBzaGFwZSByZXNlbWJsaW5n IGEgc2VtaWNpcmNsZSBvbiB0b3Agb2YgYSB0cmlhbmdsZToKKworICAgICAgICBwYXRoLm1vdmVU bygxMDAsIDApOworICAgICAgICBwYXRoLmFkZEFyYygxMDAsIDEwMCwgNTAsIDAsIFBJLCBmYWxz ZSk7CisgICAgICAgIGNvbnRleHQuZmlsbChwYXRoKTsKKworICAgICAgICBXaGVuIGEgUGF0aCBp cyBpbml0aWFsaXplZCAob3IgYWZ0ZXIgaXQgaXMgY2xlYXJlZCksIGl0IHN0YXJ0cyBvZmYgd2l0 aCBuZWl0aGVyIGEgQ0dQYXRoIG5vciBpbmxpbmUgZGF0YS4gTW92aW5nCisgICAgICAgIHRoZSBw YXRoIGNhdXNlcyBpdCB0byBzdG9yZSBpbmxpbmUgTW92ZURhdGE7IGNhbGxpbmcgY2FsbGluZyBg YWRkTGluZVRvYCBvciBgYWRkQXJjYCB0aGVuIHJlcGxhY2VzIHRoZSBpbmxpbmUKKyAgICAgICAg ZGF0YSB3aXRoIGVpdGhlciBMaW5lRGF0YSBvciBBcmNEYXRhLgorCisgICAgICAgIElmLCBhdCBh bnkgcG9pbnQsIHRoZSBwYXRoIGNoYW5nZXMgaW4gYSBkaWZmZXJlbnQgd2F5IChpLmUuIG5laXRo ZXIgbGluZSwgYXJjLCBub3IgbW92ZSksIHdlIGNsZWFyIG91dCB0aGUKKyAgICAgICAgaW5saW5l IGRhdGEgYW5kIGZhbGwgYmFjayB0byBqdXN0IHJlcHJlc2VudGluZyB0aGUgcGF0aCBkYXRhIHVz aW5nIHRoZSBDR1BhdGggKG1fcGF0aCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9Q YXRoLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5l ZWRlZCBjb25zdCk6CisKKyAgICAgICAgQWRkIGEgaGVscGVyIG1ldGhvZCB0aGF0IGlzIGludm9r ZWQgd2hlbiB0aGUgUGF0aCBpcyBhc2tlZCBmb3IgYSBDR1BhdGguIEluIHRoaXMgY2FzZSwgZXZl biBpZiBtX3BhdGggaXMgbnVsbCwKKyAgICAgICAgd2UgbmVlZCB0byBsYXppbHkgY3JlYXRlIGl0 IGFuZCBhcHBseSBhbnkgaW5saW5lIHBhdGggZGF0YSB3ZSd2ZSBhY2N1bXVsYXRlZC4gT25jZSB3 ZSdyZSBkb25lIGFwcGx5aW5nIHRoZQorICAgICAgICBpbmxpbmUgZGF0YSwgc2V0IGEgZmxhZyAo bV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKSB0byBmYWxzZSB0byBhdm9pZCByZS1hcHBseWluZyBp bmxpbmUgZGF0YSB0byB0aGUgcGF0aC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1Bh dGguaDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjpkZWNvZGUpOgorCisgICAgICAgIFRlYWNoIFBhdGg6OmVuY29kZSBhbmQg UGF0aDo6ZGVjb2RlIHRvIHJlc3BlY3RpdmVseSBzZXJpYWxpemUgYW5kIGRlc2VyaWFsaXplIFdl YkNvcmU6OlBhdGggYnkgY29uc3VsdGluZyBvbmx5CisgICAgICAgIHRoZSBpbmxpbmUgZGF0YSwg aWYgaXQgaXMgcHJlc2VudC4gRm9yIHNpbXBsZSB0eXBlcyBvZiBwYXRocywgdGhpcyBkZWNyZWFz ZXMgdGhlIGNvc3Qgb2YgYm90aCBJUEMgZW5jb2RpbmcgYW5kCisgICAgICAgIGRlY29kaW5nLCBi dXQgYWRkcyBhIG5lZ2xpZ2libGUgYW1vdW50IG9mIG92ZXJoZWFkIGluIHRoZSBjYXNlIHdoZXJl IHRoZSBwYXRoIGlzIG5vbi1pbmxpbmUuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0lu bGluZURhdGEgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aGFzQW55SW5saW5lRGF0 YSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOiBEZWxldGVk LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0 aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9Q YXRoQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGEpOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6cGxhdGZvcm1QYXRoIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisKKyAgICAgICAgV2hlbiBlbnN1cmVQbGF0Zm9ybVBh dGggaXMgaW52b2tlZCwgd2UgYXJlIGFib3V0IHRvIG11dGF0ZSBvdXIgQ0dQYXRoIGluIHN1Y2gg YSB3YXkgdGhhdCBpdCBjYW4ndCBiZSBleHByZXNzZWQKKyAgICAgICAgaW4gdGVybXMgb2YgaW5s aW5lIGRhdGEgKGF0IGxlYXN0LCBub3Qgd2l0aCB0aGUgY2hhbmdlcyBpbiB0aGlzIHBhdGNoKS4g Q2xlYXIgb3V0IHRoZSBpbmxpbmUgcGF0aCBkYXRhIGluIHRoaXMKKyAgICAgICAgY2FzZSwgYW5k IGFwcGx5IHRoZSBDR1BhdGggbXV0YXRpb25zIHRoYXQgd2VyZSBwcmV2aW91c2x5IHN0YXNoZWQg YXdheSBpbiBpbmxpbmUgcGF0aCBkYXRhLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051 bGwgY29uc3QpOgorCisgICAgICAgIEEgcGF0aCBpcyBub3cgY29uc2lkZXJlZCBudWxsIGlmIGl0 IGlzIG5vdCBvbmx5IG1pc3NpbmcgYSBDR1BhdGgsIGJ1dCBhbHNvIGRvZXMgbm90IGhhdmUgYW55 IGlubGluZSBwYXRoIGRhdGEuCisgICAgICAgIFRoaXMgbWFpbnRhaW5zIHRoZSBpbnZhcmlhbnQg dGhhdCBgaXNOdWxsKClgIGlzIHRydWUgaWZmIHRoZSBgcGxhdGZvcm1QYXRoKClgIHJldHVybnMg MHgwLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OnN3YXApOgorCisgICAgICAgIFVwZGF0ZSB0aGUgY29uc3RydWN0b3JzIGFuZCBgc3dh cGAgaGVscGVyIG1ldGhvZCAodXNlZCBieSBhc3NpZ25tZW50IG9wZXJhdG9ycykgdG8gYWNjb3Vu dCBmb3IgdGhlIG5ldyBtZW1iZXJzLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjb250YWlu cyBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjp0cmFuc2Zvcm0pOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmZhc3RCb3VuZGluZ1JlY3QgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6bW92 ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZExpbmVUbyk6CisgICAgICAgIChXZWJD b3JlOjpQYXRoOjphZGRBcmMpOgorCisgICAgICAgIEluIHRoZSBjYXNlIG9mIHRoZXNlIHRocmVl IG1ldGhvZHMgZm9yIG11dGF0aW5nIGEgcGF0aCwgaWYgd2UndmUgZWl0aGVyIG9ubHkgbW92ZWQg dGhlIHBhdGggb3IgaGF2ZW4ndCB0b3VjaGVkCisgICAgICAgIGl0IGF0IGFsbCwgd2UgY2FuIGdl dCBhd2F5IHdpdGggb25seSB1cGRhdGluZyBvdXIgaW5saW5lIHBhdGggZGF0YSwgYW5kIGF2b2lk IGNyZWF0aW5nIGEgQ0dQYXRoLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisK KyAgICAgICAgV2hlbiBjbGVhcmluZyBQYXRoLCBpbnN0ZWFkIG9mIHNldHRpbmcgYG1fcGF0aGAg dG8gYSBuZXdseSBhbGxvY2F0ZWQgQ0dQYXRoLCBzaW1wbHkgcmVzZXQgaXQgdG8gbnVsbC4gVGhp cworICAgICAgICBlbnN1cmVzIHRoYXQgaWYgd2UgdGhlbiBhcHBseSBzb21lIGNoYW5nZXMgdGhh dCBjYW4gYmUgZXhwcmVzc2VkIHVzaW5nIG9ubHkgaW5saW5lIHBhdGggZGF0YSwgd2UgYXZvaWQg aGF2aW5nIHRvCisgICAgICAgIHVwZGF0ZSB0aGUgQ0dQYXRoLCBhbmQgaW5zdGVhZCBqdXN0IHVw ZGF0ZSB0aGUgaW5saW5lIHBhdGggZGF0YS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNF bXB0eSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnQgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHkgY29uc3QpOgorCisgICAgICAgIFRocm93 IG91dCB0aGUgY3VycmVudCBXZWJDb3JlOjpQYXRoIGFmdGVyIHdlJ3JlIGRvbmUgcGFpbnRpbmcg d2l0aCBpdCAoc2VlICgyKSBpbiB0aGUgYWJvdmUgQ2hhbmdlTG9nIGVudHJ5KS4KKworICAgICAg ICAoV2ViQ29yZTo6UGF0aDo6ZWxlbWVudENvdW50IGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpEaXNwbGF5TGlzdDo6U3Ryb2tlUGF0aDo6YXBwbHkgY29uc3QpOgorICAgICAgICAq IHBsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6aXNOdWxsIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNyZWF0ZVBs YXRmb3JtUGF0aCk6CisKIDIwMjAtMDMtMDQgIFNhaWQgQWJvdS1IYWxsYXdhICA8c2Fib3VoYWxs YXdhQGFwcGxlLmNvbT4KIAogICAgICAgICBDYW52YXMgZHJhd2luZyBjb21tYW5kcyBoYXZlIHRv IGJlIGZsdXNoZWQgdG8gdGhlIEdQVVByb2Nlc3MgaW4gYmF0Y2hlcwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCAyOGU0 NGE5MzczOWIzMjU5OTQyYjkyNTYyZWMxMTU2MzYwYjUxNTNmLi4xZThkYTViMmZlZTBmZTEwZWZi OGRiOWE3MGQ0NzJiNzE0MGQ1ZWNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIwLTAz LTA3ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIExh emlseSBnZW5lcmF0ZSBDR1BhdGhzIGZvciBzb21lIHNpbXBsZSB0eXBlcyBvZiBwYXRocywgc3Vj aCBhcyBhcmNzIGFuZCBsaW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjA4NDY0CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTk2MzIyNj4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYXJndW1l bnQgY29kZXJzIGZvciBgV1RGOjpNb25vc3RhdGVgLCBzbyB0aGF0IFZhcmlhbnRzIG9mIHRoZSBm b3JtOiBgVmFyaWFudDxNb25vc3RhdGUsIEZvbywgQmFyPmAgY2FuIGJlCisgICAgICAgIGVuY29k ZWQgYW5kIGRlY29kZWQgb3ZlciBJUEMuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9JUEMvQXJndW1l bnRDb2RlcnMuY3BwOgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVyPE1vbm9zdGF0ZT46OmVu Y29kZSk6CisgICAgICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZGVjb2RlKToK KyAgICAgICAgKiBQbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuaDoKKwogMjAyMC0wMy0wNCAg U2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgogCiAgICAgICAgIENh bnZhcyBkcmF3aW5nIGNvbW1hbmRzIGhhdmUgdG8gYmUgZmx1c2hlZCB0byB0aGUgR1BVUHJvY2Vz cyBpbiBiYXRjaGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5o IGIvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaAppbmRleCBmMGMxNTE1M2ZkNDk1MjNm NzIzYTBmNDg0ZjliNDAzZjlmMjc0ODkzLi4yZGM5YWY1M2UwMzQ1NTNjNGRiNmJkNjZkOTk0MTRm ZWFjZTI2NzJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5oCisr KyBiL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgKQEAgLTgxMyw2ICs4MTMsOSBAQAog I2RlZmluZSBFTkFCTEVfT1BFTlRZUEVfTUFUSCAxCiAjZW5kaWYKIAorI2lmICFkZWZpbmVkKEVO QUJMRV9JTkxJTkVfUEFUSF9EQVRBKSAmJiBVU0UoQ0cpCisjZGVmaW5lIEVOQUJMRV9JTkxJTkVf UEFUSF9EQVRBIDEKKyNlbmRpZgogCiAvKiBEaXNhYmxlIFNoYXJlZEFycmF5QnVmZmVycyB1bnRp bCBTcGVjdHJlIHNlY3VyaXR5IGNvbmNlcm5zIGFyZSBtaXRpZ2F0ZWQuICovCiAjZGVmaW5lIEVO QUJMRV9TSEFSRURfQVJSQVlfQlVGRkVSIDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA1YTZlOGE1YWYyZTczOTliZmZkZmE0NmZi N2EyNjZhZWY0MDI5ZDQxLi45ZDAzZTY4OWQyZjFhMGU1MTY4NTIwYzQ5OTMwMTkyZDNhNjJmMjdl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCkBAIC00OTc1LDYgKzQ5NzUsNyBAQAogCQlGNDQyQzM1OTIzRTNBREQyMDA0OTk1ODIgLyog Q29tcG9zaXRpb25IaWdobGlnaHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEY0NDJDMzU3MjNFM0FDNTEwMDQ5OTU4MiAvKiBDb21wb3NpdGlvbkhpZ2hs aWdodC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJ CUY0NEE1RjU5MUZFRDM4RjIwMDdGNTk0NCAvKiBMZWdhY3lOU1Bhc3RlYm9hcmRUeXBlcy5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ0QTVGNTcxRkVE MzgzMDAwN0Y1OTQ0IC8qIExlZ2FjeU5TUGFzdGVib2FyZFR5cGVzLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ0RUJCRDkxREI1RDIxNDAwMjc3 MzM0IC8qIFN0YXRpY1JhbmdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGNDRFQkJEODFEQjVEMjE0MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlGNDU3NzVDRTI0 MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxp bmVQYXRoRGF0YS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFD MTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDY3MjkyODFFMERFNjg1MDBB Q0MzRDggLyogU2Nyb2xsU25hcE9mZnNldHNJbmZvLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDY3MjkyNTFFMERFNUFCMDBBQ0MzRDggLyogU2Nyb2xs U25hcE9mZnNldHNJbmZvLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwg KTsgfTsgfTsKIAkJRjQ2QzQ0N0UyMzQ2NTQ1NDAwMzlBNzlEIC8qIENsaXBib2FyZEl0ZW1CaW5k aW5nc0RhdGFTb3VyY2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEY0NkM0NDdDMjM0NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVtQmluZGluZ3NE YXRhU291cmNlLmggKi87IH07CkBAIC0xNTQ2MCw2ICsxNTQ2MSw3IEBACiAJCUY0NEVCQkQ2MURC NUQxQjYwMDI3NzMzNCAvKiBTdGF0aWNSYW5nZS5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0g U3RhdGljUmFuZ2UuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDRFQkJEODFE QjVEMjE0MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gU3RhdGljUmFuZ2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ0 RUJCREExREI1REQ5RDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFN0YXRpY1JhbmdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJRjQ1Nzc1Q0QyNDE0MzdENTAwMkRGMUEwIC8qIElubGluZVBhdGhEYXRhLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IElubGluZVBhdGhEYXRhLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBP ZmZzZXRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ1QzIzMUMxOTk1Qjcz QjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJRjQ2MjhBOUUyMzREM0JCRjAwQkM4ODRDIC8qIFBsYXRmb3JtUGFzdGVib2Fy ZENvY29hLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUGxhdGZv cm1QYXN0ZWJvYXJkQ29jb2EubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yNTEx Nyw2ICsyNTExOSw3IEBACiAJCQkJMDcwNkEwRDcyNDA4MzBBNjAwRTkzODE4IC8qIEluYmFuZEdl bmVyaWNDdWVJZGVudGlmaWVyLmggKi8sCiAJCQkJMDc5NDE3OTMxNjZFQTA0RTAwOTQxNkMyIC8q IEluYmFuZFRleHRUcmFja1ByaXZhdGUuaCAqLywKIAkJCQkwN0NFNzdENDE2NzEyQTZBMDBDNTVB NDcgLyogSW5iYW5kVGV4dFRyYWNrUHJpdmF0ZUNsaWVudC5oICovLAorCQkJCUY0NTc3NUNEMjQx NDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovLAogCQkJCTJENDZGMDREMTdCOTZG QkQwMDU2NDdGMCAvKiBJbnRQb2ludC5jcHAgKi8sCiAJCQkJQjI3NTM1NDQwQjA1MzgxNDAwMkNF NjRGIC8qIEludFBvaW50LmggKi8sCiAJCQkJRTQ2MkE0QTAxMTNFNzFCRTAwNEE0MjIwIC8qIElu dFBvaW50SGFzaC5oICovLApAQCAtMzA0MDgsNiArMzA0MTEsNyBAQAogCQkJCTZGQjI0MDA1MjNE RkYxMjgwMDc5NjQ1OCAvKiBJbmxpbmVMaW5lQm94QnVpbGRlci5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJNkZFMTk4MTcyMTc4Mzk3QzAwNDQ2RjA4IC8qIElubGluZUxpbmVCcmVha2VyLmggaW4gSGVh ZGVycyAqLywKIAkJCQk2RjBDRDY5NTIyOUVEMzI3MDBDNTk5NEUgLyogSW5saW5lTGluZUJ1aWxk ZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCUY0NTc3NUNFMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxp bmVQYXRoRGF0YS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNkYzNjBFNTAyMzk5OTQyMTAwMTUxMkE3 IC8qIElubGluZVNvZnRMaW5lQnJlYWtJdGVtLmggaW4gSGVhZGVycyAqLywKIAkJCQlBQTRDM0E3 NzBCMkIxNjc5MDAyMzM0QTIgLyogSW5saW5lU3R5bGVTaGVldE93bmVyLmggaW4gSGVhZGVycyAq LywKIAkJCQlCQ0VBNDg1QTA5N0Q5MzAyMDA5NEM5RTQgLyogSW5saW5lVGV4dEJveC5oIGluIEhl YWRlcnMgKi8sCkBAIC0zMTU0OCw2ICszMTU1Miw3IEBACiAJCQkJQTE3RDI3NUUxRUFDNTc5ODAw QkYwMUU3IC8qIE1lZGlhU2VsZWN0aW9uT3B0aW9uLmggaW4gSGVhZGVycyAqLywKIAkJCQlDOTAy N0Y0MjFCMUQwQUQyMDBCRkJGRUYgLyogTWVkaWFTZXNzaW9uLmggaW4gSGVhZGVycyAqLywKIAkJ CQlDOUY4N0NGRTFCMjhGNDBFMDA5NzlCODMgLyogTWVkaWFTZXNzaW9uRXZlbnRzLmggaW4gSGVh ZGVycyAqLywKKwkJCQk0MTQ0NjBBMjI0MTI5OTQ1MDA4MTRCRTcgLyogTWVkaWFTZXNzaW9uSWRl bnRpZmllci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzk2RjVFQzgxQjU4NzIyNjAwOTFFQTlEIC8q IE1lZGlhU2Vzc2lvbkludGVycnVwdGlvblByb3ZpZGVyLmggaW4gSGVhZGVycyAqLywKIAkJCQlD OTZGNUVDNTFCNTg3MjI2MDA5MUVBOUQgLyogTWVkaWFTZXNzaW9uSW50ZXJydXB0aW9uUHJvdmlk ZXJNYWMuaCBpbiBIZWFkZXJzICovLAogCQkJCUM5MEY2NTU2MUIyMjUzQkUwMDIxNjNBMSAvKiBN ZWRpYVNlc3Npb25NYW5hZ2VyLmggaW4gSGVhZGVycyAqLywKQEAgLTMyODAxLDcgKzMyODA2LDYg QEAKIAkJCQlFNEM5MUEwRTE4MDIzNDMxMDBBMTdGNkQgLyogVGV4dFBhaW50U3R5bGUuaCBpbiBI ZWFkZXJzICovLAogCQkJCTkzRjE5OEY2MDgyNDVFNTkwMDFFOUFCQyAvKiBUZXh0UmVzb3VyY2VE ZWNvZGVyLmggaW4gSGVhZGVycyAqLywKIAkJCQlBODI0QjQ2NTBFMkVGMkVBMDA4MUE3QjcgLyog VGV4dFJ1bi5oIGluIEhlYWRlcnMgKi8sCi0JCQkJNDE0NDYwQTIyNDEyOTk0NTAwODE0QkU3IC8q IE1lZGlhU2Vzc2lvbklkZW50aWZpZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTQ0OEIxQjdBMEYz QTJGOUIwMDQ3QTlFMiAvKiBUZXh0U2l6ZUFkanVzdG1lbnQuaCBpbiBIZWFkZXJzICovLAogCQkJ CTk3NTlFOTQwMTRFRjFDRjgwMDI2QTJERCAvKiBUZXh0VHJhY2suaCBpbiBIZWFkZXJzICovLAog CQkJCTk3NTlFOTQzMTRFRjFDRjgwMDI2QTJERCAvKiBUZXh0VHJhY2tDdWUuaCBpbiBIZWFkZXJz ICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5l UGF0aERhdGEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhE YXRhLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjUzNTlhYmFlYzA2MjEwZTE4OTQ4ZTUwZTYwOGQ5YTVmZWM5MWE0 NgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lu bGluZVBhdGhEYXRhLmgKQEAgLTAsMCArMSwxMzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9u Y2UKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCisjaW5jbHVkZSAiRmxvYXRQb2lu dC5oIgorI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJpYW50Lmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RydWN0IExpbmVEYXRhIHsKKyAgICBGbG9hdFBv aW50IHN0YXJ0OworICAgIEZsb2F0UG9pbnQgZW5kOworCisgICAgdGVtcGxhdGU8Y2xhc3MgRW5j b2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNsYXNzIERl Y29kZXI+IHN0YXRpYyBPcHRpb25hbDxMaW5lRGF0YT4gZGVjb2RlKERlY29kZXImKTsKK307CisK K3N0cnVjdCBBcmNEYXRhIHsKKyAgICBGbG9hdFBvaW50IG9mZnNldDsKKyAgICBGbG9hdFBvaW50 IGNlbnRlcjsKKyAgICBmbG9hdCByYWRpdXMgeyAwIH07CisgICAgZmxvYXQgc3RhcnQgeyAwIH07 CisgICAgZmxvYXQgZW5kIHsgMCB9OworICAgIGJvb2wgY2xvY2t3aXNlIHsgZmFsc2UgfTsKKyAg ICBib29sIGhhc09mZnNldCB7IGZhbHNlIH07CisKKyAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVy PiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rl cj4gc3RhdGljIE9wdGlvbmFsPEFyY0RhdGE+IGRlY29kZShEZWNvZGVyJik7Cit9OworCitzdHJ1 Y3QgTW92ZURhdGEgeworICAgIEZsb2F0UG9pbnQgbG9jYXRpb247CisKKyAgICB0ZW1wbGF0ZTxj bGFzcyBFbmNvZGVyPiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8 Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPE1vdmVEYXRhPiBkZWNvZGUoRGVjb2RlciYp OworfTsKKwordGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBNb3ZlRGF0YTo6ZW5jb2RlKEVu Y29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCBsb2NhdGlvbjsKK30KKwor dGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8TW92ZURhdGE+IE1vdmVEYXRhOjpkZWNv ZGUoRGVjb2RlciYgZGVjb2RlcikKK3sKKyAgICBNb3ZlRGF0YSBkYXRhOworICAgIGlmICghZGVj b2Rlci5kZWNvZGUoZGF0YS5sb2NhdGlvbikpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7 CisgICAgcmV0dXJuIHsgZGF0YSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IExpbmVEYXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVy IDw8IHN0YXJ0OworICAgIGVuY29kZXIgPDwgZW5kOworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNv ZGVyPiBPcHRpb25hbDxMaW5lRGF0YT4gTGluZURhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVy KQoreworICAgIExpbmVEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnN0 YXJ0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5k ZWNvZGUoZGF0YS5lbmQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0 dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IEFyY0RhdGE6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIg PDwgb2Zmc2V0OworICAgIGVuY29kZXIgPDwgY2VudGVyOworICAgIGVuY29kZXIgPDwgcmFkaXVz OworICAgIGVuY29kZXIgPDwgc3RhcnQ7CisgICAgZW5jb2RlciA8PCBlbmQ7CisgICAgZW5jb2Rl ciA8PCBjbG9ja3dpc2U7CisgICAgZW5jb2RlciA8PCBoYXNPZmZzZXQ7Cit9CisKK3RlbXBsYXRl PGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPEFyY0RhdGE+IEFyY0RhdGE6OmRlY29kZShEZWNvZGVy JiBkZWNvZGVyKQoreworICAgIEFyY0RhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KGRhdGEub2Zmc2V0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICgh ZGVjb2Rlci5kZWNvZGUoZGF0YS5jZW50ZXIpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnJhZGl1cykpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuc3RhcnQpKQor ICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShk YXRhLmVuZCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29k ZXIuZGVjb2RlKGRhdGEuY2xvY2t3aXNlKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsK KworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5oYXNPZmZzZXQpKQorICAgICAgICByZXR1 cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit1 c2luZyBJbmxpbmVQYXRoRGF0YSA9IFZhcmlhbnQ8TW9ub3N0YXRlLCBNb3ZlRGF0YSwgTGluZURh dGEsIEFyY0RhdGE+OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFC TEUoSU5MSU5FX1BBVEhfREFUQSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1BhdGguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0 aC5jcHAKaW5kZXggYTYyOGQzNzQyMjQyM2MxMjAzNTRmZmZmMjE5MDYxN2Y3MmI0Mzg1Mi4uMzU1 MTU3ZmQwMTRiNDcwZmY2ZTQ0YjRlZWJhYWQzMWI0MDYxYjMwNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKQEAgLTE4OCw2ICsxODgsMjYgQEAgRmxvYXRSZWN0 IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUo SU5MSU5FX1BBVEhfREFUQSkKKwordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhEYXRhSWZOZWVk ZWQoKSBjb25zdAoreworICAgIGlmICghbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKQorICAgICAg ICByZXR1cm47CisKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBmYWxzZTsKKworICAg IGlmICghaGFzQW55SW5saW5lRGF0YSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1f cGF0aCkKKyAgICAgICAgbV9wYXRoID0gY3JlYXRlUGxhdGZvcm1QYXRoKCk7CisKKyAgICBhcHBs eUlubGluZVBhdGhEYXRhKG1faW5saW5lRGF0YSwgbV9wYXRoLmdldCgpKTsKK30KKworI2VuZGlm IC8vIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCiAjaWZuZGVmIE5ERUJVRwogdm9pZCBQYXRo OjpkdW1wKCkgY29uc3QKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaApp bmRleCA3ZmFkYTYwZDgzYzI5MjUwYWM0YTE3NDhhODkyNDA3MDI5MTk5ZTFiLi42MTYyZjdkMGI1 ZGU2Mjc3Mjk3NjNhOGQ0NjU0MDVmY2JkMGI2OWY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oCkBAIC0yNSwxNCArMjUsMTUgQEAKICAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAogICov CiAKLSNpZm5kZWYgUGF0aF9oCi0jZGVmaW5lIFBhdGhfaAorI3ByYWdtYSBvbmNlCiAKICNpbmNs dWRlICJGbG9hdFJlY3QuaCIKKyNpbmNsdWRlICJJbmxpbmVQYXRoRGF0YS5oIgogI2luY2x1ZGUg IldpbmRSdWxlLmgiCiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KICNpbmNsdWRlIDx3dGYv RnVuY3Rpb24uaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJp YW50Lmg+CiAKICNpZiBVU0UoQ0cpCiAKQEAgLTE0Nyw3ICsxNDgsNyBAQCBwdWJsaWM6CiAgICAg RmxvYXRQb2ludCBwb2ludEF0TGVuZ3RoKGZsb2F0IGxlbmd0aCkgY29uc3Q7CiAKICAgICBXRUJD T1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7Ci0gICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVy biAhbV9wYXRoOyB9CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBpc051bGwoKSBjb25zdDsKICAg ICBib29sIGlzRW1wdHkoKSBjb25zdDsKICAgICAvLyBHZXRzIHRoZSBjdXJyZW50IHBvaW50IG9m IHRoZSBjdXJyZW50IHBhdGgsIHdoaWNoIGlzIGNvbmNlcHR1YWxseSB0aGUgZmluYWwgcG9pbnQg cmVhY2hlZCBieSB0aGUgcGF0aCBzbyBmYXIuCiAgICAgLy8gTm90ZSB0aGUgUGF0aCBjYW4gYmUg ZW1wdHkgKGlzRW1wdHkoKSA9PSB0cnVlKSBhbmQgc3RpbGwgaGF2ZSBhIGN1cnJlbnQgcG9pbnQu CkBAIC0xODUsNyArMTg2LDcgQEAgcHVibGljOgogICAgIEZsb2F0UmVjdCBmYXN0Qm91bmRpbmdS ZWN0Rm9yU3Ryb2tlKGNvbnN0IFBsYXRmb3JtQ29udGV4dERpcmVjdDJEJikgY29uc3Q7CiAgICAg UGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0aC5nZXQo KTsgfQogI2VsaWYgVVNFKENHKQotICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBj b25zdCB7IHJldHVybiBtX3BhdGguZ2V0KCk7IH0KKyAgICBXRUJDT1JFX0VYUE9SVCBQbGF0Zm9y bVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3Q7CiAjZWxzZQogICAgIFBsYXRmb3JtUGF0aFB0 ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGg7IH0KICNlbmRpZgpAQCAtMjI1 LDYgKzIyNiwxNSBAQCBwdWJsaWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGlj IE9wdGlvbmFsPFBhdGg+IGRlY29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6CisgICAgc3RhdGlj IFBsYXRmb3JtUGF0aFN0b3JhZ2VUeXBlIGNyZWF0ZVBsYXRmb3JtUGF0aCgpOworCisjaWYgRU5B QkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgc3RhdGljIHZvaWQgYXBwbHlJbmxpbmVQYXRoRGF0 YShjb25zdCBJbmxpbmVQYXRoRGF0YSYsIFBsYXRmb3JtUGF0aFB0cik7CisgICAgdGVtcGxhdGUg PHR5cGVuYW1lIERhdGFUeXBlPiBib29sIGhhc0lubGluZURhdGEoKSBjb25zdDsKKyAgICBib29s IGhhc0FueUlubGluZURhdGEoKSBjb25zdDsKKyAgICB2b2lkIGFwcGx5SW5saW5lUGF0aERhdGFJ Zk5lZWRlZCgpIGNvbnN0OworI2VuZGlmCisKICNpZiBVU0UoQ0cpCiAgICAgdm9pZCBzd2FwKFBh dGgmKTsKICNlbmRpZgpAQCAtMjM3LDYgKzI0NywxMCBAQCBwcml2YXRlOgogICAgIG11dGFibGUg Ym9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNlbmRpZgogCisjaWYgRU5BQkxFKElO TElORV9QQVRIX0RBVEEpCisgICAgSW5saW5lUGF0aERhdGEgbV9pbmxpbmVEYXRhOworICAgIG11 dGFibGUgYm9vbCBtX25lZWRzVG9BcHBseUlubGluZURhdGEgeyBmYWxzZSB9OworI2VuZGlmCiAj aWYgVVNFKENHKQogICAgIG11dGFibGUgYm9vbCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24geyBm YWxzZSB9OwogI2VuZGlmCkBAIC0yNDYsNiArMjYwLDE1IEBAIFdURjo6VGV4dFN0cmVhbSYgb3Bl cmF0b3I8PChXVEY6OlRleHRTdHJlYW0mLCBjb25zdCBQYXRoJik7CiAKIHRlbXBsYXRlPGNsYXNz IEVuY29kZXI+IHZvaWQgUGF0aDo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiB7Cisj aWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgYm9vbCBoYXNJbmxpbmVEYXRhID0gaGFz QW55SW5saW5lRGF0YSgpOworICAgIGVuY29kZXIgPDwgaGFzSW5saW5lRGF0YTsKKyAgICBpZiAo aGFzSW5saW5lRGF0YSkgeworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgorCiAgICAgZW5jb2RlciA8PCBzdGF0aWNfY2FzdDx1 aW50NjRfdD4oZWxlbWVudENvdW50KCkpOwogCiAgICAgYXBwbHkoWyZdKGF1dG8mIGVsZW1lbnQp IHsKQEAgLTI3Niw2ICsyOTksMjEgQEAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRo OjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+ IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQogewogICAgIFBh dGggcGF0aDsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGJvb2wgaGFzSW5s aW5lRGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc0lubGluZURhdGEpKQorICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKGhhc0lubGluZURhdGEpIHsKKyAgICAg ICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YSkpCisgICAgICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHsgV1RGTW92ZShwYXRoKSB9OworICAgIH0KKyNl bmRpZgorCiAgICAgdWludDY0X3QgbnVtUG9pbnRzOwogICAgIGlmICghZGVjb2Rlci5kZWNvZGUo bnVtUG9pbnRzKSkKICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKQEAgLTMzNiw5ICszNzQs MTcgQEAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aD4gUGF0aDo6ZGVjb2Rl KERlY29kZXImIGRlY29kZXIpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gcGF0aDsK KyAgICByZXR1cm4geyBXVEZNb3ZlKHBhdGgpIH07CiB9CiAKK3RlbXBsYXRlIDx0eXBlbmFtZSBE YXRhVHlwZT4gYm9vbCBQYXRoOjpoYXNJbmxpbmVEYXRhKCkgY29uc3QKK3sKKyAgICByZXR1cm4g V1RGOjpob2xkc19hbHRlcm5hdGl2ZTxEYXRhVHlwZT4obV9pbmxpbmVEYXRhKTsKIH0KIAotI2Vu ZGlmCitib29sIFBhdGg6Omhhc0FueUlubGluZURhdGEoKSBjb25zdAoreworICAgIHJldHVybiAh aGFzSW5saW5lRGF0YTxNb25vc3RhdGU+KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhD YWlyby5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fp cm8uY3BwCmluZGV4IGUxYjU1NGM4ODRjMTUyZDVhOThiMDRhOTdjYTQ3NzNmNTQ3Mzg2M2IuLjM2 ZjMxNzRlZmZjZGZjOTQ5NzFiOGM0NzQ3MDA5NGMwMjJiODRkZjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcApAQCAtNDU1 LDYgKzQ1NSwxNiBAQCB2b2lkIFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0m IHRyYW5zZm9ybSkKICAgICBjYWlyb190cmFuc2Zvcm0oY3IsICZtYXRyaXgpOwogfQogCitib29s IFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGg7Cit9CisKK0NhaXJv UGF0aCogUGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKCkKK3sKKyAgICByZXR1cm4gbmV3IENhaXJv UGF0aDsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJP KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENH LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKaW5k ZXggNTIxYzE1NTNhOWE2YTM0YTM4MWMzNGY5Nzg2MjU0ZGQ1ZjBjNzI2ZS4uOTQ1ODcyYTM0MjFj NzA1YjgzYzRjNWQzOGFiMWEyNDNhNTg1ZDQyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCkBAIC04MSw2ICs4MSwzMCBAQCBQYXRoIFBhdGg6 OnBvbHlnb25QYXRoRnJvbVBvaW50cyhjb25zdCBWZWN0b3I8RmxvYXRQb2ludD4mIHBvaW50cykK ICAgICByZXR1cm4gcGF0aDsKIH0KIAorUmV0YWluUHRyPENHTXV0YWJsZVBhdGhSZWY+IFBhdGg6 OmNyZWF0ZVBsYXRmb3JtUGF0aCgpCit7CisgICAgcmV0dXJuIGFkb3B0Q0YoQ0dQYXRoQ3JlYXRl TXV0YWJsZSgpKTsKK30KKwordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhEYXRhKGNvbnN0IElu bGluZVBhdGhEYXRhJiBkYXRhLCBDR011dGFibGVQYXRoUmVmIHBhdGgpCit7CisgICAgV1RGOjpz d2l0Y2hPbihkYXRhLAorICAgICAgICBbJl0oYXV0bykgeyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsg fSwKKyAgICAgICAgWyZdKGNvbnN0IE1vdmVEYXRhJiBtb3ZlKSB7CisgICAgICAgICAgICBDR1Bh dGhNb3ZlVG9Qb2ludChwYXRoLCBudWxscHRyLCBtb3ZlLmxvY2F0aW9uLngoKSwgbW92ZS5sb2Nh dGlvbi55KCkpOworICAgICAgICB9LAorICAgICAgICBbJl0oY29uc3QgTGluZURhdGEmIGxpbmUp IHsKKyAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgsIG51bGxwdHIsIGxpbmUuc3Rh cnQueCgpLCBsaW5lLnN0YXJ0LnkoKSk7CisgICAgICAgICAgICBDR1BhdGhBZGRMaW5lVG9Qb2lu dChwYXRoLCBudWxscHRyLCBsaW5lLmVuZC54KCksIGxpbmUuZW5kLnkoKSk7CisgICAgICAgIH0s CisgICAgICAgIFsmXShjb25zdCBBcmNEYXRhJiBhcmMpIHsKKyAgICAgICAgICAgIGlmIChhcmMu aGFzT2Zmc2V0KQorICAgICAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgsIG51bGxw dHIsIGFyYy5vZmZzZXQueCgpLCBhcmMub2Zmc2V0LnkoKSk7CisgICAgICAgICAgICBDR1BhdGhB ZGRBcmMocGF0aCwgbnVsbHB0ciwgYXJjLmNlbnRlci54KCksIGFyYy5jZW50ZXIueSgpLCBhcmMu cmFkaXVzLCBhcmMuc3RhcnQsIGFyYy5lbmQsIGFyYy5jbG9ja3dpc2UpOworICAgICAgICB9Cisg ICAgKTsKK30KKwogUGF0aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4mJiBwYXRo KQogICAgIDogbV9wYXRoKFdURk1vdmUocGF0aCkpCiB7CkBAIC04OSw2ICsxMTMsMTIgQEAgUGF0 aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4mJiBwYXRoKQogUGF0aDo6UGF0aCgp ID0gZGVmYXVsdDsKIFBhdGg6On5QYXRoKCkgPSBkZWZhdWx0OwogCitQbGF0Zm9ybVBhdGhQdHIg UGF0aDo6cGxhdGZvcm1QYXRoKCkgY29uc3QKK3sKKyAgICBhcHBseUlubGluZVBhdGhEYXRhSWZO ZWVkZWQoKTsKKyAgICByZXR1cm4gbV9wYXRoLmdldCgpOworfQorCiBQbGF0Zm9ybVBhdGhQdHIg UGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkKIHsKICAgICBpZiAoIW1fcGF0aCkKQEAgLTk4LDEy ICsxMjgsMjEgQEAgUGxhdGZvcm1QYXRoUHRyIFBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCgpCiAg ICAgICAgICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG1fcGF0 aC5nZXQoKSkpOwogICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKICAg ICB9CisgICAgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkKCk7CisgICAgbV9pbmxpbmVEYXRh ID0gTW9ub3N0YXRlIHsgfTsKICAgICByZXR1cm4gbV9wYXRoLmdldCgpOwogfQogCitib29sIFBh dGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGggJiYgIWhhc0FueUlubGlu ZURhdGEoKTsKK30KKwogUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIHsKICAgICBtX3Bh dGggPSB7IG90aGVyLm1fcGF0aCB9OworICAgIG1faW5saW5lRGF0YSA9IG90aGVyLm1faW5saW5l RGF0YTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBvdGhlci5tX25lZWRzVG9BcHBs eUlubGluZURhdGE7CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAgICBtX2NvcHlQYXRoQmVmb3Jl TXV0YXRpb24gPSB0cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24g PSB0cnVlOwpAQCAtMTEyLDYgKzE1MSw4IEBAIFBhdGg6OlBhdGgoY29uc3QgUGF0aCYgb3RoZXIp CiAKIFBhdGg6OlBhdGgoUGF0aCYmIG90aGVyKQogICAgIDogbV9wYXRoKHN0ZDo6ZXhjaGFuZ2Uo b3RoZXIubV9wYXRoLCBudWxscHRyKSkKKyAgICAsIG1faW5saW5lRGF0YShzdGQ6OmV4Y2hhbmdl KG90aGVyLm1faW5saW5lRGF0YSwgTW9ub3N0YXRlIHsgfSkpCisgICAgLCBtX25lZWRzVG9BcHBs eUlubGluZURhdGEoc3RkOjpleGNoYW5nZShvdGhlci5tX25lZWRzVG9BcHBseUlubGluZURhdGEs IGZhbHNlKSkKICAgICAsIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbihzdGQ6OmV4Y2hhbmdlKG90 aGVyLm1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiwgZmFsc2UpKQogewogfQpAQCAtMTE5LDYgKzE2 MCw4IEBAIFBhdGg6OlBhdGgoUGF0aCYmIG90aGVyKQogdm9pZCBQYXRoOjpzd2FwKFBhdGgmIG90 aGVyUGF0aCkKIHsKICAgICBzdGQ6OnN3YXAobV9wYXRoLCBvdGhlclBhdGgubV9wYXRoKTsKKyAg ICBzdGQ6OnN3YXAobV9pbmxpbmVEYXRhLCBvdGhlclBhdGgubV9pbmxpbmVEYXRhKTsKKyAgICBz dGQ6OnN3YXAobV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBvdGhlclBhdGgubV9uZWVkc1RvQXBw bHlJbmxpbmVEYXRhKTsKICAgICBzdGQ6OnN3YXAobV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBv dGhlclBhdGgubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKTsKIH0KIApAQCAtMTc5LDcgKzIyMiw3 IEBAIGJvb2wgUGF0aDo6Y29udGFpbnMoY29uc3QgRmxvYXRQb2ludCAmcG9pbnQsIFdpbmRSdWxl IHJ1bGUpIGNvbnN0CiAgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIC8vIENHUGF0aENvbnRh aW5zUG9pbnQgcmV0dXJucyBmYWxzZSBmb3Igbm9uLWNsb3NlZCBwYXRocywgYXMgYSB3b3JrLWFy b3VuZCwgd2UgY29weSBhbmQgY2xvc2UgdGhlIHBhdGggZmlyc3QuICBSYWRhciA0NzU4OTk4IGFz a3MgZm9yIGEgYmV0dGVyIENHIEFQSSB0byB1c2UKLSAgICBhdXRvIHBhdGggPSBhZG9wdENGKGNv cHlDR1BhdGhDbG9zaW5nU3VicGF0aHMobV9wYXRoLmdldCgpKSk7CisgICAgYXV0byBwYXRoID0g YWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhzKHBsYXRmb3JtUGF0aCgpKSk7CiAgICAg Ym9vbCByZXQgPSBDR1BhdGhDb250YWluc1BvaW50KHBhdGguZ2V0KCksIDAsIHBvaW50LCBydWxl ID09IFdpbmRSdWxlOjpFdmVuT2RkID8gdHJ1ZSA6IGZhbHNlKTsKICAgICByZXR1cm4gcmV0Owog fQpAQCAtMjE3LDkgKzI2MCw5IEBAIHZvaWQgUGF0aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRy YW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIENHQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybUNHID0g dHJhbnNmb3JtOwogI2lmIFBMQVRGT1JNKFdJTikKICAgICBhdXRvIHBhdGggPSBhZG9wdENGKENH UGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgQ0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJh bnNmb3JtQ0csIG1fcGF0aC5nZXQoKSk7CisgICAgQ0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAm dHJhbnNmb3JtQ0csIGVuc3VyZVBsYXRmb3JtUGF0aCgpKTsKICNlbHNlCi0gICAgYXV0byBwYXRo ID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weUJ5VHJhbnNmb3JtaW5nUGF0aChtX3Bh dGguZ2V0KCksICZ0cmFuc2Zvcm1DRykpOworICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRo Q3JlYXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgoZW5zdXJlUGxhdGZvcm1QYXRoKCks ICZ0cmFuc2Zvcm1DRykpOwogI2VuZGlmCiAgICAgbV9wYXRoID0gV1RGTW92ZShwYXRoKTsKICAg ICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKQEAgLTIzMCw5ICsyNzMsMTkgQEAg RmxvYXRSZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgpIGNvbnN0CiAgICAgaWYgKGlzTnVsbCgpKQog ICAgICAgICByZXR1cm4gQ0dSZWN0WmVybzsKIAorICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVE YXRhPigpKQorICAgICAgICByZXR1cm4geyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGlu ZURhdGE+KCkpIHsKKyAgICAgICAgRmxvYXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGlu ZSA9IFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0 VG9Qb2ludHMobGluZS5zdGFydCwgbGluZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0Owor ICAgIH0KKwogICAgIC8vIENHUGF0aEdldEJvdW5kaW5nQm94IGluY2x1ZGVzIHRoZSBwYXRoJ3Mg Y29udHJvbCBwb2ludHMsIENHUGF0aEdldFBhdGhCb3VuZGluZ0JveCBkb2VzIG5vdC4KIAotICAg IENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChtX3BhdGguZ2V0KCkpOwor ICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChwbGF0Zm9ybVBhdGgo KSk7CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7 CiB9CiAKQEAgLTI0MCw3ICsyOTMsMTggQEAgRmxvYXRSZWN0IFBhdGg6OmZhc3RCb3VuZGluZ1Jl Y3QoKSBjb25zdAogewogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuIENHUmVjdFpl cm87Ci0gICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0Qm91bmRpbmdCb3gobV9wYXRoLmdldCgp KTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4g eyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGluZURhdGE+KCkpIHsKKyAgICAgICAgRmxv YXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGluZSA9IFdURjo6Z2V0PExpbmVEYXRhPiht X2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0VG9Qb2ludHMobGluZS5zdGFydCwgbGlu ZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKworICAgIENHUmVjdCBib3Vu ZCA9IENHUGF0aEdldEJvdW5kaW5nQm94KHBsYXRmb3JtUGF0aCgpKTsKICAgICByZXR1cm4gQ0dS ZWN0SXNOdWxsKGJvdW5kKSA/IENHUmVjdFplcm8gOiBib3VuZDsKIH0KIApAQCAtMjY5LDExICsz MzMsMjMgQEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5nUmVjdChTdHJva2VTdHlsZUFw cGxpZXIqIGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9p bnQmIHBvaW50KQogeworICAgIGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRh PigpKSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9IE1vdmVEYXRhIHsgcG9pbnQgfTsKKyAgICAg ICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKwogICAgIENHUGF0aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRy LCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0 IEZsb2F0UG9pbnQmIHApCiB7CisgICAgaWYgKGlzTnVsbCgpIHx8IGhhc0lubGluZURhdGE8TW92 ZURhdGE+KCkpIHsKKyAgICAgICAgbV9pbmxpbmVEYXRhID0gTGluZURhdGEgeyBoYXNBbnlJbmxp bmVEYXRhKCkgPyBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2NhdGlvbiA6IEZs b2F0UG9pbnQoKSwgcCB9OworICAgICAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSB0cnVl OworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5z dXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSk7CiB9CiAKQEAgLTM1Niw2 ICs0MzIsMTIgQEAgdm9pZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQb2ludCYgcCwgZmxvYXQg cmFkaXVzLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmQKICAgICBpZiAoIXN0ZDo6aXNmaW5p dGUoc3RhcnRBbmdsZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUpKQogICAgICAgICByZXR1 cm47CiAKKyAgICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkgewor ICAgICAgICBtX2lubGluZURhdGEgPSBBcmNEYXRhIHsgaGFzQW55SW5saW5lRGF0YSgpID8gV1RG OjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb24gOiBGbG9hdFBvaW50KCksIHAs IHJhZGl1cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGNsb2Nrd2lzZSwgaGFzQW55SW5saW5lRGF0 YSgpIH07CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhBZGRBcmMoZW5zdXJlUGxhdGZvcm1QYXRoKCks IG51bGxwdHIsIHAueCgpLCBwLnkoKSwgcmFkaXVzLCBzdGFydEFuZ2xlLCBlbmRBbmdsZSwgY2xv Y2t3aXNlKTsKIH0KIApAQCAtNDAyLDI1ICs0ODQsNDAgQEAgdm9pZCBQYXRoOjpjbGVhcigpCiAg ICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX3BhdGggPSBhZG9wdENG KENHUGF0aENyZWF0ZU11dGFibGUoKSk7CisgICAgbV9wYXRoLmNsZWFyKCk7CisgICAgbV9pbmxp bmVEYXRhID0gTW9ub3N0YXRlIHsgfTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBm YWxzZTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKIH0KIAogYm9vbCBQ YXRoOjppc0VtcHR5KCkgY29uc3QKIHsKLSAgICByZXR1cm4gaXNOdWxsKCkgfHwgQ0dQYXRoSXNF bXB0eShtX3BhdGguZ2V0KCkpOworICAgIGlmIChpc051bGwoKSkKKyAgICAgICAgcmV0dXJuIHRy dWU7CisKKyAgICBpZiAoaGFzQW55SW5saW5lRGF0YSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7 CisKKyAgICByZXR1cm4gQ0dQYXRoSXNFbXB0eShtX3BhdGguZ2V0KCkpOwogfQogCiBib29sIFBh dGg6Omhhc0N1cnJlbnRQb2ludCgpIGNvbnN0CiB7CiAgICAgcmV0dXJuICFpc0VtcHR5KCk7CiB9 Ci0gICAgCi1GbG9hdFBvaW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0IAorCitGbG9hdFBv aW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0CiB7CiAgICAgaWYgKGlzTnVsbCgpKQotICAg ICAgICByZXR1cm4gRmxvYXRQb2ludCgpOwotICAgIHJldHVybiBDR1BhdGhHZXRDdXJyZW50UG9p bnQobV9wYXRoLmdldCgpKTsKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAgIGlmIChoYXNJbmxp bmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4gV1RGOjpnZXQ8TW92ZURhdGE+KG1f aW5saW5lRGF0YSkubG9jYXRpb247CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4o KSkKKyAgICAgICAgcmV0dXJuIFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpLmVuZDsK KworICAgIHJldHVybiBDR1BhdGhHZXRDdXJyZW50UG9pbnQocGxhdGZvcm1QYXRoKCkpOwogfQog CiBzdGF0aWMgdm9pZCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcih2b2lkKiBpbmZvLCBjb25z dCBDR1BhdGhFbGVtZW50KiBlbGVtZW50KQpAQCAtNDU0LDE0ICs1NTEsNDAgQEAgdm9pZCBQYXRo OjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9uJiBmdW5jdGlvbikgY29uc3QKICAgICBp ZiAoaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIENHUGF0aEFwcGx5KG1fcGF0aC5n ZXQoKSwgKHZvaWQqKSZmdW5jdGlvbiwgQ0dQYXRoQXBwbGllclRvUGF0aEFwcGxpZXIpOworICAg IGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKSB7CisgICAgICAgIFBhdGhFbGVtZW50IGVs ZW1lbnQ7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpUeXBlOjpNb3ZlVG9Q b2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBXVEY6OmdldDxNb3ZlRGF0YT4obV9p bmxpbmVEYXRhKS5sb2NhdGlvbjsKKyAgICAgICAgZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4oKSkgewor ICAgICAgICBhdXRvJiBsaW5lID0gV1RGOjpnZXQ8TGluZURhdGE+KG1faW5saW5lRGF0YSk7Cisg ICAgICAgIFBhdGhFbGVtZW50IGVsZW1lbnQ7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhF bGVtZW50OjpUeXBlOjpNb3ZlVG9Qb2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBs aW5lLnN0YXJ0OworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAgICAgZWxlbWVudC50 eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6OkFkZExpbmVUb1BvaW50OworICAgICAgICBlbGVtZW50 LnBvaW50c1swXSA9IGxpbmUuZW5kOworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIENHUGF0aEFwcGx5KHBsYXRmb3JtUGF0aCgpLCAodm9p ZCopJmZ1bmN0aW9uLCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcik7CiB9CiAKICNpZiBIQVZF KENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQogCiBzaXplX3QgUGF0aDo6ZWxlbWVudENv dW50KCkgY29uc3QKIHsKLSAgICByZXR1cm4gQ0dQYXRoR2V0TnVtYmVyT2ZFbGVtZW50cyhtX3Bh dGgpOworICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4g MTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKQorICAgICAgICByZXR1cm4g MjsKKworICAgIHJldHVybiBDR1BhdGhHZXROdW1iZXJPZkVsZW1lbnRzKHBsYXRmb3JtUGF0aCgp KTsKIH0KIAogI2VuZGlmIC8vIEhBVkUoQ0dQQVRIX0dFVF9OVU1CRVJfT0ZfRUxFTUVOVFMpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMv RGlzcGxheUxpc3RJdGVtcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9k aXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKaW5kZXggOThlMGIxOWI2ZTlhN2RlNDhm MWFjNzgzOWJiODA3YmU0MGFiZWJjMC4uNDNjNzQzNWQ5NTc5YjUyN2JhYWY1OWY5YzQ4Mjc5OTFm ZmRkMGIwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlz cGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcApAQCAtMTE4OCw3 ICsxMTg4LDcgQEAgT3B0aW9uYWw8RmxvYXRSZWN0PiBTdHJva2VQYXRoOjpsb2NhbEJvdW5kcyhj b25zdCBHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNvbnMKIAogdm9pZCBTdHJva2VQYXRoOjph cHBseShHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNvbnN0CiB7Ci0gICAgY29udGV4dC5zdHJv a2VQYXRoKG1fcGF0aCk7CisgICAgY29udGV4dC5zdHJva2VQYXRoKFdURk1vdmUobV9wYXRoKSk7 CiB9CiAKIHN0YXRpYyBUZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFRleHRTdHJlYW0mIHRzLCBjb25z dCBTdHJva2VQYXRoJiBpdGVtKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKaW5kZXgg MWNlMDRmYzc5MDY1N2UyZWFlNGJkZDY5ZTc4OWM1OGU3YjU0N2Q0My4uMTZkNzczNDc1MWEyYTU2 NDE4NzcyNjJlYjI1NzVlYWRjNDIwY2RhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVt cy5oCkBAIC0yNTEwLDcgKzI1MTAsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgYXBwbHkoR3JhcGhp Y3NDb250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAgICAgT3B0aW9uYWw8RmxvYXRSZWN0PiBsb2Nh bEJvdW5kcyhjb25zdCBHcmFwaGljc0NvbnRleHQmKSBjb25zdCBvdmVycmlkZTsKIAotICAgIGNv bnN0IFBhdGggbV9wYXRoOworICAgIG11dGFibGUgUGF0aCBtX3BhdGg7CiB9OwogCiB0ZW1wbGF0 ZTxjbGFzcyBFbmNvZGVyPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy93aW4vUGF0aERpcmVjdDJELmNwcAppbmRleCBmZjYzMDE0Mzk0MDRmMDdmYTcwZjhhM2M2 NDdhNThkMWI0Y2JiZDY1Li5kZDRjNjdkZjYxYTg4M2I1ZGMwMTQyODUxNTM4ZmUzYTFhMjVjMWMz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0aERp cmVjdDJELmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0 aERpcmVjdDJELmNwcApAQCAtNjc2LDYgKzY3NiwyMSBAQCB2b2lkIFBhdGg6OmFwcGx5KGNvbnN0 IFBhdGhBcHBsaWVyRnVuY3Rpb24mIGZ1bmN0aW9uKSBjb25zdAogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcGF0 aDsKK30KKworQ09NUHRyPElEMkQxR2VvbWV0cnlHcm91cD4gUGF0aDo6Y3JlYXRlUGxhdGZvcm1Q YXRoKCkKK3sKKyAgICBDT01QdHI8SUQyRDFHZW9tZXRyeUdyb3VwPiBwYXRoOworICAgIEhSRVNV TFQgaHIgPSBHcmFwaGljc0NvbnRleHQ6OnN5c3RlbUZhY3RvcnkoKS0+Q3JlYXRlR2VvbWV0cnlH cm91cChEMkQxX0ZJTExfTU9ERV9XSU5ESU5HLCBudWxscHRyLCAwLCAmcGF0aCk7CisgICAgQVNT RVJUKFNVQ0NFRURFRChocikpOworICAgIGlmIChGQUlMRUQoaHIpKQorICAgICAgICByZXR1cm4g bnVsbHB0cjsKKyAgICByZXR1cm4gcGF0aDsKK30KKwogfQogCiAjZW5kaWYgLy8gVVNFKERJUkVD VDJEKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2Rl cnMuY3BwIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuY3BwCmlu ZGV4IDc2ZDJiMDlkYWJmMTE0YzM5YzY0NmFlMzE2MzdmYTIwMTYxZmRiM2YuLjE4ZTk1MTc2NTQ3 N2VhMzRlYmM1NWNmNTAyODQ1ZjVkNDk4NzIzYTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv UGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRm b3JtL0lQQy9Bcmd1bWVudENvZGVycy5jcHAKQEAgLTIwNSw0ICsyMDUsMTMgQEAgYm9vbCBBcmd1 bWVudENvZGVyPGF1ZGl0X3Rva2VuX3Q+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlciwgYXVkaXRf dG9rZW5fdCYgYXVkaXQKIH0KICNlbmRpZgogCit2b2lkIEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRl Pjo6ZW5jb2RlKEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKQoreworfQorCitPcHRpb25hbDxN b25vc3RhdGU+IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZGVjb2RlKERlY29kZXImIGRlY29k ZXIpCit7CisgICAgcmV0dXJuIE1vbm9zdGF0ZSB7IH07Cit9CisKIH0gLy8gbmFtZXNwYWNlIElQ QwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMu aCBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmgKaW5kZXggNThj NDU2NDY4OGM4ZjNmMmVhYzFhYzQ3MDE4MmI4NWFmYWRmYzY2NC4uZTdiMjZmNDU1NmZhNGQzMmY1 ZjZmYmRlOWY1YWRmZGM5ZjFmYWM5YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9y bS9JUEMvQXJndW1lbnRDb2RlcnMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9B cmd1bWVudENvZGVycy5oCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSA8d3RmL01vbm90b25p Y1RpbWUuaD4KICNpbmNsdWRlIDx3dGYvU0hBMS5oPgogI2luY2x1ZGUgPHd0Zi9VbmV4cGVjdGVk Lmg+CisjaW5jbHVkZSA8d3RmL1ZhcmlhbnQuaD4KICNpbmNsdWRlIDx3dGYvV2FsbFRpbWUuaD4K IAogbmFtZXNwYWNlIElQQyB7CkBAIC02OTEsNCArNjkyLDkgQEAgdGVtcGxhdGU8PiBzdHJ1Y3Qg QXJndW1lbnRDb2RlcjxhdWRpdF90b2tlbl90PiB7CiB9OwogI2VuZGlmCiAKK3RlbXBsYXRlPD4g c3RydWN0IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPiB7CisgICAgc3RhdGljIHZvaWQgZW5jb2Rl KEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKTsKKyAgICBzdGF0aWMgT3B0aW9uYWw8TW9ub3N0 YXRlPiBkZWNvZGUoRGVjb2RlciYpOworfTsKKwogfSAvLyBuYW1lc3BhY2UgSVBDCg== 392923 2020-03-07 18:14:34 -0800 2020-03-07 18:19:23 -0800 v3 (rebased on trunk) bug-208464-20200307181433.patch text/plain 37099 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDkxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNlYjg0YzRhMTNhNTFmNzlkODIwZDc0 YjNhOGVkNmIwOTg5NDkyOGEuLjcwYmZlMTQ5YmJiYTAxYjc2MjEwZmQwOWZhYmVmNjdlYTlhMjg3 ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGZlYXR1cmUgZmxhZyBmb3IgSU5MSU5FX1BBVEhf REFUQS4gVGhpcyBmZWF0dXJlIGZsYWcgZXhpc3RzIHRvIGVuc3VyZSB0aGF0IHdlIGNhbiBhdm9p ZCBoYXZpbmcKKyAgICAgICAgbV9pbmxpbmVEYXRhIG9uIFBhdGggaW4gcG9ydHMgdGhhdCBkb24n dCBpbXBsZW1lbnQgdGhlIG5lY2Vzc2FyeSBmYWNpbGl0aWVzIGZvciBpbmxpbmUgcGF0aCBkYXRh IHlldCwgc2luY2UgaXQKKyAgICAgICAgd291bGQganVzdCBlbmQgdXAgYmVpbmcgd2FzdGVkIG1l bW9yeS4KKworICAgICAgICAqIHd0Zi9QbGF0Zm9ybUVuYWJsZS5oOgorCiAyMDIwLTAzLTA3ICBE YW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbaU9TXSBJbXBsZW1l bnQgc3VwcG9ydCBmb3IgZGljdGF0aW9uIGFsdGVybmF0aXZlcwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDA0YjE3 NDQ0MjVhNzY0YjIzMDUwZWI3YjhiNDM0ZjM4YzhhNjRiODguLmQ4M2U0ODA0NmVjYzAzNzU3ODli Y2Q4YzExNWMwYzVkOGIyMWY2MGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNDQgQEAKKzIwMjAt MDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg TGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBz dWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdoZW4gdGhl IEdQVSBwcm9jZXNzIGlzIGVuYWJsZWQgYW5kIHVzZWQgdG8gcmVuZGVyIHRoZSBjYW52YXMgZWxl bWVudCwgc29tZSBjYW52YXMtcmVsYXRlZCBzdWJ0ZXN0cyBpbgorICAgICAgICBNb3Rpb25NYXJr IHNlZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNzaW9ucy4gT25lIG9mIHRoZSByZWFz b25zIGZvciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mgb2YKKyAgICAgICAgZGVjb2Rpbmcg ZGlzcGxheSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2ViQ29yZTo6UGF0aGBzIGluIHRoZSBH UFUgcHJvY2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBuZXcgQ0dQYXRoCisgICAgICAgIGZv ciBlYWNoIFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNhbGx5IGluY3JlYXNlcyBwYWdlIGRl bWFuZCBhbmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJvY2VzcyBpbiBjb250cmFzdAorICAg ICAgICB0byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUgZmFjdCB0aGF0IGFsbCBvZiB0aGVz ZSBDR1BhdGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11c3QgYWxsIGV4aXN0IHNvbWV3aGVy ZQorICAgICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5nIHRoZSBkaXNwbGF5IGxpc3QuCisK KyAgICAgICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdlYktpdCwgZWFjaCBjYWxsIHRvIHN0 cm9rZSB0aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBpbnZva2luZworICAgICAgICBHcmFw aGljc0NvbnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRlZCBieSBjbGVhcmluZyB0aGUgcGF0 aCwgd2hpY2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlCisgICAg ICAgIFBhdGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVlZHMgdG8gYmUgY3JlYXRlZCwgQ29y ZUdyYXBoaWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0aGUgbmV3IENHUGF0aCBhdCB0aGUK KyAgICAgICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQYXRoIHdoaWNoIHdhcyBqdXN0IGRl c3Ryb3llZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0eWluZyBtb3JlIHBhZ2VzIHRoYW4K KyAgICAgICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24gYWZmZWN0cyBtb3N0IG9mIHRoZSBj YW52YXMtcmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRvIHNvbWUgZGVncmVlLCB0aG91Z2gg dGhlCisgICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFibGUgd2l0aCBDYW52YXMgTGluZXMu CisKKyAgICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNpZ25pZmljYW50IHBvcnRpb24gb2Yg dGltZSBpcyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBwbHkgYW5kIGNvbnZlcnRpbmcgdGhl IHJlc3VsdGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBpbnRvIHNlcmlhbGl6YWJsZSBkYXRh IHdoZW4gZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisKKyAgICAgICAgVG8gbWl0aWdhdGUg dGhlc2UgdHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lucyB3ZSBnZXQgZnJvbSBtZW1vcnkg bG9jYWxpdHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdlCisgICAgICAgIHF1YW50aXRpZXMs IHdlIGNhbjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ugb2Ygc2ltcGxlIHBhdGhzLCBzdHVm ZiBzb21lIGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBhdGggd2FzIGNyZWF0ZWQgYXMgaW5s aW5lIGRhdGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBhdGggaXRzZWxmLCBhcyBhIG5ldyBk YXRhIG1lbWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29tcGFzc2VzIGxpbmVzLCBhcmNzLCBh bmQgbW92ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBvbmx5IGBQYXRoOjptb3ZlVG9gIHdh cyBpbnZva2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGluY2x1ZGUg ZWxsaXBzZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhpcyBhbGxvd3MgdXMgdG8gYWNoaWV2 ZSB0d28gdGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVhcGVyIGJ5IG5vdCByZXF1aXJpbmcg YSB3YWxrIHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBDR1BhdGgncyBlbGVtZW50cywgYW5k IChiKSBtYWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBpbml0aWFsaXppbmcgdGhlIFBhdGgg dXNpbmcgaW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBoYXZpbmcgdG8gY3Jl YXRlIGEgbmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hlbiBwYWludGluZyB0aGUgU3Ryb2tl UGF0aCBkaXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJkIGBtX3BhdGhgIGFmdGVyIHdlJ3Jl IGRvbmUgcGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAgIFRoaXMsIGluIGNvbmp1bmN0aW9u IHdpdGggKDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZTo6UGF0 aCBpbiB0aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAgICAgICAgY3JlYXRlZCB3aGVuIHdl J3JlIGp1c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBjYWxsaW5nIGludG8gc3Ryb2tlUGF0 aCgpKSwgYW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAgICAgICAgICAgd2UncmUgZG9uZSBw YWludGluZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxvdyBmb3IgZGV0YWlscy4gVGhlcmUg c2hvdWxkIGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKworICAgICAgICAqIFdlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9Jbmxp bmVQYXRoRGF0YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Ok1vdmVEYXRhOjplbmNvZGUg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6TW92ZURhdGE6OmRlY29kZSk6CisgICAgICAgIChX ZWJDb3JlOjpMaW5lRGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkxpbmVE YXRhOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXJjRGF0YTo6ZW5jb2RlIGNvbnN0KToK KyAgICAgICAgKFdlYkNvcmU6OkFyY0RhdGE6OmRlY29kZSk6CisKKyAgICAgICAgSW50cm9kdWNl IElubGluZVBhdGhEYXRhLCBhIFZhcmlhbnQgb2Ygc2V2ZXJhbCBkaWZmZXJlbnQgaW5saW5lIGRh dGEgdHlwZXMsIGVhY2ggb2Ygd2hpY2ggcmVwcmVzZW50cyBvbmUgc2ltcGxlCisgICAgICAgIHBh dGggdHlwZSB0aGF0IGlzIHN0b3JlZCB1c2luZyBvbmx5IGlubGluZSBkYXRhLiBUaGlzIGluY2x1 ZGVzIGxpbmUgc2VnbWVudHMgKGEgc3RhcnQgcG9pbnQgYW5kIGFuIGVuZCBwb2ludCksCisgICAg ICAgIGFzIHdlbGwgYXMgYXJjcyAod2hpY2gsIGluIGFkZGl0aW9uIHRvIGEgY2VudGVyIGFuZCBz dGFydCBhbmQgZW5kIGFuZ2xlcykgYWxzbyBpbmNsdWRlcyBhbiBvcHRpb25hbCBvZmZzZXQsCisg ICAgICAgIHdoaWNoIHJlcHJlc2VudHMgdGhlIGN1cnJlbnQgcG9zaXRpb24gb2YgdGhlIHBhdGgg YXQgdGhlIHRpbWUgImFkZEFyYyIgd2FzIGNhbGxlZC4KKworICAgICAgICBGb3IgaW5zdGFuY2Us IGluIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW8sIHRoZSBwYXRoIHdvdWxkIGhhdmUgYW4gYXJjIHRo YXQgaXMgb2Zmc2V0IGJ5ICgxMDAsIDApOyBpZiBmaWxsZWQsIGl0CisgICAgICAgIHdvdWxkIHJl c3VsdCBpbiBhIGNvbXBvc2l0ZSBzaGFwZSByZXNlbWJsaW5nIGEgc2VtaWNpcmNsZSBvbiB0b3Ag b2YgYSB0cmlhbmdsZToKKworICAgICAgICBwYXRoLm1vdmVUbygxMDAsIDApOworICAgICAgICBw YXRoLmFkZEFyYygxMDAsIDEwMCwgNTAsIDAsIFBJLCBmYWxzZSk7CisgICAgICAgIGNvbnRleHQu ZmlsbChwYXRoKTsKKworICAgICAgICBXaGVuIGEgUGF0aCBpcyBpbml0aWFsaXplZCAob3IgYWZ0 ZXIgaXQgaXMgY2xlYXJlZCksIGl0IHN0YXJ0cyBvZmYgd2l0aCBuZWl0aGVyIGEgQ0dQYXRoIG5v ciBpbmxpbmUgZGF0YS4gTW92aW5nCisgICAgICAgIHRoZSBwYXRoIGNhdXNlcyBpdCB0byBzdG9y ZSBpbmxpbmUgTW92ZURhdGE7IGNhbGxpbmcgY2FsbGluZyBgYWRkTGluZVRvYCBvciBgYWRkQXJj YCB0aGVuIHJlcGxhY2VzIHRoZSBpbmxpbmUKKyAgICAgICAgZGF0YSB3aXRoIGVpdGhlciBMaW5l RGF0YSBvciBBcmNEYXRhLgorCisgICAgICAgIElmLCBhdCBhbnkgcG9pbnQsIHRoZSBwYXRoIGNo YW5nZXMgaW4gYSBkaWZmZXJlbnQgd2F5IChpLmUuIG5laXRoZXIgbGluZSwgYXJjLCBub3IgbW92 ZSksIHdlIGNsZWFyIG91dCB0aGUKKyAgICAgICAgaW5saW5lIGRhdGEgYW5kIGZhbGwgYmFjayB0 byBqdXN0IHJlcHJlc2VudGluZyB0aGUgcGF0aCBkYXRhIHVzaW5nIHRoZSBDR1BhdGggKG1fcGF0 aCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCBjb25zdCk6CisKKyAgICAg ICAgQWRkIGEgaGVscGVyIG1ldGhvZCB0aGF0IGlzIGludm9rZWQgd2hlbiB0aGUgUGF0aCBpcyBh c2tlZCBmb3IgYSBDR1BhdGguIEluIHRoaXMgY2FzZSwgZXZlbiBpZiBtX3BhdGggaXMgbnVsbCwK KyAgICAgICAgd2UgbmVlZCB0byBsYXppbHkgY3JlYXRlIGl0IGFuZCBhcHBseSBhbnkgaW5saW5l IHBhdGggZGF0YSB3ZSd2ZSBhY2N1bXVsYXRlZC4gT25jZSB3ZSdyZSBkb25lIGFwcGx5aW5nIHRo ZQorICAgICAgICBpbmxpbmUgZGF0YSwgc2V0IGEgZmxhZyAobV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhKSB0byBmYWxzZSB0byBhdm9pZCByZS1hcHBseWluZyBpbmxpbmUgZGF0YSB0byB0aGUgcGF0 aC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1BhdGguaDoKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpkZWNvZGUp OgorCisgICAgICAgIFRlYWNoIFBhdGg6OmVuY29kZSBhbmQgUGF0aDo6ZGVjb2RlIHRvIHJlc3Bl Y3RpdmVseSBzZXJpYWxpemUgYW5kIGRlc2VyaWFsaXplIFdlYkNvcmU6OlBhdGggYnkgY29uc3Vs dGluZyBvbmx5CisgICAgICAgIHRoZSBpbmxpbmUgZGF0YSwgaWYgaXQgaXMgcHJlc2VudC4gRm9y IHNpbXBsZSB0eXBlcyBvZiBwYXRocywgdGhpcyBkZWNyZWFzZXMgdGhlIGNvc3Qgb2YgYm90aCBJ UEMgZW5jb2RpbmcgYW5kCisgICAgICAgIGRlY29kaW5nLCBidXQgYWRkcyBhIG5lZ2xpZ2libGUg YW1vdW50IG9mIG92ZXJoZWFkIGluIHRoZSBjYXNlIHdoZXJlIHRoZSBwYXRoIGlzIG5vbi1pbmxp bmUuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0lubGluZURhdGEgY29uc3QpOgorICAg ICAgICAoV2ViQ29yZTo6UGF0aDo6aGFzQW55SW5saW5lRGF0YSBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpp c051bGwgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRo KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmFwcGx5SW5saW5lUGF0aERhdGEpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZv cm1QYXRoIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0 aCk6CisKKyAgICAgICAgV2hlbiBlbnN1cmVQbGF0Zm9ybVBhdGggaXMgaW52b2tlZCwgd2UgYXJl IGFib3V0IHRvIG11dGF0ZSBvdXIgQ0dQYXRoIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBjYW4ndCBi ZSBleHByZXNzZWQKKyAgICAgICAgaW4gdGVybXMgb2YgaW5saW5lIGRhdGEgKGF0IGxlYXN0LCBu b3Qgd2l0aCB0aGUgY2hhbmdlcyBpbiB0aGlzIHBhdGNoKS4gQ2xlYXIgb3V0IHRoZSBpbmxpbmUg cGF0aCBkYXRhIGluIHRoaXMKKyAgICAgICAgY2FzZSwgYW5kIGFwcGx5IHRoZSBDR1BhdGggbXV0 YXRpb25zIHRoYXQgd2VyZSBwcmV2aW91c2x5IHN0YXNoZWQgYXdheSBpbiBpbmxpbmUgcGF0aCBk YXRhLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorCisgICAgICAg IEEgcGF0aCBpcyBub3cgY29uc2lkZXJlZCBudWxsIGlmIGl0IGlzIG5vdCBvbmx5IG1pc3Npbmcg YSBDR1BhdGgsIGJ1dCBhbHNvIGRvZXMgbm90IGhhdmUgYW55IGlubGluZSBwYXRoIGRhdGEuCisg ICAgICAgIFRoaXMgbWFpbnRhaW5zIHRoZSBpbnZhcmlhbnQgdGhhdCBgaXNOdWxsKClgIGlzIHRy dWUgaWZmIHRoZSBgcGxhdGZvcm1QYXRoKClgIHJldHVybnMgMHgwLgorCisgICAgICAgIChXZWJD b3JlOjpQYXRoOjpQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnN3YXApOgorCisgICAg ICAgIFVwZGF0ZSB0aGUgY29uc3RydWN0b3JzIGFuZCBgc3dhcGAgaGVscGVyIG1ldGhvZCAodXNl ZCBieSBhc3NpZ25tZW50IG9wZXJhdG9ycykgdG8gYWNjb3VudCBmb3IgdGhlIG5ldyBtZW1iZXJz LgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjb250YWlucyBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjp0cmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRp bmdSZWN0IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3Qg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6bW92ZVRvKToKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmFkZExpbmVUbyk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmMpOgor CisgICAgICAgIEluIHRoZSBjYXNlIG9mIHRoZXNlIHRocmVlIG1ldGhvZHMgZm9yIG11dGF0aW5n IGEgcGF0aCwgaWYgd2UndmUgZWl0aGVyIG9ubHkgbW92ZWQgdGhlIHBhdGggb3IgaGF2ZW4ndCB0 b3VjaGVkCisgICAgICAgIGl0IGF0IGFsbCwgd2UgY2FuIGdldCBhd2F5IHdpdGggb25seSB1cGRh dGluZyBvdXIgaW5saW5lIHBhdGggZGF0YSwgYW5kIGF2b2lkIGNyZWF0aW5nIGEgQ0dQYXRoLgor CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisKKyAgICAgICAgV2hlbiBjbGVhcmlu ZyBQYXRoLCBpbnN0ZWFkIG9mIHNldHRpbmcgYG1fcGF0aGAgdG8gYSBuZXdseSBhbGxvY2F0ZWQg Q0dQYXRoLCBzaW1wbHkgcmVzZXQgaXQgdG8gbnVsbC4gVGhpcworICAgICAgICBlbnN1cmVzIHRo YXQgaWYgd2UgdGhlbiBhcHBseSBzb21lIGNoYW5nZXMgdGhhdCBjYW4gYmUgZXhwcmVzc2VkIHVz aW5nIG9ubHkgaW5saW5lIHBhdGggZGF0YSwgd2UgYXZvaWQgaGF2aW5nIHRvCisgICAgICAgIHVw ZGF0ZSB0aGUgQ0dQYXRoLCBhbmQgaW5zdGVhZCBqdXN0IHVwZGF0ZSB0aGUgaW5saW5lIHBhdGgg ZGF0YS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6 UGF0aDo6YXBwbHkgY29uc3QpOgorCisgICAgICAgIFRocm93IG91dCB0aGUgY3VycmVudCBXZWJD b3JlOjpQYXRoIGFmdGVyIHdlJ3JlIGRvbmUgcGFpbnRpbmcgd2l0aCBpdCAoc2VlICgyKSBpbiB0 aGUgYWJvdmUgQ2hhbmdlTG9nIGVudHJ5KS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZWxl bWVudENvdW50IGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlz dHMvRGlzcGxheUxpc3RJdGVtcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEaXNwbGF5TGlzdDo6 U3Ryb2tlUGF0aDo6YXBwbHkgY29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3dp bi9QYXRoRGlyZWN0MkQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNOdWxsIGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNyZWF0ZVBsYXRmb3JtUGF0aCk6CisKIDIwMjAt MDMtMDcgIERhbmllbCBCYXRlcyAgPGRhYmF0ZXNAYXBwbGUuY29tPgogCiAgICAgICAgIFtpT1Nd IEltcGxlbWVudCBzdXBwb3J0IGZvciBkaWN0YXRpb24gYWx0ZXJuYXRpdmVzCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4 IDQzNzJiZTY0OThiYzczZjNkMGI4M2RhMzVmN2QwM2JmNmQxNTU3OTcuLmZjMzRkY2VmYzQ1ZmM4 M2FlYmFhNmIxZjAyN2E3MDBjMTE1ODc3YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIw MjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAg ICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhz LCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2 PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBh cmd1bWVudCBjb2RlcnMgZm9yIGBXVEY6Ok1vbm9zdGF0ZWAsIHNvIHRoYXQgVmFyaWFudHMgb2Yg dGhlIGZvcm06IGBWYXJpYW50PE1vbm9zdGF0ZSwgRm9vLCBCYXI+YCBjYW4gYmUKKyAgICAgICAg ZW5jb2RlZCBhbmQgZGVjb2RlZCBvdmVyIElQQy4KKworICAgICAgICAqIFBsYXRmb3JtL0lQQy9B cmd1bWVudENvZGVycy5jcHA6CisgICAgICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8TW9ub3N0YXRl Pjo6ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxNb25vc3RhdGU+OjpkZWNv ZGUpOgorICAgICAgICAqIFBsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5oOgorCiAyMDIwLTAz LTA3ICBQZW5nIExpdSAgPHBlbmcubGl1NkBhcHBsZS5jb20+CiAKICAgICAgICAgVXNlIHRoZSBm ZWF0dXJlIGZsYWdzIG1lY2hhbmlzbSB0byBnaXZlIGRlZmF1bHQgZmVhdHVyZSBwcmVmZXJlbmNl IHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaCBiL1Nv dXJjZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgKaW5kZXggMzg1MWVkYmJkOTQ3NjYxYjI2YmM5 MjZkMzhkM2I3YWRjZmJkZDBjNi4uZDAzMDE5MWE4ZjkwZWMyNGU5MjNiNzdhN2IxNzE0OTBlYmU4 MWZjZSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaAorKysgYi9T b3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5oCkBAIC04MTcsNiArODE3LDkgQEAKICNkZWZp bmUgRU5BQkxFX09QRU5UWVBFX01BVEggMQogI2VuZGlmCiAKKyNpZiAhZGVmaW5lZChFTkFCTEVf SU5MSU5FX1BBVEhfREFUQSkgJiYgVVNFKENHKQorI2RlZmluZSBFTkFCTEVfSU5MSU5FX1BBVEhf REFUQSAxCisjZW5kaWYKIAogLyogRGlzYWJsZSBTaGFyZWRBcnJheUJ1ZmZlcnMgdW50aWwgU3Bl Y3RyZSBzZWN1cml0eSBjb25jZXJucyBhcmUgbWl0aWdhdGVkLiAqLwogI2RlZmluZSBFTkFCTEVf U0hBUkVEX0FSUkFZX0JVRkZFUiAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZDFiMGFmOGU2YzAxZmU4MWNlY2FmYzYyMTQzMGU5 Mjk3ZjlkMjAyYy4uMjViODg3M2EzYzlkNTYzYjE5MTA5NTIzZjEzZjRmMDI1MWNiMjQzYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpA QCAtNDk3Nyw2ICs0OTc3LDcgQEAKIAkJRjQ0MkMzNTkyM0UzQUREMjAwNDk5NTgyIC8qIENvbXBv c2l0aW9uSGlnaGxpZ2h0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGNDQyQzM1NzIzRTNBQzUxMDA0OTk1ODIgLyogQ29tcG9zaXRpb25IaWdobGlnaHQu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDRB NUY1OTFGRUQzOEYyMDA3RjU5NDQgLyogTGVnYWN5TlNQYXN0ZWJvYXJkVHlwZXMuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NEE1RjU3MUZFRDM4MzAw MDdGNTk0NCAvKiBMZWdhY3lOU1Bhc3RlYm9hcmRUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0NEVCQkQ5MURCNUQyMTQwMDI3NzMzNCAv KiBTdGF0aWNSYW5nZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRjQ0RUJCRDgxREI1RDIxNDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggKi87IHNldHRp bmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJRjQ1Nzc1Q0UyNDE0MzdE NTAwMkRGMUEwIC8qIElubGluZVBhdGhEYXRhLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGNDU3NzVDRDI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0 aERhdGEuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQlGNDVDMjMxRTE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMxQzE5OTVC NzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi87IHNldHRpbmdzID0ge0FU VFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ2NzI5MjgxRTBERTY4NTAwQUNDM0Q4 IC8qIFNjcm9sbFNuYXBPZmZzZXRzSW5mby5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRjQ2NzI5MjUxRTBERTVBQjAwQUNDM0Q4IC8qIFNjcm9sbFNuYXBP ZmZzZXRzSW5mby5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCUY0NkM0NDdFMjM0NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVtQmluZGluZ3NE YXRhU291cmNlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGNDZDNDQ3QzIzNDY1NDU0MDAzOUE3OUQgLyogQ2xpcGJvYXJkSXRlbUJpbmRpbmdzRGF0YVNv dXJjZS5oICovOyB9OwpAQCAtMTU0NjUsNiArMTU0NjYsNyBAQAogCQlGNDRFQkJENjFEQjVEMUI2 MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IFN0YXRp Y1JhbmdlLmlkbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ0RUJCRDgxREI1RDIx NDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IFN0YXRpY1JhbmdlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NEVCQkRB MURCNUREOUQwMDI3NzMzNCAvKiBTdGF0aWNSYW5nZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBTdGF0aWNSYW5nZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCUY0NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBJbmxpbmVQYXRoRGF0YS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NUMyMzFDMTk5NUI3M0IwMEE2 RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUY0NjI4QTlFMjM0RDNCQkYwMEJDODg0QyAvKiBQbGF0Zm9ybVBhc3RlYm9hcmRDb2Nv YS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFBsYXRmb3JtUGFz dGVib2FyZENvY29hLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjUxMjcsNiAr MjUxMjksNyBAQAogCQkJCTA3MDZBMEQ3MjQwODMwQTYwMEU5MzgxOCAvKiBJbmJhbmRHZW5lcmlj Q3VlSWRlbnRpZmllci5oICovLAogCQkJCTA3OTQxNzkzMTY2RUEwNEUwMDk0MTZDMiAvKiBJbmJh bmRUZXh0VHJhY2tQcml2YXRlLmggKi8sCiAJCQkJMDdDRTc3RDQxNjcxMkE2QTAwQzU1QTQ3IC8q IEluYmFuZFRleHRUcmFja1ByaXZhdGVDbGllbnQuaCAqLywKKwkJCQlGNDU3NzVDRDI0MTQzN0Q1 MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCAqLywKIAkJCQkyRDQ2RjA0RDE3Qjk2RkJEMDA1 NjQ3RjAgLyogSW50UG9pbnQuY3BwICovLAogCQkJCUIyNzUzNTQ0MEIwNTM4MTQwMDJDRTY0RiAv KiBJbnRQb2ludC5oICovLAogCQkJCUU0NjJBNEEwMTEzRTcxQkUwMDRBNDIyMCAvKiBJbnRQb2lu dEhhc2guaCAqLywKQEAgLTMwNDE2LDYgKzMwNDE5LDcgQEAKIAkJCQk2RkIyNDAwNTIzREZGMTI4 MDA3OTY0NTggLyogSW5saW5lTGluZUJveEJ1aWxkZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTZG RTE5ODE3MjE3ODM5N0MwMDQ0NkYwOCAvKiBJbmxpbmVMaW5lQnJlYWtlci5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJNkYwQ0Q2OTUyMjlFRDMyNzAwQzU5OTRFIC8qIElubGluZUxpbmVCdWlsZGVyLmgg aW4gSGVhZGVycyAqLywKKwkJCQlGNDU3NzVDRTI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0 aERhdGEuaCBpbiBIZWFkZXJzICovLAogCQkJCTZGMzYwRTUwMjM5OTk0MjEwMDE1MTJBNyAvKiBJ bmxpbmVTb2Z0TGluZUJyZWFrSXRlbS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQUE0QzNBNzcwQjJC MTY3OTAwMjMzNEEyIC8qIElubGluZVN0eWxlU2hlZXRPd25lci5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQkNFQTQ4NUEwOTdEOTMwMjAwOTRDOUU0IC8qIElubGluZVRleHRCb3guaCBpbiBIZWFkZXJz ICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5l UGF0aERhdGEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhE YXRhLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjUzNTlhYmFlYzA2MjEwZTE4OTQ4ZTUwZTYwOGQ5YTVmZWM5MWE0 NgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lu bGluZVBhdGhEYXRhLmgKQEAgLTAsMCArMSwxMzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9u Y2UKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCisjaW5jbHVkZSAiRmxvYXRQb2lu dC5oIgorI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJpYW50Lmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RydWN0IExpbmVEYXRhIHsKKyAgICBGbG9hdFBv aW50IHN0YXJ0OworICAgIEZsb2F0UG9pbnQgZW5kOworCisgICAgdGVtcGxhdGU8Y2xhc3MgRW5j b2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNsYXNzIERl Y29kZXI+IHN0YXRpYyBPcHRpb25hbDxMaW5lRGF0YT4gZGVjb2RlKERlY29kZXImKTsKK307CisK K3N0cnVjdCBBcmNEYXRhIHsKKyAgICBGbG9hdFBvaW50IG9mZnNldDsKKyAgICBGbG9hdFBvaW50 IGNlbnRlcjsKKyAgICBmbG9hdCByYWRpdXMgeyAwIH07CisgICAgZmxvYXQgc3RhcnQgeyAwIH07 CisgICAgZmxvYXQgZW5kIHsgMCB9OworICAgIGJvb2wgY2xvY2t3aXNlIHsgZmFsc2UgfTsKKyAg ICBib29sIGhhc09mZnNldCB7IGZhbHNlIH07CisKKyAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVy PiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rl cj4gc3RhdGljIE9wdGlvbmFsPEFyY0RhdGE+IGRlY29kZShEZWNvZGVyJik7Cit9OworCitzdHJ1 Y3QgTW92ZURhdGEgeworICAgIEZsb2F0UG9pbnQgbG9jYXRpb247CisKKyAgICB0ZW1wbGF0ZTxj bGFzcyBFbmNvZGVyPiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8 Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPE1vdmVEYXRhPiBkZWNvZGUoRGVjb2RlciYp OworfTsKKwordGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBNb3ZlRGF0YTo6ZW5jb2RlKEVu Y29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCBsb2NhdGlvbjsKK30KKwor dGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8TW92ZURhdGE+IE1vdmVEYXRhOjpkZWNv ZGUoRGVjb2RlciYgZGVjb2RlcikKK3sKKyAgICBNb3ZlRGF0YSBkYXRhOworICAgIGlmICghZGVj b2Rlci5kZWNvZGUoZGF0YS5sb2NhdGlvbikpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7 CisgICAgcmV0dXJuIHsgZGF0YSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IExpbmVEYXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVy IDw8IHN0YXJ0OworICAgIGVuY29kZXIgPDwgZW5kOworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNv ZGVyPiBPcHRpb25hbDxMaW5lRGF0YT4gTGluZURhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVy KQoreworICAgIExpbmVEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnN0 YXJ0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5k ZWNvZGUoZGF0YS5lbmQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0 dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IEFyY0RhdGE6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIg PDwgb2Zmc2V0OworICAgIGVuY29kZXIgPDwgY2VudGVyOworICAgIGVuY29kZXIgPDwgcmFkaXVz OworICAgIGVuY29kZXIgPDwgc3RhcnQ7CisgICAgZW5jb2RlciA8PCBlbmQ7CisgICAgZW5jb2Rl ciA8PCBjbG9ja3dpc2U7CisgICAgZW5jb2RlciA8PCBoYXNPZmZzZXQ7Cit9CisKK3RlbXBsYXRl PGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPEFyY0RhdGE+IEFyY0RhdGE6OmRlY29kZShEZWNvZGVy JiBkZWNvZGVyKQoreworICAgIEFyY0RhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KGRhdGEub2Zmc2V0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICgh ZGVjb2Rlci5kZWNvZGUoZGF0YS5jZW50ZXIpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnJhZGl1cykpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuc3RhcnQpKQor ICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShk YXRhLmVuZCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29k ZXIuZGVjb2RlKGRhdGEuY2xvY2t3aXNlKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsK KworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5oYXNPZmZzZXQpKQorICAgICAgICByZXR1 cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit1 c2luZyBJbmxpbmVQYXRoRGF0YSA9IFZhcmlhbnQ8TW9ub3N0YXRlLCBNb3ZlRGF0YSwgTGluZURh dGEsIEFyY0RhdGE+OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFC TEUoSU5MSU5FX1BBVEhfREFUQSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1BhdGguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0 aC5jcHAKaW5kZXggYTYyOGQzNzQyMjQyM2MxMjAzNTRmZmZmMjE5MDYxN2Y3MmI0Mzg1Mi4uMzU1 MTU3ZmQwMTRiNDcwZmY2ZTQ0YjRlZWJhYWQzMWI0MDYxYjMwNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKQEAgLTE4OCw2ICsxODgsMjYgQEAgRmxvYXRSZWN0 IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUo SU5MSU5FX1BBVEhfREFUQSkKKwordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhEYXRhSWZOZWVk ZWQoKSBjb25zdAoreworICAgIGlmICghbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKQorICAgICAg ICByZXR1cm47CisKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBmYWxzZTsKKworICAg IGlmICghaGFzQW55SW5saW5lRGF0YSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1f cGF0aCkKKyAgICAgICAgbV9wYXRoID0gY3JlYXRlUGxhdGZvcm1QYXRoKCk7CisKKyAgICBhcHBs eUlubGluZVBhdGhEYXRhKG1faW5saW5lRGF0YSwgbV9wYXRoLmdldCgpKTsKK30KKworI2VuZGlm IC8vIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCiAjaWZuZGVmIE5ERUJVRwogdm9pZCBQYXRo OjpkdW1wKCkgY29uc3QKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaApp bmRleCA3ZmFkYTYwZDgzYzI5MjUwYWM0YTE3NDhhODkyNDA3MDI5MTk5ZTFiLi42MTYyZjdkMGI1 ZGU2Mjc3Mjk3NjNhOGQ0NjU0MDVmY2JkMGI2OWY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oCkBAIC0yNSwxNCArMjUsMTUgQEAKICAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAogICov CiAKLSNpZm5kZWYgUGF0aF9oCi0jZGVmaW5lIFBhdGhfaAorI3ByYWdtYSBvbmNlCiAKICNpbmNs dWRlICJGbG9hdFJlY3QuaCIKKyNpbmNsdWRlICJJbmxpbmVQYXRoRGF0YS5oIgogI2luY2x1ZGUg IldpbmRSdWxlLmgiCiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KICNpbmNsdWRlIDx3dGYv RnVuY3Rpb24uaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJp YW50Lmg+CiAKICNpZiBVU0UoQ0cpCiAKQEAgLTE0Nyw3ICsxNDgsNyBAQCBwdWJsaWM6CiAgICAg RmxvYXRQb2ludCBwb2ludEF0TGVuZ3RoKGZsb2F0IGxlbmd0aCkgY29uc3Q7CiAKICAgICBXRUJD T1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7Ci0gICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVy biAhbV9wYXRoOyB9CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBpc051bGwoKSBjb25zdDsKICAg ICBib29sIGlzRW1wdHkoKSBjb25zdDsKICAgICAvLyBHZXRzIHRoZSBjdXJyZW50IHBvaW50IG9m IHRoZSBjdXJyZW50IHBhdGgsIHdoaWNoIGlzIGNvbmNlcHR1YWxseSB0aGUgZmluYWwgcG9pbnQg cmVhY2hlZCBieSB0aGUgcGF0aCBzbyBmYXIuCiAgICAgLy8gTm90ZSB0aGUgUGF0aCBjYW4gYmUg ZW1wdHkgKGlzRW1wdHkoKSA9PSB0cnVlKSBhbmQgc3RpbGwgaGF2ZSBhIGN1cnJlbnQgcG9pbnQu CkBAIC0xODUsNyArMTg2LDcgQEAgcHVibGljOgogICAgIEZsb2F0UmVjdCBmYXN0Qm91bmRpbmdS ZWN0Rm9yU3Ryb2tlKGNvbnN0IFBsYXRmb3JtQ29udGV4dERpcmVjdDJEJikgY29uc3Q7CiAgICAg UGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0aC5nZXQo KTsgfQogI2VsaWYgVVNFKENHKQotICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBj b25zdCB7IHJldHVybiBtX3BhdGguZ2V0KCk7IH0KKyAgICBXRUJDT1JFX0VYUE9SVCBQbGF0Zm9y bVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3Q7CiAjZWxzZQogICAgIFBsYXRmb3JtUGF0aFB0 ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGg7IH0KICNlbmRpZgpAQCAtMjI1 LDYgKzIyNiwxNSBAQCBwdWJsaWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGlj IE9wdGlvbmFsPFBhdGg+IGRlY29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6CisgICAgc3RhdGlj IFBsYXRmb3JtUGF0aFN0b3JhZ2VUeXBlIGNyZWF0ZVBsYXRmb3JtUGF0aCgpOworCisjaWYgRU5B QkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgc3RhdGljIHZvaWQgYXBwbHlJbmxpbmVQYXRoRGF0 YShjb25zdCBJbmxpbmVQYXRoRGF0YSYsIFBsYXRmb3JtUGF0aFB0cik7CisgICAgdGVtcGxhdGUg PHR5cGVuYW1lIERhdGFUeXBlPiBib29sIGhhc0lubGluZURhdGEoKSBjb25zdDsKKyAgICBib29s IGhhc0FueUlubGluZURhdGEoKSBjb25zdDsKKyAgICB2b2lkIGFwcGx5SW5saW5lUGF0aERhdGFJ Zk5lZWRlZCgpIGNvbnN0OworI2VuZGlmCisKICNpZiBVU0UoQ0cpCiAgICAgdm9pZCBzd2FwKFBh dGgmKTsKICNlbmRpZgpAQCAtMjM3LDYgKzI0NywxMCBAQCBwcml2YXRlOgogICAgIG11dGFibGUg Ym9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNlbmRpZgogCisjaWYgRU5BQkxFKElO TElORV9QQVRIX0RBVEEpCisgICAgSW5saW5lUGF0aERhdGEgbV9pbmxpbmVEYXRhOworICAgIG11 dGFibGUgYm9vbCBtX25lZWRzVG9BcHBseUlubGluZURhdGEgeyBmYWxzZSB9OworI2VuZGlmCiAj aWYgVVNFKENHKQogICAgIG11dGFibGUgYm9vbCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24geyBm YWxzZSB9OwogI2VuZGlmCkBAIC0yNDYsNiArMjYwLDE1IEBAIFdURjo6VGV4dFN0cmVhbSYgb3Bl cmF0b3I8PChXVEY6OlRleHRTdHJlYW0mLCBjb25zdCBQYXRoJik7CiAKIHRlbXBsYXRlPGNsYXNz IEVuY29kZXI+IHZvaWQgUGF0aDo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiB7Cisj aWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgYm9vbCBoYXNJbmxpbmVEYXRhID0gaGFz QW55SW5saW5lRGF0YSgpOworICAgIGVuY29kZXIgPDwgaGFzSW5saW5lRGF0YTsKKyAgICBpZiAo aGFzSW5saW5lRGF0YSkgeworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgorCiAgICAgZW5jb2RlciA8PCBzdGF0aWNfY2FzdDx1 aW50NjRfdD4oZWxlbWVudENvdW50KCkpOwogCiAgICAgYXBwbHkoWyZdKGF1dG8mIGVsZW1lbnQp IHsKQEAgLTI3Niw2ICsyOTksMjEgQEAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRo OjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+ IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQogewogICAgIFBh dGggcGF0aDsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGJvb2wgaGFzSW5s aW5lRGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc0lubGluZURhdGEpKQorICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKGhhc0lubGluZURhdGEpIHsKKyAgICAg ICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YSkpCisgICAgICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHsgV1RGTW92ZShwYXRoKSB9OworICAgIH0KKyNl bmRpZgorCiAgICAgdWludDY0X3QgbnVtUG9pbnRzOwogICAgIGlmICghZGVjb2Rlci5kZWNvZGUo bnVtUG9pbnRzKSkKICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKQEAgLTMzNiw5ICszNzQs MTcgQEAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aD4gUGF0aDo6ZGVjb2Rl KERlY29kZXImIGRlY29kZXIpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gcGF0aDsK KyAgICByZXR1cm4geyBXVEZNb3ZlKHBhdGgpIH07CiB9CiAKK3RlbXBsYXRlIDx0eXBlbmFtZSBE YXRhVHlwZT4gYm9vbCBQYXRoOjpoYXNJbmxpbmVEYXRhKCkgY29uc3QKK3sKKyAgICByZXR1cm4g V1RGOjpob2xkc19hbHRlcm5hdGl2ZTxEYXRhVHlwZT4obV9pbmxpbmVEYXRhKTsKIH0KIAotI2Vu ZGlmCitib29sIFBhdGg6Omhhc0FueUlubGluZURhdGEoKSBjb25zdAoreworICAgIHJldHVybiAh aGFzSW5saW5lRGF0YTxNb25vc3RhdGU+KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhD YWlyby5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fp cm8uY3BwCmluZGV4IGUxYjU1NGM4ODRjMTUyZDVhOThiMDRhOTdjYTQ3NzNmNTQ3Mzg2M2IuLjM2 ZjMxNzRlZmZjZGZjOTQ5NzFiOGM0NzQ3MDA5NGMwMjJiODRkZjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcApAQCAtNDU1 LDYgKzQ1NSwxNiBAQCB2b2lkIFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0m IHRyYW5zZm9ybSkKICAgICBjYWlyb190cmFuc2Zvcm0oY3IsICZtYXRyaXgpOwogfQogCitib29s IFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGg7Cit9CisKK0NhaXJv UGF0aCogUGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKCkKK3sKKyAgICByZXR1cm4gbmV3IENhaXJv UGF0aDsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJP KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENH LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKaW5k ZXggNTIxYzE1NTNhOWE2YTM0YTM4MWMzNGY5Nzg2MjU0ZGQ1ZjBjNzI2ZS4uOTQ1ODcyYTM0MjFj NzA1YjgzYzRjNWQzOGFiMWEyNDNhNTg1ZDQyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCkBAIC04MSw2ICs4MSwzMCBAQCBQYXRoIFBhdGg6 OnBvbHlnb25QYXRoRnJvbVBvaW50cyhjb25zdCBWZWN0b3I8RmxvYXRQb2ludD4mIHBvaW50cykK ICAgICByZXR1cm4gcGF0aDsKIH0KIAorUmV0YWluUHRyPENHTXV0YWJsZVBhdGhSZWY+IFBhdGg6 OmNyZWF0ZVBsYXRmb3JtUGF0aCgpCit7CisgICAgcmV0dXJuIGFkb3B0Q0YoQ0dQYXRoQ3JlYXRl TXV0YWJsZSgpKTsKK30KKwordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhEYXRhKGNvbnN0IElu bGluZVBhdGhEYXRhJiBkYXRhLCBDR011dGFibGVQYXRoUmVmIHBhdGgpCit7CisgICAgV1RGOjpz d2l0Y2hPbihkYXRhLAorICAgICAgICBbJl0oYXV0bykgeyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsg fSwKKyAgICAgICAgWyZdKGNvbnN0IE1vdmVEYXRhJiBtb3ZlKSB7CisgICAgICAgICAgICBDR1Bh dGhNb3ZlVG9Qb2ludChwYXRoLCBudWxscHRyLCBtb3ZlLmxvY2F0aW9uLngoKSwgbW92ZS5sb2Nh dGlvbi55KCkpOworICAgICAgICB9LAorICAgICAgICBbJl0oY29uc3QgTGluZURhdGEmIGxpbmUp IHsKKyAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgsIG51bGxwdHIsIGxpbmUuc3Rh cnQueCgpLCBsaW5lLnN0YXJ0LnkoKSk7CisgICAgICAgICAgICBDR1BhdGhBZGRMaW5lVG9Qb2lu dChwYXRoLCBudWxscHRyLCBsaW5lLmVuZC54KCksIGxpbmUuZW5kLnkoKSk7CisgICAgICAgIH0s CisgICAgICAgIFsmXShjb25zdCBBcmNEYXRhJiBhcmMpIHsKKyAgICAgICAgICAgIGlmIChhcmMu aGFzT2Zmc2V0KQorICAgICAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgsIG51bGxw dHIsIGFyYy5vZmZzZXQueCgpLCBhcmMub2Zmc2V0LnkoKSk7CisgICAgICAgICAgICBDR1BhdGhB ZGRBcmMocGF0aCwgbnVsbHB0ciwgYXJjLmNlbnRlci54KCksIGFyYy5jZW50ZXIueSgpLCBhcmMu cmFkaXVzLCBhcmMuc3RhcnQsIGFyYy5lbmQsIGFyYy5jbG9ja3dpc2UpOworICAgICAgICB9Cisg ICAgKTsKK30KKwogUGF0aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4mJiBwYXRo KQogICAgIDogbV9wYXRoKFdURk1vdmUocGF0aCkpCiB7CkBAIC04OSw2ICsxMTMsMTIgQEAgUGF0 aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4mJiBwYXRoKQogUGF0aDo6UGF0aCgp ID0gZGVmYXVsdDsKIFBhdGg6On5QYXRoKCkgPSBkZWZhdWx0OwogCitQbGF0Zm9ybVBhdGhQdHIg UGF0aDo6cGxhdGZvcm1QYXRoKCkgY29uc3QKK3sKKyAgICBhcHBseUlubGluZVBhdGhEYXRhSWZO ZWVkZWQoKTsKKyAgICByZXR1cm4gbV9wYXRoLmdldCgpOworfQorCiBQbGF0Zm9ybVBhdGhQdHIg UGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkKIHsKICAgICBpZiAoIW1fcGF0aCkKQEAgLTk4LDEy ICsxMjgsMjEgQEAgUGxhdGZvcm1QYXRoUHRyIFBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCgpCiAg ICAgICAgICAgICBtX3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5KG1fcGF0 aC5nZXQoKSkpOwogICAgICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKICAg ICB9CisgICAgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkKCk7CisgICAgbV9pbmxpbmVEYXRh ID0gTW9ub3N0YXRlIHsgfTsKICAgICByZXR1cm4gbV9wYXRoLmdldCgpOwogfQogCitib29sIFBh dGg6OmlzTnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGggJiYgIWhhc0FueUlubGlu ZURhdGEoKTsKK30KKwogUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIHsKICAgICBtX3Bh dGggPSB7IG90aGVyLm1fcGF0aCB9OworICAgIG1faW5saW5lRGF0YSA9IG90aGVyLm1faW5saW5l RGF0YTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBvdGhlci5tX25lZWRzVG9BcHBs eUlubGluZURhdGE7CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAgICBtX2NvcHlQYXRoQmVmb3Jl TXV0YXRpb24gPSB0cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24g PSB0cnVlOwpAQCAtMTEyLDYgKzE1MSw4IEBAIFBhdGg6OlBhdGgoY29uc3QgUGF0aCYgb3RoZXIp CiAKIFBhdGg6OlBhdGgoUGF0aCYmIG90aGVyKQogICAgIDogbV9wYXRoKHN0ZDo6ZXhjaGFuZ2Uo b3RoZXIubV9wYXRoLCBudWxscHRyKSkKKyAgICAsIG1faW5saW5lRGF0YShzdGQ6OmV4Y2hhbmdl KG90aGVyLm1faW5saW5lRGF0YSwgTW9ub3N0YXRlIHsgfSkpCisgICAgLCBtX25lZWRzVG9BcHBs eUlubGluZURhdGEoc3RkOjpleGNoYW5nZShvdGhlci5tX25lZWRzVG9BcHBseUlubGluZURhdGEs IGZhbHNlKSkKICAgICAsIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbihzdGQ6OmV4Y2hhbmdlKG90 aGVyLm1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiwgZmFsc2UpKQogewogfQpAQCAtMTE5LDYgKzE2 MCw4IEBAIFBhdGg6OlBhdGgoUGF0aCYmIG90aGVyKQogdm9pZCBQYXRoOjpzd2FwKFBhdGgmIG90 aGVyUGF0aCkKIHsKICAgICBzdGQ6OnN3YXAobV9wYXRoLCBvdGhlclBhdGgubV9wYXRoKTsKKyAg ICBzdGQ6OnN3YXAobV9pbmxpbmVEYXRhLCBvdGhlclBhdGgubV9pbmxpbmVEYXRhKTsKKyAgICBz dGQ6OnN3YXAobV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBvdGhlclBhdGgubV9uZWVkc1RvQXBw bHlJbmxpbmVEYXRhKTsKICAgICBzdGQ6OnN3YXAobV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBv dGhlclBhdGgubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKTsKIH0KIApAQCAtMTc5LDcgKzIyMiw3 IEBAIGJvb2wgUGF0aDo6Y29udGFpbnMoY29uc3QgRmxvYXRQb2ludCAmcG9pbnQsIFdpbmRSdWxl IHJ1bGUpIGNvbnN0CiAgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIC8vIENHUGF0aENvbnRh aW5zUG9pbnQgcmV0dXJucyBmYWxzZSBmb3Igbm9uLWNsb3NlZCBwYXRocywgYXMgYSB3b3JrLWFy b3VuZCwgd2UgY29weSBhbmQgY2xvc2UgdGhlIHBhdGggZmlyc3QuICBSYWRhciA0NzU4OTk4IGFz a3MgZm9yIGEgYmV0dGVyIENHIEFQSSB0byB1c2UKLSAgICBhdXRvIHBhdGggPSBhZG9wdENGKGNv cHlDR1BhdGhDbG9zaW5nU3VicGF0aHMobV9wYXRoLmdldCgpKSk7CisgICAgYXV0byBwYXRoID0g YWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhzKHBsYXRmb3JtUGF0aCgpKSk7CiAgICAg Ym9vbCByZXQgPSBDR1BhdGhDb250YWluc1BvaW50KHBhdGguZ2V0KCksIDAsIHBvaW50LCBydWxl ID09IFdpbmRSdWxlOjpFdmVuT2RkID8gdHJ1ZSA6IGZhbHNlKTsKICAgICByZXR1cm4gcmV0Owog fQpAQCAtMjE3LDkgKzI2MCw5IEBAIHZvaWQgUGF0aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRy YW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIENHQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybUNHID0g dHJhbnNmb3JtOwogI2lmIFBMQVRGT1JNKFdJTikKICAgICBhdXRvIHBhdGggPSBhZG9wdENGKENH UGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgQ0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJh bnNmb3JtQ0csIG1fcGF0aC5nZXQoKSk7CisgICAgQ0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAm dHJhbnNmb3JtQ0csIGVuc3VyZVBsYXRmb3JtUGF0aCgpKTsKICNlbHNlCi0gICAgYXV0byBwYXRo ID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weUJ5VHJhbnNmb3JtaW5nUGF0aChtX3Bh dGguZ2V0KCksICZ0cmFuc2Zvcm1DRykpOworICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRo Q3JlYXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgoZW5zdXJlUGxhdGZvcm1QYXRoKCks ICZ0cmFuc2Zvcm1DRykpOwogI2VuZGlmCiAgICAgbV9wYXRoID0gV1RGTW92ZShwYXRoKTsKICAg ICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKQEAgLTIzMCw5ICsyNzMsMTkgQEAg RmxvYXRSZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgpIGNvbnN0CiAgICAgaWYgKGlzTnVsbCgpKQog ICAgICAgICByZXR1cm4gQ0dSZWN0WmVybzsKIAorICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVE YXRhPigpKQorICAgICAgICByZXR1cm4geyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGlu ZURhdGE+KCkpIHsKKyAgICAgICAgRmxvYXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGlu ZSA9IFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0 VG9Qb2ludHMobGluZS5zdGFydCwgbGluZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0Owor ICAgIH0KKwogICAgIC8vIENHUGF0aEdldEJvdW5kaW5nQm94IGluY2x1ZGVzIHRoZSBwYXRoJ3Mg Y29udHJvbCBwb2ludHMsIENHUGF0aEdldFBhdGhCb3VuZGluZ0JveCBkb2VzIG5vdC4KIAotICAg IENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChtX3BhdGguZ2V0KCkpOwor ICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChwbGF0Zm9ybVBhdGgo KSk7CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7 CiB9CiAKQEAgLTI0MCw3ICsyOTMsMTggQEAgRmxvYXRSZWN0IFBhdGg6OmZhc3RCb3VuZGluZ1Jl Y3QoKSBjb25zdAogewogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuIENHUmVjdFpl cm87Ci0gICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0Qm91bmRpbmdCb3gobV9wYXRoLmdldCgp KTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4g eyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGluZURhdGE+KCkpIHsKKyAgICAgICAgRmxv YXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGluZSA9IFdURjo6Z2V0PExpbmVEYXRhPiht X2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0VG9Qb2ludHMobGluZS5zdGFydCwgbGlu ZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKworICAgIENHUmVjdCBib3Vu ZCA9IENHUGF0aEdldEJvdW5kaW5nQm94KHBsYXRmb3JtUGF0aCgpKTsKICAgICByZXR1cm4gQ0dS ZWN0SXNOdWxsKGJvdW5kKSA/IENHUmVjdFplcm8gOiBib3VuZDsKIH0KIApAQCAtMjY5LDExICsz MzMsMjMgQEAgRmxvYXRSZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5nUmVjdChTdHJva2VTdHlsZUFw cGxpZXIqIGFwcGxpZXIpIGNvbnN0CiAKIHZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9p bnQmIHBvaW50KQogeworICAgIGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRh PigpKSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9IE1vdmVEYXRhIHsgcG9pbnQgfTsKKyAgICAg ICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKwogICAgIENHUGF0aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRy LCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9CiAKIHZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0 IEZsb2F0UG9pbnQmIHApCiB7CisgICAgaWYgKGlzTnVsbCgpIHx8IGhhc0lubGluZURhdGE8TW92 ZURhdGE+KCkpIHsKKyAgICAgICAgbV9pbmxpbmVEYXRhID0gTGluZURhdGEgeyBoYXNBbnlJbmxp bmVEYXRhKCkgPyBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2NhdGlvbiA6IEZs b2F0UG9pbnQoKSwgcCB9OworICAgICAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSB0cnVl OworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5z dXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSk7CiB9CiAKQEAgLTM1Niw2 ICs0MzIsMTIgQEAgdm9pZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQb2ludCYgcCwgZmxvYXQg cmFkaXVzLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmQKICAgICBpZiAoIXN0ZDo6aXNmaW5p dGUoc3RhcnRBbmdsZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUpKQogICAgICAgICByZXR1 cm47CiAKKyAgICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkgewor ICAgICAgICBtX2lubGluZURhdGEgPSBBcmNEYXRhIHsgaGFzQW55SW5saW5lRGF0YSgpID8gV1RG OjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb24gOiBGbG9hdFBvaW50KCksIHAs IHJhZGl1cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGNsb2Nrd2lzZSwgaGFzQW55SW5saW5lRGF0 YSgpIH07CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhBZGRBcmMoZW5zdXJlUGxhdGZvcm1QYXRoKCks IG51bGxwdHIsIHAueCgpLCBwLnkoKSwgcmFkaXVzLCBzdGFydEFuZ2xlLCBlbmRBbmdsZSwgY2xv Y2t3aXNlKTsKIH0KIApAQCAtNDAyLDI1ICs0ODQsNDAgQEAgdm9pZCBQYXRoOjpjbGVhcigpCiAg ICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX3BhdGggPSBhZG9wdENG KENHUGF0aENyZWF0ZU11dGFibGUoKSk7CisgICAgbV9wYXRoLmNsZWFyKCk7CisgICAgbV9pbmxp bmVEYXRhID0gTW9ub3N0YXRlIHsgfTsKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBm YWxzZTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKIH0KIAogYm9vbCBQ YXRoOjppc0VtcHR5KCkgY29uc3QKIHsKLSAgICByZXR1cm4gaXNOdWxsKCkgfHwgQ0dQYXRoSXNF bXB0eShtX3BhdGguZ2V0KCkpOworICAgIGlmIChpc051bGwoKSkKKyAgICAgICAgcmV0dXJuIHRy dWU7CisKKyAgICBpZiAoaGFzQW55SW5saW5lRGF0YSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7 CisKKyAgICByZXR1cm4gQ0dQYXRoSXNFbXB0eShtX3BhdGguZ2V0KCkpOwogfQogCiBib29sIFBh dGg6Omhhc0N1cnJlbnRQb2ludCgpIGNvbnN0CiB7CiAgICAgcmV0dXJuICFpc0VtcHR5KCk7CiB9 Ci0gICAgCi1GbG9hdFBvaW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0IAorCitGbG9hdFBv aW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0CiB7CiAgICAgaWYgKGlzTnVsbCgpKQotICAg ICAgICByZXR1cm4gRmxvYXRQb2ludCgpOwotICAgIHJldHVybiBDR1BhdGhHZXRDdXJyZW50UG9p bnQobV9wYXRoLmdldCgpKTsKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAgIGlmIChoYXNJbmxp bmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4gV1RGOjpnZXQ8TW92ZURhdGE+KG1f aW5saW5lRGF0YSkubG9jYXRpb247CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4o KSkKKyAgICAgICAgcmV0dXJuIFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpLmVuZDsK KworICAgIHJldHVybiBDR1BhdGhHZXRDdXJyZW50UG9pbnQocGxhdGZvcm1QYXRoKCkpOwogfQog CiBzdGF0aWMgdm9pZCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcih2b2lkKiBpbmZvLCBjb25z dCBDR1BhdGhFbGVtZW50KiBlbGVtZW50KQpAQCAtNDU0LDE0ICs1NTEsNDAgQEAgdm9pZCBQYXRo OjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9uJiBmdW5jdGlvbikgY29uc3QKICAgICBp ZiAoaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIENHUGF0aEFwcGx5KG1fcGF0aC5n ZXQoKSwgKHZvaWQqKSZmdW5jdGlvbiwgQ0dQYXRoQXBwbGllclRvUGF0aEFwcGxpZXIpOworICAg IGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKSB7CisgICAgICAgIFBhdGhFbGVtZW50IGVs ZW1lbnQ7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpUeXBlOjpNb3ZlVG9Q b2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBXVEY6OmdldDxNb3ZlRGF0YT4obV9p bmxpbmVEYXRhKS5sb2NhdGlvbjsKKyAgICAgICAgZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4oKSkgewor ICAgICAgICBhdXRvJiBsaW5lID0gV1RGOjpnZXQ8TGluZURhdGE+KG1faW5saW5lRGF0YSk7Cisg ICAgICAgIFBhdGhFbGVtZW50IGVsZW1lbnQ7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhF bGVtZW50OjpUeXBlOjpNb3ZlVG9Qb2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBs aW5lLnN0YXJ0OworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAgICAgZWxlbWVudC50 eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6OkFkZExpbmVUb1BvaW50OworICAgICAgICBlbGVtZW50 LnBvaW50c1swXSA9IGxpbmUuZW5kOworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIENHUGF0aEFwcGx5KHBsYXRmb3JtUGF0aCgpLCAodm9p ZCopJmZ1bmN0aW9uLCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcik7CiB9CiAKICNpZiBIQVZF KENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQogCiBzaXplX3QgUGF0aDo6ZWxlbWVudENv dW50KCkgY29uc3QKIHsKLSAgICByZXR1cm4gQ0dQYXRoR2V0TnVtYmVyT2ZFbGVtZW50cyhtX3Bh dGgpOworICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4g MTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKQorICAgICAgICByZXR1cm4g MjsKKworICAgIHJldHVybiBDR1BhdGhHZXROdW1iZXJPZkVsZW1lbnRzKHBsYXRmb3JtUGF0aCgp KTsKIH0KIAogI2VuZGlmIC8vIEhBVkUoQ0dQQVRIX0dFVF9OVU1CRVJfT0ZfRUxFTUVOVFMpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMv RGlzcGxheUxpc3RJdGVtcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9k aXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKaW5kZXggZDQ1MzFiYWI1Y2E0NGNlYmNh Zjk1YWFmZTc1MDMyZjQzOWFiOGFkNy4uZTIyNjE3MDNlNGJjMGI5YWFmNTA1M2IzNDdhOGZjOGYw MTA5YTQ3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlz cGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcApAQCAtMTIyOCw3 ICsxMjI4LDcgQEAgT3B0aW9uYWw8RmxvYXRSZWN0PiBTdHJva2VQYXRoOjpsb2NhbEJvdW5kcyhj b25zdCBHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNvbnMKIAogdm9pZCBTdHJva2VQYXRoOjph cHBseShHcmFwaGljc0NvbnRleHQmIGNvbnRleHQpIGNvbnN0CiB7Ci0gICAgY29udGV4dC5zdHJv a2VQYXRoKG1fcGF0aCk7CisgICAgY29udGV4dC5zdHJva2VQYXRoKFdURk1vdmUobV9wYXRoKSk7 CiB9CiAKIHN0YXRpYyBUZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFRleHRTdHJlYW0mIHRzLCBjb25z dCBTdHJva2VQYXRoJiBpdGVtKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKaW5kZXgg Nzc0MjA1YWM3M2Y2MjcxNGUzY2ZhOTBlMDIyY2U1Yzc3MDgyOGYyYi4uYjkwZWQyMDlkMWQxOTM3 YjMyNjczN2Y5NmM1OWI5MTZkYjcyZTgzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVt cy5oCkBAIC0yNTg5LDcgKzI1ODksNyBAQCBwcml2YXRlOgogICAgIHZvaWQgYXBwbHkoR3JhcGhp Y3NDb250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAgICAgT3B0aW9uYWw8RmxvYXRSZWN0PiBsb2Nh bEJvdW5kcyhjb25zdCBHcmFwaGljc0NvbnRleHQmKSBjb25zdCBvdmVycmlkZTsKIAotICAgIGNv bnN0IFBhdGggbV9wYXRoOworICAgIG11dGFibGUgUGF0aCBtX3BhdGg7CiB9OwogCiB0ZW1wbGF0 ZTxjbGFzcyBFbmNvZGVyPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy93aW4vUGF0aERpcmVjdDJELmNwcAppbmRleCBmZjYzMDE0Mzk0MDRmMDdmYTcwZjhhM2M2 NDdhNThkMWI0Y2JiZDY1Li5kZDRjNjdkZjYxYTg4M2I1ZGMwMTQyODUxNTM4ZmUzYTFhMjVjMWMz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0aERp cmVjdDJELmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0 aERpcmVjdDJELmNwcApAQCAtNjc2LDYgKzY3NiwyMSBAQCB2b2lkIFBhdGg6OmFwcGx5KGNvbnN0 IFBhdGhBcHBsaWVyRnVuY3Rpb24mIGZ1bmN0aW9uKSBjb25zdAogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcGF0 aDsKK30KKworQ09NUHRyPElEMkQxR2VvbWV0cnlHcm91cD4gUGF0aDo6Y3JlYXRlUGxhdGZvcm1Q YXRoKCkKK3sKKyAgICBDT01QdHI8SUQyRDFHZW9tZXRyeUdyb3VwPiBwYXRoOworICAgIEhSRVNV TFQgaHIgPSBHcmFwaGljc0NvbnRleHQ6OnN5c3RlbUZhY3RvcnkoKS0+Q3JlYXRlR2VvbWV0cnlH cm91cChEMkQxX0ZJTExfTU9ERV9XSU5ESU5HLCBudWxscHRyLCAwLCAmcGF0aCk7CisgICAgQVNT RVJUKFNVQ0NFRURFRChocikpOworICAgIGlmIChGQUlMRUQoaHIpKQorICAgICAgICByZXR1cm4g bnVsbHB0cjsKKyAgICByZXR1cm4gcGF0aDsKK30KKwogfQogCiAjZW5kaWYgLy8gVVNFKERJUkVD VDJEKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2Rl cnMuY3BwIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuY3BwCmlu ZGV4IDc2ZDJiMDlkYWJmMTE0YzM5YzY0NmFlMzE2MzdmYTIwMTYxZmRiM2YuLjE4ZTk1MTc2NTQ3 N2VhMzRlYmM1NWNmNTAyODQ1ZjVkNDk4NzIzYTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv UGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRm b3JtL0lQQy9Bcmd1bWVudENvZGVycy5jcHAKQEAgLTIwNSw0ICsyMDUsMTMgQEAgYm9vbCBBcmd1 bWVudENvZGVyPGF1ZGl0X3Rva2VuX3Q+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlciwgYXVkaXRf dG9rZW5fdCYgYXVkaXQKIH0KICNlbmRpZgogCit2b2lkIEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRl Pjo6ZW5jb2RlKEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKQoreworfQorCitPcHRpb25hbDxN b25vc3RhdGU+IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZGVjb2RlKERlY29kZXImIGRlY29k ZXIpCit7CisgICAgcmV0dXJuIE1vbm9zdGF0ZSB7IH07Cit9CisKIH0gLy8gbmFtZXNwYWNlIElQ QwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMu aCBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmgKaW5kZXggNThj NDU2NDY4OGM4ZjNmMmVhYzFhYzQ3MDE4MmI4NWFmYWRmYzY2NC4uZTdiMjZmNDU1NmZhNGQzMmY1 ZjZmYmRlOWY1YWRmZGM5ZjFmYWM5YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9y bS9JUEMvQXJndW1lbnRDb2RlcnMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9B cmd1bWVudENvZGVycy5oCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSA8d3RmL01vbm90b25p Y1RpbWUuaD4KICNpbmNsdWRlIDx3dGYvU0hBMS5oPgogI2luY2x1ZGUgPHd0Zi9VbmV4cGVjdGVk Lmg+CisjaW5jbHVkZSA8d3RmL1ZhcmlhbnQuaD4KICNpbmNsdWRlIDx3dGYvV2FsbFRpbWUuaD4K IAogbmFtZXNwYWNlIElQQyB7CkBAIC02OTEsNCArNjkyLDkgQEAgdGVtcGxhdGU8PiBzdHJ1Y3Qg QXJndW1lbnRDb2RlcjxhdWRpdF90b2tlbl90PiB7CiB9OwogI2VuZGlmCiAKK3RlbXBsYXRlPD4g c3RydWN0IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPiB7CisgICAgc3RhdGljIHZvaWQgZW5jb2Rl KEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKTsKKyAgICBzdGF0aWMgT3B0aW9uYWw8TW9ub3N0 YXRlPiBkZWNvZGUoRGVjb2RlciYpOworfTsKKwogfSAvLyBuYW1lc3BhY2UgSVBDCg== 392924 2020-03-07 18:19:24 -0800 2020-03-07 19:20:07 -0800 v3 (fix GTK/WPE builds) bug-208464-20200307181924.patch text/plain 37133 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDkxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNlYjg0YzRhMTNhNTFmNzlkODIwZDc0 YjNhOGVkNmIwOTg5NDkyOGEuLjcwYmZlMTQ5YmJiYTAxYjc2MjEwZmQwOWZhYmVmNjdlYTlhMjg3 ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGZlYXR1cmUgZmxhZyBmb3IgSU5MSU5FX1BBVEhf REFUQS4gVGhpcyBmZWF0dXJlIGZsYWcgZXhpc3RzIHRvIGVuc3VyZSB0aGF0IHdlIGNhbiBhdm9p ZCBoYXZpbmcKKyAgICAgICAgbV9pbmxpbmVEYXRhIG9uIFBhdGggaW4gcG9ydHMgdGhhdCBkb24n dCBpbXBsZW1lbnQgdGhlIG5lY2Vzc2FyeSBmYWNpbGl0aWVzIGZvciBpbmxpbmUgcGF0aCBkYXRh IHlldCwgc2luY2UgaXQKKyAgICAgICAgd291bGQganVzdCBlbmQgdXAgYmVpbmcgd2FzdGVkIG1l bW9yeS4KKworICAgICAgICAqIHd0Zi9QbGF0Zm9ybUVuYWJsZS5oOgorCiAyMDIwLTAzLTA3ICBE YW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbaU9TXSBJbXBsZW1l bnQgc3VwcG9ydCBmb3IgZGljdGF0aW9uIGFsdGVybmF0aXZlcwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDA0YjE3 NDQ0MjVhNzY0YjIzMDUwZWI3YjhiNDM0ZjM4YzhhNjRiODguLmQ4M2U0ODA0NmVjYzAzNzU3ODli Y2Q4YzExNWMwYzVkOGIyMWY2MGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNDQgQEAKKzIwMjAt MDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg TGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBz dWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdoZW4gdGhl IEdQVSBwcm9jZXNzIGlzIGVuYWJsZWQgYW5kIHVzZWQgdG8gcmVuZGVyIHRoZSBjYW52YXMgZWxl bWVudCwgc29tZSBjYW52YXMtcmVsYXRlZCBzdWJ0ZXN0cyBpbgorICAgICAgICBNb3Rpb25NYXJr IHNlZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNzaW9ucy4gT25lIG9mIHRoZSByZWFz b25zIGZvciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mgb2YKKyAgICAgICAgZGVjb2Rpbmcg ZGlzcGxheSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2ViQ29yZTo6UGF0aGBzIGluIHRoZSBH UFUgcHJvY2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBuZXcgQ0dQYXRoCisgICAgICAgIGZv ciBlYWNoIFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNhbGx5IGluY3JlYXNlcyBwYWdlIGRl bWFuZCBhbmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJvY2VzcyBpbiBjb250cmFzdAorICAg ICAgICB0byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUgZmFjdCB0aGF0IGFsbCBvZiB0aGVz ZSBDR1BhdGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11c3QgYWxsIGV4aXN0IHNvbWV3aGVy ZQorICAgICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5nIHRoZSBkaXNwbGF5IGxpc3QuCisK KyAgICAgICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdlYktpdCwgZWFjaCBjYWxsIHRvIHN0 cm9rZSB0aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBpbnZva2luZworICAgICAgICBHcmFw aGljc0NvbnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRlZCBieSBjbGVhcmluZyB0aGUgcGF0 aCwgd2hpY2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlCisgICAg ICAgIFBhdGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVlZHMgdG8gYmUgY3JlYXRlZCwgQ29y ZUdyYXBoaWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0aGUgbmV3IENHUGF0aCBhdCB0aGUK KyAgICAgICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQYXRoIHdoaWNoIHdhcyBqdXN0IGRl c3Ryb3llZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0eWluZyBtb3JlIHBhZ2VzIHRoYW4K KyAgICAgICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24gYWZmZWN0cyBtb3N0IG9mIHRoZSBj YW52YXMtcmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRvIHNvbWUgZGVncmVlLCB0aG91Z2gg dGhlCisgICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFibGUgd2l0aCBDYW52YXMgTGluZXMu CisKKyAgICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNpZ25pZmljYW50IHBvcnRpb24gb2Yg dGltZSBpcyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBwbHkgYW5kIGNvbnZlcnRpbmcgdGhl IHJlc3VsdGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBpbnRvIHNlcmlhbGl6YWJsZSBkYXRh IHdoZW4gZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisKKyAgICAgICAgVG8gbWl0aWdhdGUg dGhlc2UgdHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lucyB3ZSBnZXQgZnJvbSBtZW1vcnkg bG9jYWxpdHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdlCisgICAgICAgIHF1YW50aXRpZXMs IHdlIGNhbjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ugb2Ygc2ltcGxlIHBhdGhzLCBzdHVm ZiBzb21lIGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBhdGggd2FzIGNyZWF0ZWQgYXMgaW5s aW5lIGRhdGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBhdGggaXRzZWxmLCBhcyBhIG5ldyBk YXRhIG1lbWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29tcGFzc2VzIGxpbmVzLCBhcmNzLCBh bmQgbW92ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBvbmx5IGBQYXRoOjptb3ZlVG9gIHdh cyBpbnZva2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGluY2x1ZGUg ZWxsaXBzZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhpcyBhbGxvd3MgdXMgdG8gYWNoaWV2 ZSB0d28gdGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVhcGVyIGJ5IG5vdCByZXF1aXJpbmcg YSB3YWxrIHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBDR1BhdGgncyBlbGVtZW50cywgYW5k IChiKSBtYWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBpbml0aWFsaXppbmcgdGhlIFBhdGgg dXNpbmcgaW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBoYXZpbmcgdG8gY3Jl YXRlIGEgbmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hlbiBwYWludGluZyB0aGUgU3Ryb2tl UGF0aCBkaXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJkIGBtX3BhdGhgIGFmdGVyIHdlJ3Jl IGRvbmUgcGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAgIFRoaXMsIGluIGNvbmp1bmN0aW9u IHdpdGggKDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZTo6UGF0 aCBpbiB0aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAgICAgICAgY3JlYXRlZCB3aGVuIHdl J3JlIGp1c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBjYWxsaW5nIGludG8gc3Ryb2tlUGF0 aCgpKSwgYW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAgICAgICAgICAgd2UncmUgZG9uZSBw YWludGluZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxvdyBmb3IgZGV0YWlscy4gVGhlcmUg c2hvdWxkIGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKworICAgICAgICAqIFdlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9Jbmxp bmVQYXRoRGF0YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Ok1vdmVEYXRhOjplbmNvZGUg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6TW92ZURhdGE6OmRlY29kZSk6CisgICAgICAgIChX ZWJDb3JlOjpMaW5lRGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkxpbmVE YXRhOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXJjRGF0YTo6ZW5jb2RlIGNvbnN0KToK KyAgICAgICAgKFdlYkNvcmU6OkFyY0RhdGE6OmRlY29kZSk6CisKKyAgICAgICAgSW50cm9kdWNl IElubGluZVBhdGhEYXRhLCBhIFZhcmlhbnQgb2Ygc2V2ZXJhbCBkaWZmZXJlbnQgaW5saW5lIGRh dGEgdHlwZXMsIGVhY2ggb2Ygd2hpY2ggcmVwcmVzZW50cyBvbmUgc2ltcGxlCisgICAgICAgIHBh dGggdHlwZSB0aGF0IGlzIHN0b3JlZCB1c2luZyBvbmx5IGlubGluZSBkYXRhLiBUaGlzIGluY2x1 ZGVzIGxpbmUgc2VnbWVudHMgKGEgc3RhcnQgcG9pbnQgYW5kIGFuIGVuZCBwb2ludCksCisgICAg ICAgIGFzIHdlbGwgYXMgYXJjcyAod2hpY2gsIGluIGFkZGl0aW9uIHRvIGEgY2VudGVyIGFuZCBz dGFydCBhbmQgZW5kIGFuZ2xlcykgYWxzbyBpbmNsdWRlcyBhbiBvcHRpb25hbCBvZmZzZXQsCisg ICAgICAgIHdoaWNoIHJlcHJlc2VudHMgdGhlIGN1cnJlbnQgcG9zaXRpb24gb2YgdGhlIHBhdGgg YXQgdGhlIHRpbWUgImFkZEFyYyIgd2FzIGNhbGxlZC4KKworICAgICAgICBGb3IgaW5zdGFuY2Us IGluIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW8sIHRoZSBwYXRoIHdvdWxkIGhhdmUgYW4gYXJjIHRo YXQgaXMgb2Zmc2V0IGJ5ICgxMDAsIDApOyBpZiBmaWxsZWQsIGl0CisgICAgICAgIHdvdWxkIHJl c3VsdCBpbiBhIGNvbXBvc2l0ZSBzaGFwZSByZXNlbWJsaW5nIGEgc2VtaWNpcmNsZSBvbiB0b3Ag b2YgYSB0cmlhbmdsZToKKworICAgICAgICBwYXRoLm1vdmVUbygxMDAsIDApOworICAgICAgICBw YXRoLmFkZEFyYygxMDAsIDEwMCwgNTAsIDAsIFBJLCBmYWxzZSk7CisgICAgICAgIGNvbnRleHQu ZmlsbChwYXRoKTsKKworICAgICAgICBXaGVuIGEgUGF0aCBpcyBpbml0aWFsaXplZCAob3IgYWZ0 ZXIgaXQgaXMgY2xlYXJlZCksIGl0IHN0YXJ0cyBvZmYgd2l0aCBuZWl0aGVyIGEgQ0dQYXRoIG5v ciBpbmxpbmUgZGF0YS4gTW92aW5nCisgICAgICAgIHRoZSBwYXRoIGNhdXNlcyBpdCB0byBzdG9y ZSBpbmxpbmUgTW92ZURhdGE7IGNhbGxpbmcgY2FsbGluZyBgYWRkTGluZVRvYCBvciBgYWRkQXJj YCB0aGVuIHJlcGxhY2VzIHRoZSBpbmxpbmUKKyAgICAgICAgZGF0YSB3aXRoIGVpdGhlciBMaW5l RGF0YSBvciBBcmNEYXRhLgorCisgICAgICAgIElmLCBhdCBhbnkgcG9pbnQsIHRoZSBwYXRoIGNo YW5nZXMgaW4gYSBkaWZmZXJlbnQgd2F5IChpLmUuIG5laXRoZXIgbGluZSwgYXJjLCBub3IgbW92 ZSksIHdlIGNsZWFyIG91dCB0aGUKKyAgICAgICAgaW5saW5lIGRhdGEgYW5kIGZhbGwgYmFjayB0 byBqdXN0IHJlcHJlc2VudGluZyB0aGUgcGF0aCBkYXRhIHVzaW5nIHRoZSBDR1BhdGggKG1fcGF0 aCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCBjb25zdCk6CisKKyAgICAg ICAgQWRkIGEgaGVscGVyIG1ldGhvZCB0aGF0IGlzIGludm9rZWQgd2hlbiB0aGUgUGF0aCBpcyBh c2tlZCBmb3IgYSBDR1BhdGguIEluIHRoaXMgY2FzZSwgZXZlbiBpZiBtX3BhdGggaXMgbnVsbCwK KyAgICAgICAgd2UgbmVlZCB0byBsYXppbHkgY3JlYXRlIGl0IGFuZCBhcHBseSBhbnkgaW5saW5l IHBhdGggZGF0YSB3ZSd2ZSBhY2N1bXVsYXRlZC4gT25jZSB3ZSdyZSBkb25lIGFwcGx5aW5nIHRo ZQorICAgICAgICBpbmxpbmUgZGF0YSwgc2V0IGEgZmxhZyAobV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhKSB0byBmYWxzZSB0byBhdm9pZCByZS1hcHBseWluZyBpbmxpbmUgZGF0YSB0byB0aGUgcGF0 aC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1BhdGguaDoKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpkZWNvZGUp OgorCisgICAgICAgIFRlYWNoIFBhdGg6OmVuY29kZSBhbmQgUGF0aDo6ZGVjb2RlIHRvIHJlc3Bl Y3RpdmVseSBzZXJpYWxpemUgYW5kIGRlc2VyaWFsaXplIFdlYkNvcmU6OlBhdGggYnkgY29uc3Vs dGluZyBvbmx5CisgICAgICAgIHRoZSBpbmxpbmUgZGF0YSwgaWYgaXQgaXMgcHJlc2VudC4gRm9y IHNpbXBsZSB0eXBlcyBvZiBwYXRocywgdGhpcyBkZWNyZWFzZXMgdGhlIGNvc3Qgb2YgYm90aCBJ UEMgZW5jb2RpbmcgYW5kCisgICAgICAgIGRlY29kaW5nLCBidXQgYWRkcyBhIG5lZ2xpZ2libGUg YW1vdW50IG9mIG92ZXJoZWFkIGluIHRoZSBjYXNlIHdoZXJlIHRoZSBwYXRoIGlzIG5vbi1pbmxp bmUuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0lubGluZURhdGEgY29uc3QpOgorICAg ICAgICAoV2ViQ29yZTo6UGF0aDo6aGFzQW55SW5saW5lRGF0YSBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpp c051bGwgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRo KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmFwcGx5SW5saW5lUGF0aERhdGEpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZv cm1QYXRoIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0 aCk6CisKKyAgICAgICAgV2hlbiBlbnN1cmVQbGF0Zm9ybVBhdGggaXMgaW52b2tlZCwgd2UgYXJl IGFib3V0IHRvIG11dGF0ZSBvdXIgQ0dQYXRoIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBjYW4ndCBi ZSBleHByZXNzZWQKKyAgICAgICAgaW4gdGVybXMgb2YgaW5saW5lIGRhdGEgKGF0IGxlYXN0LCBu b3Qgd2l0aCB0aGUgY2hhbmdlcyBpbiB0aGlzIHBhdGNoKS4gQ2xlYXIgb3V0IHRoZSBpbmxpbmUg cGF0aCBkYXRhIGluIHRoaXMKKyAgICAgICAgY2FzZSwgYW5kIGFwcGx5IHRoZSBDR1BhdGggbXV0 YXRpb25zIHRoYXQgd2VyZSBwcmV2aW91c2x5IHN0YXNoZWQgYXdheSBpbiBpbmxpbmUgcGF0aCBk YXRhLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorCisgICAgICAg IEEgcGF0aCBpcyBub3cgY29uc2lkZXJlZCBudWxsIGlmIGl0IGlzIG5vdCBvbmx5IG1pc3Npbmcg YSBDR1BhdGgsIGJ1dCBhbHNvIGRvZXMgbm90IGhhdmUgYW55IGlubGluZSBwYXRoIGRhdGEuCisg ICAgICAgIFRoaXMgbWFpbnRhaW5zIHRoZSBpbnZhcmlhbnQgdGhhdCBgaXNOdWxsKClgIGlzIHRy dWUgaWZmIHRoZSBgcGxhdGZvcm1QYXRoKClgIHJldHVybnMgMHgwLgorCisgICAgICAgIChXZWJD b3JlOjpQYXRoOjpQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnN3YXApOgorCisgICAg ICAgIFVwZGF0ZSB0aGUgY29uc3RydWN0b3JzIGFuZCBgc3dhcGAgaGVscGVyIG1ldGhvZCAodXNl ZCBieSBhc3NpZ25tZW50IG9wZXJhdG9ycykgdG8gYWNjb3VudCBmb3IgdGhlIG5ldyBtZW1iZXJz LgorCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjb250YWlucyBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjp0cmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRp bmdSZWN0IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3Qg Y29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6bW92ZVRvKToKKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmFkZExpbmVUbyk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmMpOgor CisgICAgICAgIEluIHRoZSBjYXNlIG9mIHRoZXNlIHRocmVlIG1ldGhvZHMgZm9yIG11dGF0aW5n IGEgcGF0aCwgaWYgd2UndmUgZWl0aGVyIG9ubHkgbW92ZWQgdGhlIHBhdGggb3IgaGF2ZW4ndCB0 b3VjaGVkCisgICAgICAgIGl0IGF0IGFsbCwgd2UgY2FuIGdldCBhd2F5IHdpdGggb25seSB1cGRh dGluZyBvdXIgaW5saW5lIHBhdGggZGF0YSwgYW5kIGF2b2lkIGNyZWF0aW5nIGEgQ0dQYXRoLgor CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisKKyAgICAgICAgV2hlbiBjbGVhcmlu ZyBQYXRoLCBpbnN0ZWFkIG9mIHNldHRpbmcgYG1fcGF0aGAgdG8gYSBuZXdseSBhbGxvY2F0ZWQg Q0dQYXRoLCBzaW1wbHkgcmVzZXQgaXQgdG8gbnVsbC4gVGhpcworICAgICAgICBlbnN1cmVzIHRo YXQgaWYgd2UgdGhlbiBhcHBseSBzb21lIGNoYW5nZXMgdGhhdCBjYW4gYmUgZXhwcmVzc2VkIHVz aW5nIG9ubHkgaW5saW5lIHBhdGggZGF0YSwgd2UgYXZvaWQgaGF2aW5nIHRvCisgICAgICAgIHVw ZGF0ZSB0aGUgQ0dQYXRoLCBhbmQgaW5zdGVhZCBqdXN0IHVwZGF0ZSB0aGUgaW5saW5lIHBhdGgg ZGF0YS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6 UGF0aDo6YXBwbHkgY29uc3QpOgorCisgICAgICAgIFRocm93IG91dCB0aGUgY3VycmVudCBXZWJD b3JlOjpQYXRoIGFmdGVyIHdlJ3JlIGRvbmUgcGFpbnRpbmcgd2l0aCBpdCAoc2VlICgyKSBpbiB0 aGUgYWJvdmUgQ2hhbmdlTG9nIGVudHJ5KS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZWxl bWVudENvdW50IGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlz dHMvRGlzcGxheUxpc3RJdGVtcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEaXNwbGF5TGlzdDo6 U3Ryb2tlUGF0aDo6YXBwbHkgY29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3dp bi9QYXRoRGlyZWN0MkQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNOdWxsIGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNyZWF0ZVBsYXRmb3JtUGF0aCk6CisKIDIwMjAt MDMtMDcgIERhbmllbCBCYXRlcyAgPGRhYmF0ZXNAYXBwbGUuY29tPgogCiAgICAgICAgIFtpT1Nd IEltcGxlbWVudCBzdXBwb3J0IGZvciBkaWN0YXRpb24gYWx0ZXJuYXRpdmVzCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4 IDQzNzJiZTY0OThiYzczZjNkMGI4M2RhMzVmN2QwM2JmNmQxNTU3OTcuLmZjMzRkY2VmYzQ1ZmM4 M2FlYmFhNmIxZjAyN2E3MDBjMTE1ODc3YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIw MjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAg ICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhz LCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2 PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBh cmd1bWVudCBjb2RlcnMgZm9yIGBXVEY6Ok1vbm9zdGF0ZWAsIHNvIHRoYXQgVmFyaWFudHMgb2Yg dGhlIGZvcm06IGBWYXJpYW50PE1vbm9zdGF0ZSwgRm9vLCBCYXI+YCBjYW4gYmUKKyAgICAgICAg ZW5jb2RlZCBhbmQgZGVjb2RlZCBvdmVyIElQQy4KKworICAgICAgICAqIFBsYXRmb3JtL0lQQy9B cmd1bWVudENvZGVycy5jcHA6CisgICAgICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8TW9ub3N0YXRl Pjo6ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxNb25vc3RhdGU+OjpkZWNv ZGUpOgorICAgICAgICAqIFBsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5oOgorCiAyMDIwLTAz LTA3ICBQZW5nIExpdSAgPHBlbmcubGl1NkBhcHBsZS5jb20+CiAKICAgICAgICAgVXNlIHRoZSBm ZWF0dXJlIGZsYWdzIG1lY2hhbmlzbSB0byBnaXZlIGRlZmF1bHQgZmVhdHVyZSBwcmVmZXJlbmNl IHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaCBiL1Nv dXJjZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgKaW5kZXggMzg1MWVkYmJkOTQ3NjYxYjI2YmM5 MjZkMzhkM2I3YWRjZmJkZDBjNi4uZDAzMDE5MWE4ZjkwZWMyNGU5MjNiNzdhN2IxNzE0OTBlYmU4 MWZjZSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaAorKysgYi9T b3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5oCkBAIC04MTcsNiArODE3LDkgQEAKICNkZWZp bmUgRU5BQkxFX09QRU5UWVBFX01BVEggMQogI2VuZGlmCiAKKyNpZiAhZGVmaW5lZChFTkFCTEVf SU5MSU5FX1BBVEhfREFUQSkgJiYgVVNFKENHKQorI2RlZmluZSBFTkFCTEVfSU5MSU5FX1BBVEhf REFUQSAxCisjZW5kaWYKIAogLyogRGlzYWJsZSBTaGFyZWRBcnJheUJ1ZmZlcnMgdW50aWwgU3Bl Y3RyZSBzZWN1cml0eSBjb25jZXJucyBhcmUgbWl0aWdhdGVkLiAqLwogI2RlZmluZSBFTkFCTEVf U0hBUkVEX0FSUkFZX0JVRkZFUiAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZDFiMGFmOGU2YzAxZmU4MWNlY2FmYzYyMTQzMGU5 Mjk3ZjlkMjAyYy4uMjViODg3M2EzYzlkNTYzYjE5MTA5NTIzZjEzZjRmMDI1MWNiMjQzYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpA QCAtNDk3Nyw2ICs0OTc3LDcgQEAKIAkJRjQ0MkMzNTkyM0UzQUREMjAwNDk5NTgyIC8qIENvbXBv c2l0aW9uSGlnaGxpZ2h0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGNDQyQzM1NzIzRTNBQzUxMDA0OTk1ODIgLyogQ29tcG9zaXRpb25IaWdobGlnaHQu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDRB NUY1OTFGRUQzOEYyMDA3RjU5NDQgLyogTGVnYWN5TlNQYXN0ZWJvYXJkVHlwZXMuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NEE1RjU3MUZFRDM4MzAw MDdGNTk0NCAvKiBMZWdhY3lOU1Bhc3RlYm9hcmRUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0NEVCQkQ5MURCNUQyMTQwMDI3NzMzNCAv KiBTdGF0aWNSYW5nZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRjQ0RUJCRDgxREI1RDIxNDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggKi87IHNldHRp bmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJRjQ1Nzc1Q0UyNDE0MzdE NTAwMkRGMUEwIC8qIElubGluZVBhdGhEYXRhLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGNDU3NzVDRDI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0 aERhdGEuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owog CQlGNDVDMjMxRTE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMxQzE5OTVC NzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi87IHNldHRpbmdzID0ge0FU VFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ2NzI5MjgxRTBERTY4NTAwQUNDM0Q4 IC8qIFNjcm9sbFNuYXBPZmZzZXRzSW5mby5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gRjQ2NzI5MjUxRTBERTVBQjAwQUNDM0Q4IC8qIFNjcm9sbFNuYXBP ZmZzZXRzSW5mby5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCUY0NkM0NDdFMjM0NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVtQmluZGluZ3NE YXRhU291cmNlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGNDZDNDQ3QzIzNDY1NDU0MDAzOUE3OUQgLyogQ2xpcGJvYXJkSXRlbUJpbmRpbmdzRGF0YVNv dXJjZS5oICovOyB9OwpAQCAtMTU0NjUsNiArMTU0NjYsNyBAQAogCQlGNDRFQkJENjFEQjVEMUI2 MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IFN0YXRp Y1JhbmdlLmlkbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ0RUJCRDgxREI1RDIx NDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IFN0YXRpY1JhbmdlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NEVCQkRB MURCNUREOUQwMDI3NzMzNCAvKiBTdGF0aWNSYW5nZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBTdGF0aWNSYW5nZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCUY0NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBJbmxpbmVQYXRoRGF0YS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlGNDVDMjMxQjE5OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0 cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NUMyMzFDMTk5NUI3M0IwMEE2 RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUY0NjI4QTlFMjM0RDNCQkYwMEJDODg0QyAvKiBQbGF0Zm9ybVBhc3RlYm9hcmRDb2Nv YS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFBsYXRmb3JtUGFz dGVib2FyZENvY29hLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjUxMjcsNiAr MjUxMjksNyBAQAogCQkJCTA3MDZBMEQ3MjQwODMwQTYwMEU5MzgxOCAvKiBJbmJhbmRHZW5lcmlj Q3VlSWRlbnRpZmllci5oICovLAogCQkJCTA3OTQxNzkzMTY2RUEwNEUwMDk0MTZDMiAvKiBJbmJh bmRUZXh0VHJhY2tQcml2YXRlLmggKi8sCiAJCQkJMDdDRTc3RDQxNjcxMkE2QTAwQzU1QTQ3IC8q IEluYmFuZFRleHRUcmFja1ByaXZhdGVDbGllbnQuaCAqLywKKwkJCQlGNDU3NzVDRDI0MTQzN0Q1 MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCAqLywKIAkJCQkyRDQ2RjA0RDE3Qjk2RkJEMDA1 NjQ3RjAgLyogSW50UG9pbnQuY3BwICovLAogCQkJCUIyNzUzNTQ0MEIwNTM4MTQwMDJDRTY0RiAv KiBJbnRQb2ludC5oICovLAogCQkJCUU0NjJBNEEwMTEzRTcxQkUwMDRBNDIyMCAvKiBJbnRQb2lu dEhhc2guaCAqLywKQEAgLTMwNDE2LDYgKzMwNDE5LDcgQEAKIAkJCQk2RkIyNDAwNTIzREZGMTI4 MDA3OTY0NTggLyogSW5saW5lTGluZUJveEJ1aWxkZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTZG RTE5ODE3MjE3ODM5N0MwMDQ0NkYwOCAvKiBJbmxpbmVMaW5lQnJlYWtlci5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJNkYwQ0Q2OTUyMjlFRDMyNzAwQzU5OTRFIC8qIElubGluZUxpbmVCdWlsZGVyLmgg aW4gSGVhZGVycyAqLywKKwkJCQlGNDU3NzVDRTI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0 aERhdGEuaCBpbiBIZWFkZXJzICovLAogCQkJCTZGMzYwRTUwMjM5OTk0MjEwMDE1MTJBNyAvKiBJ bmxpbmVTb2Z0TGluZUJyZWFrSXRlbS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQUE0QzNBNzcwQjJC MTY3OTAwMjMzNEEyIC8qIElubGluZVN0eWxlU2hlZXRPd25lci5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQkNFQTQ4NUEwOTdEOTMwMjAwOTRDOUU0IC8qIElubGluZVRleHRCb3guaCBpbiBIZWFkZXJz ICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5l UGF0aERhdGEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhE YXRhLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjUzNTlhYmFlYzA2MjEwZTE4OTQ4ZTUwZTYwOGQ5YTVmZWM5MWE0 NgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lu bGluZVBhdGhEYXRhLmgKQEAgLTAsMCArMSwxMzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBg YEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJ QlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9u Y2UKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCisjaW5jbHVkZSAiRmxvYXRQb2lu dC5oIgorI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJpYW50Lmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RydWN0IExpbmVEYXRhIHsKKyAgICBGbG9hdFBv aW50IHN0YXJ0OworICAgIEZsb2F0UG9pbnQgZW5kOworCisgICAgdGVtcGxhdGU8Y2xhc3MgRW5j b2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNsYXNzIERl Y29kZXI+IHN0YXRpYyBPcHRpb25hbDxMaW5lRGF0YT4gZGVjb2RlKERlY29kZXImKTsKK307CisK K3N0cnVjdCBBcmNEYXRhIHsKKyAgICBGbG9hdFBvaW50IG9mZnNldDsKKyAgICBGbG9hdFBvaW50 IGNlbnRlcjsKKyAgICBmbG9hdCByYWRpdXMgeyAwIH07CisgICAgZmxvYXQgc3RhcnQgeyAwIH07 CisgICAgZmxvYXQgZW5kIHsgMCB9OworICAgIGJvb2wgY2xvY2t3aXNlIHsgZmFsc2UgfTsKKyAg ICBib29sIGhhc09mZnNldCB7IGZhbHNlIH07CisKKyAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVy PiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rl cj4gc3RhdGljIE9wdGlvbmFsPEFyY0RhdGE+IGRlY29kZShEZWNvZGVyJik7Cit9OworCitzdHJ1 Y3QgTW92ZURhdGEgeworICAgIEZsb2F0UG9pbnQgbG9jYXRpb247CisKKyAgICB0ZW1wbGF0ZTxj bGFzcyBFbmNvZGVyPiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8 Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPE1vdmVEYXRhPiBkZWNvZGUoRGVjb2RlciYp OworfTsKKwordGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBNb3ZlRGF0YTo6ZW5jb2RlKEVu Y29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCBsb2NhdGlvbjsKK30KKwor dGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8TW92ZURhdGE+IE1vdmVEYXRhOjpkZWNv ZGUoRGVjb2RlciYgZGVjb2RlcikKK3sKKyAgICBNb3ZlRGF0YSBkYXRhOworICAgIGlmICghZGVj b2Rlci5kZWNvZGUoZGF0YS5sb2NhdGlvbikpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7 CisgICAgcmV0dXJuIHsgZGF0YSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IExpbmVEYXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVy IDw8IHN0YXJ0OworICAgIGVuY29kZXIgPDwgZW5kOworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNv ZGVyPiBPcHRpb25hbDxMaW5lRGF0YT4gTGluZURhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVy KQoreworICAgIExpbmVEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnN0 YXJ0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5k ZWNvZGUoZGF0YS5lbmQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0 dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lk IEFyY0RhdGE6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIg PDwgb2Zmc2V0OworICAgIGVuY29kZXIgPDwgY2VudGVyOworICAgIGVuY29kZXIgPDwgcmFkaXVz OworICAgIGVuY29kZXIgPDwgc3RhcnQ7CisgICAgZW5jb2RlciA8PCBlbmQ7CisgICAgZW5jb2Rl ciA8PCBjbG9ja3dpc2U7CisgICAgZW5jb2RlciA8PCBoYXNPZmZzZXQ7Cit9CisKK3RlbXBsYXRl PGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPEFyY0RhdGE+IEFyY0RhdGE6OmRlY29kZShEZWNvZGVy JiBkZWNvZGVyKQoreworICAgIEFyY0RhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KGRhdGEub2Zmc2V0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICgh ZGVjb2Rlci5kZWNvZGUoZGF0YS5jZW50ZXIpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnJhZGl1cykpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuc3RhcnQpKQor ICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShk YXRhLmVuZCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29k ZXIuZGVjb2RlKGRhdGEuY2xvY2t3aXNlKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsK KworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5oYXNPZmZzZXQpKQorICAgICAgICByZXR1 cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0dXJuIHsgV1RGTW92ZShkYXRhKSB9OworfQorCit1 c2luZyBJbmxpbmVQYXRoRGF0YSA9IFZhcmlhbnQ8TW9ub3N0YXRlLCBNb3ZlRGF0YSwgTGluZURh dGEsIEFyY0RhdGE+OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFC TEUoSU5MSU5FX1BBVEhfREFUQSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1BhdGguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0 aC5jcHAKaW5kZXggYTYyOGQzNzQyMjQyM2MxMjAzNTRmZmZmMjE5MDYxN2Y3MmI0Mzg1Mi4uMzU1 MTU3ZmQwMTRiNDcwZmY2ZTQ0YjRlZWJhYWQzMWI0MDYxYjMwNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKQEAgLTE4OCw2ICsxODgsMjYgQEAgRmxvYXRSZWN0 IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUo SU5MSU5FX1BBVEhfREFUQSkKKwordm9pZCBQYXRoOjphcHBseUlubGluZVBhdGhEYXRhSWZOZWVk ZWQoKSBjb25zdAoreworICAgIGlmICghbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKQorICAgICAg ICByZXR1cm47CisKKyAgICBtX25lZWRzVG9BcHBseUlubGluZURhdGEgPSBmYWxzZTsKKworICAg IGlmICghaGFzQW55SW5saW5lRGF0YSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1f cGF0aCkKKyAgICAgICAgbV9wYXRoID0gY3JlYXRlUGxhdGZvcm1QYXRoKCk7CisKKyAgICBhcHBs eUlubGluZVBhdGhEYXRhKG1faW5saW5lRGF0YSwgbV9wYXRoLmdldCgpKTsKK30KKworI2VuZGlm IC8vIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCiAjaWZuZGVmIE5ERUJVRwogdm9pZCBQYXRo OjpkdW1wKCkgY29uc3QKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaApp bmRleCA3ZmFkYTYwZDgzYzI5MjUwYWM0YTE3NDhhODkyNDA3MDI5MTk5ZTFiLi41NWE0MTU2Mjgx NzBhNjhhMWI4NWQwNjkzY2ZiNTAwNjkwNGNkMDk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oCkBAIC0yNSwxNCArMjUsMTUgQEAKICAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAogICov CiAKLSNpZm5kZWYgUGF0aF9oCi0jZGVmaW5lIFBhdGhfaAorI3ByYWdtYSBvbmNlCiAKICNpbmNs dWRlICJGbG9hdFJlY3QuaCIKKyNpbmNsdWRlICJJbmxpbmVQYXRoRGF0YS5oIgogI2luY2x1ZGUg IldpbmRSdWxlLmgiCiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KICNpbmNsdWRlIDx3dGYv RnVuY3Rpb24uaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJp YW50Lmg+CiAKICNpZiBVU0UoQ0cpCiAKQEAgLTE0Nyw3ICsxNDgsNyBAQCBwdWJsaWM6CiAgICAg RmxvYXRQb2ludCBwb2ludEF0TGVuZ3RoKGZsb2F0IGxlbmd0aCkgY29uc3Q7CiAKICAgICBXRUJD T1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7Ci0gICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVy biAhbV9wYXRoOyB9CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBpc051bGwoKSBjb25zdDsKICAg ICBib29sIGlzRW1wdHkoKSBjb25zdDsKICAgICAvLyBHZXRzIHRoZSBjdXJyZW50IHBvaW50IG9m IHRoZSBjdXJyZW50IHBhdGgsIHdoaWNoIGlzIGNvbmNlcHR1YWxseSB0aGUgZmluYWwgcG9pbnQg cmVhY2hlZCBieSB0aGUgcGF0aCBzbyBmYXIuCiAgICAgLy8gTm90ZSB0aGUgUGF0aCBjYW4gYmUg ZW1wdHkgKGlzRW1wdHkoKSA9PSB0cnVlKSBhbmQgc3RpbGwgaGF2ZSBhIGN1cnJlbnQgcG9pbnQu CkBAIC0xODUsNyArMTg2LDcgQEAgcHVibGljOgogICAgIEZsb2F0UmVjdCBmYXN0Qm91bmRpbmdS ZWN0Rm9yU3Ryb2tlKGNvbnN0IFBsYXRmb3JtQ29udGV4dERpcmVjdDJEJikgY29uc3Q7CiAgICAg UGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0aC5nZXQo KTsgfQogI2VsaWYgVVNFKENHKQotICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBj b25zdCB7IHJldHVybiBtX3BhdGguZ2V0KCk7IH0KKyAgICBXRUJDT1JFX0VYUE9SVCBQbGF0Zm9y bVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3Q7CiAjZWxzZQogICAgIFBsYXRmb3JtUGF0aFB0 ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGg7IH0KICNlbmRpZgpAQCAtMjI1 LDYgKzIyNiwxNSBAQCBwdWJsaWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGlj IE9wdGlvbmFsPFBhdGg+IGRlY29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6CisgICAgc3RhdGlj IFBsYXRmb3JtUGF0aFN0b3JhZ2VUeXBlIGNyZWF0ZVBsYXRmb3JtUGF0aCgpOworCisjaWYgRU5B QkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgc3RhdGljIHZvaWQgYXBwbHlJbmxpbmVQYXRoRGF0 YShjb25zdCBJbmxpbmVQYXRoRGF0YSYsIFBsYXRmb3JtUGF0aFB0cik7CisgICAgdGVtcGxhdGUg PHR5cGVuYW1lIERhdGFUeXBlPiBib29sIGhhc0lubGluZURhdGEoKSBjb25zdDsKKyAgICBib29s IGhhc0FueUlubGluZURhdGEoKSBjb25zdDsKKyAgICB2b2lkIGFwcGx5SW5saW5lUGF0aERhdGFJ Zk5lZWRlZCgpIGNvbnN0OworI2VuZGlmCisKICNpZiBVU0UoQ0cpCiAgICAgdm9pZCBzd2FwKFBh dGgmKTsKICNlbmRpZgpAQCAtMjM3LDYgKzI0NywxMCBAQCBwcml2YXRlOgogICAgIG11dGFibGUg Ym9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNlbmRpZgogCisjaWYgRU5BQkxFKElO TElORV9QQVRIX0RBVEEpCisgICAgSW5saW5lUGF0aERhdGEgbV9pbmxpbmVEYXRhOworICAgIG11 dGFibGUgYm9vbCBtX25lZWRzVG9BcHBseUlubGluZURhdGEgeyBmYWxzZSB9OworI2VuZGlmCiAj aWYgVVNFKENHKQogICAgIG11dGFibGUgYm9vbCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24geyBm YWxzZSB9OwogI2VuZGlmCkBAIC0yNDYsNiArMjYwLDE1IEBAIFdURjo6VGV4dFN0cmVhbSYgb3Bl cmF0b3I8PChXVEY6OlRleHRTdHJlYW0mLCBjb25zdCBQYXRoJik7CiAKIHRlbXBsYXRlPGNsYXNz IEVuY29kZXI+IHZvaWQgUGF0aDo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiB7Cisj aWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgYm9vbCBoYXNJbmxpbmVEYXRhID0gaGFz QW55SW5saW5lRGF0YSgpOworICAgIGVuY29kZXIgPDwgaGFzSW5saW5lRGF0YTsKKyAgICBpZiAo aGFzSW5saW5lRGF0YSkgeworICAgICAgICBlbmNvZGVyIDw8IG1faW5saW5lRGF0YTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgorCiAgICAgZW5jb2RlciA8PCBzdGF0aWNfY2FzdDx1 aW50NjRfdD4oZWxlbWVudENvdW50KCkpOwogCiAgICAgYXBwbHkoWyZdKGF1dG8mIGVsZW1lbnQp IHsKQEAgLTI3Niw2ICsyOTksMjEgQEAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRo OjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+ IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQogewogICAgIFBh dGggcGF0aDsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGJvb2wgaGFzSW5s aW5lRGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc0lubGluZURhdGEpKQorICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKGhhc0lubGluZURhdGEpIHsKKyAgICAg ICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5saW5lRGF0YSkpCisgICAgICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHBhdGgubV9uZWVkc1RvQXBwbHlJbmxpbmVE YXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIHsgV1RGTW92ZShwYXRoKSB9OworICAgIH0KKyNl bmRpZgorCiAgICAgdWludDY0X3QgbnVtUG9pbnRzOwogICAgIGlmICghZGVjb2Rlci5kZWNvZGUo bnVtUG9pbnRzKSkKICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKQEAgLTMzNiw5ICszNzQs MjEgQEAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aD4gUGF0aDo6ZGVjb2Rl KERlY29kZXImIGRlY29kZXIpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gcGF0aDsK KyAgICByZXR1cm4geyBXVEZNb3ZlKHBhdGgpIH07CiB9CiAKKyNpZiBFTkFCTEUoSU5MSU5FX1BB VEhfREFUQSkKKwordGVtcGxhdGUgPHR5cGVuYW1lIERhdGFUeXBlPiBib29sIFBhdGg6Omhhc0lu bGluZURhdGEoKSBjb25zdAoreworICAgIHJldHVybiBXVEY6OmhvbGRzX2FsdGVybmF0aXZlPERh dGFUeXBlPihtX2lubGluZURhdGEpOworfQorCitib29sIFBhdGg6Omhhc0FueUlubGluZURhdGEo KSBjb25zdAoreworICAgIHJldHVybiAhaGFzSW5saW5lRGF0YTxNb25vc3RhdGU+KCk7CiB9CiAK ICNlbmRpZgorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fpcm8uY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcAppbmRleCBlMWI1NTRjODg0 YzE1MmQ1YTk4YjA0YTk3Y2E0NzczZjU0NzM4NjNiLi4zNmYzMTc0ZWZmY2RmYzk0OTcxYjhjNDc0 NzAwOTRjMDIyYjg0ZGYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9QYXRoQ2Fpcm8uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHAKQEAgLTQ1NSw2ICs0NTUsMTYgQEAgdm9pZCBQYXRo Ojp0cmFuc2Zvcm0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAgICAgY2Fpcm9f dHJhbnNmb3JtKGNyLCAmbWF0cml4KTsKIH0KIAorYm9vbCBQYXRoOjppc051bGwoKSBjb25zdAor eworICAgIHJldHVybiAhbV9wYXRoOworfQorCitDYWlyb1BhdGgqIFBhdGg6OmNyZWF0ZVBsYXRm b3JtUGF0aCgpCit7CisgICAgcmV0dXJuIG5ldyBDYWlyb1BhdGg7Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIFVTRShDQUlSTykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCmluZGV4IDUyMWMxNTUzYTlhNmEzNGEzODFj MzRmOTc4NjI1NGRkNWYwYzcyNmUuLjk0NTg3MmEzNDIxYzcwNWI4M2M0YzVkMzhhYjFhMjQzYTU4 NWQ0MmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1Bh dGhDRy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENH LmNwcApAQCAtODEsNiArODEsMzAgQEAgUGF0aCBQYXRoOjpwb2x5Z29uUGF0aEZyb21Qb2ludHMo Y29uc3QgVmVjdG9yPEZsb2F0UG9pbnQ+JiBwb2ludHMpCiAgICAgcmV0dXJuIHBhdGg7CiB9CiAK K1JldGFpblB0cjxDR011dGFibGVQYXRoUmVmPiBQYXRoOjpjcmVhdGVQbGF0Zm9ybVBhdGgoKQor eworICAgIHJldHVybiBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7Cit9CisKK3ZvaWQg UGF0aDo6YXBwbHlJbmxpbmVQYXRoRGF0YShjb25zdCBJbmxpbmVQYXRoRGF0YSYgZGF0YSwgQ0dN dXRhYmxlUGF0aFJlZiBwYXRoKQoreworICAgIFdURjo6c3dpdGNoT24oZGF0YSwKKyAgICAgICAg WyZdKGF1dG8pIHsgQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0sCisgICAgICAgIFsmXShjb25zdCBN b3ZlRGF0YSYgbW92ZSkgeworICAgICAgICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQocGF0aCwgbnVs bHB0ciwgbW92ZS5sb2NhdGlvbi54KCksIG1vdmUubG9jYXRpb24ueSgpKTsKKyAgICAgICAgfSwK KyAgICAgICAgWyZdKGNvbnN0IExpbmVEYXRhJiBsaW5lKSB7CisgICAgICAgICAgICBDR1BhdGhN b3ZlVG9Qb2ludChwYXRoLCBudWxscHRyLCBsaW5lLnN0YXJ0LngoKSwgbGluZS5zdGFydC55KCkp OworICAgICAgICAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQocGF0aCwgbnVsbHB0ciwgbGluZS5l bmQueCgpLCBsaW5lLmVuZC55KCkpOworICAgICAgICB9LAorICAgICAgICBbJl0oY29uc3QgQXJj RGF0YSYgYXJjKSB7CisgICAgICAgICAgICBpZiAoYXJjLmhhc09mZnNldCkKKyAgICAgICAgICAg ICAgICBDR1BhdGhNb3ZlVG9Qb2ludChwYXRoLCBudWxscHRyLCBhcmMub2Zmc2V0LngoKSwgYXJj Lm9mZnNldC55KCkpOworICAgICAgICAgICAgQ0dQYXRoQWRkQXJjKHBhdGgsIG51bGxwdHIsIGFy Yy5jZW50ZXIueCgpLCBhcmMuY2VudGVyLnkoKSwgYXJjLnJhZGl1cywgYXJjLnN0YXJ0LCBhcmMu ZW5kLCBhcmMuY2xvY2t3aXNlKTsKKyAgICAgICAgfQorICAgICk7Cit9CisKIFBhdGg6OlBhdGgo UmV0YWluUHRyPENHTXV0YWJsZVBhdGhSZWY+JiYgcGF0aCkKICAgICA6IG1fcGF0aChXVEZNb3Zl KHBhdGgpKQogewpAQCAtODksNiArMTEzLDEyIEBAIFBhdGg6OlBhdGgoUmV0YWluUHRyPENHTXV0 YWJsZVBhdGhSZWY+JiYgcGF0aCkKIFBhdGg6OlBhdGgoKSA9IGRlZmF1bHQ7CiBQYXRoOjp+UGF0 aCgpID0gZGVmYXVsdDsKIAorUGxhdGZvcm1QYXRoUHRyIFBhdGg6OnBsYXRmb3JtUGF0aCgpIGNv bnN0Cit7CisgICAgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkKCk7CisgICAgcmV0dXJuIG1f cGF0aC5nZXQoKTsKK30KKwogUGxhdGZvcm1QYXRoUHRyIFBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0 aCgpCiB7CiAgICAgaWYgKCFtX3BhdGgpCkBAIC05OCwxMiArMTI4LDIxIEBAIFBsYXRmb3JtUGF0 aFB0ciBQYXRoOjplbnN1cmVQbGF0Zm9ybVBhdGgoKQogICAgICAgICAgICAgbV9wYXRoID0gYWRv cHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weShtX3BhdGguZ2V0KCkpKTsKICAgICAgICAgbV9j b3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7CiAgICAgfQorICAgIGFwcGx5SW5saW5lUGF0 aERhdGFJZk5lZWRlZCgpOworICAgIG1faW5saW5lRGF0YSA9IE1vbm9zdGF0ZSB7IH07CiAgICAg cmV0dXJuIG1fcGF0aC5nZXQoKTsKIH0KIAorYm9vbCBQYXRoOjppc051bGwoKSBjb25zdAorewor ICAgIHJldHVybiAhbV9wYXRoICYmICFoYXNBbnlJbmxpbmVEYXRhKCk7Cit9CisKIFBhdGg6OlBh dGgoY29uc3QgUGF0aCYgb3RoZXIpCiB7CiAgICAgbV9wYXRoID0geyBvdGhlci5tX3BhdGggfTsK KyAgICBtX2lubGluZURhdGEgPSBvdGhlci5tX2lubGluZURhdGE7CisgICAgbV9uZWVkc1RvQXBw bHlJbmxpbmVEYXRhID0gb3RoZXIubV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhOwogICAgIGlmICht X3BhdGgpIHsKICAgICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gdHJ1ZTsKICAgICAg ICAgb3RoZXIubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gdHJ1ZTsKQEAgLTExMiw2ICsxNTEs OCBAQCBQYXRoOjpQYXRoKGNvbnN0IFBhdGgmIG90aGVyKQogCiBQYXRoOjpQYXRoKFBhdGgmJiBv dGhlcikKICAgICA6IG1fcGF0aChzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fcGF0aCwgbnVsbHB0cikp CisgICAgLCBtX2lubGluZURhdGEoc3RkOjpleGNoYW5nZShvdGhlci5tX2lubGluZURhdGEsIE1v bm9zdGF0ZSB7IH0pKQorICAgICwgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhKHN0ZDo6ZXhjaGFu Z2Uob3RoZXIubV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhLCBmYWxzZSkpCiAgICAgLCBtX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24oc3RkOjpleGNoYW5nZShvdGhlci5tX2NvcHlQYXRoQmVmb3JlTXV0 YXRpb24sIGZhbHNlKSkKIHsKIH0KQEAgLTExOSw2ICsxNjAsOCBAQCBQYXRoOjpQYXRoKFBhdGgm JiBvdGhlcikKIHZvaWQgUGF0aDo6c3dhcChQYXRoJiBvdGhlclBhdGgpCiB7CiAgICAgc3RkOjpz d2FwKG1fcGF0aCwgb3RoZXJQYXRoLm1fcGF0aCk7CisgICAgc3RkOjpzd2FwKG1faW5saW5lRGF0 YSwgb3RoZXJQYXRoLm1faW5saW5lRGF0YSk7CisgICAgc3RkOjpzd2FwKG1fbmVlZHNUb0FwcGx5 SW5saW5lRGF0YSwgb3RoZXJQYXRoLm1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSk7CiAgICAgc3Rk Ojpzd2FwKG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiwgb3RoZXJQYXRoLm1fY29weVBhdGhCZWZv cmVNdXRhdGlvbik7CiB9CiAKQEAgLTE3OSw3ICsyMjIsNyBAQCBib29sIFBhdGg6OmNvbnRhaW5z KGNvbnN0IEZsb2F0UG9pbnQgJnBvaW50LCBXaW5kUnVsZSBydWxlKSBjb25zdAogICAgICAgICBy ZXR1cm4gZmFsc2U7CiAKICAgICAvLyBDR1BhdGhDb250YWluc1BvaW50IHJldHVybnMgZmFsc2Ug Zm9yIG5vbi1jbG9zZWQgcGF0aHMsIGFzIGEgd29yay1hcm91bmQsIHdlIGNvcHkgYW5kIGNsb3Nl IHRoZSBwYXRoIGZpcnN0LiAgUmFkYXIgNDc1ODk5OCBhc2tzIGZvciBhIGJldHRlciBDRyBBUEkg dG8gdXNlCi0gICAgYXV0byBwYXRoID0gYWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhz KG1fcGF0aC5nZXQoKSkpOworICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoY29weUNHUGF0aENsb3Np bmdTdWJwYXRocyhwbGF0Zm9ybVBhdGgoKSkpOwogICAgIGJvb2wgcmV0ID0gQ0dQYXRoQ29udGFp bnNQb2ludChwYXRoLmdldCgpLCAwLCBwb2ludCwgcnVsZSA9PSBXaW5kUnVsZTo6RXZlbk9kZCA/ IHRydWUgOiBmYWxzZSk7CiAgICAgcmV0dXJuIHJldDsKIH0KQEAgLTIxNyw5ICsyNjAsOSBAQCB2 b2lkIFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSkKICAg ICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm1DRyA9IHRyYW5zZm9ybTsKICNpZiBQTEFURk9S TShXSU4pCiAgICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlKCkpOwot ICAgIENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBtX3BhdGguZ2V0KCkp OworICAgIENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBlbnN1cmVQbGF0 Zm9ybVBhdGgoKSk7CiAjZWxzZQotICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRl TXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgobV9wYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0cp KTsKKyAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5QnlUcmFu c2Zvcm1pbmdQYXRoKGVuc3VyZVBsYXRmb3JtUGF0aCgpLCAmdHJhbnNmb3JtQ0cpKTsKICNlbmRp ZgogICAgIG1fcGF0aCA9IFdURk1vdmUocGF0aCk7CiAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0 aW9uID0gZmFsc2U7CkBAIC0yMzAsOSArMjczLDE5IEBAIEZsb2F0UmVjdCBQYXRoOjpib3VuZGlu Z1JlY3QoKSBjb25zdAogICAgIGlmIChpc051bGwoKSkKICAgICAgICAgcmV0dXJuIENHUmVjdFpl cm87CiAKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkKKyAgICAgICAgcmV0dXJu IHsgfTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKSB7CisgICAgICAgIEZs b2F0UmVjdCByZXN1bHQ7CisgICAgICAgIGF1dG8mIGxpbmUgPSBXVEY6OmdldDxMaW5lRGF0YT4o bV9pbmxpbmVEYXRhKTsKKyAgICAgICAgcmVzdWx0LmZpdFRvUG9pbnRzKGxpbmUuc3RhcnQsIGxp bmUuZW5kKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9CisKICAgICAvLyBDR1BhdGhH ZXRCb3VuZGluZ0JveCBpbmNsdWRlcyB0aGUgcGF0aCdzIGNvbnRyb2wgcG9pbnRzLCBDR1BhdGhH ZXRQYXRoQm91bmRpbmdCb3ggZG9lcyBub3QuCiAKLSAgICBDR1JlY3QgYm91bmQgPSBDR1BhdGhH ZXRQYXRoQm91bmRpbmdCb3gobV9wYXRoLmdldCgpKTsKKyAgICBDR1JlY3QgYm91bmQgPSBDR1Bh dGhHZXRQYXRoQm91bmRpbmdCb3gocGxhdGZvcm1QYXRoKCkpOwogICAgIHJldHVybiBDR1JlY3RJ c051bGwoYm91bmQpID8gQ0dSZWN0WmVybyA6IGJvdW5kOwogfQogCkBAIC0yNDAsNyArMjkzLDE4 IEBAIEZsb2F0UmVjdCBQYXRoOjpmYXN0Qm91bmRpbmdSZWN0KCkgY29uc3QKIHsKICAgICBpZiAo aXNOdWxsKCkpCiAgICAgICAgIHJldHVybiBDR1JlY3RaZXJvOwotICAgIENHUmVjdCBib3VuZCA9 IENHUGF0aEdldEJvdW5kaW5nQm94KG1fcGF0aC5nZXQoKSk7CisKKyAgICBpZiAoaGFzSW5saW5l RGF0YTxNb3ZlRGF0YT4oKSkKKyAgICAgICAgcmV0dXJuIHsgfTsKKworICAgIGlmIChoYXNJbmxp bmVEYXRhPExpbmVEYXRhPigpKSB7CisgICAgICAgIEZsb2F0UmVjdCByZXN1bHQ7CisgICAgICAg IGF1dG8mIGxpbmUgPSBXVEY6OmdldDxMaW5lRGF0YT4obV9pbmxpbmVEYXRhKTsKKyAgICAgICAg cmVzdWx0LmZpdFRvUG9pbnRzKGxpbmUuc3RhcnQsIGxpbmUuZW5kKTsKKyAgICAgICAgcmV0dXJu IHJlc3VsdDsKKyAgICB9CisKKyAgICBDR1JlY3QgYm91bmQgPSBDR1BhdGhHZXRCb3VuZGluZ0Jv eChwbGF0Zm9ybVBhdGgoKSk7CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkgPyBDR1Jl Y3RaZXJvIDogYm91bmQ7CiB9CiAKQEAgLTI2OSwxMSArMzMzLDIzIEBAIEZsb2F0UmVjdCBQYXRo OjpzdHJva2VCb3VuZGluZ1JlY3QoU3Ryb2tlU3R5bGVBcHBsaWVyKiBhcHBsaWVyKSBjb25zdAog CiB2b2lkIFBhdGg6Om1vdmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKIHsKKyAgICBpZiAo aXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkgeworICAgICAgICBtX2lubGlu ZURhdGEgPSBNb3ZlRGF0YSB7IHBvaW50IH07CisgICAgICAgIG1fbmVlZHNUb0FwcGx5SW5saW5l RGF0YSA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBDR1BhdGhNb3ZlVG9Q b2ludChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcG9pbnQueCgpLCBwb2ludC55KCkp OwogfQogCiB2b2lkIFBhdGg6OmFkZExpbmVUbyhjb25zdCBGbG9hdFBvaW50JiBwKQogeworICAg IGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKSB7CisgICAgICAgIG1f aW5saW5lRGF0YSA9IExpbmVEYXRhIHsgaGFzQW55SW5saW5lRGF0YSgpID8gV1RGOjpnZXQ8TW92 ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb24gOiBGbG9hdFBvaW50KCksIHAgfTsKKyAgICAg ICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKwogICAgIENHUGF0aEFkZExpbmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxs cHRyLCBwLngoKSwgcC55KCkpOwogfQogCkBAIC0zNTYsNiArNDMyLDEyIEBAIHZvaWQgUGF0aDo6 YWRkQXJjKGNvbnN0IEZsb2F0UG9pbnQmIHAsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmds ZSwgZmxvYXQgZW5kCiAgICAgaWYgKCFzdGQ6OmlzZmluaXRlKHN0YXJ0QW5nbGUpIHx8ICFzdGQ6 OmlzZmluaXRlKGVuZEFuZ2xlKSkKICAgICAgICAgcmV0dXJuOwogCisgICAgaWYgKGlzTnVsbCgp IHx8IGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpIHsKKyAgICAgICAgbV9pbmxpbmVEYXRhID0g QXJjRGF0YSB7IGhhc0FueUlubGluZURhdGEoKSA/IFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGlu ZURhdGEpLmxvY2F0aW9uIDogRmxvYXRQb2ludCgpLCBwLCByYWRpdXMsIHN0YXJ0QW5nbGUsIGVu ZEFuZ2xlLCBjbG9ja3dpc2UsIGhhc0FueUlubGluZURhdGEoKSB9OworICAgICAgICBtX25lZWRz VG9BcHBseUlubGluZURhdGEgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAg Q0dQYXRoQWRkQXJjKGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRyLCBwLngoKSwgcC55KCks IHJhZGl1cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGNsb2Nrd2lzZSk7CiB9CiAKQEAgLTQwMiwy NSArNDg0LDQwIEBAIHZvaWQgUGF0aDo6Y2xlYXIoKQogICAgIGlmIChpc051bGwoKSkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlKCkp OworICAgIG1fcGF0aC5jbGVhcigpOworICAgIG1faW5saW5lRGF0YSA9IE1vbm9zdGF0ZSB7IH07 CisgICAgbV9uZWVkc1RvQXBwbHlJbmxpbmVEYXRhID0gZmFsc2U7CiAgICAgbV9jb3B5UGF0aEJl Zm9yZU11dGF0aW9uID0gZmFsc2U7CiB9CiAKIGJvb2wgUGF0aDo6aXNFbXB0eSgpIGNvbnN0CiB7 Ci0gICAgcmV0dXJuIGlzTnVsbCgpIHx8IENHUGF0aElzRW1wdHkobV9wYXRoLmdldCgpKTsKKyAg ICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgaWYgKGhhc0FueUlu bGluZURhdGEoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIENHUGF0aElz RW1wdHkobV9wYXRoLmdldCgpKTsKIH0KIAogYm9vbCBQYXRoOjpoYXNDdXJyZW50UG9pbnQoKSBj b25zdAogewogICAgIHJldHVybiAhaXNFbXB0eSgpOwogfQotICAgIAotRmxvYXRQb2ludCBQYXRo OjpjdXJyZW50UG9pbnQoKSBjb25zdCAKKworRmxvYXRQb2ludCBQYXRoOjpjdXJyZW50UG9pbnQo KSBjb25zdAogewogICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIEZsb2F0UG9pbnQo KTsKLSAgICByZXR1cm4gQ0dQYXRoR2V0Q3VycmVudFBvaW50KG1fcGF0aC5nZXQoKSk7CisgICAg ICAgIHJldHVybiB7IH07CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkKKyAg ICAgICAgcmV0dXJuIFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uOwor CisgICAgaWYgKGhhc0lubGluZURhdGE8TGluZURhdGE+KCkpCisgICAgICAgIHJldHVybiBXVEY6 OmdldDxMaW5lRGF0YT4obV9pbmxpbmVEYXRhKS5lbmQ7CisKKyAgICByZXR1cm4gQ0dQYXRoR2V0 Q3VycmVudFBvaW50KHBsYXRmb3JtUGF0aCgpKTsKIH0KIAogc3RhdGljIHZvaWQgQ0dQYXRoQXBw bGllclRvUGF0aEFwcGxpZXIodm9pZCogaW5mbywgY29uc3QgQ0dQYXRoRWxlbWVudCogZWxlbWVu dCkKQEAgLTQ1NCwxNCArNTUxLDQwIEBAIHZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxp ZXJGdW5jdGlvbiYgZnVuY3Rpb24pIGNvbnN0CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICBy ZXR1cm47CiAKLSAgICBDR1BhdGhBcHBseShtX3BhdGguZ2V0KCksICh2b2lkKikmZnVuY3Rpb24s IENHUGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKTsKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3Zl RGF0YT4oKSkgeworICAgICAgICBQYXRoRWxlbWVudCBlbGVtZW50OworICAgICAgICBlbGVtZW50 LnR5cGUgPSBQYXRoRWxlbWVudDo6VHlwZTo6TW92ZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQu cG9pbnRzWzBdID0gV1RGOjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb247Cisg ICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg aWYgKGhhc0lubGluZURhdGE8TGluZURhdGE+KCkpIHsKKyAgICAgICAgYXV0byYgbGluZSA9IFdU Rjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpOworICAgICAgICBQYXRoRWxlbWVudCBlbGVt ZW50OworICAgICAgICBlbGVtZW50LnR5cGUgPSBQYXRoRWxlbWVudDo6VHlwZTo6TW92ZVRvUG9p bnQ7CisgICAgICAgIGVsZW1lbnQucG9pbnRzWzBdID0gbGluZS5zdGFydDsKKyAgICAgICAgZnVu Y3Rpb24oZWxlbWVudCk7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpUeXBl OjpBZGRMaW5lVG9Qb2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBsaW5lLmVuZDsK KyAgICAgICAgZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAg ICBDR1BhdGhBcHBseShwbGF0Zm9ybVBhdGgoKSwgKHZvaWQqKSZmdW5jdGlvbiwgQ0dQYXRoQXBw bGllclRvUGF0aEFwcGxpZXIpOwogfQogCiAjaWYgSEFWRShDR1BBVEhfR0VUX05VTUJFUl9PRl9F TEVNRU5UUykKIAogc2l6ZV90IFBhdGg6OmVsZW1lbnRDb3VudCgpIGNvbnN0CiB7Ci0gICAgcmV0 dXJuIENHUGF0aEdldE51bWJlck9mRWxlbWVudHMobV9wYXRoKTsKKyAgICBpZiAoaGFzSW5saW5l RGF0YTxNb3ZlRGF0YT4oKSkKKyAgICAgICAgcmV0dXJuIDE7CisKKyAgICBpZiAoaGFzSW5saW5l RGF0YTxMaW5lRGF0YT4oKSkKKyAgICAgICAgcmV0dXJuIDI7CisKKyAgICByZXR1cm4gQ0dQYXRo R2V0TnVtYmVyT2ZFbGVtZW50cyhwbGF0Zm9ybVBhdGgoKSk7CiB9CiAKICNlbmRpZiAvLyBIQVZF KENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0 SXRlbXMuY3BwCmluZGV4IGQ0NTMxYmFiNWNhNDRjZWJjYWY5NWFhZmU3NTAzMmY0MzlhYjhhZDcu LmUyMjYxNzAzZTRiYzBiOWFhZjUwNTNiMzQ3YThmYzhmMDEwOWE0NzMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0 ZW1zLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlz dHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKQEAgLTEyMjgsNyArMTIyOCw3IEBAIE9wdGlvbmFsPEZs b2F0UmVjdD4gU3Ryb2tlUGF0aDo6bG9jYWxCb3VuZHMoY29uc3QgR3JhcGhpY3NDb250ZXh0JiBj b250ZXh0KSBjb25zCiAKIHZvaWQgU3Ryb2tlUGF0aDo6YXBwbHkoR3JhcGhpY3NDb250ZXh0JiBj b250ZXh0KSBjb25zdAogewotICAgIGNvbnRleHQuc3Ryb2tlUGF0aChtX3BhdGgpOworICAgIGNv bnRleHQuc3Ryb2tlUGF0aChXVEZNb3ZlKG1fcGF0aCkpOwogfQogCiBzdGF0aWMgVGV4dFN0cmVh bSYgb3BlcmF0b3I8PChUZXh0U3RyZWFtJiB0cywgY29uc3QgU3Ryb2tlUGF0aCYgaXRlbSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9E aXNwbGF5TGlzdEl0ZW1zLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNw bGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oCmluZGV4IDc3NDIwNWFjNzNmNjI3MTRlM2NmYTkw ZTAyMmNlNWM3NzA4MjhmMmIuLmI5MGVkMjA5ZDFkMTkzN2IzMjY3MzdmOTZjNTliOTE2ZGI3MmU4 M2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXls aXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaApAQCAtMjU4OSw3ICsyNTg5LDcg QEAgcHJpdmF0ZToKICAgICB2b2lkIGFwcGx5KEdyYXBoaWNzQ29udGV4dCYpIGNvbnN0IG92ZXJy aWRlOwogICAgIE9wdGlvbmFsPEZsb2F0UmVjdD4gbG9jYWxCb3VuZHMoY29uc3QgR3JhcGhpY3ND b250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAKLSAgICBjb25zdCBQYXRoIG1fcGF0aDsKKyAgICBt dXRhYmxlIFBhdGggbV9wYXRoOwogfTsKIAogdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5j cHAKaW5kZXggZmY2MzAxNDM5NDA0ZjA3ZmE3MGY4YTNjNjQ3YTU4ZDFiNGNiYmQ2NS4uZGQ0YzY3 ZGY2MWE4ODNiNWRjMDE0Mjg1MTUzOGZlM2ExYTI1YzFjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHAKQEAgLTY3Niw2 ICs2NzYsMjEgQEAgdm9pZCBQYXRoOjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9uJiBm dW5jdGlvbikgY29uc3QKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCitib29sIFBhdGg6Omlz TnVsbCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3BhdGg7Cit9CisKK0NPTVB0cjxJRDJEMUdl b21ldHJ5R3JvdXA+IFBhdGg6OmNyZWF0ZVBsYXRmb3JtUGF0aCgpCit7CisgICAgQ09NUHRyPElE MkQxR2VvbWV0cnlHcm91cD4gcGF0aDsKKyAgICBIUkVTVUxUIGhyID0gR3JhcGhpY3NDb250ZXh0 OjpzeXN0ZW1GYWN0b3J5KCktPkNyZWF0ZUdlb21ldHJ5R3JvdXAoRDJEMV9GSUxMX01PREVfV0lO RElORywgbnVsbHB0ciwgMCwgJnBhdGgpOworICAgIEFTU0VSVChTVUNDRUVERUQoaHIpKTsKKyAg ICBpZiAoRkFJTEVEKGhyKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJuIHBh dGg7Cit9CisKIH0KIAogI2VuZGlmIC8vIFVTRShESVJFQ1QyRCkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcCBiL1NvdXJjZS9XZWJLaXQv UGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcAppbmRleCA3NmQyYjA5ZGFiZjExNGMzOWM2 NDZhZTMxNjM3ZmEyMDE2MWZkYjNmLi4xOGU5NTE3NjU0NzdlYTM0ZWJjNTVjZjUwMjg0NWY1ZDQ5 ODcyM2E3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENv ZGVycy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMu Y3BwCkBAIC0yMDUsNCArMjA1LDEzIEBAIGJvb2wgQXJndW1lbnRDb2RlcjxhdWRpdF90b2tlbl90 Pjo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIsIGF1ZGl0X3Rva2VuX3QmIGF1ZGl0CiB9CiAjZW5k aWYKIAordm9pZCBBcmd1bWVudENvZGVyPE1vbm9zdGF0ZT46OmVuY29kZShFbmNvZGVyJiwgY29u c3QgTW9ub3N0YXRlJikKK3sKK30KKworT3B0aW9uYWw8TW9ub3N0YXRlPiBBcmd1bWVudENvZGVy PE1vbm9zdGF0ZT46OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQoreworICAgIHJldHVybiBNb25v c3RhdGUgeyB9OworfQorCiB9IC8vIG5hbWVzcGFjZSBJUEMKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmggYi9Tb3VyY2UvV2ViS2l0L1BsYXRm b3JtL0lQQy9Bcmd1bWVudENvZGVycy5oCmluZGV4IDU4YzQ1NjQ2ODhjOGYzZjJlYWMxYWM0NzAx ODJiODVhZmFkZmM2NjQuLmU3YjI2ZjQ1NTZmYTRkMzJmNWY2ZmJkZTlmNWFkZmRjOWYxZmFjOWMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmgK KysrIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuaApAQCAtMzMs NiArMzMsNyBAQAogI2luY2x1ZGUgPHd0Zi9Nb25vdG9uaWNUaW1lLmg+CiAjaW5jbHVkZSA8d3Rm L1NIQTEuaD4KICNpbmNsdWRlIDx3dGYvVW5leHBlY3RlZC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJp YW50Lmg+CiAjaW5jbHVkZSA8d3RmL1dhbGxUaW1lLmg+CiAKIG5hbWVzcGFjZSBJUEMgewpAQCAt NjkxLDQgKzY5Miw5IEBAIHRlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8YXVkaXRfdG9r ZW5fdD4gewogfTsKICNlbmRpZgogCit0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1bWVudENvZGVyPE1v bm9zdGF0ZT4geworICAgIHN0YXRpYyB2b2lkIGVuY29kZShFbmNvZGVyJiwgY29uc3QgTW9ub3N0 YXRlJik7CisgICAgc3RhdGljIE9wdGlvbmFsPE1vbm9zdGF0ZT4gZGVjb2RlKERlY29kZXImKTsK K307CisKIH0gLy8gbmFtZXNwYWNlIElQQwo= 392930 2020-03-07 19:20:09 -0800 2020-03-07 23:43:12 -0800 v3 bug-208464-20200307192008.patch text/plain 37761 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDkxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNlYjg0YzRhMTNhNTFmNzlkODIwZDc0 YjNhOGVkNmIwOTg5NDkyOGEuLjcwYmZlMTQ5YmJiYTAxYjc2MjEwZmQwOWZhYmVmNjdlYTlhMjg3 ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGZlYXR1cmUgZmxhZyBmb3IgSU5MSU5FX1BBVEhf REFUQS4gVGhpcyBmZWF0dXJlIGZsYWcgZXhpc3RzIHRvIGVuc3VyZSB0aGF0IHdlIGNhbiBhdm9p ZCBoYXZpbmcKKyAgICAgICAgbV9pbmxpbmVEYXRhIG9uIFBhdGggaW4gcG9ydHMgdGhhdCBkb24n dCBpbXBsZW1lbnQgdGhlIG5lY2Vzc2FyeSBmYWNpbGl0aWVzIGZvciBpbmxpbmUgcGF0aCBkYXRh IHlldCwgc2luY2UgaXQKKyAgICAgICAgd291bGQganVzdCBlbmQgdXAgYmVpbmcgd2FzdGVkIG1l bW9yeS4KKworICAgICAgICAqIHd0Zi9QbGF0Zm9ybUVuYWJsZS5oOgorCiAyMDIwLTAzLTA3ICBE YW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbaU9TXSBJbXBsZW1l bnQgc3VwcG9ydCBmb3IgZGljdGF0aW9uIGFsdGVybmF0aXZlcwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDA0YjE3 NDQ0MjVhNzY0YjIzMDUwZWI3YjhiNDM0ZjM4YzhhNjRiODguLjNhMzI3OTI4YjJmMGJlMDBlZjFk ODZlNjMyNDI2MDVjYzdkMzc5OWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNDUgQEAKKzIwMjAt MDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg TGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBz dWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdoZW4gdGhl IEdQVSBwcm9jZXNzIGlzIGVuYWJsZWQgYW5kIHVzZWQgdG8gcmVuZGVyIHRoZSBjYW52YXMgZWxl bWVudCwgc29tZSBjYW52YXMtcmVsYXRlZCBzdWJ0ZXN0cyBpbgorICAgICAgICBNb3Rpb25NYXJr IHNlZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNzaW9ucy4gT25lIG9mIHRoZSByZWFz b25zIGZvciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mgb2YKKyAgICAgICAgZGVjb2Rpbmcg ZGlzcGxheSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2ViQ29yZTo6UGF0aGBzIGluIHRoZSBH UFUgcHJvY2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBuZXcgQ0dQYXRoCisgICAgICAgIGZv ciBlYWNoIFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNhbGx5IGluY3JlYXNlcyBwYWdlIGRl bWFuZCBhbmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJvY2VzcyBpbiBjb250cmFzdAorICAg ICAgICB0byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUgZmFjdCB0aGF0IGFsbCBvZiB0aGVz ZSBDR1BhdGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11c3QgYWxsIGV4aXN0IHNvbWV3aGVy ZQorICAgICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5nIHRoZSBkaXNwbGF5IGxpc3QuCisK KyAgICAgICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdlYktpdCwgZWFjaCBjYWxsIHRvIHN0 cm9rZSB0aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBpbnZva2luZworICAgICAgICBHcmFw aGljc0NvbnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRlZCBieSBjbGVhcmluZyB0aGUgcGF0 aCwgd2hpY2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlCisgICAg ICAgIFBhdGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVlZHMgdG8gYmUgY3JlYXRlZCwgQ29y ZUdyYXBoaWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0aGUgbmV3IENHUGF0aCBhdCB0aGUK KyAgICAgICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQYXRoIHdoaWNoIHdhcyBqdXN0IGRl c3Ryb3llZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0eWluZyBtb3JlIHBhZ2VzIHRoYW4K KyAgICAgICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24gYWZmZWN0cyBtb3N0IG9mIHRoZSBj YW52YXMtcmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRvIHNvbWUgZGVncmVlLCB0aG91Z2gg dGhlCisgICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFibGUgd2l0aCBDYW52YXMgTGluZXMu CisKKyAgICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNpZ25pZmljYW50IHBvcnRpb24gb2Yg dGltZSBpcyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBwbHkgYW5kIGNvbnZlcnRpbmcgdGhl IHJlc3VsdGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBpbnRvIHNlcmlhbGl6YWJsZSBkYXRh IHdoZW4gZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisKKyAgICAgICAgVG8gbWl0aWdhdGUg dGhlc2UgdHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lucyB3ZSBnZXQgZnJvbSBtZW1vcnkg bG9jYWxpdHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdlCisgICAgICAgIHF1YW50aXRpZXMs IHdlIGNhbjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ugb2Ygc2ltcGxlIHBhdGhzLCBzdHVm ZiBzb21lIGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBhdGggd2FzIGNyZWF0ZWQgYXMgaW5s aW5lIGRhdGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBhdGggaXRzZWxmLCBhcyBhIG5ldyBk YXRhIG1lbWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29tcGFzc2VzIGxpbmVzLCBhcmNzLCBh bmQgbW92ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBvbmx5IGBQYXRoOjptb3ZlVG9gIHdh cyBpbnZva2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGluY2x1ZGUg ZWxsaXBzZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhpcyBhbGxvd3MgdXMgdG8gYWNoaWV2 ZSB0d28gdGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVhcGVyIGJ5IG5vdCByZXF1aXJpbmcg YSB3YWxrIHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBDR1BhdGgncyBlbGVtZW50cywgYW5k IChiKSBtYWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBpbml0aWFsaXppbmcgdGhlIFBhdGgg dXNpbmcgaW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBoYXZpbmcgdG8gY3Jl YXRlIGEgbmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hlbiBwYWludGluZyB0aGUgU3Ryb2tl UGF0aCBkaXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJkIGBtX3BhdGhgIGFmdGVyIHdlJ3Jl IGRvbmUgcGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAgIFRoaXMsIGluIGNvbmp1bmN0aW9u IHdpdGggKDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZTo6UGF0 aCBpbiB0aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAgICAgICAgY3JlYXRlZCB3aGVuIHdl J3JlIGp1c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBjYWxsaW5nIGludG8gc3Ryb2tlUGF0 aCgpKSwgYW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAgICAgICAgICAgd2UncmUgZG9uZSBw YWludGluZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxvdyBmb3IgZGV0YWlscy4gVGhlcmUg c2hvdWxkIGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKworICAgICAgICAqIEhlYWRlcnMuY21h a2U6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAg ICAqIHBsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhEYXRhLmg6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6TW92ZURhdGE6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpNb3Zl RGF0YTo6ZGVjb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkxpbmVEYXRhOjplbmNvZGUgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6TGluZURhdGE6OmRlY29kZSk6CisgICAgICAgIChXZWJDb3Jl OjpBcmNEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6QXJjRGF0YTo6ZGVj b2RlKToKKworICAgICAgICBJbnRyb2R1Y2UgSW5saW5lUGF0aERhdGEsIGEgVmFyaWFudCBvZiBz ZXZlcmFsIGRpZmZlcmVudCBpbmxpbmUgZGF0YSB0eXBlcywgZWFjaCBvZiB3aGljaCByZXByZXNl bnRzIG9uZSBzaW1wbGUKKyAgICAgICAgcGF0aCB0eXBlIHRoYXQgaXMgc3RvcmVkIHVzaW5nIG9u bHkgaW5saW5lIGRhdGEuIFRoaXMgaW5jbHVkZXMgbGluZSBzZWdtZW50cyAoYSBzdGFydCBwb2lu dCBhbmQgYW4gZW5kIHBvaW50KSwKKyAgICAgICAgYXMgd2VsbCBhcyBhcmNzICh3aGljaCwgaW4g YWRkaXRpb24gdG8gYSBjZW50ZXIgYW5kIHN0YXJ0IGFuZCBlbmQgYW5nbGVzKSBhbHNvIGluY2x1 ZGVzIGFuIG9wdGlvbmFsIG9mZnNldCwKKyAgICAgICAgd2hpY2ggcmVwcmVzZW50cyB0aGUgY3Vy cmVudCBwb3NpdGlvbiBvZiB0aGUgcGF0aCBhdCB0aGUgdGltZSAiYWRkQXJjIiB3YXMgY2FsbGVk LgorCisgICAgICAgIEZvciBpbnN0YW5jZSwgaW4gdGhlIGZvbGxvd2luZyBzY2VuYXJpbywgdGhl IHBhdGggd291bGQgaGF2ZSBhbiBhcmMgdGhhdCBpcyBvZmZzZXQgYnkgKDEwMCwgMCk7IGlmIGZp bGxlZCwgaXQKKyAgICAgICAgd291bGQgcmVzdWx0IGluIGEgY29tcG9zaXRlIHNoYXBlIHJlc2Vt YmxpbmcgYSBzZW1pY2lyY2xlIG9uIHRvcCBvZiBhIHRyaWFuZ2xlOgorCisgICAgICAgIHBhdGgu bW92ZVRvKDEwMCwgMCk7CisgICAgICAgIHBhdGguYWRkQXJjKDEwMCwgMTAwLCA1MCwgMCwgUEks IGZhbHNlKTsKKyAgICAgICAgY29udGV4dC5maWxsKHBhdGgpOworCisgICAgICAgIFdoZW4gYSBQ YXRoIGlzIGluaXRpYWxpemVkIChvciBhZnRlciBpdCBpcyBjbGVhcmVkKSwgaXQgc3RhcnRzIG9m ZiB3aXRoIG5laXRoZXIgYSBDR1BhdGggbm9yIGlubGluZSBkYXRhLiBNb3ZpbmcKKyAgICAgICAg dGhlIHBhdGggY2F1c2VzIGl0IHRvIHN0b3JlIGlubGluZSBNb3ZlRGF0YTsgY2FsbGluZyBjYWxs aW5nIGBhZGRMaW5lVG9gIG9yIGBhZGRBcmNgIHRoZW4gcmVwbGFjZXMgdGhlIGlubGluZQorICAg ICAgICBkYXRhIHdpdGggZWl0aGVyIExpbmVEYXRhIG9yIEFyY0RhdGEuCisKKyAgICAgICAgSWYs IGF0IGFueSBwb2ludCwgdGhlIHBhdGggY2hhbmdlcyBpbiBhIGRpZmZlcmVudCB3YXkgKGkuZS4g bmVpdGhlciBsaW5lLCBhcmMsIG5vciBtb3ZlKSwgd2UgY2xlYXIgb3V0IHRoZQorICAgICAgICBp bmxpbmUgZGF0YSBhbmQgZmFsbCBiYWNrIHRvIGp1c3QgcmVwcmVzZW50aW5nIHRoZSBwYXRoIGRh dGEgdXNpbmcgdGhlIENHUGF0aCAobV9wYXRoKS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL1BhdGguY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHlJbmxpbmVQYXRoRGF0 YUlmTmVlZGVkIGNvbnN0KToKKworICAgICAgICBBZGQgYSBoZWxwZXIgbWV0aG9kIHRoYXQgaXMg aW52b2tlZCB3aGVuIHRoZSBQYXRoIGlzIGFza2VkIGZvciBhIENHUGF0aC4gSW4gdGhpcyBjYXNl LCBldmVuIGlmIG1fcGF0aCBpcyBudWxsLAorICAgICAgICB3ZSBuZWVkIHRvIGxhemlseSBjcmVh dGUgaXQgYW5kIGFwcGx5IGFueSBpbmxpbmUgcGF0aCBkYXRhIHdlJ3ZlIGFjY3VtdWxhdGVkLiBP bmNlIHdlJ3JlIGRvbmUgYXBwbHlpbmcgdGhlCisgICAgICAgIGlubGluZSBkYXRhLCBzZXQgYSBm bGFnIChtX25lZWRzVG9BcHBseUlubGluZURhdGEpIHRvIGZhbHNlIHRvIGF2b2lkIHJlLWFwcGx5 aW5nIGlubGluZSBkYXRhIHRvIHRoZSBwYXRoLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvUGF0aC5oOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZW5jb2RlIGNvbnN0KToKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmRlY29kZSk6CisKKyAgICAgICAgVGVhY2ggUGF0aDo6ZW5jb2Rl IGFuZCBQYXRoOjpkZWNvZGUgdG8gcmVzcGVjdGl2ZWx5IHNlcmlhbGl6ZSBhbmQgZGVzZXJpYWxp emUgV2ViQ29yZTo6UGF0aCBieSBjb25zdWx0aW5nIG9ubHkKKyAgICAgICAgdGhlIGlubGluZSBk YXRhLCBpZiBpdCBpcyBwcmVzZW50LiBGb3Igc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCB0aGlzIGRl Y3JlYXNlcyB0aGUgY29zdCBvZiBib3RoIElQQyBlbmNvZGluZyBhbmQKKyAgICAgICAgZGVjb2Rp bmcsIGJ1dCBhZGRzIGEgbmVnbGlnaWJsZSBhbW91bnQgb2Ygb3ZlcmhlYWQgaW4gdGhlIGNhc2Ug d2hlcmUgdGhlIHBhdGggaXMgbm9uLWlubGluZS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6 aGFzSW5saW5lRGF0YSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNBbnlJbmxp bmVEYXRhIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6IERl bGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6CisgICAgICAgIChXZWJDb3Jl OjpQYXRoOjpjcmVhdGVQbGF0Zm9ybVBhdGgpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2NnL1BhdGhDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjcmVhdGVQbGF0Zm9ybVBh dGgpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHlJbmxpbmVQYXRoRGF0YSk6CisgICAg ICAgIChXZWJDb3JlOjpQYXRoOjpwbGF0Zm9ybVBhdGggY29uc3QpOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKToKKworICAgICAgICBXaGVuIGVuc3VyZVBsYXRm b3JtUGF0aCBpcyBpbnZva2VkLCB3ZSBhcmUgYWJvdXQgdG8gbXV0YXRlIG91ciBDR1BhdGggaW4g c3VjaCBhIHdheSB0aGF0IGl0IGNhbid0IGJlIGV4cHJlc3NlZAorICAgICAgICBpbiB0ZXJtcyBv ZiBpbmxpbmUgZGF0YSAoYXQgbGVhc3QsIG5vdCB3aXRoIHRoZSBjaGFuZ2VzIGluIHRoaXMgcGF0 Y2gpLiBDbGVhciBvdXQgdGhlIGlubGluZSBwYXRoIGRhdGEgaW4gdGhpcworICAgICAgICBjYXNl LCBhbmQgYXBwbHkgdGhlIENHUGF0aCBtdXRhdGlvbnMgdGhhdCB3ZXJlIHByZXZpb3VzbHkgc3Rh c2hlZCBhd2F5IGluIGlubGluZSBwYXRoIGRhdGEuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6 OmlzTnVsbCBjb25zdCk6CisKKyAgICAgICAgQSBwYXRoIGlzIG5vdyBjb25zaWRlcmVkIG51bGwg aWYgaXQgaXMgbm90IG9ubHkgbWlzc2luZyBhIENHUGF0aCwgYnV0IGFsc28gZG9lcyBub3QgaGF2 ZSBhbnkgaW5saW5lIHBhdGggZGF0YS4KKyAgICAgICAgVGhpcyBtYWludGFpbnMgdGhlIGludmFy aWFudCB0aGF0IGBpc051bGwoKWAgaXMgdHJ1ZSBpZmYgdGhlIGBwbGF0Zm9ybVBhdGgoKWAgcmV0 dXJucyAweDAuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OlBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6c3dhcCk6CisKKyAgICAgICAgVXBkYXRlIHRoZSBjb25zdHJ1Y3RvcnMgYW5k IGBzd2FwYCBoZWxwZXIgbWV0aG9kICh1c2VkIGJ5IGFzc2lnbm1lbnQgb3BlcmF0b3JzKSB0byBh Y2NvdW50IGZvciB0aGUgbmV3IG1lbWJlcnMuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNv bnRhaW5zIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnRyYW5zZm9ybSk6CisgICAg ICAgIChXZWJDb3JlOjpQYXRoOjpib3VuZGluZ1JlY3QgY29uc3QpOgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6ZmFzdEJvdW5kaW5nUmVjdCBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRo Ojptb3ZlVG8pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRkTGluZVRvKToKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6CisKKyAgICAgICAgSW4gdGhlIGNhc2Ugb2YgdGhlc2Ug dGhyZWUgbWV0aG9kcyBmb3IgbXV0YXRpbmcgYSBwYXRoLCBpZiB3ZSd2ZSBlaXRoZXIgb25seSBt b3ZlZCB0aGUgcGF0aCBvciBoYXZlbid0IHRvdWNoZWQKKyAgICAgICAgaXQgYXQgYWxsLCB3ZSBj YW4gZ2V0IGF3YXkgd2l0aCBvbmx5IHVwZGF0aW5nIG91ciBpbmxpbmUgcGF0aCBkYXRhLCBhbmQg YXZvaWQgY3JlYXRpbmcgYSBDR1BhdGguCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNsZWFy KToKKworICAgICAgICBXaGVuIGNsZWFyaW5nIFBhdGgsIGluc3RlYWQgb2Ygc2V0dGluZyBgbV9w YXRoYCB0byBhIG5ld2x5IGFsbG9jYXRlZCBDR1BhdGgsIHNpbXBseSByZXNldCBpdCB0byBudWxs LiBUaGlzCisgICAgICAgIGVuc3VyZXMgdGhhdCBpZiB3ZSB0aGVuIGFwcGx5IHNvbWUgY2hhbmdl cyB0aGF0IGNhbiBiZSBleHByZXNzZWQgdXNpbmcgb25seSBpbmxpbmUgcGF0aCBkYXRhLCB3ZSBh dm9pZCBoYXZpbmcgdG8KKyAgICAgICAgdXBkYXRlIHRoZSBDR1BhdGgsIGFuZCBpbnN0ZWFkIGp1 c3QgdXBkYXRlIHRoZSBpbmxpbmUgcGF0aCBkYXRhLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRo Ojppc0VtcHR5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmN1cnJlbnRQb2ludCBj b25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseSBjb25zdCk6CisKKyAgICAgICAg VGhyb3cgb3V0IHRoZSBjdXJyZW50IFdlYkNvcmU6OlBhdGggYWZ0ZXIgd2UncmUgZG9uZSBwYWlu dGluZyB3aXRoIGl0IChzZWUgKDIpIGluIHRoZSBhYm92ZSBDaGFuZ2VMb2cgZW50cnkpLgorCisg ICAgICAgIChXZWJDb3JlOjpQYXRoOjplbGVtZW50Q291bnQgY29uc3QpOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkRpc3BsYXlMaXN0OjpTdHJva2VQYXRoOjphcHBseSBjb25zdCk6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3Jl YXRlUGxhdGZvcm1QYXRoKToKKwogMjAyMC0wMy0wNyAgRGFuaWVsIEJhdGVzICA8ZGFiYXRlc0Bh cHBsZS5jb20+CiAKICAgICAgICAgW2lPU10gSW1wbGVtZW50IHN1cHBvcnQgZm9yIGRpY3RhdGlv biBhbHRlcm5hdGl2ZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggNDM3MmJlNjQ5OGJjNzNmM2QwYjgzZGEzNWY3ZDAz YmY2ZDE1NTc5Ny4uZmMzNGRjZWZjNDVmYzgzYWViYWE2YjFmMDI3YTcwMGMxMTU4NzdhZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAyMC0wMy0wNyAgV2Vuc29uIEhzaWVoICA8d2Vuc29u X2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBMYXppbHkgZ2VuZXJhdGUgQ0dQYXRocyBmb3Ig c29tZSBzaW1wbGUgdHlwZXMgb2YgcGF0aHMsIHN1Y2ggYXMgYXJjcyBhbmQgbGluZXMKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwODQ2NAorICAgICAg ICA8cmRhcjovL3Byb2JsZW0vNTk5NjMyMjY+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQWRkIGFyZ3VtZW50IGNvZGVycyBmb3IgYFdURjo6TW9ub3N0 YXRlYCwgc28gdGhhdCBWYXJpYW50cyBvZiB0aGUgZm9ybTogYFZhcmlhbnQ8TW9ub3N0YXRlLCBG b28sIEJhcj5gIGNhbiBiZQorICAgICAgICBlbmNvZGVkIGFuZCBkZWNvZGVkIG92ZXIgSVBDLgor CisgICAgICAgICogUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcDoKKyAgICAgICAgKElQ Qzo6QXJndW1lbnRDb2RlcjxNb25vc3RhdGU+OjplbmNvZGUpOgorICAgICAgICAoSVBDOjpBcmd1 bWVudENvZGVyPE1vbm9zdGF0ZT46OmRlY29kZSk6CisgICAgICAgICogUGxhdGZvcm0vSVBDL0Fy Z3VtZW50Q29kZXJzLmg6CisKIDIwMjAtMDMtMDcgIFBlbmcgTGl1ICA8cGVuZy5saXU2QGFwcGxl LmNvbT4KIAogICAgICAgICBVc2UgdGhlIGZlYXR1cmUgZmxhZ3MgbWVjaGFuaXNtIHRvIGdpdmUg ZGVmYXVsdCBmZWF0dXJlIHByZWZlcmVuY2UgdmFsdWVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9QbGF0Zm9ybUVuYWJsZS5oIGIvU291cmNlL1dURi93dGYvUGxhdGZvcm1FbmFibGUuaApp bmRleCAzODUxZWRiYmQ5NDc2NjFiMjZiYzkyNmQzOGQzYjdhZGNmYmRkMGM2Li5kMDMwMTkxYThm OTBlYzI0ZTkyM2I3N2E3YjE3MTQ5MGViZTgxZmNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0 Zi9QbGF0Zm9ybUVuYWJsZS5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgK QEAgLTgxNyw2ICs4MTcsOSBAQAogI2RlZmluZSBFTkFCTEVfT1BFTlRZUEVfTUFUSCAxCiAjZW5k aWYKIAorI2lmICFkZWZpbmVkKEVOQUJMRV9JTkxJTkVfUEFUSF9EQVRBKSAmJiBVU0UoQ0cpCisj ZGVmaW5lIEVOQUJMRV9JTkxJTkVfUEFUSF9EQVRBIDEKKyNlbmRpZgogCiAvKiBEaXNhYmxlIFNo YXJlZEFycmF5QnVmZmVycyB1bnRpbCBTcGVjdHJlIHNlY3VyaXR5IGNvbmNlcm5zIGFyZSBtaXRp Z2F0ZWQuICovCiAjZGVmaW5lIEVOQUJMRV9TSEFSRURfQVJSQVlfQlVGRkVSIDAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJz LmNtYWtlCmluZGV4IDQ5NmJiNjQwNzc2N2U1Y2E0OTQzNzBjMmVhM2NiODljYzljOTBiNTEuLmFl NDY1ZWZkYjMwZWY2ODVhYTY0NjMzMDkyMWNmNjVlOTVlYjNlOGMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFr ZQpAQCAtMTEyNyw2ICsxMTI3LDcgQEAgc2V0KFdlYkNvcmVfUFJJVkFURV9GUkFNRVdPUktfSEVB REVSUwogICAgIHBsYXRmb3JtL2dyYXBoaWNzL0luYmFuZEdlbmVyaWNDdWUuaAogICAgIHBsYXRm b3JtL2dyYXBoaWNzL0luYmFuZFRleHRUcmFja1ByaXZhdGUuaAogICAgIHBsYXRmb3JtL2dyYXBo aWNzL0luYmFuZFRleHRUcmFja1ByaXZhdGVDbGllbnQuaAorICAgIHBsYXRmb3JtL2dyYXBoaWNz L0lubGluZVBhdGhEYXRhLmgKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9JbnRQb2ludC5oCiAgICAg cGxhdGZvcm0vZ3JhcGhpY3MvSW50UG9pbnRIYXNoLmgKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9J bnRSZWN0LmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagppbmRleCBkMWIwYWY4ZTZjMDFmZTgxY2VjYWZjNjIxNDMwZTkyOTdmOWQyMDJjLi4y NWI4ODczYTNjOWQ1NjNiMTkxMDk1MjNmMTNmNGYwMjUxY2IyNDNiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNl L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00OTc3LDYgKzQ5 NzcsNyBAQAogCQlGNDQyQzM1OTIzRTNBREQyMDA0OTk1ODIgLyogQ29tcG9zaXRpb25IaWdobGln aHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NDJD MzU3MjNFM0FDNTEwMDQ5OTU4MiAvKiBDb21wb3NpdGlvbkhpZ2hsaWdodC5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0NEE1RjU5MUZFRDM4RjIw MDdGNTk0NCAvKiBMZWdhY3lOU1Bhc3RlYm9hcmRUeXBlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ0QTVGNTcxRkVEMzgzMDAwN0Y1OTQ0IC8qIExl Z2FjeU5TUGFzdGVib2FyZFR5cGVzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKIAkJRjQ0RUJCRDkxREI1RDIxNDAwMjc3MzM0IC8qIFN0YXRpY1Jhbmdl LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDRFQkJE ODFEQjVEMjE0MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlGNDU3NzVDRTI0MTQzN0Q1MDAyREYxQTAgLyog SW5saW5lUGF0aERhdGEuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEY0NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovOyBz ZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0NUMyMzFFMTk5 NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAv KiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQlGNDY3MjkyODFFMERFNjg1MDBBQ0MzRDggLyogU2Nyb2xsU25h cE9mZnNldHNJbmZvLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBGNDY3MjkyNTFFMERFNUFCMDBBQ0MzRDggLyogU2Nyb2xsU25hcE9mZnNldHNJbmZvLmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ2QzQ0 N0UyMzQ2NTQ1NDAwMzlBNzlEIC8qIENsaXBib2FyZEl0ZW1CaW5kaW5nc0RhdGFTb3VyY2UuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NkM0NDdDMjM0 NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVtQmluZGluZ3NEYXRhU291cmNlLmggKi87IH07 CkBAIC0xNTQ2NSw2ICsxNTQ2Niw3IEBACiAJCUY0NEVCQkQ2MURCNUQxQjYwMDI3NzMzNCAvKiBT dGF0aWNSYW5nZS5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gU3RhdGljUmFuZ2UuaWRsOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDRFQkJEODFEQjVEMjE0MDAyNzczMzQgLyog U3RhdGljUmFuZ2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU3RhdGljUmFu Z2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ0RUJCREExREI1REQ5RDAwMjc3 MzM0IC8qIFN0YXRpY1JhbmdlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IFN0YXRpY1JhbmdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1Nzc1 Q0QyNDE0MzdENTAwMkRGMUEwIC8qIElubGluZVBhdGhEYXRhLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElu bGluZVBhdGhEYXRhLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NUMyMzFCMTk5 NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ1QzIzMUMxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNT Y3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBeGlz U2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ2MjhB OUUyMzREM0JCRjAwQkM4ODRDIC8qIFBsYXRmb3JtUGFzdGVib2FyZENvY29hLm1tICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUGxhdGZvcm1QYXN0ZWJvYXJkQ29jb2Eu bW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yNTEyNyw2ICsyNTEyOSw3IEBACiAJ CQkJMDcwNkEwRDcyNDA4MzBBNjAwRTkzODE4IC8qIEluYmFuZEdlbmVyaWNDdWVJZGVudGlmaWVy LmggKi8sCiAJCQkJMDc5NDE3OTMxNjZFQTA0RTAwOTQxNkMyIC8qIEluYmFuZFRleHRUcmFja1By aXZhdGUuaCAqLywKIAkJCQkwN0NFNzdENDE2NzEyQTZBMDBDNTVBNDcgLyogSW5iYW5kVGV4dFRy YWNrUHJpdmF0ZUNsaWVudC5oICovLAorCQkJCUY0NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJ bmxpbmVQYXRoRGF0YS5oICovLAogCQkJCTJENDZGMDREMTdCOTZGQkQwMDU2NDdGMCAvKiBJbnRQ b2ludC5jcHAgKi8sCiAJCQkJQjI3NTM1NDQwQjA1MzgxNDAwMkNFNjRGIC8qIEludFBvaW50Lmgg Ki8sCiAJCQkJRTQ2MkE0QTAxMTNFNzFCRTAwNEE0MjIwIC8qIEludFBvaW50SGFzaC5oICovLApA QCAtMzA0MTYsNiArMzA0MTksNyBAQAogCQkJCTZGQjI0MDA1MjNERkYxMjgwMDc5NjQ1OCAvKiBJ bmxpbmVMaW5lQm94QnVpbGRlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNkZFMTk4MTcyMTc4Mzk3 QzAwNDQ2RjA4IC8qIElubGluZUxpbmVCcmVha2VyLmggaW4gSGVhZGVycyAqLywKIAkJCQk2RjBD RDY5NTIyOUVEMzI3MDBDNTk5NEUgLyogSW5saW5lTGluZUJ1aWxkZXIuaCBpbiBIZWFkZXJzICov LAorCQkJCUY0NTc3NUNFMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oIGluIEhl YWRlcnMgKi8sCiAJCQkJNkYzNjBFNTAyMzk5OTQyMTAwMTUxMkE3IC8qIElubGluZVNvZnRMaW5l QnJlYWtJdGVtLmggaW4gSGVhZGVycyAqLywKIAkJCQlBQTRDM0E3NzBCMkIxNjc5MDAyMzM0QTIg LyogSW5saW5lU3R5bGVTaGVldE93bmVyLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQ0VBNDg1QTA5 N0Q5MzAyMDA5NEM5RTQgLyogSW5saW5lVGV4dEJveC5oIGluIEhlYWRlcnMgKi8sCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9JbmxpbmVQYXRoRGF0YS5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5lUGF0aERhdGEuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi42NTM1OWFiYWVjMDYyMTBlMTg5NDhlNTBlNjA4ZDlhNWZlYzkxYTQ2Ci0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5lUGF0aERhdGEu aApAQCAtMCwwICsxLDEzNyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICog QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5B QkxFKElOTElORV9QQVRIX0RBVEEpCisKKyNpbmNsdWRlICJGbG9hdFBvaW50LmgiCisjaW5jbHVk ZSA8d3RmL09wdGlvbmFsLmg+CisjaW5jbHVkZSA8d3RmL1ZhcmlhbnQuaD4KKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitzdHJ1Y3QgTGluZURhdGEgeworICAgIEZsb2F0UG9pbnQgc3RhcnQ7Cisg ICAgRmxvYXRQb2ludCBlbmQ7CisKKyAgICB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIGVu Y29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGlj IE9wdGlvbmFsPExpbmVEYXRhPiBkZWNvZGUoRGVjb2RlciYpOworfTsKKworc3RydWN0IEFyY0Rh dGEgeworICAgIEZsb2F0UG9pbnQgb2Zmc2V0OworICAgIEZsb2F0UG9pbnQgY2VudGVyOworICAg IGZsb2F0IHJhZGl1cyB7IDAgfTsKKyAgICBmbG9hdCBzdGFydCB7IDAgfTsKKyAgICBmbG9hdCBl bmQgeyAwIH07CisgICAgYm9vbCBjbG9ja3dpc2UgeyBmYWxzZSB9OworICAgIGJvb2wgaGFzT2Zm c2V0IHsgZmFsc2UgfTsKKworICAgIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgZW5jb2Rl KEVuY29kZXImKSBjb25zdDsKKyAgICB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBzdGF0aWMgT3B0 aW9uYWw8QXJjRGF0YT4gZGVjb2RlKERlY29kZXImKTsKK307CisKK3N0cnVjdCBNb3ZlRGF0YSB7 CisgICAgRmxvYXRQb2ludCBsb2NhdGlvbjsKKworICAgIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+ IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKKyAgICB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVy PiBzdGF0aWMgT3B0aW9uYWw8TW92ZURhdGE+IGRlY29kZShEZWNvZGVyJik7Cit9OworCit0ZW1w bGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIE1vdmVEYXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2Rl cikgY29uc3QKK3sKKyAgICBlbmNvZGVyIDw8IGxvY2F0aW9uOworfQorCit0ZW1wbGF0ZTxjbGFz cyBEZWNvZGVyPiBPcHRpb25hbDxNb3ZlRGF0YT4gTW92ZURhdGE6OmRlY29kZShEZWNvZGVyJiBk ZWNvZGVyKQoreworICAgIE1vdmVEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShk YXRhLmxvY2F0aW9uKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICByZXR1cm4g eyBkYXRhIH07Cit9CisKK3RlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgTGluZURhdGE6OmVu Y29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIgPDwgc3RhcnQ7Cisg ICAgZW5jb2RlciA8PCBlbmQ7Cit9CisKK3RlbXBsYXRlPGNsYXNzIERlY29kZXI+IE9wdGlvbmFs PExpbmVEYXRhPiBMaW5lRGF0YTo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCit7CisgICAgTGlu ZURhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuc3RhcnQpKQorICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLmVu ZCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICByZXR1cm4geyBXVEZNb3Zl KGRhdGEpIH07Cit9CisKK3RlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgQXJjRGF0YTo6ZW5j b2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCBvZmZzZXQ7Cisg ICAgZW5jb2RlciA8PCBjZW50ZXI7CisgICAgZW5jb2RlciA8PCByYWRpdXM7CisgICAgZW5jb2Rl ciA8PCBzdGFydDsKKyAgICBlbmNvZGVyIDw8IGVuZDsKKyAgICBlbmNvZGVyIDw8IGNsb2Nrd2lz ZTsKKyAgICBlbmNvZGVyIDw8IGhhc09mZnNldDsKK30KKwordGVtcGxhdGU8Y2xhc3MgRGVjb2Rl cj4gT3B0aW9uYWw8QXJjRGF0YT4gQXJjRGF0YTo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCit7 CisgICAgQXJjRGF0YSBkYXRhOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5vZmZzZXQp KQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29k ZShkYXRhLmNlbnRlcikpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAo IWRlY29kZXIuZGVjb2RlKGRhdGEucmFkaXVzKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9w dDsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5zdGFydCkpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuZW5kKSkKKyAg ICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0 YS5jbG9ja3dpc2UpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFk ZWNvZGVyLmRlY29kZShkYXRhLmhhc09mZnNldCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxv cHQ7CisKKyAgICByZXR1cm4geyBXVEZNb3ZlKGRhdGEpIH07Cit9CisKK3VzaW5nIElubGluZVBh dGhEYXRhID0gVmFyaWFudDxNb25vc3RhdGUsIE1vdmVEYXRhLCBMaW5lRGF0YSwgQXJjRGF0YT47 CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShJTkxJTkVfUEFU SF9EQVRBKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0 aC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmNwcAppbmRleCBh NjI4ZDM3NDIyNDIzYzEyMDM1NGZmZmYyMTkwNjE3ZjcyYjQzODUyLi4zNTUxNTdmZDAxNGI0NzBm ZjZlNDRiNGVlYmFhZDMxYjQwNjFiMzA3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9QYXRoLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9QYXRoLmNwcApAQCAtMTg4LDYgKzE4OCwyNiBAQCBGbG9hdFJlY3QgUGF0aDo6ZmFzdEJv dW5kaW5nUmVjdCgpIGNvbnN0CiB9CiAjZW5kaWYKIAorI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9E QVRBKQorCit2b2lkIFBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCgpIGNvbnN0Cit7 CisgICAgaWYgKCFtX25lZWRzVG9BcHBseUlubGluZURhdGEpCisgICAgICAgIHJldHVybjsKKwor ICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IGZhbHNlOworCisgICAgaWYgKCFoYXNBbnlJ bmxpbmVEYXRhKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9wYXRoKQorICAgICAg ICBtX3BhdGggPSBjcmVhdGVQbGF0Zm9ybVBhdGgoKTsKKworICAgIGFwcGx5SW5saW5lUGF0aERh dGEobV9pbmxpbmVEYXRhLCBtX3BhdGguZ2V0KCkpOworfQorCisjZW5kaWYgLy8gRU5BQkxFKElO TElORV9QQVRIX0RBVEEpCisKICNpZm5kZWYgTkRFQlVHCiB2b2lkIFBhdGg6OmR1bXAoKSBjb25z dAogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCmluZGV4IDdmYWRhNjBk ODNjMjkyNTBhYzRhMTc0OGE4OTI0MDcwMjkxOTllMWIuLmQwM2I0ZDdhZTNkZmYzYzU4MTE2MDA0 MGJkNzQzYzUzNDcwMmI5YmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL1BhdGguaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRo LmgKQEAgLTI1LDE0ICsyNSwxNSBAQAogICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCiAgKi8KIAotI2lmbmRlZiBQ YXRoX2gKLSNkZWZpbmUgUGF0aF9oCisjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIkZsb2F0UmVj dC5oIgorI2luY2x1ZGUgIklubGluZVBhdGhEYXRhLmgiCiAjaW5jbHVkZSAiV2luZFJ1bGUuaCIK ICNpbmNsdWRlIDx3dGYvRmFzdE1hbGxvYy5oPgogI2luY2x1ZGUgPHd0Zi9GdW5jdGlvbi5oPgog I2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+CisjaW5jbHVkZSA8d3RmL1ZhcmlhbnQuaD4KIAogI2lm IFVTRShDRykKIApAQCAtMTQ3LDcgKzE0OCw3IEBAIHB1YmxpYzoKICAgICBGbG9hdFBvaW50IHBv aW50QXRMZW5ndGgoZmxvYXQgbGVuZ3RoKSBjb25zdDsKIAogICAgIFdFQkNPUkVfRVhQT1JUIHZv aWQgY2xlYXIoKTsKLSAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICFtX3BhdGg7IH0K KyAgICBXRUJDT1JFX0VYUE9SVCBib29sIGlzTnVsbCgpIGNvbnN0OwogICAgIGJvb2wgaXNFbXB0 eSgpIGNvbnN0OwogICAgIC8vIEdldHMgdGhlIGN1cnJlbnQgcG9pbnQgb2YgdGhlIGN1cnJlbnQg cGF0aCwgd2hpY2ggaXMgY29uY2VwdHVhbGx5IHRoZSBmaW5hbCBwb2ludCByZWFjaGVkIGJ5IHRo ZSBwYXRoIHNvIGZhci4KICAgICAvLyBOb3RlIHRoZSBQYXRoIGNhbiBiZSBlbXB0eSAoaXNFbXB0 eSgpID09IHRydWUpIGFuZCBzdGlsbCBoYXZlIGEgY3VycmVudCBwb2ludC4KQEAgLTE4NSw3ICsx ODYsNyBAQCBwdWJsaWM6CiAgICAgRmxvYXRSZWN0IGZhc3RCb3VuZGluZ1JlY3RGb3JTdHJva2Uo Y29uc3QgUGxhdGZvcm1Db250ZXh0RGlyZWN0MkQmKSBjb25zdDsKICAgICBQbGF0Zm9ybVBhdGhQ dHIgcGxhdGZvcm1QYXRoKCkgY29uc3QgeyByZXR1cm4gbV9wYXRoLmdldCgpOyB9CiAjZWxpZiBV U0UoQ0cpCi0gICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJu IG1fcGF0aC5nZXQoKTsgfQorICAgIFdFQkNPUkVfRVhQT1JUIFBsYXRmb3JtUGF0aFB0ciBwbGF0 Zm9ybVBhdGgoKSBjb25zdDsKICNlbHNlCiAgICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0 aCgpIGNvbnN0IHsgcmV0dXJuIG1fcGF0aDsgfQogI2VuZGlmCkBAIC0yMjUsNiArMjI2LDE1IEBA IHB1YmxpYzoKICAgICB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBzdGF0aWMgT3B0aW9uYWw8UGF0 aD4gZGVjb2RlKERlY29kZXImKTsKIAogcHJpdmF0ZToKKyAgICBzdGF0aWMgUGxhdGZvcm1QYXRo U3RvcmFnZVR5cGUgY3JlYXRlUGxhdGZvcm1QYXRoKCk7CisKKyNpZiBFTkFCTEUoSU5MSU5FX1BB VEhfREFUQSkKKyAgICBzdGF0aWMgdm9pZCBhcHBseUlubGluZVBhdGhEYXRhKGNvbnN0IElubGlu ZVBhdGhEYXRhJiwgUGxhdGZvcm1QYXRoUHRyKTsKKyAgICB0ZW1wbGF0ZSA8dHlwZW5hbWUgRGF0 YVR5cGU+IGJvb2wgaGFzSW5saW5lRGF0YSgpIGNvbnN0OworICAgIGJvb2wgaGFzQW55SW5saW5l RGF0YSgpIGNvbnN0OworICAgIHZvaWQgYXBwbHlJbmxpbmVQYXRoRGF0YUlmTmVlZGVkKCkgY29u c3Q7CisjZW5kaWYKKwogI2lmIFVTRShDRykKICAgICB2b2lkIHN3YXAoUGF0aCYpOwogI2VuZGlm CkBAIC0yMzcsNiArMjQ3LDEwIEBAIHByaXZhdGU6CiAgICAgbXV0YWJsZSBib29sIG1fZmlndXJl SXNPcGVuZWQgeyBmYWxzZSB9OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoSU5MSU5FX1BBVEhfREFU QSkKKyAgICBJbmxpbmVQYXRoRGF0YSBtX2lubGluZURhdGE7CisgICAgbXV0YWJsZSBib29sIG1f bmVlZHNUb0FwcGx5SW5saW5lRGF0YSB7IGZhbHNlIH07CisjZW5kaWYKICNpZiBVU0UoQ0cpCiAg ICAgbXV0YWJsZSBib29sIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiB7IGZhbHNlIH07CiAjZW5k aWYKQEAgLTI0Niw2ICsyNjAsMTUgQEAgV1RGOjpUZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFdURjo6 VGV4dFN0cmVhbSYsIGNvbnN0IFBhdGgmKTsKIAogdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9p ZCBQYXRoOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKIHsKKyNpZiBFTkFCTEUoSU5M SU5FX1BBVEhfREFUQSkKKyAgICBib29sIGhhc0lubGluZURhdGEgPSBoYXNBbnlJbmxpbmVEYXRh KCk7CisgICAgZW5jb2RlciA8PCBoYXNJbmxpbmVEYXRhOworICAgIGlmIChoYXNJbmxpbmVEYXRh KSB7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxpbmVEYXRhOworICAgICAgICByZXR1cm47Cisg ICAgfQorI2VuZGlmCisKICAgICBlbmNvZGVyIDw8IHN0YXRpY19jYXN0PHVpbnQ2NF90PihlbGVt ZW50Q291bnQoKSk7CiAKICAgICBhcHBseShbJl0oYXV0byYgZWxlbWVudCkgewpAQCAtMjc2LDYg KzI5OSwyMSBAQCB0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIFBhdGg6OmVuY29kZShFbmNv ZGVyJiBlbmNvZGVyKSBjb25zdAogdGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0 aD4gUGF0aDo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCiB7CiAgICAgUGF0aCBwYXRoOworCisj aWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgYm9vbCBoYXNJbmxpbmVEYXRhOworICAg IGlmICghZGVjb2Rlci5kZWNvZGUoaGFzSW5saW5lRGF0YSkpCisgICAgICAgIHJldHVybiBXVEY6 Om51bGxvcHQ7CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YSkgeworICAgICAgICBpZiAoIWRlY29k ZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhKSkKKyAgICAgICAgICAgIHJldHVybiBXVEY6Om51 bGxvcHQ7CisKKyAgICAgICAgcGF0aC5tX25lZWRzVG9BcHBseUlubGluZURhdGEgPSB0cnVlOwor ICAgICAgICByZXR1cm4geyBXVEZNb3ZlKHBhdGgpIH07CisgICAgfQorI2VuZGlmCisKICAgICB1 aW50NjRfdCBudW1Qb2ludHM7CiAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShudW1Qb2ludHMpKQog ICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OwpAQCAtMzM2LDkgKzM3NCwyMSBAQCB0ZW1wbGF0 ZTxjbGFzcyBEZWNvZGVyPiBPcHRpb25hbDxQYXRoPiBQYXRoOjpkZWNvZGUoRGVjb2RlciYgZGVj b2RlcikKICAgICAgICAgfQogICAgIH0KIAotICAgIHJldHVybiBwYXRoOworICAgIHJldHVybiB7 IFdURk1vdmUocGF0aCkgfTsKIH0KIAorI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCit0 ZW1wbGF0ZSA8dHlwZW5hbWUgRGF0YVR5cGU+IGlubGluZSBib29sIFBhdGg6Omhhc0lubGluZURh dGEoKSBjb25zdAoreworICAgIHJldHVybiBXVEY6OmhvbGRzX2FsdGVybmF0aXZlPERhdGFUeXBl PihtX2lubGluZURhdGEpOworfQorCitpbmxpbmUgYm9vbCBQYXRoOjpoYXNBbnlJbmxpbmVEYXRh KCkgY29uc3QKK3sKKyAgICByZXR1cm4gIWhhc0lubGluZURhdGE8TW9ub3N0YXRlPigpOwogfQog CiAjZW5kaWYKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL1BhdGhDYWlyby5jcHAKaW5kZXggZTFiNTU0Yzg4 NGMxNTJkNWE5OGIwNGE5N2NhNDc3M2Y1NDczODYzYi4uMzZmMzE3NGVmZmNkZmM5NDk3MWI4YzQ3 NDcwMDk0YzAyMmI4NGRmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jYWlyby9QYXRoQ2Fpcm8uY3BwCkBAIC00NTUsNiArNDU1LDE2IEBAIHZvaWQgUGF0 aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIGNhaXJv X3RyYW5zZm9ybShjciwgJm1hdHJpeCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29uc3QK K3sKKyAgICByZXR1cm4gIW1fcGF0aDsKK30KKworQ2Fpcm9QYXRoKiBQYXRoOjpjcmVhdGVQbGF0 Zm9ybVBhdGgoKQoreworICAgIHJldHVybiBuZXcgQ2Fpcm9QYXRoOworfQorCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBVU0UoQ0FJUk8pCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAppbmRleCA1MjFjMTU1M2E5YTZhMzRhMzgx YzM0Zjk3ODYyNTRkZDVmMGM3MjZlLi45NDU4NzJhMzQyMWM3MDViODNjNGM1ZDM4YWIxYTI0M2E1 ODVkNDJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Q YXRoQ0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdGhD Ry5jcHAKQEAgLTgxLDYgKzgxLDMwIEBAIFBhdGggUGF0aDo6cG9seWdvblBhdGhGcm9tUG9pbnRz KGNvbnN0IFZlY3RvcjxGbG9hdFBvaW50PiYgcG9pbnRzKQogICAgIHJldHVybiBwYXRoOwogfQog CitSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4gUGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoKCkK K3sKKyAgICByZXR1cm4gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlKCkpOworfQorCit2b2lk IFBhdGg6OmFwcGx5SW5saW5lUGF0aERhdGEoY29uc3QgSW5saW5lUGF0aERhdGEmIGRhdGEsIENH TXV0YWJsZVBhdGhSZWYgcGF0aCkKK3sKKyAgICBXVEY6OnN3aXRjaE9uKGRhdGEsCisgICAgICAg IFsmXShhdXRvKSB7IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9LAorICAgICAgICBbJl0oY29uc3Qg TW92ZURhdGEmIG1vdmUpIHsKKyAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KHBhdGgsIG51 bGxwdHIsIG1vdmUubG9jYXRpb24ueCgpLCBtb3ZlLmxvY2F0aW9uLnkoKSk7CisgICAgICAgIH0s CisgICAgICAgIFsmXShjb25zdCBMaW5lRGF0YSYgbGluZSkgeworICAgICAgICAgICAgQ0dQYXRo TW92ZVRvUG9pbnQocGF0aCwgbnVsbHB0ciwgbGluZS5zdGFydC54KCksIGxpbmUuc3RhcnQueSgp KTsKKyAgICAgICAgICAgIENHUGF0aEFkZExpbmVUb1BvaW50KHBhdGgsIG51bGxwdHIsIGxpbmUu ZW5kLngoKSwgbGluZS5lbmQueSgpKTsKKyAgICAgICAgfSwKKyAgICAgICAgWyZdKGNvbnN0IEFy Y0RhdGEmIGFyYykgeworICAgICAgICAgICAgaWYgKGFyYy5oYXNPZmZzZXQpCisgICAgICAgICAg ICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQocGF0aCwgbnVsbHB0ciwgYXJjLm9mZnNldC54KCksIGFy Yy5vZmZzZXQueSgpKTsKKyAgICAgICAgICAgIENHUGF0aEFkZEFyYyhwYXRoLCBudWxscHRyLCBh cmMuY2VudGVyLngoKSwgYXJjLmNlbnRlci55KCksIGFyYy5yYWRpdXMsIGFyYy5zdGFydCwgYXJj LmVuZCwgYXJjLmNsb2Nrd2lzZSk7CisgICAgICAgIH0KKyAgICApOworfQorCiBQYXRoOjpQYXRo KFJldGFpblB0cjxDR011dGFibGVQYXRoUmVmPiYmIHBhdGgpCiAgICAgOiBtX3BhdGgoV1RGTW92 ZShwYXRoKSkKIHsKQEAgLTg5LDYgKzExMywxMiBAQCBQYXRoOjpQYXRoKFJldGFpblB0cjxDR011 dGFibGVQYXRoUmVmPiYmIHBhdGgpCiBQYXRoOjpQYXRoKCkgPSBkZWZhdWx0OwogUGF0aDo6flBh dGgoKSA9IGRlZmF1bHQ7CiAKK1BsYXRmb3JtUGF0aFB0ciBQYXRoOjpwbGF0Zm9ybVBhdGgoKSBj b25zdAoreworICAgIGFwcGx5SW5saW5lUGF0aERhdGFJZk5lZWRlZCgpOworICAgIHJldHVybiBt X3BhdGguZ2V0KCk7Cit9CisKIFBsYXRmb3JtUGF0aFB0ciBQYXRoOjplbnN1cmVQbGF0Zm9ybVBh dGgoKQogewogICAgIGlmICghbV9wYXRoKQpAQCAtOTgsMTIgKzEyOCwyMSBAQCBQbGF0Zm9ybVBh dGhQdHIgUGF0aDo6ZW5zdXJlUGxhdGZvcm1QYXRoKCkKICAgICAgICAgICAgIG1fcGF0aCA9IGFk b3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHkobV9wYXRoLmdldCgpKSk7CiAgICAgICAgIG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwogICAgIH0KKyAgICBhcHBseUlubGluZVBh dGhEYXRhSWZOZWVkZWQoKTsKKyAgICBtX2lubGluZURhdGEgPSBNb25vc3RhdGUgeyB9OwogICAg IHJldHVybiBtX3BhdGguZ2V0KCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29uc3QKK3sK KyAgICByZXR1cm4gIW1fcGF0aCAmJiAhaGFzQW55SW5saW5lRGF0YSgpOworfQorCiBQYXRoOjpQ YXRoKGNvbnN0IFBhdGgmIG90aGVyKQogewogICAgIG1fcGF0aCA9IHsgb3RoZXIubV9wYXRoIH07 CisgICAgbV9pbmxpbmVEYXRhID0gb3RoZXIubV9pbmxpbmVEYXRhOworICAgIG1fbmVlZHNUb0Fw cGx5SW5saW5lRGF0YSA9IG90aGVyLm1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YTsKICAgICBpZiAo bV9wYXRoKSB7CiAgICAgICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CiAgICAg ICAgIG90aGVyLm1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IHRydWU7CkBAIC0xMTIsNiArMTUx LDggQEAgUGF0aDo6UGF0aChjb25zdCBQYXRoJiBvdGhlcikKIAogUGF0aDo6UGF0aChQYXRoJiYg b3RoZXIpCiAgICAgOiBtX3BhdGgoc3RkOjpleGNoYW5nZShvdGhlci5tX3BhdGgsIG51bGxwdHIp KQorICAgICwgbV9pbmxpbmVEYXRhKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9pbmxpbmVEYXRhLCBN b25vc3RhdGUgeyB9KSkKKyAgICAsIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YShzdGQ6OmV4Y2hh bmdlKG90aGVyLm1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSwgZmFsc2UpKQogICAgICwgbV9jb3B5 UGF0aEJlZm9yZU11dGF0aW9uKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9jb3B5UGF0aEJlZm9yZU11 dGF0aW9uLCBmYWxzZSkpCiB7CiB9CkBAIC0xMTksNiArMTYwLDggQEAgUGF0aDo6UGF0aChQYXRo JiYgb3RoZXIpCiB2b2lkIFBhdGg6OnN3YXAoUGF0aCYgb3RoZXJQYXRoKQogewogICAgIHN0ZDo6 c3dhcChtX3BhdGgsIG90aGVyUGF0aC5tX3BhdGgpOworICAgIHN0ZDo6c3dhcChtX2lubGluZURh dGEsIG90aGVyUGF0aC5tX2lubGluZURhdGEpOworICAgIHN0ZDo6c3dhcChtX25lZWRzVG9BcHBs eUlubGluZURhdGEsIG90aGVyUGF0aC5tX25lZWRzVG9BcHBseUlubGluZURhdGEpOwogICAgIHN0 ZDo6c3dhcChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24sIG90aGVyUGF0aC5tX2NvcHlQYXRoQmVm b3JlTXV0YXRpb24pOwogfQogCkBAIC0xNzksNyArMjIyLDcgQEAgYm9vbCBQYXRoOjpjb250YWlu cyhjb25zdCBGbG9hdFBvaW50ICZwb2ludCwgV2luZFJ1bGUgcnVsZSkgY29uc3QKICAgICAgICAg cmV0dXJuIGZhbHNlOwogCiAgICAgLy8gQ0dQYXRoQ29udGFpbnNQb2ludCByZXR1cm5zIGZhbHNl IGZvciBub24tY2xvc2VkIHBhdGhzLCBhcyBhIHdvcmstYXJvdW5kLCB3ZSBjb3B5IGFuZCBjbG9z ZSB0aGUgcGF0aCBmaXJzdC4gIFJhZGFyIDQ3NTg5OTggYXNrcyBmb3IgYSBiZXR0ZXIgQ0cgQVBJ IHRvIHVzZQotICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoY29weUNHUGF0aENsb3NpbmdTdWJwYXRo cyhtX3BhdGguZ2V0KCkpKTsKKyAgICBhdXRvIHBhdGggPSBhZG9wdENGKGNvcHlDR1BhdGhDbG9z aW5nU3VicGF0aHMocGxhdGZvcm1QYXRoKCkpKTsKICAgICBib29sIHJldCA9IENHUGF0aENvbnRh aW5zUG9pbnQocGF0aC5nZXQoKSwgMCwgcG9pbnQsIHJ1bGUgPT0gV2luZFJ1bGU6OkV2ZW5PZGQg PyB0cnVlIDogZmFsc2UpOwogICAgIHJldHVybiByZXQ7CiB9CkBAIC0yMTcsOSArMjYwLDkgQEAg dm9pZCBQYXRoOjp0cmFuc2Zvcm0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAg ICAgQ0dBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtQ0cgPSB0cmFuc2Zvcm07CiAjaWYgUExBVEZP Uk0oV0lOKQogICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsK LSAgICBDR1BhdGhBZGRQYXRoKHBhdGguZ2V0KCksICZ0cmFuc2Zvcm1DRywgbV9wYXRoLmdldCgp KTsKKyAgICBDR1BhdGhBZGRQYXRoKHBhdGguZ2V0KCksICZ0cmFuc2Zvcm1DRywgZW5zdXJlUGxh dGZvcm1QYXRoKCkpOwogI2Vsc2UKLSAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0 ZU11dGFibGVDb3B5QnlUcmFuc2Zvcm1pbmdQYXRoKG1fcGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNH KSk7CisgICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weUJ5VHJh bnNmb3JtaW5nUGF0aChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgJnRyYW5zZm9ybUNHKSk7CiAjZW5k aWYKICAgICBtX3BhdGggPSBXVEZNb3ZlKHBhdGgpOwogICAgIG1fY29weVBhdGhCZWZvcmVNdXRh dGlvbiA9IGZhbHNlOwpAQCAtMjMwLDkgKzI3MywxOSBAQCBGbG9hdFJlY3QgUGF0aDo6Ym91bmRp bmdSZWN0KCkgY29uc3QKICAgICBpZiAoaXNOdWxsKCkpCiAgICAgICAgIHJldHVybiBDR1JlY3Ra ZXJvOwogCisgICAgaWYgKGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpCisgICAgICAgIHJldHVy biB7IH07CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4oKSkgeworICAgICAgICBG bG9hdFJlY3QgcmVzdWx0OworICAgICAgICBhdXRvJiBsaW5lID0gV1RGOjpnZXQ8TGluZURhdGE+ KG1faW5saW5lRGF0YSk7CisgICAgICAgIHJlc3VsdC5maXRUb1BvaW50cyhsaW5lLnN0YXJ0LCBs aW5lLmVuZCk7CisgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgfQorCiAgICAgLy8gQ0dQYXRo R2V0Qm91bmRpbmdCb3ggaW5jbHVkZXMgdGhlIHBhdGgncyBjb250cm9sIHBvaW50cywgQ0dQYXRo R2V0UGF0aEJvdW5kaW5nQm94IGRvZXMgbm90LgogCi0gICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRo R2V0UGF0aEJvdW5kaW5nQm94KG1fcGF0aC5nZXQoKSk7CisgICAgQ0dSZWN0IGJvdW5kID0gQ0dQ YXRoR2V0UGF0aEJvdW5kaW5nQm94KHBsYXRmb3JtUGF0aCgpKTsKICAgICByZXR1cm4gQ0dSZWN0 SXNOdWxsKGJvdW5kKSA/IENHUmVjdFplcm8gOiBib3VuZDsKIH0KIApAQCAtMjQwLDcgKzI5Mywx OCBAQCBGbG9hdFJlY3QgUGF0aDo6ZmFzdEJvdW5kaW5nUmVjdCgpIGNvbnN0CiB7CiAgICAgaWYg KGlzTnVsbCgpKQogICAgICAgICByZXR1cm4gQ0dSZWN0WmVybzsKLSAgICBDR1JlY3QgYm91bmQg PSBDR1BhdGhHZXRCb3VuZGluZ0JveChtX3BhdGguZ2V0KCkpOworCisgICAgaWYgKGhhc0lubGlu ZURhdGE8TW92ZURhdGE+KCkpCisgICAgICAgIHJldHVybiB7IH07CisKKyAgICBpZiAoaGFzSW5s aW5lRGF0YTxMaW5lRGF0YT4oKSkgeworICAgICAgICBGbG9hdFJlY3QgcmVzdWx0OworICAgICAg ICBhdXRvJiBsaW5lID0gV1RGOjpnZXQ8TGluZURhdGE+KG1faW5saW5lRGF0YSk7CisgICAgICAg IHJlc3VsdC5maXRUb1BvaW50cyhsaW5lLnN0YXJ0LCBsaW5lLmVuZCk7CisgICAgICAgIHJldHVy biByZXN1bHQ7CisgICAgfQorCisgICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0Qm91bmRpbmdC b3gocGxhdGZvcm1QYXRoKCkpOwogICAgIHJldHVybiBDR1JlY3RJc051bGwoYm91bmQpID8gQ0dS ZWN0WmVybyA6IGJvdW5kOwogfQogCkBAIC0yNjksMTEgKzMzMywyMyBAQCBGbG9hdFJlY3QgUGF0 aDo6c3Ryb2tlQm91bmRpbmdSZWN0KFN0cm9rZVN0eWxlQXBwbGllciogYXBwbGllcikgY29uc3QK IAogdm9pZCBQYXRoOjptb3ZlVG8oY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCiB7CisgICAgaWYg KGlzTnVsbCgpIHx8IGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpIHsKKyAgICAgICAgbV9pbmxp bmVEYXRhID0gTW92ZURhdGEgeyBwb2ludCB9OworICAgICAgICBtX25lZWRzVG9BcHBseUlubGlu ZURhdGEgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgQ0dQYXRoTW92ZVRv UG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHBvaW50LngoKSwgcG9pbnQueSgp KTsKIH0KIAogdm9pZCBQYXRoOjphZGRMaW5lVG8oY29uc3QgRmxvYXRQb2ludCYgcCkKIHsKKyAg ICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkgeworICAgICAgICBt X2lubGluZURhdGEgPSBMaW5lRGF0YSB7IGhhc0FueUlubGluZURhdGEoKSA/IFdURjo6Z2V0PE1v dmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uIDogRmxvYXRQb2ludCgpLCBwIH07CisgICAg ICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKICAgICBDR1BhdGhBZGRMaW5lVG9Qb2ludChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVs bHB0ciwgcC54KCksIHAueSgpKTsKIH0KIApAQCAtMzU2LDYgKzQzMiwxMiBAQCB2b2lkIFBhdGg6 OmFkZEFyYyhjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByYWRpdXMsIGZsb2F0IHN0YXJ0QW5n bGUsIGZsb2F0IGVuZAogICAgIGlmICghc3RkOjppc2Zpbml0ZShzdGFydEFuZ2xlKSB8fCAhc3Rk Ojppc2Zpbml0ZShlbmRBbmdsZSkpCiAgICAgICAgIHJldHVybjsKIAorICAgIGlmIChpc051bGwo KSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9 IEFyY0RhdGEgeyBoYXNBbnlJbmxpbmVEYXRhKCkgPyBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxp bmVEYXRhKS5sb2NhdGlvbiA6IEZsb2F0UG9pbnQoKSwgcCwgcmFkaXVzLCBzdGFydEFuZ2xlLCBl bmRBbmdsZSwgY2xvY2t3aXNlLCBoYXNBbnlJbmxpbmVEYXRhKCkgfTsKKyAgICAgICAgbV9uZWVk c1RvQXBwbHlJbmxpbmVEYXRhID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAg IENHUGF0aEFkZEFyYyhlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgp LCByYWRpdXMsIHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOwogfQogCkBAIC00MDIs MjUgKzQ4NCw0MCBAQCB2b2lkIFBhdGg6OmNsZWFyKCkKICAgICBpZiAoaXNOdWxsKCkpCiAgICAg ICAgIHJldHVybjsKIAotICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgp KTsKKyAgICBtX3BhdGguY2xlYXIoKTsKKyAgICBtX2lubGluZURhdGEgPSBNb25vc3RhdGUgeyB9 OworICAgIG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSA9IGZhbHNlOwogICAgIG1fY29weVBhdGhC ZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwogfQogCiBib29sIFBhdGg6OmlzRW1wdHkoKSBjb25zdAog ewotICAgIHJldHVybiBpc051bGwoKSB8fCBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQoKSk7Cisg ICAgaWYgKGlzTnVsbCgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChoYXNBbnlJ bmxpbmVEYXRhKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiBDR1BhdGhJ c0VtcHR5KG1fcGF0aC5nZXQoKSk7CiB9CiAKIGJvb2wgUGF0aDo6aGFzQ3VycmVudFBvaW50KCkg Y29uc3QKIHsKICAgICByZXR1cm4gIWlzRW1wdHkoKTsKIH0KLSAgICAKLUZsb2F0UG9pbnQgUGF0 aDo6Y3VycmVudFBvaW50KCkgY29uc3QgCisKK0Zsb2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50 KCkgY29uc3QKIHsKICAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybiBGbG9hdFBvaW50 KCk7Ci0gICAgcmV0dXJuIENHUGF0aEdldEN1cnJlbnRQb2ludChtX3BhdGguZ2V0KCkpOworICAg ICAgICByZXR1cm4geyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpCisg ICAgICAgIHJldHVybiBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2NhdGlvbjsK KworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKQorICAgICAgICByZXR1cm4gV1RG OjpnZXQ8TGluZURhdGE+KG1faW5saW5lRGF0YSkuZW5kOworCisgICAgcmV0dXJuIENHUGF0aEdl dEN1cnJlbnRQb2ludChwbGF0Zm9ybVBhdGgoKSk7CiB9CiAKIHN0YXRpYyB2b2lkIENHUGF0aEFw cGxpZXJUb1BhdGhBcHBsaWVyKHZvaWQqIGluZm8sIGNvbnN0IENHUGF0aEVsZW1lbnQqIGVsZW1l bnQpCkBAIC00NTQsMTQgKzU1MSw0MCBAQCB2b2lkIFBhdGg6OmFwcGx5KGNvbnN0IFBhdGhBcHBs aWVyRnVuY3Rpb24mIGZ1bmN0aW9uKSBjb25zdAogICAgIGlmIChpc051bGwoKSkKICAgICAgICAg cmV0dXJuOwogCi0gICAgQ0dQYXRoQXBwbHkobV9wYXRoLmdldCgpLCAodm9pZCopJmZ1bmN0aW9u LCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcik7CisgICAgaWYgKGhhc0lubGluZURhdGE8TW92 ZURhdGE+KCkpIHsKKyAgICAgICAgUGF0aEVsZW1lbnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVu dC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1BvaW50OworICAgICAgICBlbGVtZW50 LnBvaW50c1swXSA9IFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uOwor ICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAg IGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKSB7CisgICAgICAgIGF1dG8mIGxpbmUgPSBX VEY6OmdldDxMaW5lRGF0YT4obV9pbmxpbmVEYXRhKTsKKyAgICAgICAgUGF0aEVsZW1lbnQgZWxl bWVudDsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1Bv aW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9IGxpbmUuc3RhcnQ7CisgICAgICAgIGZ1 bmN0aW9uKGVsZW1lbnQpOworICAgICAgICBlbGVtZW50LnR5cGUgPSBQYXRoRWxlbWVudDo6VHlw ZTo6QWRkTGluZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQucG9pbnRzWzBdID0gbGluZS5lbmQ7 CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgQ0dQYXRoQXBwbHkocGxhdGZvcm1QYXRoKCksICh2b2lkKikmZnVuY3Rpb24sIENHUGF0aEFw cGxpZXJUb1BhdGhBcHBsaWVyKTsKIH0KIAogI2lmIEhBVkUoQ0dQQVRIX0dFVF9OVU1CRVJfT0Zf RUxFTUVOVFMpCiAKIHNpemVfdCBQYXRoOjplbGVtZW50Q291bnQoKSBjb25zdAogewotICAgIHJl dHVybiBDR1BhdGhHZXROdW1iZXJPZkVsZW1lbnRzKG1fcGF0aCk7CisgICAgaWYgKGhhc0lubGlu ZURhdGE8TW92ZURhdGE+KCkpCisgICAgICAgIHJldHVybiAxOworCisgICAgaWYgKGhhc0lubGlu ZURhdGE8TGluZURhdGE+KCkpCisgICAgICAgIHJldHVybiAyOworCisgICAgcmV0dXJuIENHUGF0 aEdldE51bWJlck9mRWxlbWVudHMocGxhdGZvcm1QYXRoKCkpOwogfQogCiAjZW5kaWYgLy8gSEFW RShDR1BBVEhfR0VUX05VTUJFUl9PRl9FTEVNRU5UUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlz dEl0ZW1zLmNwcAppbmRleCBkNDUzMWJhYjVjYTQ0Y2ViY2FmOTVhYWZlNzUwMzJmNDM5YWI4YWQ3 Li5lMjI2MTcwM2U0YmMwYjlhYWY1MDUzYjM0N2E4ZmM4ZjAxMDlhNDczIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJ dGVtcy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxp c3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCkBAIC0xMjI4LDcgKzEyMjgsNyBAQCBPcHRpb25hbDxG bG9hdFJlY3Q+IFN0cm9rZVBhdGg6OmxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNzQ29udGV4dCYg Y29udGV4dCkgY29ucwogCiB2b2lkIFN0cm9rZVBhdGg6OmFwcGx5KEdyYXBoaWNzQ29udGV4dCYg Y29udGV4dCkgY29uc3QKIHsKLSAgICBjb250ZXh0LnN0cm9rZVBhdGgobV9wYXRoKTsKKyAgICBj b250ZXh0LnN0cm9rZVBhdGgoV1RGTW92ZShtX3BhdGgpKTsKIH0KIAogc3RhdGljIFRleHRTdHJl YW0mIG9wZXJhdG9yPDwoVGV4dFN0cmVhbSYgdHMsIGNvbnN0IFN0cm9rZVBhdGgmIGl0ZW0pCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMv RGlzcGxheUxpc3RJdGVtcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlz cGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuaAppbmRleCA3NzQyMDVhYzczZjYyNzE0ZTNjZmE5 MGUwMjJjZTVjNzcwODI4ZjJiLi5iOTBlZDIwOWQxZDE5MzdiMzI2NzM3Zjk2YzU5YjkxNmRiNzJl ODNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5 bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKQEAgLTI1ODksNyArMjU4OSw3 IEBAIHByaXZhdGU6CiAgICAgdm9pZCBhcHBseShHcmFwaGljc0NvbnRleHQmKSBjb25zdCBvdmVy cmlkZTsKICAgICBPcHRpb25hbDxGbG9hdFJlY3Q+IGxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNz Q29udGV4dCYpIGNvbnN0IG92ZXJyaWRlOwogCi0gICAgY29uc3QgUGF0aCBtX3BhdGg7CisgICAg bXV0YWJsZSBQYXRoIG1fcGF0aDsKIH07CiAKIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0aERpcmVjdDJE LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQu Y3BwCmluZGV4IGZmNjMwMTQzOTQwNGYwN2ZhNzBmOGEzYzY0N2E1OGQxYjRjYmJkNjUuLmRkNGM2 N2RmNjFhODgzYjVkYzAxNDI4NTE1MzhmZTNhMWEyNWMxYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCkBAIC02NzYs NiArNjc2LDIxIEBAIHZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYg ZnVuY3Rpb24pIGNvbnN0CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAorYm9vbCBQYXRoOjpp c051bGwoKSBjb25zdAoreworICAgIHJldHVybiAhbV9wYXRoOworfQorCitDT01QdHI8SUQyRDFH ZW9tZXRyeUdyb3VwPiBQYXRoOjpjcmVhdGVQbGF0Zm9ybVBhdGgoKQoreworICAgIENPTVB0cjxJ RDJEMUdlb21ldHJ5R3JvdXA+IHBhdGg7CisgICAgSFJFU1VMVCBociA9IEdyYXBoaWNzQ29udGV4 dDo6c3lzdGVtRmFjdG9yeSgpLT5DcmVhdGVHZW9tZXRyeUdyb3VwKEQyRDFfRklMTF9NT0RFX1dJ TkRJTkcsIG51bGxwdHIsIDAsICZwYXRoKTsKKyAgICBBU1NFUlQoU1VDQ0VFREVEKGhyKSk7Cisg ICAgaWYgKEZBSUxFRChocikpCisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIHJldHVybiBw YXRoOworfQorCiB9CiAKICNlbmRpZiAvLyBVU0UoRElSRUNUMkQpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0 L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5jcHAKaW5kZXggNzZkMmIwOWRhYmYxMTRjMzlj NjQ2YWUzMTYzN2ZhMjAxNjFmZGIzZi4uMThlOTUxNzY1NDc3ZWEzNGViYzU1Y2Y1MDI4NDVmNWQ0 OTg3MjNhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRD b2RlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJz LmNwcApAQCAtMjA1LDQgKzIwNSwxMyBAQCBib29sIEFyZ3VtZW50Q29kZXI8YXVkaXRfdG9rZW5f dD46OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyLCBhdWRpdF90b2tlbl90JiBhdWRpdAogfQogI2Vu ZGlmCiAKK3ZvaWQgQXJndW1lbnRDb2RlcjxNb25vc3RhdGU+OjplbmNvZGUoRW5jb2RlciYsIGNv bnN0IE1vbm9zdGF0ZSYpCit7Cit9CisKK09wdGlvbmFsPE1vbm9zdGF0ZT4gQXJndW1lbnRDb2Rl cjxNb25vc3RhdGU+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlcikKK3sKKyAgICByZXR1cm4gTW9u b3N0YXRlIHsgfTsKK30KKwogfSAvLyBuYW1lc3BhY2UgSVBDCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5oIGIvU291cmNlL1dlYktpdC9QbGF0 Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuaAppbmRleCA1OGM0NTY0Njg4YzhmM2YyZWFjMWFjNDcw MTgyYjg1YWZhZGZjNjY0Li5lN2IyNmY0NTU2ZmE0ZDMyZjVmNmZiZGU5ZjVhZGZkYzlmMWZhYzlj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5o CisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmgKQEAgLTMz LDYgKzMzLDcgQEAKICNpbmNsdWRlIDx3dGYvTW9ub3RvbmljVGltZS5oPgogI2luY2x1ZGUgPHd0 Zi9TSEExLmg+CiAjaW5jbHVkZSA8d3RmL1VuZXhwZWN0ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVmFy aWFudC5oPgogI2luY2x1ZGUgPHd0Zi9XYWxsVGltZS5oPgogCiBuYW1lc3BhY2UgSVBDIHsKQEAg LTY5MSw0ICs2OTIsOSBAQCB0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1bWVudENvZGVyPGF1ZGl0X3Rv a2VuX3Q+IHsKIH07CiAjZW5kaWYKIAordGVtcGxhdGU8PiBzdHJ1Y3QgQXJndW1lbnRDb2RlcjxN b25vc3RhdGU+IHsKKyAgICBzdGF0aWMgdm9pZCBlbmNvZGUoRW5jb2RlciYsIGNvbnN0IE1vbm9z dGF0ZSYpOworICAgIHN0YXRpYyBPcHRpb25hbDxNb25vc3RhdGU+IGRlY29kZShEZWNvZGVyJik7 Cit9OworCiB9IC8vIG5hbWVzcGFjZSBJUEMK 392942 2020-03-07 23:43:14 -0800 2020-03-08 15:11:14 -0700 v4 bug-208464-20200307234314.patch text/plain 47083 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDkxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNlYjg0YzRhMTNhNTFmNzlkODIwZDc0 YjNhOGVkNmIwOTg5NDkyOGEuLjcwYmZlMTQ5YmJiYTAxYjc2MjEwZmQwOWZhYmVmNjdlYTlhMjg3 ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGZlYXR1cmUgZmxhZyBmb3IgSU5MSU5FX1BBVEhf REFUQS4gVGhpcyBmZWF0dXJlIGZsYWcgZXhpc3RzIHRvIGVuc3VyZSB0aGF0IHdlIGNhbiBhdm9p ZCBoYXZpbmcKKyAgICAgICAgbV9pbmxpbmVEYXRhIG9uIFBhdGggaW4gcG9ydHMgdGhhdCBkb24n dCBpbXBsZW1lbnQgdGhlIG5lY2Vzc2FyeSBmYWNpbGl0aWVzIGZvciBpbmxpbmUgcGF0aCBkYXRh IHlldCwgc2luY2UgaXQKKyAgICAgICAgd291bGQganVzdCBlbmQgdXAgYmVpbmcgd2FzdGVkIG1l bW9yeS4KKworICAgICAgICAqIHd0Zi9QbGF0Zm9ybUVuYWJsZS5oOgorCiAyMDIwLTAzLTA3ICBE YW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbaU9TXSBJbXBsZW1l bnQgc3VwcG9ydCBmb3IgZGljdGF0aW9uIGFsdGVybmF0aXZlcwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDA0YjE3 NDQ0MjVhNzY0YjIzMDUwZWI3YjhiNDM0ZjM4YzhhNjRiODguLmU3OWFiMzM3MTQ2ZmI1ZmRiN2Uw ODY5MDdiZGMwMjAyYzMxOTFjOWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOTYgQEAKKzIwMjAt MDMtMDcgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg TGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9yIHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBz dWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdoZW4gdGhl IEdQVSBwcm9jZXNzIGlzIGVuYWJsZWQgYW5kIHVzZWQgdG8gcmVuZGVyIHRoZSBjYW52YXMgZWxl bWVudCwgc29tZSBjYW52YXMtcmVsYXRlZCBzdWJ0ZXN0cyBpbgorICAgICAgICBNb3Rpb25NYXJr IHNlZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSByZWdyZXNzaW9ucy4gT25lIG9mIHRoZSByZWFz b25zIGZvciB0aGlzIGlzIHRoYXQgaW4gdGhlIHByb2Nlc3Mgb2YKKyAgICAgICAgZGVjb2Rpbmcg ZGlzcGxheSBsaXN0IGl0ZW1zIHRoYXQgY29udGFpbiBgV2ViQ29yZTo6UGF0aGBzIGluIHRoZSBH UFUgcHJvY2Vzcywgd2UgZW5kIHVwIGFsbG9jYXRpbmcgYSBuZXcgQ0dQYXRoCisgICAgICAgIGZv ciBlYWNoIFdlYkNvcmU6OlBhdGguIFRoaXMgZHJhbWF0aWNhbGx5IGluY3JlYXNlcyBwYWdlIGRl bWFuZCBhbmQgbWVtb3J5IHVzYWdlIGluIHRoZSBHUFUgcHJvY2VzcyBpbiBjb250cmFzdAorICAg ICAgICB0byBzaGlwcGluZyBXZWJLaXQsIGR1ZSB0byB0aGUgZmFjdCB0aGF0IGFsbCBvZiB0aGVz ZSBDR1BhdGhzIGFsbG9jYXRlZCB1cC1mcm9udCwgYW5kIG11c3QgYWxsIGV4aXN0IHNvbWV3aGVy ZQorICAgICAgICBpbiB0aGUgaGVhcCB1cG9uIGRlY29kaW5nIHRoZSBkaXNwbGF5IGxpc3QuCisK KyAgICAgICAgSW4gY29udHJhc3QsIGluIHNoaXBwaW5nIFdlYktpdCwgZWFjaCBjYWxsIHRvIHN0 cm9rZSB0aGUgY3VycmVudCBjYW52YXMgcGF0aCAoaS5lLiBpbnZva2luZworICAgICAgICBHcmFw aGljc0NvbnRleHQ6OnN0cm9rZVBhdGgpIGlzIHN1Y2NlZWRlZCBieSBjbGVhcmluZyB0aGUgcGF0 aCwgd2hpY2ggZGVhbGxvY2F0ZXMgdGhlIENHUGF0aCBiYWNraW5nIHRoZSBXZWJDb3JlCisgICAg ICAgIFBhdGguIFRoZSBuZXh0IHRpbWUgYSBDR1BhdGggbmVlZHMgdG8gYmUgY3JlYXRlZCwgQ29y ZUdyYXBoaWNzIGlzIGZyZWUgdG8gdGhlbiBhbGxvY2F0ZSB0aGUgbmV3IENHUGF0aCBhdCB0aGUK KyAgICAgICAgYWRkcmVzcyBvZiB0aGUgcHJldmlvdXMgQ0dQYXRoIHdoaWNoIHdhcyBqdXN0IGRl c3Ryb3llZCwgd2hpY2ggcHJldmVudHMgdXMgZnJvbSBkaXJ0eWluZyBtb3JlIHBhZ2VzIHRoYW4K KyAgICAgICAgbmVjZXNzYXJ5LiBUaGlzIHBoZW5vbWVub24gYWZmZWN0cyBtb3N0IG9mIHRoZSBj YW52YXMtcmVsYXRlZCBNb3Rpb25NYXJrIHN1YnRlc3RzIHRvIHNvbWUgZGVncmVlLCB0aG91Z2gg dGhlCisgICAgICAgIGltcGFjdCBpcyBtb3N0IG5vdGljZWFibGUgd2l0aCBDYW52YXMgTGluZXMu CisKKyAgICAgICAgT24gdG9wIG9mIGFsbCB0aGlzLCBhIHNpZ25pZmljYW50IHBvcnRpb24gb2Yg dGltZSBpcyBhbHNvIHNwZW50IGNhbGxpbmcgQ0dQYXRoQXBwbHkgYW5kIGNvbnZlcnRpbmcgdGhl IHJlc3VsdGluZworICAgICAgICBDR1BhdGhFbGVtZW50cyBpbnRvIHNlcmlhbGl6YWJsZSBkYXRh IHdoZW4gZW5jb2RpbmcgZWFjaCBXZWJDb3JlIFBhdGguCisKKyAgICAgICAgVG8gbWl0aWdhdGUg dGhlc2UgdHdvIGlzc3VlcyBhbmQgcmVzdG9yZSB0aGUgd2lucyB3ZSBnZXQgZnJvbSBtZW1vcnkg bG9jYWxpdHkgd2hlbiBkcmF3aW5nIHBhdGhzIGluIGxhcmdlCisgICAgICAgIHF1YW50aXRpZXMs IHdlIGNhbjoKKworICAgICAgICAxLiAgSW4gdGhlIGNhc2Ugb2Ygc2ltcGxlIHBhdGhzLCBzdHVm ZiBzb21lIGluZm9ybWF0aW9uIGFib3V0IGhvdyBlYWNoIHBhdGggd2FzIGNyZWF0ZWQgYXMgaW5s aW5lIGRhdGEgb24KKyAgICAgICAgICAgIFdlYkNvcmU6OlBhdGggaXRzZWxmLCBhcyBhIG5ldyBk YXRhIG1lbWJlci4gRm9yIG5vdywgdGhpcyBvbmx5IGVuY29tcGFzc2VzIGxpbmVzLCBhcmNzLCBh bmQgbW92ZXMgKFBhdGhzCisgICAgICAgICAgICB3aGVyZSBvbmx5IGBQYXRoOjptb3ZlVG9gIHdh cyBpbnZva2VkKSwgYnV0IG1heSBiZSBleHBhbmRlZCBpbiB0aGUgZnV0dXJlIHRvIGluY2x1ZGUg ZWxsaXBzZXMgYW5kIHJlY3RzLgorICAgICAgICAgICAgVGhpcyBhbGxvd3MgdXMgdG8gYWNoaWV2 ZSB0d28gdGhpbmdzOiAoYSkgbWFrZSBlbmNvZGluZyBjaGVhcGVyIGJ5IG5vdCByZXF1aXJpbmcg YSB3YWxrIHRocm91Z2ggYWxsIG9mCisgICAgICAgICAgICBDR1BhdGgncyBlbGVtZW50cywgYW5k IChiKSBtYWtlIGRlY29kaW5nIGNoZWFwZXIgYnkganVzdCBpbml0aWFsaXppbmcgdGhlIFBhdGgg dXNpbmcgaW5saW5lIGRhdGEsIHJhdGhlcgorICAgICAgICAgICAgdGhhbiBoYXZpbmcgdG8gY3Jl YXRlIGEgbmV3IENHUGF0aC4KKworICAgICAgICAyLiAgV2hlbiBwYWludGluZyB0aGUgU3Ryb2tl UGF0aCBkaXNwbGF5IGxpc3QgaXRlbSwganVzdCBkaXNjYXJkIGBtX3BhdGhgIGFmdGVyIHdlJ3Jl IGRvbmUgcGFpbnRpbmcgd2l0aCBpdC4KKyAgICAgICAgICAgIFRoaXMsIGluIGNvbmp1bmN0aW9u IHdpdGggKDEpLCBtZWFucyB0aGF0IHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZTo6UGF0 aCBpbiB0aGUgR1BVIHByb2Nlc3MgaXMgb25seQorICAgICAgICAgICAgY3JlYXRlZCB3aGVuIHdl J3JlIGp1c3QgYWJvdXQgdG8gcGFpbnQgKGkuZS4gd2hlbiBjYWxsaW5nIGludG8gc3Ryb2tlUGF0 aCgpKSwgYW5kIGRlc3Ryb3llZCByaWdodCBhZnRlcgorICAgICAgICAgICAgd2UncmUgZG9uZSBw YWludGluZyB3aXRoIGl0LgorCisgICAgICAgIFNlZSBiZWxvdyBmb3IgZGV0YWlscy4gVGhlcmUg c2hvdWxkIGJlIG5vIGNoYW5nZSBpbiBiZWhhdmlvci4KKworICAgICAgICAqIEhlYWRlcnMuY21h a2U6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAg ICAqIHBsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhEYXRhLmg6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6TW92ZURhdGE6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpNb3Zl RGF0YTo6ZGVjb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkxpbmVEYXRhOjplbmNvZGUgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6TGluZURhdGE6OmRlY29kZSk6CisgICAgICAgIChXZWJDb3Jl OjpBcmNEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6QXJjRGF0YTo6ZGVj b2RlKToKKworICAgICAgICBJbnRyb2R1Y2UgSW5saW5lUGF0aERhdGEsIGEgVmFyaWFudCBvZiBz ZXZlcmFsIGRpZmZlcmVudCBpbmxpbmUgZGF0YSB0eXBlcywgZWFjaCBvZiB3aGljaCByZXByZXNl bnRzIG9uZSBzaW1wbGUKKyAgICAgICAgcGF0aCB0eXBlIHRoYXQgaXMgc3RvcmVkIHVzaW5nIG9u bHkgaW5saW5lIGRhdGEuIFRoaXMgaW5jbHVkZXMgbGluZSBzZWdtZW50cyAoYSBzdGFydCBwb2lu dCBhbmQgYW4gZW5kIHBvaW50KSwKKyAgICAgICAgYXMgd2VsbCBhcyBhcmNzICh3aGljaCwgaW4g YWRkaXRpb24gdG8gYSBjZW50ZXIgYW5kIHN0YXJ0IGFuZCBlbmQgYW5nbGVzKSBhbHNvIGluY2x1 ZGVzIGFuIG9wdGlvbmFsIG9mZnNldCwKKyAgICAgICAgd2hpY2ggcmVwcmVzZW50cyB0aGUgY3Vy cmVudCBwb3NpdGlvbiBvZiB0aGUgcGF0aCBhdCB0aGUgdGltZSAiYWRkQXJjIiB3YXMgY2FsbGVk LgorCisgICAgICAgIEZvciBpbnN0YW5jZSwgaW4gdGhlIGZvbGxvd2luZyBzY2VuYXJpbywgdGhl IHBhdGggd291bGQgaGF2ZSBhbiBhcmMgdGhhdCBpcyBvZmZzZXQgYnkgKDEwMCwgMCk7IGlmIGZp bGxlZCwgaXQKKyAgICAgICAgd291bGQgcmVzdWx0IGluIGEgY29tcG9zaXRlIHNoYXBlIHJlc2Vt YmxpbmcgYSBzZW1pY2lyY2xlIG9uIHRvcCBvZiBhIHRyaWFuZ2xlOgorCisgICAgICAgIHBhdGgu bW92ZVRvKDEwMCwgMCk7CisgICAgICAgIHBhdGguYWRkQXJjKDEwMCwgMTAwLCA1MCwgMCwgUEks IGZhbHNlKTsKKyAgICAgICAgY29udGV4dC5maWxsKHBhdGgpOworCisgICAgICAgIFdoZW4gYSBQ YXRoIGlzIGluaXRpYWxpemVkIChvciBhZnRlciBpdCBpcyBjbGVhcmVkKSwgaXQgc3RhcnRzIG9m ZiB3aXRoIG5laXRoZXIgYSBDR1BhdGggbm9yIGlubGluZSBkYXRhLiBNb3ZpbmcKKyAgICAgICAg dGhlIHBhdGggY2F1c2VzIGl0IHRvIHN0b3JlIGlubGluZSBNb3ZlRGF0YTsgY2FsbGluZyBjYWxs aW5nIGBhZGRMaW5lVG9gIG9yIGBhZGRBcmNgIHRoZW4gcmVwbGFjZXMgdGhlIGlubGluZQorICAg ICAgICBkYXRhIHdpdGggZWl0aGVyIExpbmVEYXRhIG9yIEFyY0RhdGEuCisKKyAgICAgICAgSWYs IGF0IGFueSBwb2ludCwgdGhlIHBhdGggY2hhbmdlcyBpbiBhIGRpZmZlcmVudCB3YXkgKGkuZS4g bmVpdGhlciBsaW5lLCBhcmMsIG5vciBtb3ZlKSwgd2UgY2xlYXIgb3V0IHRoZQorICAgICAgICBp bmxpbmUgZGF0YSBhbmQgZmFsbCBiYWNrIHRvIGp1c3QgcmVwcmVzZW50aW5nIHRoZSBwYXRoIGRh dGEgdXNpbmcgdGhlIENHUGF0aCAobV9wYXRoKS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL1BhdGguY3BwOgorCisgICAgICAgIFJlZmFjdG9yIHRoZSBmb2xsb3dpbmcgOCBtZXRob2Rz OiBtb3ZlVG8sIGFkZExpbmVUbywgYWRkQXJjLCBpc0VtcHR5LCBjdXJyZW50UG9pbnQsIGFwcGx5 LCBlbGVtZW50Q291bnQsIGFuZAorICAgICAgICBoYXNDdXJyZW50UG9pbnQgc3VjaCB0aGF0IHRo ZWlyIGltcGxlbWVudGF0aW9ucyBhcmUgbm93IGluIHBsYXRmb3JtLWFnbm9zdGljIGNvZGUgaW4g UGF0aC5jcHAuIExvZ2ljIGluIHRoaXMKKyAgICAgICAgcGxhdGZvcm0tYWdub3N0aWMgY29kZSB3 aWxsIGdlbmVyYWxseSBhdHRlbXB0IHRvIHVzZSBpbmxpbmUgcGF0aCBkYXRhIHRvIGNvbXB1dGUg YW4gYW5zd2VyIChvciBhcHBseSB0aGUKKyAgICAgICAgcmVxdWVzdGVkIG11dGF0aW9ucykgd2l0 aG91dCBoYXZpbmcgdG8gaW5pdGlhbGl6ZSB0aGUgcGxhdGZvcm0gcGF0aCByZXByZXNlbnRhdGlv bi4gRmFpbGluZyB0aGlzLCB3ZSBmYWxsIGJhY2sKKyAgICAgICAgdG8gY2FsbGluZyAtU2xvd0Nh c2UgdmVyc2lvbnMgb2YgdGhlc2UgbWV0aG9kcywgd2hpY2ggd2lsbCBleGVyY2lzZSB0aGUgYXBw cm9wcmlhdGUgQVBJcyBvbiBlYWNoIHBsYXRmb3JtLgorCisgICAgICAgIChXZWJDb3JlOjpQYXRo OjplbGVtZW50Q291bnRTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjph cHBseSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc0VtcHR5IGNvbnN0KToKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0N1cnJlbnRQb2ludCBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0 aDo6ZWxlbWVudENvdW50IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6 CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRMaW5lVG8pOgorICAgICAgICAoV2ViQ29yZTo6 UGF0aDo6bW92ZVRvKToKKworICAgICAgICBJbiB0aGUgY2FzZSBvZiB0aGVzZSB0aHJlZSBtZXRo b2RzIGZvciBtdXRhdGluZyBhIHBhdGgsIGlmIHdlJ3ZlIGVpdGhlciBvbmx5IG1vdmVkIHRoZSBw YXRoIG9yIGhhdmVuJ3QgdG91Y2hlZAorICAgICAgICBpdCBhdCBhbGwsIHdlIGNhbiBnZXQgYXdh eSB3aXRoIG9ubHkgdXBkYXRpbmcgb3VyIGlubGluZSBwYXRoIGRhdGEsIGFuZCBhdm9pZCBjcmVh dGluZyBhIENHUGF0aC4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0RnJv bUlubGluZURhdGEgY29uc3QpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1BhdGguaDoK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om5lZWRzVG9BcHBseUlubGluZURhdGEgY29uc3QpOgor ICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OmRlY29kZSk6CisKKyAgICAgICAgVGVhY2ggUGF0aDo6ZW5jb2RlIGFuZCBQYXRoOjpk ZWNvZGUgdG8gcmVzcGVjdGl2ZWx5IHNlcmlhbGl6ZSBhbmQgZGVzZXJpYWxpemUgV2ViQ29yZTo6 UGF0aCBieSBjb25zdWx0aW5nIG9ubHkKKyAgICAgICAgdGhlIGlubGluZSBkYXRhLCBpZiBpdCBp cyBwcmVzZW50LiBGb3Igc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCB0aGlzIGRlY3JlYXNlcyB0aGUg Y29zdCBvZiBib3RoIElQQyBlbmNvZGluZyBhbmQKKyAgICAgICAgZGVjb2RpbmcsIGJ1dCBhZGRz IGEgbmVnbGlnaWJsZSBhbW91bnQgb2Ygb3ZlcmhlYWQgaW4gdGhlIGNhc2Ugd2hlcmUgdGhlIHBh dGggaXMgbm9uLWlubGluZS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aGFzSW5saW5lRGF0 YSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNBbnlJbmxpbmVEYXRhIGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6IERlbGV0ZWQuCisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmlzRW1wdHlTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQ YXRoOjpjdXJyZW50UG9pbnRTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRo Ojptb3ZlVG9TbG93Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRMaW5lVG9TbG93 Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmNTbG93Q2FzZSk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjphcHBseVNsb3dDYXNlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OmlzTnVsbCBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjcmVhdGVQbGF0 Zm9ybVBhdGggY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6 IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNDdXJyZW50UG9pbnQgY29uc3Qp OiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVudFBvaW50IGNvbnN0KTog RGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUbyk6IERlbGV0ZWQuCisgICAg ICAgIChXZWJDb3JlOjpQYXRoOjphZGRMaW5lVG8pOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29y ZTo6UGF0aDo6YWRkQXJjKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5 IGNvbnN0KTogRGVsZXRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRoIGNvbnN0KToK KworICAgICAgICBBZGQgYSBoZWxwZXIgbWV0aG9kIHRoYXQgaXMgaW52b2tlZCB3aGVuIHRoZSBQ YXRoIGlzIGFza2VkIGZvciBhIENHUGF0aC4gSW4gdGhpcyBjYXNlLCBpZiB0aGVyZSBpcyBpbmxp bmUgZGF0YSwKKyAgICAgICAgd2UgbmVlZCB0byBsYXppbHkgY3JlYXRlIHRoZSBwYXRoIGFuZCBh cHBseSBhbnkgaW5saW5lIHBhdGggZGF0YSB3ZSd2ZSBhY2N1bXVsYXRlZC4gT25jZSB3ZSdyZSBk b25lIGFwcGx5aW5nIHRoZQorICAgICAgICBpbmxpbmUgZGF0YSwgc2V0IGEgZmxhZyAobV9uZWVk c1RvQXBwbHlJbmxpbmVEYXRhKSB0byBmYWxzZSB0byBhdm9pZCByZS1hcHBseWluZyBpbmxpbmUg ZGF0YSB0byB0aGUgcGF0aC4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6cGxhdGZvcm1QYXRo IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0aCk6CisK KyAgICAgICAgV2hlbiBlbnN1cmVQbGF0Zm9ybVBhdGggaXMgaW52b2tlZCwgd2UgYXJlIGFib3V0 IHRvIG11dGF0ZSBvdXIgQ0dQYXRoIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBjYW4ndCBiZSBleHBy ZXNzZWQKKyAgICAgICAgaW4gdGVybXMgb2YgaW5saW5lIGRhdGEgKGF0IGxlYXN0LCBub3Qgd2l0 aCB0aGUgY2hhbmdlcyBpbiB0aGlzIHBhdGNoKS4gQ2xlYXIgb3V0IHRoZSBpbmxpbmUgcGF0aCBk YXRhIGluIHRoaXMKKyAgICAgICAgY2FzZSwgYW5kIGFwcGx5IHRoZSBDR1BhdGggbXV0YXRpb25z IHRoYXQgd2VyZSBwcmV2aW91c2x5IHN0YXNoZWQgYXdheSBpbiBpbmxpbmUgcGF0aCBkYXRhLgor CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorCisgICAgICAgIEEgcGF0 aCBpcyBub3cgY29uc2lkZXJlZCBudWxsIGlmIGl0IGlzIG5vdCBvbmx5IG1pc3NpbmcgYSBDR1Bh dGgsIGJ1dCBhbHNvIGRvZXMgbm90IGhhdmUgYW55IGlubGluZSBwYXRoIGRhdGEuCisgICAgICAg IFRoaXMgbWFpbnRhaW5zIHRoZSBpbnZhcmlhbnQgdGhhdCBgaXNOdWxsKClgIGlzIHRydWUgaWZm IHRoZSBgcGxhdGZvcm1QYXRoKClgIHJldHVybnMgMHgwLgorCisgICAgICAgIChXZWJDb3JlOjpQ YXRoOjpQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnN3YXApOgorCisgICAgICAgIFVw ZGF0ZSB0aGUgY29uc3RydWN0b3JzIGFuZCBgc3dhcGAgaGVscGVyIG1ldGhvZCAodXNlZCBieSBh c3NpZ25tZW50IG9wZXJhdG9ycykgdG8gYWNjb3VudCBmb3IgdGhlIG5ldyBtZW1iZXJzLgorCisg ICAgICAgIChXZWJDb3JlOjpQYXRoOjpjb250YWlucyBjb25zdCk6CisgICAgICAgIChXZWJDb3Jl OjpQYXRoOjp0cmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0 IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3QgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6bW92ZVRvU2xvd0Nhc2UpOgorICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6YWRkTGluZVRvU2xvd0Nhc2UpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6 YWRkQXJjU2xvd0Nhc2UpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y2xlYXIpOgorCisgICAg ICAgIFdoZW4gY2xlYXJpbmcgUGF0aCwgaW5zdGVhZCBvZiBzZXR0aW5nIGBtX3BhdGhgIHRvIGEg bmV3bHkgYWxsb2NhdGVkIENHUGF0aCwgc2ltcGx5IHJlc2V0IGl0IHRvIG51bGwuIFRoaXMKKyAg ICAgICAgZW5zdXJlcyB0aGF0IGlmIHdlIHRoZW4gYXBwbHkgc29tZSBjaGFuZ2VzIHRoYXQgY2Fu IGJlIGV4cHJlc3NlZCB1c2luZyBvbmx5IGlubGluZSBwYXRoIGRhdGEsIHdlIGF2b2lkIGhhdmlu ZyB0bworICAgICAgICB1cGRhdGUgdGhlIENHUGF0aCwgYW5kIGluc3RlYWQganVzdCB1cGRhdGUg dGhlIGlubGluZSBwYXRoIGRhdGEuCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzRW1wdHlT bG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnRTbG93 Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseVNsb3dDYXNlIGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVsZW1lbnRDb3VudFNsb3dDYXNlIGNvbnN0KToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUbyk6IERlbGV0ZWQuCisgICAgICAgIChXZWJD b3JlOjpQYXRoOjphZGRMaW5lVG8pOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6 YWRkQXJjKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzRW1wdHkgY29uc3Qp OiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aGFzQ3VycmVudFBvaW50IGNvbnN0 KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmN1cnJlbnRQb2ludCBjb25zdCk6 IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseSBjb25zdCk6IERlbGV0ZWQu CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjplbGVtZW50Q291bnQgY29uc3QpOiBEZWxldGVkLgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1z LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRpc3BsYXlMaXN0OjpTdHJva2VQYXRoOjphcHBseSBj b25zdCk6CisKKyAgICAgICAgVGhyb3cgb3V0IHRoZSBjdXJyZW50IFdlYkNvcmU6OlBhdGggYWZ0 ZXIgd2UncmUgZG9uZSBwYWludGluZyB3aXRoIGl0IChzZWUgKDIpIGluIHRoZSBhYm92ZSBDaGFu Z2VMb2cgZW50cnkpLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3Rz L0Rpc3BsYXlMaXN0SXRlbXMuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0 aERpcmVjdDJELmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUb1Nsb3dDYXNlKToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZExpbmVUb1Nsb3dDYXNlKToKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFkZEFyY1Nsb3dDYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omlz RW1wdHlTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9p bnRTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseVNsb3dDYXNl IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpjcmVhdGVQbGF0Zm9ybVBhdGggY29uc3QpOgorICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6bW92ZVRvKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFk ZExpbmVUbyk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmMpOiBEZWxl dGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6IERlbGV0ZWQuCisg ICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNDdXJyZW50UG9pbnQgY29uc3QpOiBEZWxldGVkLgor ICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVudFBvaW50IGNvbnN0KTogRGVsZXRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5IGNvbnN0KTogRGVsZXRlZC4KKwogMjAyMC0wMy0w NyAgRGFuaWVsIEJhdGVzICA8ZGFiYXRlc0BhcHBsZS5jb20+CiAKICAgICAgICAgW2lPU10gSW1w bGVtZW50IHN1cHBvcnQgZm9yIGRpY3RhdGlvbiBhbHRlcm5hdGl2ZXMKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggNDM3 MmJlNjQ5OGJjNzNmM2QwYjgzZGEzNWY3ZDAzYmY2ZDE1NTc5Ny4uZmMzNGRjZWZjNDVmYzgzYWVi YWE2YjFmMDI3YTcwMGMxMTU4NzdhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAyMC0w My0wNyAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBM YXppbHkgZ2VuZXJhdGUgQ0dQYXRocyBmb3Igc29tZSBzaW1wbGUgdHlwZXMgb2YgcGF0aHMsIHN1 Y2ggYXMgYXJjcyBhbmQgbGluZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwODQ2NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTk5NjMyMjY+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGFyZ3Vt ZW50IGNvZGVycyBmb3IgYFdURjo6TW9ub3N0YXRlYCwgc28gdGhhdCBWYXJpYW50cyBvZiB0aGUg Zm9ybTogYFZhcmlhbnQ8TW9ub3N0YXRlLCBGb28sIEJhcj5gIGNhbiBiZQorICAgICAgICBlbmNv ZGVkIGFuZCBkZWNvZGVkIG92ZXIgSVBDLgorCisgICAgICAgICogUGxhdGZvcm0vSVBDL0FyZ3Vt ZW50Q29kZXJzLmNwcDoKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxNb25vc3RhdGU+Ojpl bmNvZGUpOgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVyPE1vbm9zdGF0ZT46OmRlY29kZSk6 CisgICAgICAgICogUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmg6CisKIDIwMjAtMDMtMDcg IFBlbmcgTGl1ICA8cGVuZy5saXU2QGFwcGxlLmNvbT4KIAogICAgICAgICBVc2UgdGhlIGZlYXR1 cmUgZmxhZ3MgbWVjaGFuaXNtIHRvIGdpdmUgZGVmYXVsdCBmZWF0dXJlIHByZWZlcmVuY2UgdmFs dWVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5oIGIvU291cmNl L1dURi93dGYvUGxhdGZvcm1FbmFibGUuaAppbmRleCAzODUxZWRiYmQ5NDc2NjFiMjZiYzkyNmQz OGQzYjdhZGNmYmRkMGM2Li5kMDMwMTkxYThmOTBlYzI0ZTkyM2I3N2E3YjE3MTQ5MGViZTgxZmNl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5oCisrKyBiL1NvdXJj ZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgKQEAgLTgxNyw2ICs4MTcsOSBAQAogI2RlZmluZSBF TkFCTEVfT1BFTlRZUEVfTUFUSCAxCiAjZW5kaWYKIAorI2lmICFkZWZpbmVkKEVOQUJMRV9JTkxJ TkVfUEFUSF9EQVRBKSAmJiBVU0UoQ0cpCisjZGVmaW5lIEVOQUJMRV9JTkxJTkVfUEFUSF9EQVRB IDEKKyNlbmRpZgogCiAvKiBEaXNhYmxlIFNoYXJlZEFycmF5QnVmZmVycyB1bnRpbCBTcGVjdHJl IHNlY3VyaXR5IGNvbmNlcm5zIGFyZSBtaXRpZ2F0ZWQuICovCiAjZGVmaW5lIEVOQUJMRV9TSEFS RURfQVJSQVlfQlVGRkVSIDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21h a2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlCmluZGV4IDQ5NmJiNjQwNzc2N2U1Y2E0 OTQzNzBjMmVhM2NiODljYzljOTBiNTEuLmFlNDY1ZWZkYjMwZWY2ODVhYTY0NjMzMDkyMWNmNjVl OTVlYjNlOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UKKysrIGIv U291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZQpAQCAtMTEyNyw2ICsxMTI3LDcgQEAgc2V0KFdl YkNvcmVfUFJJVkFURV9GUkFNRVdPUktfSEVBREVSUwogICAgIHBsYXRmb3JtL2dyYXBoaWNzL0lu YmFuZEdlbmVyaWNDdWUuaAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL0luYmFuZFRleHRUcmFja1By aXZhdGUuaAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL0luYmFuZFRleHRUcmFja1ByaXZhdGVDbGll bnQuaAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhEYXRhLmgKICAgICBwbGF0Zm9y bS9ncmFwaGljcy9JbnRQb2ludC5oCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvSW50UG9pbnRIYXNo LmgKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9JbnRSZWN0LmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBkMWIwYWY4ZTZjMDFmZTgx Y2VjYWZjNjIxNDMwZTkyOTdmOWQyMDJjLi4yNWI4ODczYTNjOWQ1NjNiMTkxMDk1MjNmMTNmNGYw MjUxY2IyNDNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCkBAIC00OTc3LDYgKzQ5NzcsNyBAQAogCQlGNDQyQzM1OTIzRTNBREQyMDA0 OTk1ODIgLyogQ29tcG9zaXRpb25IaWdobGlnaHQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NDJDMzU3MjNFM0FDNTEwMDQ5OTU4MiAvKiBDb21wb3Np dGlvbkhpZ2hsaWdodC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CiAJCUY0NEE1RjU5MUZFRDM4RjIwMDdGNTk0NCAvKiBMZWdhY3lOU1Bhc3RlYm9hcmRU eXBlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ0 QTVGNTcxRkVEMzgzMDAwN0Y1OTQ0IC8qIExlZ2FjeU5TUGFzdGVib2FyZFR5cGVzLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ0RUJCRDkxREI1 RDIxNDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGNDRFQkJEODFEQjVEMjE0MDAyNzczMzQgLyogU3RhdGljUmFu Z2UuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlG NDU3NzVDRTI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NTc3NUNEMjQxNDM3RDUwMDJERjFB MCAvKiBJbmxpbmVQYXRoRGF0YS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZh dGUsICk7IH07IH07CiAJCUY0NUMyMzFFMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25h cE9mZnNldHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDY3MjkyODFF MERFNjg1MDBBQ0MzRDggLyogU2Nyb2xsU25hcE9mZnNldHNJbmZvLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDY3MjkyNTFFMERFNUFCMDBBQ0MzRDgg LyogU2Nyb2xsU25hcE9mZnNldHNJbmZvLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAo UHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ2QzQ0N0UyMzQ2NTQ1NDAwMzlBNzlEIC8qIENsaXBib2Fy ZEl0ZW1CaW5kaW5nc0RhdGFTb3VyY2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEY0NkM0NDdDMjM0NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVt QmluZGluZ3NEYXRhU291cmNlLmggKi87IH07CkBAIC0xNTQ2NSw2ICsxNTQ2Niw3IEBACiAJCUY0 NEVCQkQ2MURCNUQxQjYwMDI3NzMzNCAvKiBTdGF0aWNSYW5nZS5pZGwgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0 OyBwYXRoID0gU3RhdGljUmFuZ2UuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlG NDRFQkJEODFEQjVEMjE0MDAyNzczMzQgLyogU3RhdGljUmFuZ2UuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gU3RhdGljUmFuZ2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRjQ0RUJCREExREI1REQ5RDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFN0YXRpY1JhbmdlLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjQ1Nzc1Q0QyNDE0MzdENTAwMkRGMUEwIC8qIElubGluZVBh dGhEYXRhLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElubGluZVBhdGhEYXRhLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUY0NUMyMzFCMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlzU2Nyb2xsU25h cE9mZnNldHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXhpc1Nj cm9sbFNuYXBPZmZzZXRzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ1QzIz MUMxOTk1QjczQjAwQTZFMkUzIC8qIEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBBeGlzU2Nyb2xsU25hcE9mZnNldHMuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ2MjhBOUUyMzREM0JCRjAwQkM4ODRDIC8qIFBsYXRmb3Jt UGFzdGVib2FyZENvY29hLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRo ID0gUGxhdGZvcm1QYXN0ZWJvYXJkQ29jb2EubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC0yNTEyNyw2ICsyNTEyOSw3IEBACiAJCQkJMDcwNkEwRDcyNDA4MzBBNjAwRTkzODE4IC8q IEluYmFuZEdlbmVyaWNDdWVJZGVudGlmaWVyLmggKi8sCiAJCQkJMDc5NDE3OTMxNjZFQTA0RTAw OTQxNkMyIC8qIEluYmFuZFRleHRUcmFja1ByaXZhdGUuaCAqLywKIAkJCQkwN0NFNzdENDE2NzEy QTZBMDBDNTVBNDcgLyogSW5iYW5kVGV4dFRyYWNrUHJpdmF0ZUNsaWVudC5oICovLAorCQkJCUY0 NTc3NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovLAogCQkJCTJENDZG MDREMTdCOTZGQkQwMDU2NDdGMCAvKiBJbnRQb2ludC5jcHAgKi8sCiAJCQkJQjI3NTM1NDQwQjA1 MzgxNDAwMkNFNjRGIC8qIEludFBvaW50LmggKi8sCiAJCQkJRTQ2MkE0QTAxMTNFNzFCRTAwNEE0 MjIwIC8qIEludFBvaW50SGFzaC5oICovLApAQCAtMzA0MTYsNiArMzA0MTksNyBAQAogCQkJCTZG QjI0MDA1MjNERkYxMjgwMDc5NjQ1OCAvKiBJbmxpbmVMaW5lQm94QnVpbGRlci5oIGluIEhlYWRl cnMgKi8sCiAJCQkJNkZFMTk4MTcyMTc4Mzk3QzAwNDQ2RjA4IC8qIElubGluZUxpbmVCcmVha2Vy LmggaW4gSGVhZGVycyAqLywKIAkJCQk2RjBDRDY5NTIyOUVEMzI3MDBDNTk5NEUgLyogSW5saW5l TGluZUJ1aWxkZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCUY0NTc3NUNFMjQxNDM3RDUwMDJERjFB MCAvKiBJbmxpbmVQYXRoRGF0YS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNkYzNjBFNTAyMzk5OTQy MTAwMTUxMkE3IC8qIElubGluZVNvZnRMaW5lQnJlYWtJdGVtLmggaW4gSGVhZGVycyAqLywKIAkJ CQlBQTRDM0E3NzBCMkIxNjc5MDAyMzM0QTIgLyogSW5saW5lU3R5bGVTaGVldE93bmVyLmggaW4g SGVhZGVycyAqLywKIAkJCQlCQ0VBNDg1QTA5N0Q5MzAyMDA5NEM5RTQgLyogSW5saW5lVGV4dEJv eC5oIGluIEhlYWRlcnMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9JbmxpbmVQYXRoRGF0YS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvSW5saW5lUGF0aERhdGEuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42NTM1OWFiYWVjMDYyMTBlMTg5NDhlNTBl NjA4ZDlhNWZlYzkxYTQ2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvSW5saW5lUGF0aERhdGEuaApAQCAtMCwwICsxLDEzNyBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMg Q09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS CisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisg KiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQor ICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisKKyNpbmNs dWRlICJGbG9hdFBvaW50LmgiCisjaW5jbHVkZSA8d3RmL09wdGlvbmFsLmg+CisjaW5jbHVkZSA8 d3RmL1ZhcmlhbnQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdHJ1Y3QgTGluZURhdGEg eworICAgIEZsb2F0UG9pbnQgc3RhcnQ7CisgICAgRmxvYXRQb2ludCBlbmQ7CisKKyAgICB0ZW1w bGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIGVuY29kZShFbmNvZGVyJikgY29uc3Q7CisgICAgdGVt cGxhdGU8Y2xhc3MgRGVjb2Rlcj4gc3RhdGljIE9wdGlvbmFsPExpbmVEYXRhPiBkZWNvZGUoRGVj b2RlciYpOworfTsKKworc3RydWN0IEFyY0RhdGEgeworICAgIEZsb2F0UG9pbnQgb2Zmc2V0Owor ICAgIEZsb2F0UG9pbnQgY2VudGVyOworICAgIGZsb2F0IHJhZGl1cyB7IDAgfTsKKyAgICBmbG9h dCBzdGFydCB7IDAgfTsKKyAgICBmbG9hdCBlbmQgeyAwIH07CisgICAgYm9vbCBjbG9ja3dpc2Ug eyBmYWxzZSB9OworICAgIGJvb2wgaGFzT2Zmc2V0IHsgZmFsc2UgfTsKKworICAgIHRlbXBsYXRl PGNsYXNzIEVuY29kZXI+IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsKKyAgICB0ZW1wbGF0 ZTxjbGFzcyBEZWNvZGVyPiBzdGF0aWMgT3B0aW9uYWw8QXJjRGF0YT4gZGVjb2RlKERlY29kZXIm KTsKK307CisKK3N0cnVjdCBNb3ZlRGF0YSB7CisgICAgRmxvYXRQb2ludCBsb2NhdGlvbjsKKwor ICAgIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgZW5jb2RlKEVuY29kZXImKSBjb25zdDsK KyAgICB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBzdGF0aWMgT3B0aW9uYWw8TW92ZURhdGE+IGRl Y29kZShEZWNvZGVyJik7Cit9OworCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIE1vdmVE YXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVyIDw8IGxv Y2F0aW9uOworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBPcHRpb25hbDxNb3ZlRGF0YT4g TW92ZURhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQoreworICAgIE1vdmVEYXRhIGRhdGE7 CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLmxvY2F0aW9uKSkKKyAgICAgICAgcmV0dXJu IFdURjo6bnVsbG9wdDsKKyAgICByZXR1cm4geyBkYXRhIH07Cit9CisKK3RlbXBsYXRlPGNsYXNz IEVuY29kZXI+IHZvaWQgTGluZURhdGE6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAor eworICAgIGVuY29kZXIgPDwgc3RhcnQ7CisgICAgZW5jb2RlciA8PCBlbmQ7Cit9CisKK3RlbXBs YXRlPGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPExpbmVEYXRhPiBMaW5lRGF0YTo6ZGVjb2RlKERl Y29kZXImIGRlY29kZXIpCit7CisgICAgTGluZURhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIu ZGVjb2RlKGRhdGEuc3RhcnQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAg aWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLmVuZCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxv cHQ7CisKKyAgICByZXR1cm4geyBXVEZNb3ZlKGRhdGEpIH07Cit9CisKK3RlbXBsYXRlPGNsYXNz IEVuY29kZXI+IHZvaWQgQXJjRGF0YTo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIpIGNvbnN0Cit7 CisgICAgZW5jb2RlciA8PCBvZmZzZXQ7CisgICAgZW5jb2RlciA8PCBjZW50ZXI7CisgICAgZW5j b2RlciA8PCByYWRpdXM7CisgICAgZW5jb2RlciA8PCBzdGFydDsKKyAgICBlbmNvZGVyIDw8IGVu ZDsKKyAgICBlbmNvZGVyIDw8IGNsb2Nrd2lzZTsKKyAgICBlbmNvZGVyIDw8IGhhc09mZnNldDsK K30KKwordGVtcGxhdGU8Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8QXJjRGF0YT4gQXJjRGF0YTo6 ZGVjb2RlKERlY29kZXImIGRlY29kZXIpCit7CisgICAgQXJjRGF0YSBkYXRhOworICAgIGlmICgh ZGVjb2Rlci5kZWNvZGUoZGF0YS5vZmZzZXQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLmNlbnRlcikpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEucmFkaXVzKSkK KyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUo ZGF0YS5zdGFydCkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRl Y29kZXIuZGVjb2RlKGRhdGEuZW5kKSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKwor ICAgIGlmICghZGVjb2Rlci5kZWNvZGUoZGF0YS5jbG9ja3dpc2UpKQorICAgICAgICByZXR1cm4g V1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLmhhc09mZnNldCkp CisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICByZXR1cm4geyBXVEZNb3ZlKGRh dGEpIH07Cit9CisKK3VzaW5nIElubGluZVBhdGhEYXRhID0gVmFyaWFudDxNb25vc3RhdGUsIE1v dmVEYXRhLCBMaW5lRGF0YSwgQXJjRGF0YT47CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwor I2VuZGlmIC8vIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9QYXRoLmNwcAppbmRleCBhNjI4ZDM3NDIyNDIzYzEyMDM1NGZmZmYyMTkwNjE3 ZjcyYjQzODUyLi42NDQ4YjJjZDI5MTBiZDZmM2Y3ZDk1ZDBjYzZmMjAwZjRiY2QxYjcwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmNwcApAQCAtNTUsNyArNTUsNyBA QCBmbG9hdCBQYXRoOjpsZW5ndGgoKSBjb25zdAogCiAjaWYgIUhBVkUoQ0dQQVRIX0dFVF9OVU1C RVJfT0ZfRUxFTUVOVFMpCiAKLXNpemVfdCBQYXRoOjplbGVtZW50Q291bnQoKSBjb25zdAorc2l6 ZV90IFBhdGg6OmVsZW1lbnRDb3VudFNsb3dDYXNlKCkgY29uc3QKIHsKICAgICBzaXplX3QgbnVt UG9pbnRzID0gMDsKICAgICBhcHBseShbJm51bVBvaW50c10oYXV0byYpIHsKQEAgLTE2Nyw2ICsx NjcsMTM3IEBAIHZvaWQgUGF0aDo6YWRkQmV6aWVyc0ZvclJvdW5kZWRSZWN0KGNvbnN0IEZsb2F0 UmVjdCYgcmVjdCwgY29uc3QgRmxvYXRTaXplJiB0b3BMCiAgICAgY2xvc2VTdWJwYXRoKCk7CiB9 CiAKK3ZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24p IGNvbnN0Cit7CisgICAgaWYgKGlzTnVsbCgpKQorICAgICAgICByZXR1cm47CisKKyNpZiBFTkFC TEUoSU5MSU5FX1BBVEhfREFUQSkKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkg eworICAgICAgICBQYXRoRWxlbWVudCBlbGVtZW50OworICAgICAgICBlbGVtZW50LnR5cGUgPSBQ YXRoRWxlbWVudDo6VHlwZTo6TW92ZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQucG9pbnRzWzBd ID0gV1RGOjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9jYXRpb247CisgICAgICAgIGZ1 bmN0aW9uKGVsZW1lbnQpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKGhhc0lu bGluZURhdGE8TGluZURhdGE+KCkpIHsKKyAgICAgICAgYXV0byYgbGluZSA9IFdURjo6Z2V0PExp bmVEYXRhPihtX2lubGluZURhdGEpOworICAgICAgICBQYXRoRWxlbWVudCBlbGVtZW50OworICAg ICAgICBlbGVtZW50LnR5cGUgPSBQYXRoRWxlbWVudDo6VHlwZTo6TW92ZVRvUG9pbnQ7CisgICAg ICAgIGVsZW1lbnQucG9pbnRzWzBdID0gbGluZS5zdGFydDsKKyAgICAgICAgZnVuY3Rpb24oZWxl bWVudCk7CisgICAgICAgIGVsZW1lbnQudHlwZSA9IFBhdGhFbGVtZW50OjpUeXBlOjpBZGRMaW5l VG9Qb2ludDsKKyAgICAgICAgZWxlbWVudC5wb2ludHNbMF0gPSBsaW5lLmVuZDsKKyAgICAgICAg ZnVuY3Rpb24oZWxlbWVudCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisjZW5kaWYKKyAgICBh cHBseVNsb3dDYXNlKGZ1bmN0aW9uKTsKK30KKworYm9vbCBQYXRoOjppc0VtcHR5KCkgY29uc3QK K3sKKyAgICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisjaWYgRU5BQkxF KElOTElORV9QQVRIX0RBVEEpCisgICAgaWYgKGhhc0FueUlubGluZURhdGEoKSkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworI2VuZGlmCisgICAgcmV0dXJuIGlzRW1wdHlTbG93Q2FzZSgpOworfQor Citib29sIFBhdGg6Omhhc0N1cnJlbnRQb2ludCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFpc0Vt cHR5KCk7Cit9CisKK0Zsb2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50KCkgY29uc3QKK3sKKyAg ICBpZiAoaXNOdWxsKCkpCisgICAgICAgIHJldHVybiB7IH07CisKKyNpZiBFTkFCTEUoSU5MSU5F X1BBVEhfREFUQSkKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkKKyAgICAgICAg cmV0dXJuIFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uOworCisgICAg aWYgKGhhc0lubGluZURhdGE8TGluZURhdGE+KCkpCisgICAgICAgIHJldHVybiBXVEY6OmdldDxM aW5lRGF0YT4obV9pbmxpbmVEYXRhKS5lbmQ7CisjZW5kaWYKKyAgICByZXR1cm4gY3VycmVudFBv aW50U2xvd0Nhc2UoKTsKK30KKworc2l6ZV90IFBhdGg6OmVsZW1lbnRDb3VudCgpIGNvbnN0Cit7 CisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgaWYgKGhhc0lubGluZURhdGE8TW92 ZURhdGE+KCkpCisgICAgICAgIHJldHVybiAxOworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGlu ZURhdGE+KCkpCisgICAgICAgIHJldHVybiAyOworI2VuZGlmCisgICAgcmV0dXJuIGVsZW1lbnRD b3VudFNsb3dDYXNlKCk7Cit9CisKK3ZvaWQgUGF0aDo6YWRkQXJjKGNvbnN0IEZsb2F0UG9pbnQm IHBvaW50LCBmbG9hdCByYWRpdXMsIGZsb2F0IHN0YXJ0QW5nbGUsIGZsb2F0IGVuZEFuZ2xlLCBi b29sIGFudGljbG9ja3dpc2UpCit7CisgICAgLy8gV29ya2Fyb3VuZCBmb3IgPHJkYXI6Ly9wcm9i bGVtLzUxODkyMzM+IENHUGF0aEFkZEFyYyBoYW5ncyBvciBjcmFzaGVzIHdoZW4gcGFzc2VkIGlu ZiBhcyBzdGFydCBvciBlbmQgYW5nbGUuCisgICAgLy8gYXMgd2VsbCBhcyBodHRwOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjQ0OSwgc2luY2UgY2Fpcm9fYXJjKCkgZnVuY3Rp b25zIGhhbmcgb3IgY3Jhc2ggd2hlbgorICAgIC8vIHBhc3NlZCBpbmYgYXMgcmFkaXVzIG9yIHN0 YXJ0L2VuZCBhbmdsZS4KKyAgICBpZiAoIXN0ZDo6aXNmaW5pdGUocmFkaXVzKSB8fCAhc3RkOjpp c2Zpbml0ZShzdGFydEFuZ2xlKSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCisgICAgICAg IHJldHVybjsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGlmIChpc051bGwo KSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9 IEFyY0RhdGEgeyBoYXNBbnlJbmxpbmVEYXRhKCkgPyBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxp bmVEYXRhKS5sb2NhdGlvbiA6IEZsb2F0UG9pbnQoKSwgcG9pbnQsIHJhZGl1cywgc3RhcnRBbmds ZSwgZW5kQW5nbGUsIGFudGljbG9ja3dpc2UsIGhhc0FueUlubGluZURhdGEoKSB9OworICAgICAg ICByZXR1cm47CisgICAgfQorI2VuZGlmCisgICAgYWRkQXJjU2xvd0Nhc2UocG9pbnQsIHJhZGl1 cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGFudGljbG9ja3dpc2UpOworfQorCit2b2lkIFBhdGg6 OmFkZExpbmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3sKKyNpZiBFTkFCTEUoSU5MSU5F X1BBVEhfREFUQSkKKyAgICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4o KSkgeworICAgICAgICBtX2lubGluZURhdGEgPSBMaW5lRGF0YSB7IGhhc0FueUlubGluZURhdGEo KSA/IFdURjo6Z2V0PE1vdmVEYXRhPihtX2lubGluZURhdGEpLmxvY2F0aW9uIDogRmxvYXRQb2lu dCgpLCBwb2ludCB9OworICAgICAgICByZXR1cm47CisgICAgfQorI2VuZGlmCisgICAgYWRkTGlu ZVRvU2xvd0Nhc2UocG9pbnQpOworfQorCit2b2lkIFBhdGg6Om1vdmVUbyhjb25zdCBGbG9hdFBv aW50JiBwb2ludCkKK3sKKyNpZiBFTkFCTEUoSU5MSU5FX1BBVEhfREFUQSkKKyAgICBpZiAoaXNO dWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkgeworICAgICAgICBtX2lubGluZURh dGEgPSBNb3ZlRGF0YSB7IHBvaW50IH07CisgICAgICAgIHJldHVybjsKKyAgICB9CisjZW5kaWYK KyAgICBtb3ZlVG9TbG93Q2FzZShwb2ludCk7Cit9CisKKyNpZiBFTkFCTEUoSU5MSU5FX1BBVEhf REFUQSkKKworT3B0aW9uYWw8RmxvYXRSZWN0PiBQYXRoOjpib3VuZGluZ1JlY3RGcm9tSW5saW5l RGF0YSgpIGNvbnN0Cit7CisgICAgaWYgKGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpCisgICAg ICAgIHJldHVybiBGbG9hdFJlY3QgeyB9OworCisgICAgaWYgKGhhc0lubGluZURhdGE8TGluZURh dGE+KCkpIHsKKyAgICAgICAgRmxvYXRSZWN0IHJlc3VsdDsKKyAgICAgICAgYXV0byYgbGluZSA9 IFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEpOworICAgICAgICByZXN1bHQuZml0VG9Q b2ludHMobGluZS5zdGFydCwgbGluZS5lbmQpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAg IH0KKworICAgIHJldHVybiBXVEY6Om51bGxvcHQ7Cit9CisKKyNlbmRpZgorCiAjaWYgIVVTRShD RykgJiYgIVVTRShESVJFQ1QyRCkKIFBhdGggUGF0aDo6cG9seWdvblBhdGhGcm9tUG9pbnRzKGNv bnN0IFZlY3RvcjxGbG9hdFBvaW50PiYgcG9pbnRzKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUGF0aC5oCmluZGV4IDdmYWRhNjBkODNjMjkyNTBhYzRhMTc0OGE4OTI0MDcwMjkx OTllMWIuLjcyYzcwM2YyMjY3MGQwZDU0NDAwODJlZWQwMjE5MzI4NDNkYWUyNWUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKQEAgLTI1LDEwICsyNSwxMCBAQAogICog T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4gCiAgKi8KIAotI2lmbmRlZiBQYXRoX2gKLSNkZWZpbmUgUGF0aF9oCisjcHJh Z21hIG9uY2UKIAogI2luY2x1ZGUgIkZsb2F0UmVjdC5oIgorI2luY2x1ZGUgIklubGluZVBhdGhE YXRhLmgiCiAjaW5jbHVkZSAiV2luZFJ1bGUuaCIKICNpbmNsdWRlIDx3dGYvRmFzdE1hbGxvYy5o PgogI2luY2x1ZGUgPHd0Zi9GdW5jdGlvbi5oPgpAQCAtMTQ3LDEwICsxNDcsMTIgQEAgcHVibGlj OgogICAgIEZsb2F0UG9pbnQgcG9pbnRBdExlbmd0aChmbG9hdCBsZW5ndGgpIGNvbnN0OwogCiAg ICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBjbGVhcigpOwotICAgIGJvb2wgaXNOdWxsKCkgY29uc3Qg eyByZXR1cm4gIW1fcGF0aDsgfQorICAgIFdFQkNPUkVfRVhQT1JUIGJvb2wgaXNOdWxsKCkgY29u c3Q7CiAgICAgYm9vbCBpc0VtcHR5KCkgY29uc3Q7CiAgICAgLy8gR2V0cyB0aGUgY3VycmVudCBw b2ludCBvZiB0aGUgY3VycmVudCBwYXRoLCB3aGljaCBpcyBjb25jZXB0dWFsbHkgdGhlIGZpbmFs IHBvaW50IHJlYWNoZWQgYnkgdGhlIHBhdGggc28gZmFyLgogICAgIC8vIE5vdGUgdGhlIFBhdGgg Y2FuIGJlIGVtcHR5IChpc0VtcHR5KCkgPT0gdHJ1ZSkgYW5kIHN0aWxsIGhhdmUgYSBjdXJyZW50 IHBvaW50LgorICAgIC8vIEZJWE1FOiBUaGUgYWJvdmUgY29tbWVudCBtaWdodCBuZWVkIHRvIGJl IHVwZGF0ZWQ7IG9uIGFsbCBzdXBwb3J0ZWQgcGxhdGZvcm1zLCB0aGUgcmVzdWx0IG9mIGhhc0N1 cnJlbnRQb2ludCgpIGlzIGlkZW50aWNhbAorICAgIC8vIHRvICFpc0VtcHR5KCkuCiAgICAgYm9v bCBoYXNDdXJyZW50UG9pbnQoKSBjb25zdDsKICAgICBGbG9hdFBvaW50IGN1cnJlbnRQb2ludCgp IGNvbnN0OwogCkBAIC0xODUsNyArMTg3LDcgQEAgcHVibGljOgogICAgIEZsb2F0UmVjdCBmYXN0 Qm91bmRpbmdSZWN0Rm9yU3Ryb2tlKGNvbnN0IFBsYXRmb3JtQ29udGV4dERpcmVjdDJEJikgY29u c3Q7CiAgICAgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1f cGF0aC5nZXQoKTsgfQogI2VsaWYgVVNFKENHKQotICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9y bVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGguZ2V0KCk7IH0KKyAgICBXRUJDT1JFX0VYUE9S VCBQbGF0Zm9ybVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3Q7CiAjZWxzZQogICAgIFBsYXRm b3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJldHVybiBtX3BhdGg7IH0KICNlbmRp ZgpAQCAtMjI1LDYgKzIyNywyNSBAQCBwdWJsaWM6CiAgICAgdGVtcGxhdGU8Y2xhc3MgRGVjb2Rl cj4gc3RhdGljIE9wdGlvbmFsPFBhdGg+IGRlY29kZShEZWNvZGVyJik7CiAKIHByaXZhdGU6Cisg ICAgdm9pZCBjcmVhdGVQbGF0Zm9ybVBhdGgoKSBjb25zdDsKKworI2lmIEVOQUJMRShJTkxJTkVf UEFUSF9EQVRBKQorICAgIHN0YXRpYyB2b2lkIGFwcGx5SW5saW5lUGF0aERhdGEoY29uc3QgSW5s aW5lUGF0aERhdGEmLCBQbGF0Zm9ybVBhdGhQdHIpOworICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBE YXRhVHlwZT4gYm9vbCBoYXNJbmxpbmVEYXRhKCkgY29uc3Q7CisgICAgYm9vbCBoYXNBbnlJbmxp bmVEYXRhKCkgY29uc3Q7CisgICAgT3B0aW9uYWw8RmxvYXRSZWN0PiBib3VuZGluZ1JlY3RGcm9t SW5saW5lRGF0YSgpIGNvbnN0OworICAgIGJvb2wgbmVlZHNUb0FwcGx5SW5saW5lRGF0YSgpIGNv bnN0IHsgcmV0dXJuICFtX3BhdGggJiYgaGFzQW55SW5saW5lRGF0YSgpOyB9CisjZW5kaWYKKwor ICAgIHZvaWQgbW92ZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYpOworICAgIHZvaWQgYWRk TGluZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYpOworICAgIHZvaWQgYWRkQXJjU2xvd0Nh c2UoY29uc3QgRmxvYXRQb2ludCYsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxv YXQgZW5kQW5nbGUsIGJvb2wgYW50aWNsb2Nrd2lzZSk7CisKKyAgICBib29sIGlzRW1wdHlTbG93 Q2FzZSgpIGNvbnN0OworICAgIEZsb2F0UG9pbnQgY3VycmVudFBvaW50U2xvd0Nhc2UoKSBjb25z dDsKKyAgICBzaXplX3QgZWxlbWVudENvdW50U2xvd0Nhc2UoKSBjb25zdDsKKyAgICB2b2lkIGFw cGx5U2xvd0Nhc2UoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYpIGNvbnN0OworCiAjaWYgVVNF KENHKQogICAgIHZvaWQgc3dhcChQYXRoJik7CiAjZW5kaWYKQEAgLTIzNyw2ICsyNTgsOSBAQCBw cml2YXRlOgogICAgIG11dGFibGUgYm9vbCBtX2ZpZ3VyZUlzT3BlbmVkIHsgZmFsc2UgfTsKICNl bmRpZgogCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAgSW5saW5lUGF0aERhdGEg bV9pbmxpbmVEYXRhOworI2VuZGlmCiAjaWYgVVNFKENHKQogICAgIG11dGFibGUgYm9vbCBtX2Nv cHlQYXRoQmVmb3JlTXV0YXRpb24geyBmYWxzZSB9OwogI2VuZGlmCkBAIC0yNDYsNiArMjcwLDE1 IEBAIFdURjo6VGV4dFN0cmVhbSYgb3BlcmF0b3I8PChXVEY6OlRleHRTdHJlYW0mLCBjb25zdCBQ YXRoJik7CiAKIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgUGF0aDo6ZW5jb2RlKEVuY29k ZXImIGVuY29kZXIpIGNvbnN0CiB7CisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAg Ym9vbCBoYXNJbmxpbmVEYXRhID0gaGFzQW55SW5saW5lRGF0YSgpOworICAgIGVuY29kZXIgPDwg aGFzSW5saW5lRGF0YTsKKyAgICBpZiAoaGFzSW5saW5lRGF0YSkgeworICAgICAgICBlbmNvZGVy IDw8IG1faW5saW5lRGF0YTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgorCiAgICAg ZW5jb2RlciA8PCBzdGF0aWNfY2FzdDx1aW50NjRfdD4oZWxlbWVudENvdW50KCkpOwogCiAgICAg YXBwbHkoWyZdKGF1dG8mIGVsZW1lbnQpIHsKQEAgLTI3Niw2ICszMDksMjAgQEAgdGVtcGxhdGU8 Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRoOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QK IHRlbXBsYXRlPGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNv ZGVyJiBkZWNvZGVyKQogewogICAgIFBhdGggcGF0aDsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFU SF9EQVRBKQorICAgIGJvb2wgaGFzSW5saW5lRGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KGhhc0lubGluZURhdGEpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYg KGhhc0lubGluZURhdGEpIHsKKyAgICAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXRoLm1faW5s aW5lRGF0YSkpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIHJl dHVybiB7IFdURk1vdmUocGF0aCkgfTsKKyAgICB9CisjZW5kaWYKKwogICAgIHVpbnQ2NF90IG51 bVBvaW50czsKICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKG51bVBvaW50cykpCiAgICAgICAgIHJl dHVybiBXVEY6Om51bGxvcHQ7CkBAIC0zMzYsOSArMzgzLDIxIEBAIHRlbXBsYXRlPGNsYXNzIERl Y29kZXI+IE9wdGlvbmFsPFBhdGg+IFBhdGg6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQogICAg ICAgICB9CiAgICAgfQogCi0gICAgcmV0dXJuIHBhdGg7CisgICAgcmV0dXJuIHsgV1RGTW92ZShw YXRoKSB9OwogfQogCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisKK3RlbXBsYXRlIDx0 eXBlbmFtZSBEYXRhVHlwZT4gaW5saW5lIGJvb2wgUGF0aDo6aGFzSW5saW5lRGF0YSgpIGNvbnN0 Cit7CisgICAgcmV0dXJuIFdURjo6aG9sZHNfYWx0ZXJuYXRpdmU8RGF0YVR5cGU+KG1faW5saW5l RGF0YSk7Cit9CisKK2lubGluZSBib29sIFBhdGg6Omhhc0FueUlubGluZURhdGEoKSBjb25zdAor eworICAgIHJldHVybiAhaGFzSW5saW5lRGF0YTxNb25vc3RhdGU+KCk7CiB9CiAKICNlbmRpZgor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fpcm8uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcAppbmRleCBlMWI1NTRjODg0YzE1MmQ1YTk4 YjA0YTk3Y2E0NzczZjU0NzM4NjNiLi5jZjMyODJlYTc5MzJlMjNlY2RiOTMzMWY0MjBlZjAxYzIz M2QyMDdlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWly by9QYXRoQ2Fpcm8uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nh aXJvL1BhdGhDYWlyby5jcHAKQEAgLTExNywyMSArMTE3LDEzIEBAIHZvaWQgUGF0aDo6Y2xlYXIo KQogICAgIGNhaXJvX25ld19wYXRoKGNyKTsKIH0KIAotYm9vbCBQYXRoOjppc0VtcHR5KCkgY29u c3QKK2Jvb2wgUGF0aDo6aXNFbXB0eVNsb3dDYXNlKCkgY29uc3QKIHsKLSAgICByZXR1cm4gaXNO dWxsKCkgfHwgIWNhaXJvX2hhc19jdXJyZW50X3BvaW50KHBsYXRmb3JtUGF0aCgpLT5jb250ZXh0 KCkpOworICAgIHJldHVybiAhY2Fpcm9faGFzX2N1cnJlbnRfcG9pbnQocGxhdGZvcm1QYXRoKCkt PmNvbnRleHQoKSk7CiB9CiAKLWJvb2wgUGF0aDo6aGFzQ3VycmVudFBvaW50KCkgY29uc3QKK0Zs b2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50U2xvd0Nhc2UoKSBjb25zdAogewotICAgIHJldHVy biAhaXNFbXB0eSgpOwotfQotCi1GbG9hdFBvaW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0 IAotewotICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIEZsb2F0UG9pbnQoKTsKLQog ICAgIC8vIEZJWE1FOiBJcyB0aGlzIHRoZSBjb3JyZWN0IHdheT8KICAgICBkb3VibGUgeDsKICAg ICBkb3VibGUgeTsKQEAgLTE0NSwxMyArMTM3LDEzIEBAIHZvaWQgUGF0aDo6dHJhbnNsYXRlKGNv bnN0IEZsb2F0U2l6ZSYgcCkKICAgICBjYWlyb190cmFuc2xhdGUoY3IsIC1wLndpZHRoKCksIC1w LmhlaWdodCgpKTsKIH0KIAotdm9pZCBQYXRoOjptb3ZlVG8oY29uc3QgRmxvYXRQb2ludCYgcCkK K3ZvaWQgUGF0aDo6bW92ZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYgcCkKIHsKICAgICBj YWlyb190KiBjciA9IGVuc3VyZVBsYXRmb3JtUGF0aCgpLT5jb250ZXh0KCk7CiAgICAgY2Fpcm9f bW92ZV90byhjciwgcC54KCksIHAueSgpKTsKIH0KIAotdm9pZCBQYXRoOjphZGRMaW5lVG8oY29u c3QgRmxvYXRQb2ludCYgcCkKK3ZvaWQgUGF0aDo6YWRkTGluZVRvU2xvd0Nhc2UoY29uc3QgRmxv YXRQb2ludCYgcCkKIHsKICAgICBjYWlyb190KiBjciA9IGVuc3VyZVBsYXRmb3JtUGF0aCgpLT5j b250ZXh0KCk7CiAgICAgY2Fpcm9fbGluZV90byhjciwgcC54KCksIHAueSgpKTsKQEAgLTE4OSwx MyArMTgxLDggQEAgdm9pZCBQYXRoOjphZGRCZXppZXJDdXJ2ZVRvKGNvbnN0IEZsb2F0UG9pbnQm IGNvbnRyb2xQb2ludDEsIGNvbnN0IEZsb2F0UG9pbnQmIGMKICAgICAgICAgICAgICAgICAgICBj b250cm9sUG9pbnQzLngoKSwgY29udHJvbFBvaW50My55KCkpOwogfQogCi12b2lkIFBhdGg6OmFk ZEFyYyhjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9h dCBlbmRBbmdsZSwgYm9vbCBhbnRpY2xvY2t3aXNlKQordm9pZCBQYXRoOjphZGRBcmNTbG93Q2Fz ZShjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBl bmRBbmdsZSwgYm9vbCBhbnRpY2xvY2t3aXNlKQogewotICAgIC8vIGh0dHA6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NDQ5Ci0gICAgLy8gY2Fpcm9fYXJjKCkgZnVuY3Rpb25z IGhhbmcgb3IgY3Jhc2ggd2hlbiBwYXNzZWQgaW5mIGFzIHJhZGl1cyBvciBzdGFydC9lbmQgYW5n bGUKLSAgICBpZiAoIXN0ZDo6aXNmaW5pdGUocikgfHwgIXN0ZDo6aXNmaW5pdGUoc3RhcnRBbmds ZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUpKQotICAgICAgICByZXR1cm47Ci0KICAgICBj YWlyb190KiBjciA9IGVuc3VyZVBsYXRmb3JtUGF0aCgpLT5jb250ZXh0KCk7CiAgICAgZmxvYXQg c3dlZXAgPSBlbmRBbmdsZSAtIHN0YXJ0QW5nbGU7CiAgICAgY29uc3QgZmxvYXQgdHdvUEkgPSAy ICogcGlGbG9hdDsKQEAgLTQwOCwxMSArMzk1LDggQEAgYm9vbCBQYXRoOjpzdHJva2VDb250YWlu cyhTdHJva2VTdHlsZUFwcGxpZXImIGFwcGxpZXIsIGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQog ICAgIHJldHVybiBjYWlyb19pbl9zdHJva2UoY3IsIHBvaW50LngoKSwgcG9pbnQueSgpKTsKIH0K IAotdm9pZCBQYXRoOjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9uJiBmdW5jdGlvbikg Y29uc3QKK3ZvaWQgUGF0aDo6YXBwbHlTbG93Q2FzZShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9u JiBmdW5jdGlvbikgY29uc3QKIHsKLSAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybjsK LQogICAgIGNhaXJvX3QqIGNyID0gcGxhdGZvcm1QYXRoKCktPmNvbnRleHQoKTsKICAgICBhdXRv IHBhdGhDb3B5ID0gY2Fpcm9fY29weV9wYXRoKGNyKTsKICAgICBjYWlyb19wYXRoX2RhdGFfdCog ZGF0YTsKQEAgLTQ1NSw2ICs0MzksMTYgQEAgdm9pZCBQYXRoOjp0cmFuc2Zvcm0oY29uc3QgQWZm aW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAgICAgY2Fpcm9fdHJhbnNmb3JtKGNyLCAmbWF0cml4 KTsKIH0KIAorYm9vbCBQYXRoOjppc051bGwoKSBjb25zdAoreworICAgIHJldHVybiAhbV9wYXRo OworfQorCit2b2lkIFBhdGg6OmNyZWF0ZVBsYXRmb3JtUGF0aCgpIGNvbnN0Cit7CisgICAgbV9w YXRoID0gbmV3IENhaXJvUGF0aDsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5k aWYgLy8gVVNFKENBSVJPKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2cvUGF0aENHLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nn L1BhdGhDRy5jcHAKaW5kZXggNTIxYzE1NTNhOWE2YTM0YTM4MWMzNGY5Nzg2MjU0ZGQ1ZjBjNzI2 ZS4uMzAxNjBmZDQ1YWNmYjM5OTgwMWY4YjFlNDNhMGQ1YjMxN2Q1NDBmOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3BwCkBAIC04MSw2ICs4MSwz MCBAQCBQYXRoIFBhdGg6OnBvbHlnb25QYXRoRnJvbVBvaW50cyhjb25zdCBWZWN0b3I8RmxvYXRQ b2ludD4mIHBvaW50cykKICAgICByZXR1cm4gcGF0aDsKIH0KIAordm9pZCBQYXRoOjpjcmVhdGVQ bGF0Zm9ybVBhdGgoKSBjb25zdAoreworICAgIGlmIChtX3BhdGgpCisgICAgICAgIHJldHVybjsK KworICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsKKworICAgIFdU Rjo6c3dpdGNoT24obV9pbmxpbmVEYXRhLAorICAgICAgICBbJl0oTW9ub3N0YXRlKSB7IH0sIC8v IFN0YXJ0IHdpdGggYW4gZW1wdHkgcGF0aC4KKyAgICAgICAgWyZdKGNvbnN0IE1vdmVEYXRhJiBt b3ZlKSB7CisgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KG1fcGF0aC5nZXQoKSwgbnVsbHB0ciwg bW92ZS5sb2NhdGlvbi54KCksIG1vdmUubG9jYXRpb24ueSgpKTsKKyAgICAgICAgfSwKKyAgICAg ICAgWyZdKGNvbnN0IExpbmVEYXRhJiBsaW5lKSB7CisgICAgICAgICAgICBDR1BhdGhNb3ZlVG9Q b2ludChtX3BhdGguZ2V0KCksIG51bGxwdHIsIGxpbmUuc3RhcnQueCgpLCBsaW5lLnN0YXJ0Lnko KSk7CisgICAgICAgICAgICBDR1BhdGhBZGRMaW5lVG9Qb2ludChtX3BhdGguZ2V0KCksIG51bGxw dHIsIGxpbmUuZW5kLngoKSwgbGluZS5lbmQueSgpKTsKKyAgICAgICAgfSwKKyAgICAgICAgWyZd KGNvbnN0IEFyY0RhdGEmIGFyYykgeworICAgICAgICAgICAgaWYgKGFyYy5oYXNPZmZzZXQpCisg ICAgICAgICAgICAgICAgQ0dQYXRoTW92ZVRvUG9pbnQobV9wYXRoLmdldCgpLCBudWxscHRyLCBh cmMub2Zmc2V0LngoKSwgYXJjLm9mZnNldC55KCkpOworICAgICAgICAgICAgQ0dQYXRoQWRkQXJj KG1fcGF0aC5nZXQoKSwgbnVsbHB0ciwgYXJjLmNlbnRlci54KCksIGFyYy5jZW50ZXIueSgpLCBh cmMucmFkaXVzLCBhcmMuc3RhcnQsIGFyYy5lbmQsIGFyYy5jbG9ja3dpc2UpOworICAgICAgICB9 CisgICAgKTsKK30KKwogUGF0aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0aFJlZj4mJiBw YXRoKQogICAgIDogbV9wYXRoKFdURk1vdmUocGF0aCkpCiB7CkBAIC04OSwyMSArMTEzLDM0IEBA IFBhdGg6OlBhdGgoUmV0YWluUHRyPENHTXV0YWJsZVBhdGhSZWY+JiYgcGF0aCkKIFBhdGg6OlBh dGgoKSA9IGRlZmF1bHQ7CiBQYXRoOjp+UGF0aCgpID0gZGVmYXVsdDsKIAorUGxhdGZvcm1QYXRo UHRyIFBhdGg6OnBsYXRmb3JtUGF0aCgpIGNvbnN0Cit7CisgICAgaWYgKG5lZWRzVG9BcHBseUlu bGluZURhdGEoKSkKKyAgICAgICAgY3JlYXRlUGxhdGZvcm1QYXRoKCk7CisgICAgcmV0dXJuIG1f cGF0aC5nZXQoKTsKK30KKwogUGxhdGZvcm1QYXRoUHRyIFBhdGg6OmVuc3VyZVBsYXRmb3JtUGF0 aCgpCiB7Ci0gICAgaWYgKCFtX3BhdGgpCi0gICAgICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRo Q3JlYXRlTXV0YWJsZSgpKTsKLSAgICBlbHNlIGlmIChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24p IHsKKyAgICBjcmVhdGVQbGF0Zm9ybVBhdGgoKTsKKyAgICBpZiAobV9jb3B5UGF0aEJlZm9yZU11 dGF0aW9uKSB7CiAgICAgICAgIGlmIChDRkdldFJldGFpbkNvdW50KG1fcGF0aC5nZXQoKSkgPiAx KQogICAgICAgICAgICAgbV9wYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weSht X3BhdGguZ2V0KCkpKTsKICAgICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gZmFsc2U7 CiAgICAgfQorICAgIG1faW5saW5lRGF0YSA9IE1vbm9zdGF0ZSB7IH07CiAgICAgcmV0dXJuIG1f cGF0aC5nZXQoKTsKIH0KIAorYm9vbCBQYXRoOjppc051bGwoKSBjb25zdAoreworICAgIHJldHVy biAhbV9wYXRoICYmICFoYXNBbnlJbmxpbmVEYXRhKCk7Cit9CisKIFBhdGg6OlBhdGgoY29uc3Qg UGF0aCYgb3RoZXIpCiB7CiAgICAgbV9wYXRoID0geyBvdGhlci5tX3BhdGggfTsKKyAgICBtX2lu bGluZURhdGEgPSBvdGhlci5tX2lubGluZURhdGE7CiAgICAgaWYgKG1fcGF0aCkgewogICAgICAg ICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOwogICAgICAgICBvdGhlci5tX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24gPSB0cnVlOwpAQCAtMTEyLDYgKzE0OSw3IEBAIFBhdGg6OlBhdGgo Y29uc3QgUGF0aCYgb3RoZXIpCiAKIFBhdGg6OlBhdGgoUGF0aCYmIG90aGVyKQogICAgIDogbV9w YXRoKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9wYXRoLCBudWxscHRyKSkKKyAgICAsIG1faW5saW5l RGF0YShzdGQ6OmV4Y2hhbmdlKG90aGVyLm1faW5saW5lRGF0YSwgTW9ub3N0YXRlIHsgfSkpCiAg ICAgLCBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24oc3RkOjpleGNoYW5nZShvdGhlci5tX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24sIGZhbHNlKSkKIHsKIH0KQEAgLTExOSw2ICsxNTcsNyBAQCBQYXRo OjpQYXRoKFBhdGgmJiBvdGhlcikKIHZvaWQgUGF0aDo6c3dhcChQYXRoJiBvdGhlclBhdGgpCiB7 CiAgICAgc3RkOjpzd2FwKG1fcGF0aCwgb3RoZXJQYXRoLm1fcGF0aCk7CisgICAgc3RkOjpzd2Fw KG1faW5saW5lRGF0YSwgb3RoZXJQYXRoLm1faW5saW5lRGF0YSk7CiAgICAgc3RkOjpzd2FwKG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbiwgb3RoZXJQYXRoLm1fY29weVBhdGhCZWZvcmVNdXRhdGlv bik7CiB9CiAKQEAgLTE3OSw3ICsyMTgsNyBAQCBib29sIFBhdGg6OmNvbnRhaW5zKGNvbnN0IEZs b2F0UG9pbnQgJnBvaW50LCBXaW5kUnVsZSBydWxlKSBjb25zdAogICAgICAgICByZXR1cm4gZmFs c2U7CiAKICAgICAvLyBDR1BhdGhDb250YWluc1BvaW50IHJldHVybnMgZmFsc2UgZm9yIG5vbi1j bG9zZWQgcGF0aHMsIGFzIGEgd29yay1hcm91bmQsIHdlIGNvcHkgYW5kIGNsb3NlIHRoZSBwYXRo IGZpcnN0LiAgUmFkYXIgNDc1ODk5OCBhc2tzIGZvciBhIGJldHRlciBDRyBBUEkgdG8gdXNlCi0g ICAgYXV0byBwYXRoID0gYWRvcHRDRihjb3B5Q0dQYXRoQ2xvc2luZ1N1YnBhdGhzKG1fcGF0aC5n ZXQoKSkpOworICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoY29weUNHUGF0aENsb3NpbmdTdWJwYXRo cyhwbGF0Zm9ybVBhdGgoKSkpOwogICAgIGJvb2wgcmV0ID0gQ0dQYXRoQ29udGFpbnNQb2ludChw YXRoLmdldCgpLCAwLCBwb2ludCwgcnVsZSA9PSBXaW5kUnVsZTo6RXZlbk9kZCA/IHRydWUgOiBm YWxzZSk7CiAgICAgcmV0dXJuIHJldDsKIH0KQEAgLTIxNywzMCArMjU2LDM4IEBAIHZvaWQgUGF0 aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIENHQWZm aW5lVHJhbnNmb3JtIHRyYW5zZm9ybUNHID0gdHJhbnNmb3JtOwogI2lmIFBMQVRGT1JNKFdJTikK ICAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgQ0dQ YXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIG1fcGF0aC5nZXQoKSk7CisgICAg Q0dQYXRoQWRkUGF0aChwYXRoLmdldCgpLCAmdHJhbnNmb3JtQ0csIHBsYXRmb3JtUGF0aCgpKTsK ICNlbHNlCi0gICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRhYmxlQ29weUJ5 VHJhbnNmb3JtaW5nUGF0aChtX3BhdGguZ2V0KCksICZ0cmFuc2Zvcm1DRykpOworICAgIGF1dG8g cGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgo cGxhdGZvcm1QYXRoKCksICZ0cmFuc2Zvcm1DRykpOwogI2VuZGlmCiAgICAgbV9wYXRoID0gV1RG TW92ZShwYXRoKTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24gPSBmYWxzZTsKKyAgICBt X2lubGluZURhdGEgPSBNb25vc3RhdGUgeyB9OwogfQogCiBGbG9hdFJlY3QgUGF0aDo6Ym91bmRp bmdSZWN0KCkgY29uc3QKIHsKICAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybiBDR1Jl Y3RaZXJvOworICAgICAgICByZXR1cm4geyB9OworCisgICAgaWYgKGF1dG8gcmVjdCA9IGJvdW5k aW5nUmVjdEZyb21JbmxpbmVEYXRhKCkpCisgICAgICAgIHJldHVybiAqcmVjdDsKIAogICAgIC8v IENHUGF0aEdldEJvdW5kaW5nQm94IGluY2x1ZGVzIHRoZSBwYXRoJ3MgY29udHJvbCBwb2ludHMs IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveCBkb2VzIG5vdC4KIAotICAgIENHUmVjdCBib3VuZCA9 IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChtX3BhdGguZ2V0KCkpOworICAgIENHUmVjdCBib3Vu ZCA9IENHUGF0aEdldFBhdGhCb3VuZGluZ0JveChwbGF0Zm9ybVBhdGgoKSk7CiAgICAgcmV0dXJu IENHUmVjdElzTnVsbChib3VuZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7CiB9CiAKIEZsb2F0UmVj dCBQYXRoOjpmYXN0Qm91bmRpbmdSZWN0KCkgY29uc3QKIHsKICAgICBpZiAoaXNOdWxsKCkpCi0g ICAgICAgIHJldHVybiBDR1JlY3RaZXJvOwotICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldEJv dW5kaW5nQm94KG1fcGF0aC5nZXQoKSk7CisgICAgICAgIHJldHVybiB7IH07CisKKyAgICBpZiAo YXV0byByZWN0ID0gYm91bmRpbmdSZWN0RnJvbUlubGluZURhdGEoKSkKKyAgICAgICAgcmV0dXJu ICpyZWN0OworCisgICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0Qm91bmRpbmdCb3gocGxhdGZv cm1QYXRoKCkpOwogICAgIHJldHVybiBDR1JlY3RJc051bGwoYm91bmQpID8gQ0dSZWN0WmVybyA6 IGJvdW5kOwogfQogCkBAIC0yNjcsMTIgKzMxNCwxMiBAQCBGbG9hdFJlY3QgUGF0aDo6c3Ryb2tl Qm91bmRpbmdSZWN0KFN0cm9rZVN0eWxlQXBwbGllciogYXBwbGllcikgY29uc3QKICAgICByZXR1 cm4gQ0dSZWN0SXNOdWxsKGJveCkgPyBDR1JlY3RaZXJvIDogYm94OwogfQogCi12b2lkIFBhdGg6 Om1vdmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3ZvaWQgUGF0aDo6bW92ZVRvU2xvd0Nh c2UoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCiB7CiAgICAgQ0dQYXRoTW92ZVRvUG9pbnQoZW5z dXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHBvaW50LngoKSwgcG9pbnQueSgpKTsKIH0KIAot dm9pZCBQYXRoOjphZGRMaW5lVG8oY29uc3QgRmxvYXRQb2ludCYgcCkKK3ZvaWQgUGF0aDo6YWRk TGluZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYgcCkKIHsKICAgICBDR1BhdGhBZGRMaW5l VG9Qb2ludChlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54KCksIHAueSgpKTsKIH0K QEAgLTM1MCwxMiArMzk3LDggQEAgdm9pZCBQYXRoOjpjbG9zZVN1YnBhdGgoKQogICAgIENHUGF0 aENsb3NlU3VicGF0aChlbnN1cmVQbGF0Zm9ybVBhdGgoKSk7CiB9CiAKLXZvaWQgUGF0aDo6YWRk QXJjKGNvbnN0IEZsb2F0UG9pbnQmIHAsIGZsb2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwg ZmxvYXQgZW5kQW5nbGUsIGJvb2wgY2xvY2t3aXNlKQordm9pZCBQYXRoOjphZGRBcmNTbG93Q2Fz ZShjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByYWRpdXMsIGZsb2F0IHN0YXJ0QW5nbGUsIGZs b2F0IGVuZEFuZ2xlLCBib29sIGNsb2Nrd2lzZSkKIHsKLSAgICAvLyBXb3JrYXJvdW5kIGZvciA8 cmRhcjovL3Byb2JsZW0vNTE4OTIzMz4gQ0dQYXRoQWRkQXJjIGhhbmdzIG9yIGNyYXNoZXMgd2hl biBwYXNzZWQgaW5mIGFzIHN0YXJ0IG9yIGVuZCBhbmdsZQotICAgIGlmICghc3RkOjppc2Zpbml0 ZShzdGFydEFuZ2xlKSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCi0gICAgICAgIHJldHVy bjsKLQogICAgIENHUGF0aEFkZEFyYyhlbnN1cmVQbGF0Zm9ybVBhdGgoKSwgbnVsbHB0ciwgcC54 KCksIHAueSgpLCByYWRpdXMsIHN0YXJ0QW5nbGUsIGVuZEFuZ2xlLCBjbG9ja3dpc2UpOwogfQog CkBAIC00MDIsMjUgKzQ0NSwxOSBAQCB2b2lkIFBhdGg6OmNsZWFyKCkKICAgICBpZiAoaXNOdWxs KCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRl TXV0YWJsZSgpKTsKKyAgICBtX3BhdGguY2xlYXIoKTsKKyAgICBtX2lubGluZURhdGEgPSBNb25v c3RhdGUgeyB9OwogICAgIG1fY29weVBhdGhCZWZvcmVNdXRhdGlvbiA9IGZhbHNlOwogfQogCi1i b29sIFBhdGg6OmlzRW1wdHkoKSBjb25zdAorYm9vbCBQYXRoOjppc0VtcHR5U2xvd0Nhc2UoKSBj b25zdAogewotICAgIHJldHVybiBpc051bGwoKSB8fCBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQo KSk7CisgICAgcmV0dXJuIENHUGF0aElzRW1wdHkobV9wYXRoLmdldCgpKTsKIH0KIAotYm9vbCBQ YXRoOjpoYXNDdXJyZW50UG9pbnQoKSBjb25zdAorRmxvYXRQb2ludCBQYXRoOjpjdXJyZW50UG9p bnRTbG93Q2FzZSgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuICFpc0VtcHR5KCk7Ci19Ci0gICAgCi1G bG9hdFBvaW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0IAotewotICAgIGlmIChpc051bGwo KSkKLSAgICAgICAgcmV0dXJuIEZsb2F0UG9pbnQoKTsKLSAgICByZXR1cm4gQ0dQYXRoR2V0Q3Vy cmVudFBvaW50KG1fcGF0aC5nZXQoKSk7CisgICAgcmV0dXJuIENHUGF0aEdldEN1cnJlbnRQb2lu dChwbGF0Zm9ybVBhdGgoKSk7CiB9CiAKIHN0YXRpYyB2b2lkIENHUGF0aEFwcGxpZXJUb1BhdGhB cHBsaWVyKHZvaWQqIGluZm8sIGNvbnN0IENHUGF0aEVsZW1lbnQqIGVsZW1lbnQpCkBAIC00NDks MTkgKzQ4NiwxNiBAQCBzdGF0aWMgdm9pZCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcih2b2lk KiBpbmZvLCBjb25zdCBDR1BhdGhFbGVtZW50KiBlbGVtZW50KQogICAgIGZ1bmN0aW9uKHBhdGhF bGVtZW50KTsKIH0KIAotdm9pZCBQYXRoOjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9u JiBmdW5jdGlvbikgY29uc3QKK3ZvaWQgUGF0aDo6YXBwbHlTbG93Q2FzZShjb25zdCBQYXRoQXBw bGllckZ1bmN0aW9uJiBmdW5jdGlvbikgY29uc3QKIHsKLSAgICBpZiAoaXNOdWxsKCkpCi0gICAg ICAgIHJldHVybjsKLQotICAgIENHUGF0aEFwcGx5KG1fcGF0aC5nZXQoKSwgKHZvaWQqKSZmdW5j dGlvbiwgQ0dQYXRoQXBwbGllclRvUGF0aEFwcGxpZXIpOworICAgIENHUGF0aEFwcGx5KHBsYXRm b3JtUGF0aCgpLCAodm9pZCopJmZ1bmN0aW9uLCBDR1BhdGhBcHBsaWVyVG9QYXRoQXBwbGllcik7 CiB9CiAKICNpZiBIQVZFKENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQogCi1zaXplX3Qg UGF0aDo6ZWxlbWVudENvdW50KCkgY29uc3QKK3NpemVfdCBQYXRoOjplbGVtZW50Q291bnRTbG93 Q2FzZSgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIENHUGF0aEdldE51bWJlck9mRWxlbWVudHMobV9w YXRoKTsKKyAgICByZXR1cm4gQ0dQYXRoR2V0TnVtYmVyT2ZFbGVtZW50cyhwbGF0Zm9ybVBhdGgo KSk7CiB9CiAKICNlbmRpZiAvLyBIQVZFKENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3Rz L0Rpc3BsYXlMaXN0SXRlbXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRlbXMuY3BwCmluZGV4IGQ0NTMxYmFiNWNhNDRjZWJj YWY5NWFhZmU3NTAzMmY0MzlhYjhhZDcuLmUyMjYxNzAzZTRiYzBiOWFhZjUwNTNiMzQ3YThmYzhm MDEwOWE0NzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rp c3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKQEAgLTEyMjgs NyArMTIyOCw3IEBAIE9wdGlvbmFsPEZsb2F0UmVjdD4gU3Ryb2tlUGF0aDo6bG9jYWxCb3VuZHMo Y29uc3QgR3JhcGhpY3NDb250ZXh0JiBjb250ZXh0KSBjb25zCiAKIHZvaWQgU3Ryb2tlUGF0aDo6 YXBwbHkoR3JhcGhpY3NDb250ZXh0JiBjb250ZXh0KSBjb25zdAogewotICAgIGNvbnRleHQuc3Ry b2tlUGF0aChtX3BhdGgpOworICAgIGNvbnRleHQuc3Ryb2tlUGF0aChXVEZNb3ZlKG1fcGF0aCkp OwogfQogCiBzdGF0aWMgVGV4dFN0cmVhbSYgb3BlcmF0b3I8PChUZXh0U3RyZWFtJiB0cywgY29u c3QgU3Ryb2tlUGF0aCYgaXRlbSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5oCmluZGV4 IDc3NDIwNWFjNzNmNjI3MTRlM2NmYTkwZTAyMmNlNWM3NzA4MjhmMmIuLmI5MGVkMjA5ZDFkMTkz N2IzMjY3MzdmOTZjNTliOTE2ZGI3MmU4M2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRl bXMuaApAQCAtMjU4OSw3ICsyNTg5LDcgQEAgcHJpdmF0ZToKICAgICB2b2lkIGFwcGx5KEdyYXBo aWNzQ29udGV4dCYpIGNvbnN0IG92ZXJyaWRlOwogICAgIE9wdGlvbmFsPEZsb2F0UmVjdD4gbG9j YWxCb3VuZHMoY29uc3QgR3JhcGhpY3NDb250ZXh0JikgY29uc3Qgb3ZlcnJpZGU7CiAKLSAgICBj b25zdCBQYXRoIG1fcGF0aDsKKyAgICBtdXRhYmxlIFBhdGggbV9wYXRoOwogfTsKIAogdGVtcGxh dGU8Y2xhc3MgRW5jb2Rlcj4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3Mvd2luL1BhdGhEaXJlY3QyRC5jcHAKaW5kZXggZmY2MzAxNDM5NDA0ZjA3ZmE3MGY4YTNj NjQ3YTU4ZDFiNGNiYmQ2NS4uNTgzOGE1OWE3YWNmZmJiZjJmYzAzNjdhZDBiZWI5Y2NiZWY5MmIw NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1BhdGhE aXJlY3QyRC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luL1Bh dGhEaXJlY3QyRC5jcHAKQEAgLTM3NCw3ICszNzQsNyBAQCB2b2lkIFBhdGg6Om9wZW5GaWd1cmVB dEN1cnJlbnRQb2ludElmTmVjZXNzYXJ5KCkKICAgICBtX2ZpZ3VyZUlzT3BlbmVkID0gdHJ1ZTsK IH0KIAotdm9pZCBQYXRoOjptb3ZlVG8oY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCit2b2lkIFBh dGg6Om1vdmVUb1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQogewogICAgIGlmICht X2FjdGl2ZVBhdGgpCiAgICAgICAgIGNsb3NlQW55T3Blbkdlb21ldHJpZXMoRDJEMV9GSUdVUkVf RU5EX09QRU4pOwpAQCAtMzk0LDcgKzM5NCw3IEBAIHZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0IEZs b2F0UG9pbnQmIHBvaW50KQogICAgIG1fZmlndXJlSXNPcGVuZWQgPSB0cnVlOwogfQogCi12b2lk IFBhdGg6OmFkZExpbmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3ZvaWQgUGF0aDo6YWRk TGluZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCiB7CiAgICAgb3BlbkZpZ3Vy ZUF0Q3VycmVudFBvaW50SWZOZWNlc3NhcnkoKTsKICAgICBtX2FjdGl2ZVBhdGgtPkFkZExpbmUo cG9pbnQpOwpAQCAtNTI1LDcgKzUyNSw3IEBAIHN0YXRpYyB2b2lkIGRyYXdBcmNTZWN0aW9uKElE MkQxR2VvbWV0cnlTaW5rKiBzaW5rLCBjb25zdCBGbG9hdFBvaW50JiBjZW50ZXIsIGZsCiAgICAg c2luay0+QWRkQXJjKEQyRDE6OkFyY1NlZ21lbnQoZW5kUG9pbnQsIEQyRDE6OlNpemVGKHJhZGl1 cywgcmFkaXVzKSwgMCwgZGlyZWN0aW9uLCBEMkQxX0FSQ19TSVpFX1NNQUxMKSk7CiB9CiAKLXZv aWQgUGF0aDo6YWRkQXJjKGNvbnN0IEZsb2F0UG9pbnQmIGNlbnRlciwgZmxvYXQgcmFkaXVzLCBm bG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmRBbmdsZSwgYm9vbCBhbnRpY2xvY2t3aXNlKQordm9p ZCBQYXRoOjphZGRBcmNTbG93Q2FzZShjb25zdCBGbG9hdFBvaW50JiBjZW50ZXIsIGZsb2F0IHJh ZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUsIGJvb2wgYW50aWNsb2Nrd2lz ZSkKIHsKICAgICBhdXRvIGFyY1N0YXJ0UG9pbnQgPSBhcmNTdGFydChjZW50ZXIsIHJhZGl1cywg c3RhcnRBbmdsZSk7CiAgICAgaWYgKCFtX2FjdGl2ZVBhdGgpCkBAIC02MjEsMTEgKzYyMSw4IEBA IHZvaWQgUGF0aDo6Y2xlYXIoKQogICAgIGNsZWFyR2VvbWV0cmllcygpOwogfQogCi1ib29sIFBh dGg6OmlzRW1wdHkoKSBjb25zdAorYm9vbCBQYXRoOjppc0VtcHR5U2xvd0Nhc2UoKSBjb25zdAog ewotICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICBpZiAoIW1f cGF0aC0+R2V0U291cmNlR2VvbWV0cnlDb3VudCgpKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIApA QCAtNjM0LDE2ICs2MzEsOCBAQCBib29sIFBhdGg6OmlzRW1wdHkoKSBjb25zdAogICAgIHJldHVy biBmYWxzZTsKIH0KIAotYm9vbCBQYXRoOjpoYXNDdXJyZW50UG9pbnQoKSBjb25zdAorRmxvYXRQ b2ludCBQYXRoOjpjdXJyZW50UG9pbnRTbG93Q2FzZSgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuICFp c0VtcHR5KCk7Ci19Ci0gICAgCi1GbG9hdFBvaW50IFBhdGg6OmN1cnJlbnRQb2ludCgpIGNvbnN0 IAotewotICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIEZsb2F0UG9pbnQoKTsKLQog ICAgIGZsb2F0IGxlbmd0aCA9IDA7CiAgICAgSFJFU1VMVCBociA9IG1fcGF0aC0+Q29tcHV0ZUxl bmd0aChudWxscHRyLCAmbGVuZ3RoKTsKICAgICBpZiAoIVNVQ0NFRURFRChocikpCkBAIC02Njgs MTQgKzY1NywyMiBAQCBmbG9hdCBQYXRoOjpsZW5ndGgoKSBjb25zdAogICAgIHJldHVybiBsZW5n dGg7CiB9CiAKLXZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYgZnVu Y3Rpb24pIGNvbnN0Cit2b2lkIFBhdGg6OmFwcGx5U2xvd0Nhc2UoY29uc3QgUGF0aEFwcGxpZXJG dW5jdGlvbiYpIGNvbnN0CiB7Ci0gICAgaWYgKGlzTnVsbCgpKQotICAgICAgICByZXR1cm47Ci0K ICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCitib29sIFBhdGg6OmlzTnVsbCgpIGNvbnN0Cit7 CisgICAgcmV0dXJuICFtX3BhdGg7Cit9CisKK3ZvaWQgUGF0aDo6Y3JlYXRlUGxhdGZvcm1QYXRo KCkgY29uc3QKK3sKKyAgICBIUkVTVUxUIGhyID0gR3JhcGhpY3NDb250ZXh0OjpzeXN0ZW1GYWN0 b3J5KCktPkNyZWF0ZUdlb21ldHJ5R3JvdXAoRDJEMV9GSUxMX01PREVfV0lORElORywgbnVsbHB0 ciwgMCwgJm1fcGF0aCk7CisgICAgQVNTRVJUKFNVQ0NFRURFRChocikpOworfQorCiB9CiAKICNl bmRpZiAvLyBVU0UoRElSRUNUMkQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3Jt L0lQQy9Bcmd1bWVudENvZGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Bcmd1 bWVudENvZGVycy5jcHAKaW5kZXggNzZkMmIwOWRhYmYxMTRjMzljNjQ2YWUzMTYzN2ZhMjAxNjFm ZGIzZi4uMmEzZDg2YjFmN2ExZmU0ZmMzOWJjMGE0OTdhMTgzMjgwOTAwNTM2NiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcApAQCAtMjA1LDQgKzIw NSwxMyBAQCBib29sIEFyZ3VtZW50Q29kZXI8YXVkaXRfdG9rZW5fdD46OmRlY29kZShEZWNvZGVy JiBkZWNvZGVyLCBhdWRpdF90b2tlbl90JiBhdWRpdAogfQogI2VuZGlmCiAKK3ZvaWQgQXJndW1l bnRDb2RlcjxNb25vc3RhdGU+OjplbmNvZGUoRW5jb2RlciYsIGNvbnN0IE1vbm9zdGF0ZSYpCit7 Cit9CisKK09wdGlvbmFsPE1vbm9zdGF0ZT4gQXJndW1lbnRDb2RlcjxNb25vc3RhdGU+OjpkZWNv ZGUoRGVjb2RlciYpCit7CisgICAgcmV0dXJuIE1vbm9zdGF0ZSB7IH07Cit9CisKIH0gLy8gbmFt ZXNwYWNlIElQQwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1l bnRDb2RlcnMuaCBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmgK aW5kZXggNThjNDU2NDY4OGM4ZjNmMmVhYzFhYzQ3MDE4MmI4NWFmYWRmYzY2NC4uZTdiMjZmNDU1 NmZhNGQzMmY1ZjZmYmRlOWY1YWRmZGM5ZjFmYWM5YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRm b3JtL0lQQy9Bcmd1bWVudENvZGVycy5oCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSA8d3Rm L01vbm90b25pY1RpbWUuaD4KICNpbmNsdWRlIDx3dGYvU0hBMS5oPgogI2luY2x1ZGUgPHd0Zi9V bmV4cGVjdGVkLmg+CisjaW5jbHVkZSA8d3RmL1ZhcmlhbnQuaD4KICNpbmNsdWRlIDx3dGYvV2Fs bFRpbWUuaD4KIAogbmFtZXNwYWNlIElQQyB7CkBAIC02OTEsNCArNjkyLDkgQEAgdGVtcGxhdGU8 PiBzdHJ1Y3QgQXJndW1lbnRDb2RlcjxhdWRpdF90b2tlbl90PiB7CiB9OwogI2VuZGlmCiAKK3Rl bXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPiB7CisgICAgc3RhdGljIHZv aWQgZW5jb2RlKEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKTsKKyAgICBzdGF0aWMgT3B0aW9u YWw8TW9ub3N0YXRlPiBkZWNvZGUoRGVjb2RlciYpOworfTsKKwogfSAvLyBuYW1lc3BhY2UgSVBD Cg== 392991 2020-03-08 15:11:16 -0700 2020-03-08 15:11:16 -0700 For EWS bug-208464-20200308151116.patch text/plain 50081 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4MDkxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNlYjg0YzRhMTNhNTFmNzlkODIwZDc0 YjNhOGVkNmIwOTg5NDkyOGEuLjk2ZjJjNjM5YTMxMjQwZjI4NTBjNTY1MTdhODc4NGZkYThhNTRj MWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMDggIFdlbnNvbiBIc2llaCAgPHdlbnNv bl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgTGF6aWx5IGdlbmVyYXRlIENHUGF0aHMgZm9y IHNvbWUgc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCBzdWNoIGFzIGFyY3MgYW5kIGxpbmVzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg0NjQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzU5OTYzMjI2PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhbmll bCBCYXRlcywgRGFyaW4gQWRsZXIgYW5kIFRpbSBIb3J0b24uCisKKyAgICAgICAgQWRkIGEgZmVh dHVyZSBmbGFnIGZvciBJTkxJTkVfUEFUSF9EQVRBLiBUaGlzIGZlYXR1cmUgZmxhZyBleGlzdHMg dG8gZW5zdXJlIHRoYXQgd2UgY2FuIGF2b2lkIGhhdmluZworICAgICAgICBtX2lubGluZURhdGEg b24gUGF0aCBpbiBwb3J0cyB0aGF0IGRvbid0IGltcGxlbWVudCB0aGUgbmVjZXNzYXJ5IGZhY2ls aXRpZXMgZm9yIGlubGluZSBwYXRoIGRhdGEgeWV0LCBzaW5jZSBpdAorICAgICAgICB3b3VsZCBq dXN0IGVuZCB1cCBiZWluZyB3YXN0ZWQgbWVtb3J5LgorCisgICAgICAgICogd3RmL1BsYXRmb3Jt RW5hYmxlLmg6CisKIDIwMjAtMDMtMDcgIERhbmllbCBCYXRlcyAgPGRhYmF0ZXNAYXBwbGUuY29t PgogCiAgICAgICAgIFtpT1NdIEltcGxlbWVudCBzdXBwb3J0IGZvciBkaWN0YXRpb24gYWx0ZXJu YXRpdmVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKaW5kZXggMDRiMTc0NDQyNWE3NjRiMjMwNTBlYjdiOGI0MzRmMzhjOGE2 NGI4OC4uM2VlNmM1YmVjOTA0N2JhMzkzM2EwYmI5YzM3OTEwMzFmYjcwY2U4MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDIwNyBAQAorMjAyMC0wMy0wOCAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hz aWVoQGFwcGxlLmNvbT4KKworICAgICAgICBMYXppbHkgZ2VuZXJhdGUgQ0dQYXRocyBmb3Igc29t ZSBzaW1wbGUgdHlwZXMgb2YgcGF0aHMsIHN1Y2ggYXMgYXJjcyBhbmQgbGluZXMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwODQ2NAorICAgICAgICA8 cmRhcjovL3Byb2JsZW0vNTk5NjMyMjY+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFuaWVsIEJh dGVzLCBEYXJpbiBBZGxlciBhbmQgVGltIEhvcnRvbi4KKworICAgICAgICBXaGVuIHRoZSBHUFUg cHJvY2VzcyBpcyBlbmFibGVkIGFuZCB1c2VkIHRvIHJlbmRlciB0aGUgY2FudmFzIGVsZW1lbnQs IHNvbWUgY2FudmFzLXJlbGF0ZWQgc3VidGVzdHMgaW4KKyAgICAgICAgTW90aW9uTWFyayBzZWUg c2lnbmlmaWNhbnQgcGVyZm9ybWFuY2UgcmVncmVzc2lvbnMuIE9uZSBvZiB0aGUgcmVhc29ucyBm b3IgdGhpcyBpcyB0aGF0IGluIHRoZSBwcm9jZXNzIG9mCisgICAgICAgIGRlY29kaW5nIGRpc3Bs YXkgbGlzdCBpdGVtcyB0aGF0IGNvbnRhaW4gYFdlYkNvcmU6OlBhdGhgcyBpbiB0aGUgR1BVIHBy b2Nlc3MsIHdlIGVuZCB1cCBhbGxvY2F0aW5nIGEgbmV3IENHUGF0aAorICAgICAgICBmb3IgZWFj aCBXZWJDb3JlOjpQYXRoLiBUaGlzIGRyYW1hdGljYWxseSBpbmNyZWFzZXMgcGFnZSBkZW1hbmQg YW5kIG1lbW9yeSB1c2FnZSBpbiB0aGUgR1BVIHByb2Nlc3MgaW4gY29udHJhc3QKKyAgICAgICAg dG8gc2hpcHBpbmcgV2ViS2l0LCBkdWUgdG8gdGhlIGZhY3QgdGhhdCBhbGwgb2YgdGhlc2UgQ0dQ YXRocyBhbGxvY2F0ZWQgdXAtZnJvbnQsIGFuZCBtdXN0IGFsbCBleGlzdCBzb21ld2hlcmUKKyAg ICAgICAgaW4gdGhlIGhlYXAgdXBvbiBkZWNvZGluZyB0aGUgZGlzcGxheSBsaXN0LgorCisgICAg ICAgIEluIGNvbnRyYXN0LCBpbiBzaGlwcGluZyBXZWJLaXQsIGVhY2ggY2FsbCB0byBzdHJva2Ug dGhlIGN1cnJlbnQgY2FudmFzIHBhdGggKGkuZS4gaW52b2tpbmcKKyAgICAgICAgR3JhcGhpY3ND b250ZXh0OjpzdHJva2VQYXRoKSBpcyBzdWNjZWVkZWQgYnkgY2xlYXJpbmcgdGhlIHBhdGgsIHdo aWNoIGRlYWxsb2NhdGVzIHRoZSBDR1BhdGggYmFja2luZyB0aGUgV2ViQ29yZQorICAgICAgICBQ YXRoLiBUaGUgbmV4dCB0aW1lIGEgQ0dQYXRoIG5lZWRzIHRvIGJlIGNyZWF0ZWQsIENvcmVHcmFw aGljcyBpcyBmcmVlIHRvIHRoZW4gYWxsb2NhdGUgdGhlIG5ldyBDR1BhdGggYXQgdGhlCisgICAg ICAgIGFkZHJlc3Mgb2YgdGhlIHByZXZpb3VzIENHUGF0aCB3aGljaCB3YXMganVzdCBkZXN0cm95 ZWQsIHdoaWNoIHByZXZlbnRzIHVzIGZyb20gZGlydHlpbmcgbW9yZSBwYWdlcyB0aGFuCisgICAg ICAgIG5lY2Vzc2FyeS4gVGhpcyBwaGVub21lbm9uIGFmZmVjdHMgbW9zdCBvZiB0aGUgY2FudmFz LXJlbGF0ZWQgTW90aW9uTWFyayBzdWJ0ZXN0cyB0byBzb21lIGRlZ3JlZSwgdGhvdWdoIHRoZQor ICAgICAgICBpbXBhY3QgaXMgbW9zdCBub3RpY2VhYmxlIHdpdGggQ2FudmFzIExpbmVzLgorCisg ICAgICAgIE9uIHRvcCBvZiBhbGwgdGhpcywgYSBzaWduaWZpY2FudCBwb3J0aW9uIG9mIHRpbWUg aXMgYWxzbyBzcGVudCBjYWxsaW5nIENHUGF0aEFwcGx5IGFuZCBjb252ZXJ0aW5nIHRoZSByZXN1 bHRpbmcKKyAgICAgICAgQ0dQYXRoRWxlbWVudHMgaW50byBzZXJpYWxpemFibGUgZGF0YSB3aGVu IGVuY29kaW5nIGVhY2ggV2ViQ29yZSBQYXRoLgorCisgICAgICAgIFRvIG1pdGlnYXRlIHRoZXNl IHR3byBpc3N1ZXMgYW5kIHJlc3RvcmUgdGhlIHdpbnMgd2UgZ2V0IGZyb20gbWVtb3J5IGxvY2Fs aXR5IHdoZW4gZHJhd2luZyBwYXRocyBpbiBsYXJnZQorICAgICAgICBxdWFudGl0aWVzLCB3ZSBj YW46CisKKyAgICAgICAgMS4gIEluIHRoZSBjYXNlIG9mIHNpbXBsZSBwYXRocywgc3R1ZmYgc29t ZSBpbmZvcm1hdGlvbiBhYm91dCBob3cgZWFjaCBwYXRoIHdhcyBjcmVhdGVkIGFzIGlubGluZSBk YXRhIG9uCisgICAgICAgICAgICBXZWJDb3JlOjpQYXRoIGl0c2VsZiwgYXMgYSBuZXcgZGF0YSBt ZW1iZXIuIEZvciBub3csIHRoaXMgb25seSBlbmNvbXBhc3NlcyBsaW5lcywgYXJjcywgYW5kIG1v dmVzIChQYXRocworICAgICAgICAgICAgd2hlcmUgb25seSBgUGF0aDo6bW92ZVRvYCB3YXMgaW52 b2tlZCksIGJ1dCBtYXkgYmUgZXhwYW5kZWQgaW4gdGhlIGZ1dHVyZSB0byBpbmNsdWRlIGVsbGlw c2VzIGFuZCByZWN0cy4KKyAgICAgICAgICAgIFRoaXMgYWxsb3dzIHVzIHRvIGFjaGlldmUgdHdv IHRoaW5nczogKGEpIG1ha2UgZW5jb2RpbmcgY2hlYXBlciBieSBub3QgcmVxdWlyaW5nIGEgd2Fs ayB0aHJvdWdoIGFsbCBvZgorICAgICAgICAgICAgQ0dQYXRoJ3MgZWxlbWVudHMsIGFuZCAoYikg bWFrZSBkZWNvZGluZyBjaGVhcGVyIGJ5IGp1c3QgaW5pdGlhbGl6aW5nIHRoZSBQYXRoIHVzaW5n IGlubGluZSBkYXRhLCByYXRoZXIKKyAgICAgICAgICAgIHRoYW4gaGF2aW5nIHRvIGNyZWF0ZSBh IG5ldyBDR1BhdGguCisKKyAgICAgICAgMi4gIFdoZW4gcGFpbnRpbmcgdGhlIFN0cm9rZVBhdGgg ZGlzcGxheSBsaXN0IGl0ZW0sIGp1c3QgZGlzY2FyZCBgbV9wYXRoYCBhZnRlciB3ZSdyZSBkb25l IHBhaW50aW5nIHdpdGggaXQuCisgICAgICAgICAgICBUaGlzLCBpbiBjb25qdW5jdGlvbiB3aXRo ICgxKSwgbWVhbnMgdGhhdCB0aGUgQ0dQYXRoIGJhY2tpbmcgdGhlIFdlYkNvcmU6OlBhdGggaW4g dGhlIEdQVSBwcm9jZXNzIGlzIG9ubHkKKyAgICAgICAgICAgIGNyZWF0ZWQgd2hlbiB3ZSdyZSBq dXN0IGFib3V0IHRvIHBhaW50IChpLmUuIHdoZW4gY2FsbGluZyBpbnRvIHN0cm9rZVBhdGgoKSks IGFuZCBkZXN0cm95ZWQgcmlnaHQgYWZ0ZXIKKyAgICAgICAgICAgIHdlJ3JlIGRvbmUgcGFpbnRp bmcgd2l0aCBpdC4KKworICAgICAgICBTZWUgYmVsb3cgZm9yIGRldGFpbHMuIFRoZXJlIHNob3Vs ZCBiZSBubyBjaGFuZ2UgaW4gYmVoYXZpb3IuCisKKyAgICAgICAgKiBIZWFkZXJzLmNtYWtlOgor ICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9JbmxpbmVQYXRoRGF0YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmU6Ok1vdmVEYXRhOjplbmNvZGUgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6TW92ZURhdGE6 OmRlY29kZSk6CisgICAgICAgIChXZWJDb3JlOjpMaW5lRGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAg ICAgICAgKFdlYkNvcmU6OkxpbmVEYXRhOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXJj RGF0YTo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkFyY0RhdGE6OmRlY29kZSk6 CisKKyAgICAgICAgSW50cm9kdWNlIElubGluZVBhdGhEYXRhLCBhIFZhcmlhbnQgb2Ygc2V2ZXJh bCBkaWZmZXJlbnQgaW5saW5lIGRhdGEgdHlwZXMsIGVhY2ggb2Ygd2hpY2ggcmVwcmVzZW50cyBv bmUgc2ltcGxlCisgICAgICAgIHBhdGggdHlwZSB0aGF0IGlzIHN0b3JlZCB1c2luZyBvbmx5IGlu bGluZSBkYXRhLiBUaGlzIGluY2x1ZGVzIGxpbmUgc2VnbWVudHMgKGEgc3RhcnQgcG9pbnQgYW5k IGFuIGVuZCBwb2ludCksCisgICAgICAgIGFzIHdlbGwgYXMgYXJjcyAod2hpY2gsIGluIGFkZGl0 aW9uIHRvIGEgY2VudGVyIGFuZCBzdGFydCBhbmQgZW5kIGFuZ2xlcykgYWxzbyBpbmNsdWRlcyBh biBvcHRpb25hbCBvZmZzZXQsCisgICAgICAgIHdoaWNoIHJlcHJlc2VudHMgdGhlIGN1cnJlbnQg cG9zaXRpb24gb2YgdGhlIHBhdGggYXQgdGhlIHRpbWUgImFkZEFyYyIgd2FzIGNhbGxlZC4KKwor ICAgICAgICBGb3IgaW5zdGFuY2UsIGluIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW8sIHRoZSBwYXRo IHdvdWxkIGhhdmUgYW4gYXJjIHRoYXQgaXMgb2Zmc2V0IGJ5ICgxMDAsIDApOyBpZiBmaWxsZWQs IGl0CisgICAgICAgIHdvdWxkIHJlc3VsdCBpbiBhIGNvbXBvc2l0ZSBzaGFwZSByZXNlbWJsaW5n IGEgc2VtaWNpcmNsZSBvbiB0b3Agb2YgYSB0cmlhbmdsZToKKworICAgICAgICBwYXRoLm1vdmVU bygxMDAsIDApOworICAgICAgICBwYXRoLmFkZEFyYygxMDAsIDEwMCwgNTAsIDAsIFBJLCBmYWxz ZSk7CisgICAgICAgIGNvbnRleHQuZmlsbChwYXRoKTsKKworICAgICAgICBXaGVuIGEgUGF0aCBp cyBpbml0aWFsaXplZCAob3IgYWZ0ZXIgaXQgaXMgY2xlYXJlZCksIGl0IHN0YXJ0cyBvZmYgd2l0 aCBuZWl0aGVyIGEgQ0dQYXRoIG5vciBpbmxpbmUgZGF0YS4gTW92aW5nCisgICAgICAgIHRoZSBw YXRoIGNhdXNlcyBpdCB0byBzdG9yZSBpbmxpbmUgTW92ZURhdGE7IGNhbGxpbmcgY2FsbGluZyBg YWRkTGluZVRvYCBvciBgYWRkQXJjYCB0aGVuIHJlcGxhY2VzIHRoZSBpbmxpbmUKKyAgICAgICAg ZGF0YSB3aXRoIGVpdGhlciBMaW5lRGF0YSBvciBBcmNEYXRhLgorCisgICAgICAgIElmLCBhdCBh bnkgcG9pbnQsIHRoZSBwYXRoIGNoYW5nZXMgaW4gYSBkaWZmZXJlbnQgd2F5IChpLmUuIG5laXRo ZXIgbGluZSwgYXJjLCBub3IgbW92ZSksIHdlIGNsZWFyIG91dCB0aGUKKyAgICAgICAgaW5saW5l IGRhdGEgYW5kIGZhbGwgYmFjayB0byBqdXN0IHJlcHJlc2VudGluZyB0aGUgcGF0aCBkYXRhIHVz aW5nIHRoZSBDR1BhdGggKG1fcGF0aCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9Q YXRoLmNwcDoKKworICAgICAgICBSZWZhY3RvciB0aGUgZm9sbG93aW5nIDEwIG1ldGhvZHM6IG1v dmVUbywgYWRkTGluZVRvLCBhZGRBcmMsIGlzRW1wdHksIGN1cnJlbnRQb2ludCwgYXBwbHksIGVs ZW1lbnRDb3VudCwKKyAgICAgICAgaGFzQ3VycmVudFBvaW50LCBmYXN0Qm91bmRpbmdSZWN0LCBh bmQgYm91bmRpbmdSZWN0IHN1Y2ggdGhhdCB0aGVpciBpbXBsZW1lbnRhdGlvbnMgYXJlIG5vdyBp biBwbGF0Zm9ybS1hZ25vc3RpYworICAgICAgICBjb2RlIGluIFBhdGguY3BwLiBMb2dpYyBpbiB0 aGlzIHBsYXRmb3JtLWFnbm9zdGljIGNvZGUgd2lsbCBnZW5lcmFsbHkgYXR0ZW1wdCB0byB1c2Ug aW5saW5lIHBhdGggZGF0YSB0byBjb21wdXRlCisgICAgICAgIGFuIGFuc3dlciAob3IgYXBwbHkg dGhlIHJlcXVlc3RlZCBtdXRhdGlvbnMpIHdpdGhvdXQgaGF2aW5nIHRvIGluaXRpYWxpemUgdGhl IHBsYXRmb3JtIHBhdGggcmVwcmVzZW50YXRpb24uCisgICAgICAgIEZhaWxpbmcgdGhpcywgd2Ug ZmFsbCBiYWNrIHRvIGNhbGxpbmcgLVNsb3dDYXNlIHZlcnNpb25zIG9mIHRoZXNlIG1ldGhvZHMs IHdoaWNoIHdpbGwgZXhlcmNpc2UgdGhlIGFwcHJvcHJpYXRlCisgICAgICAgIEFQSXMgb24gZWFj aCBwbGF0Zm9ybS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZWxlbWVudENvdW50U2xvd0Nh c2UgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHkgY29uc3QpOgorICAgICAg ICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRo OjpoYXNDdXJyZW50UG9pbnQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVu dFBvaW50IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVsZW1lbnRDb3VudCBjb25z dCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmMpOgorICAgICAgICAoV2ViQ29yZTo6 UGF0aDo6YWRkTGluZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUbyk6CisKKyAg ICAgICAgSW4gdGhlIGNhc2Ugb2YgdGhlc2UgdGhyZWUgbWV0aG9kcyBmb3IgbXV0YXRpbmcgYSBw YXRoLCBpZiB3ZSd2ZSBlaXRoZXIgb25seSBtb3ZlZCB0aGUgcGF0aCBvciBoYXZlbid0IHRvdWNo ZWQKKyAgICAgICAgaXQgYXQgYWxsLCB3ZSBjYW4gZ2V0IGF3YXkgd2l0aCBvbmx5IHVwZGF0aW5n IG91ciBpbmxpbmUgcGF0aCBkYXRhLCBhbmQgYXZvaWQgY3JlYXRpbmcgYSBDR1BhdGguCisKKyAg ICAgICAgKFdlYkNvcmU6OlBhdGg6OmJvdW5kaW5nUmVjdCBjb25zdCk6CisgICAgICAgIChXZWJD b3JlOjpQYXRoOjpmYXN0Qm91bmRpbmdSZWN0IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBh dGg6OmJvdW5kaW5nUmVjdEZyb21JbmxpbmVEYXRhIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6 OlBhdGg6OnBvbHlnb25QYXRoRnJvbVBvaW50cyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvUGF0aC5oOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZW5jb2RlIGNvbnN0KToKKyAgICAg ICAgKFdlYkNvcmU6OlBhdGg6OmRlY29kZSk6CisKKyAgICAgICAgVGVhY2ggUGF0aDo6ZW5jb2Rl IGFuZCBQYXRoOjpkZWNvZGUgdG8gcmVzcGVjdGl2ZWx5IHNlcmlhbGl6ZSBhbmQgZGVzZXJpYWxp emUgV2ViQ29yZTo6UGF0aCBieSBjb25zdWx0aW5nIG9ubHkKKyAgICAgICAgdGhlIGlubGluZSBk YXRhLCBpZiBpdCBpcyBwcmVzZW50LiBGb3Igc2ltcGxlIHR5cGVzIG9mIHBhdGhzLCB0aGlzIGRl Y3JlYXNlcyB0aGUgY29zdCBvZiBib3RoIElQQyBlbmNvZGluZyBhbmQKKyAgICAgICAgZGVjb2Rp bmcsIGJ1dCBhZGRzIGEgbmVnbGlnaWJsZSBhbW91bnQgb2Ygb3ZlcmhlYWQgaW4gdGhlIGNhc2Ug d2hlcmUgdGhlIHBhdGggaXMgbm9uLWlubGluZS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6 aGFzSW5saW5lRGF0YSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNBbnlJbmxp bmVEYXRhIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6IERl bGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzRW1wdHlTbG93Q2FzZSBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnRTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjptb3ZlVG9TbG93Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjph ZGRMaW5lVG9TbG93Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRBcmNTbG93Q2Fz ZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpib3VuZGluZ1JlY3RTbG93Q2FzZSBjb25zdCk6 CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseVNsb3dDYXNlIGNvbnN0KToKKyAgICAgICAg KFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3RTbG93Q2FzZSBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjppc051bGwgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6 aXNFbXB0eSBjb25zdCk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNDdXJy ZW50UG9pbnQgY29uc3QpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVu dFBvaW50IGNvbnN0KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUbyk6 IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphZGRMaW5lVG8pOiBEZWxldGVkLgor ICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YWRkQXJjKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNv cmU6OlBhdGg6OmJvdW5kaW5nUmVjdCBjb25zdCk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3Jl OjpQYXRoOjphcHBseSBjb25zdCk6IERlbGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvY2cvUGF0aENHLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmNyZWF0ZUNHUGF0aCBj b25zdCk6CisKKyAgICAgICAgQWRkIGEgaGVscGVyIG1ldGhvZCB0aGF0IGlzIGludm9rZWQgd2hl biB0aGUgUGF0aCBpcyBhc2tlZCBmb3IgYSBDR1BhdGguIEluIHRoaXMgY2FzZSwgaWYgdGhlcmUg aXMgaW5saW5lIGRhdGEsCisgICAgICAgIHdlIG5lZWQgdG8gbGF6aWx5IGNyZWF0ZSB0aGUgcGF0 aCBhbmQgYXBwbHkgYW55IGlubGluZSBwYXRoIGRhdGEgd2UndmUgYWNjdW11bGF0ZWQuIE9uY2Ug d2UncmUgZG9uZSBhcHBseWluZyB0aGUKKyAgICAgICAgaW5saW5lIGRhdGEsIHNldCBhIGZsYWcg KG1fbmVlZHNUb0FwcGx5SW5saW5lRGF0YSkgdG8gZmFsc2UgdG8gYXZvaWQgcmUtYXBwbHlpbmcg aW5saW5lIGRhdGEgdG8gdGhlIHBhdGguCisKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OnBsYXRm b3JtUGF0aCBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjplbnN1cmVQbGF0Zm9ybVBh dGgpOgorCisgICAgICAgIFdoZW4gZW5zdXJlUGxhdGZvcm1QYXRoIGlzIGludm9rZWQsIHdlIGFy ZSBhYm91dCB0byBtdXRhdGUgb3VyIENHUGF0aCBpbiBzdWNoIGEgd2F5IHRoYXQgaXQgY2FuJ3Qg YmUgZXhwcmVzc2VkCisgICAgICAgIGluIHRlcm1zIG9mIGlubGluZSBkYXRhIChhdCBsZWFzdCwg bm90IHdpdGggdGhlIGNoYW5nZXMgaW4gdGhpcyBwYXRjaCkuIENsZWFyIG91dCB0aGUgaW5saW5l IHBhdGggZGF0YSBpbiB0aGlzCisgICAgICAgIGNhc2UsIGFuZCBhcHBseSB0aGUgQ0dQYXRoIG11 dGF0aW9ucyB0aGF0IHdlcmUgcHJldmlvdXNseSBzdGFzaGVkIGF3YXkgaW4gaW5saW5lIHBhdGgg ZGF0YS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNOdWxsIGNvbnN0KToKKworICAgICAg ICBBIHBhdGggaXMgbm93IGNvbnNpZGVyZWQgbnVsbCBpZiBpdCBpcyBub3Qgb25seSBtaXNzaW5n IGEgQ0dQYXRoLCBidXQgYWxzbyBkb2VzIG5vdCBoYXZlIGFueSBpbmxpbmUgcGF0aCBkYXRhLgor ICAgICAgICBUaGlzIG1haW50YWlucyB0aGUgaW52YXJpYW50IHRoYXQgYGlzTnVsbCgpYCBpcyB0 cnVlIGlmZiB0aGUgYHBsYXRmb3JtUGF0aCgpYCByZXR1cm5zIDB4MC4KKworICAgICAgICAoV2Vi Q29yZTo6UGF0aDo6UGF0aCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpzd2FwKToKKworICAg ICAgICBVcGRhdGUgdGhlIGNvbnN0cnVjdG9ycyBhbmQgYHN3YXBgIGhlbHBlciBtZXRob2QgKHVz ZWQgYnkgYXNzaWdubWVudCBvcGVyYXRvcnMpIHRvIGFjY291bnQgZm9yIHRoZSBuZXcgbWVtYmVy cy4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y29udGFpbnMgY29uc3QpOgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6dHJhbnNmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6Onplcm9SZWN0SWZO dWxsKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmJvdW5kaW5nUmVjdFNsb3dDYXNlIGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3RTbG93Q2FzZSBjb25z dCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjptb3ZlVG9TbG93Q2FzZSk6CisgICAgICAgIChX ZWJDb3JlOjpQYXRoOjphZGRMaW5lVG9TbG93Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRo OjphZGRBcmNTbG93Q2FzZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjbGVhcik6CisKKyAg ICAgICAgV2hlbiBjbGVhcmluZyBQYXRoLCBpbnN0ZWFkIG9mIHNldHRpbmcgYG1fcGF0aGAgdG8g YSBuZXdseSBhbGxvY2F0ZWQgQ0dQYXRoLCBzaW1wbHkgcmVzZXQgaXQgdG8gbnVsbC4gVGhpcwor ICAgICAgICBlbnN1cmVzIHRoYXQgaWYgd2UgdGhlbiBhcHBseSBzb21lIGNoYW5nZXMgdGhhdCBj YW4gYmUgZXhwcmVzc2VkIHVzaW5nIG9ubHkgaW5saW5lIHBhdGggZGF0YSwgd2UgYXZvaWQgaGF2 aW5nIHRvCisgICAgICAgIHVwZGF0ZSB0aGUgQ0dQYXRoLCBhbmQgaW5zdGVhZCBqdXN0IHVwZGF0 ZSB0aGUgaW5saW5lIHBhdGggZGF0YS4KKworICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0 eVNsb3dDYXNlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmN1cnJlbnRQb2ludFNs b3dDYXNlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5U2xvd0Nhc2UgY29u c3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZWxlbWVudENvdW50U2xvd0Nhc2UgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0IGNvbnN0KTogRGVsZXRlZC4K KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmZhc3RCb3VuZGluZ1JlY3QgY29uc3QpOiBEZWxldGVk LgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6bW92ZVRvKTogRGVsZXRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFkZExpbmVUbyk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRo OjphZGRBcmMpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6aXNFbXB0eSBjb25z dCk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpoYXNDdXJyZW50UG9pbnQgY29u c3QpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Y3VycmVudFBvaW50IGNvbnN0 KTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFwcGx5IGNvbnN0KTogRGVsZXRl ZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmVsZW1lbnRDb3VudCBjb25zdCk6IERlbGV0ZWQu CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRl bXMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGlzcGxheUxpc3Q6OlN0cm9rZVBhdGg6OmFwcGx5 IGNvbnN0KToKKworICAgICAgICBUaHJvdyBvdXQgdGhlIGN1cnJlbnQgV2ViQ29yZTo6UGF0aCBh ZnRlciB3ZSdyZSBkb25lIHBhaW50aW5nIHdpdGggaXQgKHNlZSAoMikgaW4gdGhlIGFib3ZlIENo YW5nZUxvZyBlbnRyeSkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlz dHMvRGlzcGxheUxpc3RJdGVtcy5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3dpbi9Q YXRoRGlyZWN0MkQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6Ym91bmRpbmdSZWN0U2xv d0Nhc2UgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6ZmFzdEJvdW5kaW5nUmVjdFNs b3dDYXNlIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Om1vdmVUb1Nsb3dDYXNlKToK KyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZExpbmVUb1Nsb3dDYXNlKToKKyAgICAgICAgKFdl YkNvcmU6OlBhdGg6OmFkZEFyY1Nsb3dDYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omlz RW1wdHlTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9p bnRTbG93Q2FzZSBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpQYXRoOjphcHBseVNsb3dDYXNl IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmlzTnVsbCBjb25zdCk6CisgICAgICAg IChXZWJDb3JlOjpQYXRoOjpib3VuZGluZ1JlY3QgY29uc3QpOiBEZWxldGVkLgorICAgICAgICAo V2ViQ29yZTo6UGF0aDo6ZmFzdEJvdW5kaW5nUmVjdCBjb25zdCk6IERlbGV0ZWQuCisgICAgICAg IChXZWJDb3JlOjpQYXRoOjptb3ZlVG8pOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UGF0 aDo6YWRkTGluZVRvKTogRGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6OmFkZEFyYyk6 IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjppc0VtcHR5IGNvbnN0KTogRGVsZXRl ZC4KKyAgICAgICAgKFdlYkNvcmU6OlBhdGg6Omhhc0N1cnJlbnRQb2ludCBjb25zdCk6IERlbGV0 ZWQuCisgICAgICAgIChXZWJDb3JlOjpQYXRoOjpjdXJyZW50UG9pbnQgY29uc3QpOiBEZWxldGVk LgorICAgICAgICAoV2ViQ29yZTo6UGF0aDo6YXBwbHkgY29uc3QpOiBEZWxldGVkLgorCiAyMDIw LTAzLTA3ICBEYW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbaU9T XSBJbXBsZW1lbnQgc3VwcG9ydCBmb3IgZGljdGF0aW9uIGFsdGVybmF0aXZlcwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRl eCA0MzcyYmU2NDk4YmM3M2YzZDBiODNkYTM1ZjdkMDNiZjZkMTU1Nzk3Li44NDg2MjU4M2IwNzRm ZDNjZmRkY2IxZDc1YzYyMWU4MTg2YTYwY2QzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisy MDIwLTAzLTA4ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAg ICAgIExhemlseSBnZW5lcmF0ZSBDR1BhdGhzIGZvciBzb21lIHNpbXBsZSB0eXBlcyBvZiBwYXRo cywgc3VjaCBhcyBhcmNzIGFuZCBsaW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjA4NDY0CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTk2MzIy Nj4KKworICAgICAgICBSZXZpZXdlZCBieSBEYW5pZWwgQmF0ZXMsIERhcmluIEFkbGVyIGFuZCBU aW0gSG9ydG9uLgorCisgICAgICAgIEFkZCBhcmd1bWVudCBjb2RlcnMgZm9yIGBXVEY6Ok1vbm9z dGF0ZWAsIHNvIHRoYXQgVmFyaWFudHMgb2YgdGhlIGZvcm06IGBWYXJpYW50PE1vbm9zdGF0ZSwg Rm9vLCBCYXI+YCBjYW4gYmUKKyAgICAgICAgZW5jb2RlZCBhbmQgZGVjb2RlZCBvdmVyIElQQy4K KworICAgICAgICAqIFBsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5jcHA6CisgICAgICAgIChJ UEM6OkFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJn dW1lbnRDb2RlcjxNb25vc3RhdGU+OjpkZWNvZGUpOgorICAgICAgICAqIFBsYXRmb3JtL0lQQy9B cmd1bWVudENvZGVycy5oOgorCiAyMDIwLTAzLTA3ICBQZW5nIExpdSAgPHBlbmcubGl1NkBhcHBs ZS5jb20+CiAKICAgICAgICAgVXNlIHRoZSBmZWF0dXJlIGZsYWdzIG1lY2hhbmlzbSB0byBnaXZl IGRlZmF1bHQgZmVhdHVyZSBwcmVmZXJlbmNlIHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dU Ri93dGYvUGxhdGZvcm1FbmFibGUuaCBiL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtRW5hYmxlLmgK aW5kZXggMzg1MWVkYmJkOTQ3NjYxYjI2YmM5MjZkMzhkM2I3YWRjZmJkZDBjNi4uZDAzMDE5MWE4 ZjkwZWMyNGU5MjNiNzdhN2IxNzE0OTBlYmU4MWZjZSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93 dGYvUGxhdGZvcm1FbmFibGUuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUVuYWJsZS5o CkBAIC04MTcsNiArODE3LDkgQEAKICNkZWZpbmUgRU5BQkxFX09QRU5UWVBFX01BVEggMQogI2Vu ZGlmCiAKKyNpZiAhZGVmaW5lZChFTkFCTEVfSU5MSU5FX1BBVEhfREFUQSkgJiYgVVNFKENHKQor I2RlZmluZSBFTkFCTEVfSU5MSU5FX1BBVEhfREFUQSAxCisjZW5kaWYKIAogLyogRGlzYWJsZSBT aGFyZWRBcnJheUJ1ZmZlcnMgdW50aWwgU3BlY3RyZSBzZWN1cml0eSBjb25jZXJucyBhcmUgbWl0 aWdhdGVkLiAqLwogI2RlZmluZSBFTkFCTEVfU0hBUkVEX0FSUkFZX0JVRkZFUiAwCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvSGVhZGVy cy5jbWFrZQppbmRleCA0OTZiYjY0MDc3NjdlNWNhNDk0MzcwYzJlYTNjYjg5Y2M5YzkwYjUxLi5h ZTQ2NWVmZGIzMGVmNjg1YWE2NDYzMzA5MjFjZjY1ZTk1ZWIzZThjIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21h a2UKQEAgLTExMjcsNiArMTEyNyw3IEBAIHNldChXZWJDb3JlX1BSSVZBVEVfRlJBTUVXT1JLX0hF QURFUlMKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9JbmJhbmRHZW5lcmljQ3VlLmgKICAgICBwbGF0 Zm9ybS9ncmFwaGljcy9JbmJhbmRUZXh0VHJhY2tQcml2YXRlLmgKICAgICBwbGF0Zm9ybS9ncmFw aGljcy9JbmJhbmRUZXh0VHJhY2tQcml2YXRlQ2xpZW50LmgKKyAgICBwbGF0Zm9ybS9ncmFwaGlj cy9JbmxpbmVQYXRoRGF0YS5oCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvSW50UG9pbnQuaAogICAg IHBsYXRmb3JtL2dyYXBoaWNzL0ludFBvaW50SGFzaC5oCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3Mv SW50UmVjdC5oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKaW5kZXggZDFiMGFmOGU2YzAxZmU4MWNlY2FmYzYyMTQzMGU5Mjk3ZjlkMjAyYy4u MjViODg3M2EzYzlkNTYzYjE5MTA5NTIzZjEzZjRmMDI1MWNiMjQzYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNDk3Nyw2ICs0 OTc3LDcgQEAKIAkJRjQ0MkMzNTkyM0UzQUREMjAwNDk5NTgyIC8qIENvbXBvc2l0aW9uSGlnaGxp Z2h0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDQy QzM1NzIzRTNBQzUxMDA0OTk1ODIgLyogQ29tcG9zaXRpb25IaWdobGlnaHQuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDRBNUY1OTFGRUQzOEYy MDA3RjU5NDQgLyogTGVnYWN5TlNQYXN0ZWJvYXJkVHlwZXMuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0NEE1RjU3MUZFRDM4MzAwMDdGNTk0NCAvKiBM ZWdhY3lOU1Bhc3RlYm9hcmRUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CiAJCUY0NEVCQkQ5MURCNUQyMTQwMDI3NzMzNCAvKiBTdGF0aWNSYW5n ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQ0RUJC RDgxREI1RDIxNDAwMjc3MzM0IC8qIFN0YXRpY1JhbmdlLmggKi87IHNldHRpbmdzID0ge0FUVFJJ QlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJRjQ1Nzc1Q0UyNDE0MzdENTAwMkRGMUEwIC8q IElubGluZVBhdGhEYXRhLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGNDU3NzVDRDI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDVDMjMxRTE5 OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDVDMjMxQzE5OTVCNzNCMDBBNkUyRTMg LyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAo UHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQ2NzI5MjgxRTBERTY4NTAwQUNDM0Q4IC8qIFNjcm9sbFNu YXBPZmZzZXRzSW5mby5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRjQ2NzI5MjUxRTBERTVBQjAwQUNDM0Q4IC8qIFNjcm9sbFNuYXBPZmZzZXRzSW5mby5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0NkM0 NDdFMjM0NjU0NTQwMDM5QTc5RCAvKiBDbGlwYm9hcmRJdGVtQmluZGluZ3NEYXRhU291cmNlLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDZDNDQ3QzIz NDY1NDU0MDAzOUE3OUQgLyogQ2xpcGJvYXJkSXRlbUJpbmRpbmdzRGF0YVNvdXJjZS5oICovOyB9 OwpAQCAtMTU0NjUsNiArMTU0NjYsNyBAQAogCQlGNDRFQkJENjFEQjVEMUI2MDAyNzczMzQgLyog U3RhdGljUmFuZ2UuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IFN0YXRpY1JhbmdlLmlkbDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQ0RUJCRDgxREI1RDIxNDAwMjc3MzM0IC8q IFN0YXRpY1JhbmdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFN0YXRpY1Jh bmdlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NEVCQkRBMURCNUREOUQwMDI3 NzMzNCAvKiBTdGF0aWNSYW5nZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBTdGF0aWNSYW5nZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUY0NTc3 NUNEMjQxNDM3RDUwMDJERjFBMCAvKiBJbmxpbmVQYXRoRGF0YS5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJ bmxpbmVQYXRoRGF0YS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDVDMjMxQjE5 OTVCNzNCMDBBNkUyRTMgLyogQXhpc1Njcm9sbFNuYXBPZmZzZXRzLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEF4aXNTY3JvbGxTbmFwT2Zmc2V0cy5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NUMyMzFDMTk5NUI3M0IwMEE2RTJFMyAvKiBBeGlz U2Nyb2xsU25hcE9mZnNldHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXhp c1Njcm9sbFNuYXBPZmZzZXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0NjI4 QTlFMjM0RDNCQkYwMEJDODg0QyAvKiBQbGF0Zm9ybVBhc3RlYm9hcmRDb2NvYS5tbSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFBsYXRmb3JtUGFzdGVib2FyZENvY29h Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjUxMjcsNiArMjUxMjksNyBAQAog CQkJCTA3MDZBMEQ3MjQwODMwQTYwMEU5MzgxOCAvKiBJbmJhbmRHZW5lcmljQ3VlSWRlbnRpZmll ci5oICovLAogCQkJCTA3OTQxNzkzMTY2RUEwNEUwMDk0MTZDMiAvKiBJbmJhbmRUZXh0VHJhY2tQ cml2YXRlLmggKi8sCiAJCQkJMDdDRTc3RDQxNjcxMkE2QTAwQzU1QTQ3IC8qIEluYmFuZFRleHRU cmFja1ByaXZhdGVDbGllbnQuaCAqLywKKwkJCQlGNDU3NzVDRDI0MTQzN0Q1MDAyREYxQTAgLyog SW5saW5lUGF0aERhdGEuaCAqLywKIAkJCQkyRDQ2RjA0RDE3Qjk2RkJEMDA1NjQ3RjAgLyogSW50 UG9pbnQuY3BwICovLAogCQkJCUIyNzUzNTQ0MEIwNTM4MTQwMDJDRTY0RiAvKiBJbnRQb2ludC5o ICovLAogCQkJCUU0NjJBNEEwMTEzRTcxQkUwMDRBNDIyMCAvKiBJbnRQb2ludEhhc2guaCAqLywK QEAgLTMwNDE2LDYgKzMwNDE5LDcgQEAKIAkJCQk2RkIyNDAwNTIzREZGMTI4MDA3OTY0NTggLyog SW5saW5lTGluZUJveEJ1aWxkZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTZGRTE5ODE3MjE3ODM5 N0MwMDQ0NkYwOCAvKiBJbmxpbmVMaW5lQnJlYWtlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNkYw Q0Q2OTUyMjlFRDMyNzAwQzU5OTRFIC8qIElubGluZUxpbmVCdWlsZGVyLmggaW4gSGVhZGVycyAq LywKKwkJCQlGNDU3NzVDRTI0MTQzN0Q1MDAyREYxQTAgLyogSW5saW5lUGF0aERhdGEuaCBpbiBI ZWFkZXJzICovLAogCQkJCTZGMzYwRTUwMjM5OTk0MjEwMDE1MTJBNyAvKiBJbmxpbmVTb2Z0TGlu ZUJyZWFrSXRlbS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQUE0QzNBNzcwQjJCMTY3OTAwMjMzNEEy IC8qIElubGluZVN0eWxlU2hlZXRPd25lci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQkNFQTQ4NUEw OTdEOTMwMjAwOTRDOUU0IC8qIElubGluZVRleHRCb3guaCBpbiBIZWFkZXJzICovLApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvSW5saW5lUGF0aERhdGEuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhEYXRhLmgKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uNjY0MWU3MWEyZGY5MWVhNDE3MjQ3NThhY2Q5MjdhOGU5NDg4NGFiNwotLS0gL2Rldi9u dWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lubGluZVBhdGhEYXRh LmgKQEAgLTAsMCArMSwxMzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIEVO QUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCisjaW5jbHVkZSAiRmxvYXRQb2ludC5oIgorI2luY2x1 ZGUgPHd0Zi9PcHRpb25hbC5oPgorI2luY2x1ZGUgPHd0Zi9WYXJpYW50Lmg+CisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworc3RydWN0IExpbmVEYXRhIHsKKyAgICBGbG9hdFBvaW50IHN0YXJ0Owor ICAgIEZsb2F0UG9pbnQgZW5kOworCisgICAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBl bmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+IHN0YXRp YyBPcHRpb25hbDxMaW5lRGF0YT4gZGVjb2RlKERlY29kZXImKTsKK307CisKK3N0cnVjdCBBcmNE YXRhIHsKKyAgICBGbG9hdFBvaW50IG9mZnNldDsKKyAgICBGbG9hdFBvaW50IGNlbnRlcjsKKyAg ICBmbG9hdCByYWRpdXMgeyAwIH07CisgICAgZmxvYXQgc3RhcnRBbmdsZSB7IDAgfTsKKyAgICBm bG9hdCBlbmRBbmdsZSB7IDAgfTsKKyAgICBib29sIGNsb2Nrd2lzZSB7IGZhbHNlIH07CisgICAg Ym9vbCBoYXNPZmZzZXQgeyBmYWxzZSB9OworCisgICAgdGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4g dm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNsYXNzIERlY29kZXI+ IHN0YXRpYyBPcHRpb25hbDxBcmNEYXRhPiBkZWNvZGUoRGVjb2RlciYpOworfTsKKworc3RydWN0 IE1vdmVEYXRhIHsKKyAgICBGbG9hdFBvaW50IGxvY2F0aW9uOworCisgICAgdGVtcGxhdGU8Y2xh c3MgRW5jb2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OworICAgIHRlbXBsYXRlPGNs YXNzIERlY29kZXI+IHN0YXRpYyBPcHRpb25hbDxNb3ZlRGF0YT4gZGVjb2RlKERlY29kZXImKTsK K307CisKK3RlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgTW92ZURhdGE6OmVuY29kZShFbmNv ZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIgPDwgbG9jYXRpb247Cit9CisKK3Rl bXBsYXRlPGNsYXNzIERlY29kZXI+IE9wdGlvbmFsPE1vdmVEYXRhPiBNb3ZlRGF0YTo6ZGVjb2Rl KERlY29kZXImIGRlY29kZXIpCit7CisgICAgTW92ZURhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29k ZXIuZGVjb2RlKGRhdGEubG9jYXRpb24pKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0Owor ICAgIHJldHVybiBkYXRhOworfQorCit0ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIExpbmVE YXRhOjplbmNvZGUoRW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBlbmNvZGVyIDw8IHN0 YXJ0OworICAgIGVuY29kZXIgPDwgZW5kOworfQorCit0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBP cHRpb25hbDxMaW5lRGF0YT4gTGluZURhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyKQorewor ICAgIExpbmVEYXRhIGRhdGE7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnN0YXJ0KSkK KyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUo ZGF0YS5lbmQpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgcmV0dXJuIGRh dGE7Cit9CisKK3RlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQgQXJjRGF0YTo6ZW5jb2RlKEVu Y29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCBvZmZzZXQ7CisgICAgZW5j b2RlciA8PCBjZW50ZXI7CisgICAgZW5jb2RlciA8PCByYWRpdXM7CisgICAgZW5jb2RlciA8PCBz dGFydEFuZ2xlOworICAgIGVuY29kZXIgPDwgZW5kQW5nbGU7CisgICAgZW5jb2RlciA8PCBjbG9j a3dpc2U7CisgICAgZW5jb2RlciA8PCBoYXNPZmZzZXQ7Cit9CisKK3RlbXBsYXRlPGNsYXNzIERl Y29kZXI+IE9wdGlvbmFsPEFyY0RhdGE+IEFyY0RhdGE6OmRlY29kZShEZWNvZGVyJiBkZWNvZGVy KQoreworICAgIEFyY0RhdGEgZGF0YTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEub2Zm c2V0KSkKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKworICAgIGlmICghZGVjb2Rlci5k ZWNvZGUoZGF0YS5jZW50ZXIpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAg aWYgKCFkZWNvZGVyLmRlY29kZShkYXRhLnJhZGl1cykpCisgICAgICAgIHJldHVybiBXVEY6Om51 bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuc3RhcnRBbmdsZSkpCisgICAg ICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEu ZW5kQW5nbGUpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgaWYgKCFkZWNv ZGVyLmRlY29kZShkYXRhLmNsb2Nrd2lzZSkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7 CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGRhdGEuaGFzT2Zmc2V0KSkKKyAgICAgICAgcmV0 dXJuIFdURjo6bnVsbG9wdDsKKworICAgIHJldHVybiBkYXRhOworfQorCit1c2luZyBJbmxpbmVQ YXRoRGF0YSA9IFZhcmlhbnQ8TW9ub3N0YXRlLCBNb3ZlRGF0YSwgTGluZURhdGEsIEFyY0RhdGE+ OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoSU5MSU5FX1BB VEhfREFUQSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Bh dGguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKaW5kZXgg YTYyOGQzNzQyMjQyM2MxMjAzNTRmZmZmMjE5MDYxN2Y3MmI0Mzg1Mi4uYzZiMmJkZjM0ZjM0YjQ2 Njg1OTA0OWY3NjVmMGY2MmMzNjc1MTA5NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvUGF0aC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvUGF0aC5jcHAKQEAgLTU1LDcgKzU1LDcgQEAgZmxvYXQgUGF0aDo6bGVuZ3RoKCkgY29u c3QKIAogI2lmICFIQVZFKENHUEFUSF9HRVRfTlVNQkVSX09GX0VMRU1FTlRTKQogCi1zaXplX3Qg UGF0aDo6ZWxlbWVudENvdW50KCkgY29uc3QKK3NpemVfdCBQYXRoOjplbGVtZW50Q291bnRTbG93 Q2FzZSgpIGNvbnN0CiB7CiAgICAgc2l6ZV90IG51bVBvaW50cyA9IDA7CiAgICAgYXBwbHkoWyZu dW1Qb2ludHNdKGF1dG8mKSB7CkBAIC0xNjcsNiArMTY3LDE4NSBAQCB2b2lkIFBhdGg6OmFkZEJl emllcnNGb3JSb3VuZGVkUmVjdChjb25zdCBGbG9hdFJlY3QmIHJlY3QsIGNvbnN0IEZsb2F0U2l6 ZSYgdG9wTAogICAgIGNsb3NlU3VicGF0aCgpOwogfQogCit2b2lkIFBhdGg6OmFwcGx5KGNvbnN0 IFBhdGhBcHBsaWVyRnVuY3Rpb24mIGZ1bmN0aW9uKSBjb25zdAoreworICAgIGlmIChpc051bGwo KSkKKyAgICAgICAgcmV0dXJuOworCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAg aWYgKGhhc0lubGluZURhdGE8TW92ZURhdGE+KCkpIHsKKyAgICAgICAgUGF0aEVsZW1lbnQgZWxl bWVudDsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0aEVsZW1lbnQ6OlR5cGU6Ok1vdmVUb1Bv aW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9IFdURjo6Z2V0PE1vdmVEYXRhPihtX2lu bGluZURhdGEpLmxvY2F0aW9uOworICAgICAgICBmdW5jdGlvbihlbGVtZW50KTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKSB7Cisg ICAgICAgIGF1dG8mIGxpbmUgPSBXVEY6OmdldDxMaW5lRGF0YT4obV9pbmxpbmVEYXRhKTsKKyAg ICAgICAgUGF0aEVsZW1lbnQgZWxlbWVudDsKKyAgICAgICAgZWxlbWVudC50eXBlID0gUGF0aEVs ZW1lbnQ6OlR5cGU6Ok1vdmVUb1BvaW50OworICAgICAgICBlbGVtZW50LnBvaW50c1swXSA9IGxp bmUuc3RhcnQ7CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAgICBlbGVtZW50LnR5 cGUgPSBQYXRoRWxlbWVudDo6VHlwZTo6QWRkTGluZVRvUG9pbnQ7CisgICAgICAgIGVsZW1lbnQu cG9pbnRzWzBdID0gbGluZS5lbmQ7CisgICAgICAgIGZ1bmN0aW9uKGVsZW1lbnQpOworICAgICAg ICByZXR1cm47CisgICAgfQorI2VuZGlmCisKKyAgICBhcHBseVNsb3dDYXNlKGZ1bmN0aW9uKTsK K30KKworYm9vbCBQYXRoOjppc0VtcHR5KCkgY29uc3QKK3sKKyAgICBpZiAoaXNOdWxsKCkpCisg ICAgICAgIHJldHVybiB0cnVlOworCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisgICAg aWYgKGhhc0FueUlubGluZURhdGEoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCisK KyAgICByZXR1cm4gaXNFbXB0eVNsb3dDYXNlKCk7Cit9CisKK2Jvb2wgUGF0aDo6aGFzQ3VycmVu dFBvaW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gIWlzRW1wdHkoKTsKK30KKworRmxvYXRQb2lu dCBQYXRoOjpjdXJyZW50UG9pbnQoKSBjb25zdAoreworICAgIGlmIChpc051bGwoKSkKKyAgICAg ICAgcmV0dXJuIHsgfTsKKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGlmICho YXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICByZXR1cm4gV1RGOjpnZXQ8TW92ZURh dGE+KG1faW5saW5lRGF0YSkubG9jYXRpb247CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5l RGF0YT4oKSkKKyAgICAgICAgcmV0dXJuIFdURjo6Z2V0PExpbmVEYXRhPihtX2lubGluZURhdGEp LmVuZDsKKyNlbmRpZgorCisgICAgcmV0dXJuIGN1cnJlbnRQb2ludFNsb3dDYXNlKCk7Cit9CisK K3NpemVfdCBQYXRoOjplbGVtZW50Q291bnQoKSBjb25zdAoreworI2lmIEVOQUJMRShJTkxJTkVf UEFUSF9EQVRBKQorICAgIGlmIChoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigpKQorICAgICAgICBy ZXR1cm4gMTsKKworICAgIGlmIChoYXNJbmxpbmVEYXRhPExpbmVEYXRhPigpKQorICAgICAgICBy ZXR1cm4gMjsKKyNlbmRpZgorCisgICAgcmV0dXJuIGVsZW1lbnRDb3VudFNsb3dDYXNlKCk7Cit9 CisKK3ZvaWQgUGF0aDo6YWRkQXJjKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50LCBmbG9hdCByYWRp dXMsIGZsb2F0IHN0YXJ0QW5nbGUsIGZsb2F0IGVuZEFuZ2xlLCBib29sIGFudGljbG9ja3dpc2Up Cit7CisgICAgLy8gV29ya2Fyb3VuZCBmb3IgPHJkYXI6Ly9wcm9ibGVtLzUxODkyMzM+IENHUGF0 aEFkZEFyYyBoYW5ncyBvciBjcmFzaGVzIHdoZW4gcGFzc2VkIGluZiBhcyBzdGFydCBvciBlbmQg YW5nbGUsCisgICAgLy8gYXMgd2VsbCBhcyBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNjQ0OSwgc2luY2UgY2Fpcm9fYXJjKCkgZnVuY3Rpb25zIGhhbmcgb3IgY3Jhc2gg d2hlbgorICAgIC8vIHBhc3NlZCBpbmYgYXMgcmFkaXVzIG9yIHN0YXJ0L2VuZCBhbmdsZS4KKyAg ICBpZiAoIXN0ZDo6aXNmaW5pdGUocmFkaXVzKSB8fCAhc3RkOjppc2Zpbml0ZShzdGFydEFuZ2xl KSB8fCAhc3RkOjppc2Zpbml0ZShlbmRBbmdsZSkpCisgICAgICAgIHJldHVybjsKKworI2lmIEVO QUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRh PE1vdmVEYXRhPigpKSB7CisgICAgICAgIEFyY0RhdGEgYXJjOworICAgICAgICBpZiAoaGFzQW55 SW5saW5lRGF0YSgpKSB7CisgICAgICAgICAgICBhcmMuaGFzT2Zmc2V0ID0gdHJ1ZTsKKyAgICAg ICAgICAgIGFyYy5vZmZzZXQgPSBXVEY6OmdldDxNb3ZlRGF0YT4obV9pbmxpbmVEYXRhKS5sb2Nh dGlvbjsKKyAgICAgICAgfQorICAgICAgICBhcmMuY2VudGVyID0gcG9pbnQ7CisgICAgICAgIGFy Yy5yYWRpdXMgPSByYWRpdXM7CisgICAgICAgIGFyYy5zdGFydEFuZ2xlID0gc3RhcnRBbmdsZTsK KyAgICAgICAgYXJjLmVuZEFuZ2xlID0gZW5kQW5nbGU7CisgICAgICAgIC8vIEZJWE1FOiBFaXRo ZXIgQXJjRGF0YTo6Y2xvY2t3aXNlIG5lZWRzIHRvIGJlIHJlbmFtZWQgdG8gYW50aWNsb2Nrd2lz ZSwgb3IgdGhlIGxhc3QgYXJndW1lbnQgdG8KKyAgICAgICAgLy8gUGF0aDo6YWRkQXJjIG5lZWRz IHRvIGJlIHJlbmFtZWQgdG8gY2xvY2t3aXNlLgorICAgICAgICBhcmMuY2xvY2t3aXNlID0gYW50 aWNsb2Nrd2lzZTsKKyAgICAgICAgbV9pbmxpbmVEYXRhID0geyBXVEZNb3ZlKGFyYykgfTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgorCisgICAgYWRkQXJjU2xvd0Nhc2UocG9pbnQs IHJhZGl1cywgc3RhcnRBbmdsZSwgZW5kQW5nbGUsIGFudGljbG9ja3dpc2UpOworfQorCit2b2lk IFBhdGg6OmFkZExpbmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3sKKyNpZiBFTkFCTEUo SU5MSU5FX1BBVEhfREFUQSkKKyAgICBpZiAoaXNOdWxsKCkgfHwgaGFzSW5saW5lRGF0YTxNb3Zl RGF0YT4oKSkgeworICAgICAgICBMaW5lRGF0YSBsaW5lOworICAgICAgICBsaW5lLnN0YXJ0ID0g aGFzQW55SW5saW5lRGF0YSgpID8gV1RGOjpnZXQ8TW92ZURhdGE+KG1faW5saW5lRGF0YSkubG9j YXRpb24gOiBGbG9hdFBvaW50KCk7CisgICAgICAgIGxpbmUuZW5kID0gcG9pbnQ7CisgICAgICAg IG1faW5saW5lRGF0YSA9IHsgV1RGTW92ZShsaW5lKSB9OworICAgICAgICByZXR1cm47CisgICAg fQorI2VuZGlmCisKKyAgICBhZGRMaW5lVG9TbG93Q2FzZShwb2ludCk7Cit9CisKK3ZvaWQgUGF0 aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQoreworI2lmIEVOQUJMRShJTkxJTkVf UEFUSF9EQVRBKQorICAgIGlmIChpc051bGwoKSB8fCBoYXNJbmxpbmVEYXRhPE1vdmVEYXRhPigp KSB7CisgICAgICAgIG1faW5saW5lRGF0YSA9IE1vdmVEYXRhIHsgcG9pbnQgfTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKyNlbmRpZgorCisgICAgbW92ZVRvU2xvd0Nhc2UocG9pbnQpOworfQor CitGbG9hdFJlY3QgUGF0aDo6Ym91bmRpbmdSZWN0KCkgY29uc3QKK3sKKyAgICBpZiAoaXNOdWxs KCkpCisgICAgICAgIHJldHVybiB7IH07CisKKyNpZiBFTkFCTEUoSU5MSU5FX1BBVEhfREFUQSkK KyAgICBpZiAoYXV0byByZWN0ID0gYm91bmRpbmdSZWN0RnJvbUlubGluZURhdGEoKSkKKyAgICAg ICAgcmV0dXJuICpyZWN0OworI2VuZGlmCisKKyAgICByZXR1cm4gYm91bmRpbmdSZWN0U2xvd0Nh c2UoKTsKK30KKworRmxvYXRSZWN0IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3QoKSBjb25zdAorewor ICAgIGlmIChpc051bGwoKSkKKyAgICAgICAgcmV0dXJuIHsgfTsKKworI2lmIEVOQUJMRShJTkxJ TkVfUEFUSF9EQVRBKQorICAgIGlmIChhdXRvIHJlY3QgPSBib3VuZGluZ1JlY3RGcm9tSW5saW5l RGF0YSgpKQorICAgICAgICByZXR1cm4gKnJlY3Q7CisjZW5kaWYKKworICAgIHJldHVybiBmYXN0 Qm91bmRpbmdSZWN0U2xvd0Nhc2UoKTsKK30KKworI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRB KQorCitPcHRpb25hbDxGbG9hdFJlY3Q+IFBhdGg6OmJvdW5kaW5nUmVjdEZyb21JbmxpbmVEYXRh KCkgY29uc3QKK3sKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxNb3ZlRGF0YT4oKSkKKyAgICAgICAg cmV0dXJuIEZsb2F0UmVjdCB7IH07CisKKyAgICBpZiAoaGFzSW5saW5lRGF0YTxMaW5lRGF0YT4o KSkgeworICAgICAgICBGbG9hdFJlY3QgcmVzdWx0OworICAgICAgICBhdXRvJiBsaW5lID0gV1RG OjpnZXQ8TGluZURhdGE+KG1faW5saW5lRGF0YSk7CisgICAgICAgIHJlc3VsdC5maXRUb1BvaW50 cyhsaW5lLnN0YXJ0LCBsaW5lLmVuZCk7CisgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgfQor CisgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKK30KKworI2VuZGlmCisKICNpZiAhVVNFKENHKSAm JiAhVVNFKERJUkVDVDJEKQogUGF0aCBQYXRoOjpwb2x5Z29uUGF0aEZyb21Qb2ludHMoY29uc3Qg VmVjdG9yPEZsb2F0UG9pbnQ+JiBwb2ludHMpCiB7CkBAIC0xODEsMTEgKzM2MCw2IEBAIFBhdGgg UGF0aDo6cG9seWdvblBhdGhGcm9tUG9pbnRzKGNvbnN0IFZlY3RvcjxGbG9hdFBvaW50PiYgcG9p bnRzKQogICAgIHBhdGguY2xvc2VTdWJwYXRoKCk7CiAgICAgcmV0dXJuIHBhdGg7CiB9Ci0KLUZs b2F0UmVjdCBQYXRoOjpmYXN0Qm91bmRpbmdSZWN0KCkgY29uc3QKLXsKLSAgICByZXR1cm4gYm91 bmRpbmdSZWN0KCk7Ci19CiAjZW5kaWYKIAogI2lmbmRlZiBOREVCVUcKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BhdGguaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1BhdGguaAppbmRleCA3ZmFkYTYwZDgzYzI5MjUwYWM0YTE3NDhhODky NDA3MDI5MTk5ZTFiLi5kZWJlMmYwZGM3MjZiYzBlYmJmZjllZjg4NjViODM3YzZkNzk3NGE5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QYXRoLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGF0aC5oCkBAIC0yNSwxMCArMjUsMTAg QEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuIAogICovCiAKLSNpZm5kZWYgUGF0aF9oCi0jZGVmaW5lIFBhdGhf aAorI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKKyNpbmNsdWRlICJJbmxp bmVQYXRoRGF0YS5oIgogI2luY2x1ZGUgIldpbmRSdWxlLmgiCiAjaW5jbHVkZSA8d3RmL0Zhc3RN YWxsb2MuaD4KICNpbmNsdWRlIDx3dGYvRnVuY3Rpb24uaD4KQEAgLTE0NywxMCArMTQ3LDEyIEBA IHB1YmxpYzoKICAgICBGbG9hdFBvaW50IHBvaW50QXRMZW5ndGgoZmxvYXQgbGVuZ3RoKSBjb25z dDsKIAogICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgY2xlYXIoKTsKLSAgICBib29sIGlzTnVsbCgp IGNvbnN0IHsgcmV0dXJuICFtX3BhdGg7IH0KKyAgICBXRUJDT1JFX0VYUE9SVCBib29sIGlzTnVs bCgpIGNvbnN0OwogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0OwogICAgIC8vIEdldHMgdGhlIGN1 cnJlbnQgcG9pbnQgb2YgdGhlIGN1cnJlbnQgcGF0aCwgd2hpY2ggaXMgY29uY2VwdHVhbGx5IHRo ZSBmaW5hbCBwb2ludCByZWFjaGVkIGJ5IHRoZSBwYXRoIHNvIGZhci4KICAgICAvLyBOb3RlIHRo ZSBQYXRoIGNhbiBiZSBlbXB0eSAoaXNFbXB0eSgpID09IHRydWUpIGFuZCBzdGlsbCBoYXZlIGEg Y3VycmVudCBwb2ludC4KKyAgICAvLyBGSVhNRTogVGhlIGFib3ZlIGNvbW1lbnQgbWlnaHQgbmVl ZCB0byBiZSB1cGRhdGVkOyBvbiBhbGwgc3VwcG9ydGVkIHBsYXRmb3JtcywgdGhlIHJlc3VsdCBv ZiBoYXNDdXJyZW50UG9pbnQoKSBpcyBpZGVudGljYWwKKyAgICAvLyB0byAhaXNFbXB0eSgpLgog ICAgIGJvb2wgaGFzQ3VycmVudFBvaW50KCkgY29uc3Q7CiAgICAgRmxvYXRQb2ludCBjdXJyZW50 UG9pbnQoKSBjb25zdDsKIApAQCAtMTg1LDcgKzE4Nyw3IEBAIHB1YmxpYzoKICAgICBGbG9hdFJl Y3QgZmFzdEJvdW5kaW5nUmVjdEZvclN0cm9rZShjb25zdCBQbGF0Zm9ybUNvbnRleHREaXJlY3Qy RCYpIGNvbnN0OwogICAgIFBsYXRmb3JtUGF0aFB0ciBwbGF0Zm9ybVBhdGgoKSBjb25zdCB7IHJl dHVybiBtX3BhdGguZ2V0KCk7IH0KICNlbGlmIFVTRShDRykKLSAgICBQbGF0Zm9ybVBhdGhQdHIg cGxhdGZvcm1QYXRoKCkgY29uc3QgeyByZXR1cm4gbV9wYXRoLmdldCgpOyB9CisgICAgV0VCQ09S RV9FWFBPUlQgUGxhdGZvcm1QYXRoUHRyIHBsYXRmb3JtUGF0aCgpIGNvbnN0OwogI2Vsc2UKICAg ICBQbGF0Zm9ybVBhdGhQdHIgcGxhdGZvcm1QYXRoKCkgY29uc3QgeyByZXR1cm4gbV9wYXRoOyB9 CiAjZW5kaWYKQEAgLTIyNSw3ICsyMjcsMjUgQEAgcHVibGljOgogICAgIHRlbXBsYXRlPGNsYXNz IERlY29kZXI+IHN0YXRpYyBPcHRpb25hbDxQYXRoPiBkZWNvZGUoRGVjb2RlciYpOwogCiBwcml2 YXRlOgorI2lmIEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorICAgIHRlbXBsYXRlPHR5cGVuYW1l IERhdGFUeXBlPiBib29sIGhhc0lubGluZURhdGEoKSBjb25zdDsKKyAgICBib29sIGhhc0FueUlu bGluZURhdGEoKSBjb25zdDsKKyAgICBPcHRpb25hbDxGbG9hdFJlY3Q+IGJvdW5kaW5nUmVjdEZy b21JbmxpbmVEYXRhKCkgY29uc3Q7CisjZW5kaWYKKworICAgIHZvaWQgbW92ZVRvU2xvd0Nhc2Uo Y29uc3QgRmxvYXRQb2ludCYpOworICAgIHZvaWQgYWRkTGluZVRvU2xvd0Nhc2UoY29uc3QgRmxv YXRQb2ludCYpOworICAgIHZvaWQgYWRkQXJjU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYsIGZs b2F0IHJhZGl1cywgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUsIGJvb2wgYW50aWNs b2Nrd2lzZSk7CisKKyAgICBGbG9hdFJlY3QgYm91bmRpbmdSZWN0U2xvd0Nhc2UoKSBjb25zdDsK KyAgICBGbG9hdFJlY3QgZmFzdEJvdW5kaW5nUmVjdFNsb3dDYXNlKCkgY29uc3Q7CisgICAgYm9v bCBpc0VtcHR5U2xvd0Nhc2UoKSBjb25zdDsKKyAgICBGbG9hdFBvaW50IGN1cnJlbnRQb2ludFNs b3dDYXNlKCkgY29uc3Q7CisgICAgc2l6ZV90IGVsZW1lbnRDb3VudFNsb3dDYXNlKCkgY29uc3Q7 CisgICAgdm9pZCBhcHBseVNsb3dDYXNlKGNvbnN0IFBhdGhBcHBsaWVyRnVuY3Rpb24mKSBjb25z dDsKKwogI2lmIFVTRShDRykKKyAgICB2b2lkIGNyZWF0ZUNHUGF0aCgpIGNvbnN0OwogICAgIHZv aWQgc3dhcChQYXRoJik7CiAjZW5kaWYKIApAQCAtMjM3LDYgKzI1Nyw5IEBAIHByaXZhdGU6CiAg ICAgbXV0YWJsZSBib29sIG1fZmlndXJlSXNPcGVuZWQgeyBmYWxzZSB9OwogI2VuZGlmCiAKKyNp ZiBFTkFCTEUoSU5MSU5FX1BBVEhfREFUQSkKKyAgICBJbmxpbmVQYXRoRGF0YSBtX2lubGluZURh dGE7CisjZW5kaWYKICNpZiBVU0UoQ0cpCiAgICAgbXV0YWJsZSBib29sIG1fY29weVBhdGhCZWZv cmVNdXRhdGlvbiB7IGZhbHNlIH07CiAjZW5kaWYKQEAgLTI0Niw2ICsyNjksMTUgQEAgV1RGOjpU ZXh0U3RyZWFtJiBvcGVyYXRvcjw8KFdURjo6VGV4dFN0cmVhbSYsIGNvbnN0IFBhdGgmKTsKIAog dGVtcGxhdGU8Y2xhc3MgRW5jb2Rlcj4gdm9pZCBQYXRoOjplbmNvZGUoRW5jb2RlciYgZW5jb2Rl cikgY29uc3QKIHsKKyNpZiBFTkFCTEUoSU5MSU5FX1BBVEhfREFUQSkKKyAgICBib29sIGhhc0lu bGluZURhdGEgPSBoYXNBbnlJbmxpbmVEYXRhKCk7CisgICAgZW5jb2RlciA8PCBoYXNJbmxpbmVE YXRhOworICAgIGlmIChoYXNJbmxpbmVEYXRhKSB7CisgICAgICAgIGVuY29kZXIgPDwgbV9pbmxp bmVEYXRhOworICAgICAgICByZXR1cm47CisgICAgfQorI2VuZGlmCisKICAgICBlbmNvZGVyIDw8 IHN0YXRpY19jYXN0PHVpbnQ2NF90PihlbGVtZW50Q291bnQoKSk7CiAKICAgICBhcHBseShbJl0o YXV0byYgZWxlbWVudCkgewpAQCAtMjc2LDYgKzMwOCwyMCBAQCB0ZW1wbGF0ZTxjbGFzcyBFbmNv ZGVyPiB2b2lkIFBhdGg6OmVuY29kZShFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAogdGVtcGxhdGU8 Y2xhc3MgRGVjb2Rlcj4gT3B0aW9uYWw8UGF0aD4gUGF0aDo6ZGVjb2RlKERlY29kZXImIGRlY29k ZXIpCiB7CiAgICAgUGF0aCBwYXRoOworCisjaWYgRU5BQkxFKElOTElORV9QQVRIX0RBVEEpCisg ICAgYm9vbCBoYXNJbmxpbmVEYXRhOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoaGFzSW5saW5l RGF0YSkpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICBpZiAoaGFzSW5saW5l RGF0YSkgeworICAgICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhdGgubV9pbmxpbmVEYXRhKSkK KyAgICAgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAgcmV0dXJuIHBhdGg7 CisgICAgfQorI2VuZGlmCisKICAgICB1aW50NjRfdCBudW1Qb2ludHM7CiAgICAgaWYgKCFkZWNv ZGVyLmRlY29kZShudW1Qb2ludHMpKQogICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OwpAQCAt MzM5LDYgKzM4NSwxOCBAQCB0ZW1wbGF0ZTxjbGFzcyBEZWNvZGVyPiBPcHRpb25hbDxQYXRoPiBQ YXRoOjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlcikKICAgICByZXR1cm4gcGF0aDsKIH0KIAorI2lm IEVOQUJMRShJTkxJTkVfUEFUSF9EQVRBKQorCit0ZW1wbGF0ZSA8dHlwZW5hbWUgRGF0YVR5cGU+ IGlubGluZSBib29sIFBhdGg6Omhhc0lubGluZURhdGEoKSBjb25zdAoreworICAgIHJldHVybiBX VEY6OmhvbGRzX2FsdGVybmF0aXZlPERhdGFUeXBlPihtX2lubGluZURhdGEpOworfQorCitpbmxp bmUgYm9vbCBQYXRoOjpoYXNBbnlJbmxpbmVEYXRhKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIWhh c0lubGluZURhdGE8TW9ub3N0YXRlPigpOwogfQogCiAjZW5kaWYKKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vUGF0aENhaXJvLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJv L1BhdGhDYWlyby5jcHAKaW5kZXggZTFiNTU0Yzg4NGMxNTJkNWE5OGIwNGE5N2NhNDc3M2Y1NDcz ODYzYi4uNTUyNTY5ZmQxOTc5YjA0YjBhYjQ0N2E0MjFkMmJiMzg5MmY4Y2YwZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vUGF0aENhaXJvLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9QYXRoQ2Fpcm8uY3Bw CkBAIC0xMTcsMjEgKzExNywxMyBAQCB2b2lkIFBhdGg6OmNsZWFyKCkKICAgICBjYWlyb19uZXdf cGF0aChjcik7CiB9CiAKLWJvb2wgUGF0aDo6aXNFbXB0eSgpIGNvbnN0Citib29sIFBhdGg6Omlz RW1wdHlTbG93Q2FzZSgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIGlzTnVsbCgpIHx8ICFjYWlyb19o YXNfY3VycmVudF9wb2ludChwbGF0Zm9ybVBhdGgoKS0+Y29udGV4dCgpKTsKKyAgICByZXR1cm4g IWNhaXJvX2hhc19jdXJyZW50X3BvaW50KHBsYXRmb3JtUGF0aCgpLT5jb250ZXh0KCkpOwogfQog Ci1ib29sIFBhdGg6Omhhc0N1cnJlbnRQb2ludCgpIGNvbnN0CitGbG9hdFBvaW50IFBhdGg6OmN1 cnJlbnRQb2ludFNsb3dDYXNlKCkgY29uc3QKIHsKLSAgICByZXR1cm4gIWlzRW1wdHkoKTsKLX0K LQotRmxvYXRQb2ludCBQYXRoOjpjdXJyZW50UG9pbnQoKSBjb25zdCAKLXsKLSAgICBpZiAoaXNO dWxsKCkpCi0gICAgICAgIHJldHVybiBGbG9hdFBvaW50KCk7Ci0KICAgICAvLyBGSVhNRTogSXMg dGhpcyB0aGUgY29ycmVjdCB3YXk/CiAgICAgZG91YmxlIHg7CiAgICAgZG91YmxlIHk7CkBAIC0x NDUsMTMgKzEzNywxMyBAQCB2b2lkIFBhdGg6OnRyYW5zbGF0ZShjb25zdCBGbG9hdFNpemUmIHAp CiAgICAgY2Fpcm9fdHJhbnNsYXRlKGNyLCAtcC53aWR0aCgpLCAtcC5oZWlnaHQoKSk7CiB9CiAK LXZvaWQgUGF0aDo6bW92ZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHApCit2b2lkIFBhdGg6Om1vdmVU b1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CiAgICAgY2Fpcm9fdCogY3IgPSBlbnN1 cmVQbGF0Zm9ybVBhdGgoKS0+Y29udGV4dCgpOwogICAgIGNhaXJvX21vdmVfdG8oY3IsIHAueCgp LCBwLnkoKSk7CiB9CiAKLXZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHAp Cit2b2lkIFBhdGg6OmFkZExpbmVUb1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CiAg ICAgY2Fpcm9fdCogY3IgPSBlbnN1cmVQbGF0Zm9ybVBhdGgoKS0+Y29udGV4dCgpOwogICAgIGNh aXJvX2xpbmVfdG8oY3IsIHAueCgpLCBwLnkoKSk7CkBAIC0xODksMTMgKzE4MSw4IEBAIHZvaWQg UGF0aDo6YWRkQmV6aWVyQ3VydmVUbyhjb25zdCBGbG9hdFBvaW50JiBjb250cm9sUG9pbnQxLCBj b25zdCBGbG9hdFBvaW50JiBjCiAgICAgICAgICAgICAgICAgICAgY29udHJvbFBvaW50My54KCks IGNvbnRyb2xQb2ludDMueSgpKTsKIH0KIAotdm9pZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQ b2ludCYgcCwgZmxvYXQgciwgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUsIGJvb2wg YW50aWNsb2Nrd2lzZSkKK3ZvaWQgUGF0aDo6YWRkQXJjU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2lu dCYgcCwgZmxvYXQgciwgZmxvYXQgc3RhcnRBbmdsZSwgZmxvYXQgZW5kQW5nbGUsIGJvb2wgYW50 aWNsb2Nrd2lzZSkKIHsKLSAgICAvLyBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjQ0OQotICAgIC8vIGNhaXJvX2FyYygpIGZ1bmN0aW9ucyBoYW5nIG9yIGNyYXNoIHdo ZW4gcGFzc2VkIGluZiBhcyByYWRpdXMgb3Igc3RhcnQvZW5kIGFuZ2xlCi0gICAgaWYgKCFzdGQ6 OmlzZmluaXRlKHIpIHx8ICFzdGQ6OmlzZmluaXRlKHN0YXJ0QW5nbGUpIHx8ICFzdGQ6OmlzZmlu aXRlKGVuZEFuZ2xlKSkKLSAgICAgICAgcmV0dXJuOwotCiAgICAgY2Fpcm9fdCogY3IgPSBlbnN1 cmVQbGF0Zm9ybVBhdGgoKS0+Y29udGV4dCgpOwogICAgIGZsb2F0IHN3ZWVwID0gZW5kQW5nbGUg LSBzdGFydEFuZ2xlOwogICAgIGNvbnN0IGZsb2F0IHR3b1BJID0gMiAqIHBpRmxvYXQ7CkBAIC0z NTMsMTIgKzM0MCw4IEBAIHZvaWQgUGF0aDo6Y2xvc2VTdWJwYXRoKCkKICAgICBjYWlyb19jbG9z ZV9wYXRoKGNyKTsKIH0KIAotRmxvYXRSZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgpIGNvbnN0CitG bG9hdFJlY3QgUGF0aDo6Ym91bmRpbmdSZWN0U2xvd0Nhc2UoKSBjb25zdAogewotICAgIC8vIFNo b3VsZCB0aGlzIGJlIGlzRW1wdHkoKSBvciBjYW4gYW4gZW1wdHkgcGF0aCBoYXZlIGEgbm9uLXpl cm8gb3JpZ2luPwotICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIEZsb2F0UmVjdCgp OwotCiAgICAgY2Fpcm9fdCogY3IgPSBwbGF0Zm9ybVBhdGgoKS0+Y29udGV4dCgpOwogICAgIGRv dWJsZSB4MCwgeDEsIHkwLCB5MTsKICAgICBjYWlyb19wYXRoX2V4dGVudHMoY3IsICZ4MCwgJnkw LCAmeDEsICZ5MSk7CkBAIC00MDgsMTEgKzM5MSw4IEBAIGJvb2wgUGF0aDo6c3Ryb2tlQ29udGFp bnMoU3Ryb2tlU3R5bGVBcHBsaWVyJiBhcHBsaWVyLCBjb25zdCBGbG9hdFBvaW50JiBwb2ludCkK ICAgICByZXR1cm4gY2Fpcm9faW5fc3Ryb2tlKGNyLCBwb2ludC54KCksIHBvaW50LnkoKSk7CiB9 CiAKLXZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24p IGNvbnN0Cit2b2lkIFBhdGg6OmFwcGx5U2xvd0Nhc2UoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlv biYgZnVuY3Rpb24pIGNvbnN0CiB7Ci0gICAgaWYgKGlzTnVsbCgpKQotICAgICAgICByZXR1cm47 Ci0KICAgICBjYWlyb190KiBjciA9IHBsYXRmb3JtUGF0aCgpLT5jb250ZXh0KCk7CiAgICAgYXV0 byBwYXRoQ29weSA9IGNhaXJvX2NvcHlfcGF0aChjcik7CiAgICAgY2Fpcm9fcGF0aF9kYXRhX3Qq IGRhdGE7CkBAIC00NDcsNiArNDI3LDExIEBAIHZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0aEFw cGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24pIGNvbnN0CiAgICAgY2Fpcm9fcGF0aF9kZXN0cm95KHBh dGhDb3B5KTsKIH0KIAorRmxvYXRSZWN0IFBhdGg6OmZhc3RCb3VuZGluZ1JlY3RTbG93Q2FzZSgp IGNvbnN0Cit7CisgICAgcmV0dXJuIGJvdW5kaW5nUmVjdCgpOworfQorCiB2b2lkIFBhdGg6OnRy YW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSkKIHsKICAgICBjYWlyb190 KiBjciA9IGVuc3VyZVBsYXRmb3JtUGF0aCgpLT5jb250ZXh0KCk7CkBAIC00NTUsNiArNDQwLDEx IEBAIHZvaWQgUGF0aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3Jt KQogICAgIGNhaXJvX3RyYW5zZm9ybShjciwgJm1hdHJpeCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNO dWxsKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcGF0aDsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJPKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENHLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2NnL1BhdGhDRy5jcHAKaW5kZXggNTIxYzE1NTNhOWE2YTM0YTM4MWMzNGY5 Nzg2MjU0ZGQ1ZjBjNzI2ZS4uMDZjNDQ3Y2U1Y2FmZjVmMWUwZGRmN2MwZGY1NzU4NmFmZGFiZTdl YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0aENH LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXRoQ0cuY3Bw CkBAIC04MSw2ICs4MSwzMCBAQCBQYXRoIFBhdGg6OnBvbHlnb25QYXRoRnJvbVBvaW50cyhjb25z dCBWZWN0b3I8RmxvYXRQb2ludD4mIHBvaW50cykKICAgICByZXR1cm4gcGF0aDsKIH0KIAordm9p ZCBQYXRoOjpjcmVhdGVDR1BhdGgoKSBjb25zdAoreworICAgIGlmIChtX3BhdGgpCisgICAgICAg IHJldHVybjsKKworICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3JlYXRlTXV0YWJsZSgpKTsK KworICAgIFdURjo6c3dpdGNoT24obV9pbmxpbmVEYXRhLAorICAgICAgICBbJl0oTW9ub3N0YXRl KSB7IH0sIC8vIFN0YXJ0IHdpdGggYW4gZW1wdHkgcGF0aC4KKyAgICAgICAgWyZdKGNvbnN0IE1v dmVEYXRhJiBtb3ZlKSB7CisgICAgICAgICAgICBDR1BhdGhNb3ZlVG9Qb2ludChtX3BhdGguZ2V0 KCksIG51bGxwdHIsIG1vdmUubG9jYXRpb24ueCgpLCBtb3ZlLmxvY2F0aW9uLnkoKSk7CisgICAg ICAgIH0sCisgICAgICAgIFsmXShjb25zdCBMaW5lRGF0YSYgbGluZSkgeworICAgICAgICAgICAg Q0dQYXRoTW92ZVRvUG9pbnQobV9wYXRoLmdldCgpLCBudWxscHRyLCBsaW5lLnN0YXJ0LngoKSwg bGluZS5zdGFydC55KCkpOworICAgICAgICAgICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQobV9wYXRo LmdldCgpLCBudWxscHRyLCBsaW5lLmVuZC54KCksIGxpbmUuZW5kLnkoKSk7CisgICAgICAgIH0s CisgICAgICAgIFsmXShjb25zdCBBcmNEYXRhJiBhcmMpIHsKKyAgICAgICAgICAgIGlmIChhcmMu aGFzT2Zmc2V0KQorICAgICAgICAgICAgICAgIENHUGF0aE1vdmVUb1BvaW50KG1fcGF0aC5nZXQo KSwgbnVsbHB0ciwgYXJjLm9mZnNldC54KCksIGFyYy5vZmZzZXQueSgpKTsKKyAgICAgICAgICAg IENHUGF0aEFkZEFyYyhtX3BhdGguZ2V0KCksIG51bGxwdHIsIGFyYy5jZW50ZXIueCgpLCBhcmMu Y2VudGVyLnkoKSwgYXJjLnJhZGl1cywgYXJjLnN0YXJ0QW5nbGUsIGFyYy5lbmRBbmdsZSwgYXJj LmNsb2Nrd2lzZSk7CisgICAgICAgIH0KKyAgICApOworfQorCiBQYXRoOjpQYXRoKFJldGFpblB0 cjxDR011dGFibGVQYXRoUmVmPiYmIHBhdGgpCiAgICAgOiBtX3BhdGgoV1RGTW92ZShwYXRoKSkK IHsKQEAgLTg5LDIxICsxMTMsMzQgQEAgUGF0aDo6UGF0aChSZXRhaW5QdHI8Q0dNdXRhYmxlUGF0 aFJlZj4mJiBwYXRoKQogUGF0aDo6UGF0aCgpID0gZGVmYXVsdDsKIFBhdGg6On5QYXRoKCkgPSBk ZWZhdWx0OwogCitQbGF0Zm9ybVBhdGhQdHIgUGF0aDo6cGxhdGZvcm1QYXRoKCkgY29uc3QKK3sK KyAgICBpZiAoIW1fcGF0aCAmJiBoYXNBbnlJbmxpbmVEYXRhKCkpCisgICAgICAgIGNyZWF0ZUNH UGF0aCgpOworICAgIHJldHVybiBtX3BhdGguZ2V0KCk7Cit9CisKIFBsYXRmb3JtUGF0aFB0ciBQ YXRoOjplbnN1cmVQbGF0Zm9ybVBhdGgoKQogewotICAgIGlmICghbV9wYXRoKQotICAgICAgICBt X3BhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7Ci0gICAgZWxzZSBpZiAobV9j b3B5UGF0aEJlZm9yZU11dGF0aW9uKSB7CisgICAgY3JlYXRlQ0dQYXRoKCk7CisgICAgaWYgKG1f Y29weVBhdGhCZWZvcmVNdXRhdGlvbikgewogICAgICAgICBpZiAoQ0ZHZXRSZXRhaW5Db3VudCht X3BhdGguZ2V0KCkpID4gMSkKICAgICAgICAgICAgIG1fcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3Jl YXRlTXV0YWJsZUNvcHkobV9wYXRoLmdldCgpKSk7CiAgICAgICAgIG1fY29weVBhdGhCZWZvcmVN dXRhdGlvbiA9IGZhbHNlOwogICAgIH0KKyAgICBtX2lubGluZURhdGEgPSBNb25vc3RhdGUgeyB9 OwogICAgIHJldHVybiBtX3BhdGguZ2V0KCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29u c3QKK3sKKyAgICByZXR1cm4gIW1fcGF0aCAmJiAhaGFzQW55SW5saW5lRGF0YSgpOworfQorCiBQ YXRoOjpQYXRoKGNvbnN0IFBhdGgmIG90aGVyKQogewogICAgIG1fcGF0aCA9IHsgb3RoZXIubV9w YXRoIH07CisgICAgbV9pbmxpbmVEYXRhID0gb3RoZXIubV9pbmxpbmVEYXRhOwogICAgIGlmICht X3BhdGgpIHsKICAgICAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gdHJ1ZTsKICAgICAg ICAgb3RoZXIubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uID0gdHJ1ZTsKQEAgLTExMiw2ICsxNDks NyBAQCBQYXRoOjpQYXRoKGNvbnN0IFBhdGgmIG90aGVyKQogCiBQYXRoOjpQYXRoKFBhdGgmJiBv dGhlcikKICAgICA6IG1fcGF0aChzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fcGF0aCwgbnVsbHB0cikp CisgICAgLCBtX2lubGluZURhdGEoc3RkOjpleGNoYW5nZShvdGhlci5tX2lubGluZURhdGEsIE1v bm9zdGF0ZSB7IH0pKQogICAgICwgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uKHN0ZDo6ZXhjaGFu Z2Uob3RoZXIubV9jb3B5UGF0aEJlZm9yZU11dGF0aW9uLCBmYWxzZSkpCiB7CiB9CkBAIC0xMTks NiArMTU3LDcgQEAgUGF0aDo6UGF0aChQYXRoJiYgb3RoZXIpCiB2b2lkIFBhdGg6OnN3YXAoUGF0 aCYgb3RoZXJQYXRoKQogewogICAgIHN0ZDo6c3dhcChtX3BhdGgsIG90aGVyUGF0aC5tX3BhdGgp OworICAgIHN0ZDo6c3dhcChtX2lubGluZURhdGEsIG90aGVyUGF0aC5tX2lubGluZURhdGEpOwog ICAgIHN0ZDo6c3dhcChtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24sIG90aGVyUGF0aC5tX2NvcHlQ YXRoQmVmb3JlTXV0YXRpb24pOwogfQogCkBAIC0xNzksNyArMjE4LDcgQEAgYm9vbCBQYXRoOjpj b250YWlucyhjb25zdCBGbG9hdFBvaW50ICZwb2ludCwgV2luZFJ1bGUgcnVsZSkgY29uc3QKICAg ICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgLy8gQ0dQYXRoQ29udGFpbnNQb2ludCByZXR1cm5z IGZhbHNlIGZvciBub24tY2xvc2VkIHBhdGhzLCBhcyBhIHdvcmstYXJvdW5kLCB3ZSBjb3B5IGFu ZCBjbG9zZSB0aGUgcGF0aCBmaXJzdC4gIFJhZGFyIDQ3NTg5OTggYXNrcyBmb3IgYSBiZXR0ZXIg Q0cgQVBJIHRvIHVzZQotICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoY29weUNHUGF0aENsb3NpbmdT dWJwYXRocyhtX3BhdGguZ2V0KCkpKTsKKyAgICBhdXRvIHBhdGggPSBhZG9wdENGKGNvcHlDR1Bh dGhDbG9zaW5nU3VicGF0aHMocGxhdGZvcm1QYXRoKCkpKTsKICAgICBib29sIHJldCA9IENHUGF0 aENvbnRhaW5zUG9pbnQocGF0aC5nZXQoKSwgMCwgcG9pbnQsIHJ1bGUgPT0gV2luZFJ1bGU6OkV2 ZW5PZGQgPyB0cnVlIDogZmFsc2UpOwogICAgIHJldHVybiByZXQ7CiB9CkBAIC0yMTcsMzEgKzI1 NiwzMSBAQCB2b2lkIFBhdGg6OnRyYW5zZm9ybShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5z Zm9ybSkKICAgICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm1DRyA9IHRyYW5zZm9ybTsKICNp ZiBQTEFURk9STShXSU4pCiAgICAgYXV0byBwYXRoID0gYWRvcHRDRihDR1BhdGhDcmVhdGVNdXRh YmxlKCkpOwotICAgIENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBtX3Bh dGguZ2V0KCkpOworICAgIENHUGF0aEFkZFBhdGgocGF0aC5nZXQoKSwgJnRyYW5zZm9ybUNHLCBw bGF0Zm9ybVBhdGgoKSk7CiAjZWxzZQotICAgIGF1dG8gcGF0aCA9IGFkb3B0Q0YoQ0dQYXRoQ3Jl YXRlTXV0YWJsZUNvcHlCeVRyYW5zZm9ybWluZ1BhdGgobV9wYXRoLmdldCgpLCAmdHJhbnNmb3Jt Q0cpKTsKKyAgICBhdXRvIHBhdGggPSBhZG9wdENGKENHUGF0aENyZWF0ZU11dGFibGVDb3B5QnlU cmFuc2Zvcm1pbmdQYXRoKHBsYXRmb3JtUGF0aCgpLCAmdHJhbnNmb3JtQ0cpKTsKICNlbmRpZgog ICAgIG1fcGF0aCA9IFdURk1vdmUocGF0aCk7CiAgICAgbV9jb3B5UGF0aEJlZm9yZU11dGF0aW9u ID0gZmFsc2U7CisgICAgbV9pbmxpbmVEYXRhID0gTW9ub3N0YXRlIHsgfTsKIH0KIAotRmxvYXRS ZWN0IFBhdGg6OmJvdW5kaW5nUmVjdCgpIGNvbnN0CitzdGF0aWMgaW5saW5lIEZsb2F0UmVjdCB6 ZXJvUmVjdElmTnVsbChDR1JlY3QgcmVjdCkKIHsKLSAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAg IHJldHVybiBDR1JlY3RaZXJvOworICAgIGlmIChDR1JlY3RJc051bGwocmVjdCkpCisgICAgICAg IHJldHVybiB7IH07CisgICAgcmV0dXJuIHJlY3Q7Cit9CiAKK0Zsb2F0UmVjdCBQYXRoOjpib3Vu ZGluZ1JlY3RTbG93Q2FzZSgpIGNvbnN0Cit7CiAgICAgLy8gQ0dQYXRoR2V0Qm91bmRpbmdCb3gg aW5jbHVkZXMgdGhlIHBhdGgncyBjb250cm9sIHBvaW50cywgQ0dQYXRoR2V0UGF0aEJvdW5kaW5n Qm94IGRvZXMgbm90LgotCi0gICAgQ0dSZWN0IGJvdW5kID0gQ0dQYXRoR2V0UGF0aEJvdW5kaW5n Qm94KG1fcGF0aC5nZXQoKSk7Ci0gICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkgPyBDR1Jl Y3RaZXJvIDogYm91bmQ7CisgICAgcmV0dXJuIHplcm9SZWN0SWZOdWxsKENHUGF0aEdldFBhdGhC b3VuZGluZ0JveChwbGF0Zm9ybVBhdGgoKSkpOwogfQogCi1GbG9hdFJlY3QgUGF0aDo6ZmFzdEJv dW5kaW5nUmVjdCgpIGNvbnN0CitGbG9hdFJlY3QgUGF0aDo6ZmFzdEJvdW5kaW5nUmVjdFNsb3dD YXNlKCkgY29uc3QKIHsKLSAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybiBDR1JlY3Ra ZXJvOwotICAgIENHUmVjdCBib3VuZCA9IENHUGF0aEdldEJvdW5kaW5nQm94KG1fcGF0aC5nZXQo KSk7Ci0gICAgcmV0dXJuIENHUmVjdElzTnVsbChib3VuZCkgPyBDR1JlY3RaZXJvIDogYm91bmQ7 CisgICAgcmV0dXJuIHplcm9SZWN0SWZOdWxsKENHUGF0aEdldEJvdW5kaW5nQm94KHBsYXRmb3Jt UGF0aCgpKSk7CiB9CiAKIEZsb2F0UmVjdCBQYXRoOjpzdHJva2VCb3VuZGluZ1JlY3QoU3Ryb2tl U3R5bGVBcHBsaWVyKiBhcHBsaWVyKSBjb25zdApAQCAtMjY3LDEyICszMDYsMTIgQEAgRmxvYXRS ZWN0IFBhdGg6OnN0cm9rZUJvdW5kaW5nUmVjdChTdHJva2VTdHlsZUFwcGxpZXIqIGFwcGxpZXIp IGNvbnN0CiAgICAgcmV0dXJuIENHUmVjdElzTnVsbChib3gpID8gQ0dSZWN0WmVybyA6IGJveDsK IH0KIAotdm9pZCBQYXRoOjptb3ZlVG8oY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCit2b2lkIFBh dGg6Om1vdmVUb1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQogewogICAgIENHUGF0 aE1vdmVUb1BvaW50KGVuc3VyZVBsYXRmb3JtUGF0aCgpLCBudWxscHRyLCBwb2ludC54KCksIHBv aW50LnkoKSk7CiB9CiAKLXZvaWQgUGF0aDo6YWRkTGluZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHAp Cit2b2lkIFBhdGg6OmFkZExpbmVUb1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIHApCiB7CiAg ICAgQ0dQYXRoQWRkTGluZVRvUG9pbnQoZW5zdXJlUGxhdGZvcm1QYXRoKCksIG51bGxwdHIsIHAu eCgpLCBwLnkoKSk7CiB9CkBAIC0zNTAsMTIgKzM4OSw4IEBAIHZvaWQgUGF0aDo6Y2xvc2VTdWJw YXRoKCkKICAgICBDR1BhdGhDbG9zZVN1YnBhdGgoZW5zdXJlUGxhdGZvcm1QYXRoKCkpOwogfQog Ci12b2lkIFBhdGg6OmFkZEFyYyhjb25zdCBGbG9hdFBvaW50JiBwLCBmbG9hdCByYWRpdXMsIGZs b2F0IHN0YXJ0QW5nbGUsIGZsb2F0IGVuZEFuZ2xlLCBib29sIGNsb2Nrd2lzZSkKK3ZvaWQgUGF0 aDo6YWRkQXJjU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYgcCwgZmxvYXQgcmFkaXVzLCBmbG9h dCBzdGFydEFuZ2xlLCBmbG9hdCBlbmRBbmdsZSwgYm9vbCBjbG9ja3dpc2UpCiB7Ci0gICAgLy8g V29ya2Fyb3VuZCBmb3IgPHJkYXI6Ly9wcm9ibGVtLzUxODkyMzM+IENHUGF0aEFkZEFyYyBoYW5n cyBvciBjcmFzaGVzIHdoZW4gcGFzc2VkIGluZiBhcyBzdGFydCBvciBlbmQgYW5nbGUKLSAgICBp ZiAoIXN0ZDo6aXNmaW5pdGUoc3RhcnRBbmdsZSkgfHwgIXN0ZDo6aXNmaW5pdGUoZW5kQW5nbGUp KQotICAgICAgICByZXR1cm47Ci0KICAgICBDR1BhdGhBZGRBcmMoZW5zdXJlUGxhdGZvcm1QYXRo KCksIG51bGxwdHIsIHAueCgpLCBwLnkoKSwgcmFkaXVzLCBzdGFydEFuZ2xlLCBlbmRBbmdsZSwg Y2xvY2t3aXNlKTsKIH0KIApAQCAtNDAyLDI1ICs0MzcsMTkgQEAgdm9pZCBQYXRoOjpjbGVhcigp CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX3BhdGggPSBhZG9w dENGKENHUGF0aENyZWF0ZU11dGFibGUoKSk7CisgICAgbV9wYXRoLmNsZWFyKCk7CisgICAgbV9p bmxpbmVEYXRhID0gTW9ub3N0YXRlIHsgfTsKICAgICBtX2NvcHlQYXRoQmVmb3JlTXV0YXRpb24g PSBmYWxzZTsKIH0KIAotYm9vbCBQYXRoOjppc0VtcHR5KCkgY29uc3QKK2Jvb2wgUGF0aDo6aXNF bXB0eVNsb3dDYXNlKCkgY29uc3QKIHsKLSAgICByZXR1cm4gaXNOdWxsKCkgfHwgQ0dQYXRoSXNF bXB0eShtX3BhdGguZ2V0KCkpOworICAgIHJldHVybiBDR1BhdGhJc0VtcHR5KG1fcGF0aC5nZXQo KSk7CiB9CiAKLWJvb2wgUGF0aDo6aGFzQ3VycmVudFBvaW50KCkgY29uc3QKK0Zsb2F0UG9pbnQg UGF0aDo6Y3VycmVudFBvaW50U2xvd0Nhc2UoKSBjb25zdAogewotICAgIHJldHVybiAhaXNFbXB0 eSgpOwotfQotICAgIAotRmxvYXRQb2ludCBQYXRoOjpjdXJyZW50UG9pbnQoKSBjb25zdCAKLXsK LSAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybiBGbG9hdFBvaW50KCk7Ci0gICAgcmV0 dXJuIENHUGF0aEdldEN1cnJlbnRQb2ludChtX3BhdGguZ2V0KCkpOworICAgIHJldHVybiBDR1Bh dGhHZXRDdXJyZW50UG9pbnQocGxhdGZvcm1QYXRoKCkpOwogfQogCiBzdGF0aWMgdm9pZCBDR1Bh dGhBcHBsaWVyVG9QYXRoQXBwbGllcih2b2lkKiBpbmZvLCBjb25zdCBDR1BhdGhFbGVtZW50KiBl bGVtZW50KQpAQCAtNDQ5LDE5ICs0NzgsMTYgQEAgc3RhdGljIHZvaWQgQ0dQYXRoQXBwbGllclRv UGF0aEFwcGxpZXIodm9pZCogaW5mbywgY29uc3QgQ0dQYXRoRWxlbWVudCogZWxlbWVudCkKICAg ICBmdW5jdGlvbihwYXRoRWxlbWVudCk7CiB9CiAKLXZvaWQgUGF0aDo6YXBwbHkoY29uc3QgUGF0 aEFwcGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24pIGNvbnN0Cit2b2lkIFBhdGg6OmFwcGx5U2xvd0Nh c2UoY29uc3QgUGF0aEFwcGxpZXJGdW5jdGlvbiYgZnVuY3Rpb24pIGNvbnN0CiB7Ci0gICAgaWYg KGlzTnVsbCgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBDR1BhdGhBcHBseShtX3BhdGguZ2V0 KCksICh2b2lkKikmZnVuY3Rpb24sIENHUGF0aEFwcGxpZXJUb1BhdGhBcHBsaWVyKTsKKyAgICBD R1BhdGhBcHBseShwbGF0Zm9ybVBhdGgoKSwgKHZvaWQqKSZmdW5jdGlvbiwgQ0dQYXRoQXBwbGll clRvUGF0aEFwcGxpZXIpOwogfQogCiAjaWYgSEFWRShDR1BBVEhfR0VUX05VTUJFUl9PRl9FTEVN RU5UUykKIAotc2l6ZV90IFBhdGg6OmVsZW1lbnRDb3VudCgpIGNvbnN0CitzaXplX3QgUGF0aDo6 ZWxlbWVudENvdW50U2xvd0Nhc2UoKSBjb25zdAogewotICAgIHJldHVybiBDR1BhdGhHZXROdW1i ZXJPZkVsZW1lbnRzKG1fcGF0aCk7CisgICAgcmV0dXJuIENHUGF0aEdldE51bWJlck9mRWxlbWVu dHMocGxhdGZvcm1QYXRoKCkpOwogfQogCiAjZW5kaWYgLy8gSEFWRShDR1BBVEhfR0VUX05VTUJF Ul9PRl9FTEVNRU5UUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0cy9EaXNwbGF5TGlzdEl0ZW1zLmNwcAppbmRleCBk NDUzMWJhYjVjYTQ0Y2ViY2FmOTVhYWZlNzUwMzJmNDM5YWI4YWQ3Li5lMjI2MTcwM2U0YmMwYjlh YWY1MDUzYjM0N2E4ZmM4ZjAxMDlhNDczIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlMaXN0SXRl bXMuY3BwCkBAIC0xMjI4LDcgKzEyMjgsNyBAQCBPcHRpb25hbDxGbG9hdFJlY3Q+IFN0cm9rZVBh dGg6OmxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNzQ29udGV4dCYgY29udGV4dCkgY29ucwogCiB2 b2lkIFN0cm9rZVBhdGg6OmFwcGx5KEdyYXBoaWNzQ29udGV4dCYgY29udGV4dCkgY29uc3QKIHsK LSAgICBjb250ZXh0LnN0cm9rZVBhdGgobV9wYXRoKTsKKyAgICBjb250ZXh0LnN0cm9rZVBhdGgo V1RGTW92ZShtX3BhdGgpKTsKIH0KIAogc3RhdGljIFRleHRTdHJlYW0mIG9wZXJhdG9yPDwoVGV4 dFN0cmVhbSYgdHMsIGNvbnN0IFN0cm9rZVBhdGgmIGl0ZW0pCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJdGVtcy5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZGlzcGxheWxpc3RzL0Rpc3BsYXlM aXN0SXRlbXMuaAppbmRleCA3NzQyMDVhYzczZjYyNzE0ZTNjZmE5MGUwMjJjZTVjNzcwODI4ZjJi Li5iOTBlZDIwOWQxZDE5MzdiMzI2NzM3Zjk2YzU5YjkxNmRiNzJlODNiIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMvRGlzcGxheUxpc3RJ dGVtcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Rpc3BsYXlsaXN0 cy9EaXNwbGF5TGlzdEl0ZW1zLmgKQEAgLTI1ODksNyArMjU4OSw3IEBAIHByaXZhdGU6CiAgICAg dm9pZCBhcHBseShHcmFwaGljc0NvbnRleHQmKSBjb25zdCBvdmVycmlkZTsKICAgICBPcHRpb25h bDxGbG9hdFJlY3Q+IGxvY2FsQm91bmRzKGNvbnN0IEdyYXBoaWNzQ29udGV4dCYpIGNvbnN0IG92 ZXJyaWRlOwogCi0gICAgY29uc3QgUGF0aCBtX3BhdGg7CisgICAgbXV0YWJsZSBQYXRoIG1fcGF0 aDsKIH07CiAKIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vUGF0aERpcmVjdDJELmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCmluZGV4IGZmNjMwMTQz OTQwNGYwN2ZhNzBmOGEzYzY0N2E1OGQxYjRjYmJkNjUuLmYyNDdjYmFhOGIxYjY4YTE3ZmYyM2I3 ZDA1NmI4ZDJlM2UwMmY5MTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL3dpbi9QYXRoRGlyZWN0MkQuY3BwCkBAIC0zMDEsMTEgKzMwMSw4IEBAIHZvaWQg UGF0aDo6dHJhbnNmb3JtKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtKQogICAgIEFT U0VSVChyZWZDb3VudChtX3BhdGguZ2V0KCkpID09IDEpOwogfQogCi1GbG9hdFJlY3QgUGF0aDo6 Ym91bmRpbmdSZWN0KCkgY29uc3QKK0Zsb2F0UmVjdCBQYXRoOjpib3VuZGluZ1JlY3RTbG93Q2Fz ZSgpIGNvbnN0CiB7Ci0gICAgaWYgKGlzTnVsbCgpKQotICAgICAgICByZXR1cm4gRmxvYXRSZWN0 KCk7Ci0KICAgICBEMkQxX1JFQ1RfRiBib3VuZHMgPSB7IH07CiAgICAgaWYgKCFTVUNDRUVERUQo bV9wYXRoLT5HZXRCb3VuZHMobnVsbHB0ciwgJmJvdW5kcykpKQogICAgICAgICByZXR1cm4gRmxv YXRSZWN0KCk7CkBAIC0zMTMsMTEgKzMxMCw4IEBAIEZsb2F0UmVjdCBQYXRoOjpib3VuZGluZ1Jl Y3QoKSBjb25zdAogICAgIHJldHVybiBib3VuZHM7CiB9CiAKLUZsb2F0UmVjdCBQYXRoOjpmYXN0 Qm91bmRpbmdSZWN0KCkgY29uc3QKK0Zsb2F0UmVjdCBQYXRoOjpmYXN0Qm91bmRpbmdSZWN0U2xv d0Nhc2UoKSBjb25zdAogewotICAgIGlmIChpc051bGwoKSkKLSAgICAgICAgcmV0dXJuIEZsb2F0 UmVjdCgpOwotCiAgICAgRDJEMV9SRUNUX0YgYm91bmRzID0geyB9OwogICAgIGlmICghU1VDQ0VF REVEKG1fcGF0aC0+R2V0Qm91bmRzKG51bGxwdHIsICZib3VuZHMpKSkKICAgICAgICAgcmV0dXJu IEZsb2F0UmVjdCgpOwpAQCAtMzc0LDcgKzM2OCw3IEBAIHZvaWQgUGF0aDo6b3BlbkZpZ3VyZUF0 Q3VycmVudFBvaW50SWZOZWNlc3NhcnkoKQogICAgIG1fZmlndXJlSXNPcGVuZWQgPSB0cnVlOwog fQogCi12b2lkIFBhdGg6Om1vdmVUbyhjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKK3ZvaWQgUGF0 aDo6bW92ZVRvU2xvd0Nhc2UoY29uc3QgRmxvYXRQb2ludCYgcG9pbnQpCiB7CiAgICAgaWYgKG1f YWN0aXZlUGF0aCkKICAgICAgICAgY2xvc2VBbnlPcGVuR2VvbWV0cmllcyhEMkQxX0ZJR1VSRV9F TkRfT1BFTik7CkBAIC0zOTQsNyArMzg4LDcgQEAgdm9pZCBQYXRoOjptb3ZlVG8oY29uc3QgRmxv YXRQb2ludCYgcG9pbnQpCiAgICAgbV9maWd1cmVJc09wZW5lZCA9IHRydWU7CiB9CiAKLXZvaWQg UGF0aDo6YWRkTGluZVRvKGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50KQordm9pZCBQYXRoOjphZGRM aW5lVG9TbG93Q2FzZShjb25zdCBGbG9hdFBvaW50JiBwb2ludCkKIHsKICAgICBvcGVuRmlndXJl QXRDdXJyZW50UG9pbnRJZk5lY2Vzc2FyeSgpOwogICAgIG1fYWN0aXZlUGF0aC0+QWRkTGluZShw b2ludCk7CkBAIC01MjUsNyArNTE5LDcgQEAgc3RhdGljIHZvaWQgZHJhd0FyY1NlY3Rpb24oSUQy RDFHZW9tZXRyeVNpbmsqIHNpbmssIGNvbnN0IEZsb2F0UG9pbnQmIGNlbnRlciwgZmwKICAgICBz aW5rLT5BZGRBcmMoRDJEMTo6QXJjU2VnbWVudChlbmRQb2ludCwgRDJEMTo6U2l6ZUYocmFkaXVz LCByYWRpdXMpLCAwLCBkaXJlY3Rpb24sIEQyRDFfQVJDX1NJWkVfU01BTEwpKTsKIH0KIAotdm9p ZCBQYXRoOjphZGRBcmMoY29uc3QgRmxvYXRQb2ludCYgY2VudGVyLCBmbG9hdCByYWRpdXMsIGZs b2F0IHN0YXJ0QW5nbGUsIGZsb2F0IGVuZEFuZ2xlLCBib29sIGFudGljbG9ja3dpc2UpCit2b2lk IFBhdGg6OmFkZEFyY1Nsb3dDYXNlKGNvbnN0IEZsb2F0UG9pbnQmIGNlbnRlciwgZmxvYXQgcmFk aXVzLCBmbG9hdCBzdGFydEFuZ2xlLCBmbG9hdCBlbmRBbmdsZSwgYm9vbCBhbnRpY2xvY2t3aXNl KQogewogICAgIGF1dG8gYXJjU3RhcnRQb2ludCA9IGFyY1N0YXJ0KGNlbnRlciwgcmFkaXVzLCBz dGFydEFuZ2xlKTsKICAgICBpZiAoIW1fYWN0aXZlUGF0aCkKQEAgLTYyMSwxMSArNjE1LDggQEAg dm9pZCBQYXRoOjpjbGVhcigpCiAgICAgY2xlYXJHZW9tZXRyaWVzKCk7CiB9CiAKLWJvb2wgUGF0 aDo6aXNFbXB0eSgpIGNvbnN0Citib29sIFBhdGg6OmlzRW1wdHlTbG93Q2FzZSgpIGNvbnN0CiB7 Ci0gICAgaWYgKGlzTnVsbCgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLQogICAgIGlmICghbV9w YXRoLT5HZXRTb3VyY2VHZW9tZXRyeUNvdW50KCkpCiAgICAgICAgIHJldHVybiB0cnVlOwogCkBA IC02MzQsMTYgKzYyNSw4IEBAIGJvb2wgUGF0aDo6aXNFbXB0eSgpIGNvbnN0CiAgICAgcmV0dXJu IGZhbHNlOwogfQogCi1ib29sIFBhdGg6Omhhc0N1cnJlbnRQb2ludCgpIGNvbnN0CitGbG9hdFBv aW50IFBhdGg6OmN1cnJlbnRQb2ludFNsb3dDYXNlKCkgY29uc3QKIHsKLSAgICByZXR1cm4gIWlz RW1wdHkoKTsKLX0KLSAgICAKLUZsb2F0UG9pbnQgUGF0aDo6Y3VycmVudFBvaW50KCkgY29uc3Qg Ci17Ci0gICAgaWYgKGlzTnVsbCgpKQotICAgICAgICByZXR1cm4gRmxvYXRQb2ludCgpOwotCiAg ICAgZmxvYXQgbGVuZ3RoID0gMDsKICAgICBIUkVTVUxUIGhyID0gbV9wYXRoLT5Db21wdXRlTGVu Z3RoKG51bGxwdHIsICZsZW5ndGgpOwogICAgIGlmICghU1VDQ0VFREVEKGhyKSkKQEAgLTY2OCwx NCArNjUxLDE2IEBAIGZsb2F0IFBhdGg6Omxlbmd0aCgpIGNvbnN0CiAgICAgcmV0dXJuIGxlbmd0 aDsKIH0KIAotdm9pZCBQYXRoOjphcHBseShjb25zdCBQYXRoQXBwbGllckZ1bmN0aW9uJiBmdW5j dGlvbikgY29uc3QKK3ZvaWQgUGF0aDo6YXBwbHlTbG93Q2FzZShjb25zdCBQYXRoQXBwbGllckZ1 bmN0aW9uJikgY29uc3QKIHsKLSAgICBpZiAoaXNOdWxsKCkpCi0gICAgICAgIHJldHVybjsKLQog ICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKK2Jvb2wgUGF0aDo6aXNOdWxsKCkgY29uc3QKK3sK KyAgICByZXR1cm4gIW1fcGF0aDsKK30KKwogfQogCiAjZW5kaWYgLy8gVVNFKERJUkVDVDJEKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuY3Bw IGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMuY3BwCmluZGV4IDc2 ZDJiMDlkYWJmMTE0YzM5YzY0NmFlMzE2MzdmYTIwMTYxZmRiM2YuLjJhM2Q4NmIxZjdhMWZlNGZj MzliYzBhNDk3YTE4MzI4MDkwMDUzNjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZv cm0vSVBDL0FyZ3VtZW50Q29kZXJzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQ Qy9Bcmd1bWVudENvZGVycy5jcHAKQEAgLTIwNSw0ICsyMDUsMTMgQEAgYm9vbCBBcmd1bWVudENv ZGVyPGF1ZGl0X3Rva2VuX3Q+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlciwgYXVkaXRfdG9rZW5f dCYgYXVkaXQKIH0KICNlbmRpZgogCit2b2lkIEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZW5j b2RlKEVuY29kZXImLCBjb25zdCBNb25vc3RhdGUmKQoreworfQorCitPcHRpb25hbDxNb25vc3Rh dGU+IEFyZ3VtZW50Q29kZXI8TW9ub3N0YXRlPjo6ZGVjb2RlKERlY29kZXImKQoreworICAgIHJl dHVybiBNb25vc3RhdGUgeyB9OworfQorCiB9IC8vIG5hbWVzcGFjZSBJUEMKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50Q29kZXJzLmggYi9Tb3VyY2UvV2Vi S2l0L1BsYXRmb3JtL0lQQy9Bcmd1bWVudENvZGVycy5oCmluZGV4IDU4YzQ1NjQ2ODhjOGYzZjJl YWMxYWM0NzAxODJiODVhZmFkZmM2NjQuLmU3YjI2ZjQ1NTZmYTRkMzJmNWY2ZmJkZTlmNWFkZmRj OWYxZmFjOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0FyZ3VtZW50 Q29kZXJzLmgKKysrIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvQXJndW1lbnRDb2RlcnMu aApAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgPHd0Zi9Nb25vdG9uaWNUaW1lLmg+CiAjaW5j bHVkZSA8d3RmL1NIQTEuaD4KICNpbmNsdWRlIDx3dGYvVW5leHBlY3RlZC5oPgorI2luY2x1ZGUg PHd0Zi9WYXJpYW50Lmg+CiAjaW5jbHVkZSA8d3RmL1dhbGxUaW1lLmg+CiAKIG5hbWVzcGFjZSBJ UEMgewpAQCAtNjkxLDQgKzY5Miw5IEBAIHRlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8 YXVkaXRfdG9rZW5fdD4gewogfTsKICNlbmRpZgogCit0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1bWVu dENvZGVyPE1vbm9zdGF0ZT4geworICAgIHN0YXRpYyB2b2lkIGVuY29kZShFbmNvZGVyJiwgY29u c3QgTW9ub3N0YXRlJik7CisgICAgc3RhdGljIE9wdGlvbmFsPE1vbm9zdGF0ZT4gZGVjb2RlKERl Y29kZXImKTsKK307CisKIH0gLy8gbmFtZXNwYWNlIElQQwo=