229590 2021-08-26 15:14:53 -0700 Add prompt for Permissions API 2023-07-25 17:30:28 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified NEW InRadar P2 Normal --- 229339 229504 1 sihui_liu sihui_liu achristensen beidson cdumez eric.carlson esprehn+autocc ews-watchlist ggaren glenn jer.noble k4gcybex kondapallykalyan marcosc philipj sergio webkit-bug-importer youennf oldest_to_newest 1787826 0 sihui_liu 2021-08-26 15:14:53 -0700 ... 1789814 1 437178 sihui_liu 2021-09-02 11:59:49 -0700 Created attachment 437178 Patch 1789815 2 webkit-bug-importer 2021-09-02 12:00:53 -0700 <rdar://problem/82686948> 1790228 3 437178 youennf 2021-09-03 10:15:29 -0700 Comment on attachment 437178 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437178&action=review > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:163 > +- (void)_webView:(WKWebView *)webView requestPermissionForName:(NSString *)permissionName origin:(WKSecurityOrigin *)origin decisionHandler:(void (^)(BOOL granted))decisionHandler WK_API_AVAILABLE(macos(12.0), ios(15.0)); Should we use similar approach as capture delegates: Something like: requestPermissionForName:(NSString *)name origin:(WKSecurityOrigin *)origin initiatedByFrame:(WKFrameInfo *)frame decisionHandler:(void (^)(WKPermissionDecision decision))decisionHandler 1790248 4 437286 sihui_liu 2021-09-03 11:10:18 -0700 Created attachment 437286 Patch 1790250 5 sihui_liu 2021-09-03 11:16:43 -0700 (In reply to youenn fablet from comment #3) > Comment on attachment 437178 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=437178&action=review > > > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:163 > > +- (void)_webView:(WKWebView *)webView requestPermissionForName:(NSString *)permissionName origin:(WKSecurityOrigin *)origin decisionHandler:(void (^)(BOOL granted))decisionHandler WK_API_AVAILABLE(macos(12.0), ios(15.0)); > > Should we use similar approach as capture delegates: > Something like: > requestPermissionForName:(NSString *)name origin:(WKSecurityOrigin *)origin > initiatedByFrame:(WKFrameInfo *)frame decisionHandler:(void > (^)(WKPermissionDecision decision))decisionHandler Updated! 1790251 6 437286 cdumez 2021-09-03 11:24:36 -0700 Comment on attachment 437286 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437286&action=review > Source/WebCore/Modules/permissions/PermissionName.h:49 > +inline ASCIILiteral permissionNameToString(PermissionName name) What are these strings used for? Are they meant to be displayed? If so, I don't think things like "BackgroundFetch" or "DisplayCapture" is displayable. If they are no meant to be displayed, then we are we using strings and not an enum? > Source/WebCore/Modules/permissions/PermissionName.h:73 > + return "Nfc"_s; Should probably be "NFC". > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:163 > +- (void)_webView:(WKWebView *)webView requestPermissionForName:(NSString *)permissionName origin:(WKSecurityOrigin *)origin topOrigin:(WKSecurityOrigin *)topOrigin decisionHandler:(void (^)(WKPermissionDecision decision))decisionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA)); Why are we using a NSString* instead of an enum type for the permission name? > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1702 > + WTF::String nameString = permissionNameToString(name); auto > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1704 > + [delegate _webView:m_uiDelegate->m_webView.get().get() requestPermissionForName:nameString origin:wrapper(apiOrigin) topOrigin:wrapper(apiTopOrigin) decisionHandler:makeBlockPtr([completionHandler = std::exchange(completionHandler, { }), checker = WTFMove(checker), page = makeWeakPtr(page), name, originData = origin.data()] (WKPermissionDecision decision) mutable { std::exchange(completionHandler) -> WTFMove(completionHandler) > Source/WebKit/UIProcess/WebPageProxy.cpp:8511 > + auto permissionsState = granted ? PermissionState::Granted : PermissionState::Denied; This local variable is not necessary. 1790257 7 sihui_liu 2021-09-03 11:34:22 -0700 (In reply to Chris Dumez from comment #6) > Comment on attachment 437286 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=437286&action=review > > > Source/WebCore/Modules/permissions/PermissionName.h:49 > > +inline ASCIILiteral permissionNameToString(PermissionName name) > > What are these strings used for? Are they meant to be displayed? If so, I > don't think things like "BackgroundFetch" or "DisplayCapture" is displayable. > > If they are no meant to be displayed, then we are we using strings and not > an enum? I am not sure how API client will want to handle this, so I just simply convert to string. > > > Source/WebCore/Modules/permissions/PermissionName.h:73 > > + return "Nfc"_s; > > Should probably be "NFC". Will change. > > > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:163 > > +- (void)_webView:(WKWebView *)webView requestPermissionForName:(NSString *)permissionName origin:(WKSecurityOrigin *)origin topOrigin:(WKSecurityOrigin *)topOrigin decisionHandler:(void (^)(WKPermissionDecision decision))decisionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA)); > > Why are we using a NSString* instead of an enum type for the permission name? I am not sure how API client will want to handle this, so I just simply convert to string. We can convert to enum I guess. > > > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1702 > > + WTF::String nameString = permissionNameToString(name); > > auto This returns ASCIILiteral, still need to convert to WTF::String for below. > > > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1704 > > + [delegate _webView:m_uiDelegate->m_webView.get().get() requestPermissionForName:nameString origin:wrapper(apiOrigin) topOrigin:wrapper(apiTopOrigin) decisionHandler:makeBlockPtr([completionHandler = std::exchange(completionHandler, { }), checker = WTFMove(checker), page = makeWeakPtr(page), name, originData = origin.data()] (WKPermissionDecision decision) mutable { > > std::exchange(completionHandler) -> WTFMove(completionHandler) Will change. > > > Source/WebKit/UIProcess/WebPageProxy.cpp:8511 > > + auto permissionsState = granted ? PermissionState::Granted : PermissionState::Denied; > > This local variable is not necessary. Will remove. 1790290 8 437295 sihui_liu 2021-09-03 12:35:56 -0700 Created attachment 437295 Patch 1790378 9 437295 youennf 2021-09-03 14:46:19 -0700 Comment on attachment 437295 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437295&action=review > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:104 > + _WKPermissionNameSpeakerSelection I am not sure we should enumerate permissions that we do not plan to implement (BT or midi for instance). We should probably start with the core set we actually want to support and that have existing delegates (capture, device orientation, geolocation). In the future, we might need to extend this list as new APIs are created and added to the spec. > Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:179 > +- (void)_webView:(WKWebView *)webView requestPermissionForName:(_WKPermissionName)name origin:(WKSecurityOrigin *)origin topOrigin:(WKSecurityOrigin *)topOrigin decisionHandler:(void (^)(WKPermissionDecision decision))decisionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA)); I would rename it to queryPermissionForName. > Source/WebKit/UIProcess/Cocoa/UIDelegate.h:178 > + void requestPermission(WebPageProxy&, const WebCore::SecurityOrigin&, const WebCore::SecurityOrigin&, WebCore::PermissionName, CompletionHandler<void(bool)>&&) final; I would have completion handler take a permission state as input instead of a bool. > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1720 > +void UIDelegate::UIClient::requestPermission(WebKit::WebPageProxy& page, const WebCore::SecurityOrigin& origin, const WebCore::SecurityOrigin& topOrigin, WebCore::PermissionName name, CompletionHandler<void(bool granted)>&& completionHandler) I would rename requestPermission to queryPermission or queryPermissionState. This method is not about actually asking the user for permission. It is to know the existing permission value shown in Safari Preferences -> Websites tab. > Source/WebKit/UIProcess/Cocoa/UIDelegate.mm:1744 > + return page->requestPermissionByDefaultAction(originData, name, WTFMove(completionHandler)); By updating completion handler to take prompt/grant/deny as input, we could simplify this code. We should just return Prompt here. > Source/WebKit/UIProcess/Cocoa/WebPageProxyCocoa.mm:760 > + alertForPermission(*this, *reason, origin, WTFMove(completionHandler)); Ah I see, so maybe I am misunderstanding this patch. My understanding is that we are trying to implement Permissions.query. I do not think Permissions.query should trigger any prompt to the user. But maybe we are trying to achieve something else here. 1790559 10 437295 sihui_liu 2021-09-05 12:13:50 -0700 Comment on attachment 437295 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437295&action=review >> Source/WebKit/UIProcess/API/Cocoa/WKUIDelegatePrivate.h:104 >> + _WKPermissionNameSpeakerSelection > > I am not sure we should enumerate permissions that we do not plan to implement (BT or midi for instance). > We should probably start with the core set we actually want to support and that have existing delegates (capture, device orientation, geolocation). > In the future, we might need to extend this list as new APIs are created and added to the spec. Okay, I will keep what we have now. >> Source/WebKit/UIProcess/Cocoa/WebPageProxyCocoa.mm:760 >> + alertForPermission(*this, *reason, origin, WTFMove(completionHandler)); > > Ah I see, so maybe I am misunderstanding this patch. > My understanding is that we are trying to implement Permissions.query. > I do not think Permissions.query should trigger any prompt to the user. > But maybe we are trying to achieve something else here. For current implementation (https://trac.webkit.org/changeset/281771/webkit), web process does not send message to UI process for querying permission (if permission state is not in cache it will return "prompt"). It only sends message about requesting permission, and the reply from UI process must be either "granted" or "denied". Web process will cache the decision. This patch is about showing a prompt to user when permission is requested. We can add a message for querying permission (not showing prompt). 1790572 11 437366 sihui_liu 2021-09-05 14:28:47 -0700 Created attachment 437366 Patch 1790600 12 437377 sihui_liu 2021-09-05 20:38:18 -0700 Created attachment 437377 Patch 1790612 13 437386 sihui_liu 2021-09-05 23:07:56 -0700 Created attachment 437386 Patch 1790886 14 youennf 2021-09-07 00:55:49 -0700 > This patch is about showing a prompt to user when permission is requested. > We can add a message for querying permission (not showing prompt). We already have specific delegates to ask for permission (getUserMedia, device orientation, geolocation). The generic delegate would be somehow redundant with these. If we add this generic delegate, what is the plan for the existing delegates? The alternative to a generic prompt permission would be to add new permission delegates for the APIs we do care. Specific delegates have some benefits over a catch-them-all generic one: - default behavior if delegate is not implemented - passing some input/receiving some parameters in addition to grant/deny. 1791061 15 sihui_liu 2021-09-07 09:41:30 -0700 (In reply to youenn fablet from comment #14) > > This patch is about showing a prompt to user when permission is requested. > > We can add a message for querying permission (not showing prompt). > > We already have specific delegates to ask for permission (getUserMedia, > device orientation, geolocation). > The generic delegate would be somehow redundant with these. > If we add this generic delegate, what is the plan for the existing delegates? We may just remove existing delegates. Before we remove them, if existing delegate is set, I think we can prefer existing delegate over generic delegate when making a decision. For new features (or old features with new permissions), we may just use the generic delegate. > > The alternative to a generic prompt permission would be to add new > permission delegates for the APIs we do care. Specific delegates have some > benefits over a catch-them-all generic one: > - default behavior if delegate is not implemented > - passing some input/receiving some parameters in addition to grant/deny. There are many features (and permissions) according to the PermissionName enum in spec, which means we could add many new delegates, and clients need to make corresponding change when we add a new delegate (e.g. in the case where clients have a general policy to grant/deny all cross-origin requests). It may also be confusing since delegates don't have the same naming pattern: e.g. we have shouldAllowDeviceOrientationAndMotionAccess and decidePolicyForNotificationPermissionRequest. As for passing some input/receiving some parameters other than grant and deny, can you give an example? Do you mean we may want to give more information to client other than origins? 1791085 16 youennf 2021-09-07 10:17:25 -0700 (In reply to Sihui Liu from comment #15) > (In reply to youenn fablet from comment #14) > > > This patch is about showing a prompt to user when permission is requested. > > > We can add a message for querying permission (not showing prompt). > > > > We already have specific delegates to ask for permission (getUserMedia, > > device orientation, geolocation). > > The generic delegate would be somehow redundant with these. > > If we add this generic delegate, what is the plan for the existing delegates? > > We may just remove existing delegates. Before we remove them, if existing > delegate is set, I think we can prefer existing delegate over generic > delegate when making a decision. Some delegates (getUserMedia, device orientations) are WKUIDelegate API. > For new features (or old features with new permissions), we may just use the > generic delegate. > > > > > The alternative to a generic prompt permission would be to add new > > permission delegates for the APIs we do care. Specific delegates have some > > benefits over a catch-them-all generic one: > > - default behavior if delegate is not implemented > > - passing some input/receiving some parameters in addition to grant/deny. > > There are many features (and permissions) according to the PermissionName > enum in spec, which means we could add many new delegates, and clients need > to make corresponding change when we add a new delegate (e.g. in the case We want to provide good defaults, which is easy with specific delegates. A developer only has to implement a specific delegate if it does not like the default behavior for that particular permission. With a generic delegate, developer has to make a choice for all permissions when implementing the delegate so it is harder. If we add a new permission enum value with the generic delegate, it is unclear whether the application delegate existing logic will handle the new permission well or not, the developer has to think about this. > where clients have a general policy to grant/deny all cross-origin > requests). Cross-origin requests should only get to the delegate if the top level origin agreed to let the cross-origin iframe to call the API in its name. In practice, top-level origin is what should be used, I do not think most developers will actually check the cross-origin iframe. > It may also be confusing since delegates don't have the same > naming pattern: e.g. we have shouldAllowDeviceOrientationAndMotionAccess and > decidePolicyForNotificationPermissionRequest. The API delegates are named requestMediaCapturePermissionForOrigin and requestDeviceOrientationAndMotionPermissionForOrigin. > As for passing some input/receiving some parameters other than grant and > deny, can you give an example? Do you mean we may want to give more > information to client other than origins? For getUserMedia, we are asking for either camera, microphone or camera+microphone in a single delegate call. For geolocation, we may want to have a return parameter that allows the application to set the desired accuracy (needs to decide whether we go there or not). For getDisplayMedia, we may want to allow an application to do the prompt, in which case, the application might need to give us a display ID as an additional return parameter (API plan remains to be done here, maybe we will consider grant=prompt). For speaker selection, we may also want an audio route ID as additional return parameter (API plan remains to be done here). 1791306 17 sihui_liu 2021-09-07 18:36:52 -0700 (In reply to youenn fablet from comment #16) > (In reply to Sihui Liu from comment #15) > > (In reply to youenn fablet from comment #14) > > > > This patch is about showing a prompt to user when permission is requested. > > > > We can add a message for querying permission (not showing prompt). > > > > > > We already have specific delegates to ask for permission (getUserMedia, > > > device orientation, geolocation). > > > The generic delegate would be somehow redundant with these. > > > If we add this generic delegate, what is the plan for the existing delegates? > > > > We may just remove existing delegates. Before we remove them, if existing > > delegate is set, I think we can prefer existing delegate over generic > > delegate when making a decision. > > Some delegates (getUserMedia, device orientations) are WKUIDelegate API. What's the issue? The new delegate is a WKUIDelegatePrivate so we may check the old delegate in UIDelegate.mm? > > > For new features (or old features with new permissions), we may just use the > > generic delegate. > > > > > > > > The alternative to a generic prompt permission would be to add new > > > permission delegates for the APIs we do care. Specific delegates have some > > > benefits over a catch-them-all generic one: > > > - default behavior if delegate is not implemented > > > - passing some input/receiving some parameters in addition to grant/deny. > > > > There are many features (and permissions) according to the PermissionName > > enum in spec, which means we could add many new delegates, and clients need > > to make corresponding change when we add a new delegate (e.g. in the case > > We want to provide good defaults, which is easy with specific delegates. > A developer only has to implement a specific delegate if it does not like > the default behavior for that particular permission. > With a generic delegate, developer has to make a choice for all permissions > when implementing the delegate so it is harder. > If we add a new permission enum value with the generic delegate, it is > unclear whether the application delegate existing logic will handle the new > permission well or not, the developer has to think about this. ah, we can make the callback take a WKPermissionDecision just like requestMediaCapturePermissionForOrigin. Then it should be easy for the developer to make the transition. They can pick "Prompt" for all permissions they don't care and it will give them the same default behavior. > > > where clients have a general policy to grant/deny all cross-origin > > requests). > > Cross-origin requests should only get to the delegate if the top level > origin agreed to let the cross-origin iframe to call the API in its name. > In practice, top-level origin is what should be used, I do not think most > developers will actually check the cross-origin iframe. oh I thought we give frame info to the delegate because client may want to check if it's cross-origin. My point is we can provide a way to allow and deny many permissions at a time. > > > It may also be confusing since delegates don't have the same > > naming pattern: e.g. we have shouldAllowDeviceOrientationAndMotionAccess and > > decidePolicyForNotificationPermissionRequest. > > The API delegates are named requestMediaCapturePermissionForOrigin and > requestDeviceOrientationAndMotionPermissionForOrigin. hmmm I was looking at WKPageUIClient... it seems we still have some confusing permission delegates in WKUIDelegate and WKUIDelegatePrivate, e.g. requestMediaCapturePermissionForOrigin, checkUserMediaPermissionForURL, requestGeolocationPermissionForFrame, requestGeolocationPermissionForOrigin... > > > As for passing some input/receiving some parameters other than grant and > > deny, can you give an example? Do you mean we may want to give more > > information to client other than origins? > > For getUserMedia, we are asking for either camera, microphone or > camera+microphone in a single delegate call. > For geolocation, we may want to have a return parameter that allows the > application to set the desired accuracy (needs to decide whether we go there > or not). > For getDisplayMedia, we may want to allow an application to do the prompt, > in which case, the application might need to give us a display ID as an > additional return parameter (API plan remains to be done here, maybe we will > consider grant=prompt). > For speaker selection, we may also want an audio route ID as additional > return parameter (API plan remains to be done here). Permissions spec has some proposal for adding more description about the permission, like https://w3c.github.io/permissions/#dfn-extra-permission-data-type and https://w3c.github.io/permissions/#aspects. For the generic delegate, we may provide a dictionary of extra permission data in the future, which will be align with the permissions spec. The completion handler of the delegate may also take a dictionary of extra permission constraints (We may convert it to a new PermissionDescriptor and compare it with input descriptor using partial order https://w3c.github.io/permissions/#dfn-permission-descriptor-type). I think the generic delegate will be similar to permissions.query(), which is designed for use of different features. If some feature is not applicable (like camera+microphone case), we can use a special delegate for that (or turn it into a special permission). We can gradually integrate the existing features with Permissions API and the new delegate. If we think some existing delegate is better, we can remove the feature from _WKPermissionName, so requestPermissionForName will only be used by certain features. 1791396 18 youennf 2021-09-08 00:35:08 -0700 > What's the issue? The new delegate is a WKUIDelegatePrivate so we may check > the old delegate in UIDelegate.mm? I think the idea is at some point to promote this delegate to API, in which case we then have two APIs for roughly the same thing. I think it would be good to get some discussions with others on whether we would be able to ship this form of delegates as API. > ah, we can make the callback take a WKPermissionDecision just like > requestMediaCapturePermissionForOrigin. Then it should be easy for the > developer to make the transition. They can pick "Prompt" for all permissions > they don't care and it will give them the same default behavior. That is true if the default behavior is 'Prompt'. For the cases I know of, this is probably fine, but I am unsure whether that it will be the case for all permissions in the future. > > > It may also be confusing since delegates don't have the same > > > naming pattern: e.g. we have shouldAllowDeviceOrientationAndMotionAccess and > > > decidePolicyForNotificationPermissionRequest. > > > > The API delegates are named requestMediaCapturePermissionForOrigin and > > requestDeviceOrientationAndMotionPermissionForOrigin. > > hmmm I was looking at WKPageUIClient... it seems we still have some > confusing permission delegates in WKUIDelegate and WKUIDelegatePrivate, e.g. > requestMediaCapturePermissionForOrigin, checkUserMediaPermissionForURL, > requestGeolocationPermissionForFrame, > requestGeolocationPermissionForOrigin... Right, we need to remove them once we are able to do so. > Permissions spec has some proposal for adding more description about the > permission, like > https://w3c.github.io/permissions/#dfn-extra-permission-data-type and > https://w3c.github.io/permissions/#aspects. For the generic delegate, we may > provide a dictionary of extra permission data in the future, which will be > align with the permissions spec. Right, I am not sure whether we want the delegate API to be modelled around permissions spec especially since we already have API delegates that have been exposed and given the uncertainty with regards to handling additional input/output parameters. I believe this permission model is used in Chrome/Android so this might be feasible but it seems we should discuss this further. If the short term goal is to implement permission API, the permission API does not need a prompt since it is only about querying, not requesting a permission. If the short term goal is to add support for a particular prompt (storage persistency maybe?), this can be done with an ad-hoc delegate for now. Related to the patch, I would also note that we do not want to always have a straight WebPage -> WebPageProxy -> Delegate code path. In the case of device orientation and getUserMedia for instance, we first want to check for cached decisions, as well as TCC checks, before actually calling the delegate. This is currently permission-specific code. In the case of getUserMedia, we are doing other stuff in UIProcess at the same time as treating the getUserMedia permission request. 1967959 19 k4gcybex 2023-07-24 18:32:12 -0700 Under which circumstances will this prompt not show? Calling `getUserMedia()` on macOS 12.6.8 (with WKWebView) shows neither on Mac or iPhone simulator but does show on native Safari browser. 1968140 20 eric.carlson 2023-07-25 16:14:31 -0700 (In reply to bearman from comment #19) > Under which circumstances will this prompt not show? > > Calling `getUserMedia()` on macOS 12.6.8 (with WKWebView) shows neither on > Mac or iPhone simulator but does show on native Safari browser. WebKit won't prompt the user unless the application has the usual entitlements (com.apple.security.device.camera and com.apple.security.device.audio-input) and plist keys (NSCameraUsageDescription and NSMicrophoneUsageDescription) required for capture. 1968162 21 eric.carlson 2023-07-25 17:08:38 -0700 (In reply to Eric Carlson from comment #20) > (In reply to bearman from comment #19) > > Under which circumstances will this prompt not show? > > > > Calling `getUserMedia()` on macOS 12.6.8 (with WKWebView) shows neither on > > Mac or iPhone simulator but does show on native Safari browser. > > WebKit won't prompt the user unless the application has the usual > entitlements (com.apple.security.device.camera and > com.apple.security.device.audio-input) and plist keys > (NSCameraUsageDescription and NSMicrophoneUsageDescription) required for > capture. Does your application have the necessary entitlements and info.plist keys? 1968166 22 k4gcybex 2023-07-25 17:18:21 -0700 (In reply to Eric Carlson from comment #20) > (In reply to bearman from comment #19) > > Under which circumstances will this prompt not show? > > > > Calling `getUserMedia()` on macOS 12.6.8 (with WKWebView) shows neither on > > Mac or iPhone simulator but does show on native Safari browser. > > WebKit won't prompt the user unless the application has the usual > entitlements (com.apple.security.device.camera and > com.apple.security.device.audio-input) and plist keys > (NSCameraUsageDescription and NSMicrophoneUsageDescription) required for > capture. Wonderful, I've got an MCVe where this does not occur: https://github.com/cybex-dev/WKWebView. Please let me know if this prompts for you (anyone) or not. Desc: A simple swift app, evaluating `enumerateDevices()` and `getUserMedia()`. Target: macOS with Hardened Runtime permissions (and associated plist keys): Camera & Microphone). `getUserMedia()` hangs, `enumerateDevices` throws > WKWebView[60215:1070748] [plugin] AddInstanceForFactory: No factory registered for id <CFUUID 0x600000266820> F8BB1C28-BAE8-11D6-9C31-00039315CD46 > WKWebView[60215:1070748] saved enable noise cancellation setting is the same as the default (=1) (3 duplicates) > WKWebView[60215:1070703] HALC_ShellObject::GetPropertyData: call to the proxy failed, Error: 1852797029 (nope) > WKWebView[60215:1070703] HALPlugIn::ObjectGetPropertyData: got an error from the plug-in routine, Error: 1852797029 (nope) (several duplicates) 1968169 23 k4gcybex 2023-07-25 17:19:49 -0700 (In reply to Eric Carlson from comment #21) > (In reply to Eric Carlson from comment #20) > > (In reply to bearman from comment #19) > > > Under which circumstances will this prompt not show? > > > > > > Calling `getUserMedia()` on macOS 12.6.8 (with WKWebView) shows neither on > > > Mac or iPhone simulator but does show on native Safari browser. > > > > WebKit won't prompt the user unless the application has the usual > > entitlements (com.apple.security.device.camera and > > com.apple.security.device.audio-input) and plist keys > > (NSCameraUsageDescription and NSMicrophoneUsageDescription) required for > > capture. > > Does your application have the necessary entitlements and info.plist keys? Indeed, both: - plist keys (https://github.com/cybex-dev/WKWebView/blob/main/WKWebView/WKWebView/Info.plist), and - Hardend Runtime perms (https://github.com/cybex-dev/WKWebView/blob/main/WKWebView/WKWebView/WKWebView.entitlements) 1968170 24 k4gcybex 2023-07-25 17:30:28 -0700 If this helps, please review this (1:18 with timestamps) of the issue. Run w/ XCode. https://youtu.be/D0j4Ze5nFpI 437178 2021-09-02 11:59:49 -0700 2021-09-03 11:10:16 -0700 Patch bug-229590-20210902115949.patch text/plain 15512 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgxODI0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjQzMTFhYjQwNzcxMDc0 ZWI4MzkyNWY1YzhhY2NiMjEyZjhjNmExMi4uYTJiMDcxZTE4YmZjOTFmMDMzYTQyMTFkY2NiYTRm ZDkwMDMyNzI4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDIxLTA5LTAyICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgTm8gbmV3IHRlc3RzLiBObyBvYnNlcnZhYmxlIGJlaGF2aW9yIGNoYW5nZSBhcyB0aGUg cGVybWlzaW9uIHJlcXVlc3QgZmxvdyBpcyBub3QgdXNlZCBieSBhbnkgZmVhdHVyZSB5ZXQuCisK KyAgICAgICAgKiBNb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmg6CisgICAgICAg IChXZWJDb3JlOjpwZXJtaXNzaW9uTmFtZVRvU3RyaW5nKToKKwogMjAyMS0wOC0zMSAgU2lodWkg TGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OIChyMjgxNzcx KTogQVNTRVJUSU9OIEZBSUxFRDogIW1fZGVsZXRpb25IYXNCZWd1biB1bmRlciBXZWJDb3JlOjpQ ZXJtaXNzaW9uczo6flBlcm1pc3Npb25zKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggYTlmOTc0MDBlZTMxOTIyNzFk MWQ2NDYxMjdiYmJhZmYyZDE5ZDQ1Ni4uYmUwMTkyNGMxMzEzNjIxODZkNTlkODUzMDg1YWMzM2Vi MTIxYzJmYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOCBAQAorMjAyMS0wOS0wMiAgU2lodWkgTGl1 ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBBZGQgcHJvbXB0IGZvciBQZXJtaXNz aW9ucyBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIyOTU5MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IERpc3BsYXkgYSBwcm9tcHQgZm9yIHBlcm1pc3Npb24gcmVxdWVzdCBieSBkZWZhdWx0LgorCisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oOgorICAgICAgICAoQVBJOjpVSUNs aWVudDo6cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tVSURlbGVnYXRlUHJpdmF0ZS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9NZWRpYVBl cm1pc3Npb25VdGlsaXRpZXMubW06CisgICAgICAgIChXZWJLaXQ6OmNvbnZlcnRQZXJtaXNzaW9u TmFtZVRvUmVhc29uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5oOgor ICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tOgorICAgICAgICAoV2ViS2l0 OjpVSURlbGVnYXRlOjpVSUNsaWVudDo6cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAqIFVJ UHJvY2Vzcy9Db2NvYS9XZWJQYWdlUHJveHlDb2NvYS5tbToKKyAgICAgICAgKFdlYktpdDo6V2Vi UGFnZVByb3h5OjpyZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbik6CisgICAgICAgICog VUlQcm9jZXNzL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oOgorICAgICAgICAqIFVJUHJvY2Vz cy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVy bWlzc2lvbkJ5RGVmYXVsdEFjdGlvbik6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5oOgorCiAyMDIxLTA4LTMxICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgogCiAg ICAgICAgIFJFR1JFU1NJT04gKHIyODE3NzEpOiBBU1NFUlRJT04gRkFJTEVEOiAhbV9kZWxldGlv bkhhc0JlZ3VuIHVuZGVyIFdlYkNvcmU6OlBlcm1pc3Npb25zOjp+UGVybWlzc2lvbnMoKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFt ZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5o CmluZGV4IGRkMjgzZjE2OTQyYzA1ZDIzMWMzYTlmZGJiY2QyYWI3ZTRmOTg4OTMuLmY3M2Q3OTEy NGIzYTRiN2ZkNGIyZTYyY2U5MjIzZGViY2Y3YTA3MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgKQEAgLTI2LDYgKzI2LDcg QEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSA8d3RmL0VudW1UcmFpdHMuaD4KKyNpbmNsdWRl IDx3dGYvdGV4dC9BU0NJSUxpdGVyYWwuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC00 NSw2ICs0NiwzOCBAQCBlbnVtIGNsYXNzIFBlcm1pc3Npb25OYW1lIDogdWludDhfdCB7CiAgICAg U3BlYWtlclNlbGVjdGlvbgogfTsKIAoraW5saW5lIEFTQ0lJTGl0ZXJhbCBwZXJtaXNzaW9uTmFt ZVRvU3RyaW5nKFBlcm1pc3Npb25OYW1lIG5hbWUpCit7CisgICAgc3dpdGNoIChuYW1lKSB7Cisg ICAgY2FzZSBQZXJtaXNzaW9uTmFtZTo6QWNjZWxlcm9tZXRlcjoKKyAgICAgICAgcmV0dXJuICJB Y2NlbGVyb21ldGVyIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6OkJhY2tncm91bmRGZXRj aDoKKyAgICAgICAgcmV0dXJuICJCYWNrZ3JvdW5kRmV0Y2giX3M7CisgICAgY2FzZSBQZXJtaXNz aW9uTmFtZTo6Qmx1ZXRvb3RoOgorICAgICAgICByZXR1cm4gIkJsdWV0b290aCJfczsKKyAgICBj YXNlIFBlcm1pc3Npb25OYW1lOjpDYW1lcmE6CisgICAgICAgIHJldHVybiAiQ2FtZXJhIl9zOwor ICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6OkRpc3BsYXlDYXB0dXJlOgorICAgICAgICByZXR1cm4g IkRpc3BsYXlDYXB0dXJlIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6Okdlb2xvY2F0aW9u OgorICAgICAgICByZXR1cm4gIkdlb2xvY2F0aW9uIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5h bWU6Okd5cm9zY29wZToKKyAgICAgICAgcmV0dXJuICJHeXJvc2NvcGUiX3M7CisgICAgY2FzZSBQ ZXJtaXNzaW9uTmFtZTo6TWFnbmV0b21ldGVyOgorICAgICAgICByZXR1cm4gIk1hZ25ldG9tZXRl ciJfczsKKyAgICBjYXNlIFBlcm1pc3Npb25OYW1lOjpNaWNyb3Bob25lOgorICAgICAgICByZXR1 cm4gIk1pY3JvcGhvbmUiX3M7CisgICAgY2FzZSBQZXJtaXNzaW9uTmFtZTo6TWlkaToKKyAgICAg ICAgcmV0dXJuICJNaWRpIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6Ok5mYzoKKyAgICAg ICAgcmV0dXJuICJOZmMiX3M7CisgICAgY2FzZSBQZXJtaXNzaW9uTmFtZTo6Tm90aWZpY2F0aW9u czoKKyAgICAgICAgcmV0dXJuICJOb3RpZmljYXRpb25zIl9zOworICAgIGNhc2UgUGVybWlzc2lv bk5hbWU6OlNwZWFrZXJTZWxlY3Rpb246CisgICAgICAgIHJldHVybiAiU3BlYWtlclNlbGVjdGlv biJfczsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogbmFtZXNwYWNlIFdU RiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQVBJVUlDbGllbnQu aCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCmluZGV4IDJkYjBm NTY5Y2IyMjUwNTg5ZTdlYzE2MDU4ZGFmYjVhNmE0ZTdiZjAuLjhhMDY0ZWRiY2Y3ZTJhY2MwYTA3 MTU2MzM4NjY5NmNhZWUxN2U5ZWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9BUElVSUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElV SUNsaWVudC5oCkBAIC00NCwxMCArNDQsMTAgQEAgT0JKQ19DTEFTUyBVSVZpZXdDb250cm9sbGVy OwogI2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lvbk5h bWUgOiB1aW50OF90OwogY2xhc3MgUmVnaXN0cmFibGVEb21haW47CiBjbGFzcyBSZXNvdXJjZVJl cXVlc3Q7CiBzdHJ1Y3QgRm9udEF0dHJpYnV0ZXM7Ci1zdHJ1Y3QgU2VjdXJpdHlPcmlnaW5EYXRh Owogc3RydWN0IFdpbmRvd0ZlYXR1cmVzOwogfQogCkBAIC0yMTEsNiArMjExLDggQEAgcHVibGlj OgogI2lmIEVOQUJMRShXRUJYUikgJiYgUExBVEZPUk0oQ09DT0EpCiAgICAgdmlydHVhbCB2b2lk IHN0YXJ0WFJTZXNzaW9uKFdlYktpdDo6V2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8 dm9pZChSZXRhaW5QdHI8aWQ+KT4mJiBjb21wbGV0aW9uSGFuZGxlcikgeyBjb21wbGV0aW9uSGFu ZGxlcihuaWwpOyB9CiAjZW5kaWYKKworICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lv bihXZWJLaXQ6OldlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmln aW4mIG9yaWdpbiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUsIENvbXBs ZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhhbmRsZXIpIHsgcGFnZS5yZXF1 ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0YSgpLCBwZXJtaXNzaW9uTmFt ZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOyB9CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBB UEkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVs ZWdhdGVQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tVSURl bGVnYXRlUHJpdmF0ZS5oCmluZGV4IGY2NmExYmEzZTg5MjI1M2YxNzYzM2MzNDJjMjI5YWRmYWFi MjEzMjEuLjdmZGQyYzI1NThmMDRhMTZhYzcyMGY4MGQzZGY4OTllZGU3MWQ4NzIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRl LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0ZVBy aXZhdGUuaApAQCAtMTYwLDYgKzE2MCw4IEBAIHN0cnVjdCBVSUVkZ2VJbnNldHM7CiAKIC0gKHZv aWQpX3dlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgc3RhcnRYUlNlc3Npb25XaXRoQ29tcGxl dGlvbkhhbmRsZXI6KHZvaWQgKF4pKGlkKSljb21wbGV0aW9uSGFuZGxlciBXS19BUElfQVZBSUxB QkxFKG1hY29zKDEyLjApLCBpb3MoMTUuMCkpOwogCistICh2b2lkKV93ZWJWaWV3OihXS1dlYlZp ZXcgKil3ZWJWaWV3IHJlcXVlc3RQZXJtaXNzaW9uRm9yTmFtZTooTlNTdHJpbmcgKilwZXJtaXNz aW9uTmFtZSBvcmlnaW46KFdLU2VjdXJpdHlPcmlnaW4gKilvcmlnaW4gZGVjaXNpb25IYW5kbGVy Oih2b2lkICheKShCT09MIGdyYW50ZWQpKWRlY2lzaW9uSGFuZGxlciBXS19BUElfQVZBSUxBQkxF KG1hY29zKDEyLjApLCBpb3MoMTUuMCkpOworCiAjaWYgVEFSR0VUX09TX0lQSE9ORQogCiAtIChC T09MKV93ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IHNob3VsZEluY2x1ZGVBcHBMaW5rQWN0 aW9uc0ZvckVsZW1lbnQ6KF9XS0FjdGl2YXRlZEVsZW1lbnRJbmZvICopZWxlbWVudCBXS19BUElf QVZBSUxBQkxFKGlvcyg5LjApKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0NvY29hL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0NvY29hL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbQppbmRleCAxNGU5YzhhYjViYmZj YmZmYTA0ZGRiODVjYmIyNzE5NTIwYzA1ZWFlLi5lZjcwZWI4NDcxMTA3N2MyZjc2NjJjNmE5NGEx MzY1N2VmNWE4MWZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9N ZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMubW0KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv Q29jb2EvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLm1tCkBAIC0yNywxOSArMjcsMjEgQEAKICNp bXBvcnQgIk1lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oIgogCiAjaW1wb3J0ICJTYW5kYm94VXRp bGl0aWVzLmgiCi0jaW1wb3J0ICJUQ0NTb2Z0TGluay5oIgogI2ltcG9ydCAiV0tXZWJWaWV3SW50 ZXJuYWwuaCIKICNpbXBvcnQgIldlYlBhZ2VQcm94eS5oIgogI2ltcG9ydCA8V2ViQ29yZS9Mb2Nh bGl6ZWRTdHJpbmdzLmg+CisjaW1wb3J0IDxXZWJDb3JlL1Blcm1pc3Npb25OYW1lLmg+CiAjaW1w b3J0IDxXZWJDb3JlL1NlY3VyaXR5T3JpZ2luRGF0YS5oPgogI2ltcG9ydCA8bXV0ZXg+Ci0jaW1w b3J0IDxwYWwvY29jb2EvQVZGb3VuZGF0aW9uU29mdExpbmsuaD4KLSNpbXBvcnQgPHBhbC9jb2Nv YS9TcGVlY2hTb2Z0TGluay5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3 dGYvVVJMSGVscGVycy5oPgogI2ltcG9ydCA8d3RmL3NwaS9jZi9DRkJ1bmRsZVNQSS5oPgogI2lt cG9ydCA8d3RmL3NwaS9kYXJ3aW4vU2FuZGJveFNQSS5oPgogCisjaW1wb3J0ICJUQ0NTb2Z0TGlu ay5oIgorI2ltcG9ydCA8cGFsL2NvY29hL0FWRm91bmRhdGlvblNvZnRMaW5rLmg+CisjaW1wb3J0 IDxwYWwvY29jb2EvU3BlZWNoU29mdExpbmsuaD4KKwogbmFtZXNwYWNlIFdlYktpdCB7CiAKIGJv b2wgY2hlY2tTYW5kYm94UmVxdWlyZW1lbnRGb3JUeXBlKE1lZGlhUGVybWlzc2lvblR5cGUgdHlw ZSkKQEAgLTIyMiw2ICsyMjQsMjAgQEAgdm9pZCBhbGVydEZvclBlcm1pc3Npb24oV2ViUGFnZVBy b3h5JiBwYWdlLCBNZWRpYVBlcm1pc3Npb25SZWFzb24gcmVhc29uLCBjb25zdAogI2VuZGlmCiB9 CiAKK3N0ZDo6b3B0aW9uYWw8TWVkaWFQZXJtaXNzaW9uUmVhc29uPiBjb252ZXJ0UGVybWlzc2lv bk5hbWVUb1JlYXNvbihXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBwZXJtaXNzaW9uTmFtZSkKK3sK KyAgICBzd2l0Y2ggKHBlcm1pc3Npb25OYW1lKSB7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNz aW9uTmFtZTo6Q2FtZXJhOgorICAgICAgICByZXR1cm4gTWVkaWFQZXJtaXNzaW9uUmVhc29uOjpD YW1lcmE7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6TWljcm9waG9uZToKKyAg ICAgICAgcmV0dXJuIE1lZGlhUGVybWlzc2lvblJlYXNvbjo6TWljcm9waG9uZTsKKyAgICBjYXNl IFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpHZW9sb2NhdGlvbjoKKyAgICAgICAgcmV0dXJuIE1l ZGlhUGVybWlzc2lvblJlYXNvbjo6R2VvbG9jYXRpb247CisgICAgZGVmYXVsdDoKKyAgICAgICAg cmV0dXJuIHN0ZDo6bnVsbG9wdDsKKyAgICB9Cit9CisKICNpZiBIQVZFKEFWQ0FQVFVSRURFVklD RSkKIAogdm9pZCByZXF1ZXN0QVZDYXB0dXJlQWNjZXNzRm9yVHlwZShNZWRpYVBlcm1pc3Npb25U eXBlIHR5cGUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCBhdXRob3JpemVkKT4mJiBjb21w bGV0aW9uSGFuZGxlcikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29h L1VJRGVsZWdhdGUuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUu aAppbmRleCAzMjlkYjc5MWNmNDMyNzI0NjM2MzQyODAwNTA0YjA4ZWE4OWRiMGUzLi5mYzA5YTRi ODE0ODIyNzcxNmZkZmIxNzdjZjIwZjRkZGVkMDMwNmE0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5oCkBAIC0xNzUsNiArMTc1LDggQEAgcHJpdmF0ZToKICAg ICAgICAgdm9pZCBzdGFydFhSU2Vzc2lvbihXZWJQYWdlUHJveHkmLCBDb21wbGV0aW9uSGFuZGxl cjx2b2lkKFJldGFpblB0cjxpZD4pPiYmKSBmaW5hbDsKICNlbmRpZgogCisgICAgICAgIHZvaWQg cmVxdWVzdFBlcm1pc3Npb24oV2ViUGFnZVByb3h5JiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlP cmlnaW4mLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChi b29sKT4mJikgZmluYWw7CisKICAgICAgICAgV2Vha1B0cjxVSURlbGVnYXRlPiBtX3VpRGVsZWdh dGU7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2Ev VUlEZWxlZ2F0ZS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUu bW0KaW5kZXggYmRkNmIzYTY4MzM1NWFjZWQzYjlhNzIwMjQ3YTYxMzE1ZWFlOWY0MS4uYTJmOTUw NjZkNjRhNGVhMTk0OGE4YTBjZjU5MTg5OTg0NDA0MDg4OSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tCkBAIC02Myw2ICs2Myw3IEBACiAjaW1wb3J0IDxB VkZvdW5kYXRpb24vQVZDYXB0dXJlRGV2aWNlLmg+CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZN ZWRpYUZvcm1hdC5oPgogI2ltcG9ydCA8V2ViQ29yZS9Gb250QXR0cmlidXRlcy5oPgorI2ltcG9y dCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0eU9y aWdpbi5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3dGYvVVJMLmg+CkBA IC0xNjg0LDQgKzE2ODUsMjcgQEAgdm9pZCBVSURlbGVnYXRlOjpVSUNsaWVudDo6c3RhcnRYUlNl c3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgKIH0KICNlbmRpZgog Cit2b2lkIFVJRGVsZWdhdGU6OlVJQ2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbihXZWJLaXQ6Oldl YlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mIG9yaWdpbiwg V2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgbmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29s IGdyYW50ZWQpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQoreworICAgIGlmICghbV91aURlbGVnYXRl KQorICAgICAgICByZXR1cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihv cmlnaW4uZGF0YSgpLCBuYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7CisKKyAgICBh dXRvIGRlbGVnYXRlID0gKGlkIDxXS1VJRGVsZWdhdGVQcml2YXRlPiltX3VpRGVsZWdhdGUtPm1f ZGVsZWdhdGUuZ2V0KCk7CisgICAgaWYgKCFkZWxlZ2F0ZSkKKyAgICAgICAgcmV0dXJuIHBhZ2Uu cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24ob3JpZ2luLmRhdGEoKSwgbmFtZSwgV1RG TW92ZShjb21wbGV0aW9uSGFuZGxlcikpOworCisgICAgaWYgKCFbZGVsZWdhdGUgcmVzcG9uZHNU b1NlbGVjdG9yOkBzZWxlY3Rvcihfd2ViVmlldzpyZXF1ZXN0UGVybWlzc2lvbkZvck5hbWU6b3Jp Z2luOmRlY2lzaW9uSGFuZGxlcjopXSkKKyAgICAgICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1p c3Npb25CeURlZmF1bHRBY3Rpb24ob3JpZ2luLmRhdGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0 aW9uSGFuZGxlcikpOworCisgICAgYXV0byBhcGlPcmlnaW4gPSBBUEk6OlNlY3VyaXR5T3JpZ2lu OjpjcmVhdGUob3JpZ2luKTsKKyAgICBXVEY6OlN0cmluZyBuYW1lU3RyaW5nID0gcGVybWlzc2lv bk5hbWVUb1N0cmluZyhuYW1lKTsKKyAgICBhdXRvIGNoZWNrZXIgPSBDb21wbGV0aW9uSGFuZGxl ckNhbGxDaGVja2VyOjpjcmVhdGUoZGVsZWdhdGUsIEBzZWxlY3Rvcihfd2ViVmlldzpyZXF1ZXN0 UGVybWlzc2lvbkZvck5hbWU6b3JpZ2luOmRlY2lzaW9uSGFuZGxlcjopKTsKKyAgICBbZGVsZWdh dGUgX3dlYlZpZXc6bV91aURlbGVnYXRlLT5tX3dlYlZpZXcuZ2V0KCkuZ2V0KCkgcmVxdWVzdFBl cm1pc3Npb25Gb3JOYW1lOm5hbWVTdHJpbmcgb3JpZ2luOndyYXBwZXIoYXBpT3JpZ2luKSBkZWNp c2lvbkhhbmRsZXI6bWFrZUJsb2NrUHRyKFtjb21wbGV0aW9uSGFuZGxlciA9IHN0ZDo6ZXhjaGFu Z2UoY29tcGxldGlvbkhhbmRsZXIsIHsgfSksIGNoZWNrZXIgPSBXVEZNb3ZlKGNoZWNrZXIpXSAo Qk9PTCBncmFudGVkKSBtdXRhYmxlIHsKKyAgICAgICAgaWYgKGNoZWNrZXItPmNvbXBsZXRpb25I YW5kbGVySGFzQmVlbkNhbGxlZCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBjaGVj a2VyLT5kaWRDYWxsQ29tcGxldGlvbkhhbmRsZXIoKTsKKyAgICAgICAgY29tcGxldGlvbkhhbmRs ZXIoZ3JhbnRlZCk7CisgICAgfSkuZ2V0KCldOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNv Y29hLm1tIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvV2ViUGFnZVByb3h5Q29jb2Eu bW0KaW5kZXggMzMwMWVkNDhmMDQ1YTlkZDU0ZjNhODUzYmFlOTBmMTJlZGE3Y2E1Ny4uOWFlNGU2 NzAzOGM0YzhhZmUzYWE1Y2ExMWM4ODkxMjE3ZTBmNDg2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQ29jb2EvV2ViUGFnZVByb3h5Q29jb2EubW0KKysrIGIvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQ29jb2EvV2ViUGFnZVByb3h5Q29jb2EubW0KQEAgLTM0LDYgKzM0LDcg QEAKICNpbXBvcnQgIkRhdGFEZXRlY3Rpb25SZXN1bHQuaCIKICNpbXBvcnQgIkluc2VydFRleHRP cHRpb25zLmgiCiAjaW1wb3J0ICJMb2FkUGFyYW1ldGVycy5oIgorI2ltcG9ydCAiTWVkaWFQZXJt aXNzaW9uVXRpbGl0aWVzLmgiCiAjaW1wb3J0ICJQYWdlQ2xpZW50LmgiCiAjaW1wb3J0ICJRdWFy YW50aW5lU1BJLmgiCiAjaW1wb3J0ICJRdWlja0xvb2tUaHVtYm5haWxMb2FkZXIuaCIKQEAgLTc1 MCw2ICs3NTEsMTUgQEAgYm9vbCBXZWJQYWdlUHJveHk6OmlzUXVhcmFudGluZWRBbmROb3RVc2Vy QXBwcm92ZWQoY29uc3QgU3RyaW5nJiBmaWxlVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKK3ZvaWQg V2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25zdCBXZWJD b3JlOjpTZWN1cml0eU9yaWdpbkRhdGEmIG9yaWdpbiwgUGVybWlzc2lvbk5hbWUgcGVybWlzc2lv bk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhhbmRsZXIp Cit7CisgICAgYXV0byByZWFzb24gPSBjb252ZXJ0UGVybWlzc2lvbk5hbWVUb1JlYXNvbihwZXJt aXNzaW9uTmFtZSk7CisgICAgaWYgKCFyZWFzb24pCisgICAgICAgIHJldHVybiBjb21wbGV0aW9u SGFuZGxlcihmYWxzZSk7CisKKyAgICBhbGVydEZvclBlcm1pc3Npb24oKnRoaXMsICpyZWFzb24s IG9yaWdpbiwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOworfQorCiB9IC8vIG5hbWVzcGFj ZSBXZWJLaXQKIAogI3VuZGVmIE1FU1NBR0VfQ0hFQ0tfQ09NUExFVElPTgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmggYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaAppbmRleCA1YTMx NTE2OTVjYzRkOGU0MDM0NzA2NGZjZmFlNDU4MWZkN2ZhMTk1Li5jNmMwYWE3MGFiODNjOGY3YTQ4 ZTVlNDFmYjE2YWVmZGE4Y2Y4MzhjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaApAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUg PHd0Zi9WZWN0b3IuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgeworZW51bSBjbGFzcyBQZXJtaXNz aW9uTmFtZSA6IHVpbnQ4X3Q7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKIH0KIApAQCAtNTcsNiAr NTgsOCBAQCBlbnVtIGNsYXNzIE1lZGlhUGVybWlzc2lvblJlYXNvbiB7CiAgICAgU3BlZWNoUmVj b2duaXRpb24KIH07CiAKK3N0ZDo6b3B0aW9uYWw8TWVkaWFQZXJtaXNzaW9uUmVhc29uPiBjb252 ZXJ0UGVybWlzc2lvbk5hbWVUb1JlYXNvbihXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSk7CisKICNp ZiBQTEFURk9STShDT0NPQSkKIGJvb2wgY2hlY2tTYW5kYm94UmVxdWlyZW1lbnRGb3JUeXBlKE1l ZGlhUGVybWlzc2lvblR5cGUpOwogYm9vbCBjaGVja1VzYWdlRGVzY3JpcHRpb25TdHJpbmdGb3JU eXBlKE1lZGlhUGVybWlzc2lvblR5cGUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5jcHAKaW5kZXggZDQ3NDhmZDcwMzNmOWJiNDc1ZjcwMjAxMjI4MzE3YjA0ZmNhOWVhZS4u ZGI0NDliZGI3ZTg5MDIxMWZhYzA3MDhmYzM5MGE0Mjc5ZTFlNzRkMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xNzEsNiArMTcxLDcgQEAKICNpbmNsdWRl IDxXZWJDb3JlL01JTUVUeXBlUmVnaXN0cnkuaD4KICNpbmNsdWRlIDxXZWJDb3JlL01lZGlhU3Ry ZWFtUmVxdWVzdC5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGVyZm9ybWFuY2VMb2dnaW5nQ2xpZW50 Lmg+CisjaW5jbHVkZSA8V2ViQ29yZS9QZXJtaXNzaW9uRGVzY3JpcHRvci5oPgogI2luY2x1ZGUg PFdlYkNvcmUvUGVybWlzc2lvblN0YXRlLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9QbGF0Zm9ybUV2 ZW50Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9Qcml2YXRlQ2xpY2tNZWFzdXJlbWVudC5oPgpAQCAt ODQ5OSwxMCArODUwMCwxMyBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6cmV2b2tlR2VvbG9jYXRpb25B dXRob3JpemF0aW9uVG9rZW4oY29uc3QgU3RyaW5nJiBhdXRob3JpemF0aQogICAgIG1fZ2VvbG9j YXRpb25QZXJtaXNzaW9uUmVxdWVzdE1hbmFnZXIucmV2b2tlQXV0aG9yaXphdGlvblRva2VuKGF1 dGhvcml6YXRpb25Ub2tlbik7CiB9CiAKLXZvaWQgV2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVybWlz c2lvbihjb25zdCBDbGllbnRPcmlnaW4mLCBjb25zdCBQZXJtaXNzaW9uRGVzY3JpcHRvciYsIENv bXBsZXRpb25IYW5kbGVyPHZvaWQoUGVybWlzc2lvblN0YXRlKT4mJiBjb21wbGV0aW9uSGFuZGxl cikKK3ZvaWQgV2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVybWlzc2lvbihjb25zdCBDbGllbnRPcmln aW4mIG9yaWdpbiwgY29uc3QgUGVybWlzc2lvbkRlc2NyaXB0b3ImIGRlc2NyaXB0b3IsIENvbXBs ZXRpb25IYW5kbGVyPHZvaWQoUGVybWlzc2lvblN0YXRlKT4mJiBjb21wbGV0aW9uSGFuZGxlcikK IHsKLSAgICAvLyBGSVhNRTogU2hvdyBhIHByb21wdCBmb3IgdXNlciBpbnB1dC4KLSAgICBjb21w bGV0aW9uSGFuZGxlcihQZXJtaXNzaW9uU3RhdGU6OkdyYW50ZWQpOworICAgIGF1dG8gc2VjdXJp dHlPcmlnaW4gPSBvcmlnaW4uY2xpZW50T3JpZ2luLnNlY3VyaXR5T3JpZ2luKCk7CisgICAgbV91 aUNsaWVudC0+cmVxdWVzdFBlcm1pc3Npb24oKnRoaXMsIHNlY3VyaXR5T3JpZ2luLmdldCgpLCBk ZXNjcmlwdG9yLm5hbWUsIFtjb21wbGV0aW9uSGFuZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhh bmRsZXIpXShib29sIGdyYW50ZWQpIG11dGFibGUgeworICAgICAgICBhdXRvIHBlcm1pc3Npb25z U3RhdGUgPSBncmFudGVkID8gUGVybWlzc2lvblN0YXRlOjpHcmFudGVkIDogUGVybWlzc2lvblN0 YXRlOjpEZW5pZWQ7CisgICAgICAgIGNvbXBsZXRpb25IYW5kbGVyKHBlcm1pc3Npb25zU3RhdGUp OworICAgIH0pOwogfQogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKQEAgLTEwODczLDYgKzEw ODc3LDE1IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpjbGVhckFwcFByaXZhY3lSZXBvcnRUZXN0aW5n RGF0YShDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYKIH0KICNlbmRpZgogCisjaWYgIVBMQVRG T1JNKENPQ09BKQorCit2b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgUGVybWlzc2lvbk5h bWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCit7 CisgICAgY29tcGxldGlvbkhhbmRsZXIoZmFsc2UpOworfQorCisjZW5kaWYKKwogfSAvLyBuYW1l c3BhY2UgV2ViS2l0CiAKICN1bmRlZiBXRUJQQUdFUFJPWFlfUkVMRUFTRV9MT0cKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggNTRlMjAyYWVkMDkyNGMzZGNjZDI5ZmQw OTFhOTFkN2E4ZjQxOWE5NS4uMDgwYjRiMjc2MDI2MmJlZmQ3OGYxZjYyYTYwZjI3NDFhMDZkMmQ3 NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKKysr IGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKQEAgLTI2OCw2ICsyNjgs NyBAQCBlbnVtIGNsYXNzIEhpZ2hsaWdodFJlcXVlc3RPcmlnaW5hdGVkSW5BcHAgOiBib29sOwog ZW51bSBjbGFzcyBIaWdobGlnaHRWaXNpYmlsaXR5IDogYm9vbDsKIGVudW0gY2xhc3MgTW91c2VF dmVudFBvbGljeSA6IHVpbnQ4X3Q7CiBlbnVtIGNsYXNzIE5vdGlmaWNhdGlvbkRpcmVjdGlvbiA6 IHVpbnQ4X3Q7CitlbnVtIGNsYXNzIFBlcm1pc3Npb25OYW1lIDogdWludDhfdDsKIGVudW0gY2xh c3MgUm91dGVTaGFyaW5nUG9saWN5IDogdWludDhfdDsKIGVudW0gY2xhc3MgU2VsZWN0aW9uRGly ZWN0aW9uIDogdWludDhfdDsKIGVudW0gY2xhc3MgU2hvdWxkU2FtcGxlIDogYm9vbDsKQEAgLTE5 MDUsNiArMTkwNiw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlcXVlc3RVc2VyTWVkaWFQZXJtaXNz aW9uRm9yU3BlZWNoUmVjb2duaXRpb24oV2ViQ29yZTo6RnJhbWVJZGVudGlmaWVyLCBjb25zdCBX ZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwg Q29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJik7CiAKICAgICB2b2lkIHJlcXVlc3RNZWRp YUtleVN5c3RlbVBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJp dHlPcmlnaW5EYXRhJiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJik7CisgICAgdm9p ZCByZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25zdCBXZWJDb3JlOjpTZWN1cml0 eU9yaWdpbkRhdGEmLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8 dm9pZChib29sKT4mJik7CiAKICAgICB2b2lkIHN5bmNJZk1vY2tEZXZpY2VzRW5hYmxlZENoYW5n ZWQoKTsKIAo= 437286 2021-09-03 11:10:18 -0700 2021-09-03 12:35:54 -0700 Patch bug-229590-20210903111017.patch text/plain 16384 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgyMDA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDYxYzA3ZjVkMjgwZWQw YTdiZmFlYTNhODliYjIyNDlhZDhjYzgwOS4uMWIzMDVmMWE2YWEyZTQ0ZmFlMzU3Mzk2NTIwNjE1 NzYyYzA0ZWRiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA5LTAzICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIE5v IG9ic2VydmFibGUgYmVoYXZpb3IgY2hhbmdlIGFzIHRoZSBwZXJtaXNpb24gcmVxdWVzdCBmbG93 IGlzIG5vdCB1c2VkIGJ5IGFueSBmZWF0dXJlIHlldC4KKworICAgICAgICAqIE1vZHVsZXMvcGVy bWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaDoKKyAgICAgICAgKFdlYkNvcmU6OnBlcm1pc3Npb25O YW1lVG9TdHJpbmcpOgorCiAyMDIxLTA5LTAzICBaaXJhbiBTdW4gIDx6c3VuQGlnYWxpYS5jb20+ CiAKICAgICAgICAgUkVHUkVTU0lPTihyMjgwMDc4KTogYnJva2UgZmFzdC9pbWFnZXMvZXhpZi1v cmllbnRhdGlvbi1jb21wb3NpdGVkLmh0bWwgb24gd2luZG93cwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCA1NDFmNzUy MmM0ZDZmYTgyM2YxMmQ3MzZlMDg4NDhkMTExOGNhODM5Li4yNGRlOTBlNDVlMGY4NDNhYjRkMTZm MDc3YzM0N2FkNzllMmU1ODY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDIxLTA5LTAz ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQg Zm9yIFBlcm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNwbGF5IGEg cHJvbXB0IGZvciBwZXJtaXNzaW9uIHJlcXVlc3QgYnkgZGVmYXVsdC4KKworICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvQVBJVUlDbGllbnQuaDoKKyAgICAgICAgKEFQSTo6VUlDbGllbnQ6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0 ZVByaXZhdGUuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29jb2EvTWVkaWFQZXJtaXNzaW9uVXRp bGl0aWVzLm1tOgorICAgICAgICAoV2ViS2l0Ojpjb252ZXJ0UGVybWlzc2lvbk5hbWVUb1JlYXNv bik6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUuaDoKKyAgICAgICAgKiBV SVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbToKKyAgICAgICAgKFdlYktpdDo6VUlEZWxlZ2F0 ZTo6VUlDbGllbnQ6OnJlcXVlc3RQZXJtaXNzaW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29j b2EvV2ViUGFnZVByb3h5Q29jb2EubW06CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6 cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9N ZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVybWlzc2lv bik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb25CeURl ZmF1bHRBY3Rpb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaDoKKwogMjAy MS0wOS0wMyAgQWxleCBDaHJpc3RlbnNlbiAgPGFjaHJpc3RlbnNlbkB3ZWJraXQub3JnPgogCiAg ICAgICAgIENsZWFuIHVwIFByaXZhdGVDbGlja01lYXN1cmVtZW50TWFuYWdlciBpbnRlcmZhY2UK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lv bk5hbWUuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5h bWUuaAppbmRleCBkZDI4M2YxNjk0MmMwNWQyMzFjM2E5ZmRiYmNkMmFiN2U0Zjk4ODkzLi5mNzNk NzkxMjRiM2E0YjdmZDRiMmU2MmNlOTIyM2RlYmNmN2EwNzI5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgKKysrIGIvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5oCkBAIC0yNiw2ICsy Niw3IEBACiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgPHd0Zi9FbnVtVHJhaXRzLmg+CisjaW5j bHVkZSA8d3RmL3RleHQvQVNDSUlMaXRlcmFsLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApA QCAtNDUsNiArNDYsMzggQEAgZW51bSBjbGFzcyBQZXJtaXNzaW9uTmFtZSA6IHVpbnQ4X3Qgewog ICAgIFNwZWFrZXJTZWxlY3Rpb24KIH07CiAKK2lubGluZSBBU0NJSUxpdGVyYWwgcGVybWlzc2lv bk5hbWVUb1N0cmluZyhQZXJtaXNzaW9uTmFtZSBuYW1lKQoreworICAgIHN3aXRjaCAobmFtZSkg eworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6OkFjY2VsZXJvbWV0ZXI6CisgICAgICAgIHJldHVy biAiQWNjZWxlcm9tZXRlciJfczsKKyAgICBjYXNlIFBlcm1pc3Npb25OYW1lOjpCYWNrZ3JvdW5k RmV0Y2g6CisgICAgICAgIHJldHVybiAiQmFja2dyb3VuZEZldGNoIl9zOworICAgIGNhc2UgUGVy bWlzc2lvbk5hbWU6OkJsdWV0b290aDoKKyAgICAgICAgcmV0dXJuICJCbHVldG9vdGgiX3M7Cisg ICAgY2FzZSBQZXJtaXNzaW9uTmFtZTo6Q2FtZXJhOgorICAgICAgICByZXR1cm4gIkNhbWVyYSJf czsKKyAgICBjYXNlIFBlcm1pc3Npb25OYW1lOjpEaXNwbGF5Q2FwdHVyZToKKyAgICAgICAgcmV0 dXJuICJEaXNwbGF5Q2FwdHVyZSJfczsKKyAgICBjYXNlIFBlcm1pc3Npb25OYW1lOjpHZW9sb2Nh dGlvbjoKKyAgICAgICAgcmV0dXJuICJHZW9sb2NhdGlvbiJfczsKKyAgICBjYXNlIFBlcm1pc3Np b25OYW1lOjpHeXJvc2NvcGU6CisgICAgICAgIHJldHVybiAiR3lyb3Njb3BlIl9zOworICAgIGNh c2UgUGVybWlzc2lvbk5hbWU6Ok1hZ25ldG9tZXRlcjoKKyAgICAgICAgcmV0dXJuICJNYWduZXRv bWV0ZXIiX3M7CisgICAgY2FzZSBQZXJtaXNzaW9uTmFtZTo6TWljcm9waG9uZToKKyAgICAgICAg cmV0dXJuICJNaWNyb3Bob25lIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6Ok1pZGk6Cisg ICAgICAgIHJldHVybiAiTWlkaSJfczsKKyAgICBjYXNlIFBlcm1pc3Npb25OYW1lOjpOZmM6Cisg ICAgICAgIHJldHVybiAiTmZjIl9zOworICAgIGNhc2UgUGVybWlzc2lvbk5hbWU6Ok5vdGlmaWNh dGlvbnM6CisgICAgICAgIHJldHVybiAiTm90aWZpY2F0aW9ucyJfczsKKyAgICBjYXNlIFBlcm1p c3Npb25OYW1lOjpTcGVha2VyU2VsZWN0aW9uOgorICAgICAgICByZXR1cm4gIlNwZWFrZXJTZWxl Y3Rpb24iX3M7CisgICAgfQorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKIG5hbWVzcGFj ZSBXVEYgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0FQSVVJQ2xp ZW50LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQVBJVUlDbGllbnQuaAppbmRleCAy ZGIwZjU2OWNiMjI1MDU4OWU3ZWMxNjA1OGRhZmI1YTZhNGU3YmYwLi5kZmQ5M2UxYWVmOGI2MzMx MDMzYzQ4MzcxYjFlZWRlZmYzODcxM2RkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQVBJVUlDbGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv QVBJVUlDbGllbnQuaApAQCAtNDQsMTAgKzQ0LDEwIEBAIE9CSkNfQ0xBU1MgVUlWaWV3Q29udHJv bGxlcjsKICNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CitlbnVtIGNsYXNzIFBlcm1pc3Np b25OYW1lIDogdWludDhfdDsKIGNsYXNzIFJlZ2lzdHJhYmxlRG9tYWluOwogY2xhc3MgUmVzb3Vy Y2VSZXF1ZXN0Owogc3RydWN0IEZvbnRBdHRyaWJ1dGVzOwotc3RydWN0IFNlY3VyaXR5T3JpZ2lu RGF0YTsKIHN0cnVjdCBXaW5kb3dGZWF0dXJlczsKIH0KIApAQCAtMjExLDYgKzIxMSw4IEBAIHB1 YmxpYzoKICNpZiBFTkFCTEUoV0VCWFIpICYmIFBMQVRGT1JNKENPQ09BKQogICAgIHZpcnR1YWwg dm9pZCBzdGFydFhSU2Vzc2lvbihXZWJLaXQ6OldlYlBhZ2VQcm94eSYsIENvbXBsZXRpb25IYW5k bGVyPHZvaWQoUmV0YWluUHRyPGlkPik+JiYgY29tcGxldGlvbkhhbmRsZXIpIHsgY29tcGxldGlv bkhhbmRsZXIobmlsKTsgfQogI2VuZGlmCisKKyAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1p c3Npb24oV2ViS2l0OjpXZWJQYWdlUHJveHkmIHBhZ2UsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luJiBvcmlnaW4sIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiB0b3BPcmlnaW4s IFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lIHBlcm1pc3Npb25OYW1lLCBDb21wbGV0aW9uSGFuZGxl cjx2b2lkKGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKSB7IHBhZ2UucmVxdWVzdFBlcm1pc3Np b25CeURlZmF1bHRBY3Rpb24ob3JpZ2luLmRhdGEoKSwgcGVybWlzc2lvbk5hbWUsIFdURk1vdmUo Y29tcGxldGlvbkhhbmRsZXIpKTsgfQogfTsKIAogfSAvLyBuYW1lc3BhY2UgQVBJCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tVSURlbGVnYXRlUHJpdmF0 ZS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0ZVByaXZh dGUuaAppbmRleCBmNjZhMWJhM2U4OTIyNTNmMTc2MzNjMzQyYzIyOWFkZmFhYjIxMzIxLi5lNTQ4 MjZkN2VlNDdjOGFhMDE2N2I5NTY1ZDZlMzJkNDYzZjVlZGQ5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tVSURlbGVnYXRlUHJpdmF0ZS5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmgKQEAg LTE2MCw2ICsxNjAsOCBAQCBzdHJ1Y3QgVUlFZGdlSW5zZXRzOwogCiAtICh2b2lkKV93ZWJWaWV3 OihXS1dlYlZpZXcgKil3ZWJWaWV3IHN0YXJ0WFJTZXNzaW9uV2l0aENvbXBsZXRpb25IYW5kbGVy Oih2b2lkICheKShpZCkpY29tcGxldGlvbkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygx Mi4wKSwgaW9zKDE1LjApKTsKIAorLSAodm9pZClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmll dyByZXF1ZXN0UGVybWlzc2lvbkZvck5hbWU6KE5TU3RyaW5nICopcGVybWlzc2lvbk5hbWUgb3Jp Z2luOihXS1NlY3VyaXR5T3JpZ2luICopb3JpZ2luIHRvcE9yaWdpbjooV0tTZWN1cml0eU9yaWdp biAqKXRvcE9yaWdpbiBkZWNpc2lvbkhhbmRsZXI6KHZvaWQgKF4pKFdLUGVybWlzc2lvbkRlY2lz aW9uIGRlY2lzaW9uKSlkZWNpc2lvbkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19N QUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKKwogI2lmIFRBUkdFVF9PU19JUEhPTkUKIAogLSAo Qk9PTClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBzaG91bGRJbmNsdWRlQXBwTGlua0Fj dGlvbnNGb3JFbGVtZW50OihfV0tBY3RpdmF0ZWRFbGVtZW50SW5mbyAqKWVsZW1lbnQgV0tfQVBJ X0FWQUlMQUJMRShpb3MoOS4wKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9Db2NvYS9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMubW0KaW5kZXggMTRlOWM4YWI1YmJm Y2JmZmEwNGRkYjg1Y2JiMjcxOTUyMGMwNWVhZS4uZWY3MGViODQ3MTEwNzdjMmY3NjYyYzZhOTRh MTM2NTdlZjVhODFmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2Ev TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0NvY29hL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbQpAQCAtMjcsMTkgKzI3LDIxIEBACiAj aW1wb3J0ICJNZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaCIKIAogI2ltcG9ydCAiU2FuZGJveFV0 aWxpdGllcy5oIgotI2ltcG9ydCAiVENDU29mdExpbmsuaCIKICNpbXBvcnQgIldLV2ViVmlld0lu dGVybmFsLmgiCiAjaW1wb3J0ICJXZWJQYWdlUHJveHkuaCIKICNpbXBvcnQgPFdlYkNvcmUvTG9j YWxpemVkU3RyaW5ncy5oPgorI2ltcG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2lt cG9ydCA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbkRhdGEuaD4KICNpbXBvcnQgPG11dGV4PgotI2lt cG9ydCA8cGFsL2NvY29hL0FWRm91bmRhdGlvblNvZnRMaW5rLmg+Ci0jaW1wb3J0IDxwYWwvY29j b2EvU3BlZWNoU29mdExpbmsuaD4KICNpbXBvcnQgPHd0Zi9CbG9ja1B0ci5oPgogI2ltcG9ydCA8 d3RmL1VSTEhlbHBlcnMuaD4KICNpbXBvcnQgPHd0Zi9zcGkvY2YvQ0ZCdW5kbGVTUEkuaD4KICNp bXBvcnQgPHd0Zi9zcGkvZGFyd2luL1NhbmRib3hTUEkuaD4KIAorI2ltcG9ydCAiVENDU29mdExp bmsuaCIKKyNpbXBvcnQgPHBhbC9jb2NvYS9BVkZvdW5kYXRpb25Tb2Z0TGluay5oPgorI2ltcG9y dCA8cGFsL2NvY29hL1NwZWVjaFNvZnRMaW5rLmg+CisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBi b29sIGNoZWNrU2FuZGJveFJlcXVpcmVtZW50Rm9yVHlwZShNZWRpYVBlcm1pc3Npb25UeXBlIHR5 cGUpCkBAIC0yMjIsNiArMjI0LDIwIEBAIHZvaWQgYWxlcnRGb3JQZXJtaXNzaW9uKFdlYlBhZ2VQ cm94eSYgcGFnZSwgTWVkaWFQZXJtaXNzaW9uUmVhc29uIHJlYXNvbiwgY29uc3QKICNlbmRpZgog fQogCitzdGQ6Om9wdGlvbmFsPE1lZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVydFBlcm1pc3Np b25OYW1lVG9SZWFzb24oV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUpCit7 CisgICAgc3dpdGNoIChwZXJtaXNzaW9uTmFtZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlz c2lvbk5hbWU6OkNhbWVyYToKKyAgICAgICAgcmV0dXJuIE1lZGlhUGVybWlzc2lvblJlYXNvbjo6 Q2FtZXJhOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmU6Cisg ICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246Ok1pY3JvcGhvbmU7CisgICAgY2Fz ZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6R2VvbG9jYXRpb246CisgICAgICAgIHJldHVybiBN ZWRpYVBlcm1pc3Npb25SZWFzb246Okdlb2xvY2F0aW9uOworICAgIGRlZmF1bHQ6CisgICAgICAg IHJldHVybiBzdGQ6Om51bGxvcHQ7CisgICAgfQorfQorCiAjaWYgSEFWRShBVkNBUFRVUkVERVZJ Q0UpCiAKIHZvaWQgcmVxdWVzdEFWQ2FwdHVyZUFjY2Vzc0ZvclR5cGUoTWVkaWFQZXJtaXNzaW9u VHlwZSB0eXBlLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wgYXV0aG9yaXplZCk+JiYgY29t cGxldGlvbkhhbmRsZXIpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2Nv YS9VSURlbGVnYXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRl LmgKaW5kZXggMzI5ZGI3OTFjZjQzMjcyNDYzNjM0MjgwMDUwNGIwOGVhODlkYjBlMy4uMGViOTRj ZDA3N2Y1MmU1OGUxODJlMjdiZDVlOGFlYzUwZGVlYThiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0NvY29hL1VJRGVsZWdhdGUuaApAQCAtMTc1LDYgKzE3NSw4IEBAIHByaXZhdGU6CiAg ICAgICAgIHZvaWQgc3RhcnRYUlNlc3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRs ZXI8dm9pZChSZXRhaW5QdHI8aWQ+KT4mJikgZmluYWw7CiAjZW5kaWYKIAorICAgICAgICB2b2lk IHJlcXVlc3RQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luJiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mLCBXZWJDb3JlOjpQZXJtaXNz aW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJikgZmluYWw7CisKICAgICAg ICAgV2Vha1B0cjxVSURlbGVnYXRlPiBtX3VpRGVsZWdhdGU7CiAgICAgfTsKIApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbSBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW0KaW5kZXggYmRkNmIzYTY4MzM1NWFj ZWQzYjlhNzIwMjQ3YTYxMzE1ZWFlOWY0MS4uMWU2Mzg4ODg1OGYyYWI4ZjA0ZjMwYmUxMjljMzQx OGNjNzUwNmNmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlE ZWxlZ2F0ZS5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRl Lm1tCkBAIC02Myw2ICs2Myw3IEBACiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZDYXB0dXJlRGV2 aWNlLmg+CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZNZWRpYUZvcm1hdC5oPgogI2ltcG9ydCA8 V2ViQ29yZS9Gb250QXR0cmlidXRlcy5oPgorI2ltcG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFt ZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8d3RmL0Js b2NrUHRyLmg+CiAjaW1wb3J0IDx3dGYvVVJMLmg+CkBAIC0xNjg0LDQgKzE2ODUsMzggQEAgdm9p ZCBVSURlbGVnYXRlOjpVSUNsaWVudDo6c3RhcnRYUlNlc3Npb24oV2ViUGFnZVByb3h5JiwgQ29t cGxldGlvbkhhbmRsZXI8dm9pZCgKIH0KICNlbmRpZgogCit2b2lkIFVJRGVsZWdhdGU6OlVJQ2xp ZW50OjpyZXF1ZXN0UGVybWlzc2lvbihXZWJLaXQ6OldlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3Qg V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mIG9yaWdpbiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlP cmlnaW4mIHRvcE9yaWdpbiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgbmFtZSwgQ29tcGxldGlv bkhhbmRsZXI8dm9pZChib29sIGdyYW50ZWQpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQoreworICAg IGlmICghbV91aURlbGVnYXRlKQorICAgICAgICByZXR1cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lv bkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0YSgpLCBuYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25I YW5kbGVyKSk7CisKKyAgICBhdXRvIGRlbGVnYXRlID0gKGlkIDxXS1VJRGVsZWdhdGVQcml2YXRl PiltX3VpRGVsZWdhdGUtPm1fZGVsZWdhdGUuZ2V0KCk7CisgICAgaWYgKCFkZWxlZ2F0ZSkKKyAg ICAgICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24ob3JpZ2lu LmRhdGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOworCisgICAgaWYgKCFb ZGVsZWdhdGUgcmVzcG9uZHNUb1NlbGVjdG9yOkBzZWxlY3Rvcihfd2ViVmlldzpyZXF1ZXN0UGVy bWlzc2lvbkZvck5hbWU6b3JpZ2luOnRvcE9yaWdpbjpkZWNpc2lvbkhhbmRsZXI6KV0pCisgICAg ICAgIHJldHVybiBwYWdlLnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKG9yaWdpbi5k YXRhKCksIG5hbWUsIFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpKTsKKworICAgIGF1dG8gYXBp T3JpZ2luID0gQVBJOjpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlKG9yaWdpbik7CisgICAgYXV0byBh cGlUb3BPcmlnaW4gPSBBUEk6OlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUodG9wT3JpZ2luKTsKKyAg ICBXVEY6OlN0cmluZyBuYW1lU3RyaW5nID0gcGVybWlzc2lvbk5hbWVUb1N0cmluZyhuYW1lKTsK KyAgICBhdXRvIGNoZWNrZXIgPSBDb21wbGV0aW9uSGFuZGxlckNhbGxDaGVja2VyOjpjcmVhdGUo ZGVsZWdhdGUsIEBzZWxlY3Rvcihfd2ViVmlldzpyZXF1ZXN0UGVybWlzc2lvbkZvck5hbWU6b3Jp Z2luOnRvcE9yaWdpbjpkZWNpc2lvbkhhbmRsZXI6KSk7CisgICAgW2RlbGVnYXRlIF93ZWJWaWV3 Om1fdWlEZWxlZ2F0ZS0+bV93ZWJWaWV3LmdldCgpLmdldCgpIHJlcXVlc3RQZXJtaXNzaW9uRm9y TmFtZTpuYW1lU3RyaW5nIG9yaWdpbjp3cmFwcGVyKGFwaU9yaWdpbikgdG9wT3JpZ2luOndyYXBw ZXIoYXBpVG9wT3JpZ2luKSBkZWNpc2lvbkhhbmRsZXI6bWFrZUJsb2NrUHRyKFtjb21wbGV0aW9u SGFuZGxlciA9IHN0ZDo6ZXhjaGFuZ2UoY29tcGxldGlvbkhhbmRsZXIsIHsgfSksIGNoZWNrZXIg PSBXVEZNb3ZlKGNoZWNrZXIpLCBwYWdlID0gbWFrZVdlYWtQdHIocGFnZSksIG5hbWUsIG9yaWdp bkRhdGEgPSBvcmlnaW4uZGF0YSgpXSAoV0tQZXJtaXNzaW9uRGVjaXNpb24gZGVjaXNpb24pIG11 dGFibGUgeworICAgICAgICBpZiAoY2hlY2tlci0+Y29tcGxldGlvbkhhbmRsZXJIYXNCZWVuQ2Fs bGVkKCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIGNoZWNrZXItPmRpZENhbGxDb21w bGV0aW9uSGFuZGxlcigpOworCisgICAgICAgIHN3aXRjaCAoZGVjaXNpb24pIHsKKyAgICAgICAg Y2FzZSBXS1Blcm1pc3Npb25EZWNpc2lvblByb21wdDoKKyAgICAgICAgICAgIGlmICghcGFnZSkK KyAgICAgICAgICAgICAgICByZXR1cm4gY29tcGxldGlvbkhhbmRsZXIoZmFsc2UpOworICAgICAg ICAgICAgcmV0dXJuIHBhZ2UtPnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKG9yaWdp bkRhdGEsIG5hbWUsIFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpKTsKKyAgICAgICAgY2FzZSBX S1Blcm1pc3Npb25EZWNpc2lvbkdyYW50OgorICAgICAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25I YW5kbGVyKHRydWUpOworICAgICAgICBjYXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uRGVueToKKyAg ICAgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcihmYWxzZSk7CisgICAgICAgIH0KKyAg ICB9KS5nZXQoKV07Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvV2ViUGFnZVByb3h5Q29jb2EubW0gYi9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9XZWJQYWdlUHJveHlDb2NvYS5tbQppbmRleCAzMzAxZWQ0 OGYwNDVhOWRkNTRmM2E4NTNiYWU5MGYxMmVkYTdjYTU3Li45YWU0ZTY3MDM4YzRjOGFmZTNhYTVj YTExYzg4OTEyMTdlMGY0ODZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9D b2NvYS9XZWJQYWdlUHJveHlDb2NvYS5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9D b2NvYS9XZWJQYWdlUHJveHlDb2NvYS5tbQpAQCAtMzQsNiArMzQsNyBAQAogI2ltcG9ydCAiRGF0 YURldGVjdGlvblJlc3VsdC5oIgogI2ltcG9ydCAiSW5zZXJ0VGV4dE9wdGlvbnMuaCIKICNpbXBv cnQgIkxvYWRQYXJhbWV0ZXJzLmgiCisjaW1wb3J0ICJNZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMu aCIKICNpbXBvcnQgIlBhZ2VDbGllbnQuaCIKICNpbXBvcnQgIlF1YXJhbnRpbmVTUEkuaCIKICNp bXBvcnQgIlF1aWNrTG9va1RodW1ibmFpbExvYWRlci5oIgpAQCAtNzUwLDYgKzc1MSwxNSBAQCBi b29sIFdlYlBhZ2VQcm94eTo6aXNRdWFyYW50aW5lZEFuZE5vdFVzZXJBcHByb3ZlZChjb25zdCBT dHJpbmcmIGZpbGVVUkxTdHJpbmcpCiB9CiAjZW5kaWYKIAordm9pZCBXZWJQYWdlUHJveHk6OnJl cXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3Jp Z2luRGF0YSYgb3JpZ2luLCBQZXJtaXNzaW9uTmFtZSBwZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlv bkhhbmRsZXI8dm9pZChib29sKT4mJiBjb21wbGV0aW9uSGFuZGxlcikKK3sKKyAgICBhdXRvIHJl YXNvbiA9IGNvbnZlcnRQZXJtaXNzaW9uTmFtZVRvUmVhc29uKHBlcm1pc3Npb25OYW1lKTsKKyAg ICBpZiAoIXJlYXNvbikKKyAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsK KworICAgIGFsZXJ0Rm9yUGVybWlzc2lvbigqdGhpcywgKnJlYXNvbiwgb3JpZ2luLCBXVEZNb3Zl KGNvbXBsZXRpb25IYW5kbGVyKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjdW5k ZWYgTUVTU0FHRV9DSEVDS19DT01QTEVUSU9OCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oCmluZGV4IDVhMzE1MTY5NWNjNGQ4ZTQwMzQ3 MDY0ZmNmYWU0NTgxZmQ3ZmExOTUuLmM2YzBhYTcwYWI4M2M4ZjdhNDhlNWU0MWZiMTZhZWZkYThj ZjgzOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5oCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CitlbnVtIGNsYXNzIFBlcm1pc3Npb25OYW1lIDogdWludDhf dDsKIGNsYXNzIFNlY3VyaXR5T3JpZ2luOwogfQogCkBAIC01Nyw2ICs1OCw4IEBAIGVudW0gY2xh c3MgTWVkaWFQZXJtaXNzaW9uUmVhc29uIHsKICAgICBTcGVlY2hSZWNvZ25pdGlvbgogfTsKIAor c3RkOjpvcHRpb25hbDxNZWRpYVBlcm1pc3Npb25SZWFzb24+IGNvbnZlcnRQZXJtaXNzaW9uTmFt ZVRvUmVhc29uKFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lKTsKKwogI2lmIFBMQVRGT1JNKENPQ09B KQogYm9vbCBjaGVja1NhbmRib3hSZXF1aXJlbWVudEZvclR5cGUoTWVkaWFQZXJtaXNzaW9uVHlw ZSk7CiBib29sIGNoZWNrVXNhZ2VEZXNjcmlwdGlvblN0cmluZ0ZvclR5cGUoTWVkaWFQZXJtaXNz aW9uVHlwZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAppbmRleCAy ZmU5M2E1OTE1NmU4YjBlNjk4N2MwODg1NWQzZDBhZDMyOWM4MDY1Li5lMjJkNmU2MDhmZGI5ZDM3 ZjcwMmM1MjQ0MDA4MWE5YTMxMDMyYTU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9XZWJQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBh Z2VQcm94eS5jcHAKQEAgLTE3MSw2ICsxNzEsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvTUlNRVR5 cGVSZWdpc3RyeS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvTWVkaWFTdHJlYW1SZXF1ZXN0Lmg+CiAj aW5jbHVkZSA8V2ViQ29yZS9QZXJmb3JtYW5jZUxvZ2dpbmdDbGllbnQuaD4KKyNpbmNsdWRlIDxX ZWJDb3JlL1Blcm1pc3Npb25EZXNjcmlwdG9yLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9QZXJtaXNz aW9uU3RhdGUuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BsYXRmb3JtRXZlbnQuaD4KICNpbmNsdWRl IDxXZWJDb3JlL1ByaXZhdGVDbGlja01lYXN1cmVtZW50Lmg+CkBAIC04NTAyLDEwICs4NTAzLDE0 IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpyZXZva2VHZW9sb2NhdGlvbkF1dGhvcml6YXRpb25Ub2tl bihjb25zdCBTdHJpbmcmIGF1dGhvcml6YXRpCiAgICAgbV9nZW9sb2NhdGlvblBlcm1pc3Npb25S ZXF1ZXN0TWFuYWdlci5yZXZva2VBdXRob3JpemF0aW9uVG9rZW4oYXV0aG9yaXphdGlvblRva2Vu KTsKIH0KIAotdm9pZCBXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uKGNvbnN0IENsaWVu dE9yaWdpbiYsIGNvbnN0IFBlcm1pc3Npb25EZXNjcmlwdG9yJiwgQ29tcGxldGlvbkhhbmRsZXI8 dm9pZChQZXJtaXNzaW9uU3RhdGUpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQordm9pZCBXZWJQYWdl UHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uKGNvbnN0IENsaWVudE9yaWdpbiYgb3JpZ2luLCBjb25z dCBQZXJtaXNzaW9uRGVzY3JpcHRvciYgZGVzY3JpcHRvciwgQ29tcGxldGlvbkhhbmRsZXI8dm9p ZChQZXJtaXNzaW9uU3RhdGUpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQogewotICAgIC8vIEZJWE1F OiBTaG93IGEgcHJvbXB0IGZvciB1c2VyIGlucHV0LgotICAgIGNvbXBsZXRpb25IYW5kbGVyKFBl cm1pc3Npb25TdGF0ZTo6R3JhbnRlZCk7CisgICAgYXV0byBzZWN1cml0eU9yaWdpbiA9IG9yaWdp bi5jbGllbnRPcmlnaW4uc2VjdXJpdHlPcmlnaW4oKTsKKyAgICBhdXRvIHRvcFNlY3VyaXR5T3Jp Z2luID0gb3JpZ2luLnRvcE9yaWdpbi5zZWN1cml0eU9yaWdpbigpOworICAgIG1fdWlDbGllbnQt PnJlcXVlc3RQZXJtaXNzaW9uKCp0aGlzLCBzZWN1cml0eU9yaWdpbi5nZXQoKSwgdG9wU2VjdXJp dHlPcmlnaW4uZ2V0KCksIGRlc2NyaXB0b3IubmFtZSwgW2NvbXBsZXRpb25IYW5kbGVyID0gV1RG TW92ZShjb21wbGV0aW9uSGFuZGxlcildKGJvb2wgZ3JhbnRlZCkgbXV0YWJsZSB7CisgICAgICAg IGF1dG8gcGVybWlzc2lvbnNTdGF0ZSA9IGdyYW50ZWQgPyBQZXJtaXNzaW9uU3RhdGU6OkdyYW50 ZWQgOiBQZXJtaXNzaW9uU3RhdGU6OkRlbmllZDsKKyAgICAgICAgY29tcGxldGlvbkhhbmRsZXIo cGVybWlzc2lvbnNTdGF0ZSk7CisgICAgfSk7CiB9CiAKICNpZiBFTkFCTEUoTUVESUFfU1RSRUFN KQpAQCAtMTA4NzYsNiArMTA4ODEsMTUgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmNsZWFyQXBwUHJp dmFjeVJlcG9ydFRlc3RpbmdEYXRhKENvbXBsZXRpb25IYW5kbGVyPHZvaWQoKT4mJgogfQogI2Vu ZGlmCiAKKyNpZiAhUExBVEZPUk0oQ09DT0EpCisKK3ZvaWQgV2ViUGFnZVByb3h5OjpyZXF1ZXN0 UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbkRh dGEmLCBQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJiBjb21w bGV0aW9uSGFuZGxlcikKK3sKKyAgICBjb21wbGV0aW9uSGFuZGxlcihmYWxzZSk7Cit9CisKKyNl bmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI3VuZGVmIFdFQlBBR0VQUk9YWV9SRUxF QVNFX0xPRwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5 LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAppbmRleCA1NGZhZDIy M2QxYTM4OGU5YzBkNGE2N2E0NTRhYTNmZjVjMGRjODBkLi5iZDk2YTRmYzkxNDVhMjRhZjVlN2Mw ZWY3YWEzOTBmZTVkY2ZhOTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHku aApAQCAtMjY4LDYgKzI2OCw3IEBAIGVudW0gY2xhc3MgSGlnaGxpZ2h0UmVxdWVzdE9yaWdpbmF0 ZWRJbkFwcCA6IGJvb2w7CiBlbnVtIGNsYXNzIEhpZ2hsaWdodFZpc2liaWxpdHkgOiBib29sOwog ZW51bSBjbGFzcyBNb3VzZUV2ZW50UG9saWN5IDogdWludDhfdDsKIGVudW0gY2xhc3MgTm90aWZp Y2F0aW9uRGlyZWN0aW9uIDogdWludDhfdDsKK2VudW0gY2xhc3MgUGVybWlzc2lvbk5hbWUgOiB1 aW50OF90OwogZW51bSBjbGFzcyBSb3V0ZVNoYXJpbmdQb2xpY3kgOiB1aW50OF90OwogZW51bSBj bGFzcyBTZWxlY3Rpb25EaXJlY3Rpb24gOiB1aW50OF90OwogZW51bSBjbGFzcyBTaG91bGRTYW1w bGUgOiBib29sOwpAQCAtMTkwNCw2ICsxOTA1LDcgQEAgcHVibGljOgogICAgIHZvaWQgcmVxdWVz dFVzZXJNZWRpYVBlcm1pc3Npb25Gb3JTcGVlY2hSZWNvZ25pdGlvbihXZWJDb3JlOjpGcmFtZUlk ZW50aWZpZXIsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwgY29uc3QgV2ViQ29yZTo6 U2VjdXJpdHlPcmlnaW4mLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmKTsKIAogICAg IHZvaWQgcmVxdWVzdE1lZGlhS2V5U3lzdGVtUGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25z dCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbkRhdGEmLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJv b2wpPiYmKTsKKyAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0 IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luRGF0YSYsIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lLCBD b21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmKTsKIAogICAgIHZvaWQgc3luY0lmTW9ja0Rl dmljZXNFbmFibGVkQ2hhbmdlZCgpOwogCg== 437295 2021-09-03 12:35:56 -0700 2021-09-05 14:28:44 -0700 Patch bug-229590-20210903123556.patch text/plain 17288 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgyMDA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDYxYzA3ZjVkMjgwZWQw YTdiZmFlYTNhODliYjIyNDlhZDhjYzgwOS4uZjg0YzU2NmNmZjUwYThlOTgzNmY1NzEyN2UyYTQy YjczOTk2NmYwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDIxLTA5LTAzICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIE5v IG9ic2VydmFibGUgYmVoYXZpb3IgY2hhbmdlIGFzIHRoZSBwZXJtaXNpb24gcmVxdWVzdCBmbG93 IGlzIG5vdCB1c2VkIGJ5IGFueSBmZWF0dXJlIHlldC4KKworICAgICAgICAqIE1vZHVsZXMvcGVy bWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaDoKKwogMjAyMS0wOS0wMyAgWmlyYW4gU3VuICA8enN1 bkBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04ocjI4MDA3OCk6IGJyb2tlIGZhc3Qv aW1hZ2VzL2V4aWYtb3JpZW50YXRpb24tY29tcG9zaXRlZC5odG1sIG9uIHdpbmRvd3MKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cK aW5kZXggNTQxZjc1MjJjNGQ2ZmE4MjNmMTJkNzM2ZTA4ODQ4ZDExMThjYTgzOS4uNjZkMTllNGY3 YzFkMmYwZWVlM2MxZjg3NjY0NmIyNDkyOThiOTY4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMCBA QAorMjAyMS0wOS0wMyAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAg ICBBZGQgcHJvbXB0IGZvciBQZXJtaXNzaW9ucyBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyOTU5MAorICAgICAgICA8cmRhcjovL3Byb2JsZW0v ODI2ODY5NDg+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgRGlzcGxheSBhIHByb21wdCBmb3IgcGVybWlzc2lvbiByZXF1ZXN0IGJ5IGRlZmF1bHQuCisK KyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50Lmg6CisgICAgICAgIChBUEk6OlVJ Q2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS1VJRGVsZWdhdGVQcml2YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL01lZGlh UGVybWlzc2lvblV0aWxpdGllcy5tbToKKyAgICAgICAgKFdlYktpdDo6Y29udmVydFBlcm1pc3Np b25OYW1lVG9SZWFzb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmg6 CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW06CisgICAgICAgIChXZWJL aXQ6OnRvV0tQZXJtaXNzaW9uTmFtZSk6CisgICAgICAgIChXZWJLaXQ6OlVJRGVsZWdhdGU6OlVJ Q2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1dl YlBhZ2VQcm94eUNvY29hLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVl c3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTWVkaWFQ ZXJtaXNzaW9uVXRpbGl0aWVzLmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb24pOgor ICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0 QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6CisKIDIwMjEtMDkt MDMgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hyaXN0ZW5zZW5Ad2Via2l0Lm9yZz4KIAogICAgICAg ICBDbGVhbiB1cCBQcml2YXRlQ2xpY2tNZWFzdXJlbWVudE1hbmFnZXIgaW50ZXJmYWNlCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1l LmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgK aW5kZXggZGQyODNmMTY5NDJjMDVkMjMxYzNhOWZkYmJjZDJhYjdlNGY5ODg5My4uNDBhNGZlMjBj ZWY1MGFjMThhYWVkNzQxZTk4NWMzMjc4ODFhMzJjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaApAQCAtMjYsNiArMjYsNyBA QAogI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRlIDx3dGYvRW51bVRyYWl0cy5oPgorI2luY2x1ZGUg PHd0Zi90ZXh0L0FTQ0lJTGl0ZXJhbC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50LmgKaW5kZXggMmRiMGY1NjljYjIyNTA1 ODllN2VjMTYwNThkYWZiNWE2YTRlN2JmMC4uZGZkOTNlMWFlZjhiNjMzMTAzM2M0ODM3MWIxZWVk ZWZmMzg3MTNkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0FQSVVJ Q2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50LmgK QEAgLTQ0LDEwICs0NCwxMCBAQCBPQkpDX0NMQVNTIFVJVmlld0NvbnRyb2xsZXI7CiAjZW5kaWYK IAogbmFtZXNwYWNlIFdlYkNvcmUgeworZW51bSBjbGFzcyBQZXJtaXNzaW9uTmFtZSA6IHVpbnQ4 X3Q7CiBjbGFzcyBSZWdpc3RyYWJsZURvbWFpbjsKIGNsYXNzIFJlc291cmNlUmVxdWVzdDsKIHN0 cnVjdCBGb250QXR0cmlidXRlczsKLXN0cnVjdCBTZWN1cml0eU9yaWdpbkRhdGE7CiBzdHJ1Y3Qg V2luZG93RmVhdHVyZXM7CiB9CiAKQEAgLTIxMSw2ICsyMTEsOCBAQCBwdWJsaWM6CiAjaWYgRU5B QkxFKFdFQlhSKSAmJiBQTEFURk9STShDT0NPQSkKICAgICB2aXJ0dWFsIHZvaWQgc3RhcnRYUlNl c3Npb24oV2ViS2l0OjpXZWJQYWdlUHJveHkmLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKFJldGFp blB0cjxpZD4pPiYmIGNvbXBsZXRpb25IYW5kbGVyKSB7IGNvbXBsZXRpb25IYW5kbGVyKG5pbCk7 IH0KICNlbmRpZgorCisgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFdlYktpdDo6 V2ViUGFnZVByb3h5JiBwYWdlLCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgb3JpZ2lu LCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgdG9wT3JpZ2luLCBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZSBwZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4m JiBjb21wbGV0aW9uSGFuZGxlcikgeyBwYWdlLnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0 aW9uKG9yaWdpbi5kYXRhKCksIHBlcm1pc3Npb25OYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5k bGVyKSk7IH0KIH07CiAKIH0gLy8gbmFtZXNwYWNlIEFQSQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0ZVByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmgKaW5kZXggZjY2 YTFiYTNlODkyMjUzZjE3NjMzYzM0MmMyMjlhZGZhYWIyMTMyMS4uNzljZjM3MDNiODI1MDJkMGQz MWI5Yzk1ZGQ2YTQ2ZDZiNTRhMGJkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0ZVByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tVSURlbGVnYXRlUHJpdmF0ZS5oCkBAIC04OCw2ICs4OCwyMiBA QCB0eXBlZGVmIE5TX0VOVU0oTlNJbnRlZ2VyLCBfV0tGb2N1c0RpcmVjdGlvbikgewogICAgIF9X S0ZvY3VzRGlyZWN0aW9uRm9yd2FyZCwKIH0gV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMC4xMy40 KSwgaW9zKDEyLjIpKTsKIAordHlwZWRlZiBOU19FTlVNKE5TSW50ZWdlciwgX1dLUGVybWlzc2lv bk5hbWUpIHsKKyAgICBfV0tQZXJtaXNzaW9uTmFtZUFjY2VsZXJvbWV0ZXIsCisgICAgX1dLUGVy bWlzc2lvbk5hbWVCYWNrZ3JvdW5kRmV0Y2gsCisgICAgX1dLUGVybWlzc2lvbk5hbWVCbHVldG9v dGgsCisgICAgX1dLUGVybWlzc2lvbk5hbWVDYW1lcmEsCisgICAgX1dLUGVybWlzc2lvbk5hbWVE aXNwbGF5Q2FwdHVyZSwKKyAgICBfV0tQZXJtaXNzaW9uTmFtZUdlb2xvY2F0aW9uLAorICAgIF9X S1Blcm1pc3Npb25OYW1lR3lyb3Njb3BlLAorICAgIF9XS1Blcm1pc3Npb25OYW1lTWFnbmV0b21l dGVyLAorICAgIF9XS1Blcm1pc3Npb25OYW1lTWljcm9waG9uZSwKKyAgICBfV0tQZXJtaXNzaW9u TmFtZU1pZGksCisgICAgX1dLUGVybWlzc2lvbk5hbWVORkMsCisgICAgX1dLUGVybWlzc2lvbk5h bWVOb3RpZmljYXRpb25zLAorICAgIF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbgor fSBXS19BUElfQVZBSUxBQkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoV0tfSU9TX1RCQSkpOwor CiBAcHJvdG9jb2wgV0tVSURlbGVnYXRlUHJpdmF0ZSA8V0tVSURlbGVnYXRlPgogCiAjaWZkZWYg Rk9VTkRBVElPTl9IQVNfRElSRUNUSU9OQUxfR0VPTUVUUlkKQEAgLTE2MCw2ICsxNzYsOCBAQCBz dHJ1Y3QgVUlFZGdlSW5zZXRzOwogCiAtICh2b2lkKV93ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJW aWV3IHN0YXJ0WFJTZXNzaW9uV2l0aENvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShpZCkpY29t cGxldGlvbkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMi4wKSwgaW9zKDE1LjApKTsK IAorLSAodm9pZClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyByZXF1ZXN0UGVybWlzc2lv bkZvck5hbWU6KF9XS1Blcm1pc3Npb25OYW1lKW5hbWUgb3JpZ2luOihXS1NlY3VyaXR5T3JpZ2lu ICopb3JpZ2luIHRvcE9yaWdpbjooV0tTZWN1cml0eU9yaWdpbiAqKXRvcE9yaWdpbiBkZWNpc2lv bkhhbmRsZXI6KHZvaWQgKF4pKFdLUGVybWlzc2lvbkRlY2lzaW9uIGRlY2lzaW9uKSlkZWNpc2lv bkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19U QkEpKTsKKwogI2lmIFRBUkdFVF9PU19JUEhPTkUKIAogLSAoQk9PTClfd2ViVmlldzooV0tXZWJW aWV3ICopd2ViVmlldyBzaG91bGRJbmNsdWRlQXBwTGlua0FjdGlvbnNGb3JFbGVtZW50OihfV0tB Y3RpdmF0ZWRFbGVtZW50SW5mbyAqKWVsZW1lbnQgV0tfQVBJX0FWQUlMQUJMRShpb3MoOS4wKSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1p c3Npb25VdGlsaXRpZXMubW0KaW5kZXggMTRlOWM4YWI1YmJmY2JmZmEwNGRkYjg1Y2JiMjcxOTUy MGMwNWVhZS4uZWY3MGViODQ3MTEwNzdjMmY3NjYyYzZhOTRhMTM2NTdlZjVhODFmZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvTWVkaWFQZXJtaXNzaW9uVXRpbGl0 aWVzLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5tbQpAQCAtMjcsMTkgKzI3LDIxIEBACiAjaW1wb3J0ICJNZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMuaCIKIAogI2ltcG9ydCAiU2FuZGJveFV0aWxpdGllcy5oIgotI2ltcG9ydCAi VENDU29mdExpbmsuaCIKICNpbXBvcnQgIldLV2ViVmlld0ludGVybmFsLmgiCiAjaW1wb3J0ICJX ZWJQYWdlUHJveHkuaCIKICNpbXBvcnQgPFdlYkNvcmUvTG9jYWxpemVkU3RyaW5ncy5oPgorI2lt cG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0 eU9yaWdpbkRhdGEuaD4KICNpbXBvcnQgPG11dGV4PgotI2ltcG9ydCA8cGFsL2NvY29hL0FWRm91 bmRhdGlvblNvZnRMaW5rLmg+Ci0jaW1wb3J0IDxwYWwvY29jb2EvU3BlZWNoU29mdExpbmsuaD4K ICNpbXBvcnQgPHd0Zi9CbG9ja1B0ci5oPgogI2ltcG9ydCA8d3RmL1VSTEhlbHBlcnMuaD4KICNp bXBvcnQgPHd0Zi9zcGkvY2YvQ0ZCdW5kbGVTUEkuaD4KICNpbXBvcnQgPHd0Zi9zcGkvZGFyd2lu L1NhbmRib3hTUEkuaD4KIAorI2ltcG9ydCAiVENDU29mdExpbmsuaCIKKyNpbXBvcnQgPHBhbC9j b2NvYS9BVkZvdW5kYXRpb25Tb2Z0TGluay5oPgorI2ltcG9ydCA8cGFsL2NvY29hL1NwZWVjaFNv ZnRMaW5rLmg+CisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBib29sIGNoZWNrU2FuZGJveFJlcXVp cmVtZW50Rm9yVHlwZShNZWRpYVBlcm1pc3Npb25UeXBlIHR5cGUpCkBAIC0yMjIsNiArMjI0LDIw IEBAIHZvaWQgYWxlcnRGb3JQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYgcGFnZSwgTWVkaWFQZXJt aXNzaW9uUmVhc29uIHJlYXNvbiwgY29uc3QKICNlbmRpZgogfQogCitzdGQ6Om9wdGlvbmFsPE1l ZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUpCit7CisgICAgc3dpdGNoIChwZXJtaXNz aW9uTmFtZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkNhbWVyYToKKyAg ICAgICAgcmV0dXJuIE1lZGlhUGVybWlzc2lvblJlYXNvbjo6Q2FtZXJhOworICAgIGNhc2UgV2Vi Q29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmU6CisgICAgICAgIHJldHVybiBNZWRpYVBl cm1pc3Npb25SZWFzb246Ok1pY3JvcGhvbmU7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9u TmFtZTo6R2VvbG9jYXRpb246CisgICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246 Okdlb2xvY2F0aW9uOworICAgIGRlZmF1bHQ6CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7 CisgICAgfQorfQorCiAjaWYgSEFWRShBVkNBUFRVUkVERVZJQ0UpCiAKIHZvaWQgcmVxdWVzdEFW Q2FwdHVyZUFjY2Vzc0ZvclR5cGUoTWVkaWFQZXJtaXNzaW9uVHlwZSB0eXBlLCBDb21wbGV0aW9u SGFuZGxlcjx2b2lkKGJvb2wgYXV0aG9yaXplZCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmggYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmgKaW5kZXggMzI5ZGI3OTFjZjQz MjcyNDYzNjM0MjgwMDUwNGIwOGVhODlkYjBlMy4uMGViOTRjZDA3N2Y1MmU1OGUxODJlMjdiZDVl OGFlYzUwZGVlYThiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2Ev VUlEZWxlZ2F0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdh dGUuaApAQCAtMTc1LDYgKzE3NSw4IEBAIHByaXZhdGU6CiAgICAgICAgIHZvaWQgc3RhcnRYUlNl c3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+ KT4mJikgZmluYWw7CiAjZW5kaWYKIAorICAgICAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFdl YlBhZ2VQcm94eSYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwgY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW4mLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhh bmRsZXI8dm9pZChib29sKT4mJikgZmluYWw7CisKICAgICAgICAgV2Vha1B0cjxVSURlbGVnYXRl PiBtX3VpRGVsZWdhdGU7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29h L1VJRGVsZWdhdGUubW0KaW5kZXggYmRkNmIzYTY4MzM1NWFjZWQzYjlhNzIwMjQ3YTYxMzE1ZWFl OWY0MS4uYjU4OWJmOTIzNzliZjRhZTdmMDI3ZGJhZTU2MWJjMjIyMTA1NTA5OCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbQorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tCkBAIC02Myw2ICs2Myw3IEBA CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZDYXB0dXJlRGV2aWNlLmg+CiAjaW1wb3J0IDxBVkZv dW5kYXRpb24vQVZNZWRpYUZvcm1hdC5oPgogI2ltcG9ydCA8V2ViQ29yZS9Gb250QXR0cmlidXRl cy5oPgorI2ltcG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29y ZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3 dGYvVVJMLmg+CkBAIC0xNjg0LDQgKzE2ODUsNjkgQEAgdm9pZCBVSURlbGVnYXRlOjpVSUNsaWVu dDo6c3RhcnRYUlNlc3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgK IH0KICNlbmRpZgogCitzdGF0aWMgaW5saW5lIF9XS1Blcm1pc3Npb25OYW1lIHRvV0tQZXJtaXNz aW9uTmFtZShXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBuYW1lKQoreworICAgIHN3aXRjaCAobmFt ZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkFjY2VsZXJvbWV0ZXI6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZUFjY2VsZXJvbWV0ZXI7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZldGNoOgorICAgICAgICByZXR1cm4g X1dLUGVybWlzc2lvbk5hbWVCYWNrZ3JvdW5kRmV0Y2g7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6Qmx1ZXRvb3RoOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVC bHVldG9vdGg7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Q2FtZXJhOgorICAg ICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVDYW1lcmE7CisgICAgY2FzZSBXZWJDb3JlOjpQ ZXJtaXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmU6CisgICAgICAgIHJldHVybiBfV0tQZXJtaXNz aW9uTmFtZURpc3BsYXlDYXB0dXJlOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6 Okdlb2xvY2F0aW9uOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVHZW9sb2NhdGlv bjsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpHeXJvc2NvcGU6CisgICAgICAg IHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZUd5cm9zY29wZTsKKyAgICBjYXNlIFdlYkNvcmU6OlBl cm1pc3Npb25OYW1lOjpNYWduZXRvbWV0ZXI6CisgICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9u TmFtZU1hZ25ldG9tZXRlcjsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpNaWNy b3Bob25lOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVNaWNyb3Bob25lOworICAg IGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pZGk6CisgICAgICAgIHJldHVybiBfV0tQ ZXJtaXNzaW9uTmFtZU1pZGk7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6TmZj OgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVORkM7CisgICAgY2FzZSBXZWJDb3Jl OjpQZXJtaXNzaW9uTmFtZTo6Tm90aWZpY2F0aW9uczoKKyAgICAgICAgcmV0dXJuIF9XS1Blcm1p c3Npb25OYW1lTm90aWZpY2F0aW9uczsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1l OjpTcGVha2VyU2VsZWN0aW9uOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVTcGVh a2VyU2VsZWN0aW9uOworICAgIH0KK30KKwordm9pZCBVSURlbGVnYXRlOjpVSUNsaWVudDo6cmVx dWVzdFBlcm1pc3Npb24oV2ViS2l0OjpXZWJQYWdlUHJveHkmIHBhZ2UsIGNvbnN0IFdlYkNvcmU6 OlNlY3VyaXR5T3JpZ2luJiBvcmlnaW4sIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiB0 b3BPcmlnaW4sIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lIG5hbWUsIENvbXBsZXRpb25IYW5kbGVy PHZvaWQoYm9vbCBncmFudGVkKT4mJiBjb21wbGV0aW9uSGFuZGxlcikKK3sKKyAgICBpZiAoIW1f dWlEZWxlZ2F0ZSkKKyAgICAgICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24ob3JpZ2luLmRhdGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikp OworCisgICAgYXV0byBkZWxlZ2F0ZSA9IChpZCA8V0tVSURlbGVnYXRlUHJpdmF0ZT4pbV91aURl bGVnYXRlLT5tX2RlbGVnYXRlLmdldCgpOworICAgIGlmICghZGVsZWdhdGUpCisgICAgICAgIHJl dHVybiBwYWdlLnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKG9yaWdpbi5kYXRhKCks IG5hbWUsIFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpKTsKKworICAgIGlmICghW2RlbGVnYXRl IHJlc3BvbmRzVG9TZWxlY3RvcjpAc2VsZWN0b3IoX3dlYlZpZXc6cmVxdWVzdFBlcm1pc3Npb25G b3JOYW1lOm9yaWdpbjp0b3BPcmlnaW46ZGVjaXNpb25IYW5kbGVyOildKQorICAgICAgICByZXR1 cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0YSgpLCBu YW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7CisKKyAgICBhdXRvIGFwaU9yaWdpbiA9 IEFQSTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZShvcmlnaW4pOworICAgIGF1dG8gYXBpVG9wT3Jp Z2luID0gQVBJOjpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlKHRvcE9yaWdpbik7CisgICAgYXV0byBj aGVja2VyID0gQ29tcGxldGlvbkhhbmRsZXJDYWxsQ2hlY2tlcjo6Y3JlYXRlKGRlbGVnYXRlLCBA c2VsZWN0b3IoX3dlYlZpZXc6cmVxdWVzdFBlcm1pc3Npb25Gb3JOYW1lOm9yaWdpbjp0b3BPcmln aW46ZGVjaXNpb25IYW5kbGVyOikpOworICAgIFtkZWxlZ2F0ZSBfd2ViVmlldzptX3VpRGVsZWdh dGUtPm1fd2ViVmlldy5nZXQoKS5nZXQoKSByZXF1ZXN0UGVybWlzc2lvbkZvck5hbWU6dG9XS1Bl cm1pc3Npb25OYW1lKG5hbWUpIG9yaWdpbjp3cmFwcGVyKGFwaU9yaWdpbikgdG9wT3JpZ2luOndy YXBwZXIoYXBpVG9wT3JpZ2luKSBkZWNpc2lvbkhhbmRsZXI6bWFrZUJsb2NrUHRyKFtjb21wbGV0 aW9uSGFuZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpLCBjaGVja2VyID0gV1RGTW92 ZShjaGVja2VyKSwgcGFnZSA9IG1ha2VXZWFrUHRyKHBhZ2UpLCBuYW1lLCBvcmlnaW5EYXRhID0g b3JpZ2luLmRhdGEoKV0gKFdLUGVybWlzc2lvbkRlY2lzaW9uIGRlY2lzaW9uKSBtdXRhYmxlIHsK KyAgICAgICAgaWYgKGNoZWNrZXItPmNvbXBsZXRpb25IYW5kbGVySGFzQmVlbkNhbGxlZCgpKQor ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBjaGVja2VyLT5kaWRDYWxsQ29tcGxldGlvbkhh bmRsZXIoKTsKKworICAgICAgICBzd2l0Y2ggKGRlY2lzaW9uKSB7CisgICAgICAgIGNhc2UgV0tQ ZXJtaXNzaW9uRGVjaXNpb25Qcm9tcHQ6CisgICAgICAgICAgICBpZiAoIXBhZ2UpCisgICAgICAg ICAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsKKyAgICAgICAgICAgIHJl dHVybiBwYWdlLT5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW5EYXRhLCBu YW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7CisgICAgICAgIGNhc2UgV0tQZXJtaXNz aW9uRGVjaXNpb25HcmFudDoKKyAgICAgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcih0 cnVlKTsKKyAgICAgICAgY2FzZSBXS1Blcm1pc3Npb25EZWNpc2lvbkRlbnk6CisgICAgICAgICAg ICByZXR1cm4gY29tcGxldGlvbkhhbmRsZXIoZmFsc2UpOworICAgICAgICB9CisgICAgfSkuZ2V0 KCldOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvQ29jb2EvV2ViUGFnZVByb3h5Q29jb2EubW0KaW5kZXggMzMwMWVkNDhmMDQ1YTlk ZDU0ZjNhODUzYmFlOTBmMTJlZGE3Y2E1Ny4uOWFlNGU2NzAzOGM0YzhhZmUzYWE1Y2ExMWM4ODkx MjE3ZTBmNDg2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvV2Vi UGFnZVByb3h5Q29jb2EubW0KKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvV2Vi UGFnZVByb3h5Q29jb2EubW0KQEAgLTM0LDYgKzM0LDcgQEAKICNpbXBvcnQgIkRhdGFEZXRlY3Rp b25SZXN1bHQuaCIKICNpbXBvcnQgIkluc2VydFRleHRPcHRpb25zLmgiCiAjaW1wb3J0ICJMb2Fk UGFyYW1ldGVycy5oIgorI2ltcG9ydCAiTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgiCiAjaW1w b3J0ICJQYWdlQ2xpZW50LmgiCiAjaW1wb3J0ICJRdWFyYW50aW5lU1BJLmgiCiAjaW1wb3J0ICJR dWlja0xvb2tUaHVtYm5haWxMb2FkZXIuaCIKQEAgLTc1MCw2ICs3NTEsMTUgQEAgYm9vbCBXZWJQ YWdlUHJveHk6OmlzUXVhcmFudGluZWRBbmROb3RVc2VyQXBwcm92ZWQoY29uc3QgU3RyaW5nJiBm aWxlVVJMU3RyaW5nKQogfQogI2VuZGlmCiAKK3ZvaWQgV2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVy bWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbkRhdGEm IG9yaWdpbiwgUGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVy PHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCit7CisgICAgYXV0byByZWFzb24gPSBj b252ZXJ0UGVybWlzc2lvbk5hbWVUb1JlYXNvbihwZXJtaXNzaW9uTmFtZSk7CisgICAgaWYgKCFy ZWFzb24pCisgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcihmYWxzZSk7CisKKyAgICBh bGVydEZvclBlcm1pc3Npb24oKnRoaXMsICpyZWFzb24sIG9yaWdpbiwgV1RGTW92ZShjb21wbGV0 aW9uSGFuZGxlcikpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI3VuZGVmIE1FU1NB R0VfQ0hFQ0tfQ09NUExFVElPTgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9NZWRp YVBlcm1pc3Npb25VdGlsaXRpZXMuaAppbmRleCA1YTMxNTE2OTVjYzRkOGU0MDM0NzA2NGZjZmFl NDU4MWZkN2ZhMTk1Li5jNmMwYWE3MGFiODNjOGY3YTQ4ZTVlNDFmYjE2YWVmZGE4Y2Y4MzhjIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9NZWRpYVBlcm1pc3Npb25VdGlsaXRp ZXMuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9NZWRpYVBlcm1pc3Npb25VdGlsaXRp ZXMuaApAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAogbmFtZXNw YWNlIFdlYkNvcmUgeworZW51bSBjbGFzcyBQZXJtaXNzaW9uTmFtZSA6IHVpbnQ4X3Q7CiBjbGFz cyBTZWN1cml0eU9yaWdpbjsKIH0KIApAQCAtNTcsNiArNTgsOCBAQCBlbnVtIGNsYXNzIE1lZGlh UGVybWlzc2lvblJlYXNvbiB7CiAgICAgU3BlZWNoUmVjb2duaXRpb24KIH07CiAKK3N0ZDo6b3B0 aW9uYWw8TWVkaWFQZXJtaXNzaW9uUmVhc29uPiBjb252ZXJ0UGVybWlzc2lvbk5hbWVUb1JlYXNv bihXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSk7CisKICNpZiBQTEFURk9STShDT0NPQSkKIGJvb2wg Y2hlY2tTYW5kYm94UmVxdWlyZW1lbnRGb3JUeXBlKE1lZGlhUGVybWlzc2lvblR5cGUpOwogYm9v bCBjaGVja1VzYWdlRGVzY3JpcHRpb25TdHJpbmdGb3JUeXBlKE1lZGlhUGVybWlzc2lvblR5cGUp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggMmZlOTNhNTkx NTZlOGIwZTY5ODdjMDg4NTVkM2QwYWQzMjljODA2NS4uZTIyZDZlNjA4ZmRiOWQzN2Y3MDJjNTI0 NDAwODFhOWEzMTAzMmE1NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2Vi UGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHku Y3BwCkBAIC0xNzEsNiArMTcxLDcgQEAKICNpbmNsdWRlIDxXZWJDb3JlL01JTUVUeXBlUmVnaXN0 cnkuaD4KICNpbmNsdWRlIDxXZWJDb3JlL01lZGlhU3RyZWFtUmVxdWVzdC5oPgogI2luY2x1ZGUg PFdlYkNvcmUvUGVyZm9ybWFuY2VMb2dnaW5nQ2xpZW50Lmg+CisjaW5jbHVkZSA8V2ViQ29yZS9Q ZXJtaXNzaW9uRGVzY3JpcHRvci5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGVybWlzc2lvblN0YXRl Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9QbGF0Zm9ybUV2ZW50Lmg+CiAjaW5jbHVkZSA8V2ViQ29y ZS9Qcml2YXRlQ2xpY2tNZWFzdXJlbWVudC5oPgpAQCAtODUwMiwxMCArODUwMywxNCBAQCB2b2lk IFdlYlBhZ2VQcm94eTo6cmV2b2tlR2VvbG9jYXRpb25BdXRob3JpemF0aW9uVG9rZW4oY29uc3Qg U3RyaW5nJiBhdXRob3JpemF0aQogICAgIG1fZ2VvbG9jYXRpb25QZXJtaXNzaW9uUmVxdWVzdE1h bmFnZXIucmV2b2tlQXV0aG9yaXphdGlvblRva2VuKGF1dGhvcml6YXRpb25Ub2tlbik7CiB9CiAK LXZvaWQgV2ViUGFnZVByb3h5OjpyZXF1ZXN0UGVybWlzc2lvbihjb25zdCBDbGllbnRPcmlnaW4m LCBjb25zdCBQZXJtaXNzaW9uRGVzY3JpcHRvciYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoUGVy bWlzc2lvblN0YXRlKT4mJiBjb21wbGV0aW9uSGFuZGxlcikKK3ZvaWQgV2ViUGFnZVByb3h5Ojpy ZXF1ZXN0UGVybWlzc2lvbihjb25zdCBDbGllbnRPcmlnaW4mIG9yaWdpbiwgY29uc3QgUGVybWlz c2lvbkRlc2NyaXB0b3ImIGRlc2NyaXB0b3IsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoUGVybWlz c2lvblN0YXRlKT4mJiBjb21wbGV0aW9uSGFuZGxlcikKIHsKLSAgICAvLyBGSVhNRTogU2hvdyBh IHByb21wdCBmb3IgdXNlciBpbnB1dC4KLSAgICBjb21wbGV0aW9uSGFuZGxlcihQZXJtaXNzaW9u U3RhdGU6OkdyYW50ZWQpOworICAgIGF1dG8gc2VjdXJpdHlPcmlnaW4gPSBvcmlnaW4uY2xpZW50 T3JpZ2luLnNlY3VyaXR5T3JpZ2luKCk7CisgICAgYXV0byB0b3BTZWN1cml0eU9yaWdpbiA9IG9y aWdpbi50b3BPcmlnaW4uc2VjdXJpdHlPcmlnaW4oKTsKKyAgICBtX3VpQ2xpZW50LT5yZXF1ZXN0 UGVybWlzc2lvbigqdGhpcywgc2VjdXJpdHlPcmlnaW4uZ2V0KCksIHRvcFNlY3VyaXR5T3JpZ2lu LmdldCgpLCBkZXNjcmlwdG9yLm5hbWUsIFtjb21wbGV0aW9uSGFuZGxlciA9IFdURk1vdmUoY29t cGxldGlvbkhhbmRsZXIpXShib29sIGdyYW50ZWQpIG11dGFibGUgeworICAgICAgICBhdXRvIHBl cm1pc3Npb25zU3RhdGUgPSBncmFudGVkID8gUGVybWlzc2lvblN0YXRlOjpHcmFudGVkIDogUGVy bWlzc2lvblN0YXRlOjpEZW5pZWQ7CisgICAgICAgIGNvbXBsZXRpb25IYW5kbGVyKHBlcm1pc3Np b25zU3RhdGUpOworICAgIH0pOwogfQogCiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKQEAgLTEw ODc2LDYgKzEwODgxLDE1IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpjbGVhckFwcFByaXZhY3lSZXBv cnRUZXN0aW5nRGF0YShDb21wbGV0aW9uSGFuZGxlcjx2b2lkKCk+JiYKIH0KICNlbmRpZgogCisj aWYgIVBMQVRGT1JNKENPQ09BKQorCit2b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Np b25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgUGVy bWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhh bmRsZXIpCit7CisgICAgY29tcGxldGlvbkhhbmRsZXIoZmFsc2UpOworfQorCisjZW5kaWYKKwog fSAvLyBuYW1lc3BhY2UgV2ViS2l0CiAKICN1bmRlZiBXRUJQQUdFUFJPWFlfUkVMRUFTRV9MT0cK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggNTRmYWQyMjNkMWEzODhl OWMwZDRhNjdhNDU0YWEzZmY1YzBkYzgwZC4uYmQ5NmE0ZmM5MTQ1YTI0YWY1ZTdjMGVmN2FhMzkw ZmU1ZGNmYTk5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKQEAgLTI2 OCw2ICsyNjgsNyBAQCBlbnVtIGNsYXNzIEhpZ2hsaWdodFJlcXVlc3RPcmlnaW5hdGVkSW5BcHAg OiBib29sOwogZW51bSBjbGFzcyBIaWdobGlnaHRWaXNpYmlsaXR5IDogYm9vbDsKIGVudW0gY2xh c3MgTW91c2VFdmVudFBvbGljeSA6IHVpbnQ4X3Q7CiBlbnVtIGNsYXNzIE5vdGlmaWNhdGlvbkRp cmVjdGlvbiA6IHVpbnQ4X3Q7CitlbnVtIGNsYXNzIFBlcm1pc3Npb25OYW1lIDogdWludDhfdDsK IGVudW0gY2xhc3MgUm91dGVTaGFyaW5nUG9saWN5IDogdWludDhfdDsKIGVudW0gY2xhc3MgU2Vs ZWN0aW9uRGlyZWN0aW9uIDogdWludDhfdDsKIGVudW0gY2xhc3MgU2hvdWxkU2FtcGxlIDogYm9v bDsKQEAgLTE5MDQsNiArMTkwNSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlcXVlc3RVc2VyTWVk aWFQZXJtaXNzaW9uRm9yU3BlZWNoUmVjb2duaXRpb24oV2ViQ29yZTo6RnJhbWVJZGVudGlmaWVy LCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luJiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJik7CiAKICAgICB2b2lkIHJl cXVlc3RNZWRpYUtleVN5c3RlbVBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29sKT4mJik7 CisgICAgdm9pZCByZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihjb25zdCBXZWJDb3Jl OjpTZWN1cml0eU9yaWdpbkRhdGEmLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlv bkhhbmRsZXI8dm9pZChib29sKT4mJik7CiAKICAgICB2b2lkIHN5bmNJZk1vY2tEZXZpY2VzRW5h YmxlZENoYW5nZWQoKTsKIAo= 437366 2021-09-05 14:28:47 -0700 2021-09-05 20:38:15 -0700 Patch bug-229590-20210905142846.patch text/plain 18378 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgyMDQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGIyNzY3YTNjNzI4ZDk3 YWJmOTg1ZTk3ZjNkNWUzMTQ0ZTkyOWQzZi4uMGZjNmExNjdkNzRlZWIyNGQyNDM4YWUyZTFlYTZl NTRlYWZkN2U1MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA5LTA1ICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIE5v IG9ic2VydmFibGUgYmVoYXZpb3IgY2hhbmdlIGFzIHRoZSBwZXJtaXNpb24gcmVxdWVzdCBmbG93 IGlzIG5vdCB1c2VkIGJ5IGFueSBmZWF0dXJlIHlldC4KKworICAgICAgICAqIE1vZHVsZXMvcGVy bWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaDoKKyAgICAgICAgKiBNb2R1bGVzL3Blcm1pc3Npb25z L1Blcm1pc3Npb25OYW1lLmlkbDoKKwogMjAyMS0wOS0wNSAgTXlsZXMgQy4gTWF4ZmllbGQgIDxt bWF4ZmllbGRAYXBwbGUuY29tPgogCiAgICAgICAgIFJlbW92ZSB1bm5lY2Vzc2FyeSB1c2VzIG9m IFJlZiBwcm90ZWN0ID0gbV9iYWNraW5nIGZyb20gRm9udEZhY2VTZXQKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggNThk MzY4MDIzOWQzMjc3NmI4ODkzY2ZhZjUxYWQ3NTJjM2JlMDQxZC4uNjcyNzI1Nzc3MDQyMmQzY2Rk NjI0Yjk0ZTk0MmU4MGQ5NjIwNDdhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMCBAQAorMjAyMS0w OS0wNSAgU2lodWkgTGl1ICA8c2lodWlfbGl1QGFwcGxlLmNvbT4KKworICAgICAgICBBZGQgcHJv bXB0IGZvciBQZXJtaXNzaW9ucyBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyOTU5MAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vODI2ODY5NDg+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRGlzcGxh eSBhIHByb21wdCBmb3IgcGVybWlzc2lvbiByZXF1ZXN0IGJ5IGRlZmF1bHQuCisKKyAgICAgICAg KiBVSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50Lmg6CisgICAgICAgIChBUEk6OlVJQ2xpZW50Ojpy ZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVs ZWdhdGVQcml2YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5tbToKKyAgICAgICAgKFdlYktpdDo6Y29udmVydFBlcm1pc3Npb25OYW1lVG9S ZWFzb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmg6CisgICAgICAg ICogVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW06CisgICAgICAgIChXZWJLaXQ6OnRvV0tQ ZXJtaXNzaW9uTmFtZSk6CisgICAgICAgIChXZWJLaXQ6OlVJRGVsZWdhdGU6OlVJQ2xpZW50Ojpy ZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94 eUNvY29hLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNz aW9uQnlEZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9u VXRpbGl0aWVzLmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHA6CisgICAg ICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKToK KyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6CisKIDIwMjEtMDktMDUgIFNpbW9u IEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgVXNlIGEgc3Ryb25n bHkgdHlwZWQgaWRlbnRpZmllciBmb3IgYXV0aGVudGljYXRpb24gY2hhbGxlbmdlIElEcwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFt ZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5o CmluZGV4IGRkMjgzZjE2OTQyYzA1ZDIzMWMzYTlmZGJiY2QyYWI3ZTRmOTg4OTMuLjY3Mzg5MGY4 MTNlOWY5MWRmNTdkYzhjZDlmMTc0NjgxNDVkYWM4YTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgKQEAgLTMyLDE1ICszMiwx MCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBlbnVtIGNsYXNzIFBlcm1pc3Npb25OYW1lIDogdWlu dDhfdCB7CiAgICAgQWNjZWxlcm9tZXRlciwKICAgICBCYWNrZ3JvdW5kRmV0Y2gsCi0gICAgQmx1 ZXRvb3RoLAogICAgIENhbWVyYSwKICAgICBEaXNwbGF5Q2FwdHVyZSwKICAgICBHZW9sb2NhdGlv biwKLSAgICBHeXJvc2NvcGUsCi0gICAgTWFnbmV0b21ldGVyLAogICAgIE1pY3JvcGhvbmUsCi0g ICAgTWlkaSwKLSAgICBOZmMsCiAgICAgTm90aWZpY2F0aW9ucywKICAgICBTcGVha2VyU2VsZWN0 aW9uCiB9OwpAQCAtNTQsMTUgKzQ5LDEwIEBAIHRlbXBsYXRlPD4gc3RydWN0IEVudW1UcmFpdHM8 V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU+IHsKICAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5h bWUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpBY2NlbGVyb21ldGVyLAogICAg ICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZldGNoLAotICAgICAgICBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Qmx1ZXRvb3RoLAogICAgICAgICBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6Q2FtZXJhLAogICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6RGlz cGxheUNhcHR1cmUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpHZW9sb2NhdGlv biwKLSAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Okd5cm9zY29wZSwKLSAgICAgICAg V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1hZ25ldG9tZXRlciwKICAgICAgICAgV2ViQ29yZTo6 UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmUsCi0gICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25O YW1lOjpNaWRpLAotICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6TmZjLAogICAgICAg ICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Tm90aWZpY2F0aW9ucywKICAgICAgICAgV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWU6OlNwZWFrZXJTZWxlY3Rpb24KICAgICA+OwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5pZGwgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbAppbmRl eCA5NTVhNzFmODI5NWUwZDAxOTY1ODY0ZmQxMWIwOTkzMDVhY2FiYmZiLi4xMjJmMjdjOTllOTdl ZTUxNTcxYjQwNjA5ODEzZGQ1NTAxYjcxZjFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbApAQCAtMjksMTUgKzI5LDEw IEBAIGVudW0gUGVybWlzc2lvbk5hbWUgewogICAgIC8vIEZJWE1FOiB1cGRhdGUgdGhlIGxpc3Qg dG8gbWF0Y2ggc3BlYyB3aGVuIG5ldyBmZWF0dXJlcyBhcmUgaW1wbGVtZW50ZWQuCiAgICAgImFj Y2VsZXJvbWV0ZXIiLAogICAgICJiYWNrZ3JvdW5kLWZldGNoIiwKLSAgICAiYmx1ZXRvb3RoIiwK ICAgICAiY2FtZXJhIiwKICAgICAiZGlzcGxheS1jYXB0dXJlIiwKICAgICAiZ2VvbG9jYXRpb24i LAotICAgICJneXJvc2NvcGUiLAotICAgICJtYWduZXRvbWV0ZXIiLAogICAgICJtaWNyb3Bob25l IiwKLSAgICAibWlkaSIsCi0gICAgIm5mYyIsCiAgICAgIm5vdGlmaWNhdGlvbnMiLAogICAgICJz cGVha2VyLXNlbGVjdGlvbiIKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQVBJVUlDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNs aWVudC5oCmluZGV4IDJkYjBmNTY5Y2IyMjUwNTg5ZTdlYzE2MDU4ZGFmYjVhNmE0ZTdiZjAuLmRm ZDkzZTFhZWY4YjYzMzEwMzNjNDgzNzFiMWVlZGVmZjM4NzEzZGQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCkBAIC00NCwxMCArNDQsMTAgQEAgT0JKQ19DTEFT UyBVSVZpZXdDb250cm9sbGVyOwogI2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKK2VudW0g Y2xhc3MgUGVybWlzc2lvbk5hbWUgOiB1aW50OF90OwogY2xhc3MgUmVnaXN0cmFibGVEb21haW47 CiBjbGFzcyBSZXNvdXJjZVJlcXVlc3Q7CiBzdHJ1Y3QgRm9udEF0dHJpYnV0ZXM7Ci1zdHJ1Y3Qg U2VjdXJpdHlPcmlnaW5EYXRhOwogc3RydWN0IFdpbmRvd0ZlYXR1cmVzOwogfQogCkBAIC0yMTEs NiArMjExLDggQEAgcHVibGljOgogI2lmIEVOQUJMRShXRUJYUikgJiYgUExBVEZPUk0oQ09DT0Ep CiAgICAgdmlydHVhbCB2b2lkIHN0YXJ0WFJTZXNzaW9uKFdlYktpdDo6V2ViUGFnZVByb3h5Jiwg Q29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+KT4mJiBjb21wbGV0aW9uSGFuZGxl cikgeyBjb21wbGV0aW9uSGFuZGxlcihuaWwpOyB9CiAjZW5kaWYKKworICAgIHZpcnR1YWwgdm9p ZCByZXF1ZXN0UGVybWlzc2lvbihXZWJLaXQ6OldlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgV2Vi Q29yZTo6U2VjdXJpdHlPcmlnaW4mIG9yaWdpbiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmln aW4mIHRvcE9yaWdpbiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUsIENv bXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhhbmRsZXIpIHsgcGFnZS5y ZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0YSgpLCBwZXJtaXNzaW9u TmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOyB9CiB9OwogCiB9IC8vIG5hbWVzcGFj ZSBBUEkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJ RGVsZWdhdGVQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tV SURlbGVnYXRlUHJpdmF0ZS5oCmluZGV4IGY2NmExYmEzZTg5MjI1M2YxNzYzM2MzNDJjMjI5YWRm YWFiMjEzMjEuLjFkYjRiN2RmOWVmNTMzZmNjMGY2ZjgzMzIzMjMxMTM4OWEzZmU3NzQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2 YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLVUlEZWxlZ2F0 ZVByaXZhdGUuaApAQCAtODgsNiArODgsMTcgQEAgdHlwZWRlZiBOU19FTlVNKE5TSW50ZWdlciwg X1dLRm9jdXNEaXJlY3Rpb24pIHsKICAgICBfV0tGb2N1c0RpcmVjdGlvbkZvcndhcmQsCiB9IFdL X0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCksIGlvcygxMi4yKSk7CiAKK3R5cGVkZWYgTlNf RU5VTShOU0ludGVnZXIsIF9XS1Blcm1pc3Npb25OYW1lKSB7CisgICAgX1dLUGVybWlzc2lvbk5h bWVBY2NlbGVyb21ldGVyLAorICAgIF9XS1Blcm1pc3Npb25OYW1lQmFja2dyb3VuZEZldGNoLAor ICAgIF9XS1Blcm1pc3Npb25OYW1lQ2FtZXJhLAorICAgIF9XS1Blcm1pc3Npb25OYW1lRGlzcGxh eUNhcHR1cmUsCisgICAgX1dLUGVybWlzc2lvbk5hbWVHZW9sb2NhdGlvbiwKKyAgICBfV0tQZXJt aXNzaW9uTmFtZU1pY3JvcGhvbmUsCisgICAgX1dLUGVybWlzc2lvbk5hbWVOb3RpZmljYXRpb25z LAorICAgIF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbgorfSBXS19BUElfQVZBSUxB QkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoV0tfSU9TX1RCQSkpOworCiBAcHJvdG9jb2wgV0tV SURlbGVnYXRlUHJpdmF0ZSA8V0tVSURlbGVnYXRlPgogCiAjaWZkZWYgRk9VTkRBVElPTl9IQVNf RElSRUNUSU9OQUxfR0VPTUVUUlkKQEAgLTE2MCw2ICsxNzEsOCBAQCBzdHJ1Y3QgVUlFZGdlSW5z ZXRzOwogCiAtICh2b2lkKV93ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IHN0YXJ0WFJTZXNz aW9uV2l0aENvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShpZCkpY29tcGxldGlvbkhhbmRsZXIg V0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMi4wKSwgaW9zKDE1LjApKTsKIAorLSAodm9pZClfd2Vi VmlldzooV0tXZWJWaWV3ICopd2ViVmlldyByZXF1ZXN0UGVybWlzc2lvbkZvck5hbWU6KF9XS1Bl cm1pc3Npb25OYW1lKW5hbWUgb3JpZ2luOihXS1NlY3VyaXR5T3JpZ2luICopb3JpZ2luIHRvcE9y aWdpbjooV0tTZWN1cml0eU9yaWdpbiAqKXRvcE9yaWdpbiBkZWNpc2lvbkhhbmRsZXI6KHZvaWQg KF4pKFdLUGVybWlzc2lvbkRlY2lzaW9uIGRlY2lzaW9uKSlkZWNpc2lvbkhhbmRsZXIgV0tfQVBJ X0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19UQkEpKTsKKwogI2lmIFRB UkdFVF9PU19JUEhPTkUKIAogLSAoQk9PTClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBz aG91bGRJbmNsdWRlQXBwTGlua0FjdGlvbnNGb3JFbGVtZW50OihfV0tBY3RpdmF0ZWRFbGVtZW50 SW5mbyAqKWVsZW1lbnQgV0tfQVBJX0FWQUlMQUJMRShpb3MoOS4wKSk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMubW0g Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMu bW0KaW5kZXggMTRlOWM4YWI1YmJmY2JmZmEwNGRkYjg1Y2JiMjcxOTUyMGMwNWVhZS4uZWY3MGVi ODQ3MTEwNzdjMmY3NjYyYzZhOTRhMTM2NTdlZjVhODFmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQ29jb2EvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLm1tCisrKyBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbQpA QCAtMjcsMTkgKzI3LDIxIEBACiAjaW1wb3J0ICJNZWRpYVBlcm1pc3Npb25VdGlsaXRpZXMuaCIK IAogI2ltcG9ydCAiU2FuZGJveFV0aWxpdGllcy5oIgotI2ltcG9ydCAiVENDU29mdExpbmsuaCIK ICNpbXBvcnQgIldLV2ViVmlld0ludGVybmFsLmgiCiAjaW1wb3J0ICJXZWJQYWdlUHJveHkuaCIK ICNpbXBvcnQgPFdlYkNvcmUvTG9jYWxpemVkU3RyaW5ncy5oPgorI2ltcG9ydCA8V2ViQ29yZS9Q ZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbkRhdGEuaD4K ICNpbXBvcnQgPG11dGV4PgotI2ltcG9ydCA8cGFsL2NvY29hL0FWRm91bmRhdGlvblNvZnRMaW5r Lmg+Ci0jaW1wb3J0IDxwYWwvY29jb2EvU3BlZWNoU29mdExpbmsuaD4KICNpbXBvcnQgPHd0Zi9C bG9ja1B0ci5oPgogI2ltcG9ydCA8d3RmL1VSTEhlbHBlcnMuaD4KICNpbXBvcnQgPHd0Zi9zcGkv Y2YvQ0ZCdW5kbGVTUEkuaD4KICNpbXBvcnQgPHd0Zi9zcGkvZGFyd2luL1NhbmRib3hTUEkuaD4K IAorI2ltcG9ydCAiVENDU29mdExpbmsuaCIKKyNpbXBvcnQgPHBhbC9jb2NvYS9BVkZvdW5kYXRp b25Tb2Z0TGluay5oPgorI2ltcG9ydCA8cGFsL2NvY29hL1NwZWVjaFNvZnRMaW5rLmg+CisKIG5h bWVzcGFjZSBXZWJLaXQgewogCiBib29sIGNoZWNrU2FuZGJveFJlcXVpcmVtZW50Rm9yVHlwZShN ZWRpYVBlcm1pc3Npb25UeXBlIHR5cGUpCkBAIC0yMjIsNiArMjI0LDIwIEBAIHZvaWQgYWxlcnRG b3JQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYgcGFnZSwgTWVkaWFQZXJtaXNzaW9uUmVhc29uIHJl YXNvbiwgY29uc3QKICNlbmRpZgogfQogCitzdGQ6Om9wdGlvbmFsPE1lZGlhUGVybWlzc2lvblJl YXNvbj4gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29yZTo6UGVybWlzc2lvbk5h bWUgcGVybWlzc2lvbk5hbWUpCit7CisgICAgc3dpdGNoIChwZXJtaXNzaW9uTmFtZSkgeworICAg IGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkNhbWVyYToKKyAgICAgICAgcmV0dXJuIE1l ZGlhUGVybWlzc2lvblJlYXNvbjo6Q2FtZXJhOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lv bk5hbWU6Ok1pY3JvcGhvbmU6CisgICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246 Ok1pY3JvcGhvbmU7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6R2VvbG9jYXRp b246CisgICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246Okdlb2xvY2F0aW9uOwor ICAgIGRlZmF1bHQ6CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7CisgICAgfQorfQorCiAj aWYgSEFWRShBVkNBUFRVUkVERVZJQ0UpCiAKIHZvaWQgcmVxdWVzdEFWQ2FwdHVyZUFjY2Vzc0Zv clR5cGUoTWVkaWFQZXJtaXNzaW9uVHlwZSB0eXBlLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJv b2wgYXV0aG9yaXplZCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Db2NvYS9VSURlbGVnYXRlLmgKaW5kZXggMzI5ZGI3OTFjZjQzMjcyNDYzNjM0MjgwMDUw NGIwOGVhODlkYjBlMy4uMGViOTRjZDA3N2Y1MmU1OGUxODJlMjdiZDVlOGFlYzUwZGVlYThiOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5oCisr KyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUuaApAQCAtMTc1LDYg KzE3NSw4IEBAIHByaXZhdGU6CiAgICAgICAgIHZvaWQgc3RhcnRYUlNlc3Npb24oV2ViUGFnZVBy b3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+KT4mJikgZmluYWw7CiAj ZW5kaWYKIAorICAgICAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYsIGNv bnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmln aW4mLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChib29s KT4mJikgZmluYWw7CisKICAgICAgICAgV2Vha1B0cjxVSURlbGVnYXRlPiBtX3VpRGVsZWdhdGU7 CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlE ZWxlZ2F0ZS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW0K aW5kZXggYmRkNmIzYTY4MzM1NWFjZWQzYjlhNzIwMjQ3YTYxMzE1ZWFlOWY0MS4uYTM0MmRiZTZm ZTc5NmJkYzJlYTY5ZTQyYmZlN2NkY2RhZjYyYTA4OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tCkBAIC02Myw2ICs2Myw3IEBACiAjaW1wb3J0IDxBVkZv dW5kYXRpb24vQVZDYXB0dXJlRGV2aWNlLmg+CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZNZWRp YUZvcm1hdC5oPgogI2ltcG9ydCA8V2ViQ29yZS9Gb250QXR0cmlidXRlcy5oPgorI2ltcG9ydCA8 V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0eU9yaWdp bi5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3dGYvVVJMLmg+CkBAIC0x Njg0LDQgKzE2ODUsNTkgQEAgdm9pZCBVSURlbGVnYXRlOjpVSUNsaWVudDo6c3RhcnRYUlNlc3Np b24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgKIH0KICNlbmRpZgogCitz dGF0aWMgaW5saW5lIF9XS1Blcm1pc3Npb25OYW1lIHRvV0tQZXJtaXNzaW9uTmFtZShXZWJDb3Jl OjpQZXJtaXNzaW9uTmFtZSBuYW1lKQoreworICAgIHN3aXRjaCAobmFtZSkgeworICAgIGNhc2Ug V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkFjY2VsZXJvbWV0ZXI6CisgICAgICAgIHJldHVybiBf V0tQZXJtaXNzaW9uTmFtZUFjY2VsZXJvbWV0ZXI7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNz aW9uTmFtZTo6QmFja2dyb3VuZEZldGNoOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5h bWVCYWNrZ3JvdW5kRmV0Y2g7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Q2Ft ZXJhOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVDYW1lcmE7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmU6CisgICAgICAgIHJldHVybiBf V0tQZXJtaXNzaW9uTmFtZURpc3BsYXlDYXB0dXJlOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlz c2lvbk5hbWU6Okdlb2xvY2F0aW9uOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVH ZW9sb2NhdGlvbjsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpNaWNyb3Bob25l OgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVNaWNyb3Bob25lOworICAgIGNhc2Ug V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok5vdGlmaWNhdGlvbnM6CisgICAgICAgIHJldHVybiBf V0tQZXJtaXNzaW9uTmFtZU5vdGlmaWNhdGlvbnM7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNz aW9uTmFtZTo6U3BlYWtlclNlbGVjdGlvbjoKKyAgICAgICAgcmV0dXJuIF9XS1Blcm1pc3Npb25O YW1lU3BlYWtlclNlbGVjdGlvbjsKKyAgICB9Cit9CisKK3ZvaWQgVUlEZWxlZ2F0ZTo6VUlDbGll bnQ6OnJlcXVlc3RQZXJtaXNzaW9uKFdlYktpdDo6V2ViUGFnZVByb3h5JiBwYWdlLCBjb25zdCBX ZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgb3JpZ2luLCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9y aWdpbiYgdG9wT3JpZ2luLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBuYW1lLCBDb21wbGV0aW9u SGFuZGxlcjx2b2lkKGJvb2wgZ3JhbnRlZCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCit7CisgICAg aWYgKCFtX3VpRGVsZWdhdGUpCisgICAgICAgIHJldHVybiBwYWdlLnJlcXVlc3RQZXJtaXNzaW9u QnlEZWZhdWx0QWN0aW9uKG9yaWdpbi5kYXRhKCksIG5hbWUsIFdURk1vdmUoY29tcGxldGlvbkhh bmRsZXIpKTsKKworICAgIGF1dG8gZGVsZWdhdGUgPSAoaWQgPFdLVUlEZWxlZ2F0ZVByaXZhdGU+ KW1fdWlEZWxlZ2F0ZS0+bV9kZWxlZ2F0ZS5nZXQoKTsKKyAgICBpZiAoIWRlbGVnYXRlKQorICAg ICAgICByZXR1cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4u ZGF0YSgpLCBuYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7CisKKyAgICBpZiAoIVtk ZWxlZ2F0ZSByZXNwb25kc1RvU2VsZWN0b3I6QHNlbGVjdG9yKF93ZWJWaWV3OnJlcXVlc3RQZXJt aXNzaW9uRm9yTmFtZTpvcmlnaW46dG9wT3JpZ2luOmRlY2lzaW9uSGFuZGxlcjopXSkKKyAgICAg ICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24ob3JpZ2luLmRh dGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOworCisgICAgYXV0byBhcGlP cmlnaW4gPSBBUEk6OlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUob3JpZ2luKTsKKyAgICBhdXRvIGFw aVRvcE9yaWdpbiA9IEFQSTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZSh0b3BPcmlnaW4pOworICAg IGF1dG8gY2hlY2tlciA9IENvbXBsZXRpb25IYW5kbGVyQ2FsbENoZWNrZXI6OmNyZWF0ZShkZWxl Z2F0ZSwgQHNlbGVjdG9yKF93ZWJWaWV3OnJlcXVlc3RQZXJtaXNzaW9uRm9yTmFtZTpvcmlnaW46 dG9wT3JpZ2luOmRlY2lzaW9uSGFuZGxlcjopKTsKKyAgICBbZGVsZWdhdGUgX3dlYlZpZXc6bV91 aURlbGVnYXRlLT5tX3dlYlZpZXcuZ2V0KCkuZ2V0KCkgcmVxdWVzdFBlcm1pc3Npb25Gb3JOYW1l OnRvV0tQZXJtaXNzaW9uTmFtZShuYW1lKSBvcmlnaW46d3JhcHBlcihhcGlPcmlnaW4pIHRvcE9y aWdpbjp3cmFwcGVyKGFwaVRvcE9yaWdpbikgZGVjaXNpb25IYW5kbGVyOm1ha2VCbG9ja1B0cihb Y29tcGxldGlvbkhhbmRsZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSwgY2hlY2tlciA9 IFdURk1vdmUoY2hlY2tlciksIHBhZ2UgPSBtYWtlV2Vha1B0cihwYWdlKSwgbmFtZSwgb3JpZ2lu RGF0YSA9IG9yaWdpbi5kYXRhKCldIChXS1Blcm1pc3Npb25EZWNpc2lvbiBkZWNpc2lvbikgbXV0 YWJsZSB7CisgICAgICAgIGlmIChjaGVja2VyLT5jb21wbGV0aW9uSGFuZGxlckhhc0JlZW5DYWxs ZWQoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgY2hlY2tlci0+ZGlkQ2FsbENvbXBs ZXRpb25IYW5kbGVyKCk7CisKKyAgICAgICAgc3dpdGNoIChkZWNpc2lvbikgeworICAgICAgICBj YXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uUHJvbXB0OgorICAgICAgICAgICAgaWYgKCFwYWdlKQor ICAgICAgICAgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcihmYWxzZSk7CisgICAgICAg ICAgICByZXR1cm4gcGFnZS0+cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24ob3JpZ2lu RGF0YSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOworICAgICAgICBjYXNlIFdL UGVybWlzc2lvbkRlY2lzaW9uR3JhbnQ6CisgICAgICAgICAgICByZXR1cm4gY29tcGxldGlvbkhh bmRsZXIodHJ1ZSk7CisgICAgICAgIGNhc2UgV0tQZXJtaXNzaW9uRGVjaXNpb25EZW55OgorICAg ICAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsKKyAgICAgICAgfQorICAg IH0pLmdldCgpXTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9XZWJQYWdlUHJveHlDb2NvYS5tbSBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCmluZGV4IDMzMDFlZDQ4 ZjA0NWE5ZGQ1NGYzYTg1M2JhZTkwZjEyZWRhN2NhNTcuLjlhZTRlNjcwMzhjNGM4YWZlM2FhNWNh MTFjODg5MTIxN2UwZjQ4NmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0Nv Y29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0Nv Y29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCkBAIC0zNCw2ICszNCw3IEBACiAjaW1wb3J0ICJEYXRh RGV0ZWN0aW9uUmVzdWx0LmgiCiAjaW1wb3J0ICJJbnNlcnRUZXh0T3B0aW9ucy5oIgogI2ltcG9y dCAiTG9hZFBhcmFtZXRlcnMuaCIKKyNpbXBvcnQgIk1lZGlhUGVybWlzc2lvblV0aWxpdGllcy5o IgogI2ltcG9ydCAiUGFnZUNsaWVudC5oIgogI2ltcG9ydCAiUXVhcmFudGluZVNQSS5oIgogI2lt cG9ydCAiUXVpY2tMb29rVGh1bWJuYWlsTG9hZGVyLmgiCkBAIC03NTAsNiArNzUxLDE1IEBAIGJv b2wgV2ViUGFnZVByb3h5Ojppc1F1YXJhbnRpbmVkQW5kTm90VXNlckFwcHJvdmVkKGNvbnN0IFN0 cmluZyYgZmlsZVVSTFN0cmluZykKIH0KICNlbmRpZgogCit2b2lkIFdlYlBhZ2VQcm94eTo6cmVx dWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmln aW5EYXRhJiBvcmlnaW4sIFBlcm1pc3Npb25OYW1lIHBlcm1pc3Npb25OYW1lLCBDb21wbGV0aW9u SGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQoreworICAgIGF1dG8gcmVh c29uID0gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24ocGVybWlzc2lvbk5hbWUpOworICAg IGlmICghcmVhc29uKQorICAgICAgICByZXR1cm4gY29tcGxldGlvbkhhbmRsZXIoZmFsc2UpOwor CisgICAgYWxlcnRGb3JQZXJtaXNzaW9uKCp0aGlzLCAqcmVhc29uLCBvcmlnaW4sIFdURk1vdmUo Y29tcGxldGlvbkhhbmRsZXIpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CiAKICN1bmRl ZiBNRVNTQUdFX0NIRUNLX0NPTVBMRVRJT04KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKaW5kZXggNWEzMTUxNjk1Y2M0ZDhlNDAzNDcw NjRmY2ZhZTQ1ODFmZDdmYTE5NS4uYzZjMGFhNzBhYjgzYzhmN2E0OGU1ZTQxZmIxNmFlZmRhOGNm ODM4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9u VXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9u VXRpbGl0aWVzLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lvbk5hbWUgOiB1aW50OF90 OwogY2xhc3MgU2VjdXJpdHlPcmlnaW47CiB9CiAKQEAgLTU3LDYgKzU4LDggQEAgZW51bSBjbGFz cyBNZWRpYVBlcm1pc3Npb25SZWFzb24gewogICAgIFNwZWVjaFJlY29nbml0aW9uCiB9OwogCitz dGQ6Om9wdGlvbmFsPE1lZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVydFBlcm1pc3Npb25OYW1l VG9SZWFzb24oV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUpOworCiAjaWYgUExBVEZPUk0oQ09DT0Ep CiBib29sIGNoZWNrU2FuZGJveFJlcXVpcmVtZW50Rm9yVHlwZShNZWRpYVBlcm1pc3Npb25UeXBl KTsKIGJvb2wgY2hlY2tVc2FnZURlc2NyaXB0aW9uU3RyaW5nRm9yVHlwZShNZWRpYVBlcm1pc3Np b25UeXBlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDJm ZTkzYTU5MTU2ZThiMGU2OTg3YzA4ODU1ZDNkMGFkMzI5YzgwNjUuLmUyMmQ2ZTYwOGZkYjlkMzdm NzAyYzUyNDQwMDgxYTlhMzEwMzJhNTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcApAQCAtMTcxLDYgKzE3MSw3IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9NSU1FVHlw ZVJlZ2lzdHJ5Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9NZWRpYVN0cmVhbVJlcXVlc3QuaD4KICNp bmNsdWRlIDxXZWJDb3JlL1BlcmZvcm1hbmNlTG9nZ2luZ0NsaWVudC5oPgorI2luY2x1ZGUgPFdl YkNvcmUvUGVybWlzc2lvbkRlc2NyaXB0b3IuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Blcm1pc3Np b25TdGF0ZS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1FdmVudC5oPgogI2luY2x1ZGUg PFdlYkNvcmUvUHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQuaD4KQEAgLTg1MDIsMTAgKzg1MDMsMTQg QEAgdm9pZCBXZWJQYWdlUHJveHk6OnJldm9rZUdlb2xvY2F0aW9uQXV0aG9yaXphdGlvblRva2Vu KGNvbnN0IFN0cmluZyYgYXV0aG9yaXphdGkKICAgICBtX2dlb2xvY2F0aW9uUGVybWlzc2lvblJl cXVlc3RNYW5hZ2VyLnJldm9rZUF1dGhvcml6YXRpb25Ub2tlbihhdXRob3JpemF0aW9uVG9rZW4p OwogfQogCi12b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb24oY29uc3QgQ2xpZW50 T3JpZ2luJiwgY29uc3QgUGVybWlzc2lvbkRlc2NyaXB0b3ImLCBDb21wbGV0aW9uSGFuZGxlcjx2 b2lkKFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIpCit2b2lkIFdlYlBhZ2VQ cm94eTo6cmVxdWVzdFBlcm1pc3Npb24oY29uc3QgQ2xpZW50T3JpZ2luJiBvcmlnaW4sIGNvbnN0 IFBlcm1pc3Npb25EZXNjcmlwdG9yJiBkZXNjcmlwdG9yLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lk KFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIpCiB7Ci0gICAgLy8gRklYTUU6 IFNob3cgYSBwcm9tcHQgZm9yIHVzZXIgaW5wdXQuCi0gICAgY29tcGxldGlvbkhhbmRsZXIoUGVy bWlzc2lvblN0YXRlOjpHcmFudGVkKTsKKyAgICBhdXRvIHNlY3VyaXR5T3JpZ2luID0gb3JpZ2lu LmNsaWVudE9yaWdpbi5zZWN1cml0eU9yaWdpbigpOworICAgIGF1dG8gdG9wU2VjdXJpdHlPcmln aW4gPSBvcmlnaW4udG9wT3JpZ2luLnNlY3VyaXR5T3JpZ2luKCk7CisgICAgbV91aUNsaWVudC0+ cmVxdWVzdFBlcm1pc3Npb24oKnRoaXMsIHNlY3VyaXR5T3JpZ2luLmdldCgpLCB0b3BTZWN1cml0 eU9yaWdpbi5nZXQoKSwgZGVzY3JpcHRvci5uYW1lLCBbY29tcGxldGlvbkhhbmRsZXIgPSBXVEZN b3ZlKGNvbXBsZXRpb25IYW5kbGVyKV0oYm9vbCBncmFudGVkKSBtdXRhYmxlIHsKKyAgICAgICAg YXV0byBwZXJtaXNzaW9uc1N0YXRlID0gZ3JhbnRlZCA/IFBlcm1pc3Npb25TdGF0ZTo6R3JhbnRl ZCA6IFBlcm1pc3Npb25TdGF0ZTo6RGVuaWVkOworICAgICAgICBjb21wbGV0aW9uSGFuZGxlcihw ZXJtaXNzaW9uc1N0YXRlKTsKKyAgICB9KTsKIH0KIAogI2lmIEVOQUJMRShNRURJQV9TVFJFQU0p CkBAIC0xMDg3Niw2ICsxMDg4MSwxNSBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6Y2xlYXJBcHBQcml2 YWN5UmVwb3J0VGVzdGluZ0RhdGEoQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgpPiYmCiB9CiAjZW5k aWYKIAorI2lmICFQTEFURk9STShDT0NPQSkKKwordm9pZCBXZWJQYWdlUHJveHk6OnJlcXVlc3RQ ZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luRGF0 YSYsIFBlcm1pc3Npb25OYW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNvbXBs ZXRpb25IYW5kbGVyKQoreworICAgIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsKK30KKworI2Vu ZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjdW5kZWYgV0VCUEFHRVBST1hZX1JFTEVB U0VfTE9HCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHku aCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IDU0ZmFkMjIz ZDFhMzg4ZTljMGQ0YTY3YTQ1NGFhM2ZmNWMwZGM4MGQuLmJkOTZhNGZjOTE0NWEyNGFmNWU3YzBl ZjdhYTM5MGZlNWRjZmE5OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dl YlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5o CkBAIC0yNjgsNiArMjY4LDcgQEAgZW51bSBjbGFzcyBIaWdobGlnaHRSZXF1ZXN0T3JpZ2luYXRl ZEluQXBwIDogYm9vbDsKIGVudW0gY2xhc3MgSGlnaGxpZ2h0VmlzaWJpbGl0eSA6IGJvb2w7CiBl bnVtIGNsYXNzIE1vdXNlRXZlbnRQb2xpY3kgOiB1aW50OF90OwogZW51bSBjbGFzcyBOb3RpZmlj YXRpb25EaXJlY3Rpb24gOiB1aW50OF90OworZW51bSBjbGFzcyBQZXJtaXNzaW9uTmFtZSA6IHVp bnQ4X3Q7CiBlbnVtIGNsYXNzIFJvdXRlU2hhcmluZ1BvbGljeSA6IHVpbnQ4X3Q7CiBlbnVtIGNs YXNzIFNlbGVjdGlvbkRpcmVjdGlvbiA6IHVpbnQ4X3Q7CiBlbnVtIGNsYXNzIFNob3VsZFNhbXBs ZSA6IGJvb2w7CkBAIC0xOTA0LDYgKzE5MDUsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCByZXF1ZXN0 VXNlck1lZGlhUGVybWlzc2lvbkZvclNwZWVjaFJlY29nbml0aW9uKFdlYkNvcmU6OkZyYW1lSWRl bnRpZmllciwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mLCBjb25zdCBXZWJDb3JlOjpT ZWN1cml0eU9yaWdpbiYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYpOwogCiAgICAg dm9pZCByZXF1ZXN0TWVkaWFLZXlTeXN0ZW1QZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0 IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luRGF0YSYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9v bCk+JiYpOworICAgIHZvaWQgcmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3Qg V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUsIENv bXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYpOwogCiAgICAgdm9pZCBzeW5jSWZNb2NrRGV2 aWNlc0VuYWJsZWRDaGFuZ2VkKCk7CiAK 437377 2021-09-05 20:38:18 -0700 2021-09-05 23:07:54 -0700 Patch bug-229590-20210905203817.patch text/plain 19751 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgyMDQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGIyNzY3YTNjNzI4ZDk3 YWJmOTg1ZTk3ZjNkNWUzMTQ0ZTkyOWQzZi4uMTI3NGNiODM2NjM1NDMwZDM2NWNkOTZkZmUxYWQ4 NGJjNjZmZDQyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA5LTA1ICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1vdmUgc29tZSBwZXJt aXNzaW9uIG5hbWVzIGFzIHRoZWlyIGZlYXR1cmVzIGFyZSBub3Qgc3VwcG9ydGVkLgorCisgICAg ICAgICogTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5oOgorICAgICAgICAqIE1v ZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaWRsOgorCiAyMDIxLTA5LTA1ICBNeWxl cyBDLiBNYXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIHVu bmVjZXNzYXJ5IHVzZXMgb2YgUmVmIHByb3RlY3QgPSBtX2JhY2tpbmcgZnJvbSBGb250RmFjZVNl dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZwppbmRleCA1OGQzNjgwMjM5ZDMyNzc2Yjg4OTNjZmFmNTFhZDc1MmMzYmUwNDFkLi44 ZjdhZmQ2YjEwZWNhYWEzNGU4NWZjYTVkMzkyYjUzYWJlZDEzNTQ2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwz ICsxLDMxIEBACisyMDIxLTA5LTA1ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgor CisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBlcm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS84MjY4Njk0OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBEaXNwbGF5IGEgcHJvbXB0IGZvciBwZXJtaXNzaW9uIHJlcXVlc3QgYnkgZGVm YXVsdC4gTm8gb2JzZXJ2YWJsZSBiZWhhdmlvciBjaGFuZ2UgZnJvbSB0aGlzIGFzIHRoZSBwZXJt aXNpb24gCisgICAgICAgIHJlcXVlc3QgZmxvdyBpcyBub3QgdXNlZCBieSBhbnkgZmVhdHVyZSB5 ZXQuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50Lmg6CisgICAgICAgIChB UEk6OlVJQ2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29h L01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbToKKyAgICAgICAgKFdlYktpdDo6Y29udmVydFBl cm1pc3Npb25OYW1lVG9SZWFzb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9VSURlbGVn YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW06CisgICAgICAg IChXZWJLaXQ6OnRvV0tQZXJtaXNzaW9uTmFtZSk6CisgICAgICAgIChXZWJLaXQ6OlVJRGVsZWdh dGU6OlVJQ2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0Nv Y29hL1dlYlBhZ2VQcm94eUNvY29hLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Np b24pOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlE ZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6CisKIDIw MjEtMDktMDUgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAg ICAgVXNlIGEgc3Ryb25nbHkgdHlwZWQgaWRlbnRpZmllciBmb3IgYXV0aGVudGljYXRpb24gY2hh bGxlbmdlIElEcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9u cy9QZXJtaXNzaW9uTmFtZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9Q ZXJtaXNzaW9uTmFtZS5oCmluZGV4IGRkMjgzZjE2OTQyYzA1ZDIzMWMzYTlmZGJiY2QyYWI3ZTRm OTg4OTMuLjY3Mzg5MGY4MTNlOWY5MWRmNTdkYzhjZDlmMTc0NjgxNDVkYWM4YTUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgK QEAgLTMyLDE1ICszMiwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBlbnVtIGNsYXNzIFBlcm1p c3Npb25OYW1lIDogdWludDhfdCB7CiAgICAgQWNjZWxlcm9tZXRlciwKICAgICBCYWNrZ3JvdW5k RmV0Y2gsCi0gICAgQmx1ZXRvb3RoLAogICAgIENhbWVyYSwKICAgICBEaXNwbGF5Q2FwdHVyZSwK ICAgICBHZW9sb2NhdGlvbiwKLSAgICBHeXJvc2NvcGUsCi0gICAgTWFnbmV0b21ldGVyLAogICAg IE1pY3JvcGhvbmUsCi0gICAgTWlkaSwKLSAgICBOZmMsCiAgICAgTm90aWZpY2F0aW9ucywKICAg ICBTcGVha2VyU2VsZWN0aW9uCiB9OwpAQCAtNTQsMTUgKzQ5LDEwIEBAIHRlbXBsYXRlPD4gc3Ry dWN0IEVudW1UcmFpdHM8V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU+IHsKICAgICAgICAgV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpBY2Nl bGVyb21ldGVyLAogICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZl dGNoLAotICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Qmx1ZXRvb3RoLAogICAgICAg ICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Q2FtZXJhLAogICAgICAgICBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25O YW1lOjpHZW9sb2NhdGlvbiwKLSAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Okd5cm9z Y29wZSwKLSAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1hZ25ldG9tZXRlciwKICAg ICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmUsCi0gICAgICAgIFdlYkNv cmU6OlBlcm1pc3Npb25OYW1lOjpNaWRpLAotICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFt ZTo6TmZjLAogICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Tm90aWZpY2F0aW9ucywK ICAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OlNwZWFrZXJTZWxlY3Rpb24KICAgICA+ OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNz aW9uTmFtZS5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Np b25OYW1lLmlkbAppbmRleCA5NTVhNzFmODI5NWUwZDAxOTY1ODY0ZmQxMWIwOTkzMDVhY2FiYmZi Li4xMjJmMjdjOTllOTdlZTUxNTcxYjQwNjA5ODEzZGQ1NTAxYjcxZjFhIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbApA QCAtMjksMTUgKzI5LDEwIEBAIGVudW0gUGVybWlzc2lvbk5hbWUgewogICAgIC8vIEZJWE1FOiB1 cGRhdGUgdGhlIGxpc3QgdG8gbWF0Y2ggc3BlYyB3aGVuIG5ldyBmZWF0dXJlcyBhcmUgaW1wbGVt ZW50ZWQuCiAgICAgImFjY2VsZXJvbWV0ZXIiLAogICAgICJiYWNrZ3JvdW5kLWZldGNoIiwKLSAg ICAiYmx1ZXRvb3RoIiwKICAgICAiY2FtZXJhIiwKICAgICAiZGlzcGxheS1jYXB0dXJlIiwKICAg ICAiZ2VvbG9jYXRpb24iLAotICAgICJneXJvc2NvcGUiLAotICAgICJtYWduZXRvbWV0ZXIiLAog ICAgICJtaWNyb3Bob25lIiwKLSAgICAibWlkaSIsCi0gICAgIm5mYyIsCiAgICAgIm5vdGlmaWNh dGlvbnMiLAogICAgICJzcGVha2VyLXNlbGVjdGlvbiIKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9BUEkvQVBJVUlDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9BUElVSUNsaWVudC5oCmluZGV4IDJkYjBmNTY5Y2IyMjUwNTg5ZTdlYzE2MDU4ZGFm YjVhNmE0ZTdiZjAuLmRmZDkzZTFhZWY4YjYzMzEwMzNjNDgzNzFiMWVlZGVmZjM4NzEzZGQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCisrKyBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCkBAIC00NCwxMCArNDQs MTAgQEAgT0JKQ19DTEFTUyBVSVZpZXdDb250cm9sbGVyOwogI2VuZGlmCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lvbk5hbWUgOiB1aW50OF90OwogY2xhc3MgUmVn aXN0cmFibGVEb21haW47CiBjbGFzcyBSZXNvdXJjZVJlcXVlc3Q7CiBzdHJ1Y3QgRm9udEF0dHJp YnV0ZXM7Ci1zdHJ1Y3QgU2VjdXJpdHlPcmlnaW5EYXRhOwogc3RydWN0IFdpbmRvd0ZlYXR1cmVz OwogfQogCkBAIC0yMTEsNiArMjExLDggQEAgcHVibGljOgogI2lmIEVOQUJMRShXRUJYUikgJiYg UExBVEZPUk0oQ09DT0EpCiAgICAgdmlydHVhbCB2b2lkIHN0YXJ0WFJTZXNzaW9uKFdlYktpdDo6 V2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+KT4mJiBj b21wbGV0aW9uSGFuZGxlcikgeyBjb21wbGV0aW9uSGFuZGxlcihuaWwpOyB9CiAjZW5kaWYKKwor ICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihXZWJLaXQ6OldlYlBhZ2VQcm94eSYg cGFnZSwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mIG9yaWdpbiwgY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW4mIHRvcE9yaWdpbiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgcGVy bWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhh bmRsZXIpIHsgcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0 YSgpLCBwZXJtaXNzaW9uTmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOyB9CiB9Owog CiB9IC8vIG5hbWVzcGFjZSBBUEkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQ29jb2EvV0tVSURlbGVnYXRlUHJpdmF0ZS5oCmluZGV4IGY2NmExYmEzZTg5MjI1M2Yx NzYzM2MzNDJjMjI5YWRmYWFiMjEzMjEuLjFkYjRiN2RmOWVmNTMzZmNjMGY2ZjgzMzIzMjMxMTM4 OWEzZmU3NzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9X S1VJRGVsZWdhdGVQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0Nv Y29hL1dLVUlEZWxlZ2F0ZVByaXZhdGUuaApAQCAtODgsNiArODgsMTcgQEAgdHlwZWRlZiBOU19F TlVNKE5TSW50ZWdlciwgX1dLRm9jdXNEaXJlY3Rpb24pIHsKICAgICBfV0tGb2N1c0RpcmVjdGlv bkZvcndhcmQsCiB9IFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCksIGlvcygxMi4yKSk7 CiAKK3R5cGVkZWYgTlNfRU5VTShOU0ludGVnZXIsIF9XS1Blcm1pc3Npb25OYW1lKSB7CisgICAg X1dLUGVybWlzc2lvbk5hbWVBY2NlbGVyb21ldGVyLAorICAgIF9XS1Blcm1pc3Npb25OYW1lQmFj a2dyb3VuZEZldGNoLAorICAgIF9XS1Blcm1pc3Npb25OYW1lQ2FtZXJhLAorICAgIF9XS1Blcm1p c3Npb25OYW1lRGlzcGxheUNhcHR1cmUsCisgICAgX1dLUGVybWlzc2lvbk5hbWVHZW9sb2NhdGlv biwKKyAgICBfV0tQZXJtaXNzaW9uTmFtZU1pY3JvcGhvbmUsCisgICAgX1dLUGVybWlzc2lvbk5h bWVOb3RpZmljYXRpb25zLAorICAgIF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbgor fSBXS19BUElfQVZBSUxBQkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoV0tfSU9TX1RCQSkpOwor CiBAcHJvdG9jb2wgV0tVSURlbGVnYXRlUHJpdmF0ZSA8V0tVSURlbGVnYXRlPgogCiAjaWZkZWYg Rk9VTkRBVElPTl9IQVNfRElSRUNUSU9OQUxfR0VPTUVUUlkKQEAgLTE2MCw2ICsxNzEsOCBAQCBz dHJ1Y3QgVUlFZGdlSW5zZXRzOwogCiAtICh2b2lkKV93ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJW aWV3IHN0YXJ0WFJTZXNzaW9uV2l0aENvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShpZCkpY29t cGxldGlvbkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMi4wKSwgaW9zKDE1LjApKTsK IAorLSAodm9pZClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyByZXF1ZXN0UGVybWlzc2lv bkZvck5hbWU6KF9XS1Blcm1pc3Npb25OYW1lKW5hbWUgb3JpZ2luOihXS1NlY3VyaXR5T3JpZ2lu ICopb3JpZ2luIHRvcE9yaWdpbjooV0tTZWN1cml0eU9yaWdpbiAqKXRvcE9yaWdpbiBkZWNpc2lv bkhhbmRsZXI6KHZvaWQgKF4pKFdLUGVybWlzc2lvbkRlY2lzaW9uIGRlY2lzaW9uKSlkZWNpc2lv bkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19U QkEpKTsKKwogI2lmIFRBUkdFVF9PU19JUEhPTkUKIAogLSAoQk9PTClfd2ViVmlldzooV0tXZWJW aWV3ICopd2ViVmlldyBzaG91bGRJbmNsdWRlQXBwTGlua0FjdGlvbnNGb3JFbGVtZW50OihfV0tB Y3RpdmF0ZWRFbGVtZW50SW5mbyAqKWVsZW1lbnQgV0tfQVBJX0FWQUlMQUJMRShpb3MoOS4wKSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1p c3Npb25VdGlsaXRpZXMubW0KaW5kZXggMTRlOWM4YWI1YmJmY2JmZmEwNGRkYjg1Y2JiMjcxOTUy MGMwNWVhZS4uZWY3MGViODQ3MTEwNzdjMmY3NjYyYzZhOTRhMTM2NTdlZjVhODFmZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvTWVkaWFQZXJtaXNzaW9uVXRpbGl0 aWVzLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5tbQpAQCAtMjcsMTkgKzI3LDIxIEBACiAjaW1wb3J0ICJNZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMuaCIKIAogI2ltcG9ydCAiU2FuZGJveFV0aWxpdGllcy5oIgotI2ltcG9ydCAi VENDU29mdExpbmsuaCIKICNpbXBvcnQgIldLV2ViVmlld0ludGVybmFsLmgiCiAjaW1wb3J0ICJX ZWJQYWdlUHJveHkuaCIKICNpbXBvcnQgPFdlYkNvcmUvTG9jYWxpemVkU3RyaW5ncy5oPgorI2lt cG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0 eU9yaWdpbkRhdGEuaD4KICNpbXBvcnQgPG11dGV4PgotI2ltcG9ydCA8cGFsL2NvY29hL0FWRm91 bmRhdGlvblNvZnRMaW5rLmg+Ci0jaW1wb3J0IDxwYWwvY29jb2EvU3BlZWNoU29mdExpbmsuaD4K ICNpbXBvcnQgPHd0Zi9CbG9ja1B0ci5oPgogI2ltcG9ydCA8d3RmL1VSTEhlbHBlcnMuaD4KICNp bXBvcnQgPHd0Zi9zcGkvY2YvQ0ZCdW5kbGVTUEkuaD4KICNpbXBvcnQgPHd0Zi9zcGkvZGFyd2lu L1NhbmRib3hTUEkuaD4KIAorI2ltcG9ydCAiVENDU29mdExpbmsuaCIKKyNpbXBvcnQgPHBhbC9j b2NvYS9BVkZvdW5kYXRpb25Tb2Z0TGluay5oPgorI2ltcG9ydCA8cGFsL2NvY29hL1NwZWVjaFNv ZnRMaW5rLmg+CisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBib29sIGNoZWNrU2FuZGJveFJlcXVp cmVtZW50Rm9yVHlwZShNZWRpYVBlcm1pc3Npb25UeXBlIHR5cGUpCkBAIC0yMjIsNiArMjI0LDIw IEBAIHZvaWQgYWxlcnRGb3JQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYgcGFnZSwgTWVkaWFQZXJt aXNzaW9uUmVhc29uIHJlYXNvbiwgY29uc3QKICNlbmRpZgogfQogCitzdGQ6Om9wdGlvbmFsPE1l ZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUpCit7CisgICAgc3dpdGNoIChwZXJtaXNz aW9uTmFtZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkNhbWVyYToKKyAg ICAgICAgcmV0dXJuIE1lZGlhUGVybWlzc2lvblJlYXNvbjo6Q2FtZXJhOworICAgIGNhc2UgV2Vi Q29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmU6CisgICAgICAgIHJldHVybiBNZWRpYVBl cm1pc3Npb25SZWFzb246Ok1pY3JvcGhvbmU7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9u TmFtZTo6R2VvbG9jYXRpb246CisgICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246 Okdlb2xvY2F0aW9uOworICAgIGRlZmF1bHQ6CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7 CisgICAgfQorfQorCiAjaWYgSEFWRShBVkNBUFRVUkVERVZJQ0UpCiAKIHZvaWQgcmVxdWVzdEFW Q2FwdHVyZUFjY2Vzc0ZvclR5cGUoTWVkaWFQZXJtaXNzaW9uVHlwZSB0eXBlLCBDb21wbGV0aW9u SGFuZGxlcjx2b2lkKGJvb2wgYXV0aG9yaXplZCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmggYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmgKaW5kZXggMzI5ZGI3OTFjZjQz MjcyNDYzNjM0MjgwMDUwNGIwOGVhODlkYjBlMy4uMGViOTRjZDA3N2Y1MmU1OGUxODJlMjdiZDVl OGFlYzUwZGVlYThiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2Ev VUlEZWxlZ2F0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdh dGUuaApAQCAtMTc1LDYgKzE3NSw4IEBAIHByaXZhdGU6CiAgICAgICAgIHZvaWQgc3RhcnRYUlNl c3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+ KT4mJikgZmluYWw7CiAjZW5kaWYKIAorICAgICAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFdl YlBhZ2VQcm94eSYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwgY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW4mLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhh bmRsZXI8dm9pZChib29sKT4mJikgZmluYWw7CisKICAgICAgICAgV2Vha1B0cjxVSURlbGVnYXRl PiBtX3VpRGVsZWdhdGU7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29h L1VJRGVsZWdhdGUubW0KaW5kZXggYmRkNmIzYTY4MzM1NWFjZWQzYjlhNzIwMjQ3YTYxMzE1ZWFl OWY0MS4uYTM0MmRiZTZmZTc5NmJkYzJlYTY5ZTQyYmZlN2NkY2RhZjYyYTA4OCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbQorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tCkBAIC02Myw2ICs2Myw3IEBA CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZDYXB0dXJlRGV2aWNlLmg+CiAjaW1wb3J0IDxBVkZv dW5kYXRpb24vQVZNZWRpYUZvcm1hdC5oPgogI2ltcG9ydCA8V2ViQ29yZS9Gb250QXR0cmlidXRl cy5oPgorI2ltcG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29y ZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3 dGYvVVJMLmg+CkBAIC0xNjg0LDQgKzE2ODUsNTkgQEAgdm9pZCBVSURlbGVnYXRlOjpVSUNsaWVu dDo6c3RhcnRYUlNlc3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgK IH0KICNlbmRpZgogCitzdGF0aWMgaW5saW5lIF9XS1Blcm1pc3Npb25OYW1lIHRvV0tQZXJtaXNz aW9uTmFtZShXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBuYW1lKQoreworICAgIHN3aXRjaCAobmFt ZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkFjY2VsZXJvbWV0ZXI6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZUFjY2VsZXJvbWV0ZXI7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZldGNoOgorICAgICAgICByZXR1cm4g X1dLUGVybWlzc2lvbk5hbWVCYWNrZ3JvdW5kRmV0Y2g7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6Q2FtZXJhOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVDYW1l cmE7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmU6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZURpc3BsYXlDYXB0dXJlOworICAgIGNhc2Ug V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Okdlb2xvY2F0aW9uOgorICAgICAgICByZXR1cm4gX1dL UGVybWlzc2lvbk5hbWVHZW9sb2NhdGlvbjsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25O YW1lOjpNaWNyb3Bob25lOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVNaWNyb3Bo b25lOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok5vdGlmaWNhdGlvbnM6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZU5vdGlmaWNhdGlvbnM7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6U3BlYWtlclNlbGVjdGlvbjoKKyAgICAgICAgcmV0dXJu IF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbjsKKyAgICB9Cit9CisKK3ZvaWQgVUlE ZWxlZ2F0ZTo6VUlDbGllbnQ6OnJlcXVlc3RQZXJtaXNzaW9uKFdlYktpdDo6V2ViUGFnZVByb3h5 JiBwYWdlLCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgb3JpZ2luLCBjb25zdCBXZWJD b3JlOjpTZWN1cml0eU9yaWdpbiYgdG9wT3JpZ2luLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBu YW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wgZ3JhbnRlZCk+JiYgY29tcGxldGlvbkhh bmRsZXIpCit7CisgICAgaWYgKCFtX3VpRGVsZWdhdGUpCisgICAgICAgIHJldHVybiBwYWdlLnJl cXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKG9yaWdpbi5kYXRhKCksIG5hbWUsIFdURk1v dmUoY29tcGxldGlvbkhhbmRsZXIpKTsKKworICAgIGF1dG8gZGVsZWdhdGUgPSAoaWQgPFdLVUlE ZWxlZ2F0ZVByaXZhdGU+KW1fdWlEZWxlZ2F0ZS0+bV9kZWxlZ2F0ZS5nZXQoKTsKKyAgICBpZiAo IWRlbGVnYXRlKQorICAgICAgICByZXR1cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVs dEFjdGlvbihvcmlnaW4uZGF0YSgpLCBuYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7 CisKKyAgICBpZiAoIVtkZWxlZ2F0ZSByZXNwb25kc1RvU2VsZWN0b3I6QHNlbGVjdG9yKF93ZWJW aWV3OnJlcXVlc3RQZXJtaXNzaW9uRm9yTmFtZTpvcmlnaW46dG9wT3JpZ2luOmRlY2lzaW9uSGFu ZGxlcjopXSkKKyAgICAgICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRB Y3Rpb24ob3JpZ2luLmRhdGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOwor CisgICAgYXV0byBhcGlPcmlnaW4gPSBBUEk6OlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUob3JpZ2lu KTsKKyAgICBhdXRvIGFwaVRvcE9yaWdpbiA9IEFQSTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZSh0 b3BPcmlnaW4pOworICAgIGF1dG8gY2hlY2tlciA9IENvbXBsZXRpb25IYW5kbGVyQ2FsbENoZWNr ZXI6OmNyZWF0ZShkZWxlZ2F0ZSwgQHNlbGVjdG9yKF93ZWJWaWV3OnJlcXVlc3RQZXJtaXNzaW9u Rm9yTmFtZTpvcmlnaW46dG9wT3JpZ2luOmRlY2lzaW9uSGFuZGxlcjopKTsKKyAgICBbZGVsZWdh dGUgX3dlYlZpZXc6bV91aURlbGVnYXRlLT5tX3dlYlZpZXcuZ2V0KCkuZ2V0KCkgcmVxdWVzdFBl cm1pc3Npb25Gb3JOYW1lOnRvV0tQZXJtaXNzaW9uTmFtZShuYW1lKSBvcmlnaW46d3JhcHBlcihh cGlPcmlnaW4pIHRvcE9yaWdpbjp3cmFwcGVyKGFwaVRvcE9yaWdpbikgZGVjaXNpb25IYW5kbGVy Om1ha2VCbG9ja1B0cihbY29tcGxldGlvbkhhbmRsZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5k bGVyKSwgY2hlY2tlciA9IFdURk1vdmUoY2hlY2tlciksIHBhZ2UgPSBtYWtlV2Vha1B0cihwYWdl KSwgbmFtZSwgb3JpZ2luRGF0YSA9IG9yaWdpbi5kYXRhKCldIChXS1Blcm1pc3Npb25EZWNpc2lv biBkZWNpc2lvbikgbXV0YWJsZSB7CisgICAgICAgIGlmIChjaGVja2VyLT5jb21wbGV0aW9uSGFu ZGxlckhhc0JlZW5DYWxsZWQoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgY2hlY2tl ci0+ZGlkQ2FsbENvbXBsZXRpb25IYW5kbGVyKCk7CisKKyAgICAgICAgc3dpdGNoIChkZWNpc2lv bikgeworICAgICAgICBjYXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uUHJvbXB0OgorICAgICAgICAg ICAgaWYgKCFwYWdlKQorICAgICAgICAgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcihm YWxzZSk7CisgICAgICAgICAgICByZXR1cm4gcGFnZS0+cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24ob3JpZ2luRGF0YSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOwor ICAgICAgICBjYXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uR3JhbnQ6CisgICAgICAgICAgICByZXR1 cm4gY29tcGxldGlvbkhhbmRsZXIodHJ1ZSk7CisgICAgICAgIGNhc2UgV0tQZXJtaXNzaW9uRGVj aXNpb25EZW55OgorICAgICAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsK KyAgICAgICAgfQorICAgIH0pLmdldCgpXTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9XZWJQYWdlUHJveHlDb2Nv YS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1t CmluZGV4IDMzMDFlZDQ4ZjA0NWE5ZGQ1NGYzYTg1M2JhZTkwZjEyZWRhN2NhNTcuLjlhZTRlNjcw MzhjNGM4YWZlM2FhNWNhMTFjODg5MTIxN2UwZjQ4NmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCkBAIC0zNCw2ICszNCw3IEBA CiAjaW1wb3J0ICJEYXRhRGV0ZWN0aW9uUmVzdWx0LmgiCiAjaW1wb3J0ICJJbnNlcnRUZXh0T3B0 aW9ucy5oIgogI2ltcG9ydCAiTG9hZFBhcmFtZXRlcnMuaCIKKyNpbXBvcnQgIk1lZGlhUGVybWlz c2lvblV0aWxpdGllcy5oIgogI2ltcG9ydCAiUGFnZUNsaWVudC5oIgogI2ltcG9ydCAiUXVhcmFu dGluZVNQSS5oIgogI2ltcG9ydCAiUXVpY2tMb29rVGh1bWJuYWlsTG9hZGVyLmgiCkBAIC03NTAs NiArNzUxLDE1IEBAIGJvb2wgV2ViUGFnZVByb3h5Ojppc1F1YXJhbnRpbmVkQW5kTm90VXNlckFw cHJvdmVkKGNvbnN0IFN0cmluZyYgZmlsZVVSTFN0cmluZykKIH0KICNlbmRpZgogCit2b2lkIFdl YlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiBvcmlnaW4sIFBlcm1pc3Npb25OYW1lIHBlcm1pc3Npb25O YW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQor eworICAgIGF1dG8gcmVhc29uID0gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24ocGVybWlz c2lvbk5hbWUpOworICAgIGlmICghcmVhc29uKQorICAgICAgICByZXR1cm4gY29tcGxldGlvbkhh bmRsZXIoZmFsc2UpOworCisgICAgYWxlcnRGb3JQZXJtaXNzaW9uKCp0aGlzLCAqcmVhc29uLCBv cmlnaW4sIFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0CiAKICN1bmRlZiBNRVNTQUdFX0NIRUNLX0NPTVBMRVRJT04KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKaW5kZXggNWEzMTUx Njk1Y2M0ZDhlNDAzNDcwNjRmY2ZhZTQ1ODFmZDdmYTE5NS4uYzZjMGFhNzBhYjgzYzhmN2E0OGU1 ZTQxZmIxNmFlZmRhOGNmODM4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lv bk5hbWUgOiB1aW50OF90OwogY2xhc3MgU2VjdXJpdHlPcmlnaW47CiB9CiAKQEAgLTU3LDYgKzU4 LDggQEAgZW51bSBjbGFzcyBNZWRpYVBlcm1pc3Npb25SZWFzb24gewogICAgIFNwZWVjaFJlY29n bml0aW9uCiB9OwogCitzdGQ6Om9wdGlvbmFsPE1lZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVy dFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUpOworCiAjaWYg UExBVEZPUk0oQ09DT0EpCiBib29sIGNoZWNrU2FuZGJveFJlcXVpcmVtZW50Rm9yVHlwZShNZWRp YVBlcm1pc3Npb25UeXBlKTsKIGJvb2wgY2hlY2tVc2FnZURlc2NyaXB0aW9uU3RyaW5nRm9yVHlw ZShNZWRpYVBlcm1pc3Npb25UeXBlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuY3BwCmluZGV4IDJmZTkzYTU5MTU2ZThiMGU2OTg3YzA4ODU1ZDNkMGFkMzI5YzgwNjUuLmUy MmQ2ZTYwOGZkYjlkMzdmNzAyYzUyNDQwMDgxYTlhMzEwMzJhNTYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtMTcxLDYgKzE3MSw3IEBACiAjaW5jbHVkZSA8 V2ViQ29yZS9NSU1FVHlwZVJlZ2lzdHJ5Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9NZWRpYVN0cmVh bVJlcXVlc3QuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BlcmZvcm1hbmNlTG9nZ2luZ0NsaWVudC5o PgorI2luY2x1ZGUgPFdlYkNvcmUvUGVybWlzc2lvbkRlc2NyaXB0b3IuaD4KICNpbmNsdWRlIDxX ZWJDb3JlL1Blcm1pc3Npb25TdGF0ZS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1FdmVu dC5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQuaD4KQEAgLTg1 MDIsMTAgKzg1MDMsMTQgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnJldm9rZUdlb2xvY2F0aW9uQXV0 aG9yaXphdGlvblRva2VuKGNvbnN0IFN0cmluZyYgYXV0aG9yaXphdGkKICAgICBtX2dlb2xvY2F0 aW9uUGVybWlzc2lvblJlcXVlc3RNYW5hZ2VyLnJldm9rZUF1dGhvcml6YXRpb25Ub2tlbihhdXRo b3JpemF0aW9uVG9rZW4pOwogfQogCi12b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Np b24oY29uc3QgQ2xpZW50T3JpZ2luJiwgY29uc3QgUGVybWlzc2lvbkRlc2NyaXB0b3ImLCBDb21w bGV0aW9uSGFuZGxlcjx2b2lkKFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIp Cit2b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb24oY29uc3QgQ2xpZW50T3JpZ2lu JiBvcmlnaW4sIGNvbnN0IFBlcm1pc3Npb25EZXNjcmlwdG9yJiBkZXNjcmlwdG9yLCBDb21wbGV0 aW9uSGFuZGxlcjx2b2lkKFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIpCiB7 Ci0gICAgLy8gRklYTUU6IFNob3cgYSBwcm9tcHQgZm9yIHVzZXIgaW5wdXQuCi0gICAgY29tcGxl dGlvbkhhbmRsZXIoUGVybWlzc2lvblN0YXRlOjpHcmFudGVkKTsKKyAgICBhdXRvIHNlY3VyaXR5 T3JpZ2luID0gb3JpZ2luLmNsaWVudE9yaWdpbi5zZWN1cml0eU9yaWdpbigpOworICAgIGF1dG8g dG9wU2VjdXJpdHlPcmlnaW4gPSBvcmlnaW4udG9wT3JpZ2luLnNlY3VyaXR5T3JpZ2luKCk7Cisg ICAgbV91aUNsaWVudC0+cmVxdWVzdFBlcm1pc3Npb24oKnRoaXMsIHNlY3VyaXR5T3JpZ2luLmdl dCgpLCB0b3BTZWN1cml0eU9yaWdpbi5nZXQoKSwgZGVzY3JpcHRvci5uYW1lLCBbY29tcGxldGlv bkhhbmRsZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKV0oYm9vbCBncmFudGVkKSBtdXRh YmxlIHsKKyAgICAgICAgYXV0byBwZXJtaXNzaW9uc1N0YXRlID0gZ3JhbnRlZCA/IFBlcm1pc3Np b25TdGF0ZTo6R3JhbnRlZCA6IFBlcm1pc3Npb25TdGF0ZTo6RGVuaWVkOworICAgICAgICBjb21w bGV0aW9uSGFuZGxlcihwZXJtaXNzaW9uc1N0YXRlKTsKKyAgICB9KTsKIH0KIAogI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCkBAIC0xMDg3Niw2ICsxMDg4MSwxNSBAQCB2b2lkIFdlYlBhZ2VQcm94 eTo6Y2xlYXJBcHBQcml2YWN5UmVwb3J0VGVzdGluZ0RhdGEoQ29tcGxldGlvbkhhbmRsZXI8dm9p ZCgpPiYmCiB9CiAjZW5kaWYKIAorI2lmICFQTEFURk9STShDT0NPQSkKKwordm9pZCBXZWJQYWdl UHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNl Y3VyaXR5T3JpZ2luRGF0YSYsIFBlcm1pc3Npb25OYW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lk KGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQoreworICAgIGNvbXBsZXRpb25IYW5kbGVyKGZh bHNlKTsKK30KKworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjdW5kZWYgV0VC UEFHRVBST1hZX1JFTEVBU0VfTE9HCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9XZWJQYWdlUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5o CmluZGV4IDU0ZmFkMjIzZDFhMzg4ZTljMGQ0YTY3YTQ1NGFhM2ZmNWMwZGM4MGQuLmJkOTZhNGZj OTE0NWEyNGFmNWU3YzBlZjdhYTM5MGZlNWRjZmE5OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5oCkBAIC0yNjgsNiArMjY4LDcgQEAgZW51bSBjbGFzcyBIaWdobGlnaHRS ZXF1ZXN0T3JpZ2luYXRlZEluQXBwIDogYm9vbDsKIGVudW0gY2xhc3MgSGlnaGxpZ2h0VmlzaWJp bGl0eSA6IGJvb2w7CiBlbnVtIGNsYXNzIE1vdXNlRXZlbnRQb2xpY3kgOiB1aW50OF90OwogZW51 bSBjbGFzcyBOb3RpZmljYXRpb25EaXJlY3Rpb24gOiB1aW50OF90OworZW51bSBjbGFzcyBQZXJt aXNzaW9uTmFtZSA6IHVpbnQ4X3Q7CiBlbnVtIGNsYXNzIFJvdXRlU2hhcmluZ1BvbGljeSA6IHVp bnQ4X3Q7CiBlbnVtIGNsYXNzIFNlbGVjdGlvbkRpcmVjdGlvbiA6IHVpbnQ4X3Q7CiBlbnVtIGNs YXNzIFNob3VsZFNhbXBsZSA6IGJvb2w7CkBAIC0xOTA0LDYgKzE5MDUsNyBAQCBwdWJsaWM6CiAg ICAgdm9pZCByZXF1ZXN0VXNlck1lZGlhUGVybWlzc2lvbkZvclNwZWVjaFJlY29nbml0aW9uKFdl YkNvcmU6OkZyYW1lSWRlbnRpZmllciwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mLCBj b25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9v bCk+JiYpOwogCiAgICAgdm9pZCByZXF1ZXN0TWVkaWFLZXlTeXN0ZW1QZXJtaXNzaW9uQnlEZWZh dWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luRGF0YSYsIENvbXBsZXRpb25I YW5kbGVyPHZvaWQoYm9vbCk+JiYpOworICAgIHZvaWQgcmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgV2ViQ29yZTo6UGVy bWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYpOwogCiAgICAgdm9p ZCBzeW5jSWZNb2NrRGV2aWNlc0VuYWJsZWRDaGFuZ2VkKCk7CiAKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mv Q2hhbmdlTG9nCmluZGV4IDE2NGI2MTQ1NTBiMzZhYzE4ZDlmZTJmYTIwYjI4ZjJjODE3MzZjN2Mu LjRmYTljYjQyMjFjYjVjMTNlNWZlYWNmMDU3MDYyN2M2M2U2NDc5ZDUgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvaW1wb3J0 ZWQvdzNjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDIxLTA5LTA1ICBTaWh1aSBMaXUg IDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBlcm1pc3Np b25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHdlYi1wbGF0Zm9ybS10ZXN0cy9w ZXJtaXNzaW9ucy9uZmMtcGVybWlzc2lvbi1leHBlY3RlZC50eHQ6CisKIDIwMjEtMDktMDMgIEpv aG5zb24gWmhvdSAgPHFpYW9zb25nX3pob3VAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZGl0aW9u IG9mIENTU051bWVyaWNGYWN0b3J5IGluIENTUyBUeXBlZCBPTQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9wZXJtaXNzaW9ucy9uZmMtcGVy bWlzc2lvbi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mvd2ViLXBsYXRm b3JtLXRlc3RzL3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVjdGVkLnR4dAppbmRleCBj MmZkNjVlOGQ0MDAyYTcyMzAxODdhNjFmNTFjMjgyZWZjMWM2YmVjLi43NmNmODczY2VjMjQ4YWNk M2M2YTIwZjYwZTExNzA4YmNjYmRiMDhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbXBvcnRl ZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3RzL3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3Rz L3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVjdGVkLnR4dApAQCAtMSwzICsxLDMgQEAK IAotUEFTUyBUZXN0IFdlYiBORkMgUGVybWlzc2lvbi4KK0ZBSUwgVGVzdCBXZWIgTkZDIFBlcm1p c3Npb24uIHByb21pc2VfdGVzdDogVW5oYW5kbGVkIHJlamVjdGlvbiB3aXRoIHZhbHVlOiBvYmpl Y3QgIlR5cGVFcnJvcjogVHlwZSBlcnJvciIKIAo= 437386 2021-09-05 23:07:56 -0700 2021-09-06 10:24:39 -0700 Patch bug-229590-20210905230755.patch text/plain 19751 sihui_liu U3VidmVyc2lvbiBSZXZpc2lvbjogMjgyMDQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGIyNzY3YTNjNzI4ZDk3 YWJmOTg1ZTk3ZjNkNWUzMTQ0ZTkyOWQzZi4uMTI3NGNiODM2NjM1NDMwZDM2NWNkOTZkZmUxYWQ4 NGJjNjZmZDQyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA5LTA1ICBTaWh1 aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBl cm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1vdmUgc29tZSBwZXJt aXNzaW9uIG5hbWVzIGFzIHRoZWlyIGZlYXR1cmVzIGFyZSBub3Qgc3VwcG9ydGVkLgorCisgICAg ICAgICogTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNzaW9uTmFtZS5oOgorICAgICAgICAqIE1v ZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaWRsOgorCiAyMDIxLTA5LTA1ICBNeWxl cyBDLiBNYXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIHVu bmVjZXNzYXJ5IHVzZXMgb2YgUmVmIHByb3RlY3QgPSBtX2JhY2tpbmcgZnJvbSBGb250RmFjZVNl dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZwppbmRleCA1OGQzNjgwMjM5ZDMyNzc2Yjg4OTNjZmFmNTFhZDc1MmMzYmUwNDFkLi44 ZjdhZmQ2YjEwZWNhYWEzNGU4NWZjYTVkMzkyYjUzYWJlZDEzNTQ2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwz ICsxLDMxIEBACisyMDIxLTA5LTA1ICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29tPgor CisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBlcm1pc3Npb25zIEFQSQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI5NTkwCisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS84MjY4Njk0OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBEaXNwbGF5IGEgcHJvbXB0IGZvciBwZXJtaXNzaW9uIHJlcXVlc3QgYnkgZGVm YXVsdC4gTm8gb2JzZXJ2YWJsZSBiZWhhdmlvciBjaGFuZ2UgZnJvbSB0aGlzIGFzIHRoZSBwZXJt aXNpb24gCisgICAgICAgIHJlcXVlc3QgZmxvdyBpcyBub3QgdXNlZCBieSBhbnkgZmVhdHVyZSB5 ZXQuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0FQSVVJQ2xpZW50Lmg6CisgICAgICAgIChB UEk6OlVJQ2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29h L01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5tbToKKyAgICAgICAgKFdlYktpdDo6Y29udmVydFBl cm1pc3Npb25OYW1lVG9SZWFzb24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db2NvYS9VSURlbGVn YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdhdGUubW06CisgICAgICAg IChXZWJLaXQ6OnRvV0tQZXJtaXNzaW9uTmFtZSk6CisgICAgICAgIChXZWJLaXQ6OlVJRGVsZWdh dGU6OlVJQ2xpZW50OjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAgICAgICogVUlQcm9jZXNzL0Nv Y29hL1dlYlBhZ2VQcm94eUNvY29hLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Np b24pOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlE ZWZhdWx0QWN0aW9uKToKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6CisKIDIw MjEtMDktMDUgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAg ICAgVXNlIGEgc3Ryb25nbHkgdHlwZWQgaWRlbnRpZmllciBmb3IgYXV0aGVudGljYXRpb24gY2hh bGxlbmdlIElEcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9u cy9QZXJtaXNzaW9uTmFtZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9Q ZXJtaXNzaW9uTmFtZS5oCmluZGV4IGRkMjgzZjE2OTQyYzA1ZDIzMWMzYTlmZGJiY2QyYWI3ZTRm OTg4OTMuLjY3Mzg5MGY4MTNlOWY5MWRmNTdkYzhjZDlmMTc0NjgxNDVkYWM4YTUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvcGVybWlzc2lvbnMvUGVybWlzc2lvbk5hbWUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmgK QEAgLTMyLDE1ICszMiwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBlbnVtIGNsYXNzIFBlcm1p c3Npb25OYW1lIDogdWludDhfdCB7CiAgICAgQWNjZWxlcm9tZXRlciwKICAgICBCYWNrZ3JvdW5k RmV0Y2gsCi0gICAgQmx1ZXRvb3RoLAogICAgIENhbWVyYSwKICAgICBEaXNwbGF5Q2FwdHVyZSwK ICAgICBHZW9sb2NhdGlvbiwKLSAgICBHeXJvc2NvcGUsCi0gICAgTWFnbmV0b21ldGVyLAogICAg IE1pY3JvcGhvbmUsCi0gICAgTWlkaSwKLSAgICBOZmMsCiAgICAgTm90aWZpY2F0aW9ucywKICAg ICBTcGVha2VyU2VsZWN0aW9uCiB9OwpAQCAtNTQsMTUgKzQ5LDEwIEBAIHRlbXBsYXRlPD4gc3Ry dWN0IEVudW1UcmFpdHM8V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU+IHsKICAgICAgICAgV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25OYW1lOjpBY2Nl bGVyb21ldGVyLAogICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZl dGNoLAotICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Qmx1ZXRvb3RoLAogICAgICAg ICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Q2FtZXJhLAogICAgICAgICBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmUsCiAgICAgICAgIFdlYkNvcmU6OlBlcm1pc3Npb25O YW1lOjpHZW9sb2NhdGlvbiwKLSAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Okd5cm9z Y29wZSwKLSAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1hZ25ldG9tZXRlciwKICAg ICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmUsCi0gICAgICAgIFdlYkNv cmU6OlBlcm1pc3Npb25OYW1lOjpNaWRpLAotICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFt ZTo6TmZjLAogICAgICAgICBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6Tm90aWZpY2F0aW9ucywK ICAgICAgICAgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OlNwZWFrZXJTZWxlY3Rpb24KICAgICA+ OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wZXJtaXNzaW9ucy9QZXJtaXNz aW9uTmFtZS5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Np b25OYW1lLmlkbAppbmRleCA5NTVhNzFmODI5NWUwZDAxOTY1ODY0ZmQxMWIwOTkzMDVhY2FiYmZi Li4xMjJmMjdjOTllOTdlZTUxNTcxYjQwNjA5ODEzZGQ1NTAxYjcxZjFhIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3Blcm1pc3Npb25zL1Blcm1pc3Npb25OYW1lLmlkbApA QCAtMjksMTUgKzI5LDEwIEBAIGVudW0gUGVybWlzc2lvbk5hbWUgewogICAgIC8vIEZJWE1FOiB1 cGRhdGUgdGhlIGxpc3QgdG8gbWF0Y2ggc3BlYyB3aGVuIG5ldyBmZWF0dXJlcyBhcmUgaW1wbGVt ZW50ZWQuCiAgICAgImFjY2VsZXJvbWV0ZXIiLAogICAgICJiYWNrZ3JvdW5kLWZldGNoIiwKLSAg ICAiYmx1ZXRvb3RoIiwKICAgICAiY2FtZXJhIiwKICAgICAiZGlzcGxheS1jYXB0dXJlIiwKICAg ICAiZ2VvbG9jYXRpb24iLAotICAgICJneXJvc2NvcGUiLAotICAgICJtYWduZXRvbWV0ZXIiLAog ICAgICJtaWNyb3Bob25lIiwKLSAgICAibWlkaSIsCi0gICAgIm5mYyIsCiAgICAgIm5vdGlmaWNh dGlvbnMiLAogICAgICJzcGVha2VyLXNlbGVjdGlvbiIKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9BUEkvQVBJVUlDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9BUElVSUNsaWVudC5oCmluZGV4IDJkYjBmNTY5Y2IyMjUwNTg5ZTdlYzE2MDU4ZGFm YjVhNmE0ZTdiZjAuLmRmZDkzZTFhZWY4YjYzMzEwMzNjNDgzNzFiMWVlZGVmZjM4NzEzZGQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCisrKyBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9BUElVSUNsaWVudC5oCkBAIC00NCwxMCArNDQs MTAgQEAgT0JKQ19DTEFTUyBVSVZpZXdDb250cm9sbGVyOwogI2VuZGlmCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lvbk5hbWUgOiB1aW50OF90OwogY2xhc3MgUmVn aXN0cmFibGVEb21haW47CiBjbGFzcyBSZXNvdXJjZVJlcXVlc3Q7CiBzdHJ1Y3QgRm9udEF0dHJp YnV0ZXM7Ci1zdHJ1Y3QgU2VjdXJpdHlPcmlnaW5EYXRhOwogc3RydWN0IFdpbmRvd0ZlYXR1cmVz OwogfQogCkBAIC0yMTEsNiArMjExLDggQEAgcHVibGljOgogI2lmIEVOQUJMRShXRUJYUikgJiYg UExBVEZPUk0oQ09DT0EpCiAgICAgdmlydHVhbCB2b2lkIHN0YXJ0WFJTZXNzaW9uKFdlYktpdDo6 V2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+KT4mJiBj b21wbGV0aW9uSGFuZGxlcikgeyBjb21wbGV0aW9uSGFuZGxlcihuaWwpOyB9CiAjZW5kaWYKKwor ICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihXZWJLaXQ6OldlYlBhZ2VQcm94eSYg cGFnZSwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mIG9yaWdpbiwgY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW4mIHRvcE9yaWdpbiwgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUgcGVy bWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYgY29tcGxldGlvbkhh bmRsZXIpIHsgcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVsdEFjdGlvbihvcmlnaW4uZGF0 YSgpLCBwZXJtaXNzaW9uTmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOyB9CiB9Owog CiB9IC8vIG5hbWVzcGFjZSBBUEkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS1VJRGVsZWdhdGVQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQ29jb2EvV0tVSURlbGVnYXRlUHJpdmF0ZS5oCmluZGV4IGY2NmExYmEzZTg5MjI1M2Yx NzYzM2MzNDJjMjI5YWRmYWFiMjEzMjEuLjFkYjRiN2RmOWVmNTMzZmNjMGY2ZjgzMzIzMjMxMTM4 OWEzZmU3NzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9X S1VJRGVsZWdhdGVQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0Nv Y29hL1dLVUlEZWxlZ2F0ZVByaXZhdGUuaApAQCAtODgsNiArODgsMTcgQEAgdHlwZWRlZiBOU19F TlVNKE5TSW50ZWdlciwgX1dLRm9jdXNEaXJlY3Rpb24pIHsKICAgICBfV0tGb2N1c0RpcmVjdGlv bkZvcndhcmQsCiB9IFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCksIGlvcygxMi4yKSk7 CiAKK3R5cGVkZWYgTlNfRU5VTShOU0ludGVnZXIsIF9XS1Blcm1pc3Npb25OYW1lKSB7CisgICAg X1dLUGVybWlzc2lvbk5hbWVBY2NlbGVyb21ldGVyLAorICAgIF9XS1Blcm1pc3Npb25OYW1lQmFj a2dyb3VuZEZldGNoLAorICAgIF9XS1Blcm1pc3Npb25OYW1lQ2FtZXJhLAorICAgIF9XS1Blcm1p c3Npb25OYW1lRGlzcGxheUNhcHR1cmUsCisgICAgX1dLUGVybWlzc2lvbk5hbWVHZW9sb2NhdGlv biwKKyAgICBfV0tQZXJtaXNzaW9uTmFtZU1pY3JvcGhvbmUsCisgICAgX1dLUGVybWlzc2lvbk5h bWVOb3RpZmljYXRpb25zLAorICAgIF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbgor fSBXS19BUElfQVZBSUxBQkxFKG1hY29zKFdLX01BQ19UQkEpLCBpb3MoV0tfSU9TX1RCQSkpOwor CiBAcHJvdG9jb2wgV0tVSURlbGVnYXRlUHJpdmF0ZSA8V0tVSURlbGVnYXRlPgogCiAjaWZkZWYg Rk9VTkRBVElPTl9IQVNfRElSRUNUSU9OQUxfR0VPTUVUUlkKQEAgLTE2MCw2ICsxNzEsOCBAQCBz dHJ1Y3QgVUlFZGdlSW5zZXRzOwogCiAtICh2b2lkKV93ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJW aWV3IHN0YXJ0WFJTZXNzaW9uV2l0aENvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShpZCkpY29t cGxldGlvbkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMi4wKSwgaW9zKDE1LjApKTsK IAorLSAodm9pZClfd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyByZXF1ZXN0UGVybWlzc2lv bkZvck5hbWU6KF9XS1Blcm1pc3Npb25OYW1lKW5hbWUgb3JpZ2luOihXS1NlY3VyaXR5T3JpZ2lu ICopb3JpZ2luIHRvcE9yaWdpbjooV0tTZWN1cml0eU9yaWdpbiAqKXRvcE9yaWdpbiBkZWNpc2lv bkhhbmRsZXI6KHZvaWQgKF4pKFdLUGVybWlzc2lvbkRlY2lzaW9uIGRlY2lzaW9uKSlkZWNpc2lv bkhhbmRsZXIgV0tfQVBJX0FWQUlMQUJMRShtYWNvcyhXS19NQUNfVEJBKSwgaW9zKFdLX0lPU19U QkEpKTsKKwogI2lmIFRBUkdFVF9PU19JUEhPTkUKIAogLSAoQk9PTClfd2ViVmlldzooV0tXZWJW aWV3ICopd2ViVmlldyBzaG91bGRJbmNsdWRlQXBwTGlua0FjdGlvbnNGb3JFbGVtZW50OihfV0tB Y3RpdmF0ZWRFbGVtZW50SW5mbyAqKWVsZW1lbnQgV0tfQVBJX0FWQUlMQUJMRShpb3MoOS4wKSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMubW0gYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9NZWRpYVBlcm1p c3Npb25VdGlsaXRpZXMubW0KaW5kZXggMTRlOWM4YWI1YmJmY2JmZmEwNGRkYjg1Y2JiMjcxOTUy MGMwNWVhZS4uZWY3MGViODQ3MTEwNzdjMmY3NjYyYzZhOTRhMTM2NTdlZjVhODFmZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvTWVkaWFQZXJtaXNzaW9uVXRpbGl0 aWVzLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL01lZGlhUGVybWlzc2lv blV0aWxpdGllcy5tbQpAQCAtMjcsMTkgKzI3LDIxIEBACiAjaW1wb3J0ICJNZWRpYVBlcm1pc3Np b25VdGlsaXRpZXMuaCIKIAogI2ltcG9ydCAiU2FuZGJveFV0aWxpdGllcy5oIgotI2ltcG9ydCAi VENDU29mdExpbmsuaCIKICNpbXBvcnQgIldLV2ViVmlld0ludGVybmFsLmgiCiAjaW1wb3J0ICJX ZWJQYWdlUHJveHkuaCIKICNpbXBvcnQgPFdlYkNvcmUvTG9jYWxpemVkU3RyaW5ncy5oPgorI2lt cG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9TZWN1cml0 eU9yaWdpbkRhdGEuaD4KICNpbXBvcnQgPG11dGV4PgotI2ltcG9ydCA8cGFsL2NvY29hL0FWRm91 bmRhdGlvblNvZnRMaW5rLmg+Ci0jaW1wb3J0IDxwYWwvY29jb2EvU3BlZWNoU29mdExpbmsuaD4K ICNpbXBvcnQgPHd0Zi9CbG9ja1B0ci5oPgogI2ltcG9ydCA8d3RmL1VSTEhlbHBlcnMuaD4KICNp bXBvcnQgPHd0Zi9zcGkvY2YvQ0ZCdW5kbGVTUEkuaD4KICNpbXBvcnQgPHd0Zi9zcGkvZGFyd2lu L1NhbmRib3hTUEkuaD4KIAorI2ltcG9ydCAiVENDU29mdExpbmsuaCIKKyNpbXBvcnQgPHBhbC9j b2NvYS9BVkZvdW5kYXRpb25Tb2Z0TGluay5oPgorI2ltcG9ydCA8cGFsL2NvY29hL1NwZWVjaFNv ZnRMaW5rLmg+CisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBib29sIGNoZWNrU2FuZGJveFJlcXVp cmVtZW50Rm9yVHlwZShNZWRpYVBlcm1pc3Npb25UeXBlIHR5cGUpCkBAIC0yMjIsNiArMjI0LDIw IEBAIHZvaWQgYWxlcnRGb3JQZXJtaXNzaW9uKFdlYlBhZ2VQcm94eSYgcGFnZSwgTWVkaWFQZXJt aXNzaW9uUmVhc29uIHJlYXNvbiwgY29uc3QKICNlbmRpZgogfQogCitzdGQ6Om9wdGlvbmFsPE1l ZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29y ZTo6UGVybWlzc2lvbk5hbWUgcGVybWlzc2lvbk5hbWUpCit7CisgICAgc3dpdGNoIChwZXJtaXNz aW9uTmFtZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkNhbWVyYToKKyAg ICAgICAgcmV0dXJuIE1lZGlhUGVybWlzc2lvblJlYXNvbjo6Q2FtZXJhOworICAgIGNhc2UgV2Vi Q29yZTo6UGVybWlzc2lvbk5hbWU6Ok1pY3JvcGhvbmU6CisgICAgICAgIHJldHVybiBNZWRpYVBl cm1pc3Npb25SZWFzb246Ok1pY3JvcGhvbmU7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9u TmFtZTo6R2VvbG9jYXRpb246CisgICAgICAgIHJldHVybiBNZWRpYVBlcm1pc3Npb25SZWFzb246 Okdlb2xvY2F0aW9uOworICAgIGRlZmF1bHQ6CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7 CisgICAgfQorfQorCiAjaWYgSEFWRShBVkNBUFRVUkVERVZJQ0UpCiAKIHZvaWQgcmVxdWVzdEFW Q2FwdHVyZUFjY2Vzc0ZvclR5cGUoTWVkaWFQZXJtaXNzaW9uVHlwZSB0eXBlLCBDb21wbGV0aW9u SGFuZGxlcjx2b2lkKGJvb2wgYXV0aG9yaXplZCk+JiYgY29tcGxldGlvbkhhbmRsZXIpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmggYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLmgKaW5kZXggMzI5ZGI3OTFjZjQz MjcyNDYzNjM0MjgwMDUwNGIwOGVhODlkYjBlMy4uMGViOTRjZDA3N2Y1MmU1OGUxODJlMjdiZDVl OGFlYzUwZGVlYThiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2Ev VUlEZWxlZ2F0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1VJRGVsZWdh dGUuaApAQCAtMTc1LDYgKzE3NSw4IEBAIHByaXZhdGU6CiAgICAgICAgIHZvaWQgc3RhcnRYUlNl c3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZChSZXRhaW5QdHI8aWQ+ KT4mJikgZmluYWw7CiAjZW5kaWYKIAorICAgICAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFdl YlBhZ2VQcm94eSYsIGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luJiwgY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW4mLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSwgQ29tcGxldGlvbkhh bmRsZXI8dm9pZChib29sKT4mJikgZmluYWw7CisKICAgICAgICAgV2Vha1B0cjxVSURlbGVnYXRl PiBtX3VpRGVsZWdhdGU7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29h L1VJRGVsZWdhdGUubW0KaW5kZXggYmRkNmIzYTY4MzM1NWFjZWQzYjlhNzIwMjQ3YTYxMzE1ZWFl OWY0MS4uYTM0MmRiZTZmZTc5NmJkYzJlYTY5ZTQyYmZlN2NkY2RhZjYyYTA4OCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQ29jb2EvVUlEZWxlZ2F0ZS5tbQorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9VSURlbGVnYXRlLm1tCkBAIC02Myw2ICs2Myw3IEBA CiAjaW1wb3J0IDxBVkZvdW5kYXRpb24vQVZDYXB0dXJlRGV2aWNlLmg+CiAjaW1wb3J0IDxBVkZv dW5kYXRpb24vQVZNZWRpYUZvcm1hdC5oPgogI2ltcG9ydCA8V2ViQ29yZS9Gb250QXR0cmlidXRl cy5oPgorI2ltcG9ydCA8V2ViQ29yZS9QZXJtaXNzaW9uTmFtZS5oPgogI2ltcG9ydCA8V2ViQ29y ZS9TZWN1cml0eU9yaWdpbi5oPgogI2ltcG9ydCA8d3RmL0Jsb2NrUHRyLmg+CiAjaW1wb3J0IDx3 dGYvVVJMLmg+CkBAIC0xNjg0LDQgKzE2ODUsNTkgQEAgdm9pZCBVSURlbGVnYXRlOjpVSUNsaWVu dDo6c3RhcnRYUlNlc3Npb24oV2ViUGFnZVByb3h5JiwgQ29tcGxldGlvbkhhbmRsZXI8dm9pZCgK IH0KICNlbmRpZgogCitzdGF0aWMgaW5saW5lIF9XS1Blcm1pc3Npb25OYW1lIHRvV0tQZXJtaXNz aW9uTmFtZShXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBuYW1lKQoreworICAgIHN3aXRjaCAobmFt ZSkgeworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6OkFjY2VsZXJvbWV0ZXI6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZUFjY2VsZXJvbWV0ZXI7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6QmFja2dyb3VuZEZldGNoOgorICAgICAgICByZXR1cm4g X1dLUGVybWlzc2lvbk5hbWVCYWNrZ3JvdW5kRmV0Y2g7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJt aXNzaW9uTmFtZTo6Q2FtZXJhOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVDYW1l cmE7CisgICAgY2FzZSBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6RGlzcGxheUNhcHR1cmU6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZURpc3BsYXlDYXB0dXJlOworICAgIGNhc2Ug V2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Okdlb2xvY2F0aW9uOgorICAgICAgICByZXR1cm4gX1dL UGVybWlzc2lvbk5hbWVHZW9sb2NhdGlvbjsKKyAgICBjYXNlIFdlYkNvcmU6OlBlcm1pc3Npb25O YW1lOjpNaWNyb3Bob25lOgorICAgICAgICByZXR1cm4gX1dLUGVybWlzc2lvbk5hbWVNaWNyb3Bo b25lOworICAgIGNhc2UgV2ViQ29yZTo6UGVybWlzc2lvbk5hbWU6Ok5vdGlmaWNhdGlvbnM6Cisg ICAgICAgIHJldHVybiBfV0tQZXJtaXNzaW9uTmFtZU5vdGlmaWNhdGlvbnM7CisgICAgY2FzZSBX ZWJDb3JlOjpQZXJtaXNzaW9uTmFtZTo6U3BlYWtlclNlbGVjdGlvbjoKKyAgICAgICAgcmV0dXJu IF9XS1Blcm1pc3Npb25OYW1lU3BlYWtlclNlbGVjdGlvbjsKKyAgICB9Cit9CisKK3ZvaWQgVUlE ZWxlZ2F0ZTo6VUlDbGllbnQ6OnJlcXVlc3RQZXJtaXNzaW9uKFdlYktpdDo6V2ViUGFnZVByb3h5 JiBwYWdlLCBjb25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgb3JpZ2luLCBjb25zdCBXZWJD b3JlOjpTZWN1cml0eU9yaWdpbiYgdG9wT3JpZ2luLCBXZWJDb3JlOjpQZXJtaXNzaW9uTmFtZSBu YW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wgZ3JhbnRlZCk+JiYgY29tcGxldGlvbkhh bmRsZXIpCit7CisgICAgaWYgKCFtX3VpRGVsZWdhdGUpCisgICAgICAgIHJldHVybiBwYWdlLnJl cXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKG9yaWdpbi5kYXRhKCksIG5hbWUsIFdURk1v dmUoY29tcGxldGlvbkhhbmRsZXIpKTsKKworICAgIGF1dG8gZGVsZWdhdGUgPSAoaWQgPFdLVUlE ZWxlZ2F0ZVByaXZhdGU+KW1fdWlEZWxlZ2F0ZS0+bV9kZWxlZ2F0ZS5nZXQoKTsKKyAgICBpZiAo IWRlbGVnYXRlKQorICAgICAgICByZXR1cm4gcGFnZS5yZXF1ZXN0UGVybWlzc2lvbkJ5RGVmYXVs dEFjdGlvbihvcmlnaW4uZGF0YSgpLCBuYW1lLCBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSk7 CisKKyAgICBpZiAoIVtkZWxlZ2F0ZSByZXNwb25kc1RvU2VsZWN0b3I6QHNlbGVjdG9yKF93ZWJW aWV3OnJlcXVlc3RQZXJtaXNzaW9uRm9yTmFtZTpvcmlnaW46dG9wT3JpZ2luOmRlY2lzaW9uSGFu ZGxlcjopXSkKKyAgICAgICAgcmV0dXJuIHBhZ2UucmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRB Y3Rpb24ob3JpZ2luLmRhdGEoKSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOwor CisgICAgYXV0byBhcGlPcmlnaW4gPSBBUEk6OlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUob3JpZ2lu KTsKKyAgICBhdXRvIGFwaVRvcE9yaWdpbiA9IEFQSTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZSh0 b3BPcmlnaW4pOworICAgIGF1dG8gY2hlY2tlciA9IENvbXBsZXRpb25IYW5kbGVyQ2FsbENoZWNr ZXI6OmNyZWF0ZShkZWxlZ2F0ZSwgQHNlbGVjdG9yKF93ZWJWaWV3OnJlcXVlc3RQZXJtaXNzaW9u Rm9yTmFtZTpvcmlnaW46dG9wT3JpZ2luOmRlY2lzaW9uSGFuZGxlcjopKTsKKyAgICBbZGVsZWdh dGUgX3dlYlZpZXc6bV91aURlbGVnYXRlLT5tX3dlYlZpZXcuZ2V0KCkuZ2V0KCkgcmVxdWVzdFBl cm1pc3Npb25Gb3JOYW1lOnRvV0tQZXJtaXNzaW9uTmFtZShuYW1lKSBvcmlnaW46d3JhcHBlcihh cGlPcmlnaW4pIHRvcE9yaWdpbjp3cmFwcGVyKGFwaVRvcE9yaWdpbikgZGVjaXNpb25IYW5kbGVy Om1ha2VCbG9ja1B0cihbY29tcGxldGlvbkhhbmRsZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5k bGVyKSwgY2hlY2tlciA9IFdURk1vdmUoY2hlY2tlciksIHBhZ2UgPSBtYWtlV2Vha1B0cihwYWdl KSwgbmFtZSwgb3JpZ2luRGF0YSA9IG9yaWdpbi5kYXRhKCldIChXS1Blcm1pc3Npb25EZWNpc2lv biBkZWNpc2lvbikgbXV0YWJsZSB7CisgICAgICAgIGlmIChjaGVja2VyLT5jb21wbGV0aW9uSGFu ZGxlckhhc0JlZW5DYWxsZWQoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgY2hlY2tl ci0+ZGlkQ2FsbENvbXBsZXRpb25IYW5kbGVyKCk7CisKKyAgICAgICAgc3dpdGNoIChkZWNpc2lv bikgeworICAgICAgICBjYXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uUHJvbXB0OgorICAgICAgICAg ICAgaWYgKCFwYWdlKQorICAgICAgICAgICAgICAgIHJldHVybiBjb21wbGV0aW9uSGFuZGxlcihm YWxzZSk7CisgICAgICAgICAgICByZXR1cm4gcGFnZS0+cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24ob3JpZ2luRGF0YSwgbmFtZSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlcikpOwor ICAgICAgICBjYXNlIFdLUGVybWlzc2lvbkRlY2lzaW9uR3JhbnQ6CisgICAgICAgICAgICByZXR1 cm4gY29tcGxldGlvbkhhbmRsZXIodHJ1ZSk7CisgICAgICAgIGNhc2UgV0tQZXJtaXNzaW9uRGVj aXNpb25EZW55OgorICAgICAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25IYW5kbGVyKGZhbHNlKTsK KyAgICAgICAgfQorICAgIH0pLmdldCgpXTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Db2NvYS9XZWJQYWdlUHJveHlDb2Nv YS5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1t CmluZGV4IDMzMDFlZDQ4ZjA0NWE5ZGQ1NGYzYTg1M2JhZTkwZjEyZWRhN2NhNTcuLjlhZTRlNjcw MzhjNGM4YWZlM2FhNWNhMTFjODg5MTIxN2UwZjQ4NmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0NvY29hL1dlYlBhZ2VQcm94eUNvY29hLm1tCkBAIC0zNCw2ICszNCw3IEBA CiAjaW1wb3J0ICJEYXRhRGV0ZWN0aW9uUmVzdWx0LmgiCiAjaW1wb3J0ICJJbnNlcnRUZXh0T3B0 aW9ucy5oIgogI2ltcG9ydCAiTG9hZFBhcmFtZXRlcnMuaCIKKyNpbXBvcnQgIk1lZGlhUGVybWlz c2lvblV0aWxpdGllcy5oIgogI2ltcG9ydCAiUGFnZUNsaWVudC5oIgogI2ltcG9ydCAiUXVhcmFu dGluZVNQSS5oIgogI2ltcG9ydCAiUXVpY2tMb29rVGh1bWJuYWlsTG9hZGVyLmgiCkBAIC03NTAs NiArNzUxLDE1IEBAIGJvb2wgV2ViUGFnZVByb3h5Ojppc1F1YXJhbnRpbmVkQW5kTm90VXNlckFw cHJvdmVkKGNvbnN0IFN0cmluZyYgZmlsZVVSTFN0cmluZykKIH0KICNlbmRpZgogCit2b2lkIFdl YlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb25CeURlZmF1bHRBY3Rpb24oY29uc3QgV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiBvcmlnaW4sIFBlcm1pc3Npb25OYW1lIHBlcm1pc3Npb25O YW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lkKGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQor eworICAgIGF1dG8gcmVhc29uID0gY29udmVydFBlcm1pc3Npb25OYW1lVG9SZWFzb24ocGVybWlz c2lvbk5hbWUpOworICAgIGlmICghcmVhc29uKQorICAgICAgICByZXR1cm4gY29tcGxldGlvbkhh bmRsZXIoZmFsc2UpOworCisgICAgYWxlcnRGb3JQZXJtaXNzaW9uKCp0aGlzLCAqcmVhc29uLCBv cmlnaW4sIFdURk1vdmUoY29tcGxldGlvbkhhbmRsZXIpKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0CiAKICN1bmRlZiBNRVNTQUdFX0NIRUNLX0NPTVBMRVRJT04KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL01lZGlhUGVybWlzc2lvblV0aWxpdGllcy5oIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvTWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKaW5kZXggNWEzMTUx Njk1Y2M0ZDhlNDAzNDcwNjRmY2ZhZTQ1ODFmZDdmYTE5NS4uYzZjMGFhNzBhYjgzYzhmN2E0OGU1 ZTQxZmIxNmFlZmRhOGNmODM4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv TWVkaWFQZXJtaXNzaW9uVXRpbGl0aWVzLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKK2VudW0gY2xhc3MgUGVybWlzc2lv bk5hbWUgOiB1aW50OF90OwogY2xhc3MgU2VjdXJpdHlPcmlnaW47CiB9CiAKQEAgLTU3LDYgKzU4 LDggQEAgZW51bSBjbGFzcyBNZWRpYVBlcm1pc3Npb25SZWFzb24gewogICAgIFNwZWVjaFJlY29n bml0aW9uCiB9OwogCitzdGQ6Om9wdGlvbmFsPE1lZGlhUGVybWlzc2lvblJlYXNvbj4gY29udmVy dFBlcm1pc3Npb25OYW1lVG9SZWFzb24oV2ViQ29yZTo6UGVybWlzc2lvbk5hbWUpOworCiAjaWYg UExBVEZPUk0oQ09DT0EpCiBib29sIGNoZWNrU2FuZGJveFJlcXVpcmVtZW50Rm9yVHlwZShNZWRp YVBlcm1pc3Npb25UeXBlKTsKIGJvb2wgY2hlY2tVc2FnZURlc2NyaXB0aW9uU3RyaW5nRm9yVHlw ZShNZWRpYVBlcm1pc3Npb25UeXBlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuY3BwCmluZGV4IDJmZTkzYTU5MTU2ZThiMGU2OTg3YzA4ODU1ZDNkMGFkMzI5YzgwNjUuLmUy MmQ2ZTYwOGZkYjlkMzdmNzAyYzUyNDQwMDgxYTlhMzEwMzJhNTYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtMTcxLDYgKzE3MSw3IEBACiAjaW5jbHVkZSA8 V2ViQ29yZS9NSU1FVHlwZVJlZ2lzdHJ5Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9NZWRpYVN0cmVh bVJlcXVlc3QuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BlcmZvcm1hbmNlTG9nZ2luZ0NsaWVudC5o PgorI2luY2x1ZGUgPFdlYkNvcmUvUGVybWlzc2lvbkRlc2NyaXB0b3IuaD4KICNpbmNsdWRlIDxX ZWJDb3JlL1Blcm1pc3Npb25TdGF0ZS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGxhdGZvcm1FdmVu dC5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQuaD4KQEAgLTg1 MDIsMTAgKzg1MDMsMTQgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnJldm9rZUdlb2xvY2F0aW9uQXV0 aG9yaXphdGlvblRva2VuKGNvbnN0IFN0cmluZyYgYXV0aG9yaXphdGkKICAgICBtX2dlb2xvY2F0 aW9uUGVybWlzc2lvblJlcXVlc3RNYW5hZ2VyLnJldm9rZUF1dGhvcml6YXRpb25Ub2tlbihhdXRo b3JpemF0aW9uVG9rZW4pOwogfQogCi12b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Np b24oY29uc3QgQ2xpZW50T3JpZ2luJiwgY29uc3QgUGVybWlzc2lvbkRlc2NyaXB0b3ImLCBDb21w bGV0aW9uSGFuZGxlcjx2b2lkKFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIp Cit2b2lkIFdlYlBhZ2VQcm94eTo6cmVxdWVzdFBlcm1pc3Npb24oY29uc3QgQ2xpZW50T3JpZ2lu JiBvcmlnaW4sIGNvbnN0IFBlcm1pc3Npb25EZXNjcmlwdG9yJiBkZXNjcmlwdG9yLCBDb21wbGV0 aW9uSGFuZGxlcjx2b2lkKFBlcm1pc3Npb25TdGF0ZSk+JiYgY29tcGxldGlvbkhhbmRsZXIpCiB7 Ci0gICAgLy8gRklYTUU6IFNob3cgYSBwcm9tcHQgZm9yIHVzZXIgaW5wdXQuCi0gICAgY29tcGxl dGlvbkhhbmRsZXIoUGVybWlzc2lvblN0YXRlOjpHcmFudGVkKTsKKyAgICBhdXRvIHNlY3VyaXR5 T3JpZ2luID0gb3JpZ2luLmNsaWVudE9yaWdpbi5zZWN1cml0eU9yaWdpbigpOworICAgIGF1dG8g dG9wU2VjdXJpdHlPcmlnaW4gPSBvcmlnaW4udG9wT3JpZ2luLnNlY3VyaXR5T3JpZ2luKCk7Cisg ICAgbV91aUNsaWVudC0+cmVxdWVzdFBlcm1pc3Npb24oKnRoaXMsIHNlY3VyaXR5T3JpZ2luLmdl dCgpLCB0b3BTZWN1cml0eU9yaWdpbi5nZXQoKSwgZGVzY3JpcHRvci5uYW1lLCBbY29tcGxldGlv bkhhbmRsZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKV0oYm9vbCBncmFudGVkKSBtdXRh YmxlIHsKKyAgICAgICAgYXV0byBwZXJtaXNzaW9uc1N0YXRlID0gZ3JhbnRlZCA/IFBlcm1pc3Np b25TdGF0ZTo6R3JhbnRlZCA6IFBlcm1pc3Npb25TdGF0ZTo6RGVuaWVkOworICAgICAgICBjb21w bGV0aW9uSGFuZGxlcihwZXJtaXNzaW9uc1N0YXRlKTsKKyAgICB9KTsKIH0KIAogI2lmIEVOQUJM RShNRURJQV9TVFJFQU0pCkBAIC0xMDg3Niw2ICsxMDg4MSwxNSBAQCB2b2lkIFdlYlBhZ2VQcm94 eTo6Y2xlYXJBcHBQcml2YWN5UmVwb3J0VGVzdGluZ0RhdGEoQ29tcGxldGlvbkhhbmRsZXI8dm9p ZCgpPiYmCiB9CiAjZW5kaWYKIAorI2lmICFQTEFURk9STShDT0NPQSkKKwordm9pZCBXZWJQYWdl UHJveHk6OnJlcXVlc3RQZXJtaXNzaW9uQnlEZWZhdWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNl Y3VyaXR5T3JpZ2luRGF0YSYsIFBlcm1pc3Npb25OYW1lLCBDb21wbGV0aW9uSGFuZGxlcjx2b2lk KGJvb2wpPiYmIGNvbXBsZXRpb25IYW5kbGVyKQoreworICAgIGNvbXBsZXRpb25IYW5kbGVyKGZh bHNlKTsKK30KKworI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjdW5kZWYgV0VC UEFHRVBST1hZX1JFTEVBU0VfTE9HCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9XZWJQYWdlUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5o CmluZGV4IDU0ZmFkMjIzZDFhMzg4ZTljMGQ0YTY3YTQ1NGFhM2ZmNWMwZGM4MGQuLmJkOTZhNGZj OTE0NWEyNGFmNWU3YzBlZjdhYTM5MGZlNWRjZmE5OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5oCkBAIC0yNjgsNiArMjY4LDcgQEAgZW51bSBjbGFzcyBIaWdobGlnaHRS ZXF1ZXN0T3JpZ2luYXRlZEluQXBwIDogYm9vbDsKIGVudW0gY2xhc3MgSGlnaGxpZ2h0VmlzaWJp bGl0eSA6IGJvb2w7CiBlbnVtIGNsYXNzIE1vdXNlRXZlbnRQb2xpY3kgOiB1aW50OF90OwogZW51 bSBjbGFzcyBOb3RpZmljYXRpb25EaXJlY3Rpb24gOiB1aW50OF90OworZW51bSBjbGFzcyBQZXJt aXNzaW9uTmFtZSA6IHVpbnQ4X3Q7CiBlbnVtIGNsYXNzIFJvdXRlU2hhcmluZ1BvbGljeSA6IHVp bnQ4X3Q7CiBlbnVtIGNsYXNzIFNlbGVjdGlvbkRpcmVjdGlvbiA6IHVpbnQ4X3Q7CiBlbnVtIGNs YXNzIFNob3VsZFNhbXBsZSA6IGJvb2w7CkBAIC0xOTA0LDYgKzE5MDUsNyBAQCBwdWJsaWM6CiAg ICAgdm9pZCByZXF1ZXN0VXNlck1lZGlhUGVybWlzc2lvbkZvclNwZWVjaFJlY29nbml0aW9uKFdl YkNvcmU6OkZyYW1lSWRlbnRpZmllciwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4mLCBj b25zdCBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9v bCk+JiYpOwogCiAgICAgdm9pZCByZXF1ZXN0TWVkaWFLZXlTeXN0ZW1QZXJtaXNzaW9uQnlEZWZh dWx0QWN0aW9uKGNvbnN0IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luRGF0YSYsIENvbXBsZXRpb25I YW5kbGVyPHZvaWQoYm9vbCk+JiYpOworICAgIHZvaWQgcmVxdWVzdFBlcm1pc3Npb25CeURlZmF1 bHRBY3Rpb24oY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW5EYXRhJiwgV2ViQ29yZTo6UGVy bWlzc2lvbk5hbWUsIENvbXBsZXRpb25IYW5kbGVyPHZvaWQoYm9vbCk+JiYpOwogCiAgICAgdm9p ZCBzeW5jSWZNb2NrRGV2aWNlc0VuYWJsZWRDaGFuZ2VkKCk7CiAKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mv Q2hhbmdlTG9nCmluZGV4IDE2NGI2MTQ1NTBiMzZhYzE4ZDlmZTJmYTIwYjI4ZjJjODE3MzZjN2Mu LjRmYTljYjQyMjFjYjVjMTNlNWZlYWNmMDU3MDYyN2M2M2U2NDc5ZDUgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvaW1wb3J0 ZWQvdzNjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDIxLTA5LTA1ICBTaWh1aSBMaXUg IDxzaWh1aV9saXVAYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBwcm9tcHQgZm9yIFBlcm1pc3Np b25zIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjI5NTkwCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjY4Njk0OD4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHdlYi1wbGF0Zm9ybS10ZXN0cy9w ZXJtaXNzaW9ucy9uZmMtcGVybWlzc2lvbi1leHBlY3RlZC50eHQ6CisKIDIwMjEtMDktMDMgIEpv aG5zb24gWmhvdSAgPHFpYW9zb25nX3pob3VAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZGl0aW9u IG9mIENTU051bWVyaWNGYWN0b3J5IGluIENTUyBUeXBlZCBPTQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9wZXJtaXNzaW9ucy9uZmMtcGVy bWlzc2lvbi1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mvd2ViLXBsYXRm b3JtLXRlc3RzL3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVjdGVkLnR4dAppbmRleCBj MmZkNjVlOGQ0MDAyYTcyMzAxODdhNjFmNTFjMjgyZWZjMWM2YmVjLi43NmNmODczY2VjMjQ4YWNk M2M2YTIwZjYwZTExNzA4YmNjYmRiMDhiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9pbXBvcnRl ZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3RzL3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVj dGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3Rz L3Blcm1pc3Npb25zL25mYy1wZXJtaXNzaW9uLWV4cGVjdGVkLnR4dApAQCAtMSwzICsxLDMgQEAK IAotUEFTUyBUZXN0IFdlYiBORkMgUGVybWlzc2lvbi4KK0ZBSUwgVGVzdCBXZWIgTkZDIFBlcm1p c3Npb24uIHByb21pc2VfdGVzdDogVW5oYW5kbGVkIHJlamVjdGlvbiB3aXRoIHZhbHVlOiBvYmpl Y3QgIlR5cGVFcnJvcjogVHlwZSBlcnJvciIKIAo=