231467 2021-10-08 17:37:40 -0700 Switch WTF::bridge_cast to use type traits 2022-01-16 13:46:25 -0800 1 1 1 Unclassified WebKit Web Template Framework WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 230406 231251 1 ddkilzer ddkilzer aboxhall andersca andresg_22 apinheiro benjamin cdumez cfleizach cmarcelo darin dmazzoni ews-watchlist jcraig jdiggs samuel_white webkit-bug-importer oldest_to_newest 1802329 0 ddkilzer 2021-10-08 17:37:40 -0700 Switch WTF::bridge_cast to use type traits. This replaces some macro-generated code with template code. Not sure the new code is more readable, but error messages should be much less verbose. Defining the type traits in WebKit will also let us remove some duplicate code in Safari. This is based on some code written in November 2011 by Anders Carlsson. 1802330 1 webkit-bug-importer 2021-10-08 17:38:20 -0700 <rdar://problem/84050614> 1802332 2 440693 ddkilzer 2021-10-08 17:40:47 -0700 Created attachment 440693 Patch v1 1802335 3 ddkilzer 2021-10-08 17:48:36 -0700 Darin, I tried my best to use this to fix the return type of RetainPtr<>::bridgingAutorelease(), but I couldn't figure out how to make this work: #ifdef __OBJC__ + using BridgingPtrType = typename std::conditional_t<!std::is_convertible_v<T, id> && IsTypeComplete<CFTollFreeBridgingTraits<T>>, typename CFTollFreeBridgingTraits<T>::BridgedType, id>; using HelperPtrType = typename std::conditional_t<std::is_convertible_v<T, id> && !std::is_same_v<T, id>, std::remove_pointer_t<T>, T>; #else + using BridgingPtrType = id; using HelperPtrType = PtrType; #endif The challenge is that even if `IsTypeComplete<CFTollFreeBridgingTraits<T>` is false, `typename CFTollFreeBridgingTraits<T>::BridgedType` must still evaluate to something (even if it's not used). Or at least that's the conclusion I came to when I tried it. 1802340 4 darin 2021-10-08 18:09:41 -0700 I haven’t lost confidence that we can do it yet. We do not want bridgingAutorelease to do less type checking when the type is not complete, so I think that part of the solution isn’t heading in the right direction. What we want instead is that calls to bridgingAutorelease fail to compile successfully, maybe because of SFINAE, when the type is not complete. So this means we may not be able to use a using at the class level; the type expression may need to be entirely within the bridgingAutorelease function definition. 1802341 5 darin 2021-10-08 18:09:41 -0700 I haven’t lost confidence that we can do it yet. We do not want bridgingAutorelease to do less type checking when the type is not complete, so I think that part of the solution isn’t heading in the right direction. What we want instead is that calls to bridgingAutorelease fail to compile successfully, maybe because of SFINAE, when the type is not complete. So this means we may not be able to use a using at the class level; the type expression may need to be entirely within the bridgingAutorelease function definition. 1802357 6 ddkilzer 2021-10-08 20:53:08 -0700 (In reply to Darin Adler from comment #5) > I haven’t lost confidence that we can do it yet. > > We do not want bridgingAutorelease to do less type checking when the type is > not complete, so I think that part of the solution isn’t heading in the > right direction. Okay. > What we want instead is that calls to bridgingAutorelease fail to compile > successfully, maybe because of SFINAE, when the type is not complete. So > this means we may not be able to use a using at the class level; the type > expression may need to be entirely within the bridgingAutorelease function > definition. I don't think SFINAE will work because we can't make an instance method of RetainPtr<> optional (that I'm aware of), but maybe there's an SFINAE pattern I'm not thinking of. We'd have to move bridgingAutorelease() out of the RetainPtr<> class (to a stand-alone function) to use SFINAE. This does work: template<typename T> inline id RetainPtr<T>::bridgingAutorelease() { static_assert(!std::is_convertible_v<PtrType, id> && IsTypeComplete<CFTollFreeBridgingTraits<PtrType>>, "bridgingAutorelease() can only be used for toll-free bridged CF types."); return CFBridgingRelease(leakRef()); } And it already caught an "error": WebKitBuild/Debug/usr/local/include/wtf/RetainPtr.h:223:5: error: static_assert failed due to requirement 'IsTypeComplete<WTF::CFTollFreeBridgingTraits<const __AXTextMarker *>>' "bridgingAutorelease() can only be used for toll-free bridged CF types." static_assert(!std::is_convertible_v<PtrType, id> && IsTypeComplete<CFTollFreeBridgingTraits<PtrType>>, "bridgingAutorelease() can only be used for toll-free bridged CF types."); ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from WebKitBuild/Debug/DerivedSources/WebCore/unified-sources/UnifiedSource5-mm.mm:5: ./accessibility/mac/AXObjectCacheMac.mm:494:38: note: in instantiation of member function 'WTF::RetainPtr<const __AXTextMarker *>::bridgingAutorelease' requested here [change setObject:textMarker.bridgingAutorelease() forKey:NSAccessibilityTextChangeValueStartMarker]; ^ 1 error generated. Is this the type of issue we want to catch? I thought it was generally okay to autorelease CF objects. Looks like this should probably just be a .get() with a bridge_id_cast() to prevent the autorelease in the first place: static void addTextMarkerFor(NSMutableDictionary* change, AXCoreObject& object, HTMLTextFormControlElement& textControl) { if (auto textMarker = [object.wrapper() textMarkerForFirstPositionInTextControl:textControl]) - [change setObject:textMarker.bridgingAutorelease() forKey:NSAccessibilityTextChangeValueStartMarker]; + [change setObject:bridge_id_cast(textMarker.get()) forKey:NSAccessibilityTextChangeValueStartMarker]; } 1802392 7 440712 ddkilzer 2021-10-09 10:19:50 -0700 Created attachment 440712 Patch v2 1802630 8 ddkilzer 2021-10-11 08:50:11 -0700 Review ping. 1802823 9 darin 2021-10-11 15:00:24 -0700 (In reply to David Kilzer (:ddkilzer) from comment #6) > Is this the type of issue we want to catch? I thought it was generally okay > to autorelease CF objects. Once bridgingAutorelease chooses the type correctly, it might need to be replaced by two different functions, for the same reason we added both bridge_cast and bridge_id_cast; the former can be used when the class is toll-free bridged with a specific Objective-C class, while the latter can be used for any CF object that we choose to use with Objective-C, even if there is no Objective-C counterpart. Thinking about this, I want us to think about which cast function one should use in the other direction, to convert the "id" back to a CoreFoundation type. For object ownership we would use adoptNS, but then how would we convert the RetainPtr<id> into RetainPtr<AXTextMarkerRef>. It seems this particular case calls for the bridge_id_cast style. > Looks like this should probably just be a .get() with a bridge_id_cast() to > prevent the autorelease in the first place Yes, this code does not need autorelease; it needs bridging. > - [change setObject:textMarker.bridgingAutorelease() > forKey:NSAccessibilityTextChangeValueStartMarker]; > + [change setObject:bridge_id_cast(textMarker.get()) > forKey:NSAccessibilityTextChangeValueStartMarker]; I’m noticing that this will be slightly suboptimal under ARC, requiring an extra retain/release pair. Kind of annoying that RetainPtr messes up ARC optimizations. 1802890 10 440712 darin 2021-10-11 16:50:50 -0700 Comment on attachment 440712 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=440712&action=review > Source/WTF/wtf/RetainPtr.h:224 > + static_assert(!std::is_convertible_v<PtrType, id> && IsTypeComplete<CFTollFreeBridgingTraits<PtrType>>, "bridgingAutorelease() may only be used for toll-free bridged CF types."); The idea behind my saying "base the return type on the type that is bridged" was not to generate compile time errors when we wanted to bridge to just "id". So I’m not sure it’s worth making this change yet. > Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:4134 > - return [protectedSelf nextTextMarkerForCharacterOffset:characterOffset].bridgingAutorelease(); > + return bridge_id_cast([protectedSelf nextTextMarkerForCharacterOffset:characterOffset]); Is this really right? We need autorelease here. Does bridge_id_cast implicitly do an autorelease? > Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:4149 > - return [protectedSelf previousTextMarkerForCharacterOffset:characterOffset].bridgingAutorelease(); > + return bridge_id_cast([protectedSelf previousTextMarkerForCharacterOffset:characterOffset]); Same. 1802906 11 440712 ddkilzer 2021-10-11 17:46:51 -0700 Comment on attachment 440712 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=440712&action=review >> Source/WTF/wtf/RetainPtr.h:224 >> + static_assert(!std::is_convertible_v<PtrType, id> && IsTypeComplete<CFTollFreeBridgingTraits<PtrType>>, "bridgingAutorelease() may only be used for toll-free bridged CF types."); > > The idea behind my saying "base the return type on the type that is bridged" was not to generate compile time errors when we wanted to bridge to just "id". So I’m not sure it’s worth making this change yet. Okay, I'll revert this. We don't have to solve fixing the return type of bridgingAutorelease() before landing the patch, correct? >> Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:4134 >> + return bridge_id_cast([protectedSelf nextTextMarkerForCharacterOffset:characterOffset]); > > Is this really right? We need autorelease here. Does bridge_id_cast implicitly do an autorelease? I'm pretty sure this lambda returns a RetainPtr<id>, so this is way more efficient than autoreleasing it and then re-retaining it, correct? return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainPtr(self)] () -> RetainPtr<id> { Maybe I amI missing something? Is there some unexpected requirement that this be autoreleased before returning it? >> Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:4149 >> + return bridge_id_cast([protectedSelf previousTextMarkerForCharacterOffset:characterOffset]); > > Same. Same: return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainPtr(self)] () -> RetainPtr<id> { 1802908 12 440712 darin 2021-10-11 17:48:45 -0700 Comment on attachment 440712 Patch v2 View in context: https://bugs.webkit.org/attachment.cgi?id=440712&action=review >>> Source/WTF/wtf/RetainPtr.h:224 >>> + static_assert(!std::is_convertible_v<PtrType, id> && IsTypeComplete<CFTollFreeBridgingTraits<PtrType>>, "bridgingAutorelease() may only be used for toll-free bridged CF types."); >> >> The idea behind my saying "base the return type on the type that is bridged" was not to generate compile time errors when we wanted to bridge to just "id". So I’m not sure it’s worth making this change yet. > > Okay, I'll revert this. We don't have to solve fixing the return type of bridgingAutorelease() before landing the patch, correct? That’s right. A separate thought that we can pursue in its own time. >>> Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:4134 >>> + return bridge_id_cast([protectedSelf nextTextMarkerForCharacterOffset:characterOffset]); >> >> Is this really right? We need autorelease here. Does bridge_id_cast implicitly do an autorelease? > > I'm pretty sure this lambda returns a RetainPtr<id>, so this is way more efficient than autoreleasing it and then re-retaining it, correct? > > return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainPtr(self)] () -> RetainPtr<id> { > > Maybe I amI missing something? Is there some unexpected requirement that this be autoreleased before returning it? I did not see retrieveAutoreleasedValueFromMainThread, clearly that’s what does the autorelease. Thanks, my mistake. 1802923 13 440870 ddkilzer 2021-10-11 19:14:19 -0700 Created attachment 440870 Patch for landing 1803126 14 440870 darin 2021-10-12 08:36:29 -0700 Comment on attachment 440870 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=440870&action=review > Source/WTF/wtf/cocoa/TollFreeBridging.h:42 > +template<> struct CFTollFreeBridgingTraits<CFClassName##Ref> { typedef NSClassName *BridgedType; }; \ > +template<> struct NSTollFreeBridgingTraits<NSClassName> { typedef CFClassName##Ref BridgedType; }; Realized that to be more modern we could use "using" instead of typedef here. > Source/WTF/wtf/cocoa/TollFreeBridging.h:60 > +template<> struct CFTollFreeBridgingTraits<CFBooleanRef> { typedef NSNumber *BridgedType; }; Ditto. 1803314 15 440970 ddkilzer 2021-10-12 12:36:27 -0700 Created attachment 440970 Patch for landing v2 1803348 16 440970 ddkilzer 2021-10-12 13:52:30 -0700 Comment on attachment 440970 Patch for landing v2 Marking cq+ since the only changes from "Patch for landing" were to change `typedef` to `using`, which would have appeared as a build failure if they were an issue. 1803428 17 ews-feeder 2021-10-12 14:56:59 -0700 Committed r284038 (242868@main): <https://commits.webkit.org/242868@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 440970. 1831330 18 ddkilzer 2022-01-16 13:46:25 -0800 (In reply to EWS from comment #17) > Committed r284038 (242868@main): <https://commits.webkit.org/242868@main> Follow-up fix to add TollFreeBridging.h to the WTF Xcode project: Committed r288075: <https://commits.webkit.org/r288075> 440693 2021-10-08 17:40:47 -0700 2021-10-09 10:19:48 -0700 Patch v1 bug-231467-20211008174046.patch text/plain 8737 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE4NDgwMmU4NjAzYjY5ZDZiNGYwOWI2 NTQyNjY5ZTQzMTU3ZjQ1N2MuLjg2MmNjNDU1OWJlNTM3ZjkxMDdkNmZmNmU4M2YxYjQzNDdlZWJj MzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMjEtMTAtMDggIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2Ug dHlwZSB0cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdpbmcuaDogQWRk LgorICAgICAgICAoV1RGOjpDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHMpOiBBZGQuCisgICAgICAg IChXVEY6Ok5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0cyk6IEFkZC4KKyAgICAgICAgLSBEZWZpbmUg dHlwZSB0cmFpdHMgZm9yIENGIGFuZCBOUyBjbGFzc2VzIHdpdGggdG9sbC1mcmVlCisgICAgICAg ICAgYnJpZGdpbmcuCisgICAgICAgICogd3RmL2NvY29hL1R5cGVDYXN0c0NvY29hLmg6CisgICAg ICAgIChXVEY6OmJyaWRnZV9jYXN0KToKKyAgICAgICAgLSBNYWtlIHVzZSBvZiB0eXBlIHRyYWl0 cyBpbiBUb2xsRnJlZUJyaWRnaW5nLmguCisKIDIwMjEtMTAtMDUgIERhdmlkIEtpbHplciAgPGRk a2lsemVyQGFwcGxlLmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgIzI6IFdURjo6UmV0YWluUHRy PD4gYWxsb3dzIGFzc2lnbm1lbnQgb2YgdHdvIHBvaW50ZXIgdHlwZXMgdGhhdCBhcmUgbm90IGFz c2lnbmFibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdp bmcuaCBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdpbmcuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li42ZTA2M2E3YTYzMjZlNmRhNzkwMGYxN2FkZjU0OGEwZWNmNTkzMDUxCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oCkBAIC0wLDAgKzEs NzMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAor ICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisg KiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICog Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmZGVmIF9fT0JKQ19fCisjaW1w b3J0IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgorI2ltcG9ydCA8Rm91bmRhdGlv bi9Gb3VuZGF0aW9uLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdURiB7CisKK3RlbXBsYXRlPHR5 cGVuYW1lPiBzdHJ1Y3QgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzOwordGVtcGxhdGU8dHlwZW5h bWU+IHN0cnVjdCBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM7CisKKyNpZmRlZiBfX09CSkNfXwor CisjZGVmaW5lIFdURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZDbGFzc05h bWUsIE5TQ2xhc3NOYW1lKSBcCit0ZW1wbGF0ZTw+IHN0cnVjdCBDRlRvbGxGcmVlQnJpZGdpbmdU cmFpdHM8Q0ZDbGFzc05hbWUjI1JlZj4geyB0eXBlZGVmIE5TQ2xhc3NOYW1lICpCcmlkZ2VkVHlw ZTsgfTsgXAordGVtcGxhdGU8PiBzdHJ1Y3QgTlNUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPE5TQ2xh c3NOYW1lPiB7IHR5cGVkZWYgQ0ZDbGFzc05hbWUjI1JlZiBCcmlkZ2VkVHlwZTsgfTsKKworV1RG X0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkFycmF5LCBOU0FycmF5KQorV1RG X0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkF0dHJpYnV0ZWRTdHJpbmcsIE5T QXR0cmlidXRlZFN0cmluZykKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMo Q0ZDaGFyYWN0ZXJTZXQsIE5TQ2hhcmFjdGVyU2V0KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JS SURHSU5HX1RSQUlUUyhDRkRhdGEsIE5TRGF0YSkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklE R0lOR19UUkFJVFMoQ0ZEYXRlLCBOU0RhdGUpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJ TkdfVFJBSVRTKENGRGljdGlvbmFyeSwgTlNEaWN0aW9uYXJ5KQorV1RGX0RFQ0xBUkVfVE9MTF9G UkVFX0JSSURHSU5HX1RSQUlUUyhDRkVycm9yLCBOU0Vycm9yKQorV1RGX0RFQ0xBUkVfVE9MTF9G UkVFX0JSSURHSU5HX1RSQUlUUyhDRkZpbGVTZWN1cml0eSwgTlNGaWxlU2VjdXJpdHkpCitXVEZf REVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTG9jYWxlLCBOU0xvY2FsZSkKK1dU Rl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZOdWxsLCBOU051bGwpCitXVEZf REVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTnVtYmVyLCBOU051bWJlcikKK1dU Rl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZTZXQsIE5TU2V0KQorV1RGX0RF Q0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRlN0cmluZywgTlNTdHJpbmcpCitXVEZf REVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGVGltZVpvbmUsIE5TVGltZVpvbmUp CitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGVVJMLCBOU1VSTCkKKwor dGVtcGxhdGU8PiBzdHJ1Y3QgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPENGQm9vbGVhblJlZj4g eyB0eXBlZGVmIE5TTnVtYmVyICpCcmlkZ2VkVHlwZTsgfTsKKworV1RGX0RFQ0xBUkVfVE9MTF9G UkVFX0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVBcnJheSwgTlNNdXRhYmxlQXJyYXkpCitXVEZf REVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJsZUF0dHJpYnV0ZWRTdHJp bmcsIE5TTXV0YWJsZUF0dHJpYnV0ZWRTdHJpbmcpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJ REdJTkdfVFJBSVRTKENGTXV0YWJsZURhdGEsIE5TTXV0YWJsZURhdGEpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJsZURpY3Rpb25hcnksIE5TTXV0YWJsZURp Y3Rpb25hcnkpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJs ZVNldCwgTlNNdXRhYmxlU2V0KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlU UyhDRk11dGFibGVTdHJpbmcsIE5TTXV0YWJsZVN0cmluZykKKworI3VuZGVmIFdURl9ERUNMQVJF X1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMKKworI2VuZGlmIC8vIGRlZmluZWQoX19PQkpDX18p CisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2Ev VHlwZUNhc3RzQ29jb2EuaCBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL1R5cGVDYXN0c0NvY29hLmgK aW5kZXggMmJkYzI2YWM3NGJmZDA5ZTBmMjFjZDg1M2ZjNDRmOTY2YjU0ZDI3YS4uZjFmYjBjNThj ZmMwZTVkYmJhOTQyNzBjYjM2M2QyOTVhYjk2ZTExZCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93 dGYvY29jb2EvVHlwZUNhc3RzQ29jb2EuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9UeXBl Q2FzdHNDb2NvYS5oCkBAIC0yNyw2ICsyNyw3IEBACiAKICNpbXBvcnQgPHd0Zi9Bc3NlcnRpb25z Lmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisjaW1wb3J0IDx3dGYvY29jb2EvVG9sbEZy ZWVCcmlkZ2luZy5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIApAQCAtNDAsNTUgKzQxLDI1IEBAIG5h bWVzcGFjZSBXVEYgewogI2RlZmluZSBXVEZfTlNfVE9fQ0ZfQlJJREdFX1RSQU5TRkVSKHR5cGUs IHZhbHVlKSAoKF9fYnJpZGdlIHR5cGUpdmFsdWUpCiAjZW5kaWYKIAotI2RlZmluZSBXVEZfREVD TEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkNsYXNzTmFtZSwgTlNDbGFzc05hbWUpIFwKLWlubGlu ZSBDRkNsYXNzTmFtZSMjUmVmIGJyaWRnZV9jYXN0KE5TQ2xhc3NOYW1lICpvYmplY3QpIFwKLXsg XAotICAgIHJldHVybiAoX19icmlkZ2UgQ0ZDbGFzc05hbWUjI1JlZilvYmplY3Q7IFwKLX0gXAot aW5saW5lIFJldGFpblB0cjxDRkNsYXNzTmFtZSMjUmVmPiBicmlkZ2VfY2FzdChSZXRhaW5QdHI8 TlNDbGFzc05hbWU+JiYgb2JqZWN0KSBcCi17IFwKLSAgICByZXR1cm4gYWRvcHRDRihXVEZfTlNf VE9fQ0ZfQlJJREdFX1RSQU5TRkVSKENGQ2xhc3NOYW1lIyNSZWYsIG9iamVjdC5sZWFrUmVmKCkp KTsgXAotfSBcCi1pbmxpbmUgTlNDbGFzc05hbWUgKmJyaWRnZV9jYXN0KENGQ2xhc3NOYW1lIyNS ZWYgb2JqZWN0KSBcCi17IFwKLSAgICByZXR1cm4gKF9fYnJpZGdlIE5TQ2xhc3NOYW1lICopb2Jq ZWN0OyBcCi19IFwKLWlubGluZSBSZXRhaW5QdHI8TlNDbGFzc05hbWU+IGJyaWRnZV9jYXN0KFJl dGFpblB0cjxDRkNsYXNzTmFtZSMjUmVmPiYmIG9iamVjdCkgXAoteyBcCi0gICAgcmV0dXJuIGFk b3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZFUihOU0NsYXNzTmFtZSAqLCBvYmplY3Qu bGVha1JlZigpKSk7IFwKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSB0eXBlbmFtZSBOU1Rv bGxGcmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90PFQ+Pjo6QnJpZGdlZFR5 cGUgYnJpZGdlX2Nhc3QoVCBvYmplY3QpCit7CisgICAgcmV0dXJuIChfX2JyaWRnZSB0eXBlbmFt ZSBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90PFQ+Pjo6QnJp ZGdlZFR5cGUpb2JqZWN0OwogfQogCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkFy cmF5LCBOU0FycmF5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZBdHRyaWJ1dGVk U3RyaW5nLCBOU0F0dHJpYnV0ZWRTdHJpbmcpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FT VChDRkNoYXJhY3RlclNldCwgTlNDaGFyYWN0ZXJTZXQpCi1XVEZfREVDTEFSRV9DRl9OU19CUklE R0VfQ0FTVChDRkRhdGEsIE5TRGF0YSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENG RGF0ZSwgTlNEYXRlKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZEaWN0aW9uYXJ5 LCBOU0RpY3Rpb25hcnkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkVycm9yLCBO U0Vycm9yKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZGaWxlU2VjdXJpdHksIE5T RmlsZVNlY3VyaXR5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZMb2NhbGUsIE5T TG9jYWxlKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZOdWxsLCBOU051bGwpCi1X VEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk51bWJlciwgTlNOdW1iZXIpCi1XVEZfREVD TEFSRV9DRl9OU19CUklER0VfQ0FTVChDRlNldCwgTlNTZXQpCi1XVEZfREVDTEFSRV9DRl9OU19C UklER0VfQ0FTVChDRlN0cmluZywgTlNTdHJpbmcpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0Vf Q0FTVChDRlRpbWVab25lLCBOU1RpbWVab25lKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NB U1QoQ0ZVUkwsIE5TVVJMKQotCi1pbmxpbmUgTlNOdW1iZXIgKmJyaWRnZV9jYXN0KENGQm9vbGVh blJlZiBvYmplY3QpCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgUmV0YWluUHRyPHR5cGVu YW1lIE5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxzdGQ6OnJlbW92ZV9wb2ludGVyX3Q8VD4+OjpC cmlkZ2VkVHlwZT4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPFQ+JiYgb2JqZWN0KQogewotICAgIHJl dHVybiAoX19icmlkZ2UgTlNOdW1iZXIgKilvYmplY3Q7CisgICAgcmV0dXJuIGFkb3B0Q0YoV1RG X05TX1RPX0NGX0JSSURHRV9UUkFOU0ZFUih0eXBlbmFtZSBOU1RvbGxGcmVlQnJpZGdpbmdUcmFp dHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90PFQ+Pjo6QnJpZGdlZFR5cGUsIG9iamVjdC5sZWFrUmVm KCkpKTsKIH0KLWlubGluZSBSZXRhaW5QdHI8TlNOdW1iZXI+IGJyaWRnZV9jYXN0KFJldGFpblB0 cjxDRkJvb2xlYW5SZWY+JiYgb2JqZWN0KQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUg dHlwZW5hbWUgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPFQ+OjpCcmlkZ2VkVHlwZSBicmlkZ2Vf Y2FzdChUIG9iamVjdCkKIHsKLSAgICByZXR1cm4gYWRvcHROUyhXVEZfQ0ZfVE9fTlNfQlJJREdF X1RSQU5TRkVSKE5TTnVtYmVyICosIG9iamVjdC5sZWFrUmVmKCkpKTsKKyAgICByZXR1cm4gKF9f YnJpZGdlIHR5cGVuYW1lIENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxUPjo6QnJpZGdlZFR5cGUp b2JqZWN0OwogfQogCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk11dGFibGVBcnJh eSwgTlNNdXRhYmxlQXJyYXkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk11dGFi bGVBdHRyaWJ1dGVkU3RyaW5nLCBOU011dGFibGVBdHRyaWJ1dGVkU3RyaW5nKQotV1RGX0RFQ0xB UkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlRGF0YSwgTlNNdXRhYmxlRGF0YSkKLVdURl9E RUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZURpY3Rpb25hcnksIE5TTXV0YWJsZURp Y3Rpb25hcnkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk11dGFibGVTZXQsIE5T TXV0YWJsZVNldCkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZVN0cmlu ZywgTlNNdXRhYmxlU3RyaW5nKQordGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIFJldGFpblB0 cjxzdGQ6OnJlbW92ZV9wb2ludGVyX3Q8dHlwZW5hbWUgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRz PFQ+OjpCcmlkZ2VkVHlwZT4+IGJyaWRnZV9jYXN0KFJldGFpblB0cjxUPiYmIG9iamVjdCkKK3sK KyAgICByZXR1cm4gYWRvcHROUyhXVEZfQ0ZfVE9fTlNfQlJJREdFX1RSQU5TRkVSKHR5cGVuYW1l IENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxUPjo6QnJpZGdlZFR5cGUsIG9iamVjdC5sZWFrUmVm KCkpKTsKK30KIAogLy8gVXNlIGJyaWRnZV9pZF9jYXN0IHRvIGNvbnZlcnQgZnJvbSBDRiAtPiBp ZCB3aXRob3V0IHJlZiBjaHVybi4KIApAQCAtMTAyLDcgKzczLDYgQEAgaW5saW5lIFJldGFpblB0 cjxpZD4gYnJpZGdlX2lkX2Nhc3QoUmV0YWluUHRyPENGVHlwZVJlZj4mJiBvYmplY3QpCiAgICAg cmV0dXJuIGFkb3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZFUihpZCwgb2JqZWN0Lmxl YWtSZWYoKSkpOwogfQogCi0jdW5kZWYgV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QKICN1 bmRlZiBXVEZfTlNfVE9fQ0ZfQlJJREdFX1RSQU5TRkVSCiAjdW5kZWYgV1RGX0NGX1RPX05TX0JS SURHRV9UUkFOU0ZFUgogCg== 440712 2021-10-09 10:19:50 -0700 2021-10-11 17:48:45 -0700 Patch v2 bug-231467-20211009101949.patch text/plain 13762 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE4NDgwMmU4NjAzYjY5ZDZiNGYwOWI2 NTQyNjY5ZTQzMTU3ZjQ1N2MuLmFmMTBmZGE1YTY5OWM5NmQyZmFmNmE4ZDFhMDE1NDJiZDJmNTE5 YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjEtMTAtMDkgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2Ug dHlwZSB0cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogd3RmL1JldGFpblB0ci5oOgorICAgICAgICAoV1RGOjpS ZXRhaW5QdHI8VD46OmJyaWRnaW5nQXV0b3JlbGVhc2UpOgorICAgICAgICAtIENoYW5nZSBzdGF0 aWNfYXNzZXJ0KCkgdG8gYWxsb3cgb25seSBDRiB0eXBlcyB3aXRoIHRvbGwtZnJlZQorICAgICAg ICAgIGJyaWRnaW5nIHRvIGFuIE5TIHR5cGUuCisgICAgICAgICogd3RmL2NvY29hL1RvbGxGcmVl QnJpZGdpbmcuaDogQWRkLgorICAgICAgICAoV1RGOjpDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHMp OiBBZGQuCisgICAgICAgIChXVEY6Ok5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0cyk6IEFkZC4KKyAg ICAgICAgLSBEZWZpbmUgdHlwZSB0cmFpdHMgZm9yIENGIGFuZCBOUyBjbGFzc2VzIHdpdGggdG9s bC1mcmVlCisgICAgICAgICAgYnJpZGdpbmcuCisgICAgICAgICogd3RmL2NvY29hL1R5cGVDYXN0 c0NvY29hLmg6CisgICAgICAgIChXVEY6OmJyaWRnZV9jYXN0KToKKyAgICAgICAgLSBNYWtlIHVz ZSBvZiB0eXBlIHRyYWl0cyBpbiBUb2xsRnJlZUJyaWRnaW5nLmguCisKIDIwMjEtMTAtMDUgIERh dmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgIzI6 IFdURjo6UmV0YWluUHRyPD4gYWxsb3dzIGFzc2lnbm1lbnQgb2YgdHdvIHBvaW50ZXIgdHlwZXMg dGhhdCBhcmUgbm90IGFzc2lnbmFibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBmYjczN2IyNjc3NGUxMzIxZTU1 ZmExMjc4ZTQ0NWMxMDQyMmU0OTFlLi5mMDcxNWI2M2IwMGRhYTFkMjkwYmI2ODY2MTA4MzA0Y2Ix ZmE2MjVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMTAtMDkgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2Vf Y2FzdCB0byB1c2UgdHlwZSB0cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIz MTQ2Nz4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhP YmplY3RDYWNoZU1hYy5tbToKKyAgICAgICAgKFdlYkNvcmU6OmFkZFRleHRNYXJrZXJGb3IpOgor ICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL1dlYkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy TWFjLm1tOgorICAgICAgICAtIENhbGwgYnJpZGdlX2lkX2Nhc3QoKSB3aXRoIENGIHBvaW50ZXIg dG8gcHJldmVudCBhdXRvcmVsZWFzZS4KKyAgICAgICAgKC1bV2ViQWNjZXNzaWJpbGl0eU9iamVj dFdyYXBwZXIgYWNjZXNzaWJpbGl0eUF0dHJpYnV0ZVZhbHVlOmZvclBhcmFtZXRlcjpdKToKKyAg ICAgICAgLSBTd2l0Y2ggZnJvbSBjYWxsaW5nIFJldGFpblB0cjw+OjpicmlkZ2luZ0F1dG9yZWxl YXNlKCkgdG8KKyAgICAgICAgICBicmlkZ2VfaWRfY2FzdChSZXRhaW5QdHI8PiYmKSBzaW5jZSB0 aGlzIHByZXZlbnRzIHRoZSBvYmplY3RzCisgICAgICAgICAgZnJvbSBiZWluZyBhdXRvcmVsZWFz ZWQgYW5kIHByZXZlbnRzIHJldGFpbiBjb3VudCBjaHVybiBzaW5jZQorICAgICAgICAgIHRoZSBs YW1iZGFzIHJldHVybiBSZXRhaW5QdHI8aWQ+LgorCiAyMDIxLTEwLTA1ICBBbnR0aSBLb2l2aXN0 byAgPGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZW1vdmUgbV9hdXRvU2hyaW5rVG9GaXRF bmFibGVkIGZyb20gUnVsZVNldApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUmV0YWluUHRy LmggYi9Tb3VyY2UvV1RGL3d0Zi9SZXRhaW5QdHIuaAppbmRleCBjN2QzODM1ZjczZDdlNDcwYzIx MmQ4YmQ5ZDljMzJjMzNmNjY0YTNhLi40YTNlNTNhYzBiM2IyZWVjN2M2YWU3NzA5MzljMjE3ZGUz ZjgwMTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9SZXRhaW5QdHIuaAorKysgYi9Tb3Vy Y2UvV1RGL3d0Zi9SZXRhaW5QdHIuaApAQCAtMzUsNiArMzUsNyBAQAogCiAjaWZkZWYgX19PQkpD X18KICNpbXBvcnQgPEZvdW5kYXRpb24vRm91bmRhdGlvbi5oPgorI2ltcG9ydCA8d3RmL2NvY29h L1RvbGxGcmVlQnJpZGdpbmcuaD4KICNlbmRpZgogCiAjaWZuZGVmIENGX0JSSURHRURfVFlQRQpA QCAtMjIwLDcgKzIyMSw3IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSBhdXRvIFJldGFp blB0cjxUPjo6YXV0b3JlbGVhc2UoKSAtPiBQdHJUeXBlCiAvLyBGSVhNRTogSXQgd291bGQgYmUg YmV0dGVyIGlmIHdlIGNvdWxkIGJhc2UgdGhlIHJldHVybiB0eXBlIG9uIHRoZSB0eXBlIHRoYXQg aXMgdG9sbC1mcmVlIGJyaWRnZWQgd2l0aCBUIHJhdGhlciB0aGFuIHVzaW5nIGlkLgogdGVtcGxh dGU8dHlwZW5hbWUgVD4gaW5saW5lIGlkIFJldGFpblB0cjxUPjo6YnJpZGdpbmdBdXRvcmVsZWFz ZSgpCiB7Ci0gICAgc3RhdGljX2Fzc2VydCgoIXN0ZDo6aXNfY29udmVydGlibGU8UHRyVHlwZSwg aWQ+Ojp2YWx1ZSksICJEb24ndCB1c2UgYnJpZGdpbmdBdXRvcmVsZWFzZSBmb3IgT2JqZWN0aXZl LUMgcG9pbnRlciB0eXBlcy4iKTsKKyAgICBzdGF0aWNfYXNzZXJ0KCFzdGQ6OmlzX2NvbnZlcnRp YmxlX3Y8UHRyVHlwZSwgaWQ+ICYmIElzVHlwZUNvbXBsZXRlPENGVG9sbEZyZWVCcmlkZ2luZ1Ry YWl0czxQdHJUeXBlPj4sICJicmlkZ2luZ0F1dG9yZWxlYXNlKCkgbWF5IG9ubHkgYmUgdXNlZCBm b3IgdG9sbC1mcmVlIGJyaWRnZWQgQ0YgdHlwZXMuIik7CiAgICAgcmV0dXJuIENGQnJpZGdpbmdS ZWxlYXNlKGxlYWtSZWYoKSk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NvY29h L1RvbGxGcmVlQnJpZGdpbmcuaCBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdp bmcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi42ZTA2M2E3YTYzMjZlNmRhNzkwMGYxN2FkZjU0OGEwZWNmNTkzMDUx Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2lu Zy5oCkBAIC0wLDAgKzEsNzMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjEgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmZGVm IF9fT0JKQ19fCisjaW1wb3J0IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgorI2lt cG9ydCA8Rm91bmRhdGlvbi9Gb3VuZGF0aW9uLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdURiB7 CisKK3RlbXBsYXRlPHR5cGVuYW1lPiBzdHJ1Y3QgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzOwor dGVtcGxhdGU8dHlwZW5hbWU+IHN0cnVjdCBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM7CisKKyNp ZmRlZiBfX09CSkNfXworCisjZGVmaW5lIFdURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19U UkFJVFMoQ0ZDbGFzc05hbWUsIE5TQ2xhc3NOYW1lKSBcCit0ZW1wbGF0ZTw+IHN0cnVjdCBDRlRv bGxGcmVlQnJpZGdpbmdUcmFpdHM8Q0ZDbGFzc05hbWUjI1JlZj4geyB0eXBlZGVmIE5TQ2xhc3NO YW1lICpCcmlkZ2VkVHlwZTsgfTsgXAordGVtcGxhdGU8PiBzdHJ1Y3QgTlNUb2xsRnJlZUJyaWRn aW5nVHJhaXRzPE5TQ2xhc3NOYW1lPiB7IHR5cGVkZWYgQ0ZDbGFzc05hbWUjI1JlZiBCcmlkZ2Vk VHlwZTsgfTsKKworV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkFycmF5 LCBOU0FycmF5KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkF0dHJp YnV0ZWRTdHJpbmcsIE5TQXR0cmlidXRlZFN0cmluZykKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9C UklER0lOR19UUkFJVFMoQ0ZDaGFyYWN0ZXJTZXQsIE5TQ2hhcmFjdGVyU2V0KQorV1RGX0RFQ0xB UkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkRhdGEsIE5TRGF0YSkKK1dURl9ERUNMQVJF X1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZEYXRlLCBOU0RhdGUpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGRGljdGlvbmFyeSwgTlNEaWN0aW9uYXJ5KQorV1RG X0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkVycm9yLCBOU0Vycm9yKQorV1RG X0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkZpbGVTZWN1cml0eSwgTlNGaWxl U2VjdXJpdHkpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTG9jYWxl LCBOU0xvY2FsZSkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZOdWxs LCBOU051bGwpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTnVtYmVy LCBOU051bWJlcikKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZTZXQs IE5TU2V0KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRlN0cmluZywg TlNTdHJpbmcpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGVGltZVpv bmUsIE5TVGltZVpvbmUpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENG VVJMLCBOU1VSTCkKKwordGVtcGxhdGU8PiBzdHJ1Y3QgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRz PENGQm9vbGVhblJlZj4geyB0eXBlZGVmIE5TTnVtYmVyICpCcmlkZ2VkVHlwZTsgfTsKKworV1RG X0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVBcnJheSwgTlNNdXRh YmxlQXJyYXkpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJs ZUF0dHJpYnV0ZWRTdHJpbmcsIE5TTXV0YWJsZUF0dHJpYnV0ZWRTdHJpbmcpCitXVEZfREVDTEFS RV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJsZURhdGEsIE5TTXV0YWJsZURhdGEp CitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJsZURpY3Rpb25h cnksIE5TTXV0YWJsZURpY3Rpb25hcnkpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdf VFJBSVRTKENGTXV0YWJsZVNldCwgTlNNdXRhYmxlU2V0KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVF X0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVTdHJpbmcsIE5TTXV0YWJsZVN0cmluZykKKworI3Vu ZGVmIFdURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMKKworI2VuZGlmIC8vIGRl ZmluZWQoX19PQkpDX18pCisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvY29jb2EvVHlwZUNhc3RzQ29jb2EuaCBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL1R5 cGVDYXN0c0NvY29hLmgKaW5kZXggMmJkYzI2YWM3NGJmZDA5ZTBmMjFjZDg1M2ZjNDRmOTY2YjU0 ZDI3YS4uZjFmYjBjNThjZmMwZTVkYmJhOTQyNzBjYjM2M2QyOTVhYjk2ZTExZCAxMDA2NDQKLS0t IGEvU291cmNlL1dURi93dGYvY29jb2EvVHlwZUNhc3RzQ29jb2EuaAorKysgYi9Tb3VyY2UvV1RG L3d0Zi9jb2NvYS9UeXBlQ2FzdHNDb2NvYS5oCkBAIC0yNyw2ICsyNyw3IEBACiAKICNpbXBvcnQg PHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisjaW1wb3J0IDx3 dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIApAQCAtNDAs NTUgKzQxLDI1IEBAIG5hbWVzcGFjZSBXVEYgewogI2RlZmluZSBXVEZfTlNfVE9fQ0ZfQlJJREdF X1RSQU5TRkVSKHR5cGUsIHZhbHVlKSAoKF9fYnJpZGdlIHR5cGUpdmFsdWUpCiAjZW5kaWYKIAot I2RlZmluZSBXVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkNsYXNzTmFtZSwgTlNDbGFz c05hbWUpIFwKLWlubGluZSBDRkNsYXNzTmFtZSMjUmVmIGJyaWRnZV9jYXN0KE5TQ2xhc3NOYW1l ICpvYmplY3QpIFwKLXsgXAotICAgIHJldHVybiAoX19icmlkZ2UgQ0ZDbGFzc05hbWUjI1JlZilv YmplY3Q7IFwKLX0gXAotaW5saW5lIFJldGFpblB0cjxDRkNsYXNzTmFtZSMjUmVmPiBicmlkZ2Vf Y2FzdChSZXRhaW5QdHI8TlNDbGFzc05hbWU+JiYgb2JqZWN0KSBcCi17IFwKLSAgICByZXR1cm4g YWRvcHRDRihXVEZfTlNfVE9fQ0ZfQlJJREdFX1RSQU5TRkVSKENGQ2xhc3NOYW1lIyNSZWYsIG9i amVjdC5sZWFrUmVmKCkpKTsgXAotfSBcCi1pbmxpbmUgTlNDbGFzc05hbWUgKmJyaWRnZV9jYXN0 KENGQ2xhc3NOYW1lIyNSZWYgb2JqZWN0KSBcCi17IFwKLSAgICByZXR1cm4gKF9fYnJpZGdlIE5T Q2xhc3NOYW1lICopb2JqZWN0OyBcCi19IFwKLWlubGluZSBSZXRhaW5QdHI8TlNDbGFzc05hbWU+ IGJyaWRnZV9jYXN0KFJldGFpblB0cjxDRkNsYXNzTmFtZSMjUmVmPiYmIG9iamVjdCkgXAoteyBc Ci0gICAgcmV0dXJuIGFkb3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZFUihOU0NsYXNz TmFtZSAqLCBvYmplY3QubGVha1JlZigpKSk7IFwKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGlu ZSB0eXBlbmFtZSBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90 PFQ+Pjo6QnJpZGdlZFR5cGUgYnJpZGdlX2Nhc3QoVCBvYmplY3QpCit7CisgICAgcmV0dXJuIChf X2JyaWRnZSB0eXBlbmFtZSBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9p bnRlcl90PFQ+Pjo6QnJpZGdlZFR5cGUpb2JqZWN0OwogfQogCi1XVEZfREVDTEFSRV9DRl9OU19C UklER0VfQ0FTVChDRkFycmF5LCBOU0FycmF5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NB U1QoQ0ZBdHRyaWJ1dGVkU3RyaW5nLCBOU0F0dHJpYnV0ZWRTdHJpbmcpCi1XVEZfREVDTEFSRV9D Rl9OU19CUklER0VfQ0FTVChDRkNoYXJhY3RlclNldCwgTlNDaGFyYWN0ZXJTZXQpCi1XVEZfREVD TEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkRhdGEsIE5TRGF0YSkKLVdURl9ERUNMQVJFX0NGX05T X0JSSURHRV9DQVNUKENGRGF0ZSwgTlNEYXRlKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NB U1QoQ0ZEaWN0aW9uYXJ5LCBOU0RpY3Rpb25hcnkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0Vf Q0FTVChDRkVycm9yLCBOU0Vycm9yKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZG aWxlU2VjdXJpdHksIE5TRmlsZVNlY3VyaXR5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NB U1QoQ0ZMb2NhbGUsIE5TTG9jYWxlKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZO dWxsLCBOU051bGwpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk51bWJlciwgTlNO dW1iZXIpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRlNldCwgTlNTZXQpCi1XVEZf REVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRlN0cmluZywgTlNTdHJpbmcpCi1XVEZfREVDTEFS RV9DRl9OU19CUklER0VfQ0FTVChDRlRpbWVab25lLCBOU1RpbWVab25lKQotV1RGX0RFQ0xBUkVf Q0ZfTlNfQlJJREdFX0NBU1QoQ0ZVUkwsIE5TVVJMKQotCi1pbmxpbmUgTlNOdW1iZXIgKmJyaWRn ZV9jYXN0KENGQm9vbGVhblJlZiBvYmplY3QpCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUg UmV0YWluUHRyPHR5cGVuYW1lIE5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxzdGQ6OnJlbW92ZV9w b2ludGVyX3Q8VD4+OjpCcmlkZ2VkVHlwZT4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPFQ+JiYgb2Jq ZWN0KQogewotICAgIHJldHVybiAoX19icmlkZ2UgTlNOdW1iZXIgKilvYmplY3Q7CisgICAgcmV0 dXJuIGFkb3B0Q0YoV1RGX05TX1RPX0NGX0JSSURHRV9UUkFOU0ZFUih0eXBlbmFtZSBOU1RvbGxG cmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90PFQ+Pjo6QnJpZGdlZFR5cGUs IG9iamVjdC5sZWFrUmVmKCkpKTsKIH0KLWlubGluZSBSZXRhaW5QdHI8TlNOdW1iZXI+IGJyaWRn ZV9jYXN0KFJldGFpblB0cjxDRkJvb2xlYW5SZWY+JiYgb2JqZWN0KQorCit0ZW1wbGF0ZTx0eXBl bmFtZSBUPiBpbmxpbmUgdHlwZW5hbWUgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPFQ+OjpCcmlk Z2VkVHlwZSBicmlkZ2VfY2FzdChUIG9iamVjdCkKIHsKLSAgICByZXR1cm4gYWRvcHROUyhXVEZf Q0ZfVE9fTlNfQlJJREdFX1RSQU5TRkVSKE5TTnVtYmVyICosIG9iamVjdC5sZWFrUmVmKCkpKTsK KyAgICByZXR1cm4gKF9fYnJpZGdlIHR5cGVuYW1lIENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxU Pjo6QnJpZGdlZFR5cGUpb2JqZWN0OwogfQogCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FT VChDRk11dGFibGVBcnJheSwgTlNNdXRhYmxlQXJyYXkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklE R0VfQ0FTVChDRk11dGFibGVBdHRyaWJ1dGVkU3RyaW5nLCBOU011dGFibGVBdHRyaWJ1dGVkU3Ry aW5nKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlRGF0YSwgTlNNdXRh YmxlRGF0YSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZURpY3Rpb25h cnksIE5TTXV0YWJsZURpY3Rpb25hcnkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChD Rk11dGFibGVTZXQsIE5TTXV0YWJsZVNldCkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNU KENGTXV0YWJsZVN0cmluZywgTlNNdXRhYmxlU3RyaW5nKQordGVtcGxhdGU8dHlwZW5hbWUgVD4g aW5saW5lIFJldGFpblB0cjxzdGQ6OnJlbW92ZV9wb2ludGVyX3Q8dHlwZW5hbWUgQ0ZUb2xsRnJl ZUJyaWRnaW5nVHJhaXRzPFQ+OjpCcmlkZ2VkVHlwZT4+IGJyaWRnZV9jYXN0KFJldGFpblB0cjxU PiYmIG9iamVjdCkKK3sKKyAgICByZXR1cm4gYWRvcHROUyhXVEZfQ0ZfVE9fTlNfQlJJREdFX1RS QU5TRkVSKHR5cGVuYW1lIENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxUPjo6QnJpZGdlZFR5cGUs IG9iamVjdC5sZWFrUmVmKCkpKTsKK30KIAogLy8gVXNlIGJyaWRnZV9pZF9jYXN0IHRvIGNvbnZl cnQgZnJvbSBDRiAtPiBpZCB3aXRob3V0IHJlZiBjaHVybi4KIApAQCAtMTAyLDcgKzczLDYgQEAg aW5saW5lIFJldGFpblB0cjxpZD4gYnJpZGdlX2lkX2Nhc3QoUmV0YWluUHRyPENGVHlwZVJlZj4m JiBvYmplY3QpCiAgICAgcmV0dXJuIGFkb3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZF UihpZCwgb2JqZWN0LmxlYWtSZWYoKSkpOwogfQogCi0jdW5kZWYgV1RGX0RFQ0xBUkVfQ0ZfTlNf QlJJREdFX0NBU1QKICN1bmRlZiBXVEZfTlNfVE9fQ0ZfQlJJREdFX1RSQU5TRkVSCiAjdW5kZWYg V1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZFUgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQppbmRleCAwNjNjYmIwMDE1ZmQy ZGI4NDA2Njg1ZjM0YWEzN2RlZWNlM2UzMTM2Li5lNDk1NGNkZjE4MzUwZDAxOTc5Nzk4NDZmYWY2 ODY0ODlkNDEzYTkzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21h Yy9BWE9iamVjdENhY2hlTWFjLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv bWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBvcnQgIldlYkFj Y2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyTWFjLmgiCiAjaW1wb3J0IDxwYWwvc3BpL2NvY29hL05T QWNjZXNzaWJpbGl0eVNQSS5oPgogI2ltcG9ydCA8cGFsL3NwaS9tYWMvSElTZXJ2aWNlc1NQSS5o PgorI2ltcG9ydCA8d3RmL2NvY29hL1R5cGVDYXN0c0NvY29hLmg+CiAKICNpZiBFTkFCTEUoQUND RVNTSUJJTElUWV9JU09MQVRFRF9UUkVFKQogI2ltcG9ydCA8cGFsL3NwaS9jb2NvYS9BY2Nlc3Np YmlsaXR5U3VwcG9ydFNQSS5oPgpAQCAtNDkxLDcgKzQ5Miw3IEBAIHN0YXRpYyB2b2lkIGFkZFRl eHRNYXJrZXJGb3IoTlNNdXRhYmxlRGljdGlvbmFyeSogY2hhbmdlLCBBWENvcmVPYmplY3QmIG9i amVjdCwKIHN0YXRpYyB2b2lkIGFkZFRleHRNYXJrZXJGb3IoTlNNdXRhYmxlRGljdGlvbmFyeSog Y2hhbmdlLCBBWENvcmVPYmplY3QmIG9iamVjdCwgSFRNTFRleHRGb3JtQ29udHJvbEVsZW1lbnQm IHRleHRDb250cm9sKQogewogICAgIGlmIChhdXRvIHRleHRNYXJrZXIgPSBbb2JqZWN0LndyYXBw ZXIoKSB0ZXh0TWFya2VyRm9yRmlyc3RQb3NpdGlvbkluVGV4dENvbnRyb2w6dGV4dENvbnRyb2xd KQotICAgICAgICBbY2hhbmdlIHNldE9iamVjdDp0ZXh0TWFya2VyLmJyaWRnaW5nQXV0b3JlbGVh c2UoKSBmb3JLZXk6TlNBY2Nlc3NpYmlsaXR5VGV4dENoYW5nZVZhbHVlU3RhcnRNYXJrZXJdOwor ICAgICAgICBbY2hhbmdlIHNldE9iamVjdDpicmlkZ2VfaWRfY2FzdCh0ZXh0TWFya2VyLmdldCgp KSBmb3JLZXk6TlNBY2Nlc3NpYmlsaXR5VGV4dENoYW5nZVZhbHVlU3RhcnRNYXJrZXJdOwogfQog CiB0ZW1wbGF0ZSA8dHlwZW5hbWUgVGV4dE1hcmtlclRhcmdldFR5cGU+CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9XZWJBY2Nlc3NpYmlsaXR5T2JqZWN0V3Jh cHBlck1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL1dlYkFjY2Vzc2li aWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tCmluZGV4IGI5YzdmYmQ5OGFjYWMyOGVkMTlkMmY1YTE0 M2UxOTNkNGU5ZjhlYzkuLmYzYWNiYmMyNzE1MDYwOTZlZGQ0MTc0YTBkODQ3NDZjM2VlNTJkMjgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL1dlYkFjY2Vzc2li aWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvbWFjL1dlYkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tCkBAIC03OSw2ICs3OSw3 IEBACiAjaW1wb3J0ICJWaXNpYmxlVW5pdHMuaCIKICNpbXBvcnQgIldlYkNvcmVGcmFtZVZpZXcu aCIKICNpbXBvcnQgPHBhbC9zcGkvY29jb2EvTlNBY2Nlc3NpYmlsaXR5U1BJLmg+CisjaW1wb3J0 IDx3dGYvY29jb2EvVHlwZUNhc3RzQ29jb2EuaD4KICNpbXBvcnQgPHd0Zi9jb2NvYS9WZWN0b3JD b2NvYS5oPgogCiB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKQEAgLTQxMzAsNyArNDEzMSw3IEBA IEFMTE9XX0RFUFJFQ0FURURfSU1QTEVNRU5UQVRJT05TX0VORAogICAgICAgICAgICAgICAgIHJl dHVybiBuaWw7CiAKICAgICAgICAgICAgIENoYXJhY3Rlck9mZnNldCBjaGFyYWN0ZXJPZmZzZXQg PSBjaGFyYWN0ZXJPZmZzZXRGb3JUZXh0TWFya2VyKGNhY2hlLCB0ZXh0TWFya2VyKTsKLSAgICAg ICAgICAgIHJldHVybiBbcHJvdGVjdGVkU2VsZiBuZXh0VGV4dE1hcmtlckZvckNoYXJhY3Rlck9m ZnNldDpjaGFyYWN0ZXJPZmZzZXRdLmJyaWRnaW5nQXV0b3JlbGVhc2UoKTsKKyAgICAgICAgICAg IHJldHVybiBicmlkZ2VfaWRfY2FzdChbcHJvdGVjdGVkU2VsZiBuZXh0VGV4dE1hcmtlckZvckNo YXJhY3Rlck9mZnNldDpjaGFyYWN0ZXJPZmZzZXRdKTsKICAgICAgICAgfSk7CiAgICAgfQogCkBA IC00MTQ1LDcgKzQxNDYsNyBAQCBBTExPV19ERVBSRUNBVEVEX0lNUExFTUVOVEFUSU9OU19FTkQK ICAgICAgICAgICAgICAgICByZXR1cm4gbmlsOwogCiAgICAgICAgICAgICBDaGFyYWN0ZXJPZmZz ZXQgY2hhcmFjdGVyT2Zmc2V0ID0gY2hhcmFjdGVyT2Zmc2V0Rm9yVGV4dE1hcmtlcihjYWNoZSwg dGV4dE1hcmtlcik7Ci0gICAgICAgICAgICByZXR1cm4gW3Byb3RlY3RlZFNlbGYgcHJldmlvdXNU ZXh0TWFya2VyRm9yQ2hhcmFjdGVyT2Zmc2V0OmNoYXJhY3Rlck9mZnNldF0uYnJpZGdpbmdBdXRv cmVsZWFzZSgpOworICAgICAgICAgICAgcmV0dXJuIGJyaWRnZV9pZF9jYXN0KFtwcm90ZWN0ZWRT ZWxmIHByZXZpb3VzVGV4dE1hcmtlckZvckNoYXJhY3Rlck9mZnNldDpjaGFyYWN0ZXJPZmZzZXRd KTsKICAgICAgICAgfSk7CiAgICAgfQogCg== 440870 2021-10-11 19:14:19 -0700 2021-10-12 12:36:50 -0700 Patch for landing bug-231467-20211011191419.patch text/plain 12540 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE4NDgwMmU4NjAzYjY5ZDZiNGYwOWI2 NTQyNjY5ZTQzMTU3ZjQ1N2MuLmI0MDA4ZWQ2YmMwMjY4MTlhOTQ3N2MwZTUyZTg4NjU0ODJkM2E1 ZTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMjEtMTAtMTEgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2Ug dHlwZSB0cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmlu IEFkbGVyLgorCisgICAgICAgICogd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdpbmcuaDogQWRkLgor ICAgICAgICAoV1RGOjpDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHMpOiBBZGQuCisgICAgICAgIChX VEY6Ok5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0cyk6IEFkZC4KKyAgICAgICAgLSBEZWZpbmUgdHlw ZSB0cmFpdHMgZm9yIENGIGFuZCBOUyBjbGFzc2VzIHdpdGggdG9sbC1mcmVlCisgICAgICAgICAg YnJpZGdpbmcuCisgICAgICAgICogd3RmL2NvY29hL1R5cGVDYXN0c0NvY29hLmg6CisgICAgICAg IChXVEY6OmJyaWRnZV9jYXN0KToKKyAgICAgICAgLSBNYWtlIHVzZSBvZiB0eXBlIHRyYWl0cyBp biBUb2xsRnJlZUJyaWRnaW5nLmguCisKIDIwMjEtMTAtMDUgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgIzI6IFdURjo6UmV0YWluUHRyPD4g YWxsb3dzIGFzc2lnbm1lbnQgb2YgdHdvIHBvaW50ZXIgdHlwZXMgdGhhdCBhcmUgbm90IGFzc2ln bmFibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCBmYjczN2IyNjc3NGUxMzIxZTU1ZmExMjc4ZTQ0NWMxMDQyMmU0 OTFlLi45ZTQ2MjNhMzAzNmYyNjA5ZmJlNzU5YjM1MjQ1MDllYjlkZjlhMDUyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMTAtMTEgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFw cGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2UgdHlwZSB0 cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVy LgorCisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbToKKyAg ICAgICAgKFdlYkNvcmU6OmFkZFRleHRNYXJrZXJGb3IpOgorICAgICAgICAqIGFjY2Vzc2liaWxp dHkvbWFjL1dlYkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tOgorICAgICAgICAtIENh bGwgYnJpZGdlX2lkX2Nhc3QoKSB3aXRoIENGIHBvaW50ZXIgdG8gcHJldmVudCBhdXRvcmVsZWFz ZS4KKyAgICAgICAgKC1bV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIgYWNjZXNzaWJpbGl0 eUF0dHJpYnV0ZVZhbHVlOmZvclBhcmFtZXRlcjpdKToKKyAgICAgICAgLSBTd2l0Y2ggZnJvbSBj YWxsaW5nIFJldGFpblB0cjw+OjpicmlkZ2luZ0F1dG9yZWxlYXNlKCkgdG8KKyAgICAgICAgICBi cmlkZ2VfaWRfY2FzdChSZXRhaW5QdHI8PiYmKSBzaW5jZSB0aGlzIHByZXZlbnRzIHRoZSBvYmpl Y3RzCisgICAgICAgICAgZnJvbSBiZWluZyBhdXRvcmVsZWFzZWQgYW5kIHByZXZlbnRzIHJldGFp biBjb3VudCBjaHVybiBzaW5jZQorICAgICAgICAgIHRoZSBsYW1iZGFzIHJldHVybiBSZXRhaW5Q dHI8aWQ+LgorCiAyMDIxLTEwLTA1ICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4K IAogICAgICAgICBSZW1vdmUgbV9hdXRvU2hyaW5rVG9GaXRFbmFibGVkIGZyb20gUnVsZVNldApk aWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oIGIvU291 cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZlMDYzYTdh NjMyNmU2ZGE3OTAwZjE3YWRmNTQ4YTBlY2Y1OTMwNTEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV1RGL3d0Zi9jb2NvYS9Ub2xsRnJlZUJyaWRnaW5nLmgKQEAgLTAsMCArMSw3MyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWZkZWYgX19PQkpDX18KKyNpbXBvcnQgPENvcmVG b3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CisjaW1wb3J0IDxGb3VuZGF0aW9uL0ZvdW5kYXRp b24uaD4KKyNlbmRpZgorCituYW1lc3BhY2UgV1RGIHsKKwordGVtcGxhdGU8dHlwZW5hbWU+IHN0 cnVjdCBDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM7Cit0ZW1wbGF0ZTx0eXBlbmFtZT4gc3RydWN0 IE5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czsKKworI2lmZGVmIF9fT0JKQ19fCisKKyNkZWZpbmUg V1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkNsYXNzTmFtZSwgTlNDbGFz c05hbWUpIFwKK3RlbXBsYXRlPD4gc3RydWN0IENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxDRkNs YXNzTmFtZSMjUmVmPiB7IHR5cGVkZWYgTlNDbGFzc05hbWUgKkJyaWRnZWRUeXBlOyB9OyBcCit0 ZW1wbGF0ZTw+IHN0cnVjdCBOU1RvbGxGcmVlQnJpZGdpbmdUcmFpdHM8TlNDbGFzc05hbWU+IHsg dHlwZWRlZiBDRkNsYXNzTmFtZSMjUmVmIEJyaWRnZWRUeXBlOyB9OworCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGQXJyYXksIE5TQXJyYXkpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGQXR0cmlidXRlZFN0cmluZywgTlNBdHRyaWJ1dGVk U3RyaW5nKQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkNoYXJhY3Rl clNldCwgTlNDaGFyYWN0ZXJTZXQpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJB SVRTKENGRGF0YSwgTlNEYXRhKQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlU UyhDRkRhdGUsIE5TRGF0ZSkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMo Q0ZEaWN0aW9uYXJ5LCBOU0RpY3Rpb25hcnkpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJ TkdfVFJBSVRTKENGRXJyb3IsIE5TRXJyb3IpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJ TkdfVFJBSVRTKENGRmlsZVNlY3VyaXR5LCBOU0ZpbGVTZWN1cml0eSkKK1dURl9ERUNMQVJFX1RP TExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZMb2NhbGUsIE5TTG9jYWxlKQorV1RGX0RFQ0xBUkVf VE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRk51bGwsIE5TTnVsbCkKK1dURl9ERUNMQVJFX1RP TExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZOdW1iZXIsIE5TTnVtYmVyKQorV1RGX0RFQ0xBUkVf VE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRlNldCwgTlNTZXQpCitXVEZfREVDTEFSRV9UT0xM X0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGU3RyaW5nLCBOU1N0cmluZykKK1dURl9ERUNMQVJFX1RP TExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZUaW1lWm9uZSwgTlNUaW1lWm9uZSkKK1dURl9ERUNM QVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZVUkwsIE5TVVJMKQorCit0ZW1wbGF0ZTw+ IHN0cnVjdCBDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM8Q0ZCb29sZWFuUmVmPiB7IHR5cGVkZWYg TlNOdW1iZXIgKkJyaWRnZWRUeXBlOyB9OworCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJ TkdfVFJBSVRTKENGTXV0YWJsZUFycmF5LCBOU011dGFibGVBcnJheSkKK1dURl9ERUNMQVJFX1RP TExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZNdXRhYmxlQXR0cmlidXRlZFN0cmluZywgTlNNdXRh YmxlQXR0cmlidXRlZFN0cmluZykKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJ VFMoQ0ZNdXRhYmxlRGF0YSwgTlNNdXRhYmxlRGF0YSkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9C UklER0lOR19UUkFJVFMoQ0ZNdXRhYmxlRGljdGlvbmFyeSwgTlNNdXRhYmxlRGljdGlvbmFyeSkK K1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZNdXRhYmxlU2V0LCBOU011 dGFibGVTZXQpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTXV0YWJs ZVN0cmluZywgTlNNdXRhYmxlU3RyaW5nKQorCisjdW5kZWYgV1RGX0RFQ0xBUkVfVE9MTF9GUkVF X0JSSURHSU5HX1RSQUlUUworCisjZW5kaWYgLy8gZGVmaW5lZChfX09CSkNfXykKKworfSAvLyBu YW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9UeXBlQ2FzdHND b2NvYS5oIGIvU291cmNlL1dURi93dGYvY29jb2EvVHlwZUNhc3RzQ29jb2EuaAppbmRleCAyYmRj MjZhYzc0YmZkMDllMGYyMWNkODUzZmM0NGY5NjZiNTRkMjdhLi5mMWZiMGM1OGNmYzBlNWRiYmE5 NDI3MGNiMzYzZDI5NWFiOTZlMTFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9U eXBlQ2FzdHNDb2NvYS5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL2NvY29hL1R5cGVDYXN0c0NvY29h LmgKQEAgLTI3LDYgKzI3LDcgQEAKIAogI2ltcG9ydCA8d3RmL0Fzc2VydGlvbnMuaD4KICNpbXBv cnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0Zi9jb2NvYS9Ub2xsRnJlZUJyaWRnaW5n Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCkBAIC00MCw1NSArNDEsMjUgQEAgbmFtZXNwYWNlIFdU RiB7CiAjZGVmaW5lIFdURl9OU19UT19DRl9CUklER0VfVFJBTlNGRVIodHlwZSwgdmFsdWUpICgo X19icmlkZ2UgdHlwZSl2YWx1ZSkKICNlbmRpZgogCi0jZGVmaW5lIFdURl9ERUNMQVJFX0NGX05T X0JSSURHRV9DQVNUKENGQ2xhc3NOYW1lLCBOU0NsYXNzTmFtZSkgXAotaW5saW5lIENGQ2xhc3NO YW1lIyNSZWYgYnJpZGdlX2Nhc3QoTlNDbGFzc05hbWUgKm9iamVjdCkgXAoteyBcCi0gICAgcmV0 dXJuIChfX2JyaWRnZSBDRkNsYXNzTmFtZSMjUmVmKW9iamVjdDsgXAotfSBcCi1pbmxpbmUgUmV0 YWluUHRyPENGQ2xhc3NOYW1lIyNSZWY+IGJyaWRnZV9jYXN0KFJldGFpblB0cjxOU0NsYXNzTmFt ZT4mJiBvYmplY3QpIFwKLXsgXAotICAgIHJldHVybiBhZG9wdENGKFdURl9OU19UT19DRl9CUklE R0VfVFJBTlNGRVIoQ0ZDbGFzc05hbWUjI1JlZiwgb2JqZWN0LmxlYWtSZWYoKSkpOyBcCi19IFwK LWlubGluZSBOU0NsYXNzTmFtZSAqYnJpZGdlX2Nhc3QoQ0ZDbGFzc05hbWUjI1JlZiBvYmplY3Qp IFwKLXsgXAotICAgIHJldHVybiAoX19icmlkZ2UgTlNDbGFzc05hbWUgKilvYmplY3Q7IFwKLX0g XAotaW5saW5lIFJldGFpblB0cjxOU0NsYXNzTmFtZT4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPENG Q2xhc3NOYW1lIyNSZWY+JiYgb2JqZWN0KSBcCi17IFwKLSAgICByZXR1cm4gYWRvcHROUyhXVEZf Q0ZfVE9fTlNfQlJJREdFX1RSQU5TRkVSKE5TQ2xhc3NOYW1lICosIG9iamVjdC5sZWFrUmVmKCkp KTsgXAordGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIHR5cGVuYW1lIE5TVG9sbEZyZWVCcmlk Z2luZ1RyYWl0czxzdGQ6OnJlbW92ZV9wb2ludGVyX3Q8VD4+OjpCcmlkZ2VkVHlwZSBicmlkZ2Vf Y2FzdChUIG9iamVjdCkKK3sKKyAgICByZXR1cm4gKF9fYnJpZGdlIHR5cGVuYW1lIE5TVG9sbEZy ZWVCcmlkZ2luZ1RyYWl0czxzdGQ6OnJlbW92ZV9wb2ludGVyX3Q8VD4+OjpCcmlkZ2VkVHlwZSlv YmplY3Q7CiB9CiAKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGQXJyYXksIE5TQXJy YXkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkF0dHJpYnV0ZWRTdHJpbmcsIE5T QXR0cmlidXRlZFN0cmluZykKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGQ2hhcmFj dGVyU2V0LCBOU0NoYXJhY3RlclNldCkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENG RGF0YSwgTlNEYXRhKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZEYXRlLCBOU0Rh dGUpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkRpY3Rpb25hcnksIE5TRGljdGlv bmFyeSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGRXJyb3IsIE5TRXJyb3IpCi1X VEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkZpbGVTZWN1cml0eSwgTlNGaWxlU2VjdXJp dHkpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkxvY2FsZSwgTlNMb2NhbGUpCi1X VEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk51bGwsIE5TTnVsbCkKLVdURl9ERUNMQVJF X0NGX05TX0JSSURHRV9DQVNUKENGTnVtYmVyLCBOU051bWJlcikKLVdURl9ERUNMQVJFX0NGX05T X0JSSURHRV9DQVNUKENGU2V0LCBOU1NldCkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNU KENGU3RyaW5nLCBOU1N0cmluZykKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGVGlt ZVpvbmUsIE5TVGltZVpvbmUpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRlVSTCwg TlNVUkwpCi0KLWlubGluZSBOU051bWJlciAqYnJpZGdlX2Nhc3QoQ0ZCb29sZWFuUmVmIG9iamVj dCkKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSBSZXRhaW5QdHI8dHlwZW5hbWUgTlNUb2xs RnJlZUJyaWRnaW5nVHJhaXRzPHN0ZDo6cmVtb3ZlX3BvaW50ZXJfdDxUPj46OkJyaWRnZWRUeXBl PiBicmlkZ2VfY2FzdChSZXRhaW5QdHI8VD4mJiBvYmplY3QpCiB7Ci0gICAgcmV0dXJuIChfX2Jy aWRnZSBOU051bWJlciAqKW9iamVjdDsKKyAgICByZXR1cm4gYWRvcHRDRihXVEZfTlNfVE9fQ0Zf QlJJREdFX1RSQU5TRkVSKHR5cGVuYW1lIE5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxzdGQ6OnJl bW92ZV9wb2ludGVyX3Q8VD4+OjpCcmlkZ2VkVHlwZSwgb2JqZWN0LmxlYWtSZWYoKSkpOwogfQot aW5saW5lIFJldGFpblB0cjxOU051bWJlcj4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPENGQm9vbGVh blJlZj4mJiBvYmplY3QpCisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSB0eXBlbmFtZSBD RlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM8VD46OkJyaWRnZWRUeXBlIGJyaWRnZV9jYXN0KFQgb2Jq ZWN0KQogewotICAgIHJldHVybiBhZG9wdE5TKFdURl9DRl9UT19OU19CUklER0VfVFJBTlNGRVIo TlNOdW1iZXIgKiwgb2JqZWN0LmxlYWtSZWYoKSkpOworICAgIHJldHVybiAoX19icmlkZ2UgdHlw ZW5hbWUgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPFQ+OjpCcmlkZ2VkVHlwZSlvYmplY3Q7CiB9 CiAKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZUFycmF5LCBOU011dGFi bGVBcnJheSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZUF0dHJpYnV0 ZWRTdHJpbmcsIE5TTXV0YWJsZUF0dHJpYnV0ZWRTdHJpbmcpCi1XVEZfREVDTEFSRV9DRl9OU19C UklER0VfQ0FTVChDRk11dGFibGVEYXRhLCBOU011dGFibGVEYXRhKQotV1RGX0RFQ0xBUkVfQ0Zf TlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlRGljdGlvbmFyeSwgTlNNdXRhYmxlRGljdGlvbmFyeSkK LVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTXV0YWJsZVNldCwgTlNNdXRhYmxlU2V0 KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlU3RyaW5nLCBOU011dGFi bGVTdHJpbmcpCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgUmV0YWluUHRyPHN0ZDo6cmVt b3ZlX3BvaW50ZXJfdDx0eXBlbmFtZSBDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM8VD46OkJyaWRn ZWRUeXBlPj4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPFQ+JiYgb2JqZWN0KQoreworICAgIHJldHVy biBhZG9wdE5TKFdURl9DRl9UT19OU19CUklER0VfVFJBTlNGRVIodHlwZW5hbWUgQ0ZUb2xsRnJl ZUJyaWRnaW5nVHJhaXRzPFQ+OjpCcmlkZ2VkVHlwZSwgb2JqZWN0LmxlYWtSZWYoKSkpOworfQog CiAvLyBVc2UgYnJpZGdlX2lkX2Nhc3QgdG8gY29udmVydCBmcm9tIENGIC0+IGlkIHdpdGhvdXQg cmVmIGNodXJuLgogCkBAIC0xMDIsNyArNzMsNiBAQCBpbmxpbmUgUmV0YWluUHRyPGlkPiBicmlk Z2VfaWRfY2FzdChSZXRhaW5QdHI8Q0ZUeXBlUmVmPiYmIG9iamVjdCkKICAgICByZXR1cm4gYWRv cHROUyhXVEZfQ0ZfVE9fTlNfQlJJREdFX1RSQU5TRkVSKGlkLCBvYmplY3QubGVha1JlZigpKSk7 CiB9CiAKLSN1bmRlZiBXVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVAogI3VuZGVmIFdURl9O U19UT19DRl9CUklER0VfVFJBTlNGRVIKICN1bmRlZiBXVEZfQ0ZfVE9fTlNfQlJJREdFX1RSQU5T RkVSCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2Jq ZWN0Q2FjaGVNYWMubW0gYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVj dENhY2hlTWFjLm1tCmluZGV4IDA2M2NiYjAwMTVmZDJkYjg0MDY2ODVmMzRhYTM3ZGVlY2UzZTMx MzYuLmU0OTU0Y2RmMTgzNTBkMDE5Nzk3OTg0NmZhZjY4NjQ4OWQ0MTNhOTMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KKysr IGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQpA QCAtMzYsNiArMzYsNyBAQAogI2ltcG9ydCAiV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJN YWMuaCIKICNpbXBvcnQgPHBhbC9zcGkvY29jb2EvTlNBY2Nlc3NpYmlsaXR5U1BJLmg+CiAjaW1w b3J0IDxwYWwvc3BpL21hYy9ISVNlcnZpY2VzU1BJLmg+CisjaW1wb3J0IDx3dGYvY29jb2EvVHlw ZUNhc3RzQ29jb2EuaD4KIAogI2lmIEVOQUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUp CiAjaW1wb3J0IDxwYWwvc3BpL2NvY29hL0FjY2Vzc2liaWxpdHlTdXBwb3J0U1BJLmg+CkBAIC00 OTEsNyArNDkyLDcgQEAgc3RhdGljIHZvaWQgYWRkVGV4dE1hcmtlckZvcihOU011dGFibGVEaWN0 aW9uYXJ5KiBjaGFuZ2UsIEFYQ29yZU9iamVjdCYgb2JqZWN0LAogc3RhdGljIHZvaWQgYWRkVGV4 dE1hcmtlckZvcihOU011dGFibGVEaWN0aW9uYXJ5KiBjaGFuZ2UsIEFYQ29yZU9iamVjdCYgb2Jq ZWN0LCBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudCYgdGV4dENvbnRyb2wpCiB7CiAgICAgaWYg KGF1dG8gdGV4dE1hcmtlciA9IFtvYmplY3Qud3JhcHBlcigpIHRleHRNYXJrZXJGb3JGaXJzdFBv c2l0aW9uSW5UZXh0Q29udHJvbDp0ZXh0Q29udHJvbF0pCi0gICAgICAgIFtjaGFuZ2Ugc2V0T2Jq ZWN0OnRleHRNYXJrZXIuYnJpZGdpbmdBdXRvcmVsZWFzZSgpIGZvcktleTpOU0FjY2Vzc2liaWxp dHlUZXh0Q2hhbmdlVmFsdWVTdGFydE1hcmtlcl07CisgICAgICAgIFtjaGFuZ2Ugc2V0T2JqZWN0 OmJyaWRnZV9pZF9jYXN0KHRleHRNYXJrZXIuZ2V0KCkpIGZvcktleTpOU0FjY2Vzc2liaWxpdHlU ZXh0Q2hhbmdlVmFsdWVTdGFydE1hcmtlcl07CiB9CiAKIHRlbXBsYXRlIDx0eXBlbmFtZSBUZXh0 TWFya2VyVGFyZ2V0VHlwZT4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvbWFjL1dlYkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tIGIvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9tYWMvV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJNYWMubW0K aW5kZXggYjljN2ZiZDk4YWNhYzI4ZWQxOWQyZjVhMTQzZTE5M2Q0ZTlmOGVjOS4uZjNhY2JiYzI3 MTUwNjA5NmVkZDQxNzRhMGQ4NDc0NmMzZWU1MmQyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9tYWMvV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJNYWMubW0K KysrIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvV2ViQWNjZXNzaWJpbGl0eU9i amVjdFdyYXBwZXJNYWMubW0KQEAgLTc5LDYgKzc5LDcgQEAKICNpbXBvcnQgIlZpc2libGVVbml0 cy5oIgogI2ltcG9ydCAiV2ViQ29yZUZyYW1lVmlldy5oIgogI2ltcG9ydCA8cGFsL3NwaS9jb2Nv YS9OU0FjY2Vzc2liaWxpdHlTUEkuaD4KKyNpbXBvcnQgPHd0Zi9jb2NvYS9UeXBlQ2FzdHNDb2Nv YS5oPgogI2ltcG9ydCA8d3RmL2NvY29hL1ZlY3RvckNvY29hLmg+CiAKIHVzaW5nIG5hbWVzcGFj ZSBXZWJDb3JlOwpAQCAtNDEzMCw3ICs0MTMxLDcgQEAgQUxMT1dfREVQUkVDQVRFRF9JTVBMRU1F TlRBVElPTlNfRU5ECiAgICAgICAgICAgICAgICAgcmV0dXJuIG5pbDsKIAogICAgICAgICAgICAg Q2hhcmFjdGVyT2Zmc2V0IGNoYXJhY3Rlck9mZnNldCA9IGNoYXJhY3Rlck9mZnNldEZvclRleHRN YXJrZXIoY2FjaGUsIHRleHRNYXJrZXIpOwotICAgICAgICAgICAgcmV0dXJuIFtwcm90ZWN0ZWRT ZWxmIG5leHRUZXh0TWFya2VyRm9yQ2hhcmFjdGVyT2Zmc2V0OmNoYXJhY3Rlck9mZnNldF0uYnJp ZGdpbmdBdXRvcmVsZWFzZSgpOworICAgICAgICAgICAgcmV0dXJuIGJyaWRnZV9pZF9jYXN0KFtw cm90ZWN0ZWRTZWxmIG5leHRUZXh0TWFya2VyRm9yQ2hhcmFjdGVyT2Zmc2V0OmNoYXJhY3Rlck9m ZnNldF0pOwogICAgICAgICB9KTsKICAgICB9CiAKQEAgLTQxNDUsNyArNDE0Niw3IEBAIEFMTE9X X0RFUFJFQ0FURURfSU1QTEVNRU5UQVRJT05TX0VORAogICAgICAgICAgICAgICAgIHJldHVybiBu aWw7CiAKICAgICAgICAgICAgIENoYXJhY3Rlck9mZnNldCBjaGFyYWN0ZXJPZmZzZXQgPSBjaGFy YWN0ZXJPZmZzZXRGb3JUZXh0TWFya2VyKGNhY2hlLCB0ZXh0TWFya2VyKTsKLSAgICAgICAgICAg IHJldHVybiBbcHJvdGVjdGVkU2VsZiBwcmV2aW91c1RleHRNYXJrZXJGb3JDaGFyYWN0ZXJPZmZz ZXQ6Y2hhcmFjdGVyT2Zmc2V0XS5icmlkZ2luZ0F1dG9yZWxlYXNlKCk7CisgICAgICAgICAgICBy ZXR1cm4gYnJpZGdlX2lkX2Nhc3QoW3Byb3RlY3RlZFNlbGYgcHJldmlvdXNUZXh0TWFya2VyRm9y Q2hhcmFjdGVyT2Zmc2V0OmNoYXJhY3Rlck9mZnNldF0pOwogICAgICAgICB9KTsKICAgICB9CiAK 440970 2021-10-12 12:36:27 -0700 2021-10-12 14:57:01 -0700 Patch for landing v2 bug-231467-20211012123626.patch text/plain 12542 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE4NDgwMmU4NjAzYjY5ZDZiNGYwOWI2 NTQyNjY5ZTQzMTU3ZjQ1N2MuLmI0MDA4ZWQ2YmMwMjY4MTlhOTQ3N2MwZTUyZTg4NjU0ODJkM2E1 ZTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMjEtMTAtMTEgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2Ug dHlwZSB0cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmlu IEFkbGVyLgorCisgICAgICAgICogd3RmL2NvY29hL1RvbGxGcmVlQnJpZGdpbmcuaDogQWRkLgor ICAgICAgICAoV1RGOjpDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHMpOiBBZGQuCisgICAgICAgIChX VEY6Ok5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0cyk6IEFkZC4KKyAgICAgICAgLSBEZWZpbmUgdHlw ZSB0cmFpdHMgZm9yIENGIGFuZCBOUyBjbGFzc2VzIHdpdGggdG9sbC1mcmVlCisgICAgICAgICAg YnJpZGdpbmcuCisgICAgICAgICogd3RmL2NvY29hL1R5cGVDYXN0c0NvY29hLmg6CisgICAgICAg IChXVEY6OmJyaWRnZV9jYXN0KToKKyAgICAgICAgLSBNYWtlIHVzZSBvZiB0eXBlIHRyYWl0cyBp biBUb2xsRnJlZUJyaWRnaW5nLmguCisKIDIwMjEtMTAtMDUgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgIzI6IFdURjo6UmV0YWluUHRyPD4g YWxsb3dzIGFzc2lnbm1lbnQgb2YgdHdvIHBvaW50ZXIgdHlwZXMgdGhhdCBhcmUgbm90IGFzc2ln bmFibGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCBmYjczN2IyNjc3NGUxMzIxZTU1ZmExMjc4ZTQ0NWMxMDQyMmU0 OTFlLi45ZTQ2MjNhMzAzNmYyNjA5ZmJlNzU5YjM1MjQ1MDllYjlkZjlhMDUyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMTAtMTEgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFw cGxlLmNvbT4KKworICAgICAgICBTd2l0Y2ggV1RGOjpicmlkZ2VfY2FzdCB0byB1c2UgdHlwZSB0 cmFpdHMKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9iLzIzMTQ2Nz4KKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzg0MDUwNjE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVy LgorCisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbToKKyAg ICAgICAgKFdlYkNvcmU6OmFkZFRleHRNYXJrZXJGb3IpOgorICAgICAgICAqIGFjY2Vzc2liaWxp dHkvbWFjL1dlYkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyTWFjLm1tOgorICAgICAgICAtIENh bGwgYnJpZGdlX2lkX2Nhc3QoKSB3aXRoIENGIHBvaW50ZXIgdG8gcHJldmVudCBhdXRvcmVsZWFz ZS4KKyAgICAgICAgKC1bV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXIgYWNjZXNzaWJpbGl0 eUF0dHJpYnV0ZVZhbHVlOmZvclBhcmFtZXRlcjpdKToKKyAgICAgICAgLSBTd2l0Y2ggZnJvbSBj YWxsaW5nIFJldGFpblB0cjw+OjpicmlkZ2luZ0F1dG9yZWxlYXNlKCkgdG8KKyAgICAgICAgICBi cmlkZ2VfaWRfY2FzdChSZXRhaW5QdHI8PiYmKSBzaW5jZSB0aGlzIHByZXZlbnRzIHRoZSBvYmpl Y3RzCisgICAgICAgICAgZnJvbSBiZWluZyBhdXRvcmVsZWFzZWQgYW5kIHByZXZlbnRzIHJldGFp biBjb3VudCBjaHVybiBzaW5jZQorICAgICAgICAgIHRoZSBsYW1iZGFzIHJldHVybiBSZXRhaW5Q dHI8aWQ+LgorCiAyMDIxLTEwLTA1ICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4K IAogICAgICAgICBSZW1vdmUgbV9hdXRvU2hyaW5rVG9GaXRFbmFibGVkIGZyb20gUnVsZVNldApk aWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oIGIvU291 cmNlL1dURi93dGYvY29jb2EvVG9sbEZyZWVCcmlkZ2luZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhjNDUyZDhh NDlkMTQ5NTBiZTFlOTJiZjU1ZjA1M2IzOTk2YzVkMWMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV1RGL3d0Zi9jb2NvYS9Ub2xsRnJlZUJyaWRnaW5nLmgKQEAgLTAsMCArMSw3MyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWZkZWYgX19PQkpDX18KKyNpbXBvcnQgPENvcmVG b3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CisjaW1wb3J0IDxGb3VuZGF0aW9uL0ZvdW5kYXRp b24uaD4KKyNlbmRpZgorCituYW1lc3BhY2UgV1RGIHsKKwordGVtcGxhdGU8dHlwZW5hbWU+IHN0 cnVjdCBDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM7Cit0ZW1wbGF0ZTx0eXBlbmFtZT4gc3RydWN0 IE5TVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czsKKworI2lmZGVmIF9fT0JKQ19fCisKKyNkZWZpbmUg V1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkNsYXNzTmFtZSwgTlNDbGFz c05hbWUpIFwKK3RlbXBsYXRlPD4gc3RydWN0IENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxDRkNs YXNzTmFtZSMjUmVmPiB7IHVzaW5nIEJyaWRnZWRUeXBlID0gTlNDbGFzc05hbWUgKjsgfTsgXAor dGVtcGxhdGU8PiBzdHJ1Y3QgTlNUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPE5TQ2xhc3NOYW1lPiB7 IHVzaW5nIEJyaWRnZWRUeXBlID0gQ0ZDbGFzc05hbWUjI1JlZjsgfTsKKworV1RGX0RFQ0xBUkVf VE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkFycmF5LCBOU0FycmF5KQorV1RGX0RFQ0xBUkVf VE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRkF0dHJpYnV0ZWRTdHJpbmcsIE5TQXR0cmlidXRl ZFN0cmluZykKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZDaGFyYWN0 ZXJTZXQsIE5TQ2hhcmFjdGVyU2V0KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RS QUlUUyhDRkRhdGEsIE5TRGF0YSkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJ VFMoQ0ZEYXRlLCBOU0RhdGUpCitXVEZfREVDTEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRT KENGRGljdGlvbmFyeSwgTlNEaWN0aW9uYXJ5KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURH SU5HX1RSQUlUUyhDRkVycm9yLCBOU0Vycm9yKQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURH SU5HX1RSQUlUUyhDRkZpbGVTZWN1cml0eSwgTlNGaWxlU2VjdXJpdHkpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTG9jYWxlLCBOU0xvY2FsZSkKK1dURl9ERUNMQVJF X1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZOdWxsLCBOU051bGwpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGTnVtYmVyLCBOU051bWJlcikKK1dURl9ERUNMQVJF X1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZTZXQsIE5TU2V0KQorV1RGX0RFQ0xBUkVfVE9M TF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRlN0cmluZywgTlNTdHJpbmcpCitXVEZfREVDTEFSRV9U T0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGVGltZVpvbmUsIE5TVGltZVpvbmUpCitXVEZfREVD TEFSRV9UT0xMX0ZSRUVfQlJJREdJTkdfVFJBSVRTKENGVVJMLCBOU1VSTCkKKwordGVtcGxhdGU8 PiBzdHJ1Y3QgQ0ZUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPENGQm9vbGVhblJlZj4geyB1c2luZyBC cmlkZ2VkVHlwZSA9IE5TTnVtYmVyICo7IH07CisKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklE R0lOR19UUkFJVFMoQ0ZNdXRhYmxlQXJyYXksIE5TTXV0YWJsZUFycmF5KQorV1RGX0RFQ0xBUkVf VE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVBdHRyaWJ1dGVkU3RyaW5nLCBOU011 dGFibGVBdHRyaWJ1dGVkU3RyaW5nKQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RS QUlUUyhDRk11dGFibGVEYXRhLCBOU011dGFibGVEYXRhKQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVF X0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVEaWN0aW9uYXJ5LCBOU011dGFibGVEaWN0aW9uYXJ5 KQorV1RGX0RFQ0xBUkVfVE9MTF9GUkVFX0JSSURHSU5HX1RSQUlUUyhDRk11dGFibGVTZXQsIE5T TXV0YWJsZVNldCkKK1dURl9ERUNMQVJFX1RPTExfRlJFRV9CUklER0lOR19UUkFJVFMoQ0ZNdXRh YmxlU3RyaW5nLCBOU011dGFibGVTdHJpbmcpCisKKyN1bmRlZiBXVEZfREVDTEFSRV9UT0xMX0ZS RUVfQlJJREdJTkdfVFJBSVRTCisKKyNlbmRpZiAvLyBkZWZpbmVkKF9fT0JKQ19fKQorCit9IC8v IG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2NvY29hL1R5cGVDYXN0 c0NvY29hLmggYi9Tb3VyY2UvV1RGL3d0Zi9jb2NvYS9UeXBlQ2FzdHNDb2NvYS5oCmluZGV4IDJi ZGMyNmFjNzRiZmQwOWUwZjIxY2Q4NTNmYzQ0Zjk2NmI1NGQyN2EuLmYxZmIwYzU4Y2ZjMGU1ZGJi YTk0MjcwY2IzNjNkMjk1YWI5NmUxMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2NvY29h L1R5cGVDYXN0c0NvY29hLmgKKysrIGIvU291cmNlL1dURi93dGYvY29jb2EvVHlwZUNhc3RzQ29j b2EuaApAQCAtMjcsNiArMjcsNyBAQAogCiAjaW1wb3J0IDx3dGYvQXNzZXJ0aW9ucy5oPgogI2lt cG9ydCA8d3RmL1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL2NvY29hL1RvbGxGcmVlQnJpZGdp bmcuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKQEAgLTQwLDU1ICs0MSwyNSBAQCBuYW1lc3BhY2Ug V1RGIHsKICNkZWZpbmUgV1RGX05TX1RPX0NGX0JSSURHRV9UUkFOU0ZFUih0eXBlLCB2YWx1ZSkg KChfX2JyaWRnZSB0eXBlKXZhbHVlKQogI2VuZGlmCiAKLSNkZWZpbmUgV1RGX0RFQ0xBUkVfQ0Zf TlNfQlJJREdFX0NBU1QoQ0ZDbGFzc05hbWUsIE5TQ2xhc3NOYW1lKSBcCi1pbmxpbmUgQ0ZDbGFz c05hbWUjI1JlZiBicmlkZ2VfY2FzdChOU0NsYXNzTmFtZSAqb2JqZWN0KSBcCi17IFwKLSAgICBy ZXR1cm4gKF9fYnJpZGdlIENGQ2xhc3NOYW1lIyNSZWYpb2JqZWN0OyBcCi19IFwKLWlubGluZSBS ZXRhaW5QdHI8Q0ZDbGFzc05hbWUjI1JlZj4gYnJpZGdlX2Nhc3QoUmV0YWluUHRyPE5TQ2xhc3NO YW1lPiYmIG9iamVjdCkgXAoteyBcCi0gICAgcmV0dXJuIGFkb3B0Q0YoV1RGX05TX1RPX0NGX0JS SURHRV9UUkFOU0ZFUihDRkNsYXNzTmFtZSMjUmVmLCBvYmplY3QubGVha1JlZigpKSk7IFwKLX0g XAotaW5saW5lIE5TQ2xhc3NOYW1lICpicmlkZ2VfY2FzdChDRkNsYXNzTmFtZSMjUmVmIG9iamVj dCkgXAoteyBcCi0gICAgcmV0dXJuIChfX2JyaWRnZSBOU0NsYXNzTmFtZSAqKW9iamVjdDsgXAot fSBcCi1pbmxpbmUgUmV0YWluUHRyPE5TQ2xhc3NOYW1lPiBicmlkZ2VfY2FzdChSZXRhaW5QdHI8 Q0ZDbGFzc05hbWUjI1JlZj4mJiBvYmplY3QpIFwKLXsgXAotICAgIHJldHVybiBhZG9wdE5TKFdU Rl9DRl9UT19OU19CUklER0VfVFJBTlNGRVIoTlNDbGFzc05hbWUgKiwgb2JqZWN0LmxlYWtSZWYo KSkpOyBcCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgdHlwZW5hbWUgTlNUb2xsRnJlZUJy aWRnaW5nVHJhaXRzPHN0ZDo6cmVtb3ZlX3BvaW50ZXJfdDxUPj46OkJyaWRnZWRUeXBlIGJyaWRn ZV9jYXN0KFQgb2JqZWN0KQoreworICAgIHJldHVybiAoX19icmlkZ2UgdHlwZW5hbWUgTlNUb2xs RnJlZUJyaWRnaW5nVHJhaXRzPHN0ZDo6cmVtb3ZlX3BvaW50ZXJfdDxUPj46OkJyaWRnZWRUeXBl KW9iamVjdDsKIH0KIAotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZBcnJheSwgTlNB cnJheSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGQXR0cmlidXRlZFN0cmluZywg TlNBdHRyaWJ1dGVkU3RyaW5nKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZDaGFy YWN0ZXJTZXQsIE5TQ2hhcmFjdGVyU2V0KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1Qo Q0ZEYXRhLCBOU0RhdGEpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRkRhdGUsIE5T RGF0ZSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGRGljdGlvbmFyeSwgTlNEaWN0 aW9uYXJ5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZFcnJvciwgTlNFcnJvcikK LVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGRmlsZVNlY3VyaXR5LCBOU0ZpbGVTZWN1 cml0eSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTG9jYWxlLCBOU0xvY2FsZSkK LVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGTnVsbCwgTlNOdWxsKQotV1RGX0RFQ0xB UkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZOdW1iZXIsIE5TTnVtYmVyKQotV1RGX0RFQ0xBUkVfQ0Zf TlNfQlJJREdFX0NBU1QoQ0ZTZXQsIE5TU2V0KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NB U1QoQ0ZTdHJpbmcsIE5TU3RyaW5nKQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZU aW1lWm9uZSwgTlNUaW1lWm9uZSkKLVdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUKENGVVJM LCBOU1VSTCkKLQotaW5saW5lIE5TTnVtYmVyICpicmlkZ2VfY2FzdChDRkJvb2xlYW5SZWYgb2Jq ZWN0KQordGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIFJldGFpblB0cjx0eXBlbmFtZSBOU1Rv bGxGcmVlQnJpZGdpbmdUcmFpdHM8c3RkOjpyZW1vdmVfcG9pbnRlcl90PFQ+Pjo6QnJpZGdlZFR5 cGU+IGJyaWRnZV9jYXN0KFJldGFpblB0cjxUPiYmIG9iamVjdCkKIHsKLSAgICByZXR1cm4gKF9f YnJpZGdlIE5TTnVtYmVyICopb2JqZWN0OworICAgIHJldHVybiBhZG9wdENGKFdURl9OU19UT19D Rl9CUklER0VfVFJBTlNGRVIodHlwZW5hbWUgTlNUb2xsRnJlZUJyaWRnaW5nVHJhaXRzPHN0ZDo6 cmVtb3ZlX3BvaW50ZXJfdDxUPj46OkJyaWRnZWRUeXBlLCBvYmplY3QubGVha1JlZigpKSk7CiB9 Ci1pbmxpbmUgUmV0YWluUHRyPE5TTnVtYmVyPiBicmlkZ2VfY2FzdChSZXRhaW5QdHI8Q0ZCb29s ZWFuUmVmPiYmIG9iamVjdCkKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIHR5cGVuYW1l IENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxUPjo6QnJpZGdlZFR5cGUgYnJpZGdlX2Nhc3QoVCBv YmplY3QpCiB7Ci0gICAgcmV0dXJuIGFkb3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZF UihOU051bWJlciAqLCBvYmplY3QubGVha1JlZigpKSk7CisgICAgcmV0dXJuIChfX2JyaWRnZSB0 eXBlbmFtZSBDRlRvbGxGcmVlQnJpZGdpbmdUcmFpdHM8VD46OkJyaWRnZWRUeXBlKW9iamVjdDsK IH0KIAotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlQXJyYXksIE5TTXV0 YWJsZUFycmF5KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlQXR0cmli dXRlZFN0cmluZywgTlNNdXRhYmxlQXR0cmlidXRlZFN0cmluZykKLVdURl9ERUNMQVJFX0NGX05T X0JSSURHRV9DQVNUKENGTXV0YWJsZURhdGEsIE5TTXV0YWJsZURhdGEpCi1XVEZfREVDTEFSRV9D Rl9OU19CUklER0VfQ0FTVChDRk11dGFibGVEaWN0aW9uYXJ5LCBOU011dGFibGVEaWN0aW9uYXJ5 KQotV1RGX0RFQ0xBUkVfQ0ZfTlNfQlJJREdFX0NBU1QoQ0ZNdXRhYmxlU2V0LCBOU011dGFibGVT ZXQpCi1XVEZfREVDTEFSRV9DRl9OU19CUklER0VfQ0FTVChDRk11dGFibGVTdHJpbmcsIE5TTXV0 YWJsZVN0cmluZykKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSBSZXRhaW5QdHI8c3RkOjpy ZW1vdmVfcG9pbnRlcl90PHR5cGVuYW1lIENGVG9sbEZyZWVCcmlkZ2luZ1RyYWl0czxUPjo6QnJp ZGdlZFR5cGU+PiBicmlkZ2VfY2FzdChSZXRhaW5QdHI8VD4mJiBvYmplY3QpCit7CisgICAgcmV0 dXJuIGFkb3B0TlMoV1RGX0NGX1RPX05TX0JSSURHRV9UUkFOU0ZFUih0eXBlbmFtZSBDRlRvbGxG cmVlQnJpZGdpbmdUcmFpdHM8VD46OkJyaWRnZWRUeXBlLCBvYmplY3QubGVha1JlZigpKSk7Cit9 CiAKIC8vIFVzZSBicmlkZ2VfaWRfY2FzdCB0byBjb252ZXJ0IGZyb20gQ0YgLT4gaWQgd2l0aG91 dCByZWYgY2h1cm4uCiAKQEAgLTEwMiw3ICs3Myw2IEBAIGlubGluZSBSZXRhaW5QdHI8aWQ+IGJy aWRnZV9pZF9jYXN0KFJldGFpblB0cjxDRlR5cGVSZWY+JiYgb2JqZWN0KQogICAgIHJldHVybiBh ZG9wdE5TKFdURl9DRl9UT19OU19CUklER0VfVFJBTlNGRVIoaWQsIG9iamVjdC5sZWFrUmVmKCkp KTsKIH0KIAotI3VuZGVmIFdURl9ERUNMQVJFX0NGX05TX0JSSURHRV9DQVNUCiAjdW5kZWYgV1RG X05TX1RPX0NGX0JSSURHRV9UUkFOU0ZFUgogI3VuZGVmIFdURl9DRl9UT19OU19CUklER0VfVFJB TlNGRVIKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhP YmplY3RDYWNoZU1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2Jq ZWN0Q2FjaGVNYWMubW0KaW5kZXggMDYzY2JiMDAxNWZkMmRiODQwNjY4NWYzNGFhMzdkZWVjZTNl MzEzNi4uZTQ5NTRjZGYxODM1MGQwMTk3OTc5ODQ2ZmFmNjg2NDg5ZDQxM2E5MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQor KysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1t CkBAIC0zNiw2ICszNiw3IEBACiAjaW1wb3J0ICJXZWJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBl ck1hYy5oIgogI2ltcG9ydCA8cGFsL3NwaS9jb2NvYS9OU0FjY2Vzc2liaWxpdHlTUEkuaD4KICNp bXBvcnQgPHBhbC9zcGkvbWFjL0hJU2VydmljZXNTUEkuaD4KKyNpbXBvcnQgPHd0Zi9jb2NvYS9U eXBlQ2FzdHNDb2NvYS5oPgogCiAjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURfVFJF RSkKICNpbXBvcnQgPHBhbC9zcGkvY29jb2EvQWNjZXNzaWJpbGl0eVN1cHBvcnRTUEkuaD4KQEAg LTQ5MSw3ICs0OTIsNyBAQCBzdGF0aWMgdm9pZCBhZGRUZXh0TWFya2VyRm9yKE5TTXV0YWJsZURp Y3Rpb25hcnkqIGNoYW5nZSwgQVhDb3JlT2JqZWN0JiBvYmplY3QsCiBzdGF0aWMgdm9pZCBhZGRU ZXh0TWFya2VyRm9yKE5TTXV0YWJsZURpY3Rpb25hcnkqIGNoYW5nZSwgQVhDb3JlT2JqZWN0JiBv YmplY3QsIEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50JiB0ZXh0Q29udHJvbCkKIHsKICAgICBp ZiAoYXV0byB0ZXh0TWFya2VyID0gW29iamVjdC53cmFwcGVyKCkgdGV4dE1hcmtlckZvckZpcnN0 UG9zaXRpb25JblRleHRDb250cm9sOnRleHRDb250cm9sXSkKLSAgICAgICAgW2NoYW5nZSBzZXRP YmplY3Q6dGV4dE1hcmtlci5icmlkZ2luZ0F1dG9yZWxlYXNlKCkgZm9yS2V5Ok5TQWNjZXNzaWJp bGl0eVRleHRDaGFuZ2VWYWx1ZVN0YXJ0TWFya2VyXTsKKyAgICAgICAgW2NoYW5nZSBzZXRPYmpl Y3Q6YnJpZGdlX2lkX2Nhc3QodGV4dE1hcmtlci5nZXQoKSkgZm9yS2V5Ok5TQWNjZXNzaWJpbGl0 eVRleHRDaGFuZ2VWYWx1ZVN0YXJ0TWFya2VyXTsKIH0KIAogdGVtcGxhdGUgPHR5cGVuYW1lIFRl eHRNYXJrZXJUYXJnZXRUeXBlPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9tYWMvV2ViQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJNYWMubW0gYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L21hYy9XZWJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlck1hYy5t bQppbmRleCBiOWM3ZmJkOThhY2FjMjhlZDE5ZDJmNWExNDNlMTkzZDRlOWY4ZWM5Li5mM2FjYmJj MjcxNTA2MDk2ZWRkNDE3NGEwZDg0NzQ2YzNlZTUyZDI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L21hYy9XZWJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlck1hYy5t bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9XZWJBY2Nlc3NpYmlsaXR5 T2JqZWN0V3JhcHBlck1hYy5tbQpAQCAtNzksNiArNzksNyBAQAogI2ltcG9ydCAiVmlzaWJsZVVu aXRzLmgiCiAjaW1wb3J0ICJXZWJDb3JlRnJhbWVWaWV3LmgiCiAjaW1wb3J0IDxwYWwvc3BpL2Nv Y29hL05TQWNjZXNzaWJpbGl0eVNQSS5oPgorI2ltcG9ydCA8d3RmL2NvY29hL1R5cGVDYXN0c0Nv Y29hLmg+CiAjaW1wb3J0IDx3dGYvY29jb2EvVmVjdG9yQ29jb2EuaD4KIAogdXNpbmcgbmFtZXNw YWNlIFdlYkNvcmU7CkBAIC00MTMwLDcgKzQxMzEsNyBAQCBBTExPV19ERVBSRUNBVEVEX0lNUExF TUVOVEFUSU9OU19FTkQKICAgICAgICAgICAgICAgICByZXR1cm4gbmlsOwogCiAgICAgICAgICAg ICBDaGFyYWN0ZXJPZmZzZXQgY2hhcmFjdGVyT2Zmc2V0ID0gY2hhcmFjdGVyT2Zmc2V0Rm9yVGV4 dE1hcmtlcihjYWNoZSwgdGV4dE1hcmtlcik7Ci0gICAgICAgICAgICByZXR1cm4gW3Byb3RlY3Rl ZFNlbGYgbmV4dFRleHRNYXJrZXJGb3JDaGFyYWN0ZXJPZmZzZXQ6Y2hhcmFjdGVyT2Zmc2V0XS5i cmlkZ2luZ0F1dG9yZWxlYXNlKCk7CisgICAgICAgICAgICByZXR1cm4gYnJpZGdlX2lkX2Nhc3Qo W3Byb3RlY3RlZFNlbGYgbmV4dFRleHRNYXJrZXJGb3JDaGFyYWN0ZXJPZmZzZXQ6Y2hhcmFjdGVy T2Zmc2V0XSk7CiAgICAgICAgIH0pOwogICAgIH0KIApAQCAtNDE0NSw3ICs0MTQ2LDcgQEAgQUxM T1dfREVQUkVDQVRFRF9JTVBMRU1FTlRBVElPTlNfRU5ECiAgICAgICAgICAgICAgICAgcmV0dXJu IG5pbDsKIAogICAgICAgICAgICAgQ2hhcmFjdGVyT2Zmc2V0IGNoYXJhY3Rlck9mZnNldCA9IGNo YXJhY3Rlck9mZnNldEZvclRleHRNYXJrZXIoY2FjaGUsIHRleHRNYXJrZXIpOwotICAgICAgICAg ICAgcmV0dXJuIFtwcm90ZWN0ZWRTZWxmIHByZXZpb3VzVGV4dE1hcmtlckZvckNoYXJhY3Rlck9m ZnNldDpjaGFyYWN0ZXJPZmZzZXRdLmJyaWRnaW5nQXV0b3JlbGVhc2UoKTsKKyAgICAgICAgICAg IHJldHVybiBicmlkZ2VfaWRfY2FzdChbcHJvdGVjdGVkU2VsZiBwcmV2aW91c1RleHRNYXJrZXJG b3JDaGFyYWN0ZXJPZmZzZXQ6Y2hhcmFjdGVyT2Zmc2V0XSk7CiAgICAgICAgIH0pOwogICAgIH0K IAo=