212485 2020-05-28 13:26:45 -0700 [macOS]: The File Picker of the <input> file element should show the selection filter 2020-06-11 15:56:12 -0700 1 1 1 Unclassified WebKit Images WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 212489 1 sabouhallawa sabouhallawa darin simon.fraser thorton webkit-bug-importer oldest_to_newest 1656983 0 sabouhallawa 2020-05-28 13:26:45 -0700 When clicking an <input> file element, we should show the selection filter. The selection filter should reflect what is in the "accept" attribute of the <input> element. According to the specs: https://www.w3.org/TR/html51/sec-forms.html#file-upload-state-typefile, the "accept" attribute can only give the UA a hint of what file types will be accepted. So the selection filter should also allow changing the filter to "All files". Accepting files, which are not in the "accept" attribute, is what the drag/drop does. So the selecting files through the File Picker should be compatible with the dragging and dropping them. 1657003 1 webkit-bug-importer 2020-05-28 13:56:02 -0700 <rdar://problem/63731665> 1658968 2 400991 sabouhallawa 2020-06-03 21:17:31 -0700 Created attachment 400991 Patch 1658972 3 400993 sabouhallawa 2020-06-03 21:27:45 -0700 Created attachment 400993 Patch 1658986 4 400993 thorton 2020-06-03 22:08:33 -0700 Comment on attachment 400993 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=400993&action=review > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 > + NSBundle *bundle = [NSBundle bundleForClass:[NSURLFileTypeMappings class]]; > + NSData *data = [NSData dataWithContentsOfFile:[bundle pathForResource:@"types" ofType:@"plist"]]; Is there not a way to do with with CoreServices API instead of loading some random plist out of some other project's bundle? This seems pretty crazy. 1659178 5 400993 simon.fraser 2020-06-04 10:59:38 -0700 Comment on attachment 400993 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=400993&action=review > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:36 > + static NSDictionary<NSString *, NSSet<NSString *> *> *mimeWildcardsToExtensionList; This would be better as NeverDestroyed<RetainPtr<>> >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 >> + NSData *data = [NSData dataWithContentsOfFile:[bundle pathForResource:@"types" ofType:@"plist"]]; > > Is there not a way to do with with CoreServices API instead of loading some random plist out of some other project's bundle? This seems pretty crazy. Agreed. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:46 > + NSDictionary<NSString *, NSArray<NSString *> *> *mimeTypeToExtensionList = [NSPropertyListSerialization propertyListWithData:data options:NSPropertyListImmutable format:nil error:nil]; Better to explicitly capture this in a RetainPtr<> > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:47 > + NSMutableDictionary<NSString *, NSMutableSet<NSString *> *> *map = [NSMutableDictionary new]; This is leaked. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:121 > + NSArray<NSString *> *acceptedMIMETypes = [self _acceptedMIMETypes]; > + NSArray<NSString *> *acceptedFileExtensions = [self _acceptedFileExtensions]; > + > + NSMutableSet<NSString *> *allowedFileExtensions = [NSMutableSet set]; > + > + NSURLFileTypeMappings *fileTypeMappings = [NSURLFileTypeMappings sharedMappings]; > + [acceptedMIMETypes enumerateObjectsUsingBlock:^(NSString *mimeType, NSUInteger index, BOOL* stop) { > + if ([mimeType hasSuffix:@"*"]) > + [allowedFileExtensions unionSet:extensionsForMIMEWildcardType(mimeType)]; > + else > + [allowedFileExtensions addObjectsFromArray:[fileTypeMappings extensionsForMIMEType:mimeType]]; > + }]; > + > + NSMutableArray<NSString *> *whitelistedFileExtensions = [NSMutableArray array]; > + [acceptedFileExtensions enumerateObjectsUsingBlock:^(NSString *extension, NSUInteger index, BOOL *stop) { > + ASSERT([extension characterAtIndex:0] == '.'); > + [whitelistedFileExtensions addObject:[extension substringFromIndex:1]]; > + }]; > + > + [allowedFileExtensions addObjectsFromArray:whitelistedFileExtensions]; > + return [allowedFileExtensions allObjects]; I would like to see more RetainPtr<> here. 1659435 6 401104 sabouhallawa 2020-06-04 17:53:19 -0700 Created attachment 401104 Patch 1659437 7 401104 thorton 2020-06-04 18:02:11 -0700 Comment on attachment 401104 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401104&action=review > Source/WebCore/PAL/pal/spi/cocoa/NSURLFileTypeMappingsSPI.h:38 > + NSURLFileTypeMappingsInternal *_internal; This is IPI, you really ought not do this. Also, I don't see it used? > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 > + NSData *data = [NSData dataWithContentsOfFile:[bundle pathForResource:@"types" ofType:@"plist"]]; This is still here :( 1659461 8 401104 thorton 2020-06-04 20:26:12 -0700 Comment on attachment 401104 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401104&action=review > Source/WebCore/PAL/ChangeLog:9 > + To get the bundle of NSURLFileTypeMappings, we need to expose the interface > + of NSURLFileTypeMappings. This does not seem right. [NSBundle bundleForClass:NSClassFromString(@"NSURLFileTypeMappings")] would surely work without it. That said, let's keep talking about ways to avoid this crazy. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:47 > + RetainPtr<NSMutableDictionary<NSString *, NSMutableSet<NSString *> *>> map = [NSMutableDictionary new]; The original (mutable) copy of the map leaks too :) > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:88 > + _allowedFileExtensions = [[NSMutableArray arrayWithArray:allowedFileExtensions] retain]; This still leaks > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:620 > + NSTextField* label = [[NSTextField alloc] initWithFrame:CGRectZero]; This still leaks > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:628 > + NSPopUpButton *button = [[NSPopUpButton alloc] initWithFrame:CGRectZero pullsDown:NO]; This still leaks > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:631 > + [button addItemWithTitle:@"All Files "]; The spaces :| > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:637 > + NSStackView* horizontalView = [[NSStackView alloc] initWithFrame:CGRectZero]; This still leaks > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:643 > + NSStackView* filterView = [[NSStackView alloc] initWithFrame:CGRectZero]; This still leaks > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:660 > + FileExtensionsPopupTarget *popupTarget = [[FileExtensionsPopupTarget alloc] initWithOpenPanel: openPanel allowedFileExtensions: parameters._allowedFileExtensions]; This still leaks 1659537 9 401136 sabouhallawa 2020-06-05 03:23:34 -0700 Created attachment 401136 Patch 1659792 10 401198 sabouhallawa 2020-06-05 14:27:15 -0700 Created attachment 401198 Patch 1659801 11 401198 thorton 2020-06-05 14:34:32 -0700 Comment on attachment 401198 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401198&action=review > Source/WebCore/PAL/pal/spi/cocoa/UTIPrivSPI.h:30 > +#import <CoreServices/CoreServicesPriv.h> We already have CoreServicesSPI.h, lets just use that > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:52 > + NSString *mimeTypeWildcard = [[mimeType componentsSeparatedByString:@"/"][0] stringByAppendingString:@"/*"]; > + if (!map[mimeTypeWildcard]) > + map[mimeTypeWildcard] = [NSMutableSet set]; > + [map[mimeTypeWildcard] addObject:extension]; You can inline this right into the only callsite. The only reason I had it in a block in the test app was to share code between the different experiments :D > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:57 > + NSString *mimeType = CFBridgingRelease(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); Let's not use CFBridgingRelease in non-ARC code. adoptCF and RetainPtr, instead. 1659804 12 401104 sabouhallawa 2020-06-05 14:42:54 -0700 Comment on attachment 401104 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401104&action=review >> Source/WebCore/PAL/ChangeLog:9 >> + of NSURLFileTypeMappings. > > This does not seem right. [NSBundle bundleForClass:NSClassFromString(@"NSURLFileTypeMappings")] would surely work without it. > > That said, let's keep talking about ways to avoid this crazy. This was fixed with the help of Tim Horton. The SPI _UTCopyDeclaredTypeIdentifiers() can be used to enumerate all the type identifiers, aka UITs. The mime type of the UTI can be gotten form UTTypeCopyPreferredTagWithClass(..., kUTTagClassMIMEType). The extensions of the UTI can be gotten form UTTypeCopyAllTagsWithClass(..., kUTTagClassFilenameExtension). From the mime type and the extensions a hash map can be built tor mapping the wildcard mime type to file extensions. >> Source/WebCore/PAL/pal/spi/cocoa/NSURLFileTypeMappingsSPI.h:38 >> + NSURLFileTypeMappingsInternal *_internal; > > This is IPI, you really ought not do this. Also, I don't see it used? The changes in this header file were reverted. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 >> + NSData *data = [NSData dataWithContentsOfFile:[bundle pathForResource:@"types" ofType:@"plist"]]; > > This is still here :( Fixed. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:47 >> + RetainPtr<NSMutableDictionary<NSString *, NSMutableSet<NSString *> *>> map = [NSMutableDictionary new]; > > The original (mutable) copy of the map leaks too :) Fixed. The original map is now created by calling [NSMutableDictionary dictionary]. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:88 >> + _allowedFileExtensions = [[NSMutableArray arrayWithArray:allowedFileExtensions] retain]; > > This still leaks This NSArray is now released in the dealloc() of this interface. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:620 >> + NSTextField* label = [[NSTextField alloc] initWithFrame:CGRectZero]; > > This still leaks This object is now 'autorelease'. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:628 >> + NSPopUpButton *button = [[NSPopUpButton alloc] initWithFrame:CGRectZero pullsDown:NO]; > > This still leaks Ditto. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:631 >> + [button addItemWithTitle:@"All Files "]; > > The spaces :| I wanted to increase the width of the NSPopupButton but I could not figure it out how I can do it with auto-layout. So adding spaces was just a workaround till I find the right way to do. Also I could not constrain the width of the NSTextField above to fit its contents. Currently NSTextField and NSPopupButton have the same width which is not what we want. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:637 >> + NSStackView* horizontalView = [[NSStackView alloc] initWithFrame:CGRectZero]; > > This still leaks Ditto. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:660 >> + FileExtensionsPopupTarget *popupTarget = [[FileExtensionsPopupTarget alloc] initWithOpenPanel: openPanel allowedFileExtensions: parameters._allowedFileExtensions]; > > This still leaks This variable is made a member of WK2BrowserWindowController so it can live after runOpenPanelWithParameters() exists while the OpenPanel is still shown. 1659818 13 401206 sabouhallawa 2020-06-05 15:14:43 -0700 Created attachment 401206 Patch 1659839 14 401198 sabouhallawa 2020-06-05 15:55:01 -0700 Comment on attachment 401198 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401198&action=review >> Source/WebCore/PAL/pal/spi/cocoa/UTIPrivSPI.h:30 >> +#import <CoreServices/CoreServicesPriv.h> > > We already have CoreServicesSPI.h, lets just use that The new file was removed. The new SPI was added to CoreServicesSPI.h. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:52 >> + [map[mimeTypeWildcard] addObject:extension]; > > You can inline this right into the only callsite. The only reason I had it in a block in the test app was to share code between the different experiments :D Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:57 >> + NSString *mimeType = CFBridgingRelease(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); > > Let's not use CFBridgingRelease in non-ARC code. adoptCF and RetainPtr, instead. Done. But I left the one in extensionsForMIMEType(). I am not sure what the right thing here though. 1659849 15 thorton 2020-06-05 16:15:56 -0700 (In reply to Said Abou-Hallawa from comment #14) > Comment on attachment 401198 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=401198&action=review > >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:57 > >> + NSString *mimeType = CFBridgingRelease(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); > > > > Let's not use CFBridgingRelease in non-ARC code. adoptCF and RetainPtr, instead. > > Done. But I left the one in extensionsForMIMEType(). I am not sure what the > right thing here though. I meant for that review comment to apply to all instances. 1659924 16 401241 sabouhallawa 2020-06-06 00:40:20 -0700 Created attachment 401241 Patch 1659925 17 401198 sabouhallawa 2020-06-06 00:43:36 -0700 Comment on attachment 401198 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401198&action=review >>>> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:57 >>>> + NSString *mimeType = CFBridgingRelease(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); >>> >>> Let's not use CFBridgingRelease in non-ARC code. adoptCF and RetainPtr, instead. >> >> Done. But I left the one in extensionsForMIMEType(). I am not sure what the right thing here though. > > I meant for that review comment to apply to all instances. I made a single function which returns the extensions for any mime type including the wildcard mime types. So the extensionsForMIMEType() above was deleted and extensionsForWildcardMIMEType() was renamed to extensionsForMIMEType(). 1660537 18 401407 sabouhallawa 2020-06-08 18:52:19 -0700 Created attachment 401407 Patch 1660540 19 401407 sabouhallawa 2020-06-08 19:05:06 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:693 > + titles = @[@"All Files"]; I removed the extra spaces, which I used as a hack to increase the width of the NSPopupButton, and I fixed the layout of the controls. 1661260 20 401407 darin 2020-06-10 11:54:37 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review Looks OK. Where are the tests for this new code? > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:37 > + static NeverDestroyed<RetainPtr<NSDictionary<NSString *, NSSet<NSString *> *>>> s_mimeTypeToExtensions; > + static dispatch_once_t onceToken; Do we need a thread-safe one-time mechanism here? If so, why choose dispatch_once of std::call_once? If not, can we just write this with normal C++ initialization idioms? static NSDictionary<NSString *, NSSet<NSString *> *map = createMIMETypeToExtensionsMap().leakRef(); Or use a block if you prefer. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 > + NSMutableDictionary<NSString *, NSMutableSet<NSString *> *> *mimeTypeToExtensions = [NSMutableDictionary dictionary]; I suggest avoiding autorelease here: auto mimeTypeToExtensions = adoptNS([[NSMutableDictionary alloc] init]); > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:41 > + RetainPtr<NSArray> allUTIs = adoptCF(_UTCopyDeclaredTypeIdentifiers()); I suggest using auto for code like this. Also I am surprised we can just assign from a RetainPtr<CFArrayRef> into a RetainPtr<NSArray> without a cast. Does this really compile? > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:43 > + void (^addExtensionForMIMEType)(NSString *mimeType, NSString *extension) = ^(NSString *mimeType, NSString *extension) { And here. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:45 > + mimeTypeToExtensions[mimeType] = [NSMutableSet set]; It’s a little bit unfortunate to autorelease the set here. Could write this so autorelease is not involved: mimeTypeToExtensions[mimeType] = adoptNS([[NSMutableSet alloc] init]).get(); > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:49 > + void (^addExtensionsForMIMEType)(NSString *mimeType, NSArray<NSString *> *extensions) = ^(NSString *mimeType, NSArray<NSString *> *extensions) { And here. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:61 > + RetainPtr<NSString> mimeType = adoptCF(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); And here. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:64 > + RetainPtr<NSArray> extensions = adoptCF(UTTypeCopyAllTagsWithClass((__bridge CFStringRef)(uti), kUTTagClassFilenameExtension)); And here. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:75 > + RetainPtr<NSDictionary<NSString *, NSArray<NSString *> *>> whitelistedMimeTypes = adoptNS([[NSDictionary alloc] initWithObjectsAndKeys: > + [NSArray arrayWithObjects: @"webp" , nil], @"image/webp", > + nil > + ]); > + > + [whitelistedMimeTypes.get() enumerateKeysAndObjectsUsingBlock:^(NSString *mimeType, NSArray<NSString *> *extensions, BOOL *) { > + addExtensionsForMIMEType(mimeType, extensions); > + }]; And here. Also I suggest not using the term "whitelist". Also using literals makes this way nicer: auto allowedMIMETypes = @{ @"image/webp": @[ @"webp" ] }; When it’s written this way, it becomes pretty clear that "allowedMIMETypes" is a strange name for this dictionary, and also that it’s strange to use a dictionary. Why do we need to make a dictionary and enumerate it? Why not just write this one line of code: addExtensionForMIMEType(@"image/webp", @"webp"); > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:120 > + NSArray<NSString *> *acceptedMIMETypes = [self _acceptedMIMETypes]; > + NSArray<NSString *> *acceptedFileExtensions = [self _acceptedFileExtensions]; I suggest auto here. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:122 > + NSMutableSet<NSString *> *allowedFileExtensions = [NSMutableSet set]; I suggest auto and adoptNS here to avoid autorelease. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:129 > + NSMutableArray<NSString *> *additionalAllowedFileExtensions = [NSMutableArray array]; I suggest auto and adoptNS here to avoid autorelease. > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:142 > + NSArray<NSString *> *acceptedMIMETypes = [self _acceptedMIMETypes]; > + NSArray<NSString *> *acceptedFileExtensions = [self _acceptedFileExtensions]; auto > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:148 > + return @"Custom Files"; Maybe a named constant for this string. Is it OK that this is not localized? > Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:160 > + return [NSString stringWithFormat:@"%@%@ Files", [[mimeTypePrefix substringToIndex:1] uppercaseString], [mimeTypePrefix substringFromIndex:1]]; Is it OK that this is not localized? > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:78 > + NSOpenPanel *_openPanel; What guarantees this object will not be retained and outlive the open panel? > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:79 > + NSArray<NSString *> *_allowedFileExtensions; Why not use RetainPtr for this? > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:124 > + FileExtensionsPopupTarget *_fileExtensionsPopupTarget; Why not use RetainPtr for this? > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:630 > + NSTextField* label = [[[NSTextField alloc] initWithFrame:NSZeroRect] autorelease]; I suggest using adoptNS instead of autorelease. > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:638 > + NSPopUpButton *button = [[[NSPopUpButton alloc] initWithFrame:NSZeroRect pullsDown:NO] autorelease]; Ditto. > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:646 > + NSView* filterView = [[[NSView alloc] initWithFrame:NSZeroRect] autorelease]; Ditto. > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:652 > + const CGFloat margin = 20; > + const CGFloat spacing = 2; > + const CGFloat minButtonWidth = 230; constexpr is better than const for this use. Also would be helpful to have a comment saying where these values come from. > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:659 > + buttonFrame.size = NSMakeSize(MAX(NSWidth(buttonFrame), minButtonWidth), NSHeight(buttonFrame)); Could use std::max instead of MAX. > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:670 > + buttonFrame.origin = NSMakePoint(NSMaxX(labelFrame) + 2, (NSHeight(filterViewFrame) - NSHeight(buttonFrame)) / 2); Where does the magic number in the "+ 2" come from? Why is it correct? >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:693 >> + titles = @[@"All Files"]; > > I removed the extra spaces, which I used as a hack to increase the width of the NSPopupButton, and I fixed the layout of the controls. Is it OK that the string "All Files" is not localized? If so, why? > Tools/MiniBrowser/mac/WK2BrowserWindowController.m:695 > + NSView *filterView = [self createFilterView:titles popupTarget:_fileExtensionsPopupTarget]; This method name has "create" in it. Does that mean we need to adopt or release its return value? Or does it just happen to have a name that violates the Cocoa copy/create ownership rule? 1661297 21 401407 simon.fraser 2020-06-10 12:44:36 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:75 >> + }]; > > And here. Also I suggest not using the term "whitelist". Also using literals makes this way nicer: > > auto allowedMIMETypes = @{ @"image/webp": @[ @"webp" ] }; > > When it’s written this way, it becomes pretty clear that "allowedMIMETypes" is a strange name for this dictionary, and also that it’s strange to use a dictionary. Why do we need to make a dictionary and enumerate it? Why not just write this one line of code: > > addExtensionForMIMEType(@"image/webp", @"webp"); Please do not land this patch with "whitelist". We are actively trying to eliminate blacklist/whitelist terminology. 1661502 22 401407 sabouhallawa 2020-06-10 22:06:26 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:37 >> + static dispatch_once_t onceToken; > > Do we need a thread-safe one-time mechanism here? If so, why choose dispatch_once of std::call_once? If not, can we just write this with normal C++ initialization idioms? > > static NSDictionary<NSString *, NSSet<NSString *> *map = createMIMETypeToExtensionsMap().leakRef(); > > Or use a block if you prefer. Fixed. I used static auto extensionsForMIMETypeMap = makeNeverDestroyed([] { ... }; return extensionsForMIMETypeMap.get().get(); >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:40 >> + NSMutableDictionary<NSString *, NSMutableSet<NSString *> *> *mimeTypeToExtensions = [NSMutableDictionary dictionary]; > > I suggest avoiding autorelease here: > > auto mimeTypeToExtensions = adoptNS([[NSMutableDictionary alloc] init]); Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:41 >> + RetainPtr<NSArray> allUTIs = adoptCF(_UTCopyDeclaredTypeIdentifiers()); > > I suggest using auto for code like this. Also I am surprised we can just assign from a RetainPtr<CFArrayRef> into a RetainPtr<NSArray> without a cast. Does this really compile? Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:43 >> + void (^addExtensionForMIMEType)(NSString *mimeType, NSString *extension) = ^(NSString *mimeType, NSString *extension) { > > And here. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:45 >> + mimeTypeToExtensions[mimeType] = [NSMutableSet set]; > > It’s a little bit unfortunate to autorelease the set here. Could write this so autorelease is not involved: > > mimeTypeToExtensions[mimeType] = adoptNS([[NSMutableSet alloc] init]).get(); I am not sure how this should work. adopt(...).get() will return the raw pointer. But once the RetainedPtr is released this raw pointer will be released. Should we use leakRef() instead? And how will mimeTypeToExtensions[mimeType] be released eventually? Or because it is stored in a NeverDestroyed, it is okay? >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:49 >> + void (^addExtensionsForMIMEType)(NSString *mimeType, NSArray<NSString *> *extensions) = ^(NSString *mimeType, NSArray<NSString *> *extensions) { > > And here. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:61 >> + RetainPtr<NSString> mimeType = adoptCF(UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)(uti), kUTTagClassMIMEType)); > > And here. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:64 >> + RetainPtr<NSArray> extensions = adoptCF(UTTypeCopyAllTagsWithClass((__bridge CFStringRef)(uti), kUTTagClassFilenameExtension)); > > And here. Done. >>> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:75 >>> + }]; >> >> And here. Also I suggest not using the term "whitelist". Also using literals makes this way nicer: >> >> auto allowedMIMETypes = @{ @"image/webp": @[ @"webp" ] }; >> >> When it’s written this way, it becomes pretty clear that "allowedMIMETypes" is a strange name for this dictionary, and also that it’s strange to use a dictionary. Why do we need to make a dictionary and enumerate it? Why not just write this one line of code: >> >> addExtensionForMIMEType(@"image/webp", @"webp"); > > Please do not land this patch with "whitelist". We are actively trying to eliminate blacklist/whitelist terminology. Fixed. I used addExtensionForMIMEType(@"image/webp", @"webp"); >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:120 >> + NSArray<NSString *> *acceptedFileExtensions = [self _acceptedFileExtensions]; > > I suggest auto here. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:122 >> + NSMutableSet<NSString *> *allowedFileExtensions = [NSMutableSet set]; > > I suggest auto and adoptNS here to avoid autorelease. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:129 >> + NSMutableArray<NSString *> *additionalAllowedFileExtensions = [NSMutableArray array]; > > I suggest auto and adoptNS here to avoid autorelease. Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:142 >> + NSArray<NSString *> *acceptedFileExtensions = [self _acceptedFileExtensions]; > > auto Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:148 >> + return @"Custom Files"; > > Maybe a named constant for this string. Is it OK that this is not localized? Done. >> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:160 >> + return [NSString stringWithFormat:@"%@%@ Files", [[mimeTypePrefix substringToIndex:1] uppercaseString], [mimeTypePrefix substringFromIndex:1]]; > > Is it OK that this is not localized? No it should be localized. But because there are expected changes in this function, I want to postpone the localization step till I finish these changes. For mini browser, which is the only caller for these functions it's okay because mini browser is not localized. Before these functions are called by Safari, I will make sure all the strings are localized. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:78 >> + NSOpenPanel *_openPanel; > > What guarantees this object will not be retained and outlive the open panel? This object is released in the dealloc WK2BrowserWindowController. It is also released before it is assigned a new value in runOpenPanelWithParameters. This object uses _openPanel only when responding to the selection change in the NSPopupButton. NSPopupButton will keep sending selection change as long as OpenPanel is still alive. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:79 >> + NSArray<NSString *> *_allowedFileExtensions; > > Why not use RetainPtr for this? Because it is .m file. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:124 >> + FileExtensionsPopupTarget *_fileExtensionsPopupTarget; > > Why not use RetainPtr for this? Ditto. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:630 >> + NSTextField* label = [[[NSTextField alloc] initWithFrame:NSZeroRect] autorelease]; > > I suggest using adoptNS instead of autorelease. Ditto. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:652 >> + const CGFloat minButtonWidth = 230; > > constexpr is better than const for this use. > > Also would be helpful to have a comment saying where these values come from. This is .m file. I can change it to .mm file but I would prefer to do this in a separate patch. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:659 >> + buttonFrame.size = NSMakeSize(MAX(NSWidth(buttonFrame), minButtonWidth), NSHeight(buttonFrame)); > > Could use std::max instead of MAX. This is .m file. I could not include the std header file <algorithm>. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:670 >> + buttonFrame.origin = NSMakePoint(NSMaxX(labelFrame) + 2, (NSHeight(filterViewFrame) - NSHeight(buttonFrame)) / 2); > > Where does the magic number in the "+ 2" come from? Why is it correct? I meant to use 'spacing'. Fixed. >>> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:693 >>> + titles = @[@"All Files"]; >> >> I removed the extra spaces, which I used as a hack to increase the width of the NSPopupButton, and I fixed the layout of the controls. > > Is it OK that the string "All Files" is not localized? If so, why? Mini browser is not localized. >> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:695 >> + NSView *filterView = [self createFilterView:titles popupTarget:_fileExtensionsPopupTarget]; > > This method name has "create" in it. Does that mean we need to adopt or release its return value? Or does it just happen to have a name that violates the Cocoa copy/create ownership rule? The ownership of the FilterView is moved to the NSOpenPanel, see https://developer.apple.com/documentation/appkit/nssavepanel/1525544-accessoryview. 1661503 23 401619 sabouhallawa 2020-06-10 22:16:50 -0700 Created attachment 401619 Patch 1661523 24 ews-feeder 2020-06-10 23:31:57 -0700 Committed r262895: <https://trac.webkit.org/changeset/262895> All reviewed patches have been landed. Closing bug and clearing flags on attachment 401619. 1661762 25 401407 darin 2020-06-11 15:47:13 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review >>> Source/WebKit/UIProcess/API/Cocoa/WKOpenPanelParameters.mm:45 >>> + mimeTypeToExtensions[mimeType] = [NSMutableSet set]; >> >> It’s a little bit unfortunate to autorelease the set here. Could write this so autorelease is not involved: >> >> mimeTypeToExtensions[mimeType] = adoptNS([[NSMutableSet alloc] init]).get(); > > I am not sure how this should work. adopt(...).get() will return the raw pointer. But once the RetainedPtr is released this raw pointer will be released. Should we use leakRef() instead? And how will mimeTypeToExtensions[mimeType] be released eventually? Or because it is stored in a NeverDestroyed, it is okay? The dictionary retains the value stored in it (the set). The RetainPtr is destroyed only at the end of the full expression, after the set is retained by the dictionary. It does release the set, which is what we want. 1661770 26 401407 darin 2020-06-11 15:56:12 -0700 Comment on attachment 401407 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401407&action=review >>> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:78 >>> + NSOpenPanel *_openPanel; >> >> What guarantees this object will not be retained and outlive the open panel? > > This object is released in the dealloc WK2BrowserWindowController. It is also released before it is assigned a new value in runOpenPanelWithParameters. > > This object uses _openPanel only when responding to the selection change in the NSPopupButton. NSPopupButton will keep sending selection change as long as OpenPanel is still alive. That first line isn’t an answer. There’s a common misunderstanding that "releasing an object" deallocates the object. As I know you are aware, it’s not guaranteed that an object released will be deallocated at just that moment. Maybe there’s some reason we know nothing else will ever retain this, but that seems a fragile assumption. The second line is the reason this is safe, but it’s the kind of high level reasoning that doesn’t seem strong enough to prevent object lifetime bugs when later when we do refactoring or we have small misunderstandings. I suppose this code is OK, but it seems a little risky. >>> Tools/MiniBrowser/mac/WK2BrowserWindowController.m:695 >>> + NSView *filterView = [self createFilterView:titles popupTarget:_fileExtensionsPopupTarget]; >> >> This method name has "create" in it. Does that mean we need to adopt or release its return value? Or does it just happen to have a name that violates the Cocoa copy/create ownership rule? > > The ownership of the FilterView is moved to the NSOpenPanel, see https://developer.apple.com/documentation/appkit/nssavepanel/1525544-accessoryview. OK, but that doesn’t answer my question. The setAccessoryView: method is going to retain the filterView, and yes, it takes ownership of it. But my question was whether we need to release the filterView or not. I see now that we don’t because createFilterView returns an autoreleased object. So it should not be named "create" or "copy". 400991 2020-06-03 21:17:31 -0700 2020-06-03 21:27:43 -0700 Patch bug-212485-20200603211730.patch text/plain 11802 sabouhallawa SW5kZXg6IFNvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQvQ2hhbmdlTG9nCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIyIEBACisyMDIwLTA2LTAzICBTYWlkIEFib3Ut SGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAgICAgW21hY09TXTogVGhl IEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBzaG91bGQgc2hvdyB0aGUg c2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgQWRkIHR3byBwcml2YXRlIGhlbHBlcnMgdG8gV0tPcGVuUGFuZWxQYXJhbWV0ZXJz LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnMu bW06CisgICAgICAgICgtW1dLT3BlblBhbmVsUGFyYW1ldGVycyBfYWxsb3dlZEZpbGVFeHRlbnNp b25zXSk6CisgICAgICAgIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyByZXByZXNlbnRpbmcg dGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAoLVtXS09wZW5QYW5lbFBhcmFtZXRl cnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0ZpbHRlcl0pOgorICAgICAgICBSZXR1cm5zIGEgc3Ry aW5nIHJlcHJlc2VudGluZyB0aGUgdGl0bGUgb2YgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucyBpbiB0 aGUKKyAgICAgICAgT3BlblBhbmVsJ3MgQWNjZXNzb3J5Vmlldy4KKworICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oOgorCiAyMDIwLTA2 LTAxICBCcmVudCBGdWxnaGFtICA8YmZ1bGdoYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFJlbW92 ZSB1bnVzZWQgV2ViQ29udGVudCBwcm9jZXNzIHNhbmRib3ggc3lzY2FsbApJbmRleDogU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5tbQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQ YXJhbWV0ZXJzLm1tCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0y NSwxMSArMjUsNDMgQEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1wb3J0ICJXS09wZW5QYW5l bFBhcmFtZXRlcnNJbnRlcm5hbC5oIgorI2ltcG9ydCA8Rm91bmRhdGlvbi9OU1VSTEZpbGVUeXBl TWFwcGluZ3MuaD4KIAogI2lmIFBMQVRGT1JNKE1BQykKIAogI2ltcG9ydCAiV0tOU0FycmF5Lmgi CiAKK3N0YXRpYyBOU1NldDxOU1N0cmluZyAqPiAqZXh0ZW5zaW9uc0Zvck1JTUVXaWxkY2FyZFR5 cGUoTlNTdHJpbmcgKnR5cGUpCit7CisgICAgc3RhdGljIE5TRGljdGlvbmFyeTxOU1N0cmluZyAq LCBOU1NldDxOU1N0cmluZyAqPiAqPiAqbWltZVdpbGRjYXJkc1RvRXh0ZW5zaW9uTGlzdDsKKyAg ICBzdGF0aWMgZGlzcGF0Y2hfb25jZV90IG9uY2VUb2tlbjsKKyAgICBkaXNwYXRjaF9vbmNlKCZv bmNlVG9rZW4sIF57CisgICAgICAgIE5TQnVuZGxlICpidW5kbGUgPSBbTlNCdW5kbGUgYnVuZGxl Rm9yQ2xhc3M6W05TVVJMRmlsZVR5cGVNYXBwaW5ncyBjbGFzc11dOworICAgICAgICBOU0RhdGEg KmRhdGEgPSBbTlNEYXRhIGRhdGFXaXRoQ29udGVudHNPZkZpbGU6W2J1bmRsZSBwYXRoRm9yUmVz b3VyY2U6QCJ0eXBlcyIgb2ZUeXBlOkAicGxpc3QiXV07CisgICAgICAgIGlmICghZGF0YSkgewor ICAgICAgICAgICAgbWltZVdpbGRjYXJkc1RvRXh0ZW5zaW9uTGlzdCA9IFtOU0RpY3Rpb25hcnkg bmV3XTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIE5TRGljdGlv bmFyeTxOU1N0cmluZyAqLCBOU0FycmF5PE5TU3RyaW5nICo+ICo+ICptaW1lVHlwZVRvRXh0ZW5z aW9uTGlzdCA9IFtOU1Byb3BlcnR5TGlzdFNlcmlhbGl6YXRpb24gcHJvcGVydHlMaXN0V2l0aERh dGE6ZGF0YSBvcHRpb25zOk5TUHJvcGVydHlMaXN0SW1tdXRhYmxlIGZvcm1hdDpuaWwgZXJyb3I6 bmlsXTsKKyAgICAgICAgTlNNdXRhYmxlRGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU011dGFibGVT ZXQ8TlNTdHJpbmcgKj4gKj4gKm1hcCA9IFtOU011dGFibGVEaWN0aW9uYXJ5IG5ld107CisKKyAg ICAgICAgW21pbWVUeXBlVG9FeHRlbnNpb25MaXN0IGVudW1lcmF0ZUtleXNBbmRPYmplY3RzVXNp bmdCbG9jazpeKE5TU3RyaW5nICpjb250ZW50VHlwZSwgTlNBcnJheTxOU1N0cmluZyAqPiAqZXh0 ZW5zaW9uTGlzdCwgQk9PTCogc3RvcCkgeworICAgICAgICAgICAgTlNTdHJpbmcgKnR5cGUgPSBb TlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVALyoiLCBbW2NvbnRlbnRUeXBlIGNvbXBvbmVu dHNTZXBhcmF0ZWRCeVN0cmluZzpAIi8iXSBmaXJzdE9iamVjdF1dOworICAgICAgICAgICAgTlNN dXRhYmxlU2V0PE5TU3RyaW5nICo+ICpleHRlbnNpb25zID0gbWFwW3R5cGVdOworICAgICAgICAg ICAgaWYgKCFleHRlbnNpb25zKSB7CisgICAgICAgICAgICAgICAgZXh0ZW5zaW9ucyA9IFtOU011 dGFibGVTZXQgc2V0XTsKKyAgICAgICAgICAgICAgICBtYXBbdHlwZV0gPSBleHRlbnNpb25zOwor ICAgICAgICAgICAgfQorICAgICAgICAgICAgW2V4dGVuc2lvbnMgYWRkT2JqZWN0c0Zyb21BcnJh eTpleHRlbnNpb25MaXN0XTsKKyAgICAgICAgfV07CisKKyAgICAgICAgbWltZVdpbGRjYXJkc1Rv RXh0ZW5zaW9uTGlzdCA9IFttYXAgY29weV07CisgICAgfSk7CisKKyAgICByZXR1cm4gW21pbWVX aWxkY2FyZHNUb0V4dGVuc2lvbkxpc3Qgb2JqZWN0Rm9yS2V5OnR5cGVdOworfQorCiBAaW1wbGVt ZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wpYWxsb3dzTXVsdGlwbGVT ZWxlY3Rpb24KQEAgLTYzLDYgKzk1LDYxIEBAIC0gKE5TQXJyYXk8TlNTdHJpbmcgKj4gKilfYWNj ZXB0ZWRGaWxlRXgKICAgICByZXR1cm4gd3JhcHBlcihfb3BlblBhbmVsUGFyYW1ldGVycy0+YWNj ZXB0RmlsZUV4dGVuc2lvbnMoKSk7CiB9CiAKKy0gKE5TQXJyYXk8TlNTdHJpbmcgKj4gKilfYWxs b3dlZEZpbGVFeHRlbnNpb25zCit7CisgICAgLy8gQWdncmVnYXRlIGV4dGVuc2lvbnMgYmFzZWQg b24gc3BlY2lmaWVkIE1JTUUgdHlwZXMuCisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0 ZWRNSU1FVHlwZXMgPSBbc2VsZiBfYWNjZXB0ZWRNSU1FVHlwZXNdOworICAgIE5TQXJyYXk8TlNT dHJpbmcgKj4gKmFjY2VwdGVkRmlsZUV4dGVuc2lvbnMgPSBbc2VsZiBfYWNjZXB0ZWRGaWxlRXh0 ZW5zaW9uc107CisKKyAgICBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKmFsbG93ZWRGaWxlRXh0 ZW5zaW9ucyA9IFtOU011dGFibGVTZXQgc2V0XTsKKworICAgIE5TVVJMRmlsZVR5cGVNYXBwaW5n cyAqZmlsZVR5cGVNYXBwaW5ncyA9IFtOU1VSTEZpbGVUeXBlTWFwcGluZ3Mgc2hhcmVkTWFwcGlu Z3NdOworICAgIFthY2NlcHRlZE1JTUVUeXBlcyBlbnVtZXJhdGVPYmplY3RzVXNpbmdCbG9jazpe KE5TU3RyaW5nICptaW1lVHlwZSwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCogc3RvcCkgeworICAg ICAgICBpZiAoW21pbWVUeXBlIGhhc1N1ZmZpeDpAIioiXSkKKyAgICAgICAgICAgIFthbGxvd2Vk RmlsZUV4dGVuc2lvbnMgdW5pb25TZXQ6ZXh0ZW5zaW9uc0Zvck1JTUVXaWxkY2FyZFR5cGUobWlt ZVR5cGUpXTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgW2FsbG93ZWRGaWxlRXh0ZW5zaW9u cyBhZGRPYmplY3RzRnJvbUFycmF5OltmaWxlVHlwZU1hcHBpbmdzIGV4dGVuc2lvbnNGb3JNSU1F VHlwZTptaW1lVHlwZV1dOworICAgIH1dOworCisgICAgTlNNdXRhYmxlQXJyYXk8TlNTdHJpbmcg Kj4gKndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXldOwor ICAgIFthY2NlcHRlZEZpbGVFeHRlbnNpb25zIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4o TlNTdHJpbmcgKmV4dGVuc2lvbiwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCAqc3RvcCkgeworICAg ICAgICBBU1NFUlQoW2V4dGVuc2lvbiBjaGFyYWN0ZXJBdEluZGV4OjBdID09ICcuJyk7CisgICAg ICAgIFt3aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdDpbZXh0ZW5zaW9uIHN1YnN0 cmluZ0Zyb21JbmRleDoxXV07CisgICAgfV07CisgICAgCisgICAgW2FsbG93ZWRGaWxlRXh0ZW5z aW9ucyBhZGRPYmplY3RzRnJvbUFycmF5OndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnNdOworICAg IHJldHVybiBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFsbE9iamVjdHNdOworfQorCistIChOU1N0 cmluZyAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnNGaWx0ZXIKK3sKKyAgICBOU0FycmF5PE5TU3Ry aW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBlc107Cisg ICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtzZWxmIF9h Y2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIGlmICghW2FjY2VwdGVkTUlNRVR5cGVzIGNv dW50XSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICByZXR1cm4g bmlsOworCisgICAgaWYgKCEoW2FjY2VwdGVkTUlNRVR5cGVzIGNvdW50XSA9PSAxICYmICFbYWNj ZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pKQorICAgICAgICByZXR1cm4gQCJDdXN0b20gRmls ZXMiOworCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlID0gW2FjY2VwdGVkTUlNRVR5cGVzIGZpcnN0 T2JqZWN0XTsKKyAgICBOU1JhbmdlIHJhbmdlID0gW21pbWVUeXBlIHJhbmdlT2ZTdHJpbmc6QCIv Il07CisgICAgCisgICAgaWYgKCFyYW5nZS5sZW5ndGgpCisgICAgICAgIHJldHVybiBAIkN1c3Rv bSBGaWxlcyI7CisgICAgCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlUHJlZml4ID0gW21pbWVUeXBl IHN1YnN0cmluZ1RvSW5kZXg6cmFuZ2UubG9jYXRpb25dOworICAgIE5TU3RyaW5nICptaW1lVHlw ZVN1ZmZpeCA9IFttaW1lVHlwZSBzdWJzdHJpbmdGcm9tSW5kZXg6cmFuZ2UubG9jYXRpb24gKyAx XTsKKyAgICAKKyAgICBpZiAoW21pbWVUeXBlU3VmZml4IGlzRXF1YWxUb1N0cmluZzpAIioiXSkK KyAgICAgICAgcmV0dXJuIFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAlQCBGaWxlcyIs IFtbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5nVG9JbmRleDoxXSB1cHBlcmNhc2VTdHJpbmddLCBb bWltZVR5cGVQcmVmaXggc3Vic3RyaW5nRnJvbUluZGV4OjFdXTsKKworICAgIGlmIChbbWltZVR5 cGVTdWZmaXggbGVuZ3RoXSA8PSA0KQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dp dGhGb3JtYXQ6QCIlQCAlQCIsIFttaW1lVHlwZVN1ZmZpeCB1cHBlcmNhc2VTdHJpbmddLCBtaW1l VHlwZVByZWZpeF07CisKKyAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIl QCAlQCIsIG1pbWVUeXBlU3VmZml4LCBtaW1lVHlwZVByZWZpeF07Cit9CisKIEBlbmQKIAogI2Vu ZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQ YXJhbWV0ZXJzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgJKHJldmlzaW9uIDI2MjM5 NykKKysrIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFt ZXRlcnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTMxLDYgKzMxLDggQEAKIAogQHByb3Bl cnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWNj ZXB0ZWRNSU1FVHlwZXMgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMC4xMy40KSk7CiBAcHJvcGVy dHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hY2Nl cHRlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHBy b3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpf YWxsb3dlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOwor QHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU1N0cmluZyAqX2FsbG93ZWRG aWxlRXh0ZW5zaW9uc0ZpbHRlciBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEwLjEzLjQpKTsKIAog QGVuZAogCkluZGV4OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvQ2hhbmdl TG9nCShyZXZpc2lvbiAyNjI1MjkpCisrKyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkK QEAgLTEsMyArMSwyMCBAQAorMjAyMC0wNi0wMyAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhh bGxhd2FAYXBwbGUuY29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0 aGUgPGlucHV0PiBmaWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENyZWF0ZSBh IHZpZXcgd2l0aCBhbiBOU1BvcHVwQnV0dG9uIGZvciB0aGUgZmlsZSBleHRlbnNpb25zIGZpbHRl ci4gU2V0CisgICAgICAgIHRoaXMgdmlldyBhcyB0aGUgQWNjZXNzb3J5VmlldyBvZiB0aGUgT3Bl blBhbmVsLiBDcmVhdGUgYSBjdXN0b21pemVkIHRhcmdldAorICAgICAgICBmb3IgdGhlIE5TUG9w dXBCdXR0b24gdG8gcmVzcG9uZCB0byBjaGFuZ2luZyBpdHMgc2VsZWN0aW9uLgorCisgICAgICAg ICogTWluaUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm06CisgICAgICAg ICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgaW5pdFdpdGhPcGVuUGFuZWw6YWxsb3dlZEZp bGVFeHRlbnNpb25zOl0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHBv cHVwQWN0aW9uOl0pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciBjcmVh dGVGaWx0ZXJWaWV3OnBvcHVwVGFyZ2V0Ol0pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93 Q29udHJvbGxlciB3ZWJWaWV3OnJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5 RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6d2ViVmlldzpydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVy czppbml0aWF0ZWRCeUZyYW1lOmNvbXBsZXRpb25IYW5kbGVyOl0pOgorCiAyMDIwLTA2LTAzICBU YWRldSBaYWdhbGxvICA8dHphZ2FsbG9AYXBwbGUuY29tPgogCiAgICAgICAgIERpc2FibGUgQjMg aG9pc3RMb29wSW52YXJpYW50VmFsdWVzIGJ5IGRlZmF1bHQKSW5kZXg6IFRvb2xzL01pbmlCcm93 c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xz L01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCShyZXZpc2lvbiAy NjIzOTcpCisrKyBUb29scy9NaW5pQnJvd3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xs ZXIubQkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2ltcG9ydCA8V2ViS2l0L1dL RnJhbWVJbmZvLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tOYXZpZ2F0aW9uQWN0aW9uUHJpdmF0ZS5o PgogI2ltcG9ydCA8V2ViS2l0L1dLTmF2aWdhdGlvbkRlbGVnYXRlLmg+CisjaW1wb3J0IDxXZWJL aXQvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dLUHJl ZmVyZW5jZXNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlLmg+CiAjaW1w b3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlUHJpdmF0ZS5oPgpAQCAtNzEsNiArNzIsMzMgQEAgLSAo dm9pZClwZXJmb3JtQWN0aW9uOihOU1RleHRGaW5kZXJBY3RpbwogCiBAZW5kCiAKKy8vIFRhcmdl dCBmb3IgdGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5QYW5lbCdz IEFjY2Vzc29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgOiBO U09iamVjdCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOworICAgIE5T QXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5kCisKK0Bp bXBsZW1lbnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWluaXRXaXRo T3BlblBhbmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczoo TlNBcnJheTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAgaWYgKChz ZWxmID0gW3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBhbmVsOwor ICAgICAgICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW1tOU011dGFibGVBcnJheSBhcnJheVdp dGhBcnJheTphbGxvd2VkRmlsZUV4dGVuc2lvbnNdIHJldGFpbl07CisgICAgfQorICAgIHJldHVy biBzZWxmOworfQorCistICh2b2lkKXBvcHVwQWN0aW9uOihpZClzZW5kZXIgeworICAgIGlmICgh W3NlbmRlciBpbmRleE9mU2VsZWN0ZWRJdGVtXSkKKyAgICAgICAgW19vcGVuUGFuZWwgc2V0QWxs b3dlZEZpbGVUeXBlczpfYWxsb3dlZEZpbGVFeHRlbnNpb25zXTsKKyAgICBlbHNlCisgICAgICAg IFtfb3BlblBhbmVsIHNldEFsbG93ZWRGaWxlVHlwZXM6bmlsXTsKK30KKworQGVuZAorCiBAaW50 ZXJmYWNlIFdLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyICgpIDxOU1RleHRGaW5kZXJCYXJDb250 YWluZXIsIFdLTmF2aWdhdGlvbkRlbGVnYXRlLCBXS1VJRGVsZWdhdGUsIF9XS0ljb25Mb2FkaW5n RGVsZWdhdGU+CiBAZW5kCiAKQEAgLTU4Nyw2ICs2MTUsMzggQEAgLSAodm9pZCl3ZWJWaWV3OihX S1dlYlZpZXcgKil3ZWJWaWV3IHJ1bgogICAgIH1dOwogfQogCistIChudWxsYWJsZSBOU1ZpZXcg KiljcmVhdGVGaWx0ZXJWaWV3OihOU1N0cmluZyAqKWFjY2VwdGVkRmlsdGVyIHBvcHVwVGFyZ2V0 OihGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0Kilwb3B1cFRhcmdldAoreworICAgIE5TVGV4dEZp ZWxkKiBsYWJlbCA9IFtbTlNUZXh0RmllbGQgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVy b107CisgICAgW2xhYmVsIHNldFN0cmluZ1ZhbHVlOkAiRm9ybWF0OiJdOworICAgIFtsYWJlbCBz ZXRFZGl0YWJsZTpOT107CisgICAgW2xhYmVsIHNldFNlbGVjdGFibGU6Tk9dOworICAgIFtsYWJl bCBzZXRCb3JkZXJlZDpOT107CisgICAgW2xhYmVsIHNldEJhY2tncm91bmRDb2xvcjpbTlNDb2xv ciBjbGVhckNvbG9yXV07CisgICAgW2xhYmVsIHNldEFsaWdubWVudDpOU1RleHRBbGlnbm1lbnRS aWdodF07CisKKyAgICBOU1BvcFVwQnV0dG9uICpidXR0b24gPSBbW05TUG9wVXBCdXR0b24gYWxs b2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVybyBwdWxsc0Rvd246Tk9dOworICAgIGlmIChhY2Nl cHRlZEZpbHRlcikKKyAgICAgICAgW2J1dHRvbiBhZGRJdGVtV2l0aFRpdGxlOmFjY2VwdGVkRmls dGVyXTsKKyAgICBbYnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6QCJBbGwgRmlsZXMgICAgICAgICAg ICAgICAgICAgICAgICAgICJdOworICAgIFtidXR0b24gc2V0VGFyZ2V0OnBvcHVwVGFyZ2V0XTsK KyAgICBbYnV0dG9uIHNldEFjdGlvbjpAc2VsZWN0b3IocG9wdXBBY3Rpb246KV07CisgICAgW2J1 dHRvbiBzZWxlY3RJdGVtQXRJbmRleDowXTsKKyAgICBbcG9wdXBUYXJnZXQgcG9wdXBBY3Rpb246 YnV0dG9uXTsKKworICAgIE5TU3RhY2tWaWV3KiBob3Jpem9udGFsVmlldyA9IFtbTlNTdGFja1Zp ZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107CisgICAgW2hvcml6b250YWxWaWV3 IHNldERpc3RyaWJ1dGlvbjpOU1N0YWNrVmlld0Rpc3RyaWJ1dGlvbkZpbGxFcXVhbGx5XTsKKyAg ICBbaG9yaXpvbnRhbFZpZXcgc2V0U3BhY2luZzoyXTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgYWRk QXJyYW5nZWRTdWJ2aWV3OmxhYmVsXTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgYWRkQXJyYW5nZWRT dWJ2aWV3OmJ1dHRvbl07CisKKyAgICBOU1N0YWNrVmlldyogZmlsdGVyVmlldyA9IFtbTlNTdGFj a1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107CisgICAgW2ZpbHRlclZpZXcg c2V0T3JpZW50YXRpb246TlNVc2VySW50ZXJmYWNlTGF5b3V0T3JpZW50YXRpb25WZXJ0aWNhbF07 CisgICAgW2ZpbHRlclZpZXcgc2V0RWRnZUluc2V0czpOU0VkZ2VJbnNldHNNYWtlKDIwLCAyMCwg MjAsIDIwKV07CisgICAgW2ZpbHRlclZpZXcgYWRkQXJyYW5nZWRTdWJ2aWV3Omhvcml6b250YWxW aWV3XTsKKyAgICByZXR1cm4gZmlsdGVyVmlldzsKK30KKwogI2lmIF9faGFzX2ZlYXR1cmUob2Jq Y19nZW5lcmljcykKIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW5PcGVu UGFuZWxXaXRoUGFyYW1ldGVyczooV0tPcGVuUGFuZWxQYXJhbWV0ZXJzICopcGFyYW1ldGVycyBp bml0aWF0ZWRCeUZyYW1lOihXS0ZyYW1lSW5mbyAqKWZyYW1lIGNvbXBsZXRpb25IYW5kbGVyOih2 b2lkICheKShOU0FycmF5PE5TVVJMICo+ICogVVJMcykpY29tcGxldGlvbkhhbmRsZXIKICNlbHNl CkBAIC01OTcsNiArNjU3LDExIEBAIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmll dyBydW4KIAogICAgIG9wZW5QYW5lbC5hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbiA9IHBhcmFtZXRl cnMuYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb247CiAKKyAgICBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFy Z2V0ICpwb3B1cFRhcmdldCA9IFtbRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCBhbGxvY10gaW5p dFdpdGhPcGVuUGFuZWw6IG9wZW5QYW5lbCBhbGxvd2VkRmlsZUV4dGVuc2lvbnM6IHBhcmFtZXRl cnMuX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgTlNWaWV3ICpmaWx0ZXJWaWV3ID0gW3Nl bGYgY3JlYXRlRmlsdGVyVmlldzpwYXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNGaWx0 ZXIgcG9wdXBUYXJnZXQ6cG9wdXBUYXJnZXRdOworICAgIGlmIChmaWx0ZXJWaWV3KQorICAgICAg ICBbb3BlblBhbmVsIHNldEFjY2Vzc29yeVZpZXc6ZmlsdGVyVmlld107CisKICAgICBbb3BlblBh bmVsIGJlZ2luU2hlZXRNb2RhbEZvcldpbmRvdzp3ZWJWaWV3LndpbmRvdyBjb21wbGV0aW9uSGFu ZGxlcjpeKE5TSW50ZWdlciByZXN1bHQpIHsKICAgICAgICAgaWYgKHJlc3VsdCA9PSBOU01vZGFs UmVzcG9uc2VPSykKICAgICAgICAgICAgIGNvbXBsZXRpb25IYW5kbGVyKG9wZW5QYW5lbC5VUkxz KTsK 400993 2020-06-03 21:27:45 -0700 2020-06-04 17:53:17 -0700 Patch bug-212485-20200603212744.patch text/plain 11808 sabouhallawa SW5kZXg6IFNvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQvQ2hhbmdlTG9nCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIyIEBACisyMDIwLTA2LTAzICBTYWlkIEFib3Ut SGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAgICAgW21hY09TXTogVGhl IEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBzaG91bGQgc2hvdyB0aGUg c2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgQWRkIHR3byBwcml2YXRlIGhlbHBlcnMgdG8gV0tPcGVuUGFuZWxQYXJhbWV0ZXJz LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnMu bW06CisgICAgICAgICgtW1dLT3BlblBhbmVsUGFyYW1ldGVycyBfYWxsb3dlZEZpbGVFeHRlbnNp b25zXSk6CisgICAgICAgIFJldHVybnMgYW4gYXJyYXkgb2Ygc3RyaW5ncyByZXByZXNlbnRpbmcg dGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAoLVtXS09wZW5QYW5lbFBhcmFtZXRl cnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0ZpbHRlcl0pOgorICAgICAgICBSZXR1cm5zIGEgc3Ry aW5nIHJlcHJlc2VudGluZyB0aGUgdGl0bGUgb2YgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucyBpbiB0 aGUKKyAgICAgICAgT3BlblBhbmVsJ3MgQWNjZXNzb3J5Vmlldy4KKworICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oOgorCiAyMDIwLTA2 LTAxICBCcmVudCBGdWxnaGFtICA8YmZ1bGdoYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFJlbW92 ZSB1bnVzZWQgV2ViQ29udGVudCBwcm9jZXNzIHNhbmRib3ggc3lzY2FsbApJbmRleDogU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5tbQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQ YXJhbWV0ZXJzLm1tCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0y NSwxMSArMjUsNDMgQEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1wb3J0ICJXS09wZW5QYW5l bFBhcmFtZXRlcnNJbnRlcm5hbC5oIgorI2ltcG9ydCA8cGFsL3NwaS9jb2NvYS9OU1VSTEZpbGVU eXBlTWFwcGluZ3NTUEkuaD4KIAogI2lmIFBMQVRGT1JNKE1BQykKIAogI2ltcG9ydCAiV0tOU0Fy cmF5LmgiCiAKK3N0YXRpYyBOU1NldDxOU1N0cmluZyAqPiAqZXh0ZW5zaW9uc0Zvck1JTUVXaWxk Y2FyZFR5cGUoTlNTdHJpbmcgKnR5cGUpCit7CisgICAgc3RhdGljIE5TRGljdGlvbmFyeTxOU1N0 cmluZyAqLCBOU1NldDxOU1N0cmluZyAqPiAqPiAqbWltZVdpbGRjYXJkc1RvRXh0ZW5zaW9uTGlz dDsKKyAgICBzdGF0aWMgZGlzcGF0Y2hfb25jZV90IG9uY2VUb2tlbjsKKyAgICBkaXNwYXRjaF9v bmNlKCZvbmNlVG9rZW4sIF57CisgICAgICAgIE5TQnVuZGxlICpidW5kbGUgPSBbTlNCdW5kbGUg YnVuZGxlRm9yQ2xhc3M6W05TVVJMRmlsZVR5cGVNYXBwaW5ncyBjbGFzc11dOworICAgICAgICBO U0RhdGEgKmRhdGEgPSBbTlNEYXRhIGRhdGFXaXRoQ29udGVudHNPZkZpbGU6W2J1bmRsZSBwYXRo Rm9yUmVzb3VyY2U6QCJ0eXBlcyIgb2ZUeXBlOkAicGxpc3QiXV07CisgICAgICAgIGlmICghZGF0 YSkgeworICAgICAgICAgICAgbWltZVdpbGRjYXJkc1RvRXh0ZW5zaW9uTGlzdCA9IFtOU0RpY3Rp b25hcnkgbmV3XTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIE5T RGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU0FycmF5PE5TU3RyaW5nICo+ICo+ICptaW1lVHlwZVRv RXh0ZW5zaW9uTGlzdCA9IFtOU1Byb3BlcnR5TGlzdFNlcmlhbGl6YXRpb24gcHJvcGVydHlMaXN0 V2l0aERhdGE6ZGF0YSBvcHRpb25zOk5TUHJvcGVydHlMaXN0SW1tdXRhYmxlIGZvcm1hdDpuaWwg ZXJyb3I6bmlsXTsKKyAgICAgICAgTlNNdXRhYmxlRGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU011 dGFibGVTZXQ8TlNTdHJpbmcgKj4gKj4gKm1hcCA9IFtOU011dGFibGVEaWN0aW9uYXJ5IG5ld107 CisKKyAgICAgICAgW21pbWVUeXBlVG9FeHRlbnNpb25MaXN0IGVudW1lcmF0ZUtleXNBbmRPYmpl Y3RzVXNpbmdCbG9jazpeKE5TU3RyaW5nICpjb250ZW50VHlwZSwgTlNBcnJheTxOU1N0cmluZyAq PiAqZXh0ZW5zaW9uTGlzdCwgQk9PTCogc3RvcCkgeworICAgICAgICAgICAgTlNTdHJpbmcgKnR5 cGUgPSBbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVALyoiLCBbW2NvbnRlbnRUeXBlIGNv bXBvbmVudHNTZXBhcmF0ZWRCeVN0cmluZzpAIi8iXSBmaXJzdE9iamVjdF1dOworICAgICAgICAg ICAgTlNNdXRhYmxlU2V0PE5TU3RyaW5nICo+ICpleHRlbnNpb25zID0gbWFwW3R5cGVdOworICAg ICAgICAgICAgaWYgKCFleHRlbnNpb25zKSB7CisgICAgICAgICAgICAgICAgZXh0ZW5zaW9ucyA9 IFtOU011dGFibGVTZXQgc2V0XTsKKyAgICAgICAgICAgICAgICBtYXBbdHlwZV0gPSBleHRlbnNp b25zOworICAgICAgICAgICAgfQorICAgICAgICAgICAgW2V4dGVuc2lvbnMgYWRkT2JqZWN0c0Zy b21BcnJheTpleHRlbnNpb25MaXN0XTsKKyAgICAgICAgfV07CisKKyAgICAgICAgbWltZVdpbGRj YXJkc1RvRXh0ZW5zaW9uTGlzdCA9IFttYXAgY29weV07CisgICAgfSk7CisKKyAgICByZXR1cm4g W21pbWVXaWxkY2FyZHNUb0V4dGVuc2lvbkxpc3Qgb2JqZWN0Rm9yS2V5OnR5cGVdOworfQorCiBA aW1wbGVtZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wpYWxsb3dzTXVs dGlwbGVTZWxlY3Rpb24KQEAgLTYzLDYgKzk1LDYxIEBAIC0gKE5TQXJyYXk8TlNTdHJpbmcgKj4g KilfYWNjZXB0ZWRGaWxlRXgKICAgICByZXR1cm4gd3JhcHBlcihfb3BlblBhbmVsUGFyYW1ldGVy cy0+YWNjZXB0RmlsZUV4dGVuc2lvbnMoKSk7CiB9CiAKKy0gKE5TQXJyYXk8TlNTdHJpbmcgKj4g KilfYWxsb3dlZEZpbGVFeHRlbnNpb25zCit7CisgICAgLy8gQWdncmVnYXRlIGV4dGVuc2lvbnMg YmFzZWQgb24gc3BlY2lmaWVkIE1JTUUgdHlwZXMuCisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAq YWNjZXB0ZWRNSU1FVHlwZXMgPSBbc2VsZiBfYWNjZXB0ZWRNSU1FVHlwZXNdOworICAgIE5TQXJy YXk8TlNTdHJpbmcgKj4gKmFjY2VwdGVkRmlsZUV4dGVuc2lvbnMgPSBbc2VsZiBfYWNjZXB0ZWRG aWxlRXh0ZW5zaW9uc107CisKKyAgICBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKmFsbG93ZWRG aWxlRXh0ZW5zaW9ucyA9IFtOU011dGFibGVTZXQgc2V0XTsKKworICAgIE5TVVJMRmlsZVR5cGVN YXBwaW5ncyAqZmlsZVR5cGVNYXBwaW5ncyA9IFtOU1VSTEZpbGVUeXBlTWFwcGluZ3Mgc2hhcmVk TWFwcGluZ3NdOworICAgIFthY2NlcHRlZE1JTUVUeXBlcyBlbnVtZXJhdGVPYmplY3RzVXNpbmdC bG9jazpeKE5TU3RyaW5nICptaW1lVHlwZSwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCogc3RvcCkg eworICAgICAgICBpZiAoW21pbWVUeXBlIGhhc1N1ZmZpeDpAIioiXSkKKyAgICAgICAgICAgIFth bGxvd2VkRmlsZUV4dGVuc2lvbnMgdW5pb25TZXQ6ZXh0ZW5zaW9uc0Zvck1JTUVXaWxkY2FyZFR5 cGUobWltZVR5cGUpXTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgW2FsbG93ZWRGaWxlRXh0 ZW5zaW9ucyBhZGRPYmplY3RzRnJvbUFycmF5OltmaWxlVHlwZU1hcHBpbmdzIGV4dGVuc2lvbnNG b3JNSU1FVHlwZTptaW1lVHlwZV1dOworICAgIH1dOworCisgICAgTlNNdXRhYmxlQXJyYXk8TlNT dHJpbmcgKj4gKndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlQXJyYXkgYXJy YXldOworICAgIFthY2NlcHRlZEZpbGVFeHRlbnNpb25zIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Js b2NrOl4oTlNTdHJpbmcgKmV4dGVuc2lvbiwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCAqc3RvcCkg eworICAgICAgICBBU1NFUlQoW2V4dGVuc2lvbiBjaGFyYWN0ZXJBdEluZGV4OjBdID09ICcuJyk7 CisgICAgICAgIFt3aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdDpbZXh0ZW5zaW9u IHN1YnN0cmluZ0Zyb21JbmRleDoxXV07CisgICAgfV07CisgICAgCisgICAgW2FsbG93ZWRGaWxl RXh0ZW5zaW9ucyBhZGRPYmplY3RzRnJvbUFycmF5OndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnNd OworICAgIHJldHVybiBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFsbE9iamVjdHNdOworfQorCist IChOU1N0cmluZyAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnNGaWx0ZXIKK3sKKyAgICBOU0FycmF5 PE5TU3RyaW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBl c107CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtz ZWxmIF9hY2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIGlmICghW2FjY2VwdGVkTUlNRVR5 cGVzIGNvdW50XSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICBy ZXR1cm4gbmlsOworCisgICAgaWYgKCEoW2FjY2VwdGVkTUlNRVR5cGVzIGNvdW50XSA9PSAxICYm ICFbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pKQorICAgICAgICByZXR1cm4gQCJDdXN0 b20gRmlsZXMiOworCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlID0gW2FjY2VwdGVkTUlNRVR5cGVz IGZpcnN0T2JqZWN0XTsKKyAgICBOU1JhbmdlIHJhbmdlID0gW21pbWVUeXBlIHJhbmdlT2ZTdHJp bmc6QCIvIl07CisgICAgCisgICAgaWYgKCFyYW5nZS5sZW5ndGgpCisgICAgICAgIHJldHVybiBA IkN1c3RvbSBGaWxlcyI7CisgICAgCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlUHJlZml4ID0gW21p bWVUeXBlIHN1YnN0cmluZ1RvSW5kZXg6cmFuZ2UubG9jYXRpb25dOworICAgIE5TU3RyaW5nICpt aW1lVHlwZVN1ZmZpeCA9IFttaW1lVHlwZSBzdWJzdHJpbmdGcm9tSW5kZXg6cmFuZ2UubG9jYXRp b24gKyAxXTsKKyAgICAKKyAgICBpZiAoW21pbWVUeXBlU3VmZml4IGlzRXF1YWxUb1N0cmluZzpA IioiXSkKKyAgICAgICAgcmV0dXJuIFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAlQCBG aWxlcyIsIFtbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5nVG9JbmRleDoxXSB1cHBlcmNhc2VTdHJp bmddLCBbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5nRnJvbUluZGV4OjFdXTsKKworICAgIGlmIChb bWltZVR5cGVTdWZmaXggbGVuZ3RoXSA8PSA0KQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0 cmluZ1dpdGhGb3JtYXQ6QCIlQCAlQCIsIFttaW1lVHlwZVN1ZmZpeCB1cHBlcmNhc2VTdHJpbmdd LCBtaW1lVHlwZVByZWZpeF07CisKKyAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3Jt YXQ6QCIlQCAlQCIsIG1pbWVUeXBlU3VmZml4LCBtaW1lVHlwZVByZWZpeF07Cit9CisKIEBlbmQK IAogI2VuZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVu UGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgJKHJldmlzaW9u IDI2MjM5NykKKysrIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5l bFBhcmFtZXRlcnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTMxLDYgKzMxLDggQEAKIAog QHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ ICpfYWNjZXB0ZWRNSU1FVHlwZXMgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMC4xMy40KSk7CiBA cHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJyYXk8TlNTdHJpbmcgKj4g Kl9hY2NlcHRlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkp OworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5n ICo+ICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMu NCkpOworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU1N0cmluZyAqX2Fs bG93ZWRGaWxlRXh0ZW5zaW9uc0ZpbHRlciBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEwLjEzLjQp KTsKIAogQGVuZAogCkluZGV4OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv Q2hhbmdlTG9nCShyZXZpc2lvbiAyNjI1MjkpCisrKyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyMCBAQAorMjAyMC0wNi0wMyAgU2FpZCBBYm91LUhhbGxhd2EgIDxz YWJvdWhhbGxhd2FAYXBwbGUuY29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tl ciBvZiB0aGUgPGlucHV0PiBmaWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBm aWx0ZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx MjQ4NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENy ZWF0ZSBhIHZpZXcgd2l0aCBhbiBOU1BvcHVwQnV0dG9uIGZvciB0aGUgZmlsZSBleHRlbnNpb25z IGZpbHRlci4gU2V0CisgICAgICAgIHRoaXMgdmlldyBhcyB0aGUgQWNjZXNzb3J5VmlldyBvZiB0 aGUgT3BlblBhbmVsLiBDcmVhdGUgYSBjdXN0b21pemVkIHRhcmdldAorICAgICAgICBmb3IgdGhl IE5TUG9wdXBCdXR0b24gdG8gcmVzcG9uZCB0byBjaGFuZ2luZyBpdHMgc2VsZWN0aW9uLgorCisg ICAgICAgICogTWluaUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm06Cisg ICAgICAgICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgaW5pdFdpdGhPcGVuUGFuZWw6YWxs b3dlZEZpbGVFeHRlbnNpb25zOl0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFy Z2V0IHBvcHVwQWN0aW9uOl0pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxl ciBjcmVhdGVGaWx0ZXJWaWV3OnBvcHVwVGFyZ2V0Ol0pOgorICAgICAgICAoLVtXSzJCcm93c2Vy V2luZG93Q29udHJvbGxlciB3ZWJWaWV3OnJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRp YXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6d2ViVmlldzpydW5PcGVuUGFuZWxXaXRoUGFy YW1ldGVyczppbml0aWF0ZWRCeUZyYW1lOmNvbXBsZXRpb25IYW5kbGVyOl0pOgorCiAyMDIwLTA2 LTAzICBUYWRldSBaYWdhbGxvICA8dHphZ2FsbG9AYXBwbGUuY29tPgogCiAgICAgICAgIERpc2Fi bGUgQjMgaG9pc3RMb29wSW52YXJpYW50VmFsdWVzIGJ5IGRlZmF1bHQKSW5kZXg6IFRvb2xzL01p bmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFRvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCShyZXZp c2lvbiAyNjIzOTcpCisrKyBUb29scy9NaW5pQnJvd3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0Nv bnRyb2xsZXIubQkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2ltcG9ydCA8V2Vi S2l0L1dLRnJhbWVJbmZvLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tOYXZpZ2F0aW9uQWN0aW9uUHJp dmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dLTmF2aWdhdGlvbkRlbGVnYXRlLmg+CisjaW1wb3J0 IDxXZWJLaXQvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0 L1dLUHJlZmVyZW5jZXNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlLmg+ CiAjaW1wb3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlUHJpdmF0ZS5oPgpAQCAtNzEsNiArNzIsMzMg QEAgLSAodm9pZClwZXJmb3JtQWN0aW9uOihOU1RleHRGaW5kZXJBY3RpbwogCiBAZW5kCiAKKy8v IFRhcmdldCBmb3IgdGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5Q YW5lbCdzIEFjY2Vzc29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJn ZXQgOiBOU09iamVjdCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOwor ICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5k CisKK0BpbXBsZW1lbnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWlu aXRXaXRoT3BlblBhbmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5z aW9uczooTlNBcnJheTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAg aWYgKChzZWxmID0gW3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBh bmVsOworICAgICAgICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW1tOU011dGFibGVBcnJheSBh cnJheVdpdGhBcnJheTphbGxvd2VkRmlsZUV4dGVuc2lvbnNdIHJldGFpbl07CisgICAgfQorICAg IHJldHVybiBzZWxmOworfQorCistICh2b2lkKXBvcHVwQWN0aW9uOihpZClzZW5kZXIgeworICAg IGlmICghW3NlbmRlciBpbmRleE9mU2VsZWN0ZWRJdGVtXSkKKyAgICAgICAgW19vcGVuUGFuZWwg c2V0QWxsb3dlZEZpbGVUeXBlczpfYWxsb3dlZEZpbGVFeHRlbnNpb25zXTsKKyAgICBlbHNlCisg ICAgICAgIFtfb3BlblBhbmVsIHNldEFsbG93ZWRGaWxlVHlwZXM6bmlsXTsKK30KKworQGVuZAor CiBAaW50ZXJmYWNlIFdLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyICgpIDxOU1RleHRGaW5kZXJC YXJDb250YWluZXIsIFdLTmF2aWdhdGlvbkRlbGVnYXRlLCBXS1VJRGVsZWdhdGUsIF9XS0ljb25M b2FkaW5nRGVsZWdhdGU+CiBAZW5kCiAKQEAgLTU4Nyw2ICs2MTUsMzggQEAgLSAodm9pZCl3ZWJW aWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IHJ1bgogICAgIH1dOwogfQogCistIChudWxsYWJsZSBO U1ZpZXcgKiljcmVhdGVGaWx0ZXJWaWV3OihOU1N0cmluZyAqKWFjY2VwdGVkRmlsdGVyIHBvcHVw VGFyZ2V0OihGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0Kilwb3B1cFRhcmdldAoreworICAgIE5T VGV4dEZpZWxkKiBsYWJlbCA9IFtbTlNUZXh0RmllbGQgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dS ZWN0WmVyb107CisgICAgW2xhYmVsIHNldFN0cmluZ1ZhbHVlOkAiRm9ybWF0OiJdOworICAgIFts YWJlbCBzZXRFZGl0YWJsZTpOT107CisgICAgW2xhYmVsIHNldFNlbGVjdGFibGU6Tk9dOworICAg IFtsYWJlbCBzZXRCb3JkZXJlZDpOT107CisgICAgW2xhYmVsIHNldEJhY2tncm91bmRDb2xvcjpb TlNDb2xvciBjbGVhckNvbG9yXV07CisgICAgW2xhYmVsIHNldEFsaWdubWVudDpOU1RleHRBbGln bm1lbnRSaWdodF07CisKKyAgICBOU1BvcFVwQnV0dG9uICpidXR0b24gPSBbW05TUG9wVXBCdXR0 b24gYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVybyBwdWxsc0Rvd246Tk9dOworICAgIGlm IChhY2NlcHRlZEZpbHRlcikKKyAgICAgICAgW2J1dHRvbiBhZGRJdGVtV2l0aFRpdGxlOmFjY2Vw dGVkRmlsdGVyXTsKKyAgICBbYnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6QCJBbGwgRmlsZXMgICAg ICAgICAgICAgICAgICAgICAgICAgICJdOworICAgIFtidXR0b24gc2V0VGFyZ2V0OnBvcHVwVGFy Z2V0XTsKKyAgICBbYnV0dG9uIHNldEFjdGlvbjpAc2VsZWN0b3IocG9wdXBBY3Rpb246KV07Cisg ICAgW2J1dHRvbiBzZWxlY3RJdGVtQXRJbmRleDowXTsKKyAgICBbcG9wdXBUYXJnZXQgcG9wdXBB Y3Rpb246YnV0dG9uXTsKKworICAgIE5TU3RhY2tWaWV3KiBob3Jpem9udGFsVmlldyA9IFtbTlNT dGFja1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107CisgICAgW2hvcml6b250 YWxWaWV3IHNldERpc3RyaWJ1dGlvbjpOU1N0YWNrVmlld0Rpc3RyaWJ1dGlvbkZpbGxFcXVhbGx5 XTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgc2V0U3BhY2luZzoyXTsKKyAgICBbaG9yaXpvbnRhbFZp ZXcgYWRkQXJyYW5nZWRTdWJ2aWV3OmxhYmVsXTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgYWRkQXJy YW5nZWRTdWJ2aWV3OmJ1dHRvbl07CisKKyAgICBOU1N0YWNrVmlldyogZmlsdGVyVmlldyA9IFtb TlNTdGFja1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107CisgICAgW2ZpbHRl clZpZXcgc2V0T3JpZW50YXRpb246TlNVc2VySW50ZXJmYWNlTGF5b3V0T3JpZW50YXRpb25WZXJ0 aWNhbF07CisgICAgW2ZpbHRlclZpZXcgc2V0RWRnZUluc2V0czpOU0VkZ2VJbnNldHNNYWtlKDIw LCAyMCwgMjAsIDIwKV07CisgICAgW2ZpbHRlclZpZXcgYWRkQXJyYW5nZWRTdWJ2aWV3Omhvcml6 b250YWxWaWV3XTsKKyAgICByZXR1cm4gZmlsdGVyVmlldzsKK30KKwogI2lmIF9faGFzX2ZlYXR1 cmUob2JqY19nZW5lcmljcykKIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBy dW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczooV0tPcGVuUGFuZWxQYXJhbWV0ZXJzICopcGFyYW1l dGVycyBpbml0aWF0ZWRCeUZyYW1lOihXS0ZyYW1lSW5mbyAqKWZyYW1lIGNvbXBsZXRpb25IYW5k bGVyOih2b2lkICheKShOU0FycmF5PE5TVVJMICo+ICogVVJMcykpY29tcGxldGlvbkhhbmRsZXIK ICNlbHNlCkBAIC01OTcsNiArNjU3LDExIEBAIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICop d2ViVmlldyBydW4KIAogICAgIG9wZW5QYW5lbC5hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbiA9IHBh cmFtZXRlcnMuYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb247CiAKKyAgICBGaWxlRXh0ZW5zaW9uc1Bv cHVwVGFyZ2V0ICpwb3B1cFRhcmdldCA9IFtbRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCBhbGxv Y10gaW5pdFdpdGhPcGVuUGFuZWw6IG9wZW5QYW5lbCBhbGxvd2VkRmlsZUV4dGVuc2lvbnM6IHBh cmFtZXRlcnMuX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgTlNWaWV3ICpmaWx0ZXJWaWV3 ID0gW3NlbGYgY3JlYXRlRmlsdGVyVmlldzpwYXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lv bnNGaWx0ZXIgcG9wdXBUYXJnZXQ6cG9wdXBUYXJnZXRdOworICAgIGlmIChmaWx0ZXJWaWV3KQor ICAgICAgICBbb3BlblBhbmVsIHNldEFjY2Vzc29yeVZpZXc6ZmlsdGVyVmlld107CisKICAgICBb b3BlblBhbmVsIGJlZ2luU2hlZXRNb2RhbEZvcldpbmRvdzp3ZWJWaWV3LndpbmRvdyBjb21wbGV0 aW9uSGFuZGxlcjpeKE5TSW50ZWdlciByZXN1bHQpIHsKICAgICAgICAgaWYgKHJlc3VsdCA9PSBO U01vZGFsUmVzcG9uc2VPSykKICAgICAgICAgICAgIGNvbXBsZXRpb25IYW5kbGVyKG9wZW5QYW5l bC5VUkxzKTsK 401104 2020-06-04 17:53:19 -0700 2020-06-05 03:23:32 -0700 Patch bug-212485-20200604175318.patch text/plain 13706 sabouhallawa SW5kZXg6IFNvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvUEFML0NoYW5nZUxvZwkocmV2aXNpb24gMjYyMzk3KQorKysgU291cmNlL1dlYkNv cmUvUEFML0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDIwLTA2 LTA0ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAg ICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBz aG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgVG8gZ2V0IHRoZSBidW5kbGUgb2YgTlNVUkxGaWxlVHlw ZU1hcHBpbmdzLCB3ZSBuZWVkIHRvIGV4cG9zZSB0aGUgaW50ZXJmYWNlCisgICAgICAgIG9mIE5T VVJMRmlsZVR5cGVNYXBwaW5ncy4KKworICAgICAgICAqIHBhbC9zcGkvY29jb2EvTlNVUkxGaWxl VHlwZU1hcHBpbmdzU1BJLmg6CisKIDIwMjAtMDUtMzEgIEplciBOb2JsZSAgPGplci5ub2JsZUBh cHBsZS5jb20+CiAKICAgICAgICAgW0NvY29hXSBUcmFuc2l0aW9uIGJldHdlZW4gZW5jcnlwdGVk IGFuZCBjbGVhciBjb2RlY3MgdGhyb3dzIGVycm9yIGZyb20gU291cmNlQnVmZmVyLmFwcGVuZEJ1 ZmZlcigpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9OU1VSTEZpbGVU eXBlTWFwcGluZ3NTUEkuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3Nw aS9jb2NvYS9OU1VSTEZpbGVUeXBlTWFwcGluZ3NTUEkuaAkocmV2aXNpb24gMjYyMzk3KQorKysg U291cmNlL1dlYkNvcmUvUEFML3BhbC9zcGkvY29jb2EvTlNVUkxGaWxlVHlwZU1hcHBpbmdzU1BJ LmgJKHdvcmtpbmcgY29weSkKQEAgLTI5LDExICsyOSwxNSBAQAogCiAjZWxzZQogCitAY2xhc3Mg TlNVUkxGaWxlVHlwZU1hcHBpbmdzSW50ZXJuYWw7CisKIC8vIEZJWE1FOiBXZSBzaG91bGQgdXNl IFVUSSBpbnN0ZWFkLCBidXQgaXQncyBtaXNzaW5nIHNvbWUgbWFwcGluZ3MgdGhhdCB0aGlzIG9s ZCBTUEkga25vd3MuCiAvLyBSZW1vdmUgdGhlc2UgbWV0aG9kcyBvbmNlIDxyZGFyOi8vcHJvYmxl bS8xODA0MjE4ND4gaXMgZml4ZWQuCi1AaW50ZXJmYWNlIE5TVVJMRmlsZVR5cGVNYXBwaW5ncwot QGVuZAotQGludGVyZmFjZSBOU1VSTEZpbGVUeXBlTWFwcGluZ3MgKFByaXZhdGUpCitAaW50ZXJm YWNlIE5TVVJMRmlsZVR5cGVNYXBwaW5ncyA6IE5TT2JqZWN0IHsKK0Bwcml2YXRlCisgICAgTlNV UkxGaWxlVHlwZU1hcHBpbmdzSW50ZXJuYWwgKl9pbnRlcm5hbDsKK30KKwogKyAoTlNVUkxGaWxl VHlwZU1hcHBpbmdzICopc2hhcmVkTWFwcGluZ3M7CiAtIChOU1N0cmluZyAqKU1JTUVUeXBlRm9y RXh0ZW5zaW9uOihOU1N0cmluZyAqKWV4dDsKIC0gKE5TU3RyaW5nICopcHJlZmVycmVkRXh0ZW5z aW9uRm9yTUlNRVR5cGU6KE5TU3RyaW5nICopdHlwZTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCShyZXZpc2lvbiAy NjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDIxIEBACisyMDIwLTA2LTA0ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBh cHBsZS5jb20+CisKKyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5w dXQ+IGZpbGUgZWxlbWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHR3byBwcml2YXRl IGhlbHBlcnMgdG8gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLgorCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnMubW06CisgICAgICAgICgtW1dLT3BlblBh bmVsUGFyYW1ldGVycyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zXSk6CisgICAgICAgIFJldHVybnMg YW4gYXJyYXkgb2Ygc3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4K KworICAgICAgICAoLVtXS09wZW5QYW5lbFBhcmFtZXRlcnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9u c0Rlc2NyaXB0aW9uXSk6CisgICAgICAgIFJldHVybnMgYSBzdHJpbmcgcmVwcmVzZW50aW5nIHRo ZSBkZXNjcmlwdGlvbiBmb3IgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oOgorCiAyMDIw LTA2LTAxICBCcmVudCBGdWxnaGFtICA8YmZ1bGdoYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFJl bW92ZSB1bnVzZWQgV2ViQ29udGVudCBwcm9jZXNzIHNhbmRib3ggc3lzY2FsbApJbmRleDogU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5tbQo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFu ZWxQYXJhbWV0ZXJzLm1tCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0yNSwxMSArMjUsNDQgQEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1wb3J0ICJXS09wZW5Q YW5lbFBhcmFtZXRlcnNJbnRlcm5hbC5oIgorI2ltcG9ydCA8cGFsL3NwaS9jb2NvYS9OU1VSTEZp bGVUeXBlTWFwcGluZ3NTUEkuaD4KIAogI2lmIFBMQVRGT1JNKE1BQykKIAogI2ltcG9ydCAiV0tO U0FycmF5LmgiCiAKK3N0YXRpYyBOU1NldDxOU1N0cmluZyAqPiAqZXh0ZW5zaW9uc0Zvck1JTUVX aWxkY2FyZFR5cGUoTlNTdHJpbmcgKm1pbWV0eXBlKQoreworICAgIHN0YXRpYyBOZXZlckRlc3Ry b3llZDxSZXRhaW5QdHI8TlNEaWN0aW9uYXJ5PE5TU3RyaW5nICosIE5TU2V0PE5TU3RyaW5nICo+ ICo+Pj4gbWltZVdpbGRjYXJkc1RvRXh0ZW5zaW9uTGlzdDsKKyAgICBzdGF0aWMgZGlzcGF0Y2hf b25jZV90IG9uY2VUb2tlbjsKKyAgICBkaXNwYXRjaF9vbmNlKCZvbmNlVG9rZW4sIF57CisgICAg ICAgIE5TQnVuZGxlICpidW5kbGUgPSBbTlNCdW5kbGUgYnVuZGxlRm9yQ2xhc3M6W05TVVJMRmls ZVR5cGVNYXBwaW5ncyBjbGFzc11dOworICAgICAgICBOU0RhdGEgKmRhdGEgPSBbTlNEYXRhIGRh dGFXaXRoQ29udGVudHNPZkZpbGU6W2J1bmRsZSBwYXRoRm9yUmVzb3VyY2U6QCJ0eXBlcyIgb2ZU eXBlOkAicGxpc3QiXV07CisgICAgICAgIGlmICghZGF0YSkgeworICAgICAgICAgICAgbWltZVdp bGRjYXJkc1RvRXh0ZW5zaW9uTGlzdC5nZXQoKSA9IFtOU0RpY3Rpb25hcnkgbmV3XTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIE5TRGljdGlvbmFyeTxOU1N0cmlu ZyAqLCBOU0FycmF5PE5TU3RyaW5nICo+ICo+ICptaW1lVHlwZVRvRXh0ZW5zaW9uTGlzdCA9IFtO U1Byb3BlcnR5TGlzdFNlcmlhbGl6YXRpb24gcHJvcGVydHlMaXN0V2l0aERhdGE6ZGF0YSBvcHRp b25zOk5TUHJvcGVydHlMaXN0SW1tdXRhYmxlIGZvcm1hdDpuaWwgZXJyb3I6bmlsXTsKKyAgICAg ICAgUmV0YWluUHRyPE5TTXV0YWJsZURpY3Rpb25hcnk8TlNTdHJpbmcgKiwgTlNNdXRhYmxlU2V0 PE5TU3RyaW5nICo+ICo+PiBtYXAgPSBbTlNNdXRhYmxlRGljdGlvbmFyeSBuZXddOworCisgICAg ICAgIFttaW1lVHlwZVRvRXh0ZW5zaW9uTGlzdCBlbnVtZXJhdGVLZXlzQW5kT2JqZWN0c1VzaW5n QmxvY2s6XihOU1N0cmluZyAqY29udGVudFR5cGUsIE5TQXJyYXk8TlNTdHJpbmcgKj4gKmV4dGVu c2lvbkxpc3QsIEJPT0wqIHN0b3ApIHsKKyAgICAgICAgICAgIE5TU3RyaW5nICptaW1ldHlwZSA9 IFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAvKiIsIFtbY29udGVudFR5cGUgY29tcG9u ZW50c1NlcGFyYXRlZEJ5U3RyaW5nOkAiLyJdIGZpcnN0T2JqZWN0XV07CisgICAgICAgICAgICBO U011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKmV4dGVuc2lvbnMgPSBtYXAuZ2V0KClbbWltZXR5cGVd OworICAgICAgICAgICAgaWYgKCFleHRlbnNpb25zKSB7CisgICAgICAgICAgICAgICAgZXh0ZW5z aW9ucyA9IFtOU011dGFibGVTZXQgc2V0XTsKKyAgICAgICAgICAgICAgICBtYXAuZ2V0KClbbWlt ZXR5cGVdID0gZXh0ZW5zaW9uczsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIFtleHRlbnNp b25zIGFkZE9iamVjdHNGcm9tQXJyYXk6ZXh0ZW5zaW9uTGlzdF07CisgICAgICAgIH1dOworCisg ICAgICAgIG1pbWVXaWxkY2FyZHNUb0V4dGVuc2lvbkxpc3QuZ2V0KCkgPSBbbWFwIGNvcHldOwor ICAgIH0pOworCisgICAgQVNTRVJUKFttaW1ldHlwZSBjaGFyYWN0ZXJBdEluZGV4OlttaW1ldHlw ZSBsZW5ndGhdIC0gMV0gPT0gJyonKTsKKyAgICByZXR1cm4gW21pbWVXaWxkY2FyZHNUb0V4dGVu c2lvbkxpc3QuZ2V0KCkgb2JqZWN0Rm9yS2V5Om1pbWV0eXBlXTsKK30KKwogQGltcGxlbWVudGF0 aW9uIFdLT3BlblBhbmVsUGFyYW1ldGVycwogCiAtIChCT09MKWFsbG93c011bHRpcGxlU2VsZWN0 aW9uCkBAIC02Myw2ICs5Niw2MSBAQCAtIChOU0FycmF5PE5TU3RyaW5nICo+ICopX2FjY2VwdGVk RmlsZUV4CiAgICAgcmV0dXJuIHdyYXBwZXIoX29wZW5QYW5lbFBhcmFtZXRlcnMtPmFjY2VwdEZp bGVFeHRlbnNpb25zKCkpOwogfQogCistIChOU0FycmF5PE5TU3RyaW5nICo+ICopX2FsbG93ZWRG aWxlRXh0ZW5zaW9ucworeworICAgIC8vIEFnZ3JlZ2F0ZSBleHRlbnNpb25zIGJhc2VkIG9uIHNw ZWNpZmllZCBNSU1FIHR5cGVzLgorICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4gKmFjY2VwdGVkTUlN RVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5cGVzXTsKKyAgICBOU0FycmF5PE5TU3RyaW5n ICo+ICphY2NlcHRlZEZpbGVFeHRlbnNpb25zID0gW3NlbGYgX2FjY2VwdGVkRmlsZUV4dGVuc2lv bnNdOworCisgICAgTlNNdXRhYmxlU2V0PE5TU3RyaW5nICo+ICphbGxvd2VkRmlsZUV4dGVuc2lv bnMgPSBbTlNNdXRhYmxlU2V0IHNldF07CisKKyAgICBOU1VSTEZpbGVUeXBlTWFwcGluZ3MgKmZp bGVUeXBlTWFwcGluZ3MgPSBbTlNVUkxGaWxlVHlwZU1hcHBpbmdzIHNoYXJlZE1hcHBpbmdzXTsK KyAgICBbYWNjZXB0ZWRNSU1FVHlwZXMgZW51bWVyYXRlT2JqZWN0c1VzaW5nQmxvY2s6XihOU1N0 cmluZyAqbWltZVR5cGUsIE5TVUludGVnZXIgaW5kZXgsIEJPT0wqIHN0b3ApIHsKKyAgICAgICAg aWYgKFttaW1lVHlwZSBoYXNTdWZmaXg6QCIqIl0pCisgICAgICAgICAgICBbYWxsb3dlZEZpbGVF eHRlbnNpb25zIHVuaW9uU2V0OmV4dGVuc2lvbnNGb3JNSU1FV2lsZGNhcmRUeXBlKG1pbWVUeXBl KV07CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMgYWRk T2JqZWN0c0Zyb21BcnJheTpbZmlsZVR5cGVNYXBwaW5ncyBleHRlbnNpb25zRm9yTUlNRVR5cGU6 bWltZVR5cGVdXTsKKyAgICB9XTsKKworICAgIE5TTXV0YWJsZUFycmF5PE5TU3RyaW5nICo+ICp3 aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zID0gW05TTXV0YWJsZUFycmF5IGFycmF5XTsKKyAgICBb YWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBlbnVtZXJhdGVPYmplY3RzVXNpbmdCbG9jazpeKE5TU3Ry aW5nICpleHRlbnNpb24sIE5TVUludGVnZXIgaW5kZXgsIEJPT0wgKnN0b3ApIHsKKyAgICAgICAg QVNTRVJUKFtleHRlbnNpb24gY2hhcmFjdGVyQXRJbmRleDowXSA9PSAnLicpOworICAgICAgICBb d2hpdGVsaXN0ZWRGaWxlRXh0ZW5zaW9ucyBhZGRPYmplY3Q6W2V4dGVuc2lvbiBzdWJzdHJpbmdG cm9tSW5kZXg6MV1dOworICAgIH1dOworICAgIAorICAgIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMg YWRkT2JqZWN0c0Zyb21BcnJheTp3aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zXTsKKyAgICByZXR1 cm4gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBhbGxPYmplY3RzXTsKK30KKworLSAoTlNTdHJpbmcg KilfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24KK3sKKyAgICBOU0FycmF5PE5TU3Ry aW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBlc107Cisg ICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtzZWxmIF9h Y2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIGlmICghW2FjY2VwdGVkTUlNRVR5cGVzIGNv dW50XSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICByZXR1cm4g bmlsOworCisgICAgaWYgKCEoW2FjY2VwdGVkTUlNRVR5cGVzIGNvdW50XSA9PSAxICYmICFbYWNj ZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pKQorICAgICAgICByZXR1cm4gQCJDdXN0b20gRmls ZXMiOworCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlID0gW2FjY2VwdGVkTUlNRVR5cGVzIGZpcnN0 T2JqZWN0XTsKKyAgICBOU1JhbmdlIHJhbmdlID0gW21pbWVUeXBlIHJhbmdlT2ZTdHJpbmc6QCIv Il07CisgICAgCisgICAgaWYgKCFyYW5nZS5sZW5ndGgpCisgICAgICAgIHJldHVybiBAIkN1c3Rv bSBGaWxlcyI7CisgICAgCisgICAgTlNTdHJpbmcgKm1pbWVUeXBlUHJlZml4ID0gW21pbWVUeXBl IHN1YnN0cmluZ1RvSW5kZXg6cmFuZ2UubG9jYXRpb25dOworICAgIE5TU3RyaW5nICptaW1lVHlw ZVN1ZmZpeCA9IFttaW1lVHlwZSBzdWJzdHJpbmdGcm9tSW5kZXg6cmFuZ2UubG9jYXRpb24gKyAx XTsKKyAgICAKKyAgICBpZiAoW21pbWVUeXBlU3VmZml4IGlzRXF1YWxUb1N0cmluZzpAIioiXSkK KyAgICAgICAgcmV0dXJuIFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAlQCBGaWxlcyIs IFtbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5nVG9JbmRleDoxXSB1cHBlcmNhc2VTdHJpbmddLCBb bWltZVR5cGVQcmVmaXggc3Vic3RyaW5nRnJvbUluZGV4OjFdXTsKKworICAgIGlmIChbbWltZVR5 cGVTdWZmaXggbGVuZ3RoXSA8PSA0KQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dp dGhGb3JtYXQ6QCIlQCAlQCIsIFttaW1lVHlwZVN1ZmZpeCB1cHBlcmNhc2VTdHJpbmddLCBtaW1l VHlwZVByZWZpeF07CisKKyAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIl QCAlQCIsIG1pbWVUeXBlU3VmZml4LCBtaW1lVHlwZVByZWZpeF07Cit9CisKIEBlbmQKIAogI2Vu ZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQ YXJhbWV0ZXJzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgJKHJldmlzaW9uIDI2MjM5 NykKKysrIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFt ZXRlcnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTMxLDYgKzMxLDggQEAKIAogQHByb3Bl cnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWNj ZXB0ZWRNSU1FVHlwZXMgV0tfQVBJX0FWQUlMQUJMRShtYWNvcygxMC4xMy40KSk7CiBAcHJvcGVy dHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hY2Nl cHRlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHBy b3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpf YWxsb3dlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOwor QHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU1N0cmluZyAqX2FsbG93ZWRG aWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkp OwogCiBAZW5kCiAKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDI2MjU5MCkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDIwIEBACisyMDIwLTA2LTA0ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNh Ym91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2Vy IG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZp bHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEy NDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3Jl YXRlIGEgdmlldyB3aXRoIGFuIE5TUG9wdXBCdXR0b24gZm9yIHRoZSBmaWxlIGV4dGVuc2lvbnMg ZmlsdGVyLiBTZXQKKyAgICAgICAgdGhpcyB2aWV3IGFzIHRoZSBBY2Nlc3NvcnlWaWV3IG9mIHRo ZSBPcGVuUGFuZWwuIENyZWF0ZSBhIGN1c3RvbWl6ZWQgdGFyZ2V0CisgICAgICAgIGZvciB0aGUg TlNQb3B1cEJ1dHRvbiB0byByZXNwb25kIHRvIGNoYW5naW5nIGl0cyBzZWxlY3Rpb24uCisKKyAg ICAgICAgKiBNaW5pQnJvd3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubToKKyAg ICAgICAgKC1bRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCBpbml0V2l0aE9wZW5QYW5lbDphbGxv d2VkRmlsZUV4dGVuc2lvbnM6XSk6CisgICAgICAgICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJn ZXQgcG9wdXBBY3Rpb246XSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVy IGNyZWF0ZUZpbHRlclZpZXc6cG9wdXBUYXJnZXQ6XSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJX aW5kb3dDb250cm9sbGVyIHdlYlZpZXc6cnVuT3BlblBhbmVsV2l0aFBhcmFtZXRlcnM6aW5pdGlh dGVkQnlGcmFtZTpjb21wbGV0aW9uSGFuZGxlcjp3ZWJWaWV3OnJ1bk9wZW5QYW5lbFdpdGhQYXJh bWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6XSk6CisKIDIwMjAtMDYt MDQgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBVSVByb2Nlc3Mg bWF5IGNyYXNoIGFmdGVyIGl0cyBwcmV3YXJtZWQgV2ViUHJvY2VzcyBnZXRzIHRlcm1pbmF0ZWQK SW5kZXg6IFRvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5t Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFRvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29u dHJvbGxlci5tCShyZXZpc2lvbiAyNjIzOTcpCisrKyBUb29scy9NaW5pQnJvd3Nlci9tYWMvV0sy QnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubQkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBA QAogI2ltcG9ydCA8V2ViS2l0L1dLRnJhbWVJbmZvLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tOYXZp Z2F0aW9uQWN0aW9uUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dLTmF2aWdhdGlvbkRlbGVn YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oPgog I2ltcG9ydCA8V2ViS2l0L1dLUHJlZmVyZW5jZXNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQv V0tVSURlbGVnYXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlUHJpdmF0ZS5oPgpA QCAtNzEsNiArNzIsMzMgQEAgLSAodm9pZClwZXJmb3JtQWN0aW9uOihOU1RleHRGaW5kZXJBY3Rp bwogCiBAZW5kCiAKKy8vIFRhcmdldCBmb3IgdGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0 b24gaW4gdGhlIE9wZW5QYW5lbCdzIEFjY2Vzc29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRl bnNpb25zUG9wdXBUYXJnZXQgOiBOU09iamVjdCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVs ICpfb3BlblBhbmVsOworICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVu c2lvbnM7Cit9CitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFy Z2V0CisKKy0gKGlkKWluaXRXaXRoT3BlblBhbmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFs bG93ZWRGaWxlRXh0ZW5zaW9uczooTlNBcnJheTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0 ZW5zaW9ucyB7CisgICAgaWYgKChzZWxmID0gW3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3Bl blBhbmVsID0gb3BlblBhbmVsOworICAgICAgICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW1tO U011dGFibGVBcnJheSBhcnJheVdpdGhBcnJheTphbGxvd2VkRmlsZUV4dGVuc2lvbnNdIHJldGFp bl07CisgICAgfQorICAgIHJldHVybiBzZWxmOworfQorCistICh2b2lkKXBvcHVwQWN0aW9uOihp ZClzZW5kZXIgeworICAgIGlmICghW3NlbmRlciBpbmRleE9mU2VsZWN0ZWRJdGVtXSkKKyAgICAg ICAgW19vcGVuUGFuZWwgc2V0QWxsb3dlZEZpbGVUeXBlczpfYWxsb3dlZEZpbGVFeHRlbnNpb25z XTsKKyAgICBlbHNlCisgICAgICAgIFtfb3BlblBhbmVsIHNldEFsbG93ZWRGaWxlVHlwZXM6bmls XTsKK30KKworQGVuZAorCiBAaW50ZXJmYWNlIFdLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyICgp IDxOU1RleHRGaW5kZXJCYXJDb250YWluZXIsIFdLTmF2aWdhdGlvbkRlbGVnYXRlLCBXS1VJRGVs ZWdhdGUsIF9XS0ljb25Mb2FkaW5nRGVsZWdhdGU+CiBAZW5kCiAKQEAgLTU4Nyw2ICs2MTUsMzgg QEAgLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IHJ1bgogICAgIH1dOwogfQog CistIChudWxsYWJsZSBOU1ZpZXcgKiljcmVhdGVGaWx0ZXJWaWV3OihOU1N0cmluZyAqKWFsbG93 ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uIHBvcHVwVGFyZ2V0OihGaWxlRXh0ZW5zaW9uc1Bv cHVwVGFyZ2V0Kilwb3B1cFRhcmdldAoreworICAgIE5TVGV4dEZpZWxkKiBsYWJlbCA9IFtbTlNU ZXh0RmllbGQgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107CisgICAgW2xhYmVsIHNl dFN0cmluZ1ZhbHVlOkAiRm9ybWF0OiJdOworICAgIFtsYWJlbCBzZXRFZGl0YWJsZTpOT107Cisg ICAgW2xhYmVsIHNldFNlbGVjdGFibGU6Tk9dOworICAgIFtsYWJlbCBzZXRCb3JkZXJlZDpOT107 CisgICAgW2xhYmVsIHNldEJhY2tncm91bmRDb2xvcjpbTlNDb2xvciBjbGVhckNvbG9yXV07Cisg ICAgW2xhYmVsIHNldEFsaWdubWVudDpOU1RleHRBbGlnbm1lbnRSaWdodF07CisKKyAgICBOU1Bv cFVwQnV0dG9uICpidXR0b24gPSBbW05TUG9wVXBCdXR0b24gYWxsb2NdIGluaXRXaXRoRnJhbWU6 Q0dSZWN0WmVybyBwdWxsc0Rvd246Tk9dOworICAgIGlmIChhbGxvd2VkRmlsZUV4dGVuc2lvbnNE ZXNjcmlwdGlvbikKKyAgICAgICAgW2J1dHRvbiBhZGRJdGVtV2l0aFRpdGxlOmFsbG93ZWRGaWxl RXh0ZW5zaW9uc0Rlc2NyaXB0aW9uXTsKKyAgICBbYnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6QCJB bGwgRmlsZXMgICAgICAgICAgICAgICAgICAgICAgICAgICJdOworICAgIFtidXR0b24gc2V0VGFy Z2V0OnBvcHVwVGFyZ2V0XTsKKyAgICBbYnV0dG9uIHNldEFjdGlvbjpAc2VsZWN0b3IocG9wdXBB Y3Rpb246KV07CisgICAgW2J1dHRvbiBzZWxlY3RJdGVtQXRJbmRleDowXTsKKyAgICBbcG9wdXBU YXJnZXQgcG9wdXBBY3Rpb246YnV0dG9uXTsKKworICAgIE5TU3RhY2tWaWV3KiBob3Jpem9udGFs VmlldyA9IFtbTlNTdGFja1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107Cisg ICAgW2hvcml6b250YWxWaWV3IHNldERpc3RyaWJ1dGlvbjpOU1N0YWNrVmlld0Rpc3RyaWJ1dGlv bkZpbGxFcXVhbGx5XTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgc2V0U3BhY2luZzoyXTsKKyAgICBb aG9yaXpvbnRhbFZpZXcgYWRkQXJyYW5nZWRTdWJ2aWV3OmxhYmVsXTsKKyAgICBbaG9yaXpvbnRh bFZpZXcgYWRkQXJyYW5nZWRTdWJ2aWV3OmJ1dHRvbl07CisKKyAgICBOU1N0YWNrVmlldyogZmls dGVyVmlldyA9IFtbTlNTdGFja1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVyb107 CisgICAgW2ZpbHRlclZpZXcgc2V0T3JpZW50YXRpb246TlNVc2VySW50ZXJmYWNlTGF5b3V0T3Jp ZW50YXRpb25WZXJ0aWNhbF07CisgICAgW2ZpbHRlclZpZXcgc2V0RWRnZUluc2V0czpOU0VkZ2VJ bnNldHNNYWtlKDIwLCAyMCwgMjAsIDIwKV07CisgICAgW2ZpbHRlclZpZXcgYWRkQXJyYW5nZWRT dWJ2aWV3Omhvcml6b250YWxWaWV3XTsKKyAgICByZXR1cm4gZmlsdGVyVmlldzsKK30KKwogI2lm IF9faGFzX2ZlYXR1cmUob2JqY19nZW5lcmljcykKIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3 ICopd2ViVmlldyBydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczooV0tPcGVuUGFuZWxQYXJhbWV0 ZXJzICopcGFyYW1ldGVycyBpbml0aWF0ZWRCeUZyYW1lOihXS0ZyYW1lSW5mbyAqKWZyYW1lIGNv bXBsZXRpb25IYW5kbGVyOih2b2lkICheKShOU0FycmF5PE5TVVJMICo+ICogVVJMcykpY29tcGxl dGlvbkhhbmRsZXIKICNlbHNlCkBAIC01OTcsNiArNjU3LDExIEBAIC0gKHZvaWQpd2ViVmlldzoo V0tXZWJWaWV3ICopd2ViVmlldyBydW4KIAogICAgIG9wZW5QYW5lbC5hbGxvd3NNdWx0aXBsZVNl bGVjdGlvbiA9IHBhcmFtZXRlcnMuYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb247CiAKKyAgICBGaWxl RXh0ZW5zaW9uc1BvcHVwVGFyZ2V0ICpwb3B1cFRhcmdldCA9IFtbRmlsZUV4dGVuc2lvbnNQb3B1 cFRhcmdldCBhbGxvY10gaW5pdFdpdGhPcGVuUGFuZWw6IG9wZW5QYW5lbCBhbGxvd2VkRmlsZUV4 dGVuc2lvbnM6IHBhcmFtZXRlcnMuX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgTlNWaWV3 ICpmaWx0ZXJWaWV3ID0gW3NlbGYgY3JlYXRlRmlsdGVyVmlldzpwYXJhbWV0ZXJzLl9hbGxvd2Vk RmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbiBwb3B1cFRhcmdldDpwb3B1cFRhcmdldF07CisgICAg aWYgKGZpbHRlclZpZXcpCisgICAgICAgIFtvcGVuUGFuZWwgc2V0QWNjZXNzb3J5VmlldzpmaWx0 ZXJWaWV3XTsKKwogICAgIFtvcGVuUGFuZWwgYmVnaW5TaGVldE1vZGFsRm9yV2luZG93OndlYlZp ZXcud2luZG93IGNvbXBsZXRpb25IYW5kbGVyOl4oTlNJbnRlZ2VyIHJlc3VsdCkgewogICAgICAg ICBpZiAocmVzdWx0ID09IE5TTW9kYWxSZXNwb25zZU9LKQogICAgICAgICAgICAgY29tcGxldGlv bkhhbmRsZXIob3BlblBhbmVsLlVSTHMpOwo= 401136 2020-06-05 03:23:34 -0700 2020-06-05 14:27:13 -0700 Patch bug-212485-20200605032333.patch text/plain 18211 sabouhallawa SW5kZXg6IFNvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvUEFML0NoYW5nZUxvZwkocmV2aXNpb24gMjYyMzk3KQorKysgU291cmNlL1dlYkNv cmUvUEFML0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDIwLTA2 LTA1ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAg ICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBz aG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgRXhwb3NlIGFuIFNQSSBmcm9tIENvcmVTZXJ2Y2llcyB0 byBnZXQgYWxsIHRoZSBVVElzIGtub3duIGJ5IHRoZSBzeXN0ZW0uCisKKyAgICAgICAgKiBQQUwu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBwYWwvc3BpL2NvY29hL1VUSVBy aXZTUEkuaDogQWRkZWQuCisKIDIwMjAtMDUtMzEgIEplciBOb2JsZSAgPGplci5ub2JsZUBhcHBs ZS5jb20+CiAKICAgICAgICAgW0NvY29hXSBUcmFuc2l0aW9uIGJldHdlZW4gZW5jcnlwdGVkIGFu ZCBjbGVhciBjb2RlY3MgdGhyb3dzIGVycm9yIGZyb20gU291cmNlQnVmZmVyLmFwcGVuZEJ1ZmZl cigpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9QQUwvUEFMLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvUEFML1BBTC54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViQ29yZS9QQUwvUEFMLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTEyNCw2ICsxMjQsNyBA QAogCQk0NDUwRkNBMDIxRjVGNjAyMDA0REZBNTYgLyogUXVpY2tMb29rU29mdExpbmsuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ0NTBGQzlFMjFGNUY2 MDIwMDRERkE1NiAvKiBRdWlja0xvb2tTb2Z0TGluay5oICovOyB9OwogCQk0NEUxQThBRjIxRkE1 NEU2MDBDMzA0OEUgLyogTG9va3VwU29mdExpbmsuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ0RTFBOEFEMjFGQTU0REEwMEMzMDQ4RSAvKiBMb29rdXBT b2Z0TGluay5oICovOyB9OwogCQk0NEUxQThCMDIxRkE1NEVCMDBDMzA0OEUgLyogTG9va3VwU29m dExpbmsubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0 NEUxQThBRTIxRkE1NERBMDBDMzA0OEUgLyogTG9va3VwU29mdExpbmsubW0gKi87IH07CisJCTU1 NjcwOUFDMjQ4QTQ2N0EwMDBGMjIwOSAvKiBVVElQcml2U1BJLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1NTY3MDlBQjI0OEE0MDBGMDAwRjIyMDkgLyog VVRJUHJpdlNQSS5oICovOyB9OwogCQk1NzBBQjhGMTIwQUUyRThEMDBCOEJFODcgLyogU2VjS2V5 UHJveHlTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDU3MEFCOEYwMjBBRTJFOEQwMEI4QkU4NyAvKiBTZWNLZXlQcm94eVNQSS5oICovOyB9OwogCQk1 NzBBQjhGOTIwQUY2RTNEMDBCOEJFODcgLyogTlNYUENDb25uZWN0aW9uU1BJLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1NzBBQjhGODIwQUY2RTNEMDBC OEJFODcgLyogTlNYUENDb25uZWN0aW9uU1BJLmggKi87IH07CiAJCTU3MkExMDc4MjJCNDU2RjUw MEY0MTBDOCAvKiBBdXRoS2l0U1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1NzJBMTA3NzIyQjQ1NkY1MDBGNDEwQzggLyogQXV0aEtpdFNQSS5oICov OyB9OwpAQCAtMzA1LDYgKzMwNiw3IEBACiAJCTQ0NTBGQzlFMjFGNUY2MDIwMDRERkE1NiAvKiBR dWlja0xvb2tTb2Z0TGluay5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBRdWlj a0xvb2tTb2Z0TGluay5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NEUxQThBRDIx RkE1NERBMDBDMzA0OEUgLyogTG9va3VwU29mdExpbmsuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTG9va3Vw U29mdExpbmsuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDRFMUE4QUUyMUZBNTRE QTAwQzMwNDhFIC8qIExvb2t1cFNvZnRMaW5rLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gTG9v a3VwU29mdExpbmsubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU1NjcwOUFCMjQ4 QTQwMEYwMDBGMjIwOSAvKiBVVElQcml2U1BJLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFVUSVByaXZTUEku aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTcwQUI4RjAyMEFFMkU4RDAwQjhCRTg3 IC8qIFNlY0tleVByb3h5U1BJLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFNlY0tleVByb3h5U1BJLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTU3MEFCOEY4MjBBRjZFM0QwMEI4QkU4NyAvKiBO U1hQQ0Nvbm5lY3Rpb25TUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTlNYUENDb25uZWN0aW9uU1BJLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTU3MkExMDc3MjJCNDU2RjUwMEY0MTBDOCAv KiBBdXRoS2l0U1BJLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEF1dGhLaXRTUEkuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKQEAgLTQ3MSw2ICs0NzMsNyBAQAogCQkJCTU3MEFCOEYwMjBBRTJFOEQw MEI4QkU4NyAvKiBTZWNLZXlQcm94eVNQSS5oICovLAogCQkJCTBDMkRBMTNDMUYzQkVCNDkwMERC QzMxNyAvKiBTZXJ2ZXJzU1BJLmggKi8sCiAJCQkJMEMyREExMkIxRjNCRUI0OTAwREJDMzE3IC8q IFVSTEZvcm1hdHRpbmdTUEkuaCAqLywKKwkJCQk1NTY3MDlBQjI0OEE0MDBGMDAwRjIyMDkgLyog VVRJUHJpdlNQSS5oICovLAogCQkJCTBDMkRBMTNEMUYzQkVCNDkwMERCQzMxNyAvKiBXZWJGaWx0 ZXJFdmFsdWF0b3JTUEkuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gY29jb2E7CkBAIC04NjAsNiAr ODYzLDcgQEAKIAkJCQkwQzVBRjkyMjFGNDNBNEM3MDAyRUFDMDIgLyogVUlLaXRTUEkuaCBpbiBI ZWFkZXJzICovLAogCQkJCTBDMkRBMTQ3MUYzQkVCNDkwMERCQzMxNyAvKiBVUkxGb3JtYXR0aW5n U1BJLmggaW4gSGVhZGVycyAqLywKIAkJCQkwNzYxMURCNjI0M0ZBNUJGMDBEODA3MDQgLyogVXNh Z2VUcmFja2luZ1NvZnRMaW5rLmggaW4gSGVhZGVycyAqLywKKwkJCQk1NTY3MDlBQzI0OEE0NjdB MDAwRjIyMDkgLyogVVRJUHJpdlNQSS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEMyREExNTkxRjNC RUI0OTAwREJDMzE3IC8qIFdlYkZpbHRlckV2YWx1YXRvclNQSS5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQTEwODI2RjkxRjU3NjI5MjAwNDc3MkFDIC8qIFdlYlBhbmVsLmggaW4gSGVhZGVycyAqLywK IAkJCSk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9VVElQcml2U1BJ LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvUEFML3BhbC9zcGkvY29jb2EvVVRJUHJp dlNQSS5oCShub25leGlzdGVudCkKKysrIFNvdXJjZS9XZWJDb3JlL1BBTC9wYWwvc3BpL2NvY29h L1VUSVByaXZTUEkuaAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDQ1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBD T05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAq IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisg KiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI3ByYWdtYSBvbmNlCisKKyNpZiBVU0UoQVBQTEVfSU5URVJOQUxfU0RLKQorCisjaW1wb3J0 IDxDb3JlU2VydmljZXMvQ29yZVNlcnZpY2VzUHJpdi5oPgorCisjZWxzZQorCisjaWZkZWYgX19j cGx1c3BsdXMKK2V4dGVybiAiQyIgeworI2VuZGlmCisKK2V4dGVybgorQ0ZBcnJheVJlZiBfVVRD b3B5RGVjbGFyZWRUeXBlSWRlbnRpZmllcnModm9pZCk7CisKKyNpZmRlZiBfX2NwbHVzcGx1cwor fQorI2VuZGlmCisKKyNlbmRpZgpJbmRleDogU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYktpdC9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2MjM5NykKKysrIFNv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIw MjAtMDYtMDUgIFNhaWQgQWJvdS1IYWxsYXdhICA8c2Fib3VoYWxsYXdhQGFwcGxlLmNvbT4KKwor ICAgICAgICBbbWFjT1NdOiBUaGUgRmlsZSBQaWNrZXIgb2YgdGhlIDxpbnB1dD4gZmlsZSBlbGVt ZW50IHNob3VsZCBzaG93IHRoZSBzZWxlY3Rpb24gZmlsdGVyCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTI0ODUKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgdHdvIHByaXZhdGUgaGVscGVycyB0byBX S09wZW5QYW5lbFBhcmFtZXRlcnMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29hL1dL T3BlblBhbmVsUGFyYW1ldGVycy5tbToKKyAgICAgICAgKC1bV0tPcGVuUGFuZWxQYXJhbWV0ZXJz IF9hbGxvd2VkRmlsZUV4dGVuc2lvbnNdKToKKyAgICAgICAgUmV0dXJucyBhbiBhcnJheSBvZiBz dHJpbmdzIHJlcHJlc2VudGluZyB0aGUgYWxsb3dlZCBleHRlbnNpb25zLgorCisgICAgICAgICgt W1dLT3BlblBhbmVsUGFyYW1ldGVycyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb25d KToKKyAgICAgICAgUmV0dXJucyBhIHN0cmluZyByZXByZXNlbnRpbmcgYSBkZXNjcmlwdGlvbiBm b3IgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29j b2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oOgorCiAyMDIwLTA2LTAxICBCcmVudCBG dWxnaGFtICA8YmZ1bGdoYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFJlbW92ZSB1bnVzZWQgV2Vi Q29udGVudCBwcm9jZXNzIHNhbmRib3ggc3lzY2FsbApJbmRleDogU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5tbQo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1t CShyZXZpc2lvbiAyNjIzOTcpCisrKyBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2Ev V0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yNSwxMSArMjUsNTQg QEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1wb3J0ICJXS09wZW5QYW5lbFBhcmFtZXRlcnNJ bnRlcm5hbC5oIgorI2ltcG9ydCA8cGFsL3NwaS9jb2NvYS9VVElQcml2U1BJLmg+CiAKICNpZiBQ TEFURk9STShNQUMpCiAKICNpbXBvcnQgIldLTlNBcnJheS5oIgogCitzdGF0aWMgTlNBcnJheTxO U1N0cmluZyAqPiAqZXh0ZW5zaW9uc0Zvck1JTUVUeXBlKE5TU3RyaW5nICptaW1ldHlwZSkKK3sK KyAgICBOU1N0cmluZyAqdXRpID0gQ0ZCcmlkZ2luZ1JlbGVhc2UoVVRUeXBlQ3JlYXRlUHJlZmVy cmVkSWRlbnRpZmllckZvclRhZyhrVVRUYWdDbGFzc01JTUVUeXBlLCAoX19icmlkZ2UgQ0ZTdHJp bmdSZWYpKG1pbWV0eXBlKSwgMCkpOworICAgIHJldHVybiBDRkJyaWRnaW5nUmVsZWFzZShVVFR5 cGVDb3B5QWxsVGFnc1dpdGhDbGFzcygoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpKHV0aSksIGtVVFRh Z0NsYXNzRmlsZW5hbWVFeHRlbnNpb24pKTsKK30KKworc3RhdGljIE5TU2V0PE5TU3RyaW5nICo+ ICpleHRlbnNpb25zRm9yV2lsZGNhcmRNSU1FVHlwZShOU1N0cmluZyAqbWltZXR5cGUpCit7Cisg ICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPFJldGFpblB0cjxOU0RpY3Rpb25hcnk8TlNTdHJpbmcg KiwgTlNTZXQ8TlNTdHJpbmcgKj4gKj4+PiB3aWxkY2FyZE1JTUVUeXBlVG9FeHRlbnNpb25zOwor ICAgIHN0YXRpYyBkaXNwYXRjaF9vbmNlX3Qgb25jZVRva2VuOworCisgICAgZGlzcGF0Y2hfb25j ZSgmb25jZVRva2VuLCBeeworICAgICAgICBOU011dGFibGVEaWN0aW9uYXJ5PE5TU3RyaW5nICos IE5TTXV0YWJsZVNldDxOU1N0cmluZyAqPiAqPiAqbWFwID0gW05TTXV0YWJsZURpY3Rpb25hcnkg ZGljdGlvbmFyeV07CisKKyAgICAgICAgdm9pZCAoXmZvdW5kTUlNRVR5cGUpKE5TU3RyaW5nICpt aW1lVHlwZSwgTlNTdHJpbmcgKmV4dGVuc2lvbikgPSBeKE5TU3RyaW5nICptaW1lVHlwZSwgTlNT dHJpbmcgKmV4dGVuc2lvbikgeworICAgICAgICAgICAgTlNTdHJpbmcgKm1pbWVUeXBlV2lsZGNh cmQgPSBbW21pbWVUeXBlIGNvbXBvbmVudHNTZXBhcmF0ZWRCeVN0cmluZzpAIi8iXVswXSBzdHJp bmdCeUFwcGVuZGluZ1N0cmluZzpAIi8qIl07CisgICAgICAgICAgICBpZiAoIW1hcFttaW1lVHlw ZVdpbGRjYXJkXSkKKyAgICAgICAgICAgICAgICBtYXBbbWltZVR5cGVXaWxkY2FyZF0gPSBbTlNN dXRhYmxlU2V0IHNldF07CisgICAgICAgICAgICBbbWFwW21pbWVUeXBlV2lsZGNhcmRdIGFkZE9i amVjdDpleHRlbnNpb25dOworICAgICAgICB9OworICAgICAgICAKKyAgICAgICAgTlNBcnJheSAq YWxsVVRJcyA9IENGQnJpZGdpbmdSZWxlYXNlKF9VVENvcHlEZWNsYXJlZFR5cGVJZGVudGlmaWVy cygpKTsKKyAgICAgICAgZm9yIChOU1N0cmluZyAqdXRpIGluIGFsbFVUSXMpIHsKKyAgICAgICAg ICAgIE5TU3RyaW5nICptaW1lVHlwZSA9IENGQnJpZGdpbmdSZWxlYXNlKFVUVHlwZUNvcHlQcmVm ZXJyZWRUYWdXaXRoQ2xhc3MoKF9fYnJpZGdlIENGU3RyaW5nUmVmKSh1dGkpLCBrVVRUYWdDbGFz c01JTUVUeXBlKSk7CisgICAgICAgICAgICBpZiAoIW1pbWVUeXBlKQorICAgICAgICAgICAgICAg IGNvbnRpbnVlOworCisgICAgICAgICAgICBOU0FycmF5ICphbGxFeHRlbnNpb25zID0gQ0ZCcmlk Z2luZ1JlbGVhc2UoVVRUeXBlQ29weUFsbFRhZ3NXaXRoQ2xhc3MoKF9fYnJpZGdlIENGU3RyaW5n UmVmKSh1dGkpLCBrVVRUYWdDbGFzc0ZpbGVuYW1lRXh0ZW5zaW9uKSk7CisgICAgICAgICAgICBm b3IgKE5TU3RyaW5nICpleHRlbnNpb24gaW4gYWxsRXh0ZW5zaW9ucykgeworICAgICAgICAgICAg ICAgIGlmICghZXh0ZW5zaW9uKQorICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgICAgICAgICBmb3VuZE1JTUVUeXBlKG1pbWVUeXBlLCBleHRlbnNpb24pOworICAgICAgICAg ICAgfQorICAgICAgICB9CisKKyAgICAgICAgd2lsZGNhcmRNSU1FVHlwZVRvRXh0ZW5zaW9ucy5n ZXQoKSA9IFttYXAgY29weV07CisgICAgfSk7CisKKyAgICBBU1NFUlQoW21pbWV0eXBlIGNoYXJh Y3RlckF0SW5kZXg6W21pbWV0eXBlIGxlbmd0aF0gLSAxXSA9PSAnKicpOworICAgIHJldHVybiBb d2lsZGNhcmRNSU1FVHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSBvYmplY3RGb3JLZXk6bWltZXR5cGVd OworfQorCiBAaW1wbGVtZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wp YWxsb3dzTXVsdGlwbGVTZWxlY3Rpb24KQEAgLTYzLDYgKzEwNiw2MCBAQCAtIChOU0FycmF5PE5T U3RyaW5nICo+ICopX2FjY2VwdGVkRmlsZUV4CiAgICAgcmV0dXJuIHdyYXBwZXIoX29wZW5QYW5l bFBhcmFtZXRlcnMtPmFjY2VwdEZpbGVFeHRlbnNpb25zKCkpOwogfQogCistIChOU0FycmF5PE5T U3RyaW5nICo+ICopX2FsbG93ZWRGaWxlRXh0ZW5zaW9ucworeworICAgIC8vIEFnZ3JlZ2F0ZSBl eHRlbnNpb25zIGJhc2VkIG9uIHNwZWNpZmllZCBNSU1FIHR5cGVzLgorICAgIE5TQXJyYXk8TlNT dHJpbmcgKj4gKmFjY2VwdGVkTUlNRVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5cGVzXTsK KyAgICBOU0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZEZpbGVFeHRlbnNpb25zID0gW3NlbGYg X2FjY2VwdGVkRmlsZUV4dGVuc2lvbnNdOworCisgICAgTlNNdXRhYmxlU2V0PE5TU3RyaW5nICo+ ICphbGxvd2VkRmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlU2V0IHNldF07CisKKyAgICBbYWNj ZXB0ZWRNSU1FVHlwZXMgZW51bWVyYXRlT2JqZWN0c1VzaW5nQmxvY2s6XihOU1N0cmluZyAqbWlt ZVR5cGUsIE5TVUludGVnZXIgaW5kZXgsIEJPT0wqIHN0b3ApIHsKKyAgICAgICAgaWYgKFttaW1l VHlwZSBoYXNTdWZmaXg6QCIqIl0pCisgICAgICAgICAgICBbYWxsb3dlZEZpbGVFeHRlbnNpb25z IHVuaW9uU2V0OmV4dGVuc2lvbnNGb3JXaWxkY2FyZE1JTUVUeXBlKG1pbWVUeXBlKV07CisgICAg ICAgIGVsc2UKKyAgICAgICAgICAgIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMgYWRkT2JqZWN0c0Zy b21BcnJheTpleHRlbnNpb25zRm9yTUlNRVR5cGUobWltZVR5cGUpXTsKKyAgICB9XTsKKworICAg IE5TTXV0YWJsZUFycmF5PE5TU3RyaW5nICo+ICp3aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zID0g W05TTXV0YWJsZUFycmF5IGFycmF5XTsKKyAgICBbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBlbnVt ZXJhdGVPYmplY3RzVXNpbmdCbG9jazpeKE5TU3RyaW5nICpleHRlbnNpb24sIE5TVUludGVnZXIg aW5kZXgsIEJPT0wgKnN0b3ApIHsKKyAgICAgICAgQVNTRVJUKFtleHRlbnNpb24gY2hhcmFjdGVy QXRJbmRleDowXSA9PSAnLicpOworICAgICAgICBbd2hpdGVsaXN0ZWRGaWxlRXh0ZW5zaW9ucyBh ZGRPYmplY3Q6W2V4dGVuc2lvbiBzdWJzdHJpbmdGcm9tSW5kZXg6MV1dOworICAgIH1dOworICAg IAorICAgIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMgYWRkT2JqZWN0c0Zyb21BcnJheTp3aGl0ZWxp c3RlZEZpbGVFeHRlbnNpb25zXTsKKyAgICByZXR1cm4gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBh bGxPYmplY3RzXTsKK30KKworLSAoTlNTdHJpbmcgKilfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVz Y3JpcHRpb24KK3sKKyAgICBOU0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9 IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBlc107CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNj ZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtzZWxmIF9hY2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKwor ICAgIGlmICghW2FjY2VwdGVkTUlNRVR5cGVzIGNvdW50XSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVu c2lvbnMgY291bnRdKQorICAgICAgICByZXR1cm4gbmlsOworCisgICAgaWYgKCEoW2FjY2VwdGVk TUlNRVR5cGVzIGNvdW50XSA9PSAxICYmICFbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0p KQorICAgICAgICByZXR1cm4gQCJDdXN0b20gRmlsZXMiOworCisgICAgTlNTdHJpbmcgKm1pbWVU eXBlID0gW2FjY2VwdGVkTUlNRVR5cGVzIGZpcnN0T2JqZWN0XTsKKyAgICBOU1JhbmdlIHJhbmdl ID0gW21pbWVUeXBlIHJhbmdlT2ZTdHJpbmc6QCIvIl07CisgICAgCisgICAgaWYgKCFyYW5nZS5s ZW5ndGgpCisgICAgICAgIHJldHVybiBAIkN1c3RvbSBGaWxlcyI7CisgICAgCisgICAgTlNTdHJp bmcgKm1pbWVUeXBlUHJlZml4ID0gW21pbWVUeXBlIHN1YnN0cmluZ1RvSW5kZXg6cmFuZ2UubG9j YXRpb25dOworICAgIE5TU3RyaW5nICptaW1lVHlwZVN1ZmZpeCA9IFttaW1lVHlwZSBzdWJzdHJp bmdGcm9tSW5kZXg6cmFuZ2UubG9jYXRpb24gKyAxXTsKKyAgICAKKyAgICBpZiAoW21pbWVUeXBl U3VmZml4IGlzRXF1YWxUb1N0cmluZzpAIioiXSkKKyAgICAgICAgcmV0dXJuIFtOU1N0cmluZyBz dHJpbmdXaXRoRm9ybWF0OkAiJUAlQCBGaWxlcyIsIFtbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5n VG9JbmRleDoxXSB1cHBlcmNhc2VTdHJpbmddLCBbbWltZVR5cGVQcmVmaXggc3Vic3RyaW5nRnJv bUluZGV4OjFdXTsKKworICAgIGlmIChbbWltZVR5cGVTdWZmaXggbGVuZ3RoXSA8PSA0KQorICAg ICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCAlQCIsIFttaW1lVHlw ZVN1ZmZpeCB1cHBlcmNhc2VTdHJpbmddLCBtaW1lVHlwZVByZWZpeF07CisKKyAgICByZXR1cm4g W05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCAlQCIsIG1pbWVUeXBlU3VmZml4LCBtaW1l VHlwZVByZWZpeF07Cit9CisKIEBlbmQKIAogI2VuZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFt ZXRlcnNQcml2YXRlLmgJKHJldmlzaW9uIDI2MjM5NykKKysrIFNvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgJKHdvcmtpbmcgY29w eSkKQEAgLTMxLDYgKzMxLDggQEAKIAogQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBj b3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWNjZXB0ZWRNSU1FVHlwZXMgV0tfQVBJX0FWQUlM QUJMRShtYWNvcygxMC4xMy40KSk7CiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNv cHkpIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hY2NlcHRlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9B VkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5 LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zIFdLX0FQ SV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRv bmx5LCBjb3B5KSBOU1N0cmluZyAqX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uIFdL X0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOwogCiBAZW5kCiAKSW5kZXg6IFRvb2xzL0No YW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2MjYwOSkK KysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIwIEBACisyMDIw LTA2LTA1ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAg ICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVu dCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3JlYXRlIGEgdmlldyB3aXRoIGFuIE5TUG9wdXBC dXR0b24gZm9yIHRoZSBmaWxlIGV4dGVuc2lvbnMgZmlsdGVyLiBTZXQKKyAgICAgICAgdGhpcyB2 aWV3IGFzIHRoZSBBY2Nlc3NvcnlWaWV3IG9mIHRoZSBPcGVuUGFuZWwuIENyZWF0ZSBhIGN1c3Rv bWl6ZWQgdGFyZ2V0CisgICAgICAgIGZvciB0aGUgTlNQb3B1cEJ1dHRvbiB0byByZXNwb25kIHRv IGNoYW5naW5nIGl0cyBzZWxlY3Rpb24uCisKKyAgICAgICAgKiBNaW5pQnJvd3Nlci9tYWMvV0sy QnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubToKKyAgICAgICAgKC1bRmlsZUV4dGVuc2lvbnNQb3B1 cFRhcmdldCBpbml0V2l0aE9wZW5QYW5lbDphbGxvd2VkRmlsZUV4dGVuc2lvbnM6XSk6CisgICAg ICAgICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgcG9wdXBBY3Rpb246XSk6CisgICAgICAg ICgtW1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyIGNyZWF0ZUZpbHRlclZpZXc6cG9wdXBUYXJn ZXQ6XSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyIHdlYlZpZXc6cnVu T3BlblBhbmVsV2l0aFBhcmFtZXRlcnM6aW5pdGlhdGVkQnlGcmFtZTpjb21wbGV0aW9uSGFuZGxl cjp3ZWJWaWV3OnJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29t cGxldGlvbkhhbmRsZXI6XSk6CisKIDIwMjAtMDYtMDUgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8 Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIE1pbmlCcm93c2VyOiB1c2UgR0Fj dGlvbiBBUEkgZm9yIGFjdGlvbnMgYW5kIHNob3J0Y3V0cyBpbiBwcmVwYXJhdGlvbiBmb3IgR1RL NApJbmRleDogVG9vbHMvTWluaUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVy Lm0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gVG9vbHMvTWluaUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dD b250cm9sbGVyLm0JKHJldmlzaW9uIDI2MjM5NykKKysrIFRvb2xzL01pbmlCcm93c2VyL21hYy9X SzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCSh3b3JraW5nIGNvcHkpCkBAIC0zMCw2ICszMCw3 IEBACiAjaW1wb3J0IDxXZWJLaXQvV0tGcmFtZUluZm8uaD4KICNpbXBvcnQgPFdlYktpdC9XS05h dmlnYXRpb25BY3Rpb25Qcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tOYXZpZ2F0aW9uRGVs ZWdhdGUuaD4KKyNpbXBvcnQgPFdlYktpdC9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmg+ CiAjaW1wb3J0IDxXZWJLaXQvV0tQcmVmZXJlbmNlc1ByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktp dC9XS1VJRGVsZWdhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XS1VJRGVsZWdhdGVQcml2YXRlLmg+ CkBAIC03MSw2ICs3MiwzMyBAQCAtICh2b2lkKXBlcmZvcm1BY3Rpb246KE5TVGV4dEZpbmRlckFj dGlvCiAKIEBlbmQKIAorLy8gVGFyZ2V0IGZvciB0aGUgRmlsZUV4dGVuc2lvbnMgTlNQb3B1cEJ1 dHRvbiBpbiB0aGUgT3BlblBhbmVsJ3MgQWNjZXNzb3J5Vmlldy4KK0BpbnRlcmZhY2UgRmlsZUV4 dGVuc2lvbnNQb3B1cFRhcmdldCA6IE5TT2JqZWN0IHsKK0Bwcml2YXRlCisgICAgTlNPcGVuUGFu ZWwgKl9vcGVuUGFuZWw7CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqX2FsbG93ZWRGaWxlRXh0 ZW5zaW9uczsKK30KK0BlbmQKKworQGltcGxlbWVudGF0aW9uIEZpbGVFeHRlbnNpb25zUG9wdXBU YXJnZXQKKworLSAoaWQpaW5pdFdpdGhPcGVuUGFuZWw6KE5TT3BlblBhbmVsKilvcGVuUGFuZWwg YWxsb3dlZEZpbGVFeHRlbnNpb25zOihOU0FycmF5PE5TU3RyaW5nICo+ICopYWxsb3dlZEZpbGVF eHRlbnNpb25zIHsKKyAgICBpZiAoKHNlbGYgPSBbc3VwZXIgaW5pdF0pKSB7CisgICAgICAgIF9v cGVuUGFuZWwgPSBvcGVuUGFuZWw7CisgICAgICAgIF9hbGxvd2VkRmlsZUV4dGVuc2lvbnMgPSBb W05TTXV0YWJsZUFycmF5IGFycmF5V2l0aEFycmF5OmFsbG93ZWRGaWxlRXh0ZW5zaW9uc10gcmV0 YWluXTsKKyAgICB9CisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpcG9wdXBBY3Rpb246 KGlkKXNlbmRlciB7CisgICAgaWYgKCFbc2VuZGVyIGluZGV4T2ZTZWxlY3RlZEl0ZW1dKQorICAg ICAgICBbX29wZW5QYW5lbCBzZXRBbGxvd2VkRmlsZVR5cGVzOl9hbGxvd2VkRmlsZUV4dGVuc2lv bnNdOworICAgIGVsc2UKKyAgICAgICAgW19vcGVuUGFuZWwgc2V0QWxsb3dlZEZpbGVUeXBlczpu aWxdOworfQorCitAZW5kCisKIEBpbnRlcmZhY2UgV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIg KCkgPE5TVGV4dEZpbmRlckJhckNvbnRhaW5lciwgV0tOYXZpZ2F0aW9uRGVsZWdhdGUsIFdLVUlE ZWxlZ2F0ZSwgX1dLSWNvbkxvYWRpbmdEZWxlZ2F0ZT4KIEBlbmQKIApAQCAtNTg3LDYgKzYxNSwz OCBAQCAtICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgcnVuCiAgICAgfV07CiB9 CiAKKy0gKG51bGxhYmxlIE5TVmlldyAqKWNyZWF0ZUZpbHRlclZpZXc6KE5TU3RyaW5nICopYWxs b3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24gcG9wdXBUYXJnZXQ6KEZpbGVFeHRlbnNpb25z UG9wdXBUYXJnZXQqKXBvcHVwVGFyZ2V0Cit7CisgICAgTlNUZXh0RmllbGQqIGxhYmVsID0gW1tO U1RleHRGaWVsZCBhbGxvY10gaW5pdFdpdGhGcmFtZTpDR1JlY3RaZXJvXTsKKyAgICBbbGFiZWwg c2V0U3RyaW5nVmFsdWU6QCJGb3JtYXQ6Il07CisgICAgW2xhYmVsIHNldEVkaXRhYmxlOk5PXTsK KyAgICBbbGFiZWwgc2V0U2VsZWN0YWJsZTpOT107CisgICAgW2xhYmVsIHNldEJvcmRlcmVkOk5P XTsKKyAgICBbbGFiZWwgc2V0QmFja2dyb3VuZENvbG9yOltOU0NvbG9yIGNsZWFyQ29sb3JdXTsK KyAgICBbbGFiZWwgc2V0QWxpZ25tZW50Ok5TVGV4dEFsaWdubWVudFJpZ2h0XTsKKworICAgIE5T UG9wVXBCdXR0b24gKmJ1dHRvbiA9IFtbTlNQb3BVcEJ1dHRvbiBhbGxvY10gaW5pdFdpdGhGcmFt ZTpDR1JlY3RaZXJvIHB1bGxzRG93bjpOT107CisgICAgaWYgKGFsbG93ZWRGaWxlRXh0ZW5zaW9u c0Rlc2NyaXB0aW9uKQorICAgICAgICBbYnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6YWxsb3dlZEZp bGVFeHRlbnNpb25zRGVzY3JpcHRpb25dOworICAgIFtidXR0b24gYWRkSXRlbVdpdGhUaXRsZTpA IkFsbCBGaWxlcyAgICAgICAgICAgICAgICAgICAgICAgICAgIl07CisgICAgW2J1dHRvbiBzZXRU YXJnZXQ6cG9wdXBUYXJnZXRdOworICAgIFtidXR0b24gc2V0QWN0aW9uOkBzZWxlY3Rvcihwb3B1 cEFjdGlvbjopXTsKKyAgICBbYnV0dG9uIHNlbGVjdEl0ZW1BdEluZGV4OjBdOworICAgIFtwb3B1 cFRhcmdldCBwb3B1cEFjdGlvbjpidXR0b25dOworCisgICAgTlNTdGFja1ZpZXcqIGhvcml6b250 YWxWaWV3ID0gW1tOU1N0YWNrVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpDR1JlY3RaZXJvXTsK KyAgICBbaG9yaXpvbnRhbFZpZXcgc2V0RGlzdHJpYnV0aW9uOk5TU3RhY2tWaWV3RGlzdHJpYnV0 aW9uRmlsbEVxdWFsbHldOworICAgIFtob3Jpem9udGFsVmlldyBzZXRTcGFjaW5nOjJdOworICAg IFtob3Jpem9udGFsVmlldyBhZGRBcnJhbmdlZFN1YnZpZXc6bGFiZWxdOworICAgIFtob3Jpem9u dGFsVmlldyBhZGRBcnJhbmdlZFN1YnZpZXc6YnV0dG9uXTsKKworICAgIE5TU3RhY2tWaWV3KiBm aWx0ZXJWaWV3ID0gW1tOU1N0YWNrVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpDR1JlY3RaZXJv XTsKKyAgICBbZmlsdGVyVmlldyBzZXRPcmllbnRhdGlvbjpOU1VzZXJJbnRlcmZhY2VMYXlvdXRP cmllbnRhdGlvblZlcnRpY2FsXTsKKyAgICBbZmlsdGVyVmlldyBzZXRFZGdlSW5zZXRzOk5TRWRn ZUluc2V0c01ha2UoMjAsIDIwLCAyMCwgMjApXTsKKyAgICBbZmlsdGVyVmlldyBhZGRBcnJhbmdl ZFN1YnZpZXc6aG9yaXpvbnRhbFZpZXddOworICAgIHJldHVybiBmaWx0ZXJWaWV3OworfQorCiAj aWYgX19oYXNfZmVhdHVyZShvYmpjX2dlbmVyaWNzKQogLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZp ZXcgKil3ZWJWaWV3IHJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOihXS09wZW5QYW5lbFBhcmFt ZXRlcnMgKilwYXJhbWV0ZXJzIGluaXRpYXRlZEJ5RnJhbWU6KFdLRnJhbWVJbmZvICopZnJhbWUg Y29tcGxldGlvbkhhbmRsZXI6KHZvaWQgKF4pKE5TQXJyYXk8TlNVUkwgKj4gKiBVUkxzKSljb21w bGV0aW9uSGFuZGxlcgogI2Vsc2UKQEAgLTU5Nyw2ICs2NTcsMTEgQEAgLSAodm9pZCl3ZWJWaWV3 OihXS1dlYlZpZXcgKil3ZWJWaWV3IHJ1bgogCiAgICAgb3BlblBhbmVsLmFsbG93c011bHRpcGxl U2VsZWN0aW9uID0gcGFyYW1ldGVycy5hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbjsKIAorICAgIEZp bGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgKnBvcHVwVGFyZ2V0ID0gW1tGaWxlRXh0ZW5zaW9uc1Bv cHVwVGFyZ2V0IGFsbG9jXSBpbml0V2l0aE9wZW5QYW5lbDogb3BlblBhbmVsIGFsbG93ZWRGaWxl RXh0ZW5zaW9uczogcGFyYW1ldGVycy5fYWxsb3dlZEZpbGVFeHRlbnNpb25zXTsKKyAgICBOU1Zp ZXcgKmZpbHRlclZpZXcgPSBbc2VsZiBjcmVhdGVGaWx0ZXJWaWV3OnBhcmFtZXRlcnMuX2FsbG93 ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uIHBvcHVwVGFyZ2V0OnBvcHVwVGFyZ2V0XTsKKyAg ICBpZiAoZmlsdGVyVmlldykKKyAgICAgICAgW29wZW5QYW5lbCBzZXRBY2Nlc3NvcnlWaWV3OmZp bHRlclZpZXddOworCiAgICAgW29wZW5QYW5lbCBiZWdpblNoZWV0TW9kYWxGb3JXaW5kb3c6d2Vi Vmlldy53aW5kb3cgY29tcGxldGlvbkhhbmRsZXI6XihOU0ludGVnZXIgcmVzdWx0KSB7CiAgICAg ICAgIGlmIChyZXN1bHQgPT0gTlNNb2RhbFJlc3BvbnNlT0spCiAgICAgICAgICAgICBjb21wbGV0 aW9uSGFuZGxlcihvcGVuUGFuZWwuVVJMcyk7Cg== 401198 2020-06-05 14:27:15 -0700 2020-06-05 15:14:41 -0700 Patch bug-212485-20200605142714.patch text/plain 20205 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q QUwvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCAxYjgwMTQ5 OTVlMDY5YWQzMGI5MWRhYzg0ZmRiNDNiMmFjMDRlODcwLi5iZjJmNjJiZTM1MTdmZmNlN2U2Yzg3 MmE2OTQ0Mzk1MTI1YzdhMjZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAor MjAyMC0wNi0wNSAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgor CisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0PiBmaWxlIGVs ZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4cG9zZSBhbiBTUEkgZnJvbSBDb3JlU2Vy dmNpZXMgdG8gZ2V0IGFsbCB0aGUgVVRJcyBrbm93biBieSB0aGUgc3lzdGVtLgorCisgICAgICAg ICogUEFMLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogcGFsL3NwaS9jb2Nv YS9VVElQcml2U1BJLmg6IEFkZGVkLgorCiAyMDIwLTA2LTA1ICBBbmR5IEVzdGVzICA8YWVzdGVz QGFwcGxlLmNvbT4KIAogICAgICAgICBbQXBwbGUgUGF5XSBSZW1vdmUgY29uZGl0aW9uYWxzIGZv ciBFTkFCTEVfQVBQTEVfUEFZX1NFU1NJT05fVigzfDQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDNhYTMzYWQ5MWFm OTlhYmVhOGE2OGYwZmI0MTY5ZTBmYWE4NTY2OTIuLmI1MGQ4M2VmMmViMjliOTRkOWUxNjQyNTAx NTVjZjVjNGE5YjA0N2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjAtMDYtMDUgIFNh aWQgQWJvdS1IYWxsYXdhICA8c2Fib3VoYWxsYXdhQGFwcGxlLmNvbT4KKworICAgICAgICBbbWFj T1NdOiBUaGUgRmlsZSBQaWNrZXIgb2YgdGhlIDxpbnB1dD4gZmlsZSBlbGVtZW50IHNob3VsZCBz aG93IHRoZSBzZWxlY3Rpb24gZmlsdGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMTI0ODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgdHdvIHByaXZhdGUgaGVscGVycyB0byBXS09wZW5QYW5lbFBh cmFtZXRlcnMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFy YW1ldGVycy5tbToKKyAgICAgICAgKC1bV0tPcGVuUGFuZWxQYXJhbWV0ZXJzIF9hbGxvd2VkRmls ZUV4dGVuc2lvbnNdKToKKyAgICAgICAgUmV0dXJucyBhbiBhcnJheSBvZiBzdHJpbmdzIHJlcHJl c2VudGluZyB0aGUgYWxsb3dlZCBleHRlbnNpb25zLgorCisgICAgICAgICgtW1dLT3BlblBhbmVs UGFyYW1ldGVycyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb25dKToKKyAgICAgICAg UmV0dXJucyBhIHN0cmluZyByZXByZXNlbnRpbmcgYSBkZXNjcmlwdGlvbiBmb3IgdGhlIGFsbG93 ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFu ZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oOgorCiAyMDIwLTA2LTA1ICBBZHJpYW4gUGVyZXogZGUgQ2Fz dHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgTm9uLXVuaWZpZWQgYnVpbGQgZml4 ZXMsIGVhcmx5IHN1bW1lciAyMDIwIGVkaXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L1BBTC9QQUwueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1BBTC9Q QUwueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA1YjAyYjUxMzAwYTRkMGNkNWQ5ZDgy ZTgyYjRmMGNiNzdiZGI2NmYzLi5iZTRkZmEwODQwMDdjNDZiYmNiZTZlNGUzY2FiMGQzMDJlNzll MWUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvUEFMLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML1BBTC54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCkBAIC0xMjcsNiArMTI3LDcgQEAKIAkJNDQ1MEZDQTAyMUY1RjYwMjAwNERGQTU2IC8q IFF1aWNrTG9va1NvZnRMaW5rLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA0NDUwRkM5RTIxRjVGNjAyMDA0REZBNTYgLyogUXVpY2tMb29rU29mdExpbmsu aCAqLzsgfTsKIAkJNDRFMUE4QUYyMUZBNTRFNjAwQzMwNDhFIC8qIExvb2t1cFNvZnRMaW5rLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NEUxQThBRDIx RkE1NERBMDBDMzA0OEUgLyogTG9va3VwU29mdExpbmsuaCAqLzsgfTsKIAkJNDRFMUE4QjAyMUZB NTRFQjAwQzMwNDhFIC8qIExvb2t1cFNvZnRMaW5rLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDRFMUE4QUUyMUZBNTREQTAwQzMwNDhFIC8qIExvb2t1 cFNvZnRMaW5rLm1tICovOyB9OworCQk1NTY3MDlBQzI0OEE0NjdBMDAwRjIyMDkgLyogVVRJUHJp dlNQSS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTU2 NzA5QUIyNDhBNDAwRjAwMEYyMjA5IC8qIFVUSVByaXZTUEkuaCAqLzsgfTsKIAkJNTcwQUI4RjEy MEFFMkU4RDAwQjhCRTg3IC8qIFNlY0tleVByb3h5U1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1NzBBQjhGMDIwQUUyRThEMDBCOEJFODcgLyogU2Vj S2V5UHJveHlTUEkuaCAqLzsgfTsKIAkJNTcwQUI4RjkyMEFGNkUzRDAwQjhCRTg3IC8qIE5TWFBD Q29ubmVjdGlvblNQSS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNTcwQUI4RjgyMEFGNkUzRDAwQjhCRTg3IC8qIE5TWFBDQ29ubmVjdGlvblNQSS5oICov OyB9OwogCQk1NzJBMTA3ODIyQjQ1NkY1MDBGNDEwQzggLyogQXV0aEtpdFNQSS5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTcyQTEwNzcyMkI0NTZGNTAw RjQxMEM4IC8qIEF1dGhLaXRTUEkuaCAqLzsgfTsKQEAgLTMxMiw2ICszMTMsNyBAQAogCQk0NDUw RkM5RTIxRjVGNjAyMDA0REZBNTYgLyogUXVpY2tMb29rU29mdExpbmsuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gUXVpY2tMb29rU29mdExpbmsuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJNDRFMUE4QUQyMUZBNTREQTAwQzMwNDhFIC8qIExvb2t1cFNvZnRMaW5r LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IExvb2t1cFNvZnRMaW5rLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ0RTFBOEFFMjFGQTU0REEwMEMzMDQ4RSAvKiBMb29rdXBTb2Z0TGluay5tbSAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLm9iamNwcDsgcGF0aCA9IExvb2t1cFNvZnRMaW5rLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OworCQk1NTY3MDlBQjI0OEE0MDBGMDAwRjIyMDkgLyogVVRJUHJpdlNQSS5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBVVElQcml2U1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTU3MEFCOEYwMjBBRTJFOEQwMEI4QkU4NyAvKiBTZWNLZXlQcm94eVNQSS5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTZWNLZXlQcm94eVNQSS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1NzBB QjhGODIwQUY2RTNEMDBCOEJFODcgLyogTlNYUENDb25uZWN0aW9uU1BJLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IE5TWFBDQ29ubmVjdGlvblNQSS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1 NzJBMTA3NzIyQjQ1NkY1MDBGNDEwQzggLyogQXV0aEtpdFNQSS5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBB dXRoS2l0U1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC00NzgsNiArNDgwLDcg QEAKIAkJCQk1NzBBQjhGMDIwQUUyRThEMDBCOEJFODcgLyogU2VjS2V5UHJveHlTUEkuaCAqLywK IAkJCQkwQzJEQTEzQzFGM0JFQjQ5MDBEQkMzMTcgLyogU2VydmVyc1NQSS5oICovLAogCQkJCTBD MkRBMTJCMUYzQkVCNDkwMERCQzMxNyAvKiBVUkxGb3JtYXR0aW5nU1BJLmggKi8sCisJCQkJNTU2 NzA5QUIyNDhBNDAwRjAwMEYyMjA5IC8qIFVUSVByaXZTUEkuaCAqLywKIAkJCQkwQzJEQTEzRDFG M0JFQjQ5MDBEQkMzMTcgLyogV2ViRmlsdGVyRXZhbHVhdG9yU1BJLmggKi8sCiAJCQkpOwogCQkJ cGF0aCA9IGNvY29hOwpAQCAtODcyLDYgKzg3NSw3IEBACiAJCQkJMEM1QUY5MjIxRjQzQTRDNzAw MkVBQzAyIC8qIFVJS2l0U1BJLmggaW4gSGVhZGVycyAqLywKIAkJCQkwQzJEQTE0NzFGM0JFQjQ5 MDBEQkMzMTcgLyogVVJMRm9ybWF0dGluZ1NQSS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMDc2MTFE QjYyNDNGQTVCRjAwRDgwNzA0IC8qIFVzYWdlVHJhY2tpbmdTb2Z0TGluay5oIGluIEhlYWRlcnMg Ki8sCisJCQkJNTU2NzA5QUMyNDhBNDY3QTAwMEYyMjA5IC8qIFVUSVByaXZTUEkuaCBpbiBIZWFk ZXJzICovLAogCQkJCTBDMkRBMTU5MUYzQkVCNDkwMERCQzMxNyAvKiBXZWJGaWx0ZXJFdmFsdWF0 b3JTUEkuaCBpbiBIZWFkZXJzICovLAogCQkJCUExMDgyNkY5MUY1NzYyOTIwMDQ3NzJBQyAvKiBX ZWJQYW5lbC5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwpAQCAtOTgwLDcgKzk4NCw2IEBACiAJCQkJ NDRFMUE4QjAyMUZBNTRFQjAwQzMwNDhFIC8qIExvb2t1cFNvZnRMaW5rLm1tIGluIFNvdXJjZXMg Ki8sCiAJCQkJNUM3Qzc4NzQyM0FDM0U3NzAwNjVGNDdFIC8qIE1hbmFnZWRDb25maWd1cmF0aW9u U29mdExpbmsubW0gaW4gU291cmNlcyAqLywKIAkJCQkwQ0Y5OUNBNDFGNzM2Mzc1MDA3RUU3OTMg LyogTWVkaWFUaW1lQVZGb3VuZGF0aW9uLmNwcCBpbiBTb3VyY2VzICovLAotCQkJCTQxRTFGMzQ0 MjQ4QTZBMDAwMDIyRDVERSAvKiBWaWRlb1Rvb2xib3hTb2Z0TGluay5jcHAgaW4gU291cmNlcyAq LywKIAkJCQlDREFDQjM2MDIzODc0MjVCMDAxOEQ3Q0UgLyogTWVkaWFUb29sYm94U29mdExpbmsu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTFGNjNDQTAyMUE0REJGNzAwNkZCNDNCIC8qIFBhc3NL aXRTb2Z0TGluay5tbSBpbiBTb3VyY2VzICovLAogCQkJCUExMTc1QjRGMUY2QjMzNzMwMEM0QjlG MCAvKiBQb3B1cE1lbnUubW0gaW4gU291cmNlcyAqLywKQEAgLTk5NCw2ICs5OTcsNyBAQAogCQkJ CUEzQUI2RTY1MUYzRDIxN0YwMDlDMTRCMSAvKiBTeXN0ZW1TbGVlcExpc3RlbmVyTWFjLm1tIGlu IFNvdXJjZXMgKi8sCiAJCQkJMkUxMzQyQ0QyMTVBQTEwQTAwNzE5OUQyIC8qIFVJS2l0U29mdExp bmsubW0gaW4gU291cmNlcyAqLywKIAkJCQkwNzYxMURCNzI0M0ZBNUJGMDBEODA3MDQgLyogVXNh Z2VUcmFja2luZ1NvZnRMaW5rLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJNDFFMUYzNDQyNDhBNkEw MDAwMjJENURFIC8qIFZpZGVvVG9vbGJveFNvZnRMaW5rLmNwcCBpbiBTb3VyY2VzICovLAogCQkJ CUExMDgyNkZBMUY1NzYyOTIwMDQ3NzJBQyAvKiBXZWJQYW5lbC5tbSBpbiBTb3VyY2VzICovLAog CQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9zcGkvY29jb2EvVVRJUHJpdlNQSS5oIGIvU291 cmNlL1dlYkNvcmUvUEFML3BhbC9zcGkvY29jb2EvVVRJUHJpdlNQSS5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNj NmJjZmFjNmQ3Y2Y1ZjgyZDNhY2U4ZTFiNjBjMTUyNzY4YzYwOGEKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9VVElQcml2U1BJLmgKQEAgLTAsMCAr MSw0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6Cisg KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBB UFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IK KyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisg KiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgVVNFKEFQUExFX0lOVEVS TkFMX1NESykKKworI2ltcG9ydCA8Q29yZVNlcnZpY2VzL0NvcmVTZXJ2aWNlc1ByaXYuaD4KKwor I2Vsc2UKKworI2lmZGVmIF9fY3BsdXNwbHVzCitleHRlcm4gIkMiIHsKKyNlbmRpZgorCitleHRl cm4KK0NGQXJyYXlSZWYgX1VUQ29weURlY2xhcmVkVHlwZUlkZW50aWZpZXJzKHZvaWQpOworCisj aWZkZWYgX19jcGx1c3BsdXMKK30KKyNlbmRpZgorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnMubW0gYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1t CmluZGV4IDhlMGM4ZWVkMGI5YWFlN2JlZmQ0YTk2MWMwOGQyZTYwYWY2NjZhNzAuLmUwMzQ1NjUz MjUzMmZjNGM4MWE3OTMzNzNkY2EwYWU1ZGFjZWJiOTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnMubW0KKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5tbQpA QCAtMjUsMTEgKzI1LDU0IEBACiAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiV0tPcGVu UGFuZWxQYXJhbWV0ZXJzSW50ZXJuYWwuaCIKKyNpbXBvcnQgPHBhbC9zcGkvY29jb2EvVVRJUHJp dlNQSS5oPgogCiAjaWYgUExBVEZPUk0oTUFDKQogCiAjaW1wb3J0ICJXS05TQXJyYXkuaCIKIAor c3RhdGljIE5TQXJyYXk8TlNTdHJpbmcgKj4gKmV4dGVuc2lvbnNGb3JNSU1FVHlwZShOU1N0cmlu ZyAqbWltZXR5cGUpCit7CisgICAgTlNTdHJpbmcgKnV0aSA9IENGQnJpZGdpbmdSZWxlYXNlKFVU VHlwZUNyZWF0ZVByZWZlcnJlZElkZW50aWZpZXJGb3JUYWcoa1VUVGFnQ2xhc3NNSU1FVHlwZSwg KF9fYnJpZGdlIENGU3RyaW5nUmVmKShtaW1ldHlwZSksIDApKTsKKyAgICByZXR1cm4gQ0ZCcmlk Z2luZ1JlbGVhc2UoVVRUeXBlQ29weUFsbFRhZ3NXaXRoQ2xhc3MoKF9fYnJpZGdlIENGU3RyaW5n UmVmKSh1dGkpLCBrVVRUYWdDbGFzc0ZpbGVuYW1lRXh0ZW5zaW9uKSk7Cit9CisKK3N0YXRpYyBO U1NldDxOU1N0cmluZyAqPiAqZXh0ZW5zaW9uc0ZvcldpbGRjYXJkTUlNRVR5cGUoTlNTdHJpbmcg Km1pbWV0eXBlKQoreworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRhaW5QdHI8TlNEaWN0 aW9uYXJ5PE5TU3RyaW5nICosIE5TU2V0PE5TU3RyaW5nICo+ICo+Pj4gd2lsZGNhcmRNSU1FVHlw ZVRvRXh0ZW5zaW9uczsKKyAgICBzdGF0aWMgZGlzcGF0Y2hfb25jZV90IG9uY2VUb2tlbjsKKwor ICAgIGRpc3BhdGNoX29uY2UoJm9uY2VUb2tlbiwgXnsKKyAgICAgICAgTlNNdXRhYmxlRGljdGlv bmFyeTxOU1N0cmluZyAqLCBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKj4gKm1hcCA9IFtOU011 dGFibGVEaWN0aW9uYXJ5IGRpY3Rpb25hcnldOworCisgICAgICAgIHZvaWQgKF5mb3VuZE1JTUVU eXBlKShOU1N0cmluZyAqbWltZVR5cGUsIE5TU3RyaW5nICpleHRlbnNpb24pID0gXihOU1N0cmlu ZyAqbWltZVR5cGUsIE5TU3RyaW5nICpleHRlbnNpb24pIHsKKyAgICAgICAgICAgIE5TU3RyaW5n ICptaW1lVHlwZVdpbGRjYXJkID0gW1ttaW1lVHlwZSBjb21wb25lbnRzU2VwYXJhdGVkQnlTdHJp bmc6QCIvIl1bMF0gc3RyaW5nQnlBcHBlbmRpbmdTdHJpbmc6QCIvKiJdOworICAgICAgICAgICAg aWYgKCFtYXBbbWltZVR5cGVXaWxkY2FyZF0pCisgICAgICAgICAgICAgICAgbWFwW21pbWVUeXBl V2lsZGNhcmRdID0gW05TTXV0YWJsZVNldCBzZXRdOworICAgICAgICAgICAgW21hcFttaW1lVHlw ZVdpbGRjYXJkXSBhZGRPYmplY3Q6ZXh0ZW5zaW9uXTsKKyAgICAgICAgfTsKKyAgICAgICAgCisg ICAgICAgIE5TQXJyYXkgKmFsbFVUSXMgPSBDRkJyaWRnaW5nUmVsZWFzZShfVVRDb3B5RGVjbGFy ZWRUeXBlSWRlbnRpZmllcnMoKSk7CisgICAgICAgIGZvciAoTlNTdHJpbmcgKnV0aSBpbiBhbGxV VElzKSB7CisgICAgICAgICAgICBOU1N0cmluZyAqbWltZVR5cGUgPSBDRkJyaWRnaW5nUmVsZWFz ZShVVFR5cGVDb3B5UHJlZmVycmVkVGFnV2l0aENsYXNzKChfX2JyaWRnZSBDRlN0cmluZ1JlZiko dXRpKSwga1VUVGFnQ2xhc3NNSU1FVHlwZSkpOworICAgICAgICAgICAgaWYgKCFtaW1lVHlwZSkK KyAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgTlNBcnJheSAqYWxsRXh0 ZW5zaW9ucyA9IENGQnJpZGdpbmdSZWxlYXNlKFVUVHlwZUNvcHlBbGxUYWdzV2l0aENsYXNzKChf X2JyaWRnZSBDRlN0cmluZ1JlZikodXRpKSwga1VUVGFnQ2xhc3NGaWxlbmFtZUV4dGVuc2lvbikp OworICAgICAgICAgICAgZm9yIChOU1N0cmluZyAqZXh0ZW5zaW9uIGluIGFsbEV4dGVuc2lvbnMp IHsKKyAgICAgICAgICAgICAgICBpZiAoIWV4dGVuc2lvbikKKyAgICAgICAgICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgICAgICAgICAgZm91bmRNSU1FVHlwZShtaW1lVHlwZSwgZXh0ZW5z aW9uKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIHdpbGRjYXJkTUlNRVR5 cGVUb0V4dGVuc2lvbnMuZ2V0KCkgPSBbbWFwIGNvcHldOworICAgIH0pOworCisgICAgQVNTRVJU KFttaW1ldHlwZSBjaGFyYWN0ZXJBdEluZGV4OlttaW1ldHlwZSBsZW5ndGhdIC0gMV0gPT0gJyon KTsKKyAgICByZXR1cm4gW3dpbGRjYXJkTUlNRVR5cGVUb0V4dGVuc2lvbnMuZ2V0KCkgb2JqZWN0 Rm9yS2V5Om1pbWV0eXBlXTsKK30KKwogQGltcGxlbWVudGF0aW9uIFdLT3BlblBhbmVsUGFyYW1l dGVycwogCiAtIChCT09MKWFsbG93c011bHRpcGxlU2VsZWN0aW9uCkBAIC02Myw2ICsxMDYsNjAg QEAKICAgICByZXR1cm4gd3JhcHBlcihfb3BlblBhbmVsUGFyYW1ldGVycy0+YWNjZXB0RmlsZUV4 dGVuc2lvbnMoKSk7CiB9CiAKKy0gKE5TQXJyYXk8TlNTdHJpbmcgKj4gKilfYWxsb3dlZEZpbGVF eHRlbnNpb25zCit7CisgICAgLy8gQWdncmVnYXRlIGV4dGVuc2lvbnMgYmFzZWQgb24gc3BlY2lm aWVkIE1JTUUgdHlwZXMuCisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRNSU1FVHlw ZXMgPSBbc2VsZiBfYWNjZXB0ZWRNSU1FVHlwZXNdOworICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4g KmFjY2VwdGVkRmlsZUV4dGVuc2lvbnMgPSBbc2VsZiBfYWNjZXB0ZWRGaWxlRXh0ZW5zaW9uc107 CisKKyAgICBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKmFsbG93ZWRGaWxlRXh0ZW5zaW9ucyA9 IFtOU011dGFibGVTZXQgc2V0XTsKKworICAgIFthY2NlcHRlZE1JTUVUeXBlcyBlbnVtZXJhdGVP YmplY3RzVXNpbmdCbG9jazpeKE5TU3RyaW5nICptaW1lVHlwZSwgTlNVSW50ZWdlciBpbmRleCwg Qk9PTCogc3RvcCkgeworICAgICAgICBpZiAoW21pbWVUeXBlIGhhc1N1ZmZpeDpAIioiXSkKKyAg ICAgICAgICAgIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMgdW5pb25TZXQ6ZXh0ZW5zaW9uc0Zvcldp bGRjYXJkTUlNRVR5cGUobWltZVR5cGUpXTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgW2Fs bG93ZWRGaWxlRXh0ZW5zaW9ucyBhZGRPYmplY3RzRnJvbUFycmF5OmV4dGVuc2lvbnNGb3JNSU1F VHlwZShtaW1lVHlwZSldOworICAgIH1dOworCisgICAgTlNNdXRhYmxlQXJyYXk8TlNTdHJpbmcg Kj4gKndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXldOwor ICAgIFthY2NlcHRlZEZpbGVFeHRlbnNpb25zIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4o TlNTdHJpbmcgKmV4dGVuc2lvbiwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCAqc3RvcCkgeworICAg ICAgICBBU1NFUlQoW2V4dGVuc2lvbiBjaGFyYWN0ZXJBdEluZGV4OjBdID09ICcuJyk7CisgICAg ICAgIFt3aGl0ZWxpc3RlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdDpbZXh0ZW5zaW9uIHN1YnN0 cmluZ0Zyb21JbmRleDoxXV07CisgICAgfV07CisgICAgCisgICAgW2FsbG93ZWRGaWxlRXh0ZW5z aW9ucyBhZGRPYmplY3RzRnJvbUFycmF5OndoaXRlbGlzdGVkRmlsZUV4dGVuc2lvbnNdOworICAg IHJldHVybiBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFsbE9iamVjdHNdOworfQorCistIChOU1N0 cmluZyAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbgoreworICAgIE5TQXJyYXk8 TlNTdHJpbmcgKj4gKmFjY2VwdGVkTUlNRVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5cGVz XTsKKyAgICBOU0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZEZpbGVFeHRlbnNpb25zID0gW3Nl bGYgX2FjY2VwdGVkRmlsZUV4dGVuc2lvbnNdOworCisgICAgaWYgKCFbYWNjZXB0ZWRNSU1FVHlw ZXMgY291bnRdICYmICFbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pCisgICAgICAgIHJl dHVybiBuaWw7CisKKyAgICBpZiAoIShbYWNjZXB0ZWRNSU1FVHlwZXMgY291bnRdID09IDEgJiYg IVthY2NlcHRlZEZpbGVFeHRlbnNpb25zIGNvdW50XSkpCisgICAgICAgIHJldHVybiBAIkN1c3Rv bSBGaWxlcyI7CisKKyAgICBOU1N0cmluZyAqbWltZVR5cGUgPSBbYWNjZXB0ZWRNSU1FVHlwZXMg Zmlyc3RPYmplY3RdOworICAgIE5TUmFuZ2UgcmFuZ2UgPSBbbWltZVR5cGUgcmFuZ2VPZlN0cmlu ZzpAIi8iXTsKKyAgICAKKyAgICBpZiAoIXJhbmdlLmxlbmd0aCkKKyAgICAgICAgcmV0dXJuIEAi Q3VzdG9tIEZpbGVzIjsKKyAgICAKKyAgICBOU1N0cmluZyAqbWltZVR5cGVQcmVmaXggPSBbbWlt ZVR5cGUgc3Vic3RyaW5nVG9JbmRleDpyYW5nZS5sb2NhdGlvbl07CisgICAgTlNTdHJpbmcgKm1p bWVUeXBlU3VmZml4ID0gW21pbWVUeXBlIHN1YnN0cmluZ0Zyb21JbmRleDpyYW5nZS5sb2NhdGlv biArIDFdOworICAgIAorICAgIGlmIChbbWltZVR5cGVTdWZmaXggaXNFcXVhbFRvU3RyaW5nOkAi KiJdKQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCVAIEZp bGVzIiwgW1ttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdUb0luZGV4OjFdIHVwcGVyY2FzZVN0cmlu Z10sIFttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdGcm9tSW5kZXg6MV1dOworCisgICAgaWYgKFtt aW1lVHlwZVN1ZmZpeCBsZW5ndGhdIDw9IDQpCisgICAgICAgIHJldHVybiBbTlNTdHJpbmcgc3Ry aW5nV2l0aEZvcm1hdDpAIiVAICVAIiwgW21pbWVUeXBlU3VmZml4IHVwcGVyY2FzZVN0cmluZ10s IG1pbWVUeXBlUHJlZml4XTsKKworICAgIHJldHVybiBbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1h dDpAIiVAICVAIiwgbWltZVR5cGVTdWZmaXgsIG1pbWVUeXBlUHJlZml4XTsKK30KKwogQGVuZAog CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9X S09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCmluZGV4IDEzYmE3ZDgzZDY2 NjQ3YTQ2YjFjMzQxMzcwYjc4OTdlMjM0YWFjOGIuLjQxNGU1YmZhZDZmZTNjNjY4NzhkMjU4ZDA0 ZDJmNTBlMmJhNmQ1ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9D b2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaApAQCAtMzEs NiArMzEsOCBAQAogCiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJy YXk8TlNTdHJpbmcgKj4gKl9hY2NlcHRlZE1JTUVUeXBlcyBXS19BUElfQVZBSUxBQkxFKG1hY29z KDEwLjEzLjQpKTsKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSwgY29weSkgTlNBcnJh eTxOU1N0cmluZyAqPiAqX2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlMQUJMRSht YWNvcygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5T QXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlMQUJM RShtYWNvcygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkp IE5TU3RyaW5nICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24gV0tfQVBJX0FWQUlM QUJMRShtYWNvcygxMC4xMy40KSk7CiAKIEBlbmQKIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdl TG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGRhNDIyNzY3YTk4YWM4ODRkOTIwZmUxMWIzN2M3 NzQwN2FhZGE4YjguLjYyYzkyYWE0YmE0NGE1MzkzMDRjNDI5YTY4MTc4M2JhMTA5ZDU3NzEgMTAw NjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyMiBAQAorMjAyMC0wNi0wNSAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBw bGUuY29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0 PiBmaWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENyZWF0ZSBhIHZpZXcgd2l0 aCBhbiBOU1BvcHVwQnV0dG9uIGZvciB0aGUgZmlsZSBleHRlbnNpb25zIGZpbHRlci4gU2V0Cisg ICAgICAgIHRoaXMgdmlldyBhcyB0aGUgQWNjZXNzb3J5VmlldyBvZiB0aGUgT3BlblBhbmVsLiBD cmVhdGUgYSBjdXN0b21pemVkIHRhcmdldAorICAgICAgICBmb3IgdGhlIE5TUG9wdXBCdXR0b24g dG8gcmVzcG9uZCB0byBjaGFuZ2luZyBpdHMgc2VsZWN0aW9uLgorCisgICAgICAgICogTWluaUJy b3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm06CisgICAgICAgICgtW0ZpbGVF eHRlbnNpb25zUG9wdXBUYXJnZXQgaW5pdFdpdGhPcGVuUGFuZWw6YWxsb3dlZEZpbGVFeHRlbnNp b25zOl0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHBvcHVwQWN0aW9u Ol0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IGRlYWxsb2NdKToKKyAg ICAgICAgKC1bV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIgZGVhbGxvY10pOgorICAgICAgICAo LVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciBjcmVhdGVGaWx0ZXJWaWV3OnBvcHVwVGFyZ2V0 Ol0pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciB3ZWJWaWV3OnJ1bk9w ZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6 d2ViVmlldzpydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczppbml0aWF0ZWRCeUZyYW1lOmNvbXBs ZXRpb25IYW5kbGVyOl0pOgorCiAyMDIwLTA2LTA1ICBBbmR5IEVzdGVzICA8YWVzdGVzQGFwcGxl LmNvbT4KIAogICAgICAgICBbQXBwbGUgUGF5XSBSZW1vdmUgY29uZGl0aW9uYWxzIGZvciBFTkFC TEVfQVBQTEVfUEFZX1NFU1NJT05fVigzfDQpCmRpZmYgLS1naXQgYS9Ub29scy9NaW5pQnJvd3Nl ci9tYWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubSBiL1Rvb2xzL01pbmlCcm93c2VyL21h Yy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCmluZGV4IDBjYmY5YzQ1YjJiYTY4MTYxMWNi Mzg4Y2RlYWUyMGJiMWUyYzVmNTYuLjA1YTMxZDA1Zjg1YjQyMjA2NWY3Mjk0MzA1YjNhNDk0NmVk ZGVmYzMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93 Q29udHJvbGxlci5tCisrKyBiL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93 Q29udHJvbGxlci5tCkBAIC0zMCw2ICszMCw3IEBACiAjaW1wb3J0IDxXZWJLaXQvV0tGcmFtZUlu Zm8uaD4KICNpbXBvcnQgPFdlYktpdC9XS05hdmlnYXRpb25BY3Rpb25Qcml2YXRlLmg+CiAjaW1w b3J0IDxXZWJLaXQvV0tOYXZpZ2F0aW9uRGVsZWdhdGUuaD4KKyNpbXBvcnQgPFdlYktpdC9XS09w ZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tQcmVmZXJlbmNl c1ByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XS1VJRGVsZWdhdGUuaD4KICNpbXBvcnQgPFdl YktpdC9XS1VJRGVsZWdhdGVQcml2YXRlLmg+CkBAIC03MSw2ICs3MiwzOSBAQCAtICh2b2lkKXBl cmZvcm1BY3Rpb246KE5TVGV4dEZpbmRlckFjdGlvbilvcAogCiBAZW5kCiAKKy8vIFRhcmdldCBm b3IgdGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5QYW5lbCdzIEFj Y2Vzc29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgOiBOU09i amVjdCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOworICAgIE5TQXJy YXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5kCisKK0BpbXBs ZW1lbnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWluaXRXaXRoT3Bl blBhbmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczooTlNB cnJheTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAgaWYgKChzZWxm ID0gW3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBhbmVsOworICAg ICAgICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBjb3B5 XTsKKyAgICB9CisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpcG9wdXBBY3Rpb246KGlk KXNlbmRlciB7CisgICAgaWYgKCFbc2VuZGVyIGluZGV4T2ZTZWxlY3RlZEl0ZW1dKQorICAgICAg ICBbX29wZW5QYW5lbCBzZXRBbGxvd2VkRmlsZVR5cGVzOl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNd OworICAgIGVsc2UKKyAgICAgICAgW19vcGVuUGFuZWwgc2V0QWxsb3dlZEZpbGVUeXBlczpuaWxd OworfQorCistICh2b2lkKWRlYWxsb2MKK3sKKyAgICBbX2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBy ZWxlYXNlXTsKKyAgICBbc3VwZXIgZGVhbGxvY107Cit9CisKK0BlbmQKKwogQGludGVyZmFjZSBX SzJCcm93c2VyV2luZG93Q29udHJvbGxlciAoKSA8TlNUZXh0RmluZGVyQmFyQ29udGFpbmVyLCBX S05hdmlnYXRpb25EZWxlZ2F0ZSwgV0tVSURlbGVnYXRlLCBfV0tJY29uTG9hZGluZ0RlbGVnYXRl PgogQGVuZAogCkBAIC04NSw2ICsxMTksNyBAQCBAaW1wbGVtZW50YXRpb24gV0syQnJvd3Nlcldp bmRvd0NvbnRyb2xsZXIgewogICAgIE1pbmlCcm93c2VyTlNUZXh0RmluZGVyICpfdGV4dEZpbmRl cjsKICAgICBOU1ZpZXcgKl90ZXh0RmluZEJhclZpZXc7CiAgICAgQk9PTCBfZmluZEJhclZpc2li bGU7CisgICAgRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCAqX2ZpbGVFeHRlbnNpb25zUG9wdXBU YXJnZXQ7CiB9CiAKIC0gKHZvaWQpYXdha2VGcm9tTmliCkBAIC0xNzAsNiArMjA1LDcgQEAgLSAo dm9pZClkZWFsbG9jCiAKICAgICBbX3dlYlZpZXcgcmVsZWFzZV07CiAgICAgW19jb25maWd1cmF0 aW9uIHJlbGVhc2VdOworICAgIFtfZmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCByZWxlYXNlXTsK IAogICAgIFtzdXBlciBkZWFsbG9jXTsKIH0KQEAgLTU4Nyw2ICs2MjMsMzggQEAgLSAodm9pZCl3 ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IHJ1bkphdmFTY3JpcHRUZXh0SW5wdXRQYW5lbFdp dGhQcm9tcHQ6KE5TU3QKICAgICB9XTsKIH0KIAorLSAobnVsbGFibGUgTlNWaWV3ICopY3JlYXRl RmlsdGVyVmlldzooTlNTdHJpbmcgKilhbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbiBw b3B1cFRhcmdldDooRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCopcG9wdXBUYXJnZXQKK3sKKyAg ICBOU1RleHRGaWVsZCogbGFiZWwgPSBbW1tOU1RleHRGaWVsZCBhbGxvY10gaW5pdFdpdGhGcmFt ZTpOU1plcm9SZWN0XSBhdXRvcmVsZWFzZV07CisgICAgW2xhYmVsIHNldFN0cmluZ1ZhbHVlOkAi Rm9ybWF0OiJdOworICAgIFtsYWJlbCBzZXRFZGl0YWJsZTpOT107CisgICAgW2xhYmVsIHNldFNl bGVjdGFibGU6Tk9dOworICAgIFtsYWJlbCBzZXRCb3JkZXJlZDpOT107CisgICAgW2xhYmVsIHNl dEJhY2tncm91bmRDb2xvcjpbTlNDb2xvciBjbGVhckNvbG9yXV07CisgICAgW2xhYmVsIHNldEFs aWdubWVudDpOU1RleHRBbGlnbm1lbnRSaWdodF07CisKKyAgICBOU1BvcFVwQnV0dG9uICpidXR0 b24gPSBbW1tOU1BvcFVwQnV0dG9uIGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TWmVyb1JlY3QgcHVs bHNEb3duOk5PXSBhdXRvcmVsZWFzZV07CisgICAgaWYgKGFsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rl c2NyaXB0aW9uKQorICAgICAgICBbYnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6YWxsb3dlZEZpbGVF eHRlbnNpb25zRGVzY3JpcHRpb25dOworICAgIFtidXR0b24gYWRkSXRlbVdpdGhUaXRsZTpAIkFs bCBGaWxlcyAgICAgICAgICAgICAgICAgICAgICAgICAgIl07CisgICAgW2J1dHRvbiBzZXRUYXJn ZXQ6cG9wdXBUYXJnZXRdOworICAgIFtidXR0b24gc2V0QWN0aW9uOkBzZWxlY3Rvcihwb3B1cEFj dGlvbjopXTsKKyAgICBbYnV0dG9uIHNlbGVjdEl0ZW1BdEluZGV4OjBdOworICAgIFtwb3B1cFRh cmdldCBwb3B1cEFjdGlvbjpidXR0b25dOworCisgICAgTlNTdGFja1ZpZXcqIGhvcml6b250YWxW aWV3ID0gW1tbTlNTdGFja1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNaZXJvUmVjdF0gYXV0 b3JlbGVhc2VdOworICAgIFtob3Jpem9udGFsVmlldyBzZXREaXN0cmlidXRpb246TlNTdGFja1Zp ZXdEaXN0cmlidXRpb25GaWxsRXF1YWxseV07CisgICAgW2hvcml6b250YWxWaWV3IHNldFNwYWNp bmc6Ml07CisgICAgW2hvcml6b250YWxWaWV3IGFkZEFycmFuZ2VkU3VidmlldzpsYWJlbF07Cisg ICAgW2hvcml6b250YWxWaWV3IGFkZEFycmFuZ2VkU3VidmlldzpidXR0b25dOworCisgICAgTlNT dGFja1ZpZXcqIGZpbHRlclZpZXcgPSBbW1tOU1N0YWNrVmlldyBhbGxvY10gaW5pdFdpdGhGcmFt ZTpOU1plcm9SZWN0XSBhdXRvcmVsZWFzZV07CisgICAgW2ZpbHRlclZpZXcgc2V0T3JpZW50YXRp b246TlNVc2VySW50ZXJmYWNlTGF5b3V0T3JpZW50YXRpb25WZXJ0aWNhbF07CisgICAgW2ZpbHRl clZpZXcgc2V0RWRnZUluc2V0czpOU0VkZ2VJbnNldHNNYWtlKDIwLCAyMCwgMjAsIDIwKV07Cisg ICAgW2ZpbHRlclZpZXcgYWRkQXJyYW5nZWRTdWJ2aWV3Omhvcml6b250YWxWaWV3XTsKKyAgICBy ZXR1cm4gZmlsdGVyVmlldzsKK30KKwogI2lmIF9faGFzX2ZlYXR1cmUob2JqY19nZW5lcmljcykK IC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW5PcGVuUGFuZWxXaXRoUGFy YW1ldGVyczooV0tPcGVuUGFuZWxQYXJhbWV0ZXJzICopcGFyYW1ldGVycyBpbml0aWF0ZWRCeUZy YW1lOihXS0ZyYW1lSW5mbyAqKWZyYW1lIGNvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShOU0Fy cmF5PE5TVVJMICo+ICogVVJMcykpY29tcGxldGlvbkhhbmRsZXIKICNlbHNlCkBAIC01OTcsNiAr NjY1LDEzIEBAIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW5PcGVuUGFu ZWxXaXRoUGFyYW1ldGVyczooV0tPcGVuUGFuZWxQYXJhCiAKICAgICBvcGVuUGFuZWwuYWxsb3dz TXVsdGlwbGVTZWxlY3Rpb24gPSBwYXJhbWV0ZXJzLmFsbG93c011bHRpcGxlU2VsZWN0aW9uOwog CisgICAgW19maWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHJlbGVhc2VdOworICAgIF9maWxlRXh0 ZW5zaW9uc1BvcHVwVGFyZ2V0ID0gW1tGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IGFsbG9jXSBp bml0V2l0aE9wZW5QYW5lbDogb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczogcGFyYW1l dGVycy5fYWxsb3dlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIE5TVmlldyAqZmlsdGVyVmlldyA9 IFtzZWxmIGNyZWF0ZUZpbHRlclZpZXc6cGFyYW1ldGVycy5fYWxsb3dlZEZpbGVFeHRlbnNpb25z RGVzY3JpcHRpb24gcG9wdXBUYXJnZXQ6X2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXRdOworICAg IGlmIChmaWx0ZXJWaWV3KQorICAgICAgICBbb3BlblBhbmVsIHNldEFjY2Vzc29yeVZpZXc6Zmls dGVyVmlld107CisKICAgICBbb3BlblBhbmVsIGJlZ2luU2hlZXRNb2RhbEZvcldpbmRvdzp3ZWJW aWV3LndpbmRvdyBjb21wbGV0aW9uSGFuZGxlcjpeKE5TSW50ZWdlciByZXN1bHQpIHsKICAgICAg ICAgaWYgKHJlc3VsdCA9PSBOU01vZGFsUmVzcG9uc2VPSykKICAgICAgICAgICAgIGNvbXBsZXRp b25IYW5kbGVyKG9wZW5QYW5lbC5VUkxzKTsK 401206 2020-06-05 15:14:43 -0700 2020-06-06 00:40:18 -0700 Patch bug-212485-20200605151442.patch text/plain 14306 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q QUwvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCAxYjgwMTQ5 OTVlMDY5YWQzMGI5MWRhYzg0ZmRiNDNiMmFjMDRlODcwLi4xOWY2ZGI2OGUxNzdkYWNmMjc2ZTg0 NDQ1NGZiZmI1MzE5N2JjMmUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAor MjAyMC0wNi0wNSAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgor CisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0PiBmaWxlIGVs ZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4cG9zZSBhbiBTUEkgZnJvbSBDb3JlU2Vy dmNpZXMgdG8gZ2V0IGFsbCB0aGUgVVRJcyBrbm93biBieSB0aGUgc3lzdGVtLgorCisgICAgICAg ICogcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaDoKKwogMjAyMC0wNi0wNSAgQW5keSBF c3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAKICAgICAgICAgW0FwcGxlIFBheV0gUmVtb3ZlIGNv bmRpdGlvbmFscyBmb3IgRU5BQkxFX0FQUExFX1BBWV9TRVNTSU9OX1YoM3w0KQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRl eCAzYWEzM2FkOTFhZjk5YWJlYThhNjhmMGZiNDE2OWUwZmFhODU2NjkyLi5iNTBkODNlZjJlYjI5 Yjk0ZDllMTY0MjUwMTU1Y2Y1YzRhOWIwNDdmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisy MDIwLTA2LTA1ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisK KyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxl bWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHR3byBwcml2YXRlIGhlbHBlcnMgdG8g V0tPcGVuUGFuZWxQYXJhbWV0ZXJzLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9X S09wZW5QYW5lbFBhcmFtZXRlcnMubW06CisgICAgICAgICgtW1dLT3BlblBhbmVsUGFyYW1ldGVy cyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zXSk6CisgICAgICAgIFJldHVybnMgYW4gYXJyYXkgb2Yg c3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAo LVtXS09wZW5QYW5lbFBhcmFtZXRlcnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9u XSk6CisgICAgICAgIFJldHVybnMgYSBzdHJpbmcgcmVwcmVzZW50aW5nIGEgZGVzY3JpcHRpb24g Zm9yIHRoZSBhbGxvd2VkIGV4dGVuc2lvbnMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0Nv Y29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaDoKKwogMjAyMC0wNi0wNSAgQWRyaWFu IFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIE5vbi11bmlm aWVkIGJ1aWxkIGZpeGVzLCBlYXJseSBzdW1tZXIgMjAyMCBlZGl0aW9uCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaCBiL1NvdXJj ZS9XZWJDb3JlL1BBTC9wYWwvc3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCmluZGV4IGE0YTRk ZGQ1NDUyNjJlYTQ1NDhmNTRiY2QyODE0MTYzMmE2ZmMwNjkuLmNhNGVmZjM3OGMyODI0Mjg4OTY0 OGY0MzU3YzYzODU2ZjlhYTI2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCkBAIC0yNiwzICsyNiw1IEBACiAjcHJhZ21hIG9u Y2UKIAogZXh0ZXJuICJDIiB2b2lkIF9DU0NoZWNrRml4RGlzYWJsZSgpOworZXh0ZXJuICJDIiBD RkFycmF5UmVmIF9VVENvcHlEZWNsYXJlZFR5cGVJZGVudGlmaWVycyh2b2lkKTsKKwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1l dGVycy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBh cmFtZXRlcnMubW0KaW5kZXggOGUwYzhlZWQwYjlhYWU3YmVmZDRhOTYxYzA4ZDJlNjBhZjY2NmE3 MC4uZDNjMzZmNDg5NTkyNGYxNjUyY2MxNDgzNTU0OGEyNDM3M2RhZjMwYyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5t bQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJh bWV0ZXJzLm1tCkBAIC0yNSwxMSArMjUsNTEgQEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1w b3J0ICJXS09wZW5QYW5lbFBhcmFtZXRlcnNJbnRlcm5hbC5oIgorI2ltcG9ydCA8cGFsL3NwaS9j b2NvYS9Db3JlU2VydmljZXNTUEkuaD4KIAogI2lmIFBMQVRGT1JNKE1BQykKIAogI2ltcG9ydCAi V0tOU0FycmF5LmgiCiAKK3N0YXRpYyBOU0FycmF5PE5TU3RyaW5nICo+ICpleHRlbnNpb25zRm9y TUlNRVR5cGUoTlNTdHJpbmcgKm1pbWV0eXBlKQoreworICAgIFJldGFpblB0cjxOU1N0cmluZz4g dXRpID0gYWRvcHRDRihVVFR5cGVDcmVhdGVQcmVmZXJyZWRJZGVudGlmaWVyRm9yVGFnKGtVVFRh Z0NsYXNzTUlNRVR5cGUsIChfX2JyaWRnZSBDRlN0cmluZ1JlZikobWltZXR5cGUpLCAwKSk7Cisg ICAgcmV0dXJuIENGQnJpZGdpbmdSZWxlYXNlKFVUVHlwZUNvcHlBbGxUYWdzV2l0aENsYXNzKChf X2JyaWRnZSBDRlN0cmluZ1JlZikodXRpLmdldCgpKSwga1VUVGFnQ2xhc3NGaWxlbmFtZUV4dGVu c2lvbikpOworfQorCitzdGF0aWMgTlNTZXQ8TlNTdHJpbmcgKj4gKmV4dGVuc2lvbnNGb3JXaWxk Y2FyZE1JTUVUeXBlKE5TU3RyaW5nICptaW1ldHlwZSkKK3sKKyAgICBzdGF0aWMgTmV2ZXJEZXN0 cm95ZWQ8UmV0YWluUHRyPE5TRGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU1NldDxOU1N0cmluZyAq PiAqPj4+IHdpbGRjYXJkTUlNRVR5cGVUb0V4dGVuc2lvbnM7CisgICAgc3RhdGljIGRpc3BhdGNo X29uY2VfdCBvbmNlVG9rZW47CisKKyAgICBkaXNwYXRjaF9vbmNlKCZvbmNlVG9rZW4sIF57Cisg ICAgICAgIE5TTXV0YWJsZURpY3Rpb25hcnk8TlNTdHJpbmcgKiwgTlNNdXRhYmxlU2V0PE5TU3Ry aW5nICo+ICo+ICptYXAgPSBbTlNNdXRhYmxlRGljdGlvbmFyeSBkaWN0aW9uYXJ5XTsKKworICAg ICAgICBSZXRhaW5QdHI8TlNBcnJheT4gYWxsVVRJcyA9IGFkb3B0Q0YoX1VUQ29weURlY2xhcmVk VHlwZUlkZW50aWZpZXJzKCkpOworICAgICAgICBmb3IgKE5TU3RyaW5nICp1dGkgaW4gYWxsVVRJ cy5nZXQoKSkgeworICAgICAgICAgICAgUmV0YWluUHRyPE5TU3RyaW5nPiBtaW1lVHlwZSA9IGFk b3B0Q0YoVVRUeXBlQ29weVByZWZlcnJlZFRhZ1dpdGhDbGFzcygoX19icmlkZ2UgQ0ZTdHJpbmdS ZWYpKHV0aSksIGtVVFRhZ0NsYXNzTUlNRVR5cGUpKTsKKyAgICAgICAgICAgIGlmICghbWltZVR5 cGUpCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIFJldGFpblB0cjxO U0FycmF5PiBhbGxFeHRlbnNpb25zID0gYWRvcHRDRihVVFR5cGVDb3B5QWxsVGFnc1dpdGhDbGFz cygoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpKHV0aSksIGtVVFRhZ0NsYXNzRmlsZW5hbWVFeHRlbnNp b24pKTsKKyAgICAgICAgICAgIGZvciAoTlNTdHJpbmcgKmV4dGVuc2lvbiBpbiBhbGxFeHRlbnNp b25zLmdldCgpKSB7CisgICAgICAgICAgICAgICAgaWYgKCFleHRlbnNpb24pCisgICAgICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICAgICAgTlNTdHJpbmcgKm1pbWVUeXBl V2lsZGNhcmQgPSBbW21pbWVUeXBlIGNvbXBvbmVudHNTZXBhcmF0ZWRCeVN0cmluZzpAIi8iXVsw XSBzdHJpbmdCeUFwcGVuZGluZ1N0cmluZzpAIi8qIl07CisgICAgICAgICAgICAgICAgaWYgKCFt YXBbbWltZVR5cGVXaWxkY2FyZF0pCisgICAgICAgICAgICAgICAgICAgIG1hcFttaW1lVHlwZVdp bGRjYXJkXSA9IFtOU011dGFibGVTZXQgc2V0XTsKKyAgICAgICAgICAgICAgICBbbWFwW21pbWVU eXBlV2lsZGNhcmRdIGFkZE9iamVjdDpleHRlbnNpb25dOworICAgICAgICAgICAgfQorICAgICAg ICB9CisKKyAgICAgICAgd2lsZGNhcmRNSU1FVHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSA9IFttYXAg Y29weV07CisgICAgfSk7CisKKyAgICBBU1NFUlQoW21pbWV0eXBlIGNoYXJhY3RlckF0SW5kZXg6 W21pbWV0eXBlIGxlbmd0aF0gLSAxXSA9PSAnKicpOworICAgIHJldHVybiBbd2lsZGNhcmRNSU1F VHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSBvYmplY3RGb3JLZXk6bWltZXR5cGVdOworfQorCiBAaW1w bGVtZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wpYWxsb3dzTXVsdGlw bGVTZWxlY3Rpb24KQEAgLTYzLDYgKzEwMyw2MCBAQAogICAgIHJldHVybiB3cmFwcGVyKF9vcGVu UGFuZWxQYXJhbWV0ZXJzLT5hY2NlcHRGaWxlRXh0ZW5zaW9ucygpKTsKIH0KIAorLSAoTlNBcnJh eTxOU1N0cmluZyAqPiAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnMKK3sKKyAgICAvLyBBZ2dyZWdh dGUgZXh0ZW5zaW9ucyBiYXNlZCBvbiBzcGVjaWZpZWQgTUlNRSB0eXBlcy4KKyAgICBOU0FycmF5 PE5TU3RyaW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBl c107CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtz ZWxmIF9hY2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIE5TTXV0YWJsZVNldDxOU1N0cmlu ZyAqPiAqYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW05TTXV0YWJsZVNldCBzZXRdOworCisgICAg W2FjY2VwdGVkTUlNRVR5cGVzIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4oTlNTdHJpbmcg Km1pbWVUeXBlLCBOU1VJbnRlZ2VyIGluZGV4LCBCT09MKiBzdG9wKSB7CisgICAgICAgIGlmIChb bWltZVR5cGUgaGFzU3VmZml4OkAiKiJdKQorICAgICAgICAgICAgW2FsbG93ZWRGaWxlRXh0ZW5z aW9ucyB1bmlvblNldDpleHRlbnNpb25zRm9yV2lsZGNhcmRNSU1FVHlwZShtaW1lVHlwZSldOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVj dHNGcm9tQXJyYXk6ZXh0ZW5zaW9uc0Zvck1JTUVUeXBlKG1pbWVUeXBlKV07CisgICAgfV07CisK KyAgICBOU011dGFibGVBcnJheTxOU1N0cmluZyAqPiAqd2hpdGVsaXN0ZWRGaWxlRXh0ZW5zaW9u cyA9IFtOU011dGFibGVBcnJheSBhcnJheV07CisgICAgW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMg ZW51bWVyYXRlT2JqZWN0c1VzaW5nQmxvY2s6XihOU1N0cmluZyAqZXh0ZW5zaW9uLCBOU1VJbnRl Z2VyIGluZGV4LCBCT09MICpzdG9wKSB7CisgICAgICAgIEFTU0VSVChbZXh0ZW5zaW9uIGNoYXJh Y3RlckF0SW5kZXg6MF0gPT0gJy4nKTsKKyAgICAgICAgW3doaXRlbGlzdGVkRmlsZUV4dGVuc2lv bnMgYWRkT2JqZWN0OltleHRlbnNpb24gc3Vic3RyaW5nRnJvbUluZGV4OjFdXTsKKyAgICB9XTsK KyAgICAKKyAgICBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdHNGcm9tQXJyYXk6d2hp dGVsaXN0ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgcmV0dXJuIFthbGxvd2VkRmlsZUV4dGVuc2lv bnMgYWxsT2JqZWN0c107Cit9CisKKy0gKE5TU3RyaW5nICopX2FsbG93ZWRGaWxlRXh0ZW5zaW9u c0Rlc2NyaXB0aW9uCit7CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRNSU1FVHlw ZXMgPSBbc2VsZiBfYWNjZXB0ZWRNSU1FVHlwZXNdOworICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4g KmFjY2VwdGVkRmlsZUV4dGVuc2lvbnMgPSBbc2VsZiBfYWNjZXB0ZWRGaWxlRXh0ZW5zaW9uc107 CisKKyAgICBpZiAoIVthY2NlcHRlZE1JTUVUeXBlcyBjb3VudF0gJiYgIVthY2NlcHRlZEZpbGVF eHRlbnNpb25zIGNvdW50XSkKKyAgICAgICAgcmV0dXJuIG5pbDsKKworICAgIGlmICghKFthY2Nl cHRlZE1JTUVUeXBlcyBjb3VudF0gPT0gMSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291 bnRdKSkKKyAgICAgICAgcmV0dXJuIEAiQ3VzdG9tIEZpbGVzIjsKKworICAgIE5TU3RyaW5nICpt aW1lVHlwZSA9IFthY2NlcHRlZE1JTUVUeXBlcyBmaXJzdE9iamVjdF07CisgICAgTlNSYW5nZSBy YW5nZSA9IFttaW1lVHlwZSByYW5nZU9mU3RyaW5nOkAiLyJdOworICAgIAorICAgIGlmICghcmFu Z2UubGVuZ3RoKQorICAgICAgICByZXR1cm4gQCJDdXN0b20gRmlsZXMiOworICAgIAorICAgIE5T U3RyaW5nICptaW1lVHlwZVByZWZpeCA9IFttaW1lVHlwZSBzdWJzdHJpbmdUb0luZGV4OnJhbmdl LmxvY2F0aW9uXTsKKyAgICBOU1N0cmluZyAqbWltZVR5cGVTdWZmaXggPSBbbWltZVR5cGUgc3Vi c3RyaW5nRnJvbUluZGV4OnJhbmdlLmxvY2F0aW9uICsgMV07CisgICAgCisgICAgaWYgKFttaW1l VHlwZVN1ZmZpeCBpc0VxdWFsVG9TdHJpbmc6QCIqIl0pCisgICAgICAgIHJldHVybiBbTlNTdHJp bmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVAJUAgRmlsZXMiLCBbW21pbWVUeXBlUHJlZml4IHN1YnN0 cmluZ1RvSW5kZXg6MV0gdXBwZXJjYXNlU3RyaW5nXSwgW21pbWVUeXBlUHJlZml4IHN1YnN0cmlu Z0Zyb21JbmRleDoxXV07CisKKyAgICBpZiAoW21pbWVUeXBlU3VmZml4IGxlbmd0aF0gPD0gNCkK KyAgICAgICAgcmV0dXJuIFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAgJUAiLCBbbWlt ZVR5cGVTdWZmaXggdXBwZXJjYXNlU3RyaW5nXSwgbWltZVR5cGVQcmVmaXhdOworCisgICAgcmV0 dXJuIFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUAgJUAiLCBtaW1lVHlwZVN1ZmZpeCwg bWltZVR5cGVQcmVmaXhdOworfQorCiBAZW5kCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUu aCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRl cnNQcml2YXRlLmgKaW5kZXggMTNiYTdkODNkNjY2NDdhNDZiMWMzNDEzNzBiNzg5N2UyMzRhYWM4 Yi4uNDE0ZTViZmFkNmZlM2M2Njg3OGQyNThkMDRkMmY1MGUyYmE2ZDVmZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1By aXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFu ZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCkBAIC0zMSw2ICszMSw4IEBACiAKIEBwcm9wZXJ0eSAobm9u YXRvbWljLCByZWFkb25seSwgY29weSkgTlNBcnJheTxOU1N0cmluZyAqPiAqX2FjY2VwdGVkTUlN RVR5cGVzIFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOwogQHByb3BlcnR5IChub25h dG9taWMsIHJlYWRvbmx5LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWNjZXB0ZWRGaWxl RXh0ZW5zaW9ucyBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEwLjEzLjQpKTsKK0Bwcm9wZXJ0eSAo bm9uYXRvbWljLCByZWFkb25seSwgY29weSkgTlNBcnJheTxOU1N0cmluZyAqPiAqX2FsbG93ZWRG aWxlRXh0ZW5zaW9ucyBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEwLjEzLjQpKTsKK0Bwcm9wZXJ0 eSAobm9uYXRvbWljLCByZWFkb25seSwgY29weSkgTlNTdHJpbmcgKl9hbGxvd2VkRmlsZUV4dGVu c2lvbnNEZXNjcmlwdGlvbiBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEwLjEzLjQpKTsKIAogQGVu ZAogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg ZGE0MjI3NjdhOThhYzg4NGQ5MjBmZTExYjM3Yzc3NDA3YWFkYThiOC4uNjJjOTJhYTRiYTQ0YTUz OTMwNGM0MjlhNjgxNzgzYmExMDlkNTc3MSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDIwLTA2LTA1ICBTYWlkIEFi b3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAgICAgW21hY09TXTog VGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBzaG91bGQgc2hvdyB0 aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQ3JlYXRlIGEgdmlldyB3aXRoIGFuIE5TUG9wdXBCdXR0b24gZm9yIHRoZSBm aWxlIGV4dGVuc2lvbnMgZmlsdGVyLiBTZXQKKyAgICAgICAgdGhpcyB2aWV3IGFzIHRoZSBBY2Nl c3NvcnlWaWV3IG9mIHRoZSBPcGVuUGFuZWwuIENyZWF0ZSBhIGN1c3RvbWl6ZWQgdGFyZ2V0Cisg ICAgICAgIGZvciB0aGUgTlNQb3B1cEJ1dHRvbiB0byByZXNwb25kIHRvIGNoYW5naW5nIGl0cyBz ZWxlY3Rpb24uCisKKyAgICAgICAgKiBNaW5pQnJvd3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0Nv bnRyb2xsZXIubToKKyAgICAgICAgKC1bRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCBpbml0V2l0 aE9wZW5QYW5lbDphbGxvd2VkRmlsZUV4dGVuc2lvbnM6XSk6CisgICAgICAgICgtW0ZpbGVFeHRl bnNpb25zUG9wdXBUYXJnZXQgcG9wdXBBY3Rpb246XSk6CisgICAgICAgICgtW0ZpbGVFeHRlbnNp b25zUG9wdXBUYXJnZXQgZGVhbGxvY10pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29u dHJvbGxlciBkZWFsbG9jXSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVy IGNyZWF0ZUZpbHRlclZpZXc6cG9wdXBUYXJnZXQ6XSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJX aW5kb3dDb250cm9sbGVyIHdlYlZpZXc6cnVuT3BlblBhbmVsV2l0aFBhcmFtZXRlcnM6aW5pdGlh dGVkQnlGcmFtZTpjb21wbGV0aW9uSGFuZGxlcjp3ZWJWaWV3OnJ1bk9wZW5QYW5lbFdpdGhQYXJh bWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6XSk6CisKIDIwMjAtMDYt MDUgIEFuZHkgRXN0ZXMgIDxhZXN0ZXNAYXBwbGUuY29tPgogCiAgICAgICAgIFtBcHBsZSBQYXld IFJlbW92ZSBjb25kaXRpb25hbHMgZm9yIEVOQUJMRV9BUFBMRV9QQVlfU0VTU0lPTl9WKDN8NCkK ZGlmZiAtLWdpdCBhL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29udHJv bGxlci5tIGIvVG9vbHMvTWluaUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVy Lm0KaW5kZXggMGNiZjljNDViMmJhNjgxNjExY2IzODhjZGVhZTIwYmIxZTJjNWY1Ni4uMDVhMzFk MDVmODViNDIyMDY1ZjcyOTQzMDViM2E0OTQ2ZWRkZWZjMyAxMDA2NDQKLS0tIGEvVG9vbHMvTWlu aUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm0KKysrIGIvVG9vbHMvTWlu aUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm0KQEAgLTMwLDYgKzMwLDcg QEAKICNpbXBvcnQgPFdlYktpdC9XS0ZyYW1lSW5mby5oPgogI2ltcG9ydCA8V2ViS2l0L1dLTmF2 aWdhdGlvbkFjdGlvblByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XS05hdmlnYXRpb25EZWxl Z2F0ZS5oPgorI2ltcG9ydCA8V2ViS2l0L1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaD4K ICNpbXBvcnQgPFdlYktpdC9XS1ByZWZlcmVuY2VzUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0 L1dLVUlEZWxlZ2F0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dLVUlEZWxlZ2F0ZVByaXZhdGUuaD4K QEAgLTcxLDYgKzcyLDM5IEBAIC0gKHZvaWQpcGVyZm9ybUFjdGlvbjooTlNUZXh0RmluZGVyQWN0 aW9uKW9wCiAKIEBlbmQKIAorLy8gVGFyZ2V0IGZvciB0aGUgRmlsZUV4dGVuc2lvbnMgTlNQb3B1 cEJ1dHRvbiBpbiB0aGUgT3BlblBhbmVsJ3MgQWNjZXNzb3J5Vmlldy4KK0BpbnRlcmZhY2UgRmls ZUV4dGVuc2lvbnNQb3B1cFRhcmdldCA6IE5TT2JqZWN0IHsKK0Bwcml2YXRlCisgICAgTlNPcGVu UGFuZWwgKl9vcGVuUGFuZWw7CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqX2FsbG93ZWRGaWxl RXh0ZW5zaW9uczsKK30KK0BlbmQKKworQGltcGxlbWVudGF0aW9uIEZpbGVFeHRlbnNpb25zUG9w dXBUYXJnZXQKKworLSAoaWQpaW5pdFdpdGhPcGVuUGFuZWw6KE5TT3BlblBhbmVsKilvcGVuUGFu ZWwgYWxsb3dlZEZpbGVFeHRlbnNpb25zOihOU0FycmF5PE5TU3RyaW5nICo+ICopYWxsb3dlZEZp bGVFeHRlbnNpb25zIHsKKyAgICBpZiAoKHNlbGYgPSBbc3VwZXIgaW5pdF0pKSB7CisgICAgICAg IF9vcGVuUGFuZWwgPSBvcGVuUGFuZWw7CisgICAgICAgIF9hbGxvd2VkRmlsZUV4dGVuc2lvbnMg PSBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGNvcHldOworICAgIH0KKyAgICByZXR1cm4gc2VsZjsK K30KKworLSAodm9pZClwb3B1cEFjdGlvbjooaWQpc2VuZGVyIHsKKyAgICBpZiAoIVtzZW5kZXIg aW5kZXhPZlNlbGVjdGVkSXRlbV0pCisgICAgICAgIFtfb3BlblBhbmVsIHNldEFsbG93ZWRGaWxl VHlwZXM6X2FsbG93ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgZWxzZQorICAgICAgICBbX29wZW5Q YW5lbCBzZXRBbGxvd2VkRmlsZVR5cGVzOm5pbF07Cit9CisKKy0gKHZvaWQpZGVhbGxvYworewor ICAgIFtfYWxsb3dlZEZpbGVFeHRlbnNpb25zIHJlbGVhc2VdOworICAgIFtzdXBlciBkZWFsbG9j XTsKK30KKworQGVuZAorCiBAaW50ZXJmYWNlIFdLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyICgp IDxOU1RleHRGaW5kZXJCYXJDb250YWluZXIsIFdLTmF2aWdhdGlvbkRlbGVnYXRlLCBXS1VJRGVs ZWdhdGUsIF9XS0ljb25Mb2FkaW5nRGVsZWdhdGU+CiBAZW5kCiAKQEAgLTg1LDYgKzExOSw3IEBA IEBpbXBsZW1lbnRhdGlvbiBXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciB7CiAgICAgTWluaUJy b3dzZXJOU1RleHRGaW5kZXIgKl90ZXh0RmluZGVyOwogICAgIE5TVmlldyAqX3RleHRGaW5kQmFy VmlldzsKICAgICBCT09MIF9maW5kQmFyVmlzaWJsZTsKKyAgICBGaWxlRXh0ZW5zaW9uc1BvcHVw VGFyZ2V0ICpfZmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldDsKIH0KIAogLSAodm9pZClhd2FrZUZy b21OaWIKQEAgLTE3MCw2ICsyMDUsNyBAQCAtICh2b2lkKWRlYWxsb2MKIAogICAgIFtfd2ViVmll dyByZWxlYXNlXTsKICAgICBbX2NvbmZpZ3VyYXRpb24gcmVsZWFzZV07CisgICAgW19maWxlRXh0 ZW5zaW9uc1BvcHVwVGFyZ2V0IHJlbGVhc2VdOwogCiAgICAgW3N1cGVyIGRlYWxsb2NdOwogfQpA QCAtNTg3LDYgKzYyMywzOCBAQCAtICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcg cnVuSmF2YVNjcmlwdFRleHRJbnB1dFBhbmVsV2l0aFByb21wdDooTlNTdAogICAgIH1dOwogfQog CistIChudWxsYWJsZSBOU1ZpZXcgKiljcmVhdGVGaWx0ZXJWaWV3OihOU1N0cmluZyAqKWFsbG93 ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uIHBvcHVwVGFyZ2V0OihGaWxlRXh0ZW5zaW9uc1Bv cHVwVGFyZ2V0Kilwb3B1cFRhcmdldAoreworICAgIE5TVGV4dEZpZWxkKiBsYWJlbCA9IFtbW05T VGV4dEZpZWxkIGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TWmVyb1JlY3RdIGF1dG9yZWxlYXNlXTsK KyAgICBbbGFiZWwgc2V0U3RyaW5nVmFsdWU6QCJGb3JtYXQ6Il07CisgICAgW2xhYmVsIHNldEVk aXRhYmxlOk5PXTsKKyAgICBbbGFiZWwgc2V0U2VsZWN0YWJsZTpOT107CisgICAgW2xhYmVsIHNl dEJvcmRlcmVkOk5PXTsKKyAgICBbbGFiZWwgc2V0QmFja2dyb3VuZENvbG9yOltOU0NvbG9yIGNs ZWFyQ29sb3JdXTsKKyAgICBbbGFiZWwgc2V0QWxpZ25tZW50Ok5TVGV4dEFsaWdubWVudFJpZ2h0 XTsKKworICAgIE5TUG9wVXBCdXR0b24gKmJ1dHRvbiA9IFtbW05TUG9wVXBCdXR0b24gYWxsb2Nd IGluaXRXaXRoRnJhbWU6TlNaZXJvUmVjdCBwdWxsc0Rvd246Tk9dIGF1dG9yZWxlYXNlXTsKKyAg ICBpZiAoYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24pCisgICAgICAgIFtidXR0b24g YWRkSXRlbVdpdGhUaXRsZTphbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbl07CisgICAg W2J1dHRvbiBhZGRJdGVtV2l0aFRpdGxlOkAiQWxsIEZpbGVzICAgICAgICAgICAgICAgICAgICAg ICAgICAiXTsKKyAgICBbYnV0dG9uIHNldFRhcmdldDpwb3B1cFRhcmdldF07CisgICAgW2J1dHRv biBzZXRBY3Rpb246QHNlbGVjdG9yKHBvcHVwQWN0aW9uOildOworICAgIFtidXR0b24gc2VsZWN0 SXRlbUF0SW5kZXg6MF07CisgICAgW3BvcHVwVGFyZ2V0IHBvcHVwQWN0aW9uOmJ1dHRvbl07CisK KyAgICBOU1N0YWNrVmlldyogaG9yaXpvbnRhbFZpZXcgPSBbW1tOU1N0YWNrVmlldyBhbGxvY10g aW5pdFdpdGhGcmFtZTpOU1plcm9SZWN0XSBhdXRvcmVsZWFzZV07CisgICAgW2hvcml6b250YWxW aWV3IHNldERpc3RyaWJ1dGlvbjpOU1N0YWNrVmlld0Rpc3RyaWJ1dGlvbkZpbGxFcXVhbGx5XTsK KyAgICBbaG9yaXpvbnRhbFZpZXcgc2V0U3BhY2luZzoyXTsKKyAgICBbaG9yaXpvbnRhbFZpZXcg YWRkQXJyYW5nZWRTdWJ2aWV3OmxhYmVsXTsKKyAgICBbaG9yaXpvbnRhbFZpZXcgYWRkQXJyYW5n ZWRTdWJ2aWV3OmJ1dHRvbl07CisKKyAgICBOU1N0YWNrVmlldyogZmlsdGVyVmlldyA9IFtbW05T U3RhY2tWaWV3IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TWmVyb1JlY3RdIGF1dG9yZWxlYXNlXTsK KyAgICBbZmlsdGVyVmlldyBzZXRPcmllbnRhdGlvbjpOU1VzZXJJbnRlcmZhY2VMYXlvdXRPcmll bnRhdGlvblZlcnRpY2FsXTsKKyAgICBbZmlsdGVyVmlldyBzZXRFZGdlSW5zZXRzOk5TRWRnZUlu c2V0c01ha2UoMjAsIDIwLCAyMCwgMjApXTsKKyAgICBbZmlsdGVyVmlldyBhZGRBcnJhbmdlZFN1 YnZpZXc6aG9yaXpvbnRhbFZpZXddOworICAgIHJldHVybiBmaWx0ZXJWaWV3OworfQorCiAjaWYg X19oYXNfZmVhdHVyZShvYmpjX2dlbmVyaWNzKQogLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZpZXcg Kil3ZWJWaWV3IHJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOihXS09wZW5QYW5lbFBhcmFtZXRl cnMgKilwYXJhbWV0ZXJzIGluaXRpYXRlZEJ5RnJhbWU6KFdLRnJhbWVJbmZvICopZnJhbWUgY29t cGxldGlvbkhhbmRsZXI6KHZvaWQgKF4pKE5TQXJyYXk8TlNVUkwgKj4gKiBVUkxzKSljb21wbGV0 aW9uSGFuZGxlcgogI2Vsc2UKQEAgLTU5Nyw2ICs2NjUsMTMgQEAgLSAodm9pZCl3ZWJWaWV3OihX S1dlYlZpZXcgKil3ZWJWaWV3IHJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOihXS09wZW5QYW5l bFBhcmEKIAogICAgIG9wZW5QYW5lbC5hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbiA9IHBhcmFtZXRl cnMuYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb247CiAKKyAgICBbX2ZpbGVFeHRlbnNpb25zUG9wdXBU YXJnZXQgcmVsZWFzZV07CisgICAgX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgPSBbW0ZpbGVF eHRlbnNpb25zUG9wdXBUYXJnZXQgYWxsb2NdIGluaXRXaXRoT3BlblBhbmVsOiBvcGVuUGFuZWwg YWxsb3dlZEZpbGVFeHRlbnNpb25zOiBwYXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNd OworCisgICAgTlNWaWV3ICpmaWx0ZXJWaWV3ID0gW3NlbGYgY3JlYXRlRmlsdGVyVmlldzpwYXJh bWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbiBwb3B1cFRhcmdldDpfZmls ZUV4dGVuc2lvbnNQb3B1cFRhcmdldF07CisgICAgaWYgKGZpbHRlclZpZXcpCisgICAgICAgIFtv cGVuUGFuZWwgc2V0QWNjZXNzb3J5VmlldzpmaWx0ZXJWaWV3XTsKKwogICAgIFtvcGVuUGFuZWwg YmVnaW5TaGVldE1vZGFsRm9yV2luZG93OndlYlZpZXcud2luZG93IGNvbXBsZXRpb25IYW5kbGVy Ol4oTlNJbnRlZ2VyIHJlc3VsdCkgewogICAgICAgICBpZiAocmVzdWx0ID09IE5TTW9kYWxSZXNw b25zZU9LKQogICAgICAgICAgICAgY29tcGxldGlvbkhhbmRsZXIob3BlblBhbmVsLlVSTHMpOwo= 401241 2020-06-06 00:40:20 -0700 2020-06-08 18:52:17 -0700 Patch bug-212485-20200606004019.patch text/plain 15168 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q QUwvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCAxYjgwMTQ5 OTVlMDY5YWQzMGI5MWRhYzg0ZmRiNDNiMmFjMDRlODcwLi5lODU0NmU4MGRlYTJkNTRjMjZlMDY5 YmFkYzVmNzZlNTA5MzQyNjQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAor MjAyMC0wNi0wNiAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgor CisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0PiBmaWxlIGVs ZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4cG9zZSBhbiBTUEkgZnJvbSBDb3JlU2Vy dmNpZXMgdG8gZ2V0IGFsbCB0aGUgVVRJcyBrbm93biBieSB0aGUgc3lzdGVtLgorCisgICAgICAg ICogcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaDoKKwogMjAyMC0wNi0wNSAgQW5keSBF c3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAKICAgICAgICAgW0FwcGxlIFBheV0gUmVtb3ZlIGNv bmRpdGlvbmFscyBmb3IgRU5BQkxFX0FQUExFX1BBWV9TRVNTSU9OX1YoM3w0KQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRl eCAzYWEzM2FkOTFhZjk5YWJlYThhNjhmMGZiNDE2OWUwZmFhODU2NjkyLi41OTQxNTM3YzZjNzZh MGY5YmNmNmRlYzg2Mjg3Nzg5OTgwOWZjNTcwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisy MDIwLTA2LTA2ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisK KyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxl bWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHR3byBwcml2YXRlIGhlbHBlcnMgdG8g V0tPcGVuUGFuZWxQYXJhbWV0ZXJzLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9X S09wZW5QYW5lbFBhcmFtZXRlcnMubW06CisgICAgICAgICgtW1dLT3BlblBhbmVsUGFyYW1ldGVy cyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zXSk6CisgICAgICAgIFJldHVybnMgYW4gYXJyYXkgb2Yg c3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAo LVtXS09wZW5QYW5lbFBhcmFtZXRlcnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9u XSk6CisgICAgICAgIFJldHVybnMgYSBzdHJpbmcgcmVwcmVzZW50aW5nIGEgZGVzY3JpcHRpb24g Zm9yIHRoZSBhbGxvd2VkIGV4dGVuc2lvbnMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0Nv Y29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaDoKKwogMjAyMC0wNi0wNSAgQWRyaWFu IFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIE5vbi11bmlm aWVkIGJ1aWxkIGZpeGVzLCBlYXJseSBzdW1tZXIgMjAyMCBlZGl0aW9uCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaCBiL1NvdXJj ZS9XZWJDb3JlL1BBTC9wYWwvc3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCmluZGV4IGE0YTRk ZGQ1NDUyNjJlYTQ1NDhmNTRiY2QyODE0MTYzMmE2ZmMwNjkuLmNhNGVmZjM3OGMyODI0Mjg4OTY0 OGY0MzU3YzYzODU2ZjlhYTI2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCkBAIC0yNiwzICsyNiw1IEBACiAjcHJhZ21hIG9u Y2UKIAogZXh0ZXJuICJDIiB2b2lkIF9DU0NoZWNrRml4RGlzYWJsZSgpOworZXh0ZXJuICJDIiBD RkFycmF5UmVmIF9VVENvcHlEZWNsYXJlZFR5cGVJZGVudGlmaWVycyh2b2lkKTsKKwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1l dGVycy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBh cmFtZXRlcnMubW0KaW5kZXggOGUwYzhlZWQwYjlhYWU3YmVmZDRhOTYxYzA4ZDJlNjBhZjY2NmE3 MC4uZmE1MTIyNDk1MGZmNWFmZGM2YzMzMWVjOTRlNzE4ZTc4N2UyNTY1ZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5t bQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJh bWV0ZXJzLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNiBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAyMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKQEAgLTI1LDExICsyNSw2MSBAQAogCiAjaW1wb3J0ICJjb25maWcuaCIKICNpbXBvcnQg IldLT3BlblBhbmVsUGFyYW1ldGVyc0ludGVybmFsLmgiCisjaW1wb3J0IDxwYWwvc3BpL2NvY29h L0NvcmVTZXJ2aWNlc1NQSS5oPgogCiAjaWYgUExBVEZPUk0oTUFDKQogCiAjaW1wb3J0ICJXS05T QXJyYXkuaCIKIAorc3RhdGljIE5TU2V0PE5TU3RyaW5nICo+ICpleHRlbnNpb25zRm9yTUlNRVR5 cGUoTlNTdHJpbmcgKm1pbWV0eXBlKQoreworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRh aW5QdHI8TlNEaWN0aW9uYXJ5PE5TU3RyaW5nICosIE5TU2V0PE5TU3RyaW5nICo+ICo+Pj4gc19t aW1lVHlwZVRvRXh0ZW5zaW9uczsKKyAgICBzdGF0aWMgZGlzcGF0Y2hfb25jZV90IG9uY2VUb2tl bjsKKworICAgIGRpc3BhdGNoX29uY2UoJm9uY2VUb2tlbiwgXnsKKyAgICAgICAgTlNNdXRhYmxl RGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKj4gKm1pbWVU eXBlVG9FeHRlbnNpb25zID0gW05TTXV0YWJsZURpY3Rpb25hcnkgZGljdGlvbmFyeV07CisgICAg ICAgIFJldGFpblB0cjxOU0FycmF5PiBhbGxVVElzID0gYWRvcHRDRihfVVRDb3B5RGVjbGFyZWRU eXBlSWRlbnRpZmllcnMoKSk7CisKKyAgICAgICAgdm9pZCAoXmFkZEV4dGVuc2lvblRvTUlNRVR5 cGUpKE5TU3RyaW5nICptaW1lVHlwZSwgTlNTdHJpbmcgKmV4dGVuc2lvbikgPSBeKE5TU3RyaW5n ICptaW1lVHlwZSwgTlNTdHJpbmcgKmV4dGVuc2lvbikgeworICAgICAgICAgICAgaWYgKCFtaW1l VHlwZVRvRXh0ZW5zaW9uc1ttaW1lVHlwZV0pCisgICAgICAgICAgICAgICAgbWltZVR5cGVUb0V4 dGVuc2lvbnNbbWltZVR5cGVdID0gW05TTXV0YWJsZVNldCBzZXRdOworICAgICAgICAgICAgW21p bWVUeXBlVG9FeHRlbnNpb25zW21pbWVUeXBlXSBhZGRPYmplY3Q6ZXh0ZW5zaW9uXTsKKyAgICAg ICAgfTsKKworICAgICAgICB2b2lkICheYWRkRXh0ZW5zaW9uc1RvTUlNRVR5cGUpKE5TU3RyaW5n ICptaW1lVHlwZSwgTlNBcnJheTxOU1N0cmluZyAqPiAqZXh0ZW5zaW9ucykgPSBeKE5TU3RyaW5n ICptaW1lVHlwZSwgTlNBcnJheTxOU1N0cmluZyAqPiAqZXh0ZW5zaW9ucykgeworICAgICAgICAg ICAgTlNTdHJpbmcgKm1pbWVUeXBlV2lsZGNhcmQgPSBbW21pbWVUeXBlIGNvbXBvbmVudHNTZXBh cmF0ZWRCeVN0cmluZzpAIi8iXVswXSBzdHJpbmdCeUFwcGVuZGluZ1N0cmluZzpAIi8qIl07CisK KyAgICAgICAgICAgIGZvciAoTlNTdHJpbmcgKmV4dGVuc2lvbiBpbiBleHRlbnNpb25zKSB7Cisg ICAgICAgICAgICAgICAgaWYgKCFleHRlbnNpb24pCisgICAgICAgICAgICAgICAgICAgIGNvbnRp bnVlOworICAgICAgICAgICAgICAgIGFkZEV4dGVuc2lvblRvTUlNRVR5cGUobWltZVR5cGVXaWxk Y2FyZCwgZXh0ZW5zaW9uKTsKKyAgICAgICAgICAgICAgICBhZGRFeHRlbnNpb25Ub01JTUVUeXBl KG1pbWVUeXBlLCBleHRlbnNpb24pOworICAgICAgICAgICAgfQorICAgICAgICB9OworCisgICAg ICAgIGZvciAoTlNTdHJpbmcgKnV0aSBpbiBhbGxVVElzLmdldCgpKSB7CisgICAgICAgICAgICBS ZXRhaW5QdHI8TlNTdHJpbmc+IG1pbWVUeXBlID0gYWRvcHRDRihVVFR5cGVDb3B5UHJlZmVycmVk VGFnV2l0aENsYXNzKChfX2JyaWRnZSBDRlN0cmluZ1JlZikodXRpKSwga1VUVGFnQ2xhc3NNSU1F VHlwZSkpOworICAgICAgICAgICAgaWYgKCFtaW1lVHlwZSkKKyAgICAgICAgICAgICAgICBjb250 aW51ZTsKKyAgICAgICAgICAgIFJldGFpblB0cjxOU0FycmF5PiBleHRlbnNpb25zID0gYWRvcHRD RihVVFR5cGVDb3B5QWxsVGFnc1dpdGhDbGFzcygoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpKHV0aSks IGtVVFRhZ0NsYXNzRmlsZW5hbWVFeHRlbnNpb24pKTsKKyAgICAgICAgICAgIGFkZEV4dGVuc2lv bnNUb01JTUVUeXBlKG1pbWVUeXBlLmdldCgpLCBleHRlbnNpb25zLmdldCgpKTsKKyAgICAgICAg fQorICAgICAgICAKKyAgICAgICAgUmV0YWluUHRyPE5TRGljdGlvbmFyeTxOU1N0cmluZyAqLCBO U0FycmF5PE5TU3RyaW5nICo+ICo+PiB3aGl0ZWxpc3RlZE1pbWVUeXBlcyA9IGFkb3B0TlMoW1tO U0RpY3Rpb25hcnkgYWxsb2NdIGluaXRXaXRoT2JqZWN0c0FuZEtleXM6CisgICAgICAgICAgICBb TlNBcnJheSBhcnJheVdpdGhPYmplY3RzOiBAIndlYnAiICwgbmlsXSwgQCJpbWFnZS93ZWJwIiwK KyAgICAgICAgICAgIG5pbAorICAgICAgICBdKTsKKworICAgICAgICBbd2hpdGVsaXN0ZWRNaW1l VHlwZXMuZ2V0KCkgZW51bWVyYXRlS2V5c0FuZE9iamVjdHNVc2luZ0Jsb2NrOl4oTlNTdHJpbmcg Km1pbWVUeXBlLCBOU0FycmF5PE5TU3RyaW5nICo+ICpleHRlbnNpb25zLCBCT09MICopIHsKKyAg ICAgICAgICAgIGFkZEV4dGVuc2lvbnNUb01JTUVUeXBlKG1pbWVUeXBlLCBleHRlbnNpb25zKTsK KyAgICAgICAgfV07CisKKyAgICAgICAgc19taW1lVHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSA9IFtt aW1lVHlwZVRvRXh0ZW5zaW9ucyBjb3B5XTsKKyAgICB9KTsKKworICAgIHJldHVybiBbc19taW1l VHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSBvYmplY3RGb3JLZXk6bWltZXR5cGVdOworfQorCiBAaW1w bGVtZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wpYWxsb3dzTXVsdGlw bGVTZWxlY3Rpb24KQEAgLTYzLDYgKzExMyw1OCBAQAogICAgIHJldHVybiB3cmFwcGVyKF9vcGVu UGFuZWxQYXJhbWV0ZXJzLT5hY2NlcHRGaWxlRXh0ZW5zaW9ucygpKTsKIH0KIAorLSAoTlNBcnJh eTxOU1N0cmluZyAqPiAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnMKK3sKKyAgICAvLyBBZ2dyZWdh dGUgZXh0ZW5zaW9ucyBiYXNlZCBvbiBzcGVjaWZpZWQgTUlNRSB0eXBlcy4KKyAgICBOU0FycmF5 PE5TU3RyaW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1JTUVUeXBl c107CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyA9IFtz ZWxmIF9hY2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIE5TTXV0YWJsZVNldDxOU1N0cmlu ZyAqPiAqYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW05TTXV0YWJsZVNldCBzZXRdOworCisgICAg W2FjY2VwdGVkTUlNRVR5cGVzIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4oTlNTdHJpbmcg Km1pbWVUeXBlLCBOU1VJbnRlZ2VyIGluZGV4LCBCT09MKiBzdG9wKSB7CisgICAgICAgIEFTU0VS VChbbWltZVR5cGUgY29udGFpbnNTdHJpbmc6QCIvIl0pOworICAgICAgICBbYWxsb3dlZEZpbGVF eHRlbnNpb25zIHVuaW9uU2V0OmV4dGVuc2lvbnNGb3JNSU1FVHlwZShtaW1lVHlwZSldOworICAg IH1dOworCisgICAgTlNNdXRhYmxlQXJyYXk8TlNTdHJpbmcgKj4gKmFkZGl0aW9uYWxBbGxvd2Vk RmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXldOworICAgIFthY2NlcHRlZEZp bGVFeHRlbnNpb25zIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4oTlNTdHJpbmcgKmV4dGVu c2lvbiwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCAqc3RvcCkgeworICAgICAgICBBU1NFUlQoW2V4 dGVuc2lvbiBjaGFyYWN0ZXJBdEluZGV4OjBdID09ICcuJyk7CisgICAgICAgIFthZGRpdGlvbmFs QWxsb3dlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdDpbZXh0ZW5zaW9uIHN1YnN0cmluZ0Zyb21J bmRleDoxXV07CisgICAgfV07CisgICAgCisgICAgW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBhZGRP YmplY3RzRnJvbUFycmF5OmFkZGl0aW9uYWxBbGxvd2VkRmlsZUV4dGVuc2lvbnNdOworICAgIHJl dHVybiBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFsbE9iamVjdHNdOworfQorCistIChOU1N0cmlu ZyAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbgoreworICAgIE5TQXJyYXk8TlNT dHJpbmcgKj4gKmFjY2VwdGVkTUlNRVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5cGVzXTsK KyAgICBOU0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZEZpbGVFeHRlbnNpb25zID0gW3NlbGYg X2FjY2VwdGVkRmlsZUV4dGVuc2lvbnNdOworCisgICAgaWYgKCFbYWNjZXB0ZWRNSU1FVHlwZXMg Y291bnRdICYmICFbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pCisgICAgICAgIHJldHVy biBuaWw7CisKKyAgICBpZiAoIShbYWNjZXB0ZWRNSU1FVHlwZXMgY291bnRdID09IDEgJiYgIVth Y2NlcHRlZEZpbGVFeHRlbnNpb25zIGNvdW50XSkpCisgICAgICAgIHJldHVybiBAIkN1c3RvbSBG aWxlcyI7CisKKyAgICBOU1N0cmluZyAqbWltZVR5cGUgPSBbYWNjZXB0ZWRNSU1FVHlwZXMgZmly c3RPYmplY3RdOworICAgIE5TUmFuZ2UgcmFuZ2UgPSBbbWltZVR5cGUgcmFuZ2VPZlN0cmluZzpA Ii8iXTsKKyAgICAKKyAgICBpZiAoIXJhbmdlLmxlbmd0aCkKKyAgICAgICAgcmV0dXJuIEAiQ3Vz dG9tIEZpbGVzIjsKKyAgICAKKyAgICBOU1N0cmluZyAqbWltZVR5cGVQcmVmaXggPSBbbWltZVR5 cGUgc3Vic3RyaW5nVG9JbmRleDpyYW5nZS5sb2NhdGlvbl07CisgICAgTlNTdHJpbmcgKm1pbWVU eXBlU3VmZml4ID0gW21pbWVUeXBlIHN1YnN0cmluZ0Zyb21JbmRleDpyYW5nZS5sb2NhdGlvbiAr IDFdOworICAgIAorICAgIGlmIChbbWltZVR5cGVTdWZmaXggaXNFcXVhbFRvU3RyaW5nOkAiKiJd KQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCVAIEZpbGVz IiwgW1ttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdUb0luZGV4OjFdIHVwcGVyY2FzZVN0cmluZ10s IFttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdGcm9tSW5kZXg6MV1dOworCisgICAgaWYgKFttaW1l VHlwZVN1ZmZpeCBsZW5ndGhdIDw9IDQpCisgICAgICAgIHJldHVybiBbTlNTdHJpbmcgc3RyaW5n V2l0aEZvcm1hdDpAIiVAICVAIiwgW21pbWVUeXBlU3VmZml4IHVwcGVyY2FzZVN0cmluZ10sIG1p bWVUeXBlUHJlZml4XTsKKworICAgIHJldHVybiBbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpA IiVAICVAIiwgbWltZVR5cGVTdWZmaXgsIG1pbWVUeXBlUHJlZml4XTsKK30KKwogQGVuZAogCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09w ZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv Q29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCmluZGV4IDEzYmE3ZDgzZDY2NjQ3 YTQ2YjFjMzQxMzcwYjc4OTdlMjM0YWFjOGIuLjQxNGU1YmZhZDZmZTNjNjY4NzhkMjU4ZDA0ZDJm NTBlMmJhNmQ1ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaApAQCAtMzEsNiAr MzEsOCBAQAogCiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJyYXk8 TlNTdHJpbmcgKj4gKl9hY2NlcHRlZE1JTUVUeXBlcyBXS19BUElfQVZBSUxBQkxFKG1hY29zKDEw LjEzLjQpKTsKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSwgY29weSkgTlNBcnJheTxO U1N0cmluZyAqPiAqX2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlMQUJMRShtYWNv cygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5TQXJy YXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlMQUJMRSht YWNvcygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5T U3RyaW5nICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24gV0tfQVBJX0FWQUlMQUJM RShtYWNvcygxMC4xMy40KSk7CiAKIEBlbmQKIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGRhNDIyNzY3YTk4YWM4ODRkOTIwZmUxMWIzN2M3NzQw N2FhZGE4YjguLmJiNTQzN2FmMTE1ZDVkNGIwYzMwN2NkOTY4ZmZhZGQ5MzgxZGQ4MjggMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy MiBAQAorMjAyMC0wNi0wNiAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUu Y29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0PiBm aWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENyZWF0ZSBhIHZpZXcgd2l0aCBh biBOU1BvcHVwQnV0dG9uIGZvciB0aGUgZmlsZSBleHRlbnNpb25zIGZpbHRlci4gU2V0CisgICAg ICAgIHRoaXMgdmlldyBhcyB0aGUgQWNjZXNzb3J5VmlldyBvZiB0aGUgT3BlblBhbmVsLiBDcmVh dGUgYSBjdXN0b21pemVkIHRhcmdldAorICAgICAgICBmb3IgdGhlIE5TUG9wdXBCdXR0b24gdG8g cmVzcG9uZCB0byBjaGFuZ2luZyBpdHMgc2VsZWN0aW9uLgorCisgICAgICAgICogTWluaUJyb3dz ZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm06CisgICAgICAgICgtW0ZpbGVFeHRl bnNpb25zUG9wdXBUYXJnZXQgaW5pdFdpdGhPcGVuUGFuZWw6YWxsb3dlZEZpbGVFeHRlbnNpb25z Ol0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHBvcHVwQWN0aW9uOl0p OgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IGRlYWxsb2NdKToKKyAgICAg ICAgKC1bV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIgZGVhbGxvY10pOgorICAgICAgICAoLVtX SzJCcm93c2VyV2luZG93Q29udHJvbGxlciBjcmVhdGVGaWx0ZXJWaWV3OnBvcHVwVGFyZ2V0Ol0p OgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciB3ZWJWaWV3OnJ1bk9wZW5Q YW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6d2Vi VmlldzpydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczppbml0aWF0ZWRCeUZyYW1lOmNvbXBsZXRp b25IYW5kbGVyOl0pOgorCiAyMDIwLTA2LTA1ICBBbmR5IEVzdGVzICA8YWVzdGVzQGFwcGxlLmNv bT4KIAogICAgICAgICBbQXBwbGUgUGF5XSBSZW1vdmUgY29uZGl0aW9uYWxzIGZvciBFTkFCTEVf QVBQTEVfUEFZX1NFU1NJT05fVigzfDQpCmRpZmYgLS1naXQgYS9Ub29scy9NaW5pQnJvd3Nlci9t YWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubSBiL1Rvb2xzL01pbmlCcm93c2VyL21hYy9X SzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCmluZGV4IDBjYmY5YzQ1YjJiYTY4MTYxMWNiMzg4 Y2RlYWUyMGJiMWUyYzVmNTYuLmE5MmUzMTQ4NTBjMWE1MGJmOTZkODEyNjI2M2E2ZjRlNDA5YTQ5 YjQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29u dHJvbGxlci5tCisrKyBiL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2luZG93Q29u dHJvbGxlci5tCkBAIC0zMCw2ICszMCw3IEBACiAjaW1wb3J0IDxXZWJLaXQvV0tGcmFtZUluZm8u aD4KICNpbXBvcnQgPFdlYktpdC9XS05hdmlnYXRpb25BY3Rpb25Qcml2YXRlLmg+CiAjaW1wb3J0 IDxXZWJLaXQvV0tOYXZpZ2F0aW9uRGVsZWdhdGUuaD4KKyNpbXBvcnQgPFdlYktpdC9XS09wZW5Q YW5lbFBhcmFtZXRlcnNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tQcmVmZXJlbmNlc1By aXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XS1VJRGVsZWdhdGUuaD4KICNpbXBvcnQgPFdlYktp dC9XS1VJRGVsZWdhdGVQcml2YXRlLmg+CkBAIC03MSw2ICs3Miw0MSBAQCAtICh2b2lkKXBlcmZv cm1BY3Rpb246KE5TVGV4dEZpbmRlckFjdGlvbilvcAogCiBAZW5kCiAKKy8vIFRhcmdldCBmb3Ig dGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5QYW5lbCdzIEFjY2Vz c29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgOiBOU09iamVj dCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOworICAgIE5TQXJyYXk8 TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5kCisKK0BpbXBsZW1l bnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWluaXRXaXRoT3BlblBh bmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczooTlNBcnJh eTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAgaWYgKChzZWxmID0g W3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBhbmVsOworICAgICAg ICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBjb3B5XTsK KyAgICB9CisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpcG9wdXBBY3Rpb246KGlkKXNl bmRlciB7CisgICAgaWYgKFtzZW5kZXIgaW5kZXhPZlNlbGVjdGVkSXRlbV0pCisgICAgICAgIFtf b3BlblBhbmVsIHNldEFsbG93ZWRGaWxlVHlwZXM6bmlsXTsKKyAgICBlbHNlIGlmICghW19hbGxv d2VkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICBbX29wZW5QYW5lbCBzZXRBbGxvd2Vk RmlsZVR5cGVzOkBbQCIiXV07CisgICAgZWxzZQorICAgICAgICBbX29wZW5QYW5lbCBzZXRBbGxv d2VkRmlsZVR5cGVzOl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNdOworfQorCistICh2b2lkKWRlYWxs b2MKK3sKKyAgICBbX2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyByZWxlYXNlXTsKKyAgICBbc3VwZXIg ZGVhbGxvY107Cit9CisKK0BlbmQKKwogQGludGVyZmFjZSBXSzJCcm93c2VyV2luZG93Q29udHJv bGxlciAoKSA8TlNUZXh0RmluZGVyQmFyQ29udGFpbmVyLCBXS05hdmlnYXRpb25EZWxlZ2F0ZSwg V0tVSURlbGVnYXRlLCBfV0tJY29uTG9hZGluZ0RlbGVnYXRlPgogQGVuZAogCkBAIC04NSw2ICsx MjEsNyBAQCBAaW1wbGVtZW50YXRpb24gV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIgewogICAg IE1pbmlCcm93c2VyTlNUZXh0RmluZGVyICpfdGV4dEZpbmRlcjsKICAgICBOU1ZpZXcgKl90ZXh0 RmluZEJhclZpZXc7CiAgICAgQk9PTCBfZmluZEJhclZpc2libGU7CisgICAgRmlsZUV4dGVuc2lv bnNQb3B1cFRhcmdldCAqX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQ7CiB9CiAKIC0gKHZvaWQp YXdha2VGcm9tTmliCkBAIC0xNzAsNiArMjA3LDcgQEAgLSAodm9pZClkZWFsbG9jCiAKICAgICBb X3dlYlZpZXcgcmVsZWFzZV07CiAgICAgW19jb25maWd1cmF0aW9uIHJlbGVhc2VdOworICAgIFtf ZmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCByZWxlYXNlXTsKIAogICAgIFtzdXBlciBkZWFsbG9j XTsKIH0KQEAgLTU4Nyw2ICs2MjUsMzggQEAgLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZpZXcgKil3 ZWJWaWV3IHJ1bkphdmFTY3JpcHRUZXh0SW5wdXRQYW5lbFdpdGhQcm9tcHQ6KE5TU3QKICAgICB9 XTsKIH0KIAorLSAobnVsbGFibGUgTlNWaWV3ICopY3JlYXRlRmlsdGVyVmlldzooTlNTdHJpbmcg KilhbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbiBwb3B1cFRhcmdldDooRmlsZUV4dGVu c2lvbnNQb3B1cFRhcmdldCopcG9wdXBUYXJnZXQKK3sKKyAgICBOU1RleHRGaWVsZCogbGFiZWwg PSBbW1tOU1RleHRGaWVsZCBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU1plcm9SZWN0XSBhdXRvcmVs ZWFzZV07CisgICAgW2xhYmVsIHNldFN0cmluZ1ZhbHVlOkAiRm9ybWF0OiJdOworICAgIFtsYWJl bCBzZXRFZGl0YWJsZTpOT107CisgICAgW2xhYmVsIHNldFNlbGVjdGFibGU6Tk9dOworICAgIFts YWJlbCBzZXRCb3JkZXJlZDpOT107CisgICAgW2xhYmVsIHNldEJhY2tncm91bmRDb2xvcjpbTlND b2xvciBjbGVhckNvbG9yXV07CisgICAgW2xhYmVsIHNldEFsaWdubWVudDpOU1RleHRBbGlnbm1l bnRSaWdodF07CisKKyAgICBOU1BvcFVwQnV0dG9uICpidXR0b24gPSBbW1tOU1BvcFVwQnV0dG9u IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TWmVyb1JlY3QgcHVsbHNEb3duOk5PXSBhdXRvcmVsZWFz ZV07CisgICAgaWYgKGFsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9uKQorICAgICAgICBb YnV0dG9uIGFkZEl0ZW1XaXRoVGl0bGU6YWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb25d OworICAgIFtidXR0b24gYWRkSXRlbVdpdGhUaXRsZTpAIkFsbCBGaWxlcyAgICAgICAgICAgICAg ICAgICAgICAgICAgIl07CisgICAgW2J1dHRvbiBzZXRUYXJnZXQ6cG9wdXBUYXJnZXRdOworICAg IFtidXR0b24gc2V0QWN0aW9uOkBzZWxlY3Rvcihwb3B1cEFjdGlvbjopXTsKKyAgICBbYnV0dG9u IHNlbGVjdEl0ZW1BdEluZGV4OjBdOworICAgIFtwb3B1cFRhcmdldCBwb3B1cEFjdGlvbjpidXR0 b25dOworCisgICAgTlNTdGFja1ZpZXcqIGhvcml6b250YWxWaWV3ID0gW1tbTlNTdGFja1ZpZXcg YWxsb2NdIGluaXRXaXRoRnJhbWU6TlNaZXJvUmVjdF0gYXV0b3JlbGVhc2VdOworICAgIFtob3Jp em9udGFsVmlldyBzZXREaXN0cmlidXRpb246TlNTdGFja1ZpZXdEaXN0cmlidXRpb25GaWxsRXF1 YWxseV07CisgICAgW2hvcml6b250YWxWaWV3IHNldFNwYWNpbmc6Ml07CisgICAgW2hvcml6b250 YWxWaWV3IGFkZEFycmFuZ2VkU3VidmlldzpsYWJlbF07CisgICAgW2hvcml6b250YWxWaWV3IGFk ZEFycmFuZ2VkU3VidmlldzpidXR0b25dOworCisgICAgTlNTdGFja1ZpZXcqIGZpbHRlclZpZXcg PSBbW1tOU1N0YWNrVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU1plcm9SZWN0XSBhdXRvcmVs ZWFzZV07CisgICAgW2ZpbHRlclZpZXcgc2V0T3JpZW50YXRpb246TlNVc2VySW50ZXJmYWNlTGF5 b3V0T3JpZW50YXRpb25WZXJ0aWNhbF07CisgICAgW2ZpbHRlclZpZXcgc2V0RWRnZUluc2V0czpO U0VkZ2VJbnNldHNNYWtlKDIwLCAyMCwgMjAsIDIwKV07CisgICAgW2ZpbHRlclZpZXcgYWRkQXJy YW5nZWRTdWJ2aWV3Omhvcml6b250YWxWaWV3XTsKKyAgICByZXR1cm4gZmlsdGVyVmlldzsKK30K KwogI2lmIF9faGFzX2ZlYXR1cmUob2JqY19nZW5lcmljcykKIC0gKHZvaWQpd2ViVmlldzooV0tX ZWJWaWV3ICopd2ViVmlldyBydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczooV0tPcGVuUGFuZWxQ YXJhbWV0ZXJzICopcGFyYW1ldGVycyBpbml0aWF0ZWRCeUZyYW1lOihXS0ZyYW1lSW5mbyAqKWZy YW1lIGNvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShOU0FycmF5PE5TVVJMICo+ICogVVJMcykp Y29tcGxldGlvbkhhbmRsZXIKICNlbHNlCkBAIC01OTcsNiArNjY3LDEzIEBAIC0gKHZvaWQpd2Vi VmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczooV0tP cGVuUGFuZWxQYXJhCiAKICAgICBvcGVuUGFuZWwuYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb24gPSBw YXJhbWV0ZXJzLmFsbG93c011bHRpcGxlU2VsZWN0aW9uOwogCisgICAgW19maWxlRXh0ZW5zaW9u c1BvcHVwVGFyZ2V0IHJlbGVhc2VdOworICAgIF9maWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0ID0g W1tGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IGFsbG9jXSBpbml0V2l0aE9wZW5QYW5lbDogb3Bl blBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczogcGFyYW1ldGVycy5fYWxsb3dlZEZpbGVFeHRl bnNpb25zXTsKKworICAgIE5TVmlldyAqZmlsdGVyVmlldyA9IFtzZWxmIGNyZWF0ZUZpbHRlclZp ZXc6cGFyYW1ldGVycy5fYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24gcG9wdXBUYXJn ZXQ6X2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXRdOworICAgIGlmIChmaWx0ZXJWaWV3KQorICAg ICAgICBbb3BlblBhbmVsIHNldEFjY2Vzc29yeVZpZXc6ZmlsdGVyVmlld107CisKICAgICBbb3Bl blBhbmVsIGJlZ2luU2hlZXRNb2RhbEZvcldpbmRvdzp3ZWJWaWV3LndpbmRvdyBjb21wbGV0aW9u SGFuZGxlcjpeKE5TSW50ZWdlciByZXN1bHQpIHsKICAgICAgICAgaWYgKHJlc3VsdCA9PSBOU01v ZGFsUmVzcG9uc2VPSykKICAgICAgICAgICAgIGNvbXBsZXRpb25IYW5kbGVyKG9wZW5QYW5lbC5V UkxzKTsK 401407 2020-06-08 18:52:19 -0700 2020-06-10 22:16:48 -0700 Patch bug-212485-20200608185218.patch text/plain 15892 sabouhallawa U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q QUwvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCAxYjgwMTQ5 OTVlMDY5YWQzMGI5MWRhYzg0ZmRiNDNiMmFjMDRlODcwLi41MzA3YzFmMmZkM2E0ZTc2NTZmY2Ji OWI1ZjAwY2U5MGNmNzc2NTJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAor MjAyMC0wNi0wOCAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FAYXBwbGUuY29tPgor CisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlucHV0PiBmaWxlIGVs ZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4cG9zZSBhbiBTUEkgZnJvbSBDb3JlU2Vy dmNpZXMgdG8gZ2V0IGFsbCB0aGUgVVRJcyBrbm93biBieSB0aGUgc3lzdGVtLgorCisgICAgICAg ICogcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaDoKKwogMjAyMC0wNi0wNSAgQW5keSBF c3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAKICAgICAgICAgW0FwcGxlIFBheV0gUmVtb3ZlIGNv bmRpdGlvbmFscyBmb3IgRU5BQkxFX0FQUExFX1BBWV9TRVNTSU9OX1YoM3w0KQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRl eCAzYWEzM2FkOTFhZjk5YWJlYThhNjhmMGZiNDE2OWUwZmFhODU2NjkyLi4yNDFkNzUwMTE5NzQ4 NzZlMTYzM2EwMjFlNTk2MGI4MDdjZWRkOTNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisy MDIwLTA2LTA4ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisK KyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxl bWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHR3byBwcml2YXRlIGhlbHBlcnMgdG8g V0tPcGVuUGFuZWxQYXJhbWV0ZXJzLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9Db2NvYS9X S09wZW5QYW5lbFBhcmFtZXRlcnMubW06CisgICAgICAgICgtW1dLT3BlblBhbmVsUGFyYW1ldGVy cyBfYWxsb3dlZEZpbGVFeHRlbnNpb25zXSk6CisgICAgICAgIFJldHVybnMgYW4gYXJyYXkgb2Yg c3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGFsbG93ZWQgZXh0ZW5zaW9ucy4KKworICAgICAgICAo LVtXS09wZW5QYW5lbFBhcmFtZXRlcnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc0Rlc2NyaXB0aW9u XSk6CisgICAgICAgIFJldHVybnMgYSBzdHJpbmcgcmVwcmVzZW50aW5nIGEgZGVzY3JpcHRpb24g Zm9yIHRoZSBhbGxvd2VkIGV4dGVuc2lvbnMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0Nv Y29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaDoKKwogMjAyMC0wNi0wNSAgQWRyaWFu IFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIE5vbi11bmlm aWVkIGJ1aWxkIGZpeGVzLCBlYXJseSBzdW1tZXIgMjAyMCBlZGl0aW9uCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaCBiL1NvdXJj ZS9XZWJDb3JlL1BBTC9wYWwvc3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCmluZGV4IGE0YTRk ZGQ1NDUyNjJlYTQ1NDhmNTRiY2QyODE0MTYzMmE2ZmMwNjkuLmNhNGVmZjM3OGMyODI0Mjg4OTY0 OGY0MzU3YzYzODU2ZjlhYTI2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3BpL2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oCkBAIC0yNiwzICsyNiw1IEBACiAjcHJhZ21hIG9u Y2UKIAogZXh0ZXJuICJDIiB2b2lkIF9DU0NoZWNrRml4RGlzYWJsZSgpOworZXh0ZXJuICJDIiBD RkFycmF5UmVmIF9VVENvcHlEZWNsYXJlZFR5cGVJZGVudGlmaWVycyh2b2lkKTsKKwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1l dGVycy5tbSBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBh cmFtZXRlcnMubW0KaW5kZXggOGUwYzhlZWQwYjlhYWU3YmVmZDRhOTYxYzA4ZDJlNjBhZjY2NmE3 MC4uNjM2YjIzZjcxZmQ0NzQwMDVlM2IzODk3YTU4OTk0YmJmY2I1OTVjOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVycy5t bQorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJh bWV0ZXJzLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNiBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAyMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKQEAgLTI1LDExICsyNSw2MSBAQAogCiAjaW1wb3J0ICJjb25maWcuaCIKICNpbXBvcnQg IldLT3BlblBhbmVsUGFyYW1ldGVyc0ludGVybmFsLmgiCisjaW1wb3J0IDxwYWwvc3BpL2NvY29h L0NvcmVTZXJ2aWNlc1NQSS5oPgogCiAjaWYgUExBVEZPUk0oTUFDKQogCiAjaW1wb3J0ICJXS05T QXJyYXkuaCIKIAorc3RhdGljIE5TU2V0PE5TU3RyaW5nICo+ICpleHRlbnNpb25zRm9yTUlNRVR5 cGUoTlNTdHJpbmcgKm1pbWV0eXBlKQoreworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxSZXRh aW5QdHI8TlNEaWN0aW9uYXJ5PE5TU3RyaW5nICosIE5TU2V0PE5TU3RyaW5nICo+ICo+Pj4gc19t aW1lVHlwZVRvRXh0ZW5zaW9uczsKKyAgICBzdGF0aWMgZGlzcGF0Y2hfb25jZV90IG9uY2VUb2tl bjsKKworICAgIGRpc3BhdGNoX29uY2UoJm9uY2VUb2tlbiwgXnsKKyAgICAgICAgTlNNdXRhYmxl RGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU011dGFibGVTZXQ8TlNTdHJpbmcgKj4gKj4gKm1pbWVU eXBlVG9FeHRlbnNpb25zID0gW05TTXV0YWJsZURpY3Rpb25hcnkgZGljdGlvbmFyeV07CisgICAg ICAgIFJldGFpblB0cjxOU0FycmF5PiBhbGxVVElzID0gYWRvcHRDRihfVVRDb3B5RGVjbGFyZWRU eXBlSWRlbnRpZmllcnMoKSk7CisKKyAgICAgICAgdm9pZCAoXmFkZEV4dGVuc2lvbkZvck1JTUVU eXBlKShOU1N0cmluZyAqbWltZVR5cGUsIE5TU3RyaW5nICpleHRlbnNpb24pID0gXihOU1N0cmlu ZyAqbWltZVR5cGUsIE5TU3RyaW5nICpleHRlbnNpb24pIHsKKyAgICAgICAgICAgIGlmICghbWlt ZVR5cGVUb0V4dGVuc2lvbnNbbWltZVR5cGVdKQorICAgICAgICAgICAgICAgIG1pbWVUeXBlVG9F eHRlbnNpb25zW21pbWVUeXBlXSA9IFtOU011dGFibGVTZXQgc2V0XTsKKyAgICAgICAgICAgIFtt aW1lVHlwZVRvRXh0ZW5zaW9uc1ttaW1lVHlwZV0gYWRkT2JqZWN0OmV4dGVuc2lvbl07CisgICAg ICAgIH07CisKKyAgICAgICAgdm9pZCAoXmFkZEV4dGVuc2lvbnNGb3JNSU1FVHlwZSkoTlNTdHJp bmcgKm1pbWVUeXBlLCBOU0FycmF5PE5TU3RyaW5nICo+ICpleHRlbnNpb25zKSA9IF4oTlNTdHJp bmcgKm1pbWVUeXBlLCBOU0FycmF5PE5TU3RyaW5nICo+ICpleHRlbnNpb25zKSB7CisgICAgICAg ICAgICBOU1N0cmluZyAqd2lsZGNhcmRNSU1FVHlwZSA9IFtbbWltZVR5cGUgY29tcG9uZW50c1Nl cGFyYXRlZEJ5U3RyaW5nOkAiLyJdWzBdIHN0cmluZ0J5QXBwZW5kaW5nU3RyaW5nOkAiLyoiXTsK KworICAgICAgICAgICAgZm9yIChOU1N0cmluZyAqZXh0ZW5zaW9uIGluIGV4dGVuc2lvbnMpIHsK KyAgICAgICAgICAgICAgICBpZiAoIWV4dGVuc2lvbikKKyAgICAgICAgICAgICAgICAgICAgY29u dGludWU7CisgICAgICAgICAgICAgICAgYWRkRXh0ZW5zaW9uRm9yTUlNRVR5cGUod2lsZGNhcmRN SU1FVHlwZSwgZXh0ZW5zaW9uKTsKKyAgICAgICAgICAgICAgICBhZGRFeHRlbnNpb25Gb3JNSU1F VHlwZShtaW1lVHlwZSwgZXh0ZW5zaW9uKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfTsKKwor ICAgICAgICBmb3IgKE5TU3RyaW5nICp1dGkgaW4gYWxsVVRJcy5nZXQoKSkgeworICAgICAgICAg ICAgUmV0YWluUHRyPE5TU3RyaW5nPiBtaW1lVHlwZSA9IGFkb3B0Q0YoVVRUeXBlQ29weVByZWZl cnJlZFRhZ1dpdGhDbGFzcygoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpKHV0aSksIGtVVFRhZ0NsYXNz TUlNRVR5cGUpKTsKKyAgICAgICAgICAgIGlmICghbWltZVR5cGUpCisgICAgICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgICAgICBSZXRhaW5QdHI8TlNBcnJheT4gZXh0ZW5zaW9ucyA9IGFk b3B0Q0YoVVRUeXBlQ29weUFsbFRhZ3NXaXRoQ2xhc3MoKF9fYnJpZGdlIENGU3RyaW5nUmVmKSh1 dGkpLCBrVVRUYWdDbGFzc0ZpbGVuYW1lRXh0ZW5zaW9uKSk7CisgICAgICAgICAgICBhZGRFeHRl bnNpb25zRm9yTUlNRVR5cGUobWltZVR5cGUuZ2V0KCksIGV4dGVuc2lvbnMuZ2V0KCkpOworICAg ICAgICB9CisgICAgICAgIAorICAgICAgICBSZXRhaW5QdHI8TlNEaWN0aW9uYXJ5PE5TU3RyaW5n ICosIE5TQXJyYXk8TlNTdHJpbmcgKj4gKj4+IHdoaXRlbGlzdGVkTWltZVR5cGVzID0gYWRvcHRO UyhbW05TRGljdGlvbmFyeSBhbGxvY10gaW5pdFdpdGhPYmplY3RzQW5kS2V5czoKKyAgICAgICAg ICAgIFtOU0FycmF5IGFycmF5V2l0aE9iamVjdHM6IEAid2VicCIgLCBuaWxdLCBAImltYWdlL3dl YnAiLAorICAgICAgICAgICAgbmlsCisgICAgICAgIF0pOworCisgICAgICAgIFt3aGl0ZWxpc3Rl ZE1pbWVUeXBlcy5nZXQoKSBlbnVtZXJhdGVLZXlzQW5kT2JqZWN0c1VzaW5nQmxvY2s6XihOU1N0 cmluZyAqbWltZVR5cGUsIE5TQXJyYXk8TlNTdHJpbmcgKj4gKmV4dGVuc2lvbnMsIEJPT0wgKikg eworICAgICAgICAgICAgYWRkRXh0ZW5zaW9uc0Zvck1JTUVUeXBlKG1pbWVUeXBlLCBleHRlbnNp b25zKTsKKyAgICAgICAgfV07CisKKyAgICAgICAgc19taW1lVHlwZVRvRXh0ZW5zaW9ucy5nZXQo KSA9IFttaW1lVHlwZVRvRXh0ZW5zaW9ucyBjb3B5XTsKKyAgICB9KTsKKworICAgIHJldHVybiBb c19taW1lVHlwZVRvRXh0ZW5zaW9ucy5nZXQoKSBvYmplY3RGb3JLZXk6bWltZXR5cGVdOworfQor CiBAaW1wbGVtZW50YXRpb24gV0tPcGVuUGFuZWxQYXJhbWV0ZXJzCiAKIC0gKEJPT0wpYWxsb3dz TXVsdGlwbGVTZWxlY3Rpb24KQEAgLTYzLDYgKzExMyw1OCBAQAogICAgIHJldHVybiB3cmFwcGVy KF9vcGVuUGFuZWxQYXJhbWV0ZXJzLT5hY2NlcHRGaWxlRXh0ZW5zaW9ucygpKTsKIH0KIAorLSAo TlNBcnJheTxOU1N0cmluZyAqPiAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnMKK3sKKyAgICAvLyBB Z2dyZWdhdGUgZXh0ZW5zaW9ucyBiYXNlZCBvbiBzcGVjaWZpZWQgTUlNRSB0eXBlcy4KKyAgICBO U0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRlZE1J TUVUeXBlc107CisgICAgTlNBcnJheTxOU1N0cmluZyAqPiAqYWNjZXB0ZWRGaWxlRXh0ZW5zaW9u cyA9IFtzZWxmIF9hY2NlcHRlZEZpbGVFeHRlbnNpb25zXTsKKworICAgIE5TTXV0YWJsZVNldDxO U1N0cmluZyAqPiAqYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW05TTXV0YWJsZVNldCBzZXRdOwor CisgICAgW2FjY2VwdGVkTUlNRVR5cGVzIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4oTlNT dHJpbmcgKm1pbWVUeXBlLCBOU1VJbnRlZ2VyIGluZGV4LCBCT09MKiBzdG9wKSB7CisgICAgICAg IEFTU0VSVChbbWltZVR5cGUgY29udGFpbnNTdHJpbmc6QCIvIl0pOworICAgICAgICBbYWxsb3dl ZEZpbGVFeHRlbnNpb25zIHVuaW9uU2V0OmV4dGVuc2lvbnNGb3JNSU1FVHlwZShtaW1lVHlwZSld OworICAgIH1dOworCisgICAgTlNNdXRhYmxlQXJyYXk8TlNTdHJpbmcgKj4gKmFkZGl0aW9uYWxB bGxvd2VkRmlsZUV4dGVuc2lvbnMgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXldOworICAgIFthY2Nl cHRlZEZpbGVFeHRlbnNpb25zIGVudW1lcmF0ZU9iamVjdHNVc2luZ0Jsb2NrOl4oTlNTdHJpbmcg KmV4dGVuc2lvbiwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCAqc3RvcCkgeworICAgICAgICBBU1NF UlQoW2V4dGVuc2lvbiBjaGFyYWN0ZXJBdEluZGV4OjBdID09ICcuJyk7CisgICAgICAgIFthZGRp dGlvbmFsQWxsb3dlZEZpbGVFeHRlbnNpb25zIGFkZE9iamVjdDpbZXh0ZW5zaW9uIHN1YnN0cmlu Z0Zyb21JbmRleDoxXV07CisgICAgfV07CisgICAgCisgICAgW2FsbG93ZWRGaWxlRXh0ZW5zaW9u cyBhZGRPYmplY3RzRnJvbUFycmF5OmFkZGl0aW9uYWxBbGxvd2VkRmlsZUV4dGVuc2lvbnNdOwor ICAgIHJldHVybiBbYWxsb3dlZEZpbGVFeHRlbnNpb25zIGFsbE9iamVjdHNdOworfQorCistIChO U1N0cmluZyAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbgoreworICAgIE5TQXJy YXk8TlNTdHJpbmcgKj4gKmFjY2VwdGVkTUlNRVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5 cGVzXTsKKyAgICBOU0FycmF5PE5TU3RyaW5nICo+ICphY2NlcHRlZEZpbGVFeHRlbnNpb25zID0g W3NlbGYgX2FjY2VwdGVkRmlsZUV4dGVuc2lvbnNdOworCisgICAgaWYgKCFbYWNjZXB0ZWRNSU1F VHlwZXMgY291bnRdICYmICFbYWNjZXB0ZWRGaWxlRXh0ZW5zaW9ucyBjb3VudF0pCisgICAgICAg IHJldHVybiBuaWw7CisKKyAgICBpZiAoIShbYWNjZXB0ZWRNSU1FVHlwZXMgY291bnRdID09IDEg JiYgIVthY2NlcHRlZEZpbGVFeHRlbnNpb25zIGNvdW50XSkpCisgICAgICAgIHJldHVybiBAIkN1 c3RvbSBGaWxlcyI7CisKKyAgICBOU1N0cmluZyAqbWltZVR5cGUgPSBbYWNjZXB0ZWRNSU1FVHlw ZXMgZmlyc3RPYmplY3RdOworICAgIE5TUmFuZ2UgcmFuZ2UgPSBbbWltZVR5cGUgcmFuZ2VPZlN0 cmluZzpAIi8iXTsKKyAgICAKKyAgICBpZiAoIXJhbmdlLmxlbmd0aCkKKyAgICAgICAgcmV0dXJu IEAiQ3VzdG9tIEZpbGVzIjsKKyAgICAKKyAgICBOU1N0cmluZyAqbWltZVR5cGVQcmVmaXggPSBb bWltZVR5cGUgc3Vic3RyaW5nVG9JbmRleDpyYW5nZS5sb2NhdGlvbl07CisgICAgTlNTdHJpbmcg Km1pbWVUeXBlU3VmZml4ID0gW21pbWVUeXBlIHN1YnN0cmluZ0Zyb21JbmRleDpyYW5nZS5sb2Nh dGlvbiArIDFdOworICAgIAorICAgIGlmIChbbWltZVR5cGVTdWZmaXggaXNFcXVhbFRvU3RyaW5n OkAiKiJdKQorICAgICAgICByZXR1cm4gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCVA IEZpbGVzIiwgW1ttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdUb0luZGV4OjFdIHVwcGVyY2FzZVN0 cmluZ10sIFttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdGcm9tSW5kZXg6MV1dOworCisgICAgaWYg KFttaW1lVHlwZVN1ZmZpeCBsZW5ndGhdIDw9IDQpCisgICAgICAgIHJldHVybiBbTlNTdHJpbmcg c3RyaW5nV2l0aEZvcm1hdDpAIiVAICVAIiwgW21pbWVUeXBlU3VmZml4IHVwcGVyY2FzZVN0cmlu Z10sIG1pbWVUeXBlUHJlZml4XTsKKworICAgIHJldHVybiBbTlNTdHJpbmcgc3RyaW5nV2l0aEZv cm1hdDpAIiVAICVAIiwgbWltZVR5cGVTdWZmaXgsIG1pbWVUeXBlUHJlZml4XTsKK30KKwogQGVu ZAogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2Nv YS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCmluZGV4IDEzYmE3ZDgz ZDY2NjQ3YTQ2YjFjMzQxMzcwYjc4OTdlMjM0YWFjOGIuLjQxNGU1YmZhZDZmZTNjNjY4NzhkMjU4 ZDA0ZDJmNTBlMmJhNmQ1ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQ SS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVsUGFyYW1ldGVyc1ByaXZhdGUuaApAQCAt MzEsNiArMzEsOCBAQAogCiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkpIE5T QXJyYXk8TlNTdHJpbmcgKj4gKl9hY2NlcHRlZE1JTUVUeXBlcyBXS19BUElfQVZBSUxBQkxFKG1h Y29zKDEwLjEzLjQpKTsKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSwgY29weSkgTlNB cnJheTxOU1N0cmluZyAqPiAqX2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlMQUJM RShtYWNvcygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkp IE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnMgV0tfQVBJX0FWQUlM QUJMRShtYWNvcygxMC4xMy40KSk7CitAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNv cHkpIE5TU3RyaW5nICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zRGVzY3JpcHRpb24gV0tfQVBJX0FW QUlMQUJMRShtYWNvcygxMC4xMy40KSk7CiAKIEBlbmQKIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hh bmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGRhNDIyNzY3YTk4YWM4ODRkOTIwZmUxMWIz N2M3NzQwN2FhZGE4YjguLmJmZTY5MTU5M2E1MTNkZDI0NzM4Y2QxM2ZiMzQyY2I0YmMyNTExMWQg MTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMiBAQAorMjAyMC0wNi0wOCAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxhd2FA YXBwbGUuY29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBvZiB0aGUgPGlu cHV0PiBmaWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0ZXIKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4NQorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENyZWF0ZSBhIHZpZXcg d2l0aCBhbiBOU1BvcHVwQnV0dG9uIGZvciB0aGUgZmlsZSBleHRlbnNpb25zIGZpbHRlci4gU2V0 CisgICAgICAgIHRoaXMgdmlldyBhcyB0aGUgQWNjZXNzb3J5VmlldyBvZiB0aGUgT3BlblBhbmVs LiBDcmVhdGUgYSBjdXN0b21pemVkIHRhcmdldAorICAgICAgICBmb3IgdGhlIE5TUG9wdXBCdXR0 b24gdG8gcmVzcG9uZCB0byBjaGFuZ2luZyBpdHMgc2VsZWN0aW9uLgorCisgICAgICAgICogTWlu aUJyb3dzZXIvbWFjL1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyLm06CisgICAgICAgICgtW0Zp bGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgaW5pdFdpdGhPcGVuUGFuZWw6YWxsb3dlZEZpbGVFeHRl bnNpb25zOl0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHBvcHVwQWN0 aW9uOl0pOgorICAgICAgICAoLVtGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IGRlYWxsb2NdKToK KyAgICAgICAgKC1bV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIgZGVhbGxvY10pOgorICAgICAg ICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciBjcmVhdGVGaWx0ZXJWaWV3OnBvcHVwVGFy Z2V0Ol0pOgorICAgICAgICAoLVtXSzJCcm93c2VyV2luZG93Q29udHJvbGxlciB3ZWJWaWV3OnJ1 bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRs ZXI6d2ViVmlldzpydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczppbml0aWF0ZWRCeUZyYW1lOmNv bXBsZXRpb25IYW5kbGVyOl0pOgorCiAyMDIwLTA2LTA1ICBBbmR5IEVzdGVzICA8YWVzdGVzQGFw cGxlLmNvbT4KIAogICAgICAgICBbQXBwbGUgUGF5XSBSZW1vdmUgY29uZGl0aW9uYWxzIGZvciBF TkFCTEVfQVBQTEVfUEFZX1NFU1NJT05fVigzfDQpCmRpZmYgLS1naXQgYS9Ub29scy9NaW5pQnJv d3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubSBiL1Rvb2xzL01pbmlCcm93c2Vy L21hYy9XSzJCcm93c2VyV2luZG93Q29udHJvbGxlci5tCmluZGV4IDBjYmY5YzQ1YjJiYTY4MTYx MWNiMzg4Y2RlYWUyMGJiMWUyYzVmNTYuLmViM2M5MmM0Zjk2ZjlhOWIyZmM2OTYwZDA4NDRiNjlj MmViODQ3NzIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2lu ZG93Q29udHJvbGxlci5tCisrKyBiL1Rvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2lu ZG93Q29udHJvbGxlci5tCkBAIC0zMCw2ICszMCw3IEBACiAjaW1wb3J0IDxXZWJLaXQvV0tGcmFt ZUluZm8uaD4KICNpbXBvcnQgPFdlYktpdC9XS05hdmlnYXRpb25BY3Rpb25Qcml2YXRlLmg+CiAj aW1wb3J0IDxXZWJLaXQvV0tOYXZpZ2F0aW9uRGVsZWdhdGUuaD4KKyNpbXBvcnQgPFdlYktpdC9X S09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tQcmVmZXJl bmNlc1ByaXZhdGUuaD4KICNpbXBvcnQgPFdlYktpdC9XS1VJRGVsZWdhdGUuaD4KICNpbXBvcnQg PFdlYktpdC9XS1VJRGVsZWdhdGVQcml2YXRlLmg+CkBAIC03MSw2ICs3Miw0MSBAQCAtICh2b2lk KXBlcmZvcm1BY3Rpb246KE5TVGV4dEZpbmRlckFjdGlvbilvcAogCiBAZW5kCiAKKy8vIFRhcmdl dCBmb3IgdGhlIEZpbGVFeHRlbnNpb25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5QYW5lbCdz IEFjY2Vzc29yeVZpZXcuCitAaW50ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgOiBO U09iamVjdCB7CitAcHJpdmF0ZQorICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOworICAgIE5T QXJyYXk8TlNTdHJpbmcgKj4gKl9hbGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5kCisKK0Bp bXBsZW1lbnRhdGlvbiBGaWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWluaXRXaXRo T3BlblBhbmVsOihOU09wZW5QYW5lbCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczoo TlNBcnJheTxOU1N0cmluZyAqPiAqKWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAgaWYgKChz ZWxmID0gW3N1cGVyIGluaXRdKSkgeworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBhbmVsOwor ICAgICAgICBfYWxsb3dlZEZpbGVFeHRlbnNpb25zID0gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBj b3B5XTsKKyAgICB9CisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpcG9wdXBBY3Rpb246 KGlkKXNlbmRlciB7CisgICAgaWYgKFtzZW5kZXIgaW5kZXhPZlNlbGVjdGVkSXRlbV0pCisgICAg ICAgIFtfb3BlblBhbmVsIHNldEFsbG93ZWRGaWxlVHlwZXM6bmlsXTsKKyAgICBlbHNlIGlmICgh W19hbGxvd2VkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICBbX29wZW5QYW5lbCBzZXRB bGxvd2VkRmlsZVR5cGVzOkBbQCIiXV07CisgICAgZWxzZQorICAgICAgICBbX29wZW5QYW5lbCBz ZXRBbGxvd2VkRmlsZVR5cGVzOl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNdOworfQorCistICh2b2lk KWRlYWxsb2MKK3sKKyAgICBbX2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyByZWxlYXNlXTsKKyAgICBb c3VwZXIgZGVhbGxvY107Cit9CisKK0BlbmQKKwogQGludGVyZmFjZSBXSzJCcm93c2VyV2luZG93 Q29udHJvbGxlciAoKSA8TlNUZXh0RmluZGVyQmFyQ29udGFpbmVyLCBXS05hdmlnYXRpb25EZWxl Z2F0ZSwgV0tVSURlbGVnYXRlLCBfV0tJY29uTG9hZGluZ0RlbGVnYXRlPgogQGVuZAogCkBAIC04 NSw2ICsxMjEsNyBAQCBAaW1wbGVtZW50YXRpb24gV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIg ewogICAgIE1pbmlCcm93c2VyTlNUZXh0RmluZGVyICpfdGV4dEZpbmRlcjsKICAgICBOU1ZpZXcg Kl90ZXh0RmluZEJhclZpZXc7CiAgICAgQk9PTCBfZmluZEJhclZpc2libGU7CisgICAgRmlsZUV4 dGVuc2lvbnNQb3B1cFRhcmdldCAqX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQ7CiB9CiAKIC0g KHZvaWQpYXdha2VGcm9tTmliCkBAIC0xNzAsNiArMjA3LDcgQEAgLSAodm9pZClkZWFsbG9jCiAK ICAgICBbX3dlYlZpZXcgcmVsZWFzZV07CiAgICAgW19jb25maWd1cmF0aW9uIHJlbGVhc2VdOwor ICAgIFtfZmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCByZWxlYXNlXTsKIAogICAgIFtzdXBlciBk ZWFsbG9jXTsKIH0KQEAgLTU4Nyw2ICs2MjUsNTQgQEAgLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZp ZXcgKil3ZWJWaWV3IHJ1bkphdmFTY3JpcHRUZXh0SW5wdXRQYW5lbFdpdGhQcm9tcHQ6KE5TU3QK ICAgICB9XTsKIH0KIAorLSAobnVsbGFibGUgTlNWaWV3ICopY3JlYXRlRmlsdGVyVmlldzooTlNB cnJheSAqKXRpdGxlcyBwb3B1cFRhcmdldDooRmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldCopcG9w dXBUYXJnZXQKK3sKKyAgICBOU1RleHRGaWVsZCogbGFiZWwgPSBbW1tOU1RleHRGaWVsZCBhbGxv Y10gaW5pdFdpdGhGcmFtZTpOU1plcm9SZWN0XSBhdXRvcmVsZWFzZV07CisgICAgW2xhYmVsIHNl dFN0cmluZ1ZhbHVlOkAiRm9ybWF0OiJdOworICAgIFtsYWJlbCBzZXRFZGl0YWJsZTpOT107Cisg ICAgW2xhYmVsIHNldFNlbGVjdGFibGU6Tk9dOworICAgIFtsYWJlbCBzZXRCb3JkZXJlZDpOT107 CisgICAgW2xhYmVsIHNldEJhY2tncm91bmRDb2xvcjpbTlNDb2xvciBjbGVhckNvbG9yXV07Cisg ICAgW2xhYmVsIHNpemVUb0ZpdF07CisKKyAgICBOU1BvcFVwQnV0dG9uICpidXR0b24gPSBbW1tO U1BvcFVwQnV0dG9uIGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TWmVyb1JlY3QgcHVsbHNEb3duOk5P XSBhdXRvcmVsZWFzZV07CisgICAgW2J1dHRvbiBhZGRJdGVtc1dpdGhUaXRsZXM6dGl0bGVzXTsK KyAgICBbYnV0dG9uIHNldFRhcmdldDpwb3B1cFRhcmdldF07CisgICAgW2J1dHRvbiBzZXRBY3Rp b246QHNlbGVjdG9yKHBvcHVwQWN0aW9uOildOworICAgIFtidXR0b24gc2l6ZVRvRml0XTsKKyAg ICBbYnV0dG9uIHNlbGVjdEl0ZW1BdEluZGV4OjBdOworICAgIFtwb3B1cFRhcmdldCBwb3B1cEFj dGlvbjpidXR0b25dOworICAgIAorICAgIE5TVmlldyogZmlsdGVyVmlldyA9IFtbW05TVmlldyBh bGxvY10gaW5pdFdpdGhGcmFtZTpOU1plcm9SZWN0XSBhdXRvcmVsZWFzZV07CisgICAgW2ZpbHRl clZpZXcgYWRkU3VidmlldzpsYWJlbF07CisgICAgW2ZpbHRlclZpZXcgYWRkU3VidmlldzpidXR0 b25dOworCisgICAgY29uc3QgQ0dGbG9hdCBtYXJnaW4gPSAyMDsKKyAgICBjb25zdCBDR0Zsb2F0 IHNwYWNpbmcgPSAyOworICAgIGNvbnN0IENHRmxvYXQgbWluQnV0dG9uV2lkdGggPSAyMzA7CisK KyAgICBOU1JlY3QgbGFiZWxGcmFtZSA9IFtsYWJlbCBmcmFtZV07CisgICAgTlNSZWN0IGJ1dHRv bkZyYW1lID0gW2J1dHRvbiBmcmFtZV07CisgICAgTlNSZWN0IGZpbHRlclZpZXdGcmFtZSA9IFtm aWx0ZXJWaWV3IGZyYW1lXTsKKworICAgIC8vIFNldCBhIG1pbmltdW0gd2lkdGggZm9yICdidXR0 b24nLgorICAgIGJ1dHRvbkZyYW1lLnNpemUgPSBOU01ha2VTaXplKE1BWChOU1dpZHRoKGJ1dHRv bkZyYW1lKSwgbWluQnV0dG9uV2lkdGgpLCBOU0hlaWdodChidXR0b25GcmFtZSkpOworICAgIAor ICAgIC8vIEZpbHRlclZpZXcgd2lsbCBsYXkgb3V0ICdsYWJlbCcgYW5kICdidXR0b24nIGhvcml6 b250YWxseSBhbmQgaGF2ZSBhIHZlcnRpY2FsIG1hcmdpbnMuCisgICAgZmlsdGVyVmlld0ZyYW1l LnNpemUgPSBOU01ha2VTaXplKE5TV2lkdGgobGFiZWxGcmFtZSkgKyBOU1dpZHRoKGJ1dHRvbkZy YW1lKSArIHNwYWNpbmcsIE1BWChOU0hlaWdodChsYWJlbEZyYW1lKSwgTlNIZWlnaHQoYnV0dG9u RnJhbWUpKSArIG1hcmdpbiAqIDIpOworICAgIFtmaWx0ZXJWaWV3IHNldEZyYW1lOmZpbHRlclZp ZXdGcmFtZV07CisKKyAgICAvLyAnbGFiZWwnIHdpbGwgYmUgbGFpZCBvdXQgY2VudGVyIHZlcnRp Y2FsbHkuCisgICAgbGFiZWxGcmFtZS5vcmlnaW4gPSBOU01ha2VQb2ludChOU01pblgobGFiZWxG cmFtZSksIChOU0hlaWdodChmaWx0ZXJWaWV3RnJhbWUpIC0gTlNIZWlnaHQobGFiZWxGcmFtZSkp IC8gMik7CisgICAgW2xhYmVsIHNldEZyYW1lOmxhYmVsRnJhbWVdOworICAgIAorICAgIC8vICdi dXR0b24nIHdpbGwgYmUgbGFpZCBvdXQgY2VudGVyIHZlcnRpY2FsbHkgYW5kIGl0IHdpbGwgY29t ZSBhZnRlciAnbGFiZWwnIGhvcml6b250YWxseS4KKyAgICBidXR0b25GcmFtZS5vcmlnaW4gPSBO U01ha2VQb2ludChOU01heFgobGFiZWxGcmFtZSkgKyAyLCAoTlNIZWlnaHQoZmlsdGVyVmlld0Zy YW1lKSAtIE5TSGVpZ2h0KGJ1dHRvbkZyYW1lKSkgLyAyKTsKKyAgICBbYnV0dG9uIHNldEZyYW1l OmJ1dHRvbkZyYW1lXTsKKworICAgIHJldHVybiBmaWx0ZXJWaWV3OworfQorCiAjaWYgX19oYXNf ZmVhdHVyZShvYmpjX2dlbmVyaWNzKQogLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJW aWV3IHJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOihXS09wZW5QYW5lbFBhcmFtZXRlcnMgKilw YXJhbWV0ZXJzIGluaXRpYXRlZEJ5RnJhbWU6KFdLRnJhbWVJbmZvICopZnJhbWUgY29tcGxldGlv bkhhbmRsZXI6KHZvaWQgKF4pKE5TQXJyYXk8TlNVUkwgKj4gKiBVUkxzKSljb21wbGV0aW9uSGFu ZGxlcgogI2Vsc2UKQEAgLTU5Nyw2ICs2ODMsMTkgQEAgLSAodm9pZCl3ZWJWaWV3OihXS1dlYlZp ZXcgKil3ZWJWaWV3IHJ1bk9wZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOihXS09wZW5QYW5lbFBhcmEK IAogICAgIG9wZW5QYW5lbC5hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbiA9IHBhcmFtZXRlcnMuYWxs b3dzTXVsdGlwbGVTZWxlY3Rpb247CiAKKyAgICBbX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQg cmVsZWFzZV07CisgICAgX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgPSBbW0ZpbGVFeHRlbnNp b25zUG9wdXBUYXJnZXQgYWxsb2NdIGluaXRXaXRoT3BlblBhbmVsOiBvcGVuUGFuZWwgYWxsb3dl ZEZpbGVFeHRlbnNpb25zOiBwYXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNdOworCisg ICAgTlNBcnJheSogdGl0bGVzOworICAgIGlmIChwYXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVu c2lvbnNEZXNjcmlwdGlvbikKKyAgICAgICAgdGl0bGVzID0gQFtwYXJhbWV0ZXJzLl9hbGxvd2Vk RmlsZUV4dGVuc2lvbnNEZXNjcmlwdGlvbiwgQCJBbGwgRmlsZXMiXTsKKyAgICBlbHNlCisgICAg ICAgIHRpdGxlcyA9IEBbQCJBbGwgRmlsZXMiXTsKKworICAgIE5TVmlldyAqZmlsdGVyVmlldyA9 IFtzZWxmIGNyZWF0ZUZpbHRlclZpZXc6dGl0bGVzIHBvcHVwVGFyZ2V0Ol9maWxlRXh0ZW5zaW9u c1BvcHVwVGFyZ2V0XTsKKyAgICBpZiAoZmlsdGVyVmlldykKKyAgICAgICAgW29wZW5QYW5lbCBz ZXRBY2Nlc3NvcnlWaWV3OmZpbHRlclZpZXddOworCiAgICAgW29wZW5QYW5lbCBiZWdpblNoZWV0 TW9kYWxGb3JXaW5kb3c6d2ViVmlldy53aW5kb3cgY29tcGxldGlvbkhhbmRsZXI6XihOU0ludGVn ZXIgcmVzdWx0KSB7CiAgICAgICAgIGlmIChyZXN1bHQgPT0gTlNNb2RhbFJlc3BvbnNlT0spCiAg ICAgICAgICAgICBjb21wbGV0aW9uSGFuZGxlcihvcGVuUGFuZWwuVVJMcyk7Cg== 401619 2020-06-10 22:16:50 -0700 2020-06-10 23:31:58 -0700 Patch bug-212485-20200610221649.patch text/plain 15490 sabouhallawa SW5kZXg6IFNvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvUEFML0NoYW5nZUxvZwkocmV2aXNpb24gMjYyNjI2KQorKysgU291cmNlL1dlYkNv cmUvUEFML0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDIwLTA2 LTEwICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisKKyAgICAg ICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxlbWVudCBz aG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFy aW4gQWRsZXIuCisKKyAgICAgICAgRXhwb3NlIGFuIFNQSSBmcm9tIENvcmVTZXJ2Y2llcyB0byBn ZXQgYWxsIHRoZSBVVElzIGtub3duIGJ5IHRoZSBzeXN0ZW0uCisKKyAgICAgICAgKiBwYWwvc3Bp L2NvY29hL0NvcmVTZXJ2aWNlc1NQSS5oOgorCiAyMDIwLTA2LTA1ICBBbmR5IEVzdGVzICA8YWVz dGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBbQXBwbGUgUGF5XSBSZW1vdmUgY29uZGl0aW9uYWxz IGZvciBFTkFCTEVfQVBQTEVfUEFZX1NFU1NJT05fVigzfDQpCkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9QQUwvcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViQ29yZS9QQUwvcGFsL3NwaS9jb2NvYS9Db3JlU2VydmljZXNTUEkuaAkocmV2aXNpb24g MjYyNjI2KQorKysgU291cmNlL1dlYkNvcmUvUEFML3BhbC9zcGkvY29jb2EvQ29yZVNlcnZpY2Vz U1BJLmgJKHdvcmtpbmcgY29weSkKQEAgLTI2LDMgKzI2LDUgQEAKICNwcmFnbWEgb25jZQogCiBl eHRlcm4gIkMiIHZvaWQgX0NTQ2hlY2tGaXhEaXNhYmxlKCk7CitleHRlcm4gIkMiIENGQXJyYXlS ZWYgX1VUQ29weURlY2xhcmVkVHlwZUlkZW50aWZpZXJzKHZvaWQpOworCkluZGV4OiBTb3VyY2Uv V2ViS2l0L0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwko cmV2aXNpb24gMjYyNjI2KQorKysgU291cmNlL1dlYktpdC9DaGFuZ2VMb2cJKHdvcmtpbmcgY29w eSkKQEAgLTEsMyArMSwyMSBAQAorMjAyMC0wNi0xMCAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJv dWhhbGxhd2FAYXBwbGUuY29tPgorCisgICAgICAgIFttYWNPU106IFRoZSBGaWxlIFBpY2tlciBv ZiB0aGUgPGlucHV0PiBmaWxlIGVsZW1lbnQgc2hvdWxkIHNob3cgdGhlIHNlbGVjdGlvbiBmaWx0 ZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMjQ4 NQorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgorCisgICAgICAgIEFkZCB0d28g cHJpdmF0ZSBoZWxwZXJzIHRvIFdLT3BlblBhbmVsUGFyYW1ldGVycy4KKworICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tOgorICAgICAgICAoLVtX S09wZW5QYW5lbFBhcmFtZXRlcnMgX2FsbG93ZWRGaWxlRXh0ZW5zaW9uc10pOgorICAgICAgICBS ZXR1cm5zIGFuIGFycmF5IG9mIHN0cmluZ3MgcmVwcmVzZW50aW5nIHRoZSBhbGxvd2VkIGV4dGVu c2lvbnMuCisKKyAgICAgICAgKC1bV0tPcGVuUGFuZWxQYXJhbWV0ZXJzIF9hbGxvd2VkRmlsZUV4 dGVuc2lvbnNEZXNjcmlwdGlvbl0pOgorICAgICAgICBSZXR1cm5zIGEgc3RyaW5nIHJlcHJlc2Vu dGluZyBhIGRlc2NyaXB0aW9uIGZvciB0aGUgYWxsb3dlZCBleHRlbnNpb25zLgorCisgICAgICAg ICogVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmg6CisK IDIwMjAtMDYtMDUgIEFkcmlhbiBQZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4K IAogICAgICAgICBOb24tdW5pZmllZCBidWlsZCBmaXhlcywgZWFybHkgc3VtbWVyIDIwMjAgZWRp dGlvbgpJbmRleDogU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0NvY29hL1dLT3BlblBhbmVs UGFyYW1ldGVycy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv Q29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCShyZXZpc2lvbiAyNjI2MjYpCisrKyBTb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzLm1tCSh3 b3JraW5nIGNvcHkpCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNiBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAy MCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKQEAgLTI1LDExICsyNSw2MCBAQAogCiAjaW1wb3J0ICJjb25maWcuaCIKICNpbXBv cnQgIldLT3BlblBhbmVsUGFyYW1ldGVyc0ludGVybmFsLmgiCisjaW1wb3J0IDxwYWwvc3BpL2Nv Y29hL0NvcmVTZXJ2aWNlc1NQSS5oPgogCiAjaWYgUExBVEZPUk0oTUFDKQogCiAjaW1wb3J0ICJX S05TQXJyYXkuaCIKIAorc3RhdGljIE5TRGljdGlvbmFyeTxOU1N0cmluZyAqLCBOU1NldDxOU1N0 cmluZyAqPiAqPiAqZXh0ZW5zaW9uc0Zvck1JTUVUeXBlTWFwKCkKK3sKKyAgICBzdGF0aWMgYXV0 byBleHRlbnNpb25zRm9yTUlNRVR5cGVNYXAgPSBtYWtlTmV2ZXJEZXN0cm95ZWQoW10geworICAg ICAgICBhdXRvIGV4dGVuc2lvbnNGb3JNSU1FVHlwZU1hcCA9IGFkb3B0TlMoW1tOU011dGFibGVE aWN0aW9uYXJ5IGFsbG9jXSBpbml0XSk7CisgICAgICAgIGF1dG8gYWxsVVRJcyA9IGFkb3B0Q0Yo X1VUQ29weURlY2xhcmVkVHlwZUlkZW50aWZpZXJzKCkpOworCisgICAgICAgIGF1dG8gYWRkRXh0 ZW5zaW9uRm9yTUlNRVR5cGUgPSBeKE5TU3RyaW5nICptaW1lVHlwZSwgTlNTdHJpbmcgKmV4dGVu c2lvbikgeworICAgICAgICAgICAgaWYgKCFleHRlbnNpb25zRm9yTUlNRVR5cGVNYXAuZ2V0KClb bWltZVR5cGVdKQorICAgICAgICAgICAgICAgIGV4dGVuc2lvbnNGb3JNSU1FVHlwZU1hcC5nZXQo KVttaW1lVHlwZV0gPSBbTlNNdXRhYmxlU2V0IHNldF07CisgICAgICAgICAgICBbZXh0ZW5zaW9u c0Zvck1JTUVUeXBlTWFwLmdldCgpW21pbWVUeXBlXSBhZGRPYmplY3Q6ZXh0ZW5zaW9uXTsKKyAg ICAgICAgfTsKKworICAgICAgICBhdXRvIGFkZEV4dGVuc2lvbnNGb3JNSU1FVHlwZSA9IF4oTlNT dHJpbmcgKm1pbWVUeXBlLCBOU0FycmF5PE5TU3RyaW5nICo+ICpleHRlbnNpb25zKSB7CisgICAg ICAgICAgICBhdXRvIHdpbGRjYXJkTUlNRVR5cGUgPSBbW21pbWVUeXBlIGNvbXBvbmVudHNTZXBh cmF0ZWRCeVN0cmluZzpAIi8iXVswXSBzdHJpbmdCeUFwcGVuZGluZ1N0cmluZzpAIi8qIl07CisK KyAgICAgICAgICAgIGZvciAoTlNTdHJpbmcgKmV4dGVuc2lvbiBpbiBleHRlbnNpb25zKSB7Cisg ICAgICAgICAgICAgICAgaWYgKCFleHRlbnNpb24pCisgICAgICAgICAgICAgICAgICAgIGNvbnRp bnVlOworICAgICAgICAgICAgICAgIC8vIEFkZCBleHRlbnNpb24gdG8gd2lsZGNhcmRNSU1FVHlw ZSwgZm9yIGV4YW1wbGUgYWRkICJwbmciIHRvICJpbWFnZS8qIgorICAgICAgICAgICAgICAgIGFk ZEV4dGVuc2lvbkZvck1JTUVUeXBlKHdpbGRjYXJkTUlNRVR5cGUsIGV4dGVuc2lvbik7CisgICAg ICAgICAgICAgICAgLy8gQWRkIGV4dGVuc2lvbiB0byBpdHNtaW1lVHlwZSwgZm9yIGV4YW1wbGUg YWRkICJwbmciIHRvICJpbWFnZS9wbmciCisgICAgICAgICAgICAgICAgYWRkRXh0ZW5zaW9uRm9y TUlNRVR5cGUobWltZVR5cGUsIGV4dGVuc2lvbik7CisgICAgICAgICAgICB9CisgICAgICAgIH07 CisKKyAgICAgICAgZm9yIChDRkluZGV4IGkgPSAwLCBjb3VudCA9IENGQXJyYXlHZXRDb3VudChh bGxVVElzLmdldCgpKTsgaSA8IGNvdW50OyArK2kpIHsKKyAgICAgICAgICAgIGF1dG8gdXRpID0g c3RhdGljX2Nhc3Q8Q0ZTdHJpbmdSZWY+KENGQXJyYXlHZXRWYWx1ZUF0SW5kZXgoYWxsVVRJcy5n ZXQoKSwgaSkpOworICAgICAgICAgICAgYXV0byBtaW1lVHlwZSA9IGFkb3B0Q0YoVVRUeXBlQ29w eVByZWZlcnJlZFRhZ1dpdGhDbGFzcyh1dGksIGtVVFRhZ0NsYXNzTUlNRVR5cGUpKTsKKyAgICAg ICAgICAgIGlmICghbWltZVR5cGUpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICBhdXRvIGV4dGVuc2lvbnMgPSBhZG9wdENGKFVUVHlwZUNvcHlBbGxUYWdzV2l0aENsYXNz KHV0aSwga1VUVGFnQ2xhc3NGaWxlbmFtZUV4dGVuc2lvbikpOworICAgICAgICAgICAgYWRkRXh0 ZW5zaW9uc0Zvck1JTUVUeXBlKChfX2JyaWRnZSBOU1N0cmluZyAqKW1pbWVUeXBlLmdldCgpLCAo X19icmlkZ2UgTlNBcnJheTxOU1N0cmluZyAqPiAqKWV4dGVuc2lvbnMuZ2V0KCkpOworICAgICAg ICB9CisKKyAgICAgICAgLy8gQWRkIGFkZGl0aW9uYWwgbWltZSB0eXBlcyB3aGljaCBfVVRDb3B5 RGVjbGFyZWRUeXBlSWRlbnRpZmllcnMoKSBtYXkgbm90IHJldHVybi4KKyAgICAgICAgYWRkRXh0 ZW5zaW9uRm9yTUlNRVR5cGUoQCJpbWFnZS93ZWJwIiwgQCJ3ZWJwIik7CisKKyAgICAgICAgcmV0 dXJuIGV4dGVuc2lvbnNGb3JNSU1FVHlwZU1hcDsKKyAgICB9KCkpOworCisgICAgcmV0dXJuIGV4 dGVuc2lvbnNGb3JNSU1FVHlwZU1hcC5nZXQoKS5nZXQoKTsKK30KKworc3RhdGljIE5TU2V0PE5T U3RyaW5nICo+ICpleHRlbnNpb25zRm9yTUlNRVR5cGUoTlNTdHJpbmcgKm1pbWV0eXBlKQorewor ICAgIHJldHVybiBbZXh0ZW5zaW9uc0Zvck1JTUVUeXBlTWFwKCkgb2JqZWN0Rm9yS2V5Om1pbWV0 eXBlXTsKK30KKwogQGltcGxlbWVudGF0aW9uIFdLT3BlblBhbmVsUGFyYW1ldGVycwogCiAtIChC T09MKWFsbG93c011bHRpcGxlU2VsZWN0aW9uCkBAIC02Myw2ICsxMTIsNjIgQEAgLSAoTlNBcnJh eTxOU1N0cmluZyAqPiAqKV9hY2NlcHRlZEZpbGVFeAogICAgIHJldHVybiB3cmFwcGVyKF9vcGVu UGFuZWxQYXJhbWV0ZXJzLT5hY2NlcHRGaWxlRXh0ZW5zaW9ucygpKTsKIH0KIAorLSAoTlNBcnJh eTxOU1N0cmluZyAqPiAqKV9hbGxvd2VkRmlsZUV4dGVuc2lvbnMKK3sKKyAgICAvLyBBZ2dyZWdh dGUgZXh0ZW5zaW9ucyBiYXNlZCBvbiBzcGVjaWZpZWQgTUlNRSB0eXBlcy4KKyAgICBhdXRvIGFj Y2VwdGVkTUlNRVR5cGVzID0gW3NlbGYgX2FjY2VwdGVkTUlNRVR5cGVzXTsKKyAgICBhdXRvIGFj Y2VwdGVkRmlsZUV4dGVuc2lvbnMgPSBbc2VsZiBfYWNjZXB0ZWRGaWxlRXh0ZW5zaW9uc107CisK KyAgICBhdXRvIGFsbG93ZWRGaWxlRXh0ZW5zaW9ucyA9IGFkb3B0TlMoW1tOU011dGFibGVTZXQg YWxsb2NdIGluaXRdKTsKKworICAgIFthY2NlcHRlZE1JTUVUeXBlcyBlbnVtZXJhdGVPYmplY3Rz VXNpbmdCbG9jazpeKE5TU3RyaW5nICptaW1lVHlwZSwgTlNVSW50ZWdlciBpbmRleCwgQk9PTCog c3RvcCkgeworICAgICAgICBBU1NFUlQoW21pbWVUeXBlIGNvbnRhaW5zU3RyaW5nOkAiLyJdKTsK KyAgICAgICAgW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyB1bmlvblNldDpleHRlbnNpb25zRm9yTUlN RVR5cGUobWltZVR5cGUpXTsKKyAgICB9XTsKKworICAgIGF1dG8gYWRkaXRpb25hbEFsbG93ZWRG aWxlRXh0ZW5zaW9ucyA9IGFkb3B0TlMoW1tOU011dGFibGVBcnJheSBhbGxvY10gaW5pdF0pOwor CisgICAgW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgZW51bWVyYXRlT2JqZWN0c1VzaW5nQmxvY2s6 XihOU1N0cmluZyAqZXh0ZW5zaW9uLCBOU1VJbnRlZ2VyIGluZGV4LCBCT09MICpzdG9wKSB7Cisg ICAgICAgIEFTU0VSVChbZXh0ZW5zaW9uIGNoYXJhY3RlckF0SW5kZXg6MF0gPT0gJy4nKTsKKyAg ICAgICAgW2FkZGl0aW9uYWxBbGxvd2VkRmlsZUV4dGVuc2lvbnMgYWRkT2JqZWN0OltleHRlbnNp b24gc3Vic3RyaW5nRnJvbUluZGV4OjFdXTsKKyAgICB9XTsKKyAgICAKKyAgICBbYWxsb3dlZEZp bGVFeHRlbnNpb25zIGFkZE9iamVjdHNGcm9tQXJyYXk6YWRkaXRpb25hbEFsbG93ZWRGaWxlRXh0 ZW5zaW9ucy5nZXQoKV07CisgICAgcmV0dXJuIFthbGxvd2VkRmlsZUV4dGVuc2lvbnMgYWxsT2Jq ZWN0c107Cit9CisKKy0gKE5TQXJyYXk8TlNTdHJpbmcgKj4gKilfYWxsb3dlZEZpbGVFeHRlbnNp b25zVGl0bGVzCit7CisgICAgYXV0byBhY2NlcHRlZE1JTUVUeXBlcyA9IFtzZWxmIF9hY2NlcHRl ZE1JTUVUeXBlc107CisgICAgYXV0byBhY2NlcHRlZEZpbGVFeHRlbnNpb25zID0gW3NlbGYgX2Fj Y2VwdGVkRmlsZUV4dGVuc2lvbnNdOworCisgICAgY29uc3RleHByIGF1dG8gQWxsRmlsZXNUaXRs ZSA9IEAiQWxsIEZpbGVzIjsKKyAgICBjb25zdGV4cHIgYXV0byBDdXN0b21GaWxlc1RpdGxlID0g QCJDdXN0b20gRmlsZXMiOworICAgIAorICAgIGlmICghW2FjY2VwdGVkTUlNRVR5cGVzIGNvdW50 XSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291bnRdKQorICAgICAgICByZXR1cm4gQFtB bGxGaWxlc1RpdGxlXTsKKworICAgIGlmICghKFthY2NlcHRlZE1JTUVUeXBlcyBjb3VudF0gPT0g MSAmJiAhW2FjY2VwdGVkRmlsZUV4dGVuc2lvbnMgY291bnRdKSkKKyAgICAgICAgcmV0dXJuIEBb Q3VzdG9tRmlsZXNUaXRsZSwgQWxsRmlsZXNUaXRsZV07CisKKyAgICBhdXRvIG1pbWVUeXBlID0g W2FjY2VwdGVkTUlNRVR5cGVzIGZpcnN0T2JqZWN0XTsKKyAgICBhdXRvIHJhbmdlID0gW21pbWVU eXBlIHJhbmdlT2ZTdHJpbmc6QCIvIl07CisgICAgCisgICAgaWYgKCFyYW5nZS5sZW5ndGgpCisg ICAgICAgIHJldHVybiBAW0N1c3RvbUZpbGVzVGl0bGUsIEFsbEZpbGVzVGl0bGVdOworICAgIAor ICAgIGF1dG8gbWltZVR5cGVQcmVmaXggPSBbbWltZVR5cGUgc3Vic3RyaW5nVG9JbmRleDpyYW5n ZS5sb2NhdGlvbl07CisgICAgYXV0byBtaW1lVHlwZVN1ZmZpeCA9IFttaW1lVHlwZSBzdWJzdHJp bmdGcm9tSW5kZXg6cmFuZ2UubG9jYXRpb24gKyAxXTsKKyAgICAKKyAgICBpZiAoW21pbWVUeXBl U3VmZml4IGlzRXF1YWxUb1N0cmluZzpAIioiXSkKKyAgICAgICAgcmV0dXJuIEBbW05TU3RyaW5n IHN0cmluZ1dpdGhGb3JtYXQ6QCIlQCVAIEZpbGVzIiwgW1ttaW1lVHlwZVByZWZpeCBzdWJzdHJp bmdUb0luZGV4OjFdIHVwcGVyY2FzZVN0cmluZ10sIFttaW1lVHlwZVByZWZpeCBzdWJzdHJpbmdG cm9tSW5kZXg6MV1dLCBBbGxGaWxlc1RpdGxlXTsKKworICAgIGlmIChbbWltZVR5cGVTdWZmaXgg bGVuZ3RoXSA8PSA0KQorICAgICAgICByZXR1cm4gQFtbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1h dDpAIiVAICVAIiwgW21pbWVUeXBlU3VmZml4IHVwcGVyY2FzZVN0cmluZ10sIG1pbWVUeXBlUHJl Zml4XSwgQWxsRmlsZXNUaXRsZV07CisKKyAgICByZXR1cm4gQFtbTlNTdHJpbmcgc3RyaW5nV2l0 aEZvcm1hdDpAIiVAICVAIiwgbWltZVR5cGVTdWZmaXgsIG1pbWVUeXBlUHJlZml4XSwgQWxsRmls ZXNUaXRsZV07Cit9CisKIEBlbmQKIAogI2VuZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQ29jb2EvV0tPcGVuUGFuZWxQYXJhbWV0ZXJzUHJpdmF0ZS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRl cnNQcml2YXRlLmgJKHJldmlzaW9uIDI2MjYyNikKKysrIFNvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9Db2NvYS9XS09wZW5QYW5lbFBhcmFtZXRlcnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkK QEAgLTMxLDYgKzMxLDggQEAKIAogQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBjb3B5 KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWNjZXB0ZWRNSU1FVHlwZXMgV0tfQVBJX0FWQUlMQUJM RShtYWNvcygxMC4xMy40KSk7CiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHksIGNvcHkp IE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9hY2NlcHRlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9BVkFJ TEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5LCBj b3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zIFdLX0FQSV9B VkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOworQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5 LCBjb3B5KSBOU0FycmF5PE5TU3RyaW5nICo+ICpfYWxsb3dlZEZpbGVFeHRlbnNpb25zVGl0bGVz IFdLX0FQSV9BVkFJTEFCTEUobWFjb3MoMTAuMTMuNCkpOwogCiBAZW5kCiAKSW5kZXg6IFRvb2xz L0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDI2MjYy NikKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIyIEBACisy MDIwLTA2LTEwICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+CisK KyAgICAgICAgW21hY09TXTogVGhlIEZpbGUgUGlja2VyIG9mIHRoZSA8aW5wdXQ+IGZpbGUgZWxl bWVudCBzaG91bGQgc2hvdyB0aGUgc2VsZWN0aW9uIGZpbHRlcgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyNDg1CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgQ3JlYXRlIGEgdmlldyB3aXRoIGFuIE5TUG9wdXBC dXR0b24gZm9yIHRoZSBmaWxlIGV4dGVuc2lvbnMgZmlsdGVyLiBTZXQKKyAgICAgICAgdGhpcyB2 aWV3IGFzIHRoZSBBY2Nlc3NvcnlWaWV3IG9mIHRoZSBPcGVuUGFuZWwuIENyZWF0ZSBhIGN1c3Rv bWl6ZWQgdGFyZ2V0CisgICAgICAgIGZvciB0aGUgTlNQb3B1cEJ1dHRvbiB0byByZXNwb25kIHRv IGNoYW5naW5nIGl0cyBzZWxlY3Rpb24uCisKKyAgICAgICAgKiBNaW5pQnJvd3Nlci9tYWMvV0sy QnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubToKKyAgICAgICAgKC1bRmlsZUV4dGVuc2lvbnNQb3B1 cFRhcmdldCBpbml0V2l0aE9wZW5QYW5lbDphbGxvd2VkRmlsZUV4dGVuc2lvbnM6XSk6CisgICAg ICAgICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgcG9wdXBBY3Rpb246XSk6CisgICAgICAg ICgtW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgZGVhbGxvY10pOgorICAgICAgICAoLVtXSzJC cm93c2VyV2luZG93Q29udHJvbGxlciBkZWFsbG9jXSk6CisgICAgICAgICgtW1dLMkJyb3dzZXJX aW5kb3dDb250cm9sbGVyIGNyZWF0ZUZpbHRlclZpZXc6cG9wdXBUYXJnZXQ6XSk6CisgICAgICAg ICgtW1dLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyIHdlYlZpZXc6cnVuT3BlblBhbmVsV2l0aFBh cmFtZXRlcnM6aW5pdGlhdGVkQnlGcmFtZTpjb21wbGV0aW9uSGFuZGxlcjp3ZWJWaWV3OnJ1bk9w ZW5QYW5lbFdpdGhQYXJhbWV0ZXJzOmluaXRpYXRlZEJ5RnJhbWU6Y29tcGxldGlvbkhhbmRsZXI6 XSk6CisKIDIwMjAtMDYtMDUgIEFuZHkgRXN0ZXMgIDxhZXN0ZXNAYXBwbGUuY29tPgogCiAgICAg ICAgIFtBcHBsZSBQYXldIFJlbW92ZSBjb25kaXRpb25hbHMgZm9yIEVOQUJMRV9BUFBMRV9QQVlf U0VTU0lPTl9WKDN8NCkKSW5kZXg6IFRvb2xzL01pbmlCcm93c2VyL21hYy9XSzJCcm93c2VyV2lu ZG93Q29udHJvbGxlci5tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL01pbmlCcm93c2VyL21hYy9XSzJC cm93c2VyV2luZG93Q29udHJvbGxlci5tCShyZXZpc2lvbiAyNjI2MjYpCisrKyBUb29scy9NaW5p QnJvd3Nlci9tYWMvV0syQnJvd3NlcldpbmRvd0NvbnRyb2xsZXIubQkod29ya2luZyBjb3B5KQpA QCAtMzAsNiArMzAsNyBAQAogI2ltcG9ydCA8V2ViS2l0L1dLRnJhbWVJbmZvLmg+CiAjaW1wb3J0 IDxXZWJLaXQvV0tOYXZpZ2F0aW9uQWN0aW9uUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dL TmF2aWdhdGlvbkRlbGVnYXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tPcGVuUGFuZWxQYXJhbWV0 ZXJzUHJpdmF0ZS5oPgogI2ltcG9ydCA8V2ViS2l0L1dLUHJlZmVyZW5jZXNQcml2YXRlLmg+CiAj aW1wb3J0IDxXZWJLaXQvV0tVSURlbGVnYXRlLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tVSURlbGVn YXRlUHJpdmF0ZS5oPgpAQCAtNzEsNiArNzIsNDUgQEAgLSAodm9pZClwZXJmb3JtQWN0aW9uOihO U1RleHRGaW5kZXJBY3RpbwogCiBAZW5kCiAKKy8vIFRhcmdldCBmb3IgdGhlIEZpbGVFeHRlbnNp b25zIE5TUG9wdXBCdXR0b24gaW4gdGhlIE9wZW5QYW5lbCdzIEFjY2Vzc29yeVZpZXcuCitAaW50 ZXJmYWNlIEZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgOiBOU09iamVjdCB7CitAcHJpdmF0ZQor ICAgIE5TT3BlblBhbmVsICpfb3BlblBhbmVsOworICAgIE5TQXJyYXk8TlNTdHJpbmcgKj4gKl9h bGxvd2VkRmlsZUV4dGVuc2lvbnM7Cit9CitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBGaWxlRXh0 ZW5zaW9uc1BvcHVwVGFyZ2V0CisKKy0gKGlkKWluaXRXaXRoT3BlblBhbmVsOihOU09wZW5QYW5l bCopb3BlblBhbmVsIGFsbG93ZWRGaWxlRXh0ZW5zaW9uczooTlNBcnJheTxOU1N0cmluZyAqPiAq KWFsbG93ZWRGaWxlRXh0ZW5zaW9ucyB7CisgICAgaWYgKChzZWxmID0gW3N1cGVyIGluaXRdKSkg eworICAgICAgICBfb3BlblBhbmVsID0gb3BlblBhbmVsOworICAgICAgICBfYWxsb3dlZEZpbGVF eHRlbnNpb25zID0gW2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyBjb3B5XTsKKyAgICB9CisgICAgcmV0 dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpcG9wdXBBY3Rpb246KGlkKXNlbmRlciB7CisgICAgLy8g TGFzdCBpdGVtLgorICAgIGlmIChbc2VuZGVyIGluZGV4T2ZTZWxlY3RlZEl0ZW1dID09IFtzZW5k ZXIgbnVtYmVyT2ZJdGVtc10gLSAxKQorICAgICAgICBbX29wZW5QYW5lbCBzZXRBbGxvd2VkRmls ZVR5cGVzOm5pbF07CisgICAgZWxzZSBpZiAoIVtzZW5kZXIgaW5kZXhPZlNlbGVjdGVkSXRlbV0p IHsKKyAgICAgICAgLy8gRmlyc3QgaXRlbS4KKyAgICAgICAgaWYgKCFbX2FsbG93ZWRGaWxlRXh0 ZW5zaW9ucyBjb3VudF0pCisgICAgICAgICAgICBbX29wZW5QYW5lbCBzZXRBbGxvd2VkRmlsZVR5 cGVzOkBbQCIiXV07CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIFtfb3BlblBhbmVsIHNldEFs bG93ZWRGaWxlVHlwZXM6X2FsbG93ZWRGaWxlRXh0ZW5zaW9uc107CisgICAgfQorfQorCistICh2 b2lkKWRlYWxsb2MKK3sKKyAgICBbX2FsbG93ZWRGaWxlRXh0ZW5zaW9ucyByZWxlYXNlXTsKKyAg ICBbc3VwZXIgZGVhbGxvY107Cit9CisKK0BlbmQKKwogQGludGVyZmFjZSBXSzJCcm93c2VyV2lu ZG93Q29udHJvbGxlciAoKSA8TlNUZXh0RmluZGVyQmFyQ29udGFpbmVyLCBXS05hdmlnYXRpb25E ZWxlZ2F0ZSwgV0tVSURlbGVnYXRlLCBfV0tJY29uTG9hZGluZ0RlbGVnYXRlPgogQGVuZAogCkBA IC04NSw2ICsxMjUsNyBAQCBAaW50ZXJmYWNlIFdLMkJyb3dzZXJXaW5kb3dDb250cm9sbGVyICgp CiAgICAgTWluaUJyb3dzZXJOU1RleHRGaW5kZXIgKl90ZXh0RmluZGVyOwogICAgIE5TVmlldyAq X3RleHRGaW5kQmFyVmlldzsKICAgICBCT09MIF9maW5kQmFyVmlzaWJsZTsKKyAgICBGaWxlRXh0 ZW5zaW9uc1BvcHVwVGFyZ2V0ICpfZmlsZUV4dGVuc2lvbnNQb3B1cFRhcmdldDsKIH0KIAogLSAo dm9pZClhd2FrZUZyb21OaWIKQEAgLTE3MCw2ICsyMTEsNyBAQCAtICh2b2lkKWRlYWxsb2MKIAog ICAgIFtfd2ViVmlldyByZWxlYXNlXTsKICAgICBbX2NvbmZpZ3VyYXRpb24gcmVsZWFzZV07Cisg ICAgW19maWxlRXh0ZW5zaW9uc1BvcHVwVGFyZ2V0IHJlbGVhc2VdOwogCiAgICAgW3N1cGVyIGRl YWxsb2NdOwogfQpAQCAtNTg3LDYgKzYyOSw1NCBAQCAtICh2b2lkKXdlYlZpZXc6KFdLV2ViVmll dyAqKXdlYlZpZXcgcnVuCiAgICAgfV07CiB9CiAKKy0gKG51bGxhYmxlIE5TVmlldyAqKWNyZWF0 ZUZpbHRlclZpZXc6KE5TQXJyYXkgKil0aXRsZXMgcG9wdXBUYXJnZXQ6KEZpbGVFeHRlbnNpb25z UG9wdXBUYXJnZXQqKXBvcHVwVGFyZ2V0Cit7CisgICAgTlNUZXh0RmllbGQqIGxhYmVsID0gW1tb TlNUZXh0RmllbGQgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNaZXJvUmVjdF0gYXV0b3JlbGVhc2Vd OworICAgIFtsYWJlbCBzZXRTdHJpbmdWYWx1ZTpAIkZvcm1hdDoiXTsKKyAgICBbbGFiZWwgc2V0 RWRpdGFibGU6Tk9dOworICAgIFtsYWJlbCBzZXRTZWxlY3RhYmxlOk5PXTsKKyAgICBbbGFiZWwg c2V0Qm9yZGVyZWQ6Tk9dOworICAgIFtsYWJlbCBzZXRCYWNrZ3JvdW5kQ29sb3I6W05TQ29sb3Ig Y2xlYXJDb2xvcl1dOworICAgIFtsYWJlbCBzaXplVG9GaXRdOworCisgICAgTlNQb3BVcEJ1dHRv biAqYnV0dG9uID0gW1tbTlNQb3BVcEJ1dHRvbiBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU1plcm9S ZWN0IHB1bGxzRG93bjpOT10gYXV0b3JlbGVhc2VdOworICAgIFtidXR0b24gYWRkSXRlbXNXaXRo VGl0bGVzOnRpdGxlc107CisgICAgW2J1dHRvbiBzZXRUYXJnZXQ6cG9wdXBUYXJnZXRdOworICAg IFtidXR0b24gc2V0QWN0aW9uOkBzZWxlY3Rvcihwb3B1cEFjdGlvbjopXTsKKyAgICBbYnV0dG9u IHNpemVUb0ZpdF07CisgICAgW2J1dHRvbiBzZWxlY3RJdGVtQXRJbmRleDowXTsKKyAgICBbcG9w dXBUYXJnZXQgcG9wdXBBY3Rpb246YnV0dG9uXTsKKyAgICAKKyAgICBOU1ZpZXcqIGZpbHRlclZp ZXcgPSBbW1tOU1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNaZXJvUmVjdF0gYXV0b3JlbGVh c2VdOworICAgIFtmaWx0ZXJWaWV3IGFkZFN1YnZpZXc6bGFiZWxdOworICAgIFtmaWx0ZXJWaWV3 IGFkZFN1YnZpZXc6YnV0dG9uXTsKKworICAgIGNvbnN0IENHRmxvYXQgbWFyZ2luID0gMjA7Cisg ICAgY29uc3QgQ0dGbG9hdCBzcGFjaW5nID0gMjsKKyAgICBjb25zdCBDR0Zsb2F0IG1pbkJ1dHRv bldpZHRoID0gMjMwOworCisgICAgTlNSZWN0IGxhYmVsRnJhbWUgPSBbbGFiZWwgZnJhbWVdOwor ICAgIE5TUmVjdCBidXR0b25GcmFtZSA9IFtidXR0b24gZnJhbWVdOworICAgIE5TUmVjdCBmaWx0 ZXJWaWV3RnJhbWUgPSBbZmlsdGVyVmlldyBmcmFtZV07CisKKyAgICAvLyBTZXQgYSBtaW5pbXVt IHdpZHRoIGZvciAnYnV0dG9uJy4KKyAgICBidXR0b25GcmFtZS5zaXplID0gTlNNYWtlU2l6ZShN QVgoTlNXaWR0aChidXR0b25GcmFtZSksIG1pbkJ1dHRvbldpZHRoKSwgTlNIZWlnaHQoYnV0dG9u RnJhbWUpKTsKKyAgICAKKyAgICAvLyBGaWx0ZXJWaWV3IHdpbGwgbGF5IG91dCAnbGFiZWwnIGFu ZCAnYnV0dG9uJyBob3Jpem9udGFsbHkgYW5kIGhhdmUgYSB2ZXJ0aWNhbCBtYXJnaW5zLgorICAg IGZpbHRlclZpZXdGcmFtZS5zaXplID0gTlNNYWtlU2l6ZShOU1dpZHRoKGxhYmVsRnJhbWUpICsg TlNXaWR0aChidXR0b25GcmFtZSkgKyBzcGFjaW5nLCBNQVgoTlNIZWlnaHQobGFiZWxGcmFtZSks IE5TSGVpZ2h0KGJ1dHRvbkZyYW1lKSkgKyBtYXJnaW4gKiAyKTsKKyAgICBbZmlsdGVyVmlldyBz ZXRGcmFtZTpmaWx0ZXJWaWV3RnJhbWVdOworCisgICAgLy8gJ2xhYmVsJyB3aWxsIGJlIGxhaWQg b3V0IGNlbnRlciB2ZXJ0aWNhbGx5LgorICAgIGxhYmVsRnJhbWUub3JpZ2luID0gTlNNYWtlUG9p bnQoTlNNaW5YKGxhYmVsRnJhbWUpLCAoTlNIZWlnaHQoZmlsdGVyVmlld0ZyYW1lKSAtIE5TSGVp Z2h0KGxhYmVsRnJhbWUpKSAvIDIpOworICAgIFtsYWJlbCBzZXRGcmFtZTpsYWJlbEZyYW1lXTsK KyAgICAKKyAgICAvLyAnYnV0dG9uJyB3aWxsIGJlIGxhaWQgb3V0IGNlbnRlciB2ZXJ0aWNhbGx5 IGFuZCBpdCB3aWxsIGNvbWUgYWZ0ZXIgJ2xhYmVsJyBob3Jpem9udGFsbHkuCisgICAgYnV0dG9u RnJhbWUub3JpZ2luID0gTlNNYWtlUG9pbnQoTlNNYXhYKGxhYmVsRnJhbWUpICsgc3BhY2luZywg KE5TSGVpZ2h0KGZpbHRlclZpZXdGcmFtZSkgLSBOU0hlaWdodChidXR0b25GcmFtZSkpIC8gMik7 CisgICAgW2J1dHRvbiBzZXRGcmFtZTpidXR0b25GcmFtZV07CisKKyAgICByZXR1cm4gZmlsdGVy VmlldzsKK30KKwogI2lmIF9faGFzX2ZlYXR1cmUob2JqY19nZW5lcmljcykKIC0gKHZvaWQpd2Vi VmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW5PcGVuUGFuZWxXaXRoUGFyYW1ldGVyczooV0tP cGVuUGFuZWxQYXJhbWV0ZXJzICopcGFyYW1ldGVycyBpbml0aWF0ZWRCeUZyYW1lOihXS0ZyYW1l SW5mbyAqKWZyYW1lIGNvbXBsZXRpb25IYW5kbGVyOih2b2lkICheKShOU0FycmF5PE5TVVJMICo+ ICogVVJMcykpY29tcGxldGlvbkhhbmRsZXIKICNlbHNlCkBAIC01OTcsNiArNjg3LDE0IEBAIC0g KHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBydW4KIAogICAgIG9wZW5QYW5lbC5h bGxvd3NNdWx0aXBsZVNlbGVjdGlvbiA9IHBhcmFtZXRlcnMuYWxsb3dzTXVsdGlwbGVTZWxlY3Rp b247CiAKKyAgICBbX2ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgcmVsZWFzZV07CisgICAgX2Zp bGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgPSBbW0ZpbGVFeHRlbnNpb25zUG9wdXBUYXJnZXQgYWxs b2NdIGluaXRXaXRoT3BlblBhbmVsOiBvcGVuUGFuZWwgYWxsb3dlZEZpbGVFeHRlbnNpb25zOiBw YXJhbWV0ZXJzLl9hbGxvd2VkRmlsZUV4dGVuc2lvbnNdOworCisgICAgTlNBcnJheSAqYWxsb3dl ZEZpbGVFeHRlbnNpb25zVGl0bGVzID0gcGFyYW1ldGVycy5fYWxsb3dlZEZpbGVFeHRlbnNpb25z VGl0bGVzOworICAgIE5TVmlldyAqZmlsdGVyVmlldyA9IFtzZWxmIGNyZWF0ZUZpbHRlclZpZXc6 YWxsb3dlZEZpbGVFeHRlbnNpb25zVGl0bGVzIHBvcHVwVGFyZ2V0Ol9maWxlRXh0ZW5zaW9uc1Bv cHVwVGFyZ2V0XTsKKyAgICBpZiAoZmlsdGVyVmlldykKKyAgICAgICAgW29wZW5QYW5lbCBzZXRB Y2Nlc3NvcnlWaWV3OmZpbHRlclZpZXddOworCiAgICAgW29wZW5QYW5lbCBiZWdpblNoZWV0TW9k YWxGb3JXaW5kb3c6d2ViVmlldy53aW5kb3cgY29tcGxldGlvbkhhbmRsZXI6XihOU0ludGVnZXIg cmVzdWx0KSB7CiAgICAgICAgIGlmIChyZXN1bHQgPT0gTlNNb2RhbFJlc3BvbnNlT0spCiAgICAg ICAgICAgICBjb21wbGV0aW9uSGFuZGxlcihvcGVuUGFuZWwuVVJMcyk7Cg==