129344 2014-02-25 16:33:33 -0800 [iOS WebKit2] Form controls handling 2014-03-05 11:43:20 -0800 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) iPhone / iPad Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 enrica enrica commit-queue joepeck simon.fraser thorton oldest_to_newest 984533 0 enrica 2014-02-25 16:33:33 -0800 We need to implement the logic to show the appropriate keyboard for the selected input or to show the pickers and popover. <rdar://problem/16053643> 984540 1 225197 enrica 2014-02-25 16:41:39 -0800 Created attachment 225197 Patch1 984541 2 commit-queue 2014-02-25 16:43:23 -0800 Attachment 225197 did not pass style-queue: ERROR: Source/WebKit2/WebProcess/WebPage/WebPage.h:753: The parameter name "information" adds no information, so it should be removed. [readability/parameter_name] [5] ERROR: Source/WebKit2/Shared/AssistedNodeInformation.h:30: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 2 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 984545 3 225197 simon.fraser 2014-02-25 16:53:34 -0800 Comment on attachment 225197 Patch1 View in context: https://bugs.webkit.org/attachment.cgi?id=225197&action=review > Source/WebKit2/Shared/AssistedNodeInformation.h:72 > + WebCore::IntRect elementRect; In what coordinate space? What about iframes? > Source/WebKit2/Shared/AssistedNodeInformation.h:76 > + bool hasNextNode; > + bool hasPreviousNode; > + bool isPasswordField; > + bool isAutocorrect; Please group all the bools together (some lower down). for better packing. > Source/WebKit2/UIProcess/ios/PageClientImplIOS.mm:352 > + [m_contentView _startAssistingNode:information]; "information" seems a bit vague here. > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:102 > WebKit::WKAutoCorrectionData _autocorrectionData; > WebKit::InteractionInformationAtPosition _positionInformation; > + WebKit::AssistedNodeInformation _assistedNodeInformation; I wish we didn't store all these by value. We should only allocate AssistedNodeInformation when a node is being assisted. > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1447 > + _traits.get().secureTextEntry = _assistedNodeInformation.isPasswordField; I think our preferred style is [_traits.get setSecureTextEntry:...] > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1457 > + _traits.get().shortcutConversionType = _assistedNodeInformation.isPasswordField ? UITextShortcutConversionTypeNo : UITextShortcutConversionTypeDefault; > + if (!_assistedNodeInformation.formAction.isEmpty()) > + [_traits setReturnKeyType:(_assistedNodeInformation.elementType == WebKit::WKTypeSearch) ? UIReturnKeySearch : UIReturnKeyGo]; > + if (_assistedNodeInformation.isPasswordField || _assistedNodeInformation.elementType == WKTypeEmail || _assistedNodeInformation.elementType == WKTypeURL || _assistedNodeInformation.formAction.contains("login")) { > + [_traits setAutocapitalizationType:UITextAutocapitalizationTypeNone]; > + [_traits setAutocorrectionType:UITextAutocorrectionTypeNo]; > + } else { > + [_traits setAutocapitalizationType:toUITextAutocapitalize(_assistedNodeInformation.autocapitalizeType)]; > + [_traits setAutocorrectionType:_assistedNodeInformation.isAutocorrect ? UITextAutocorrectionTypeYes : UITextAutocorrectionTypeNo]; > + } Can we subclass UITextInputTraits and push some of this logic into it? > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1500 > + RefPtr<KeyboardEvent> key = KeyboardEvent::create(); Seems weird to have to create a fake key event to call nextFocusableElement() etc. > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1511 > + information.elementRect = m_assistedNode->renderer()->absoluteBoundingBoxRect(); Wrong for subframes? > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1512 > + Page* page = m_assistedNode->document().page(); We should get the Page from |this| > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1515 > + if (!page) { > + information.hasNextNode = false; > + information.hasPreviousNode = false; Does this ever happen? > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1532 > + information.isMultiSelect = element->multiple(); > + } else if (isHTMLTextAreaElement(m_assistedNode.get())) { Maybe early returns here. 984546 4 simon.fraser 2014-02-25 16:54:10 -0800 > I think our preferred style is [_traits.get setSecureTextEntry:...] Sorry, I meant [_traits setSecureTextEntry:...] 984555 5 225197 joepeck 2014-02-25 17:17:29 -0800 Comment on attachment 225197 Patch1 View in context: https://bugs.webkit.org/attachment.cgi?id=225197&action=review Looks good to me. I am not a WK2 Owner. > Source/WebKit2/ChangeLog:11 > + select the appropriate keybaord type based on the Typo: "keybaord" => "keyboard" > Source/WebKit2/Shared/AssistedNodeInformation.cpp:101 > + > + Nit: extra blank line > Source/WebKit2/Shared/AssistedNodeInformation.h:31 > +#include <WebCore/WebAutocapitalize.h> > +#include <WebCore/IntRect.h> Nit: sort order > Source/WebKit2/Shared/AssistedNodeInformation.h:39 > + WKTypeText, Should Password be a specific type instead of an "isPasswordField" boolean? > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:370 > + case WebKit::WKTypeDate: > + case WebKit::WKTypeDateTime: > + case WebKit::WKTypeDateTimeLocal: > + case WebKit::WKTypeTime: > + return !UICurrentUserInterfaceIdiomIsPad(); Needs Month type. > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1449 > + if (!_assistedNodeInformation.formAction.isEmpty()) Some newlines would really make this code easier to read! > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1456 > + [_traits setAutocapitalizationType:toUITextAutocapitalize(_assistedNodeInformation.autocapitalizeType)]; > + [_traits setAutocorrectionType:_assistedNodeInformation.isAutocorrect ? UITextAutocorrectionTypeYes : UITextAutocorrectionTypeNo]; Style: double indent. > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1505 > + Node* nextNode = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), startNode, key.get()) > + : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), startNode, key.get()); > + while (nextNode && !isAssistableNode(startNode)) > + nextNode = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()) > + : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()); I think this is supposed to be isAssistableNode(nextNode) not startNode. How reducing the duplicated logic with a do/while. Node* nextNode = startNode; do { nextNode = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()) : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()); } while (nextNode && !isAssistableNode(startNode) > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1554 > + information.elementType = element->getAttribute("pattern") == "\\d*" || element->getAttribute("pattern") == "[0-9]*" ? WKTypeNumberPad : WKTypeNumber; I think this should also happen for text inputs. If we get <input type="text" pattern="[0-9]*"> we should show a number pad. Not only for <input type="number">. > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1574 > + information.valueAsNumber = element->valueAsNumber(); Will we need to be careful about only encoding valueAsNumber when it is valid? document.createElement("input").valueAsNumber => NaN. 984556 6 joepeck 2014-02-25 17:18:15 -0800 I think I may have accidentally erased smfr's r+ submitting the review form. 984578 7 enrica 2014-02-25 18:16:13 -0800 (In reply to comment #3) > > In what coordinate space? What about frames? The idea is to have everything in view coordinates. > > I wish we didn't store all these by value. We should only allocate AssistedNodeInformation when a node is being assisted. It is possible. There is only one per view though. > > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1447 > > + _traits.get().secureTextEntry = _assistedNodeInformation.isPasswordField; > > I think our preferred style is [_traits.get setSecureTextEntry:...] I'll change it. > > Can we subclass UITextInputTraits and push some of this logic into it? Not sure how to do this. UITextInputTraits is a protocol that the view needs to implement. > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1500 > > + RefPtr<KeyboardEvent> key = KeyboardEvent::create(); > > Seems weird to have to create a fake key event to call nextFocusableElement() etc. FocusController::nextFocusableElement and FocusController::previousFocusableElement internally dereference the KeyboardEvent* parameter. Don't see any other way to do it. > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1511 > > + information.elementRect = m_assistedNode->renderer()->absoluteBoundingBoxRect(); > > Wrong for subframes? > I'll add the mapping. The rect needs to be in view coordinates. > Does this ever happen? No I'll remove it. > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1532 > > + information.isMultiSelect = element->multiple(); > > + } else if (isHTMLTextAreaElement(m_assistedNode.get())) { > > Maybe early returns here. 984583 8 enrica 2014-02-25 18:31:50 -0800 Thanks for the review!! > > > Source/WebKit2/Shared/AssistedNodeInformation.h:39 > > + WKTypeText, > > Should Password be a specific type instead of an "isPasswordField" boolean? Yes, I'll change it. > > > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:370 > > + case WebKit::WKTypeDate: > > + case WebKit::WKTypeDateTime: > > + case WebKit::WKTypeDateTimeLocal: > > + case WebKit::WKTypeTime: > > + return !UICurrentUserInterfaceIdiomIsPad(); > > Needs Month type. I'll double check WK1. I didn't think we were using month, but I might be wrong. > > > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1505 > > + Node* nextNode = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), startNode, key.get()) > > + : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), startNode, key.get()); > > + while (nextNode && !isAssistableNode(startNode)) > > + nextNode = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()) > > + : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&startNode->document()), nextNode, key.get()); > > I think this is supposed to be isAssistableNode(nextNode) not startNode. > You are absolutely right. I had already fixed it. > How reducing the duplicated logic with a do/while. > Much better! > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1554 > > + information.elementType = element->getAttribute("pattern") == "\\d*" || element->getAttribute("pattern") == "[0-9]*" ? WKTypeNumberPad : WKTypeNumber; > > I think this should also happen for text inputs. If we get <input type="text" pattern="[0-9]*"> we should show a number pad. Not only for <input type="number">. > I'll fix it. > > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1574 > > + information.valueAsNumber = element->valueAsNumber(); > > Will we need to be careful about only encoding valueAsNumber when it is valid? > > document.createElement("input").valueAsNumber => NaN. I'll double check what we do for WK1. 984594 9 225197 sam 2014-02-25 18:56:32 -0800 Comment on attachment 225197 Patch1 View in context: https://bugs.webkit.org/attachment.cgi?id=225197&action=review > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:50 > +struct AssistedNodeInformation; I don't think you need to forward declare this since you are #importing it. > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:1484 > +static inline bool isAssistableNode(Node* node) Pass the node as a Node& 984595 10 enrica 2014-02-25 19:00:20 -0800 First patch landed. Committed revision 164690. 984949 11 225311 enrica 2014-02-26 15:35:03 -0800 Created attachment 225311 Patch2 984951 12 commit-queue 2014-02-26 15:36:38 -0800 Attachment 225311 did not pass style-queue: ERROR: Source/WebKit2/UIProcess/ios/WKFormPopover.h:32: This { should be at the end of the previous line [whitespace/braces] [4] ERROR: Source/WebKit2/UIProcess/ios/WKFormPopover.h:44: Missing space after , [whitespace/comma] [3] ERROR: Source/WebKit2/UIProcess/ios/WKFormPopover.h:45: Missing space after , [whitespace/comma] [3] ERROR: Source/WebKit2/UIProcess/ios/WKFormPopover.h:46: Missing space after , [whitespace/comma] [3] Total errors found: 4 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 984973 13 225311 simon.fraser 2014-02-26 16:14:01 -0800 Comment on attachment 225311 Patch2 View in context: https://bugs.webkit.org/attachment.cgi?id=225311&action=review Seems OK but I would like to see some naming improvements, and preferably file moves. > Source/WebKit2/ChangeLog:25 > + * UIProcess/ios/WKFormInputControl.h: Added. > + * UIProcess/ios/WKFormInputControl.mm: Added. Maybe the files should be called WKFormInputControls? > Source/WebKit2/ChangeLog:54 > + * UIProcess/ios/WKFormPeripheral.h: Added. > + * UIProcess/ios/WKFormPopover.h: Added. > + * UIProcess/ios/WKFormPopover.mm: Added. Lots of new form-related files. Maybe make UIProcess/ios/forms ? > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:104 > + RetainPtr<NSObject<WKFormPeripheral> > _inputPeripheral; Can this have a better name? What is a peripheral? > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:139 > +- (void)accessoryDone; Is this a protocol method or can it have a better name (e.g. formAccessoryDone)? > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:50 > +// WKDateTimePicker Comment is not useful. > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:53 > + NSString *_formatString; What's the ownership of this string? > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:62 > +// WKDateTimePopover Ditto. > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:87 > + self = [super init]; > + if (!self) > + return nil; We usually do if ((self == [super init])) {...} > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:92 > + _formatString = nil; No need. > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:206 > + RetainPtr<NSLocale> englishLocale = adoptNS([[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"]); > + RetainPtr<NSDateFormatter> dateFormatter = adoptNS([[NSDateFormatter alloc] init]); > + [dateFormatter setTimeZone:_datePicker.get().timeZone]; > + [dateFormatter setDateFormat:_formatString]; > + [dateFormatter setLocale:englishLocale.get()]; Maybe share with the previous copy of this code? > Source/WebKit2/UIProcess/ios/WKFormPopover.h:36 > + id <WKRotatingPopoverDelegate> _dismissDelegate; "_dismissDelegate" sounds like a command. dismissionDelegate? > Source/WebKit2/UIProcess/ios/WKFormPopover.h:54 > +@interface WKFormRotatingAccessoryPopover : WKRotatingPopover <WKRotatingPopoverDelegate> "form rotating accessory popover" is hard to parse. I can't tell what this does. Is it related to device rotation? 984975 14 joepeck 2014-02-26 16:17:20 -0800 View in context: https://bugs.webkit.org/attachment.cgi?id=225311&action=review Looks good to me. > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:104 > + RetainPtr<NSObject<WKFormPeripheral> > _inputPeripheral; Style: No need for "> >" it can be ">>". > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:29 > +#import "config.h" > +#import "WKContentView.h" > +#import "WKContentViewInteraction.h" > +#import "WKFormInputControl.h" Isn't the usual style: #import "config.h" #import "WKFormInputControl.h" #import ... > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:244 > + case WebKit::WKTypeDate: > + mode = UIDatePickerModeDate; > + break; > + case WebKit::WKTypeDateTimeLocal: > + mode = UIDatePickerModeDateAndTime; > + break; Nit: newline between these cases like the other cases? > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:345 > +#pragma clang diagnostic push > +#pragma clang diagnostic ignored "-Wdeprecated-declarations" > + UIBarButtonItem *clearButton = [[[UIBarButtonItem alloc] initWithTitle:clearString style:UIBarButtonItemStyleBordered target:self action:@selector(clear:)] autorelease]; > +#pragma clang diagnostic pop Gross =(. 984982 15 enrica 2014-02-26 16:28:35 -0800 Thanks for the review. > Maybe the files should be called WKFormInputControls? Not sure I agree. It handles HTMLInput control with different types. > > > Source/WebKit2/ChangeLog:54 > > + * UIProcess/ios/WKFormPeripheral.h: Added. > > + * UIProcess/ios/WKFormPopover.h: Added. > > + * UIProcess/ios/WKFormPopover.mm: Added. > > Lots of new form-related files. Maybe make UIProcess/ios/forms ? I can do that. > > Can this have a better name? What is a peripheral? Peripheral is the UIKit terminology for input device. > > > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:139 > > +- (void)accessoryDone; > > Is this a protocol method or can it have a better name (e.g. formAccessoryDone)? I prefer to keep the name the same as the WebKit1 version. It makes it easier to find the corresponding implementation. > > > What's the ownership of this string? It only points to constant strings. > > Source/WebKit2/UIProcess/ios/WKFormInputControl.mm:206 > > + RetainPtr<NSLocale> englishLocale = adoptNS([[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"]); > > + RetainPtr<NSDateFormatter> dateFormatter = adoptNS([[NSDateFormatter alloc] init]); > > + [dateFormatter setTimeZone:_datePicker.get().timeZone]; > > + [dateFormatter setDateFormat:_formatString]; > > + [dateFormatter setLocale:englishLocale.get()]; > > Maybe share with the previous copy of this code? Good idea. > > Source/WebKit2/UIProcess/ios/WKFormPopover.h:36 > > + id <WKRotatingPopoverDelegate> _dismissDelegate; > > "_dismissDelegate" sounds like a command. dismissionDelegate? Sure. > > > Source/WebKit2/UIProcess/ios/WKFormPopover.h:54 > > +@interface WKFormRotatingAccessoryPopover : WKRotatingPopover <WKRotatingPopoverDelegate> > > "form rotating accessory popover" is hard to parse. I can't tell what this does. Is it related to device rotation? Yes. for iPad the date/time pickers are inside a popover. We need to handle the device rotation to hide the popover when rotation begins and show it at the new position and potentially with a different arrow direction when done. 984997 16 enrica 2014-02-26 17:01:31 -0800 Committed revision 164760. 986031 17 225579 enrica 2014-03-01 18:39:09 -0800 Created attachment 225579 Patch3 Adds support for select elements on iOS. 986032 18 225579 thorton 2014-03-01 19:13:17 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:403 > + _tableViewController.get().popover = self; I (think) we prefer [_object setPopover:self]; in the smartptr message passing case. > Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm:55 > +#import <WebCore/HTMLOptGroupElement.h> > +#import <WebCore/HTMLOptionElement.h> > #import <WebCore/HTMLInputElement.h> these don't look sorted correctly 986049 19 225579 simon.fraser 2014-03-01 20:46:10 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:120 > +- (Vector<WebKit::WKOptionItem>&) assistedNodeSelectOptions; Why not make this a readonly property? If you want it as a method, please move it lower down. > Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1812 > +- (Vector<WKOptionItem>&) assistedNodeSelectOptions No space after the ) Should this return a non-const reference? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.h:40 > +- (id)initWithView:(WKContentView *)view hasGroups:(BOOL)hasGroups; Return instancetype? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.h:45 > +- (id)initWithView:(WKContentView *)view; instancetype? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.mm:73 > ++ (WKFormSelectControl *)createPeripheralWithView:(WKContentView *)view It would be more idiomatic to call this +peripheralWithView and have it return an autoreleased object (don't forget to fix the callers). > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:49 > + WKOptionItem* _optionToSelectWhenDone; I don't really like holding a pointer to an object in an array that's held by some other class. Can we store its index instead? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:60 > + self.dataSource = self; Is the dataSource retained? Is this creating a retain cycle? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:68 > + for (size_t i = 0; i < _view.assistedNodeInformation.selectOptions.size(); ++i) { > + WKOptionItem* item = &[_view assistedNodeSelectOptions][i]; Really confusing that the first line uses _view.assistedNodeInformation.selectOptions and the second [_view assistedNodeSelectOptions] which I think are the same? Use const WKOptionItem& > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:144 > + return [string substringWithRange: r]; No space after : > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:149 > +- (NSInteger)pickerView:(UIPickerView *)aPickerView numberOfRowsInComponent:(NSInteger)aColumnIndex aPickerView -> pickerView, aColumnIndex -> columnIndex > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:156 > + const WKOptionItem& option = [_view assistedNodeSelectOptions][row]; I think you should check that 'row' is in bounds here. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:168 > + const WKOptionItem& newSelectedOption = [_view assistedNodeSelectOptions][row]; Ditto. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:200 > + _optionToSelectWhenDone = &[_view assistedNodeSelectOptions][row]; Nasty. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:50 > +static NSString *WKPopoverTableViewCellReuseIdentifier = @"WKPopoverTableViewCellReuseIdentifier"; static NSString* const Foo > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:77 > + unichar directionalFormattingCharacter = (writingDirection == UITextWritingDirectionLeftToRight) ? (override ? leftToRightOverride : leftToRightEmbedding) > + : (override ? rightToLeftOverride : rightToLeftEmbedding); Hard to understand. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:112 > + WKSelectPopover *_popover; What's the ownership model? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:260 > + cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:WKPopoverTableViewCellReuseIdentifier] autorelease]; This is leaked. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:407 > + CGFloat titleHeight = 0.0; = 0 > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:439 > + _tableViewController.get().popover = nil; [_tableViewController.get setPopover:nil] etc > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:443 > + _tableViewController = nil; No point doing this. 986133 20 225579 darin 2014-03-02 11:13:16 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review > Source/WebCore/WebCore.exp.in:262 > __ZNK7WebCore11HTMLElement5titleEv > +__ZN7WebCore9HTMLNames11optgroupTagE > +__ZNK7WebCore19HTMLOptGroupElement14groupLabelTextEv > +__ZN7WebCore17HTMLOptionElement8selectedEv > +__ZN7WebCore9HTMLNames12disabledAttrE > +__ZN7WebCore17HTMLSelectElement20optionSelectedByUserEibb > __ZNK7WebCore17HTMLOptionElement4textEv To make merges of this file easier, it’s much better if we keep these lists of symbols sorted in the order that the command-line sort tool does, rather than just putting new symbols in a block together. The existing symbols seem to be sorted. What I do is add my symbols, then select the text and copy, then "pbpaste | sort | pbcopy", then paste the symbols back in. 986176 21 225579 enrica 2014-03-02 14:48:51 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review Thanks for the review! I added some replies to your comments. >> Source/WebCore/WebCore.exp.in:262 >> __ZNK7WebCore17HTMLOptionElement4textEv > > To make merges of this file easier, it’s much better if we keep these lists of symbols sorted in the order that the command-line sort tool does, rather than just putting new symbols in a block together. The existing symbols seem to be sorted. What I do is add my symbols, then select the text and copy, then "pbpaste | sort | pbcopy", then paste the symbols back in. Thanks! I'll do that. >> Source/WebKit2/UIProcess/ios/WKContentViewInteraction.h:120 >> +- (Vector<WebKit::WKOptionItem>&) assistedNodeSelectOptions; > > Why not make this a readonly property? > > If you want it as a method, please move it lower down. I need this to be readwrite because, if we have a multi-select, we want to update the information on the UIProcess side, without querying a new state from the WebProcess. I preferred to leave the existing assistedNodeInformation as readonly and expose only the select option part as writable. I'll move it down, as you suggested. >> Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm:1812 >> +- (Vector<WKOptionItem>&) assistedNodeSelectOptions > > No space after the ) > Should this return a non-const reference? Yes, see the comment above. >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.mm:73 >> ++ (WKFormSelectControl *)createPeripheralWithView:(WKContentView *)view > > It would be more idiomatic to call this +peripheralWithView and have it return an autoreleased object (don't forget to fix the callers). This is consistent with the way we handle the input controls. Why did you find it ok for those and not this one? >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:49 >> + WKOptionItem* _optionToSelectWhenDone; > > I don't really like holding a pointer to an object in an array that's held by some other class. Can we store its index instead? I agree, I'll change it >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:60 >> + self.dataSource = self; > > Is the dataSource retained? Is this creating a retain cycle? This is the same model used by the WebKit1 implementation. I believe this is ok. >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:68 >> + WKOptionItem* item = &[_view assistedNodeSelectOptions][i]; > > Really confusing that the first line uses _view.assistedNodeInformation.selectOptions and the second [_view assistedNodeSelectOptions] which I think are the same? > > Use const WKOptionItem& Sure, I forgot. >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:200 >> + _optionToSelectWhenDone = &[_view assistedNodeSelectOptions][row]; > > Nasty. I'll use the index here too. >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:112 >> + WKSelectPopover *_popover; > > What's the ownership model? WKSelectPopover has a RetainPtr to WKSelectTableViewController which in turn holds a weak reference to WKSelectPopover. >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:260 >> + cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:WKPopoverTableViewCellReuseIdentifier] autorelease]; > > This is leaked. Why? It is autoreleased. 986187 22 225579 enrica 2014-03-02 15:28:08 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review >>> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:49 >>> + WKOptionItem* _optionToSelectWhenDone; >> >> I don't really like holding a pointer to an object in an array that's held by some other class. Can we store its index instead? > > I agree, I'll change it Actually this is leftover of me trying to implement the multi select picker. I only need _selectedIndex here. 986194 23 enrica 2014-03-02 16:14:27 -0800 Committed revision 164955. 986276 24 simon.fraser 2014-03-02 23:22:54 -0800 > >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.mm:73 > >> ++ (WKFormSelectControl *)createPeripheralWithView:(WKContentView *)view > > > > It would be more idiomatic to call this +peripheralWithView and have it return an autoreleased object (don't forget to fix the callers). > > This is consistent with the way we handle the input controls. Why did you find it ok for those and not this one? Maybe I didn't notice! Use of "create" is fairly rare in Obj-C, and doing it this way is more likely to result in mistakes I think. > >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:60 > >> + self.dataSource = self; > > > > Is the dataSource retained? Is this creating a retain cycle? Could you check? > >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:112 > >> + WKSelectPopover *_popover; > > > > What's the ownership model? > > WKSelectPopover has a RetainPtr to WKSelectTableViewController which in turn holds a weak reference to WKSelectPopover. I think it's good to document weak refs with comments (or the 'weak' keyword) to make ownership clear. > >> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPopover.mm:260 > >> + cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:WKPopoverTableViewCellReuseIdentifier] autorelease]; > > > > This is leaked. > > Why? It is autoreleased. Sorry, I misread. 986439 25 225579 joepeck 2014-03-03 12:02:46 -0800 Comment on attachment 225579 Patch3 View in context: https://bugs.webkit.org/attachment.cgi?id=225579&action=review >>> Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:60 >>> + self.dataSource = self; >> >> Is the dataSource retained? Is this creating a retain cycle? > > This is the same model used by the WebKit1 implementation. I believe this is ok. A dataSource is just like a delegate. They are both (assign) UIPickerView properties. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:131 > + // First strip all white space off the end of the range Weird double space in comments here. 987303 26 225892 enrica 2014-03-05 10:38:56 -0800 Created attachment 225892 Patch4 987304 27 commit-queue 2014-03-05 10:41:26 -0800 Attachment 225892 did not pass style-queue: ERROR: Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.h:34: The parameter name "font" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 987311 28 225892 simon.fraser 2014-03-05 11:08:18 -0800 Comment on attachment 225892 Patch4 View in context: https://bugs.webkit.org/attachment.cgi?id=225892&action=review > Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.h:34 > +extern CGFloat adjustedFontSize(CGFloat textWidth, UIFont *font, CGFloat initialFontSize, const Vector<WebKit::WKOptionItem>& items); Does this need the 'extern'? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectControl.h:51 > +@interface WKSelectMultiplePicker : UIPickerView <WKFormControl, UIPickerViewDataSource, UIPickerViewDelegate> SelectMultiple or MultipleSelect? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:52 > +static NSString *stringByTrimmingWhitespaceAndNewlines(NSString *string) Can this just use CFTrimWhitespace (which says it removes newlines too)? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:85 > +- (instancetype)initCommon; Why not just -init? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:101 > + [self.titleLabel setLineBreakMode:NSLineBreakByTruncatingMiddle]; Should not use property syntax in init and dealloc methods. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:114 > + self.titleLabel.text = stringByTrimmingWhitespaceAndNewlines(item.text); > + self.checked = item.isSelected; > + self.disabled = item.disabled; > + if (self.disabled) > + self.titleLabel.textColor = [UIColor colorWithWhite:0.0 alpha:DisabledOptionAlpha]; Ditto. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:136 > + self.titleLabel.text = stringByTrimmingWhitespaceAndNewlines(item.text); > + self.checked = NO; > + self.titleLabel.textColor = [UIColor colorWithWhite:0.0 alpha:0.5]; > + self.disabled = YES; Ditto > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:163 > + float _layoutWidth; Why not a CGFloat? > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:178 > + self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight; > + self.dataSource = self; > + self.delegate = self; Property access. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:200 > + if (!_allowsMultipleSelection && item.isSelected) { > + _singleSelectionIndex = currentIndex; > + } No braces. > Source/WebKit2/UIProcess/ios/forms/WKFormSelectPicker.mm:213 > + self.dataSource = nil; > + self.delegate = nil; property access 987328 29 enrica 2014-03-05 11:43:20 -0800 The work is now complete Committed revision 165116. 225197 2014-02-25 16:41:39 -0800 2014-02-25 18:56:32 -0800 Patch1 keyboardtypesupport.txt text/plain 37731 enrica SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE2NDY4MCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDE0LTAyLTI1ICBFbnJpY2Eg Q2FzdWNjaSAgPGVucmljYUBhcHBsZS5jb20+CisKKyAgICAgICAgW1dlYktpdDJdIEZvcm0gY29u dHJvbHMgaGFuZGxpbmcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xMjkzNDQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzE2MDUzNjQzPgorCisgICAg ICAgIEFkZGluZyBzb21lIGV4cG9ydHMuCisgICAgICAgIAorICAgICAgICAqIFdlYkNvcmUuZXhw LmluOgorCiAyMDE0LTAyLTI1ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KIAogICAg ICAgICBKU0RPTVByb21pc2UgbWV0aG9kcyBzaG91bGQgYWNxdWlyZSBWTSBsb2NrIGJlZm9yZSBj YWxsaW5nIGludG8gSlMuCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgkocmV2aXNpb24gMTY0NjU0 KQorKysgU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4JKHdvcmtpbmcgY29weSkKQEAgLTI0 OSw2ICsyNDksMzEgQEAgX19aTjdXZWJDb3JlMTJjYWNoZVN0b3JhZ2VFdgogX19aTjdXZWJDb3Jl MTJkZWxldGVDb29raWVFUktOU18yMU5ldHdvcmtTdG9yYWdlU2Vzc2lvbkVSS05TXzNVUkxFUktO M1dURjZTdHJpbmdFCiBfX1pON1dlYkNvcmUxMmdjQ29udHJvbGxlckV2CiBfX1pON1dlYkNvcmUx Mmljb25EYXRhYmFzZUV2CitfX1pON1dlYkNvcmUxM0tleWJvYXJkRXZlbnRDMUV2CitfX1pON1dl YkNvcmUxNUZvY3VzQ29udHJvbGxlcjIwbmV4dEZvY3VzYWJsZUVsZW1lbnRFTlNfMjBGb2N1c05h dmlnYXRpb25TY29wZUVQTlNfNE5vZGVFUE5TXzEzS2V5Ym9hcmRFdmVudEUKK19fWk43V2ViQ29y ZTE1Rm9jdXNDb250cm9sbGVyMjRwcmV2aW91c0ZvY3VzYWJsZUVsZW1lbnRFTlNfMjBGb2N1c05h dmlnYXRpb25TY29wZUVQTlNfNE5vZGVFUE5TXzEzS2V5Ym9hcmRFdmVudEUKK19fWk5LN1dlYkNv cmUxMUhUTUxFbGVtZW50NXRpdGxlRXYKK19fWk5LN1dlYkNvcmUxN0hUTUxPcHRpb25FbGVtZW50 NHRleHRFdgorX19aTks3V2ViQ29yZTE3SFRNTFNlbGVjdEVsZW1lbnQxM3NlbGVjdGVkSW5kZXhF dgorX19aTks3V2ViQ29yZTIySFRNTEZvcm1Db250cm9sRWxlbWVudDE4YXV0b2NhcGl0YWxpemVU eXBlRXYKK19fWk5LN1dlYkNvcmUxNkhUTUxJbnB1dEVsZW1lbnQxM2lzU2VhcmNoRmllbGRFdgor X19aTks3V2ViQ29yZTE2SFRNTElucHV0RWxlbWVudDIwaXNEYXRlVGltZUxvY2FsRmllbGRFdgor X19aTks3V2ViQ29yZTE2SFRNTElucHV0RWxlbWVudDEzdmFsdWVBc051bWJlckV2CitfX1pOSzdX ZWJDb3JlMTlIVE1MVGV4dEFyZWFFbGVtZW50NXZhbHVlRXYKK19fWk5LN1dlYkNvcmUyMkhUTUxG b3JtQ29udHJvbEVsZW1lbnQxMWF1dG9jb3JyZWN0RXYKK19fWk5LN1dlYkNvcmUxNkhUTUxJbnB1 dEVsZW1lbnQxMmlzRW1haWxGaWVsZEV2CitfX1pON1dlYkNvcmUyMEZvY3VzTmF2aWdhdGlvblNj b3BlMjJmb2N1c05hdmlnYXRpb25TY29wZU9mRVBOU180Tm9kZUUKK19fWk5LN1dlYkNvcmUxNkhU TUxJbnB1dEVsZW1lbnQxMmlzTW9udGhGaWVsZEV2CitfX1pOSzdXZWJDb3JlMTZIVE1MSW5wdXRF bGVtZW50MTFpc0RhdGVGaWVsZEV2CitfX1pOSzdXZWJDb3JlMTdIVE1MU2VsZWN0RWxlbWVudDls aXN0SXRlbXNFdgorX19aTks3V2ViQ29yZTE2SFRNTElucHV0RWxlbWVudDE1aXNEYXRlVGltZUZp ZWxkRXYKK19fWk5LN1dlYkNvcmUxNkhUTUxJbnB1dEVsZW1lbnQxMWlzVGltZUZpZWxkRXYKK19f Wk5LN1dlYkNvcmUxNkhUTUxJbnB1dEVsZW1lbnQxM2lzTnVtYmVyRmllbGRFdgorX19aTks3V2Vi Q29yZTE2SFRNTElucHV0RWxlbWVudDExaXNXZWVrRmllbGRFdgorX19aTks3V2ViQ29yZTE2SFRN TElucHV0RWxlbWVudDEwaXNVUkxGaWVsZEV2CitfX1pOSzdXZWJDb3JlMTZIVE1MSW5wdXRFbGVt ZW50MTZpc1RlbGVwaG9uZUZpZWxkRXYKK19fWk43V2ViQ29yZTlIVE1MTmFtZXMxMGFjdGlvbkF0 dHJFCitfX1pOSzdXZWJDb3JlN0VsZW1lbnQxNWdldFVSTEF0dHJpYnV0ZUVSS05TXzEzUXVhbGlm aWVkTmFtZUUKIF9fWk43V2ViQ29yZTEzQVhPYmplY3RDYWNoZTEwcm9vdE9iamVjdEV2CiBfX1pO N1dlYkNvcmUxM0FYT2JqZWN0Q2FjaGUxOHJvb3RPYmplY3RGb3JGcmFtZUVQTlNfNUZyYW1lRQog X19aTjdXZWJDb3JlMTNBWE9iamVjdENhY2hlMTllbmFibGVBY2Nlc3NpYmlsaXR5RXYKSW5kZXg6 IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cJKHJldmlzaW9uIDE2NDY4MCkKKysrIFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwko d29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDUyIEBACisyMDE0LTAyLTI1ICBFbnJpY2EgQ2FzdWNj aSAgPGVucmljYUBhcHBsZS5jb20+CisKKyAgICAgICAgW1dlYktpdDJdIEZvcm0gY29udHJvbHMg aGFuZGxpbmcuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xMjkzNDQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzE2MDUzNjQzPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgaXMgdGhlIHN0ZXAgdG93 YXJkIGFkZGluZyBzdXBwb3J0IGZvcgorICAgICAgICBmb3JtIGNvbnRyb2xzIGlPUyBzdHlsZS4g SXQgYWRkcyB0aGUgbG9naWMgdG8KKyAgICAgICAgc2VsZWN0IHRoZSBhcHByb3ByaWF0ZSBrZXli YW9yZCB0eXBlIGJhc2VkIG9uIHRoZQorICAgICAgICBlbGVtZW50IHR5cGUgYW5kIGludHJvZHVj ZXMgdGhlIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uCisgICAgICAgIHN0cnVjdHVyZSB1c2VkIGN1 cnJlbnRseSBmb3IgdGhlIGtleWJvYXJkIHR5cGUgc2VsZWN0aW9uCisgICAgICAgIGFuZCB0aGF0 IHdpbGwgYmUgdXNlZCB0byBwb3B1bGF0ZSBwaWNrZXJzIGFuZCBwb3BvdmVycy4KKyAgICAgICAg SXQgYWxzbyBwcm92aWRlcyBpbmZvcm1hdGlvbiB0byBlbmFibGUvZGlzYWJsZSBuZXh0L3ByZXZp b3VzCisgICAgICAgIGJ1dHRvbnMgaW4gdGhlIGFjY2Vzc29yeSB2aWV3LgorCisgICAgICAgICog U2NyaXB0cy93ZWJraXQyL21lc3NhZ2VzLnB5OgorICAgICAgICAoc3RydWN0X29yX2NsYXNzKToK KyAgICAgICAgKiBTaGFyZWQvQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb246OmVuY29kZSk6CisgICAgICAg IChXZWJLaXQ6OkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uOjpkZWNvZGUpOgorICAgICAgICAqIFNo YXJlZC9Bc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6 QXNzaXN0ZWROb2RlSW5mb3JtYXRpb246OkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uKToKKyAgICAg ICAgKiBVSVByb2Nlc3MvUGFnZUNsaWVudC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdl UHJveHkuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluOgor ICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvUGFnZUNsaWVudEltcGxJT1MuaDoKKyAgICAgICAgKiBV SVByb2Nlc3MvaW9zL1BhZ2VDbGllbnRJbXBsSU9TLm1tOgorICAgICAgICAoV2ViS2l0OjpQYWdl Q2xpZW50SW1wbDo6c3RhcnRBc3Npc3RpbmdOb2RlKToKKyAgICAgICAgKiBVSVByb2Nlc3MvaW9z L1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvV0tD b250ZW50Vmlld0ludGVyYWN0aW9uLm1tOgorICAgICAgICAoLVtXS0NvbnRlbnRWaWV3IF9yZXF1 aXJlc0tleWJvYXJkV2hlbkZpcnN0UmVzcG9uZGVyXSk6CisgICAgICAgICgtW1dLQ29udGVudFZp ZXcgX3VwZGF0ZUFjY2Vzc29yeV0pOgorICAgICAgICAodG9VSVRleHRBdXRvY2FwaXRhbGl6ZSk6 CisgICAgICAgICgtW1dLQ29udGVudFZpZXcgdGV4dElucHV0VHJhaXRzXSk6CisgICAgICAgICgt W1dLQ29udGVudFZpZXcgYXNzaXN0ZWROb2RlSW5mb3JtYXRpb25dKToKKyAgICAgICAgKC1bV0tD b250ZW50VmlldyBfc3RhcnRBc3Npc3RpbmdOb2RlOl0pOgorICAgICAgICAoLVtXS0NvbnRlbnRW aWV3IF9zdG9wQXNzaXN0aW5nTm9kZV0pOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvV2ViUGFn ZVByb3h5SU9TLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnN0YXJ0QXNzaXN0 aW5nTm9kZSk6CisgICAgICAgICogV2ViS2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgor ICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmg6CisgICAgICAgICogV2ViUHJv Y2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1tOgorICAgICAgICAoV2ViS2l0Ojppc0Fzc2lz dGFibGVOb2RlKToKKyAgICAgICAgKFdlYktpdDo6aGFzRm9jdXNhYmxlTm9kZSk6CisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2U6OmdldEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uKToKKyAgICAgICAg KFdlYktpdDo6V2ViUGFnZTo6ZWxlbWVudERpZEZvY3VzKToKKwogMjAxNC0wMi0yNSAgQW5kZXJz IENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFNpbXBsaWZ5IHZpc2l0 ZWQgbGluayBzdHlsZSBpbnZhbGlkYXRpb24KSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1NjcmlwdHMv d2Via2l0Mi9tZXNzYWdlcy5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9TY3JpcHRz L3dlYmtpdDIvbWVzc2FnZXMucHkJKHJldmlzaW9uIDE2NDY1NCkKKysrIFNvdXJjZS9XZWJLaXQy L1NjcmlwdHMvd2Via2l0Mi9tZXNzYWdlcy5weQkod29ya2luZyBjb3B5KQpAQCAtMjA0LDYgKzIw NCw3IEBAIGRlZiBzdHJ1Y3Rfb3JfY2xhc3MobmFtZXNwYWNlLCB0eXBlKToKICAgICAgICAgJ1dl YkNvcmU6OlZpZXdwb3J0QXJndW1lbnRzJywKICAgICAgICAgJ1dlYkNvcmU6OlZpZXdwb3J0QXR0 cmlidXRlcycsCiAgICAgICAgICdXZWJDb3JlOjpXaW5kb3dGZWF0dXJlcycsCisgICAgICAgICdX ZWJLaXQ6OkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJywKICAgICAgICAgJ1dlYktpdDo6QXR0cmli dXRlZFN0cmluZycsCiAgICAgICAgICdXZWJLaXQ6OkNvbG9yU3BhY2VEYXRhJywKICAgICAgICAg J1dlYktpdDo6Q29udGV4dE1lbnVTdGF0ZScsCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9TaGFyZWQv QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQy L1NoYXJlZC9Bc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5jcHAJKHJldmlzaW9uIDApCisrKyBTb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0wLDAgKzEsMTA2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisg KiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICog QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmgiCisKKyNpbmNsdWRlICJBcmd1bWVu dHMuaCIKKyNpbmNsdWRlICJXZWJDb3JlQXJndW1lbnRDb2RlcnMuaCIKKworbmFtZXNwYWNlIFdl YktpdCB7CisKKyNpZiBQTEFURk9STShJT1MpCit2b2lkIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9u OjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNvbnN0Cit7CisgICAgZW5j b2RlciA8PCBlbGVtZW50UmVjdDsKKyAgICBlbmNvZGVyIDw8IGhhc05leHROb2RlOworICAgIGVu Y29kZXIgPDwgaGFzUHJldmlvdXNOb2RlOworICAgIGVuY29kZXIgPDwgaXNQYXNzd29yZEZpZWxk OworICAgIGVuY29kZXIgPDwgaXNBdXRvY29ycmVjdDsKKyAgICBlbmNvZGVyIDw8ICh1aW50MzJf dClhdXRvY2FwaXRhbGl6ZVR5cGU7CisgICAgZW5jb2RlciA8PCAodWludDMyX3QpZWxlbWVudFR5 cGU7CisgICAgZW5jb2RlciA8PCBmb3JtQWN0aW9uOworICAgIGVuY29kZXIgPDwgc2VsZWN0aW9u T3B0aW9uczsKKyAgICBlbmNvZGVyIDw8IHNlbGVjdGVkSW5kZXg7CisgICAgZW5jb2RlciA8PCBp c011bHRpU2VsZWN0OworICAgIGVuY29kZXIgPDwgaXNSZWFkT25seTsKKyAgICBlbmNvZGVyIDw8 IHZhbHVlOworICAgIGVuY29kZXIgPDwgdmFsdWVBc051bWJlcjsKKyAgICBlbmNvZGVyIDw8IHRp dGxlOworfQorCitib29sIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uOjpkZWNvZGUoSVBDOjpBcmd1 bWVudERlY29kZXImIGRlY29kZXIsIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJiByZXN1bHQpCit7 CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShyZXN1bHQuZWxlbWVudFJlY3QpKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5oYXNOZXh0Tm9k ZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVz dWx0Lmhhc1ByZXZpb3VzTm9kZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICgh ZGVjb2Rlci5kZWNvZGUocmVzdWx0LmlzUGFzc3dvcmRGaWVsZCkpCisgICAgICAgIHJldHVybiBm YWxzZTsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LmlzQXV0b2NvcnJlY3QpKQor ICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKCh1aW50MzJf dCYpcmVzdWx0LmF1dG9jYXBpdGFsaXplVHlwZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgIGlmICghZGVjb2Rlci5kZWNvZGUoKHVpbnQzMl90JilyZXN1bHQuZWxlbWVudFR5cGUpKQor ICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5m b3JtQWN0aW9uKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFkZWNvZGVyLmRl Y29kZShyZXN1bHQuc2VsZWN0aW9uT3B0aW9ucykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LnNlbGVjdGVkSW5kZXgpKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5pc011bHRpU2Vs ZWN0KSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShy ZXN1bHQuaXNSZWFkT25seSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICghZGVj b2Rlci5kZWNvZGUocmVzdWx0LnZhbHVlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg aWYgKCFkZWNvZGVyLmRlY29kZShyZXN1bHQudmFsdWVBc051bWJlcikpCisgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LnRpdGxlKSkKKyAgICAg ICAgcmV0dXJuIGZhbHNlOworCisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKyNlbmRpZgorCit9Cklu ZGV4OiBTb3VyY2UvV2ViS2l0Mi9TaGFyZWQvQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9TaGFyZWQvQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24u aAkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJLaXQyL1NoYXJlZC9Bc3Npc3RlZE5vZGVJbmZv cm1hdGlvbi5oCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsOTUgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJ VFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aWZuZGVmIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uX2gKKyNkZWZpbmUgQXNzaXN0ZWROb2RlSW5m b3JtYXRpb25faAorCisjaW5jbHVkZSAiQXJndW1lbnRDb2RlcnMuaCIKKyNpbmNsdWRlIDxXZWJD b3JlL1dlYkF1dG9jYXBpdGFsaXplLmg+CisjaW5jbHVkZSA8V2ViQ29yZS9JbnRSZWN0Lmg+Cisj aW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitl bnVtIFdLSW5wdXRUeXBlIHsKKyAgICBXS1R5cGVOb25lLAorICAgIFdLVHlwZUNvbnRlbnRFZGl0 YWJsZSwKKyAgICBXS1R5cGVUZXh0LAorICAgIFdLVHlwZVRleHRBcmVhLAorICAgIFdLVHlwZVNl YXJjaCwKKyAgICBXS1R5cGVFbWFpbCwKKyAgICBXS1R5cGVVUkwsCisgICAgV0tUeXBlUGhvbmUs CisgICAgV0tUeXBlTnVtYmVyLAorICAgIFdLVHlwZU51bWJlclBhZCwKKyAgICBXS1R5cGVEYXRl LAorICAgIFdLVHlwZURhdGVUaW1lLAorICAgIFdLVHlwZURhdGVUaW1lTG9jYWwsCisgICAgV0tU eXBlTW9udGgsCisgICAgV0tUeXBlV2VlaywKKyAgICBXS1R5cGVUaW1lLAorICAgIFdLVHlwZVNl bGVjdAorfTsKKworI2lmIFBMQVRGT1JNKElPUykKK3N0cnVjdCBBc3Npc3RlZE5vZGVJbmZvcm1h dGlvbiB7CisgICAgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24oKQorICAgICAgICA6IGhhc05leHRO b2RlKGZhbHNlKQorICAgICAgICAsIGhhc1ByZXZpb3VzTm9kZShmYWxzZSkKKyAgICAgICAgLCBp c1Bhc3N3b3JkRmllbGQoZmFsc2UpCisgICAgICAgICwgaXNBdXRvY29ycmVjdChmYWxzZSkKKyAg ICAgICAgLCBhdXRvY2FwaXRhbGl6ZVR5cGUoV2ViQXV0b2NhcGl0YWxpemVUeXBlRGVmYXVsdCkK KyAgICAgICAgLCBlbGVtZW50VHlwZShXS1R5cGVOb25lKQorICAgICAgICAsIHNlbGVjdGVkSW5k ZXgoLTEpCisgICAgICAgICwgaXNNdWx0aVNlbGVjdChmYWxzZSkKKyAgICAgICAgLCBpc1JlYWRP bmx5KGZhbHNlKQorICAgICAgICAsIHZhbHVlQXNOdW1iZXIoMCkKKyAgICB7CisgICAgfQorCisg ICAgV2ViQ29yZTo6SW50UmVjdCBlbGVtZW50UmVjdDsKKyAgICBib29sIGhhc05leHROb2RlOwor ICAgIGJvb2wgaGFzUHJldmlvdXNOb2RlOworICAgIGJvb2wgaXNQYXNzd29yZEZpZWxkOworICAg IGJvb2wgaXNBdXRvY29ycmVjdDsKKyAgICBXZWJBdXRvY2FwaXRhbGl6ZVR5cGUgYXV0b2NhcGl0 YWxpemVUeXBlOworICAgIFdLSW5wdXRUeXBlIGVsZW1lbnRUeXBlOworICAgIFN0cmluZyBmb3Jt QWN0aW9uOworICAgIFZlY3RvcjxTdHJpbmc+IHNlbGVjdGlvbk9wdGlvbnM7CisgICAgaW50IHNl bGVjdGVkSW5kZXg7CisgICAgYm9vbCBpc011bHRpU2VsZWN0OworICAgIGJvb2wgaXNSZWFkT25s eTsKKyAgICBTdHJpbmcgdmFsdWU7CisgICAgZG91YmxlIHZhbHVlQXNOdW1iZXI7CisgICAgU3Ry aW5nIHRpdGxlOworCisgICAgdm9pZCBlbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImKSBjb25z dDsKKyAgICBzdGF0aWMgYm9vbCBkZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImLCBBc3Npc3Rl ZE5vZGVJbmZvcm1hdGlvbiYpOworfTsKKyNlbmRpZgorCit9CisKKyNlbmRpZiAvLyBJbnRlcmFj dGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbl9oCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvUGFnZUNsaWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Q YWdlQ2xpZW50LmgJKHJldmlzaW9uIDE2NDY1NCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9QYWdlQ2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTI0Myw3ICsyNDMsNyBAQCBwdWJsaWM6 CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0TGF5ZXJUcmVlKGNvbnN0IFJlbW90ZUxheWVy VHJlZVRyYW5zYWN0aW9uJikgPSAwOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0QXNzaXN0aW5n Tm9kZShjb25zdCBXZWJDb3JlOjpJbnRSZWN0JiwgYm9vbCBoYXNOZXh0Rm9jdXNhYmxlLCBib29s IGhhc1ByZXZpb3VzRm9jdXNhYmxlKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0QXNzaXN0 aW5nTm9kZShjb25zdCBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbiYpID0gMDsKICAgICB2aXJ0dWFs IHZvaWQgc3RvcEFzc2lzdGluZ05vZGUoKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNlbGVjdGlv bkRpZENoYW5nZSgpID0gMDsKICAgICB2aXJ0dWFsIGJvb2wgaW50ZXJwcmV0S2V5RXZlbnQoY29u c3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJvb2wgaXNDaGFyRXZlbnQpID0gMDsKSW5kZXg6 IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgJKHJldmlzaW9uIDE2NDY1NCkK KysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAkod29ya2luZyBjb3B5 KQpAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQVBJT2JqZWN0LmgiCiAjaW5jbHVkZSAi QVBJU2Vzc2lvbi5oIgorI2luY2x1ZGUgIkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmgiCiAjaW5j bHVkZSAiQXV0b0NvcnJlY3Rpb25DYWxsYmFjay5oIgogI2luY2x1ZGUgIkNvbm5lY3Rpb24uaCIK ICNpbmNsdWRlICJEcmFnQ29udHJvbGxlckFjdGlvbi5oIgpAQCAtMTE2Myw3ICsxMTY0LDcgQEAg cHJpdmF0ZToKICNpZiBQTEFURk9STShJT1MpCiAgICAgdm9pZCBkaWRHZXRUYXBIaWdobGlnaHRH ZW9tZXRyaWVzKHVpbnQ2NF90IHJlcXVlc3RJRCwgY29uc3QgV2ViQ29yZTo6Q29sb3ImIGNvbG9y LCBjb25zdCBWZWN0b3I8V2ViQ29yZTo6RmxvYXRRdWFkPiYgZ2VvbWV0cmllcywgY29uc3QgV2Vi Q29yZTo6SW50U2l6ZSYgdG9wTGVmdFJhZGl1cywgY29uc3QgV2ViQ29yZTo6SW50U2l6ZSYgdG9w UmlnaHRSYWRpdXMsIGNvbnN0IFdlYkNvcmU6OkludFNpemUmIGJvdHRvbUxlZnRSYWRpdXMsIGNv bnN0IFdlYkNvcmU6OkludFNpemUmIGJvdHRvbVJpZ2h0UmFkaXVzKTsKIAotICAgIHZvaWQgc3Rh cnRBc3Npc3RpbmdOb2RlKGNvbnN0IFdlYkNvcmU6OkludFJlY3QmLCBib29sIGhhc05leHRGb2N1 c2FibGUsIGJvb2wgaGFzUHJldmlvdXNGb2N1c2FibGUpOworICAgIHZvaWQgc3RhcnRBc3Npc3Rp bmdOb2RlKGNvbnN0IEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJik7CiAgICAgdm9pZCBzdG9wQXNz aXN0aW5nTm9kZSgpOwogICAgIHZvaWQgbm90aWZ5UmV2ZWFsZWRTZWxlY3Rpb24oKTsKICNlbmRp ZiAvLyBQTEFURk9STShJT1MpCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5Lm1lc3NhZ2VzLmluCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4JKHJldmlzaW9uIDE2NDY1NCkKKysrIFNvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW4JKHdvcmtpbmcgY29weSkK QEAgLTMwNyw3ICszMDcsNyBAQCBtZXNzYWdlcyAtPiBXZWJQYWdlUHJveHkgewogI2lmIFBMQVRG T1JNKElPUykKICAgICBEaWRHZXRUYXBIaWdobGlnaHRHZW9tZXRyaWVzKHVpbnQ2NF90IHJlcXVl c3RJRCwgV2ViQ29yZTo6Q29sb3IgY29sb3IsIFZlY3RvcjxXZWJDb3JlOjpGbG9hdFF1YWQ+IGdl b21ldHJpZXMsIFdlYkNvcmU6OkludFNpemUgdG9wTGVmdFJhZGl1cywgV2ViQ29yZTo6SW50U2l6 ZSB0b3BSaWdodFJhZGl1cywgV2ViQ29yZTo6SW50U2l6ZSBib3R0b21MZWZ0UmFkaXVzLCBXZWJD b3JlOjpJbnRTaXplIGJvdHRvbVJpZ2h0UmFkaXVzKQogCi0gICAgU3RhcnRBc3Npc3RpbmdOb2Rl KFdlYkNvcmU6OkludFJlY3Qgc2Nyb2xsUmVjdCwgYm9vbCBoYXNOZXh0Rm9jdXNhYmxlLCBib29s IGhhc1ByZXZpb3VzRm9jdXNhYmxlKQorICAgIFN0YXJ0QXNzaXN0aW5nTm9kZShXZWJLaXQ6OkFz c2lzdGVkTm9kZUluZm9ybWF0aW9uIGluZm9ybWF0aW9uKQogICAgIFN0b3BBc3Npc3RpbmdOb2Rl KCkKICAgICBOb3RpZnlSZXZlYWxlZFNlbGVjdGlvbigpCiAjZW5kaWYKSW5kZXg6IFNvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9pb3MvUGFnZUNsaWVudEltcGxJT1MuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1BhZ2VDbGllbnRJbXBsSU9TLmgJKHJldmlzaW9u IDE2NDY1NCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvUGFnZUNsaWVudEltcGxJ T1MuaAkod29ya2luZyBjb3B5KQpAQCAtMTA0LDcgKzEwNCw3IEBAIHByaXZhdGU6CiAKICAgICB2 aXJ0dWFsIHZvaWQgZGlkQ29tbWl0TGF5ZXJUcmVlKGNvbnN0IFJlbW90ZUxheWVyVHJlZVRyYW5z YWN0aW9uJikgb3ZlcnJpZGU7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnRBc3Npc3RpbmdOb2Rl KGNvbnN0IFdlYkNvcmU6OkludFJlY3QmLCBib29sIGhhc05leHRGb2N1c2FibGUsIGJvb2wgaGFz UHJldmlvdXNGb2N1c2FibGUpIG92ZXJyaWRlOworICAgIHZpcnR1YWwgdm9pZCBzdGFydEFzc2lz dGluZ05vZGUoY29uc3QgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mKSBvdmVycmlkZTsKICAgICB2 aXJ0dWFsIHZvaWQgc3RvcEFzc2lzdGluZ05vZGUoKSBvdmVycmlkZTsKICAgICB2aXJ0dWFsIHZv aWQgc2VsZWN0aW9uRGlkQ2hhbmdlKCkgb3ZlcnJpZGU7CiAgICAgdmlydHVhbCBib29sIGludGVy cHJldEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmLCBib29sIGlzQ2hhckV2 ZW50KSBvdmVycmlkZTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvUGFnZUNs aWVudEltcGxJT1MubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lv cy9QYWdlQ2xpZW50SW1wbElPUy5tbQkocmV2aXNpb24gMTY0NjU0KQorKysgU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL2lvcy9QYWdlQ2xpZW50SW1wbElPUy5tbQkod29ya2luZyBjb3B5KQpAQCAt MzQ3LDkgKzM0Nyw5IEBAIHZvaWQgUGFnZUNsaWVudEltcGw6OmRpZENvbW1pdExheWVyVHJlZSgK ICAgICBbbV9jb250ZW50VmlldyBfZGlkQ29tbWl0TGF5ZXJUcmVlOmxheWVyVHJlZVRyYW5zYWN0 aW9uXTsKIH0KIAotdm9pZCBQYWdlQ2xpZW50SW1wbDo6c3RhcnRBc3Npc3RpbmdOb2RlKGNvbnN0 IFdlYkNvcmU6OkludFJlY3QmLCBib29sLCBib29sKQordm9pZCBQYWdlQ2xpZW50SW1wbDo6c3Rh cnRBc3Npc3RpbmdOb2RlKGNvbnN0IEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJiBpbmZvcm1hdGlv bikKIHsKLSAgICBbbV9jb250ZW50VmlldyBfc3RhcnRBc3Npc3RpbmdOb2RlXTsKKyAgICBbbV9j b250ZW50VmlldyBfc3RhcnRBc3Npc3RpbmdOb2RlOmluZm9ybWF0aW9uXTsKIH0KIAogdm9pZCBQ YWdlQ2xpZW50SW1wbDo6c3RvcEFzc2lzdGluZ05vZGUoKQpJbmRleDogU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24uaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5oCShy ZXZpc2lvbiAxNjQ2NTQpCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLQ29udGVu dFZpZXdJbnRlcmFjdGlvbi5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2ICsyNSw3IEBACiAKICNp bXBvcnQgIldLQ29udGVudFZpZXcuaCIKIAorI2ltcG9ydCAiQXNzaXN0ZWROb2RlSW5mb3JtYXRp b24uaCIKICNpbXBvcnQgIkludGVyYWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uLmgiCiAjaW1w b3J0ICJXS0dlc3R1cmVUeXBlcy5oIgogI2ltcG9ydCA8VUlLaXQvVUlUZXh0SW5wdXRfUHJpdmF0 ZS5oPgpAQCAtNDYsNiArNDcsNyBAQCBjbGFzcyBJbnRTaXplOwogbmFtZXNwYWNlIFdlYktpdCB7 CiBjbGFzcyBOYXRpdmVXZWJUb3VjaEV2ZW50OwogY2xhc3MgV2ViUGFnZVByb3h5Oworc3RydWN0 IEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uOwogc3RydWN0IEludGVyYWN0aW9uSW5mb3JtYXRpb25B dFBvc2l0aW9uOwogfQogCkBAIC05Nyw2ICs5OSw3IEBAIHN0cnVjdCBXS0F1dG9Db3JyZWN0aW9u RGF0YSB7CiAKICAgICBXZWJLaXQ6OldLQXV0b0NvcnJlY3Rpb25EYXRhIF9hdXRvY29ycmVjdGlv bkRhdGE7CiAgICAgV2ViS2l0OjpJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbiBfcG9z aXRpb25JbmZvcm1hdGlvbjsKKyAgICBXZWJLaXQ6OkFzc2lzdGVkTm9kZUluZm9ybWF0aW9uIF9h c3Npc3RlZE5vZGVJbmZvcm1hdGlvbjsKIAogICAgIEJPT0wgX2lzRWRpdGFibGU7CiAgICAgQk9P TCBfc2hvd2luZ1RleHRTdHlsZU9wdGlvbnM7CkBAIC0xMTEsNiArMTE0LDcgQEAgc3RydWN0IFdL QXV0b0NvcnJlY3Rpb25EYXRhIHsKIEBwcm9wZXJ0eSAobm9uYXRvbWljLCByZWFkb25seSkgQk9P TCBpc0VkaXRhYmxlOwogQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5KSBjb25zdCBXZWJL aXQ6OkludGVyYWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uJiBwb3NpdGlvbkluZm9ybWF0aW9u OwogQHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5KSBjb25zdCBXZWJLaXQ6OldLQXV0b0Nv cnJlY3Rpb25EYXRhJiBhdXRvY29ycmVjdGlvbkRhdGE7CitAcHJvcGVydHkgKG5vbmF0b21pYywg cmVhZG9ubHkpIGNvbnN0IFdlYktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mIGFzc2lzdGVk Tm9kZUluZm9ybWF0aW9uOwogCiAtICh2b2lkKXNldHVwSW50ZXJhY3Rpb247CiAtICh2b2lkKWNs ZWFudXBJbnRlcmFjdGlvbjsKQEAgLTExOCw3ICsxMjIsNyBAQCBzdHJ1Y3QgV0tBdXRvQ29ycmVj dGlvbkRhdGEgewogLSAodm9pZClfd2ViVG91Y2hFdmVudDooY29uc3QgV2ViS2l0OjpOYXRpdmVX ZWJUb3VjaEV2ZW50Jil0b3VjaEV2ZW50IHByZXZlbnRzTmF0aXZlR2VzdHVyZXM6KEJPT0wpcHJl dmVudHNEZWZhdWx0OwogLSAodm9pZClfZGlkR2V0VGFwSGlnaGxpZ2h0Rm9yUmVxdWVzdDoodWlu dDY0X3QpcmVxdWVzdElEIGNvbG9yOihjb25zdCBXZWJDb3JlOjpDb2xvciYpY29sb3IgcXVhZHM6 KGNvbnN0IFZlY3RvcjxXZWJDb3JlOjpGbG9hdFF1YWQ+JiloaWdobGlnaHRlZFF1YWRzIHRvcExl ZnRSYWRpdXM6KGNvbnN0IFdlYkNvcmU6OkludFNpemUmKXRvcExlZnRSYWRpdXMgdG9wUmlnaHRS YWRpdXM6KGNvbnN0IFdlYkNvcmU6OkludFNpemUmKXRvcFJpZ2h0UmFkaXVzIGJvdHRvbUxlZnRS YWRpdXM6KGNvbnN0IFdlYkNvcmU6OkludFNpemUmKWJvdHRvbUxlZnRSYWRpdXMgYm90dG9tUmln aHRSYWRpdXM6KGNvbnN0IFdlYkNvcmU6OkludFNpemUmKWJvdHRvbVJpZ2h0UmFkaXVzOwogCi0t ICh2b2lkKV9zdGFydEFzc2lzdGluZ05vZGU7CistICh2b2lkKV9zdGFydEFzc2lzdGluZ05vZGU6 KGNvbnN0IFdlYktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mKWluZm9ybWF0aW9uOwogLSAo dm9pZClfc3RvcEFzc2lzdGluZ05vZGU7CiAtICh2b2lkKV9zZWxlY3Rpb25DaGFuZ2VkOwogLSAo Qk9PTClfaW50ZXJwcmV0S2V5RXZlbnQ6KFdlYklPU0V2ZW50ICopdGhlRXZlbnQgaXNDaGFyRXZl bnQ6KEJPT0wpaXNDaGFyRXZlbnQ7CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9z L1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvaW9zL1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5tbQkocmV2aXNpb24gMTY0 NjU0KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJh Y3Rpb24ubW0JKHdvcmtpbmcgY29weSkKQEAgLTM1Nyw2ICszNTcsMjMgQEAgLSAodm9pZClfZGlk U2Nyb2xsCiAgICAgW3NlbGYgX2NhbmNlbEludGVyYWN0aW9uXTsKIH0KIAorLSAoQk9PTClfcmVx dWlyZXNLZXlib2FyZFdoZW5GaXJzdFJlc3BvbmRlcgoreworICAgIC8vIEZJWE1FOiBXZSBzaG91 bGQgYWRkIHRoZSBsb2dpYyB0byBoYW5kbGUga2V5Ym9hcmQgdmlzaWJpbGl0eSBkdXJpbmcgZm9j dXMgcmVkaXJlY3RzLgorICAgIHN3aXRjaCAoX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmVsZW1l bnRUeXBlKSB7CisgICAgY2FzZSBXZWJLaXQ6OldLVHlwZVNlbGVjdDoKKyAgICAgICAgcmV0dXJu ICFVSUN1cnJlbnRVc2VySW50ZXJmYWNlSWRpb21Jc1BhZCgpOworICAgIGNhc2UgV2ViS2l0OjpX S1R5cGVEYXRlOgorICAgIGNhc2UgV2ViS2l0OjpXS1R5cGVEYXRlVGltZToKKyAgICBjYXNlIFdl YktpdDo6V0tUeXBlRGF0ZVRpbWVMb2NhbDoKKyAgICBjYXNlIFdlYktpdDo6V0tUeXBlVGltZToK KyAgICAgICAgcmV0dXJuICFVSUN1cnJlbnRVc2VySW50ZXJmYWNlSWRpb21Jc1BhZCgpOworICAg IGRlZmF1bHQ6CisgICAgICAgIHJldHVybiAhX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlzUmVh ZE9ubHk7CisgICAgfQorICAgIHJldHVybiBOTzsKK30KKwogLSAoQk9PTClfcmVxdWlyZXNLZXli b2FyZFJlc2V0T25SZWxvYWQKIHsKICAgICByZXR1cm4gWUVTOwpAQCAtMTIyMyw5ICsxMjQwLDgg QEAgLSAodm9pZClhY2Nlc3NvcnlDbGVhcgogCiAtICh2b2lkKV91cGRhdGVBY2Nlc3NvcnkKIHsK LSAgICAvLyBGSVhNRTogV2UgbmVlZCB0byBpbml0aWFsaXplIHdpdGggdmFsdWVzIGZyb20gdGhl IFdlYlByb2Nlc3MuCi0gICAgW19mb3JtQWNjZXNzb3J5VmlldyBzZXROZXh0RW5hYmxlZDpZRVNd OwotICAgIFtfZm9ybUFjY2Vzc29yeVZpZXcgc2V0UHJldmlvdXNFbmFibGVkOllFU107CisgICAg W19mb3JtQWNjZXNzb3J5VmlldyBzZXROZXh0RW5hYmxlZDpfYXNzaXN0ZWROb2RlSW5mb3JtYXRp b24uaGFzTmV4dE5vZGVdOworICAgIFtfZm9ybUFjY2Vzc29yeVZpZXcgc2V0UHJldmlvdXNFbmFi bGVkOl9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oYXNQcmV2aW91c05vZGVdOwogICAgIAogICAg IFtfZm9ybUFjY2Vzc29yeVZpZXcgc2V0Q2xlYXJWaXNpYmxlOk5PXTsKIApAQCAtMTQwMyw2ICsx NDE5LDI0IEBAIC0gKEJPT0wpaGFzVGV4dAogCiAvLyBlbmQgb2YgVUlUZXh0SW5wdXQgcHJvdG9j b2wgaW1wbGVtZW50YXRpb24KIAorc3RhdGljIFVJVGV4dEF1dG9jYXBpdGFsaXphdGlvblR5cGUg dG9VSVRleHRBdXRvY2FwaXRhbGl6ZShXZWJBdXRvY2FwaXRhbGl6ZVR5cGUgd2Via2l0VHlwZSkK K3sKKyAgICBzd2l0Y2ggKHdlYmtpdFR5cGUpIHsKKyAgICBjYXNlIFdlYkF1dG9jYXBpdGFsaXpl VHlwZURlZmF1bHQ6CisgICAgICAgIHJldHVybiBVSVRleHRBdXRvY2FwaXRhbGl6YXRpb25UeXBl U2VudGVuY2VzOworICAgIGNhc2UgV2ViQXV0b2NhcGl0YWxpemVUeXBlTm9uZToKKyAgICAgICAg cmV0dXJuIFVJVGV4dEF1dG9jYXBpdGFsaXphdGlvblR5cGVOb25lOworICAgIGNhc2UgV2ViQXV0 b2NhcGl0YWxpemVUeXBlV29yZHM6CisgICAgICAgIHJldHVybiBVSVRleHRBdXRvY2FwaXRhbGl6 YXRpb25UeXBlV29yZHM7CisgICAgY2FzZSBXZWJBdXRvY2FwaXRhbGl6ZVR5cGVTZW50ZW5jZXM6 CisgICAgICAgIHJldHVybiBVSVRleHRBdXRvY2FwaXRhbGl6YXRpb25UeXBlU2VudGVuY2VzOwor ICAgIGNhc2UgV2ViQXV0b2NhcGl0YWxpemVUeXBlQWxsQ2hhcmFjdGVyczoKKyAgICAgICAgcmV0 dXJuIFVJVGV4dEF1dG9jYXBpdGFsaXphdGlvblR5cGVBbGxDaGFyYWN0ZXJzOworICAgIH0KKwor ICAgIHJldHVybiBVSVRleHRBdXRvY2FwaXRhbGl6YXRpb25UeXBlU2VudGVuY2VzOworfQorCiAv LyBVSVRleHRJbnB1dFByaXZhdGUgcHJvdG9jb2wKIC8vIERpcmVjdCBhY2Nlc3MgdG8gdGhlIChw cml2YXRlKSBVSVRleHRJbnB1dFRyYWl0cyBvYmplY3QuCiAtIChVSVRleHRJbnB1dFRyYWl0cyAq KXRleHRJbnB1dFRyYWl0cwpAQCAtMTQxMCw2ICsxNDQ0LDM3IEBAIC0gKFVJVGV4dElucHV0VHJh aXRzICopdGV4dElucHV0VHJhaXRzCiAgICAgaWYgKCFfdHJhaXRzKQogICAgICAgICBfdHJhaXRz ID0gYWRvcHROUyhbW1VJVGV4dElucHV0VHJhaXRzIGFsbG9jXSBpbml0XSk7CiAKKyAgICBfdHJh aXRzLmdldCgpLnNlY3VyZVRleHRFbnRyeSA9IF9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5pc1Bh c3N3b3JkRmllbGQ7CisgICAgX3RyYWl0cy5nZXQoKS5zaG9ydGN1dENvbnZlcnNpb25UeXBlID0g X2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlzUGFzc3dvcmRGaWVsZCA/IFVJVGV4dFNob3J0Y3V0 Q29udmVyc2lvblR5cGVObyA6IFVJVGV4dFNob3J0Y3V0Q29udmVyc2lvblR5cGVEZWZhdWx0Owor ICAgIGlmICghX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmZvcm1BY3Rpb24uaXNFbXB0eSgpKQor ICAgICAgICBbX3RyYWl0cyBzZXRSZXR1cm5LZXlUeXBlOihfYXNzaXN0ZWROb2RlSW5mb3JtYXRp b24uZWxlbWVudFR5cGUgPT0gV2ViS2l0OjpXS1R5cGVTZWFyY2gpID8gVUlSZXR1cm5LZXlTZWFy Y2ggOiBVSVJldHVybktleUdvXTsKKyAgICBpZiAoX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlz UGFzc3dvcmRGaWVsZCB8fCBfYXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPT0g V0tUeXBlRW1haWwgfHwgX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmVsZW1lbnRUeXBlID09IFdL VHlwZVVSTCB8fCBfYXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uZm9ybUFjdGlvbi5jb250YWlucygi bG9naW4iKSkgeworICAgICAgICBbX3RyYWl0cyBzZXRBdXRvY2FwaXRhbGl6YXRpb25UeXBlOlVJ VGV4dEF1dG9jYXBpdGFsaXphdGlvblR5cGVOb25lXTsKKyAgICAgICAgW190cmFpdHMgc2V0QXV0 b2NvcnJlY3Rpb25UeXBlOlVJVGV4dEF1dG9jb3JyZWN0aW9uVHlwZU5vXTsKKyAgICB9IGVsc2Ug eworICAgICAgICAgICAgW190cmFpdHMgc2V0QXV0b2NhcGl0YWxpemF0aW9uVHlwZTp0b1VJVGV4 dEF1dG9jYXBpdGFsaXplKF9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5hdXRvY2FwaXRhbGl6ZVR5 cGUpXTsKKyAgICAgICAgICAgIFtfdHJhaXRzIHNldEF1dG9jb3JyZWN0aW9uVHlwZTpfYXNzaXN0 ZWROb2RlSW5mb3JtYXRpb24uaXNBdXRvY29ycmVjdCA/IFVJVGV4dEF1dG9jb3JyZWN0aW9uVHlw ZVllcyA6IFVJVGV4dEF1dG9jb3JyZWN0aW9uVHlwZU5vXTsKKyAgICB9CisgICAgc3dpdGNoIChf YXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uZWxlbWVudFR5cGUpIHsKKyAgICBjYXNlIFdlYktpdDo6 V0tUeXBlUGhvbmU6CisgICAgICAgICBbX3RyYWl0cyBzZXRLZXlib2FyZFR5cGU6VUlLZXlib2Fy ZFR5cGVQaG9uZVBhZF07CisgICAgICAgICBicmVhazsKKyAgICBjYXNlIFdlYktpdDo6V0tUeXBl VVJMOgorICAgICAgICAgW190cmFpdHMgc2V0S2V5Ym9hcmRUeXBlOlVJS2V5Ym9hcmRUeXBlVVJM XTsKKyAgICAgICAgIGJyZWFrOworICAgIGNhc2UgV2ViS2l0OjpXS1R5cGVFbWFpbDoKKyAgICAg ICAgIFtfdHJhaXRzIHNldEtleWJvYXJkVHlwZTpVSUtleWJvYXJkVHlwZUVtYWlsQWRkcmVzc107 CisgICAgICAgICAgYnJlYWs7CisgICAgY2FzZSBXZWJLaXQ6OldLVHlwZU51bWJlcjoKKyAgICAg ICAgIFtfdHJhaXRzIHNldEtleWJvYXJkVHlwZTpVSUtleWJvYXJkVHlwZU51bWJlcnNBbmRQdW5j dHVhdGlvbl07CisgICAgICAgICBicmVhazsKKyAgICBjYXNlIFdlYktpdDo6V0tUeXBlTnVtYmVy UGFkOgorICAgICAgICAgW190cmFpdHMgc2V0S2V5Ym9hcmRUeXBlOlVJS2V5Ym9hcmRUeXBlTnVt YmVyUGFkXTsKKyAgICAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICAgICBbX3RyYWl0 cyBzZXRLZXlib2FyZFR5cGU6VUlLZXlib2FyZFR5cGVEZWZhdWx0XTsKKyAgICB9CisKICAgICBy ZXR1cm4gX3RyYWl0cy5nZXQoKTsKIH0KIApAQCAtMTcwMCw5ICsxNzY1LDE2IEBAIC0gKHZvaWQp X3N0b3BBc3Npc3RpbmdLZXlib2FyZAogICAgIFtzZWxmIHVzZVNlbGVjdGlvbkFzc2lzdGFudFdp dGhNb2RlOlVJV2ViU2VsZWN0aW9uTW9kZVdlYl07CiB9CiAKLS0gKHZvaWQpX3N0YXJ0QXNzaXN0 aW5nTm9kZQorLSAoY29uc3QgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mKWFzc2lzdGVkTm9kZUlu Zm9ybWF0aW9uCit7CisgICAgcmV0dXJuIF9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbjsKK30KKwor LSAodm9pZClfc3RhcnRBc3Npc3RpbmdOb2RlOihjb25zdCBBc3Npc3RlZE5vZGVJbmZvcm1hdGlv biYpaW5mb3JtYXRpb24KIHsKICAgICBfaXNFZGl0YWJsZSA9IFlFUzsKKyAgICBfYXNzaXN0ZWRO b2RlSW5mb3JtYXRpb24gPSBpbmZvcm1hdGlvbjsKKyAgICBfdHJhaXRzID0gbmlsOwogICAgIGlm ICghW3NlbGYgaXNGaXJzdFJlc3BvbmRlcl0pCiAgICAgICAgIFtzZWxmIGJlY29tZUZpcnN0UmVz cG9uZGVyXTsKIApAQCAtMTcxNCw2ICsxNzg2LDcgQEAgLSAodm9pZClfc3RhcnRBc3Npc3RpbmdO b2RlCiAtICh2b2lkKV9zdG9wQXNzaXN0aW5nTm9kZQogewogICAgIF9pc0VkaXRhYmxlID0gTk87 CisgICAgX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmVsZW1lbnRUeXBlID0gV0tUeXBlTm9uZTsK IAogICAgIFtzZWxmIF9zdG9wQXNzaXN0aW5nS2V5Ym9hcmRdOwogICAgIFtzZWxmIHJlbG9hZElu cHV0Vmlld3NdOwpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XZWJQYWdlUHJv eHlJT1MubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XZWJQ YWdlUHJveHlJT1MubW0JKHJldmlzaW9uIDE2NDY1NCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9pb3MvV2ViUGFnZVByb3h5SU9TLm1tCSh3b3JraW5nIGNvcHkpCkBAIC00NzksOSArNDc5 LDkgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmRpZEdldFRhcEhpZ2hsaWdodEdlbwogICAgIG1fcGFn ZUNsaWVudC5kaWRHZXRUYXBIaWdobGlnaHRHZW9tZXRyaWVzKHJlcXVlc3RJRCwgY29sb3IsIGhp Z2hsaWdodGVkUXVhZHMsIHRvcExlZnRSYWRpdXMsIHRvcFJpZ2h0UmFkaXVzLCBib3R0b21MZWZ0 UmFkaXVzLCBib3R0b21SaWdodFJhZGl1cyk7CiB9CiAKLXZvaWQgV2ViUGFnZVByb3h5OjpzdGFy dEFzc2lzdGluZ05vZGUoY29uc3QgV2ViQ29yZTo6SW50UmVjdCYgc2Nyb2xsUmVjdCwgYm9vbCBo YXNOZXh0Rm9jdXNhYmxlLCBib29sIGhhc1ByZXZpb3VzRm9jdXNhYmxlKQordm9pZCBXZWJQYWdl UHJveHk6OnN0YXJ0QXNzaXN0aW5nTm9kZShjb25zdCBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbiYg aW5mb3JtYXRpb24pCiB7Ci0gICAgbV9wYWdlQ2xpZW50LnN0YXJ0QXNzaXN0aW5nTm9kZShzY3Jv bGxSZWN0LCBoYXNOZXh0Rm9jdXNhYmxlLCBoYXNQcmV2aW91c0ZvY3VzYWJsZSk7CisgICAgbV9w YWdlQ2xpZW50LnN0YXJ0QXNzaXN0aW5nTm9kZShpbmZvcm1hdGlvbik7CiB9CiAKIHZvaWQgV2Vi UGFnZVByb3h5OjpzdG9wQXNzaXN0aW5nTm9kZSgpCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9XZWJL aXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktp dDIvV2ViS2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAxNjQ2NTQpCisr KyBTb3VyY2UvV2ViS2l0Mi9XZWJLaXQyLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtp bmcgY29weSkKQEAgLTEzODUsNiArMTM4NSw4IEBACiAJCUM1OENERjJBMTg4NzU0OEIwMDg3MTUz NiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU4Q0RGMjgxODg3NTQ4QjAwODcxNTM2IC8q IEludGVyYWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uLmggKi87IH07CiAJCUM1OENERjJEMTg4 NzYwOUYwMDg3MTUzNiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbi5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNThDREYyQjE4ODc2 MDlGMDA4NzE1MzYgLyogSW50ZXJhY3Rpb25JbmZvcm1hdGlvbkF0UG9zaXRpb24uY3BwICovOyB9 OwogCQlDNThDREYyRTE4ODc2MDlGMDA4NzE1MzYgLyogSW50ZXJhY3Rpb25JbmZvcm1hdGlvbkF0 UG9zaXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEM1OENERjJDMTg4NzYwOUYwMDg3MTUzNiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3Np dGlvbi5oICovOyB9OworCQlDNTlDNEE1ODE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2Rl SW5mb3JtYXRpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQzU5QzRBNTYxOEI4MTE3NDAwN0JEQ0I2IC8qIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9u LmNwcCAqLzsgfTsKKwkJQzU5QzRBNTkxOEI4MTE3NDAwN0JEQ0I2IC8qIEFzc2lzdGVkTm9kZUlu Zm9ybWF0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBDNTlDNEE1NzE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaCAq LzsgfTsKIAkJQzVFMUFGRTgxNkIyMEI2NzAwNkNDMUYyIC8qIFdLV2ViQXJjaGl2ZS5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBCQzMyOURBNTE2QUNF NUE5MDAzMTZERTIgLyogV0tXZWJBcmNoaXZlLmNwcCAqLzsgfTsKIAkJQzVFMUFGRTkxNkIyMEI3 NTAwNkNDMUYyIC8qIFdLV2ViQXJjaGl2ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gQkMzMjlEQTYxNkFDRTVBOTAwMzE2REUyIC8qIFdLV2ViQXJjaGl2 ZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUM1 RTFBRkVBMTZCMjBCN0IwMDZDQzFGMiAvKiBXS1dlYkFyY2hpdmVSZXNvdXJjZS5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBCQzMyOURBOTE2QUNFNUJG MDAzMTZERTIgLyogV0tXZWJBcmNoaXZlUmVzb3VyY2UuY3BwICovOyB9OwpAQCAtMzE5Myw2ICsz MTk1LDggQEAKIAkJQzU4Q0RGMjgxODg3NTQ4QjAwODcxNTM2IC8qIEludGVyYWN0aW9uSW5mb3Jt YXRpb25BdFBvc2l0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEludGVy YWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUM1OENERjJCMTg4NzYwOUYwMDg3MTUzNiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQ b3NpdGlvbi5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBJbnRlcmFj dGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUM1OENERjJDMTg4NzYwOUYwMDg3MTUzNiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQ b3NpdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnRlcmFjdGlvbklu Zm9ybWF0aW9uQXRQb3NpdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDNTlD NEE1NjE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24u Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDNTlDNEE1NzE4QjgxMTc0MDA3QkRD QjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJQ0Q1QzY2OUUxMzRCOUQzNjAwNEZFMkE4IC8qIEluamVjdGVkQnVuZGxlUGFnZUZ1 bGxTY3JlZW5DbGllbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g SW5qZWN0ZWRCdW5kbGVQYWdlRnVsbFNjcmVlbkNsaWVudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUNENUM2NjlGMTM0QjlEMzcwMDRGRTJBOCAvKiBJbmplY3RlZEJ1bmRsZVBh Z2VGdWxsU2NyZWVuQ2xpZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElu amVjdGVkQnVuZGxlUGFnZUZ1bGxTY3JlZW5DbGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJQ0Q2N0QzMDgxNUMwN0JFMDAwODQzQURGIC8qIEluamVjdGVkQnVuZGxlUGFnZURp YWdub3N0aWNMb2dnaW5nQ2xpZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IEluamVjdGVkQnVuZGxlUGFnZURpYWdub3N0aWNMb2dnaW5nQ2xpZW50LmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTM4NzUsNiArMzg3OSw4IEBACiAJCQkJQkM5MEEx RDAxMjJERDU1RTAwQ0M4QzUwIC8qIEFQSVVSTFJlc3BvbnNlLmggKi8sCiAJCQkJQTdENzkyRDUx NzY3Q0I2RTAwODgxQ0JFIC8qIEFjdGl2aXR5QXNzZXJ0aW9uLmNwcCAqLywKIAkJCQlBN0Q3OTJE NDE3NjdDQjA5MDA4ODFDQkUgLyogQWN0aXZpdHlBc3NlcnRpb24uaCAqLywKKwkJCQlDNTlDNEE1 NjE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwICovLAorCQkJ CUM1OUM0QTU3MThCODExNzQwMDdCRENCNiAvKiBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oICov LAogCQkJCTUxNUU3NzI1MTgzREQ2RjYwMDA3MjAzRiAvKiBBc3luY1JlcXVlc3QuY3BwICovLAog CQkJCTUxNUU3NzI2MTgzREQ2RjYwMDA3MjAzRiAvKiBBc3luY1JlcXVlc3QuaCAqLywKIAkJCQk1 MUJBMjQ0MzE4NThFRTMwMDBFQTI4MTEgLyogQXN5bmNUYXNrLmggKi8sCkBAIC02NDUwLDYgKzY0 NTYsNyBAQAogCQkJCTFBRTQ5ODc4MTFGRjdGQUEwMDQ4QjQ2NCAvKiBKU05QT2JqZWN0LmggaW4g SGVhZGVycyAqLywKIAkJCQlCQ0UwOTM3ODE0RkIxMjhDMDAxMTM4RDkgLyogTGF5ZXJIb3N0aW5n Q29udGV4dC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMUE5MkRDMTExMkY4QkE0NjAwMTdBRjY1IC8q IExheWVyVHJlZUNvbnRleHQuaCBpbiBIZWFkZXJzICovLAorCQkJCUM1OUM0QTU5MThCODExNzQw MDdCRENCNiAvKiBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJ MUExODZFRUExMkVGNzYxODAwOEU1RjM3IC8qIExheWVyVHJlZUhvc3QuaCBpbiBIZWFkZXJzICov LAogCQkJCTFBMUQ4QkEyMTczMUEzNjMwMDE0MURBNCAvKiBMb2NhbFN0b3JhZ2VEYXRhYmFzZS5o IGluIEhlYWRlcnMgKi8sCiAJCQkJMUE4QzcyOEQxNzM4NDc3QzAwMEE2NTU0IC8qIExvY2FsU3Rv cmFnZURhdGFiYXNlVHJhY2tlci5oIGluIEhlYWRlcnMgKi8sCkBAIC04MTYzLDYgKzgxNzAsNyBA QAogCQkJCTBGQ0I0RTQ5MThCQkUwNDQwMDBGQ0ZDOSAvKiBXS0FjdGlvblNoZWV0Lm1tIGluIFNv dXJjZXMgKi8sCiAJCQkJNTE1MzU2OUMxMjkxQjFEMjAwMDc0OURDIC8qIFdlYlBhZ2VDb250ZXh0 TWVudUNsaWVudC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlDMDZDNjA5NTEyNEMxNDRCMDAwMTY4 MkYgLyogV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycy5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlD NTlDNEE1ODE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJQkM3QjYyMDcxMjlBMEE2NzAwRDE3NEE0IC8qIFdlYlBhZ2VHcm91 cC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCQzdCNjI1MzEyQTQzQzk2MDBEMTc0QTQgLyogV2Vi UGFnZUdyb3VwRGF0YS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCQzdCNjIxNjEyQTQyMTlBMDBE MTc0QTQgLyogV2ViUGFnZUdyb3VwUHJveHkuY3BwIGluIFNvdXJjZXMgKi8sCkluZGV4OiBTb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHJldmlzaW9uIDE2NDY1 NCkKKysrIFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHdvcmtp bmcgY29weSkKQEAgLTE2MCw2ICsxNjAsNyBAQCBjbGFzcyBXZWJQYWdlR3JvdXBQcm94eTsKIGNs YXNzIFdlYlBvcHVwTWVudTsKIGNsYXNzIFdlYlZpZGVvRnVsbHNjcmVlbk1hbmFnZXI7CiBjbGFz cyBXZWJXaGVlbEV2ZW50Oworc3RydWN0IEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uOwogc3RydWN0 IEF0dHJpYnV0ZWRTdHJpbmc7CiBzdHJ1Y3QgRWRpdG9yU3RhdGU7CiBzdHJ1Y3QgSW50ZXJhY3Rp b25JbmZvcm1hdGlvbkF0UG9zaXRpb247CkBAIC03NDksNiArNzUwLDcgQEAgcHJpdmF0ZToKICAg ICBQYXNzUmVmUHRyPFdlYkNvcmU6OlJhbmdlPiBjaGFuZ2VCbG9ja1NlbGVjdGlvbihjb25zdCBX ZWJDb3JlOjpJbnRQb2ludCYsIFdLSGFuZGxlUG9zaXRpb24sIGZsb2F0JiBncm93VGhyZXNob2xk LCBmbG9hdCYgc2hyaW5rVGhyZXNob2xkLCBXS1NlbGVjdGlvbkZsYWdzJik7CiAgICAgUGFzc1Jl ZlB0cjxXZWJDb3JlOjpSYW5nZT4gZXhwYW5kZWRSYW5nZUZyb21IYW5kbGUoV2ViQ29yZTo6UmFu Z2UqLCBXS0hhbmRsZVBvc2l0aW9uKTsKICAgICBQYXNzUmVmUHRyPFdlYkNvcmU6OlJhbmdlPiBj b250cmFjdGVkUmFuZ2VGcm9tSGFuZGxlKFdlYkNvcmU6OlJhbmdlKiBjdXJyZW50UmFuZ2UsIFdL SGFuZGxlUG9zaXRpb24sIFdLU2VsZWN0aW9uRmxhZ3MmKTsKKyAgICB2b2lkIGdldEFzc2lzdGVk Tm9kZUluZm9ybWF0aW9uKEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJiBpbmZvcm1hdGlvbik7CiAK ICAgICBSZWZQdHI8V2ViQ29yZTo6UmFuZ2U+IG1fY3VycmVudEJsb2NrU2VsZWN0aW9uOwogI2Vu ZGlmCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJ T1MubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL2lv cy9XZWJQYWdlSU9TLm1tCShyZXZpc2lvbiAxNjQ2NTQpCisrKyBTb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0JKHdvcmtpbmcgY29weSkKQEAgLTI2LDYg KzI2LDcgQEAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiV2ViUGFnZS5oIgogCisjaW1w b3J0ICJBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oIgogI2ltcG9ydCAiRWRpdG9yU3RhdGUuaCIK ICNpbXBvcnQgIkludGVyYWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uLmgiCiAjaW1wb3J0ICJX ZWJDaHJvbWVDbGllbnQuaCIKQEAgLTQ0LDcgKzQ1LDEyIEBACiAjaW1wb3J0IDxXZWJDb3JlL0Zy YW1lVmlldy5oPgogI2ltcG9ydCA8V2ViQ29yZS9IaXRUZXN0UmVzdWx0Lmg+CiAjaW1wb3J0IDxX ZWJDb3JlL0hUTUxFbGVtZW50VHlwZUhlbHBlcnMuaD4KKyNpbXBvcnQgPFdlYkNvcmUvSFRNTEZv cm1FbGVtZW50Lmg+CisjaW1wb3J0IDxXZWJDb3JlL0hUTUxJbnB1dEVsZW1lbnQuaD4KKyNpbXBv cnQgPFdlYkNvcmUvSFRNTE9wdGlvbkVsZW1lbnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSFRNTFBh cnNlcklkaW9tcy5oPgorI2ltcG9ydCA8V2ViQ29yZS9IVE1MU2VsZWN0RWxlbWVudC5oPgorI2lt cG9ydCA8V2ViQ29yZS9IVE1MVGV4dEFyZWFFbGVtZW50Lmg+CiAjaW1wb3J0IDxXZWJDb3JlL01h aW5GcmFtZS5oPgogI2ltcG9ydCA8V2ViQ29yZS9Ob2RlLmg+CiAjaW1wb3J0IDxXZWJDb3JlL05v dEltcGxlbWVudGVkLmg+CkBAIC0xNDc1LDExICsxNDgxLDExNCBAQCB2b2lkIFdlYlBhZ2U6OnBl cmZvcm1BY3Rpb25PbkVsZW1lbnQodWluCiAgICAgfQogfQogCitzdGF0aWMgaW5saW5lIGJvb2wg aXNBc3Npc3RhYmxlTm9kZShOb2RlKiBub2RlKQoreworICAgIGlmIChpc0hUTUxTZWxlY3RFbGVt ZW50KG5vZGUpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBpZiAoaXNIVE1MVGV4dEFyZWFF bGVtZW50KG5vZGUpKQorICAgICAgICByZXR1cm4gIXRvSFRNTFRleHRBcmVhRWxlbWVudChub2Rl KS0+aXNSZWFkT25seU5vZGUoKTsKKyAgICBpZiAoaXNIVE1MSW5wdXRFbGVtZW50KG5vZGUpKSB7 CisgICAgICAgIEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQgPSB0b0hUTUxJbnB1dEVsZW1lbnQo bm9kZSk7CisgICAgICAgIHJldHVybiAhZWxlbWVudC0+aXNSZWFkT25seU5vZGUoKSAmJiAoZWxl bWVudC0+aXNUZXh0RmllbGQoKSB8fCBlbGVtZW50LT5pc0RhdGVGaWVsZCgpIHx8IGVsZW1lbnQt PmlzRGF0ZVRpbWVMb2NhbEZpZWxkKCkgfHwgZWxlbWVudC0+aXNNb250aEZpZWxkKCkgfHwgZWxl bWVudC0+aXNUaW1lRmllbGQoKSk7CisgICAgfQorCisgICAgcmV0dXJuIG5vZGUtPmlzQ29udGVu dEVkaXRhYmxlKCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBoYXNGb2N1c2FibGVOb2RlKE5v ZGUqIHN0YXJ0Tm9kZSwgUGFnZSogcGFnZSwgYm9vbCBpc0ZvcndhcmQpCit7CisgICAgUmVmUHRy PEtleWJvYXJkRXZlbnQ+IGtleSA9IEtleWJvYXJkRXZlbnQ6OmNyZWF0ZSgpOworICAgIE5vZGUq IG5leHROb2RlID0gaXNGb3J3YXJkID8gcGFnZS0+Zm9jdXNDb250cm9sbGVyKCkubmV4dEZvY3Vz YWJsZUVsZW1lbnQoRm9jdXNOYXZpZ2F0aW9uU2NvcGU6OmZvY3VzTmF2aWdhdGlvblNjb3BlT2Yo JnN0YXJ0Tm9kZS0+ZG9jdW1lbnQoKSksIHN0YXJ0Tm9kZSwga2V5LmdldCgpKQorICAgICAgICA6 IHBhZ2UtPmZvY3VzQ29udHJvbGxlcigpLnByZXZpb3VzRm9jdXNhYmxlRWxlbWVudChGb2N1c05h dmlnYXRpb25TY29wZTo6Zm9jdXNOYXZpZ2F0aW9uU2NvcGVPZigmc3RhcnROb2RlLT5kb2N1bWVu dCgpKSwgc3RhcnROb2RlLCBrZXkuZ2V0KCkpOworICAgIHdoaWxlIChuZXh0Tm9kZSAmJiAhaXNB c3Npc3RhYmxlTm9kZShzdGFydE5vZGUpKQorICAgICAgICBuZXh0Tm9kZSA9IGlzRm9yd2FyZCA/ IHBhZ2UtPmZvY3VzQ29udHJvbGxlcigpLm5leHRGb2N1c2FibGVFbGVtZW50KEZvY3VzTmF2aWdh dGlvblNjb3BlOjpmb2N1c05hdmlnYXRpb25TY29wZU9mKCZzdGFydE5vZGUtPmRvY3VtZW50KCkp LCBuZXh0Tm9kZSwga2V5LmdldCgpKQorICAgICAgICA6IHBhZ2UtPmZvY3VzQ29udHJvbGxlcigp LnByZXZpb3VzRm9jdXNhYmxlRWxlbWVudChGb2N1c05hdmlnYXRpb25TY29wZTo6Zm9jdXNOYXZp Z2F0aW9uU2NvcGVPZigmc3RhcnROb2RlLT5kb2N1bWVudCgpKSwgbmV4dE5vZGUsIGtleS5nZXQo KSk7CisgICAgcmV0dXJuIG5leHROb2RlOworfQorCit2b2lkIFdlYlBhZ2U6OmdldEFzc2lzdGVk Tm9kZUluZm9ybWF0aW9uKEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJiBpbmZvcm1hdGlvbikKK3sK KyAgICBpbmZvcm1hdGlvbi5lbGVtZW50UmVjdCA9IG1fYXNzaXN0ZWROb2RlLT5yZW5kZXJlcigp LT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpOworICAgIFBhZ2UqIHBhZ2UgPSBtX2Fzc2lzdGVk Tm9kZS0+ZG9jdW1lbnQoKS5wYWdlKCk7CisgICAgaWYgKCFwYWdlKSB7CisgICAgICAgIGluZm9y bWF0aW9uLmhhc05leHROb2RlID0gZmFsc2U7CisgICAgICAgIGluZm9ybWF0aW9uLmhhc1ByZXZp b3VzTm9kZSA9IGZhbHNlOworICAgIH0gZWxzZSB7CisgICAgICAgIGluZm9ybWF0aW9uLmhhc05l eHROb2RlID0gaGFzRm9jdXNhYmxlTm9kZShtX2Fzc2lzdGVkTm9kZS5nZXQoKSwgcGFnZSwgdHJ1 ZSk7CisgICAgICAgIGluZm9ybWF0aW9uLmhhc1ByZXZpb3VzTm9kZSA9IGhhc0ZvY3VzYWJsZU5v ZGUobV9hc3Npc3RlZE5vZGUuZ2V0KCksIHBhZ2UsIGZhbHNlKTsKKyAgICB9CisKKyAgICBpZiAo aXNIVE1MU2VsZWN0RWxlbWVudChtX2Fzc2lzdGVkTm9kZS5nZXQoKSkpIHsKKyAgICAgICAgSFRN TFNlbGVjdEVsZW1lbnQqIGVsZW1lbnQgPSB0b0hUTUxTZWxlY3RFbGVtZW50KG1fYXNzaXN0ZWRO b2RlLmdldCgpKTsKKyAgICAgICAgaW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVTZWxl Y3Q7CisgICAgICAgIHNpemVfdCBjb3VudCA9IGVsZW1lbnQtPmxpc3RJdGVtcygpLnNpemUoKTsK KyAgICAgICAgLy8gRklYTUU6IFdlIG5lZWQgdG8gaGFuZGxlIGdyb3VwIGVsZW1lbnRzIGFzIHdl bGwKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CisgICAgICAg ICAgICBIVE1MT3B0aW9uRWxlbWVudCogaXRlbSA9IHRvSFRNTE9wdGlvbkVsZW1lbnQoZWxlbWVu dC0+bGlzdEl0ZW1zKClbaV0pOworICAgICAgICAgICAgaW5mb3JtYXRpb24uc2VsZWN0aW9uT3B0 aW9ucy5hcHBlbmQoaXRlbS0+dGV4dCgpKTsKKyAgICAgICAgfQorICAgICAgICBpbmZvcm1hdGlv bi5zZWxlY3RlZEluZGV4ID0gZWxlbWVudC0+c2VsZWN0ZWRJbmRleCgpOworICAgICAgICBpbmZv cm1hdGlvbi5pc011bHRpU2VsZWN0ID0gZWxlbWVudC0+bXVsdGlwbGUoKTsKKyAgICB9IGVsc2Ug aWYgKGlzSFRNTFRleHRBcmVhRWxlbWVudChtX2Fzc2lzdGVkTm9kZS5nZXQoKSkpIHsKKyAgICAg ICAgSFRNTFRleHRBcmVhRWxlbWVudCogZWxlbWVudCA9IHRvSFRNTFRleHRBcmVhRWxlbWVudCht X2Fzc2lzdGVkTm9kZS5nZXQoKSk7CisgICAgICAgIGluZm9ybWF0aW9uLmF1dG9jYXBpdGFsaXpl VHlwZSA9IHN0YXRpY19jYXN0PFdlYkF1dG9jYXBpdGFsaXplVHlwZT4oZWxlbWVudC0+YXV0b2Nh cGl0YWxpemVUeXBlKCkpOworICAgICAgICBpbmZvcm1hdGlvbi5pc0F1dG9jb3JyZWN0ID0gZWxl bWVudC0+YXV0b2NvcnJlY3QoKTsKKyAgICAgICAgaW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBX S1R5cGVUZXh0QXJlYTsKKyAgICAgICAgaW5mb3JtYXRpb24uaXNSZWFkT25seSA9IGVsZW1lbnQt PmlzUmVhZE9ubHkoKTsKKyAgICAgICAgaW5mb3JtYXRpb24udmFsdWUgPSBlbGVtZW50LT52YWx1 ZSgpOworICAgIH0gZWxzZSBpZiAoaXNIVE1MSW5wdXRFbGVtZW50KG1fYXNzaXN0ZWROb2RlLmdl dCgpKSkgeworICAgICAgICBIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50ID0gdG9IVE1MSW5wdXRF bGVtZW50KG1fYXNzaXN0ZWROb2RlLmdldCgpKTsKKyAgICAgICAgSFRNTEZvcm1FbGVtZW50KiBm b3JtID0gZWxlbWVudC0+Zm9ybSgpOworICAgICAgICBpZiAoZm9ybSkKKyAgICAgICAgICAgIGlu Zm9ybWF0aW9uLmZvcm1BY3Rpb24gPSBmb3JtLT5nZXRVUkxBdHRyaWJ1dGUoV2ViQ29yZTo6SFRN TE5hbWVzOjphY3Rpb25BdHRyKTsKKyAgICAgICAgaW5mb3JtYXRpb24uYXV0b2NhcGl0YWxpemVU eXBlID0gc3RhdGljX2Nhc3Q8V2ViQXV0b2NhcGl0YWxpemVUeXBlPihlbGVtZW50LT5hdXRvY2Fw aXRhbGl6ZVR5cGUoKSk7CisgICAgICAgIGluZm9ybWF0aW9uLmlzQXV0b2NvcnJlY3QgPSBlbGVt ZW50LT5hdXRvY29ycmVjdCgpOworICAgICAgICBpbmZvcm1hdGlvbi5pc1Bhc3N3b3JkRmllbGQg PSBlbGVtZW50LT5pc1Bhc3N3b3JkRmllbGQoKTsKKyAgICAgICAgaWYgKGVsZW1lbnQtPmlzU2Vh cmNoRmllbGQoKSkKKyAgICAgICAgICAgIGluZm9ybWF0aW9uLmVsZW1lbnRUeXBlID0gV0tUeXBl U2VhcmNoOworICAgICAgICBlbHNlIGlmIChlbGVtZW50LT5pc0VtYWlsRmllbGQoKSkKKyAgICAg ICAgICAgIGluZm9ybWF0aW9uLmVsZW1lbnRUeXBlID0gV0tUeXBlRW1haWw7CisgICAgICAgIGVs c2UgaWYgKGVsZW1lbnQtPmlzVGVsZXBob25lRmllbGQoKSkKKyAgICAgICAgICAgIGluZm9ybWF0 aW9uLmVsZW1lbnRUeXBlID0gV0tUeXBlUGhvbmU7CisgICAgICAgIGVsc2UgaWYgKGVsZW1lbnQt PmlzTnVtYmVyRmllbGQoKSkKKyAgICAgICAgICAgIGluZm9ybWF0aW9uLmVsZW1lbnRUeXBlID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKCJwYXR0ZXJuIikgPT0gIlxcZCoiIHx8IGVsZW1lbnQtPmdl dEF0dHJpYnV0ZSgicGF0dGVybiIpID09ICJbMC05XSoiID8gV0tUeXBlTnVtYmVyUGFkIDogV0tU eXBlTnVtYmVyOworICAgICAgICBlbHNlIGlmIChlbGVtZW50LT5pc0RhdGVUaW1lTG9jYWxGaWVs ZCgpKQorICAgICAgICAgICAgaW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVEYXRlVGlt ZUxvY2FsOworICAgICAgICBlbHNlIGlmIChlbGVtZW50LT5pc0RhdGVGaWVsZCgpKQorICAgICAg ICAgICAgaW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVEYXRlOworICAgICAgICBlbHNl IGlmIChlbGVtZW50LT5pc0RhdGVUaW1lRmllbGQoKSkKKyAgICAgICAgICAgIGluZm9ybWF0aW9u LmVsZW1lbnRUeXBlID0gV0tUeXBlRGF0ZVRpbWU7CisgICAgICAgIGVsc2UgaWYgKGVsZW1lbnQt PmlzVGltZUZpZWxkKCkpCisgICAgICAgICAgICBpbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9IFdL VHlwZVRpbWU7CisgICAgICAgIGVsc2UgaWYgKGVsZW1lbnQtPmlzV2Vla0ZpZWxkKCkpCisgICAg ICAgICAgICBpbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9IFdLVHlwZVdlZWs7CisgICAgICAgIGVs c2UgaWYgKGVsZW1lbnQtPmlzTW9udGhGaWVsZCgpKQorICAgICAgICAgICAgaW5mb3JtYXRpb24u ZWxlbWVudFR5cGUgPSBXS1R5cGVNb250aDsKKyAgICAgICAgZWxzZSBpZiAoZWxlbWVudC0+aXNV UkxGaWVsZCgpKQorICAgICAgICAgICAgaW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVV Ukw7CisgICAgICAgIGVsc2UgaWYgKGVsZW1lbnQtPmlzVGV4dCgpKQorICAgICAgICAgICAgaW5m b3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVUZXh0OworCisgICAgICAgIGluZm9ybWF0aW9u LmlzUmVhZE9ubHkgPSBlbGVtZW50LT5pc1JlYWRPbmx5KCk7CisgICAgICAgIGluZm9ybWF0aW9u LnZhbHVlID0gZWxlbWVudC0+dmFsdWUoKTsKKyAgICAgICAgaW5mb3JtYXRpb24udmFsdWVBc051 bWJlciA9IGVsZW1lbnQtPnZhbHVlQXNOdW1iZXIoKTsKKyAgICAgICAgaW5mb3JtYXRpb24udGl0 bGUgPSBlbGVtZW50LT50aXRsZSgpOworICAgIH0gZWxzZSBpZiAobV9hc3Npc3RlZE5vZGUtPmhh c0VkaXRhYmxlU3R5bGUoKSkgeworICAgICAgICBpbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9IFdL VHlwZUNvbnRlbnRFZGl0YWJsZTsKKyAgICAgICAgaW5mb3JtYXRpb24uaXNBdXRvY29ycmVjdCA9 IHRydWU7ICAgLy8gRklYTUU6IFNob3VsZCB3ZSBsb29rIGF0IHRoZSBhdHRyaWJ1dGU/CisgICAg ICAgIGluZm9ybWF0aW9uLmF1dG9jYXBpdGFsaXplVHlwZSA9IFdlYkF1dG9jYXBpdGFsaXplVHlw ZVNlbnRlbmNlczsgLy8gRklYTUU6IFNob3VsZCB3ZSBsb29rIGF0IHRoZSBhdHRyaWJ1dGU/Cisg ICAgICAgIGluZm9ybWF0aW9uLmlzUmVhZE9ubHkgPSBmYWxzZTsKKyAgICB9Cit9CisKIHZvaWQg V2ViUGFnZTo6ZWxlbWVudERpZEZvY3VzKFdlYkNvcmU6Ok5vZGUqIG5vZGUpCiB7CiAgICAgbV9h c3Npc3RlZE5vZGUgPSBub2RlOwotICAgIGlmIChub2RlLT5oYXNUYWdOYW1lKFdlYkNvcmU6OkhU TUxOYW1lczo6aW5wdXRUYWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUoV2ViQ29yZTo6SFRNTE5hbWVz Ojp0ZXh0YXJlYVRhZykgfHwgbm9kZS0+aGFzRWRpdGFibGVTdHlsZSgpKQotICAgICAgICBzZW5k KE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlN0YXJ0QXNzaXN0aW5nTm9kZShXZWJDb3JlOjpJbnRS ZWN0KCksIHRydWUsIHRydWUpKTsgICAgCisgICAgaWYgKG5vZGUtPmhhc1RhZ05hbWUoV2ViQ29y ZTo6SFRNTE5hbWVzOjppbnB1dFRhZykgfHwgbm9kZS0+aGFzVGFnTmFtZShXZWJDb3JlOjpIVE1M TmFtZXM6OnRleHRhcmVhVGFnKSB8fCBub2RlLT5oYXNFZGl0YWJsZVN0eWxlKCkpIHsKKyAgICAg ICAgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24gaW5mb3JtYXRpb247CisgICAgICAgIGdldEFzc2lz dGVkTm9kZUluZm9ybWF0aW9uKGluZm9ybWF0aW9uKTsKKyAgICAgICAgc2VuZChNZXNzYWdlczo6 V2ViUGFnZVByb3h5OjpTdGFydEFzc2lzdGluZ05vZGUoaW5mb3JtYXRpb24pKTsKKyAgICB9CiB9 CiAKIHZvaWQgV2ViUGFnZTo6ZWxlbWVudERpZEJsdXIoV2ViQ29yZTo6Tm9kZSogbm9kZSkK 225311 2014-02-26 15:35:03 -0800 2014-02-26 16:14:01 -0800 Patch2 datitimecontrols.txt text/plain 49515 enrica SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE2NDc1NCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDE0LTAyLTI2ICBFbnJpY2Eg Q2FzdWNjaSAgPGVucmljYUBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXZWJLaXQyXSBGb3Jt IGNvbnRyb2xzIGhhbmRsaW5nOiBpbXBsZW1lbnQgZGF0ZSBhbmQgdGltZSBjb250cm9scy4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyOTM0NAorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGluZyBvbmUg bG9jYWxpemFibGUgc3RyaW5nLgorCisgICAgICAgICogRW5nbGlzaC5scHJvai9Mb2NhbGl6YWJs ZS5zdHJpbmdzOgorCiAyMDE0LTAyLTI2ICBCcmlhbiBCdXJnICA8YmJ1cmdAYXBwbGUuY29tPgog CiAgICAgICAgIFVucmV2aWV3ZWQgYnVpbGQgZml4IGZvciAhRU5BQkxFKENPTlRFWFRfTUVOVVMp LgpJbmRleDogU291cmNlL1dlYkNvcmUvRW5nbGlzaC5scHJvai9Mb2NhbGl6YWJsZS5zdHJpbmdz Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL0VuZ2xpc2gubHByb2ovTG9jYWxpemFibGUu c3RyaW5ncwkocmV2aXNpb24gMTY0NzUzKQorKysgU291cmNlL1dlYkNvcmUvRW5nbGlzaC5scHJv ai9Mb2NhbGl6YWJsZS5zdHJpbmdzCSh3b3JraW5nIGNvcHkpCkBAIC0xMjcsNiArMTI3LDkgQEAK IC8qIFRpdGxlIGZvciBmaWxlIGJ1dHRvbiB1c2VkIGluIEhUTUwgZm9ybXMgZm9yIG1lZGlhIGZp bGVzICovCiAiQ2hvb3NlIE1lZGlhIChTaW5nbGUpIiA9ICJDaG9vc2UgTWVkaWEgKFNpbmdsZSki OwogCisvKiBDbGVhciBidXR0b24gaW4gZGF0ZSBpbnB1dCBwb3BvdmVyICovCisiQ2xlYXIgQnV0 dG9uIERhdGUgUG9wb3ZlciIgPSAiQ2xlYXIiOworCiAvKiBtZW51IGl0ZW0gaW4gUmVjZW50IFNl YXJjaGVzIG1lbnUgdGhhdCBlbXB0aWVzIG1lbnUncyBjb250ZW50cyAqLwogIkNsZWFyIFJlY2Vu dCBTZWFyY2hlcyIgPSAiQ2xlYXIgUmVjZW50IFNlYXJjaGVzIjsKIApJbmRleDogU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwko cmV2aXNpb24gMTY0NzU0KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsODIgQEAKKzIwMTQtMDItMjYgIEVucmljYSBDYXN1Y2NpICA8ZW5yaWNh QGFwcGxlLmNvbT4KKworICAgICAgICBbaU9TIFdlYktpdDJdIEZvcm0gY29udHJvbHMgaGFuZGxp bmc6IGltcGxlbWVudCBkYXRlIGFuZCB0aW1lIGNvbnRyb2xzLgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI5MzQ0CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBhbm90aGVyIHN0ZXAgaW4gdGhl IGltcGxlbWVudGF0aW9uIG9mIGZvcm0gY29udHJvbHMgb24gaU9TCisgICAgICAgIGZvciBXZWJL aXQyLiBUaGlzIGFkZHMgc3VwcG9ydCBmb3IgZGF0ZSBhbmQgdGltZSBpbnB1dCBlbGVtZW50cyBz dXBwb3J0aW5nCisgICAgICAgIHRoZSBkaWZmZXJlbnQgbG9vayBhbmQgZmVlbCBmb3IgaVBob25l IGFuZCBpUGFkLgorICAgICAgICBXS0RhdGVUaW1lUGlja2VyIGltcGxlbWVudHMgaVBob25lIFVJ IGFuZAorICAgICAgICBXS0RhdGVUaW1lUG9wb3ZlciBpbXBsZW1lbnRzIGlQYWQgVUkuCisgICAg ICAgIFdLRm9ybVJvdGF0aW5nQWNjZXNzb3J5UG9wb3ZlciBhbmQgV0tSb3RhdGluZ1BvcG92ZXIg YXJlCisgICAgICAgIGNsYXNzZXMgdGhhdCBpbXBsZW1lbnQgdGhlIHBvcG92ZXIgb2JqZWN0IGhh bmRsaW5nIHRoZSByb3RhdGlvbgorICAgICAgICBhbmQgdGhleSB3aWxsIGJlIHVzZWQgYXMgYmFz ZSBjbGFzcyBmb3IgdGhlIHNlbGVjdCBjb250cm9scyBhcyB3ZWxsLgorCisgICAgICAgICogVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvV0tDb250ZW50 Vmlld0ludGVyYWN0aW9uLmg6CisgICAgICAgICogVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3 SW50ZXJhY3Rpb24ubW06CisgICAgICAgICgtW1dLQ29udGVudFZpZXcgX2Rpc3BsYXlGb3JtTm9k ZUlucHV0Vmlld10pOgorICAgICAgICAoLVtXS0NvbnRlbnRWaWV3IGlucHV0Vmlld10pOgorICAg ICAgICAoLVtXS0NvbnRlbnRWaWV3IF9zdGFydEFzc2lzdGluZ05vZGU6XSk6CisgICAgICAgICgt W1dLQ29udGVudFZpZXcgX3N0b3BBc3Npc3RpbmdOb2RlXSk6CisgICAgICAgICogVUlQcm9jZXNz L2lvcy9XS0Zvcm1JbnB1dENvbnRyb2wuaDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL2lv cy9XS0Zvcm1JbnB1dENvbnRyb2wubW06IEFkZGVkLgorICAgICAgICAoLVtXS0RhdGVUaW1lUGlj a2VyIGRhdGVQaWNrZXJdKToKKyAgICAgICAgKC1bV0tEYXRlVGltZVBpY2tlciBpbml0V2l0aFZp ZXc6ZGF0ZVBpY2tlck1vZGU6XSk6CisgICAgICAgICgtW1dLRGF0ZVRpbWVQaWNrZXIgZGVhbGxv Y10pOgorICAgICAgICAoLVtXS0RhdGVUaW1lUGlja2VyIGNvbnRyb2xWaWV3XSk6CisgICAgICAg ICgtW1dLRGF0ZVRpbWVQaWNrZXIgX3RpbWVab25lT2Zmc2V0RnJvbUdNVDpdKToKKyAgICAgICAg KC1bV0tEYXRlVGltZVBpY2tlciBfc2FuaXRpemVJbnB1dFZhbHVlRm9yRm9ybWF0dGVyOl0pOgor ICAgICAgICAoLVtXS0RhdGVUaW1lUGlja2VyIF9kYXRlQ2hhbmdlZFNldEFzTnVtYmVyXSk6Cisg ICAgICAgICgtW1dLRGF0ZVRpbWVQaWNrZXIgX2RhdGVDaGFuZ2VkU2V0QXNTdHJpbmddKToKKyAg ICAgICAgKC1bV0tEYXRlVGltZVBpY2tlciBfZGF0ZUNoYW5nZWRdKToKKyAgICAgICAgKC1bV0tE YXRlVGltZVBpY2tlciBfZGF0ZUNoYW5nZUhhbmRsZXI6XSk6CisgICAgICAgICgtW1dLRGF0ZVRp bWVQaWNrZXIgY29udHJvbEJlZ2luRWRpdGluZ10pOgorICAgICAgICAoLVtXS0RhdGVUaW1lUGlj a2VyIGNvbnRyb2xFbmRFZGl0aW5nXSk6CisgICAgICAgICgtW1dLRm9ybUlucHV0Q29udHJvbCBp bml0V2l0aFZpZXc6XSk6CisgICAgICAgICgrW1dLRm9ybUlucHV0Q29udHJvbCBjcmVhdGVQZXJp cGhlcmFsV2l0aFZpZXc6XSk6CisgICAgICAgICgtW1dLRm9ybUlucHV0Q29udHJvbCBiZWdpbkVk aXRpbmddKToKKyAgICAgICAgKC1bV0tGb3JtSW5wdXRDb250cm9sIGVuZEVkaXRpbmddKToKKyAg ICAgICAgKC1bV0tGb3JtSW5wdXRDb250cm9sIGFzc2lzdGFudFZpZXddKToKKyAgICAgICAgKC1b V0tEYXRlVGltZVBvcG92ZXJWaWV3Q29udHJvbGxlciBpbml0V2l0aFZpZXc6ZGF0ZVBpY2tlck1v ZGU6XSk6CisgICAgICAgICgtW1dLRGF0ZVRpbWVQb3BvdmVyVmlld0NvbnRyb2xsZXIgaW5uZXJD b250cm9sXSk6CisgICAgICAgICgtW1dLRGF0ZVRpbWVQb3BvdmVyVmlld0NvbnRyb2xsZXIgbG9h ZFZpZXddKToKKyAgICAgICAgKC1bV0tEYXRlVGltZVBvcG92ZXIgY2xlYXI6XSk6CisgICAgICAg ICgtW1dLRGF0ZVRpbWVQb3BvdmVyIGluaXRXaXRoVmlldzpkYXRlUGlja2VyTW9kZTpdKToKKyAg ICAgICAgKC1bV0tEYXRlVGltZVBvcG92ZXIgdmlld0NvbnRyb2xsZXJdKToKKyAgICAgICAgKC1b V0tEYXRlVGltZVBvcG92ZXIgY29udHJvbEJlZ2luRWRpdGluZ10pOgorICAgICAgICAoLVtXS0Rh dGVUaW1lUG9wb3ZlciBjb250cm9sRW5kRWRpdGluZ10pOgorICAgICAgICAoLVtXS0RhdGVUaW1l UG9wb3ZlciBjb250cm9sVmlld10pOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvV0tGb3JtUGVy aXBoZXJhbC5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvaW9zL1dLRm9ybVBvcG92ZXIu aDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL2lvcy9XS0Zvcm1Qb3BvdmVyLm1tOiBBZGRl ZC4KKyAgICAgICAgKC1bV0tGb3JtUm90YXRpbmdBY2Nlc3NvcnlQb3BvdmVyIGluaXRXaXRoVmll dzpdKToKKyAgICAgICAgKC1bV0tGb3JtUm90YXRpbmdBY2Nlc3NvcnlQb3BvdmVyIGFjY2Vzc29y eURvbmVdKToKKyAgICAgICAgKC1bV0tGb3JtUm90YXRpbmdBY2Nlc3NvcnlQb3BvdmVyIHBvcG92 ZXJBcnJvd0RpcmVjdGlvbnNdKToKKyAgICAgICAgKC1bV0tGb3JtUm90YXRpbmdBY2Nlc3NvcnlQ b3BvdmVyIHBvcG92ZXJXYXNEaXNtaXNzZWQ6XSk6CisgICAgICAgICgtW1dLUm90YXRpbmdQb3Bv dmVyIGluaXRXaXRoVmlldzpdKToKKyAgICAgICAgKC1bV0tSb3RhdGluZ1BvcG92ZXIgZGVhbGxv Y10pOgorICAgICAgICAoLVtXS1JvdGF0aW5nUG9wb3ZlciBwb3BvdmVyQ29udHJvbGxlcl0pOgor ICAgICAgICAoLVtXS1JvdGF0aW5nUG9wb3ZlciBzZXRQb3BvdmVyQ29udHJvbGxlcjpdKToKKyAg ICAgICAgKC1bV0tSb3RhdGluZ1BvcG92ZXIgcG9wb3ZlckFycm93RGlyZWN0aW9uc10pOgorICAg ICAgICAoLVtXS1JvdGF0aW5nUG9wb3ZlciBwcmVzZW50UG9wb3ZlckFuaW1hdGVkOl0pOgorICAg ICAgICAoLVtXS1JvdGF0aW5nUG9wb3ZlciBkaXNtaXNzUG9wb3ZlckFuaW1hdGVkOl0pOgorICAg ICAgICAoLVtXS1JvdGF0aW5nUG9wb3ZlciB3aWxsUm90YXRlOl0pOgorICAgICAgICAoLVtXS1Jv dGF0aW5nUG9wb3ZlciBkaWRSb3RhdGU6XSk6CisgICAgICAgICgtW1dLUm90YXRpbmdQb3BvdmVy IHBvcG92ZXJDb250cm9sbGVyRGlkRGlzbWlzc1BvcG92ZXI6XSk6CisgICAgICAgICogVUlQcm9j ZXNzL2lvcy9XS0Zvcm1TZWxlY3RDb250cm9sLmg6IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vz cy9pb3MvV2ViUGFnZVByb3h5SU9TLm1tOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OnNldEFzc2lzdGVkTm9kZVZhbHVlKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpz ZXRBc3Npc3RlZE5vZGVWYWx1ZUFzTnVtYmVyKToKKyAgICAgICAgKiBXZWJLaXQyLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2Uu aDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbjoKKyAg ICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW06CisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2U6OnNldEFzc2lzdGVkTm9kZVZhbHVlKToKKyAgICAgICAgKFdlYktpdDo6 V2ViUGFnZTo6c2V0QXNzaXN0ZWROb2RlVmFsdWVBc051bWJlcik6CisKIDIwMTQtMDItMjYgIEpp bndvbyBTb25nICA8amlud29vNy5zb25nQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFVucmV2aWV3 ZWQgQ01BS0UgYnVpbGQgZml4IGFmdGVyIHIxNjQ3NTEuCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5oCShyZXZpc2lvbiAxNjQ3NTMpCisrKyBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgJKHdvcmtpbmcgY29weSkKQEAgLTQ3Nyw2ICs0Nzcs OCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwZXJmb3JtQWN0aW9uT25FbGVtZW50KHVpbnQzMl90IGFj dGlvbik7CiAgICAgdm9pZCBzYXZlSW1hZ2VUb0xpYnJhcnkoY29uc3QgU2hhcmVkTWVtb3J5OjpI YW5kbGUmIGltYWdlSGFuZGxlLCB1aW50NjRfdCBpbWFnZVNpemUpOwogICAgIHZvaWQgZGlkVXBk YXRlQmxvY2tTZWxlY3Rpb25XaXRoVG91Y2godWludDMyX3QgdG91Y2gsIHVpbnQzMl90IGZsYWdz LCBmbG9hdCBncm93VGhyZXNob2xkLCBmbG9hdCBzaHJpbmtUaHJlc2hvbGQpOworICAgIHZvaWQg c2V0QXNzaXN0ZWROb2RlVmFsdWUoY29uc3QgU3RyaW5nJik7CisgICAgdm9pZCBzZXRBc3Npc3Rl ZE5vZGVWYWx1ZUFzTnVtYmVyKGRvdWJsZSk7CiAjZW5kaWYKIAogICAgIGNvbnN0IEVkaXRvclN0 YXRlJiBlZGl0b3JTdGF0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fZWRpdG9yU3RhdGU7IH0KSW5kZXg6 IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tDb250ZW50Vmlld0ludGVyYWN0aW9uLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3 SW50ZXJhY3Rpb24uaAkocmV2aXNpb24gMTY0NzUzKQorKysgU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24uaAkod29ya2luZyBjb3B5KQpAQCAtMjcs NiArMjcsNyBAQAogCiAjaW1wb3J0ICJBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oIgogI2ltcG9y dCAiSW50ZXJhY3Rpb25JbmZvcm1hdGlvbkF0UG9zaXRpb24uaCIKKyNpbXBvcnQgIldLRm9ybVBl cmlwaGVyYWwuaCIKICNpbXBvcnQgIldLR2VzdHVyZVR5cGVzLmgiCiAjaW1wb3J0IDxVSUtpdC9V SVRleHRJbnB1dF9Qcml2YXRlLmg+CiAjaW1wb3J0IDxVSUtpdC9VSVZpZXcuaD4KQEAgLTEwMCw2 ICsxMDEsNyBAQCBzdHJ1Y3QgV0tBdXRvQ29ycmVjdGlvbkRhdGEgewogICAgIFdlYktpdDo6V0tB dXRvQ29ycmVjdGlvbkRhdGEgX2F1dG9jb3JyZWN0aW9uRGF0YTsKICAgICBXZWJLaXQ6OkludGVy YWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uIF9wb3NpdGlvbkluZm9ybWF0aW9uOwogICAgIFdl YktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24gX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uOwor ICAgIFJldGFpblB0cjxOU09iamVjdDxXS0Zvcm1QZXJpcGhlcmFsPiA+IF9pbnB1dFBlcmlwaGVy YWw7CiAKICAgICBCT09MIF9pc0VkaXRhYmxlOwogICAgIEJPT0wgX3Nob3dpbmdUZXh0U3R5bGVP cHRpb25zOwpAQCAtMTM0LDUgKzEzNiw1IEBAIHN0cnVjdCBXS0F1dG9Db3JyZWN0aW9uRGF0YSB7 CiAtICh2b2lkKV93aWxsU3RhcnRVc2VyVHJpZ2dlcmVkU2Nyb2xsaW5nT3Jab29taW5nOwogLSAo dm9pZClfZGlkRW5kU2Nyb2xsaW5nT3Jab29taW5nOwogLSAodm9pZClfZGlkVXBkYXRlQmxvY2tT ZWxlY3Rpb25XaXRoVG91Y2g6KFdlYktpdDo6V0tTZWxlY3Rpb25Ub3VjaCl0b3VjaCB3aXRoRmxh Z3M6KFdlYktpdDo6V0tTZWxlY3Rpb25GbGFncylmbGFncyBncm93VGhyZXNob2xkOihDR0Zsb2F0 KWdyb3dUaHJlc2hvbGQgc2hyaW5rVGhyZXNob2xkOihDR0Zsb2F0KXNocmlua1RocmVzaG9sZDsK LQorLSAodm9pZClhY2Nlc3NvcnlEb25lOwogQGVuZApJbmRleDogU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24ubW0KPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24ubW0JKHJl dmlzaW9uIDE2NDc1MykKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tDb250ZW50 Vmlld0ludGVyYWN0aW9uLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0zMyw2ICszMyw3IEBACiAjaW1w b3J0ICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbXBvcnQgIldlYlByb2Nlc3NQcm94eS5oIgogI2lt cG9ydCAiV0tBY3Rpb25TaGVldEFzc2lzdGFudC5oIgorI2ltcG9ydCAiV0tGb3JtSW5wdXRDb250 cm9sLmgiCiAjaW1wb3J0IDxEYXRhRGV0ZWN0b3JzVUkvREREZXRlY3Rpb25Db250cm9sbGVyLmg+ CiAjaW1wb3J0IDxVSUtpdC9fVUlIaWdobGlnaHRWaWV3Lmg+CiAjaW1wb3J0IDxVSUtpdC9fVUlX ZWJIaWdobGlnaHRMb25nUHJlc3NHZXN0dXJlUmVjb2duaXplci5oPgpAQCAtMzgxLDYgKzM4Miwy MiBAQCAtIChCT09MKV9yZXF1aXJlc0tleWJvYXJkUmVzZXRPblJlbG9hZAogICAgIHJldHVybiBZ RVM7CiB9CiAKKy0gKHZvaWQpX2Rpc3BsYXlGb3JtTm9kZUlucHV0VmlldworeworICAgIC8vIEZJ WE1FOiBUaGlzIGlzIHRoZSBwbGFjZSB3aGVyZSB3ZSBzaG91bGQgem9vbSB0byBub2RlCisgICAg W3NlbGYgX3VwZGF0ZUFjY2Vzc29yeV07Cit9CisKKy0gKFVJVmlldyAqKWlucHV0Vmlldworewor ICAgIGlmICghX2lucHV0UGVyaXBoZXJhbCkKKyAgICAgICAgX2lucHV0UGVyaXBoZXJhbCA9IGFk b3B0TlMoW1dLRm9ybUlucHV0Q29udHJvbCBjcmVhdGVQZXJpcGhlcmFsV2l0aFZpZXc6c2VsZl0p OworICAgIGVsc2UKKyAgICAgICAgW3NlbGYgX2Rpc3BsYXlGb3JtTm9kZUlucHV0Vmlld107CisK KyAgICByZXR1cm4gW19pbnB1dFBlcmlwaGVyYWwgYXNzaXN0YW50Vmlld107Cit9CisKIC0gKEJP T0wpZ2VzdHVyZVJlY29nbml6ZXI6KFVJR2VzdHVyZVJlY29nbml6ZXIgKilwcmV2ZW50aW5nR2Vz dHVyZVJlY29nbml6ZXIgY2FuUHJldmVudEdlc3R1cmVSZWNvZ25pemVyOihVSUdlc3R1cmVSZWNv Z25pemVyICopcHJldmVudGVkR2VzdHVyZVJlY29nbml6ZXIKIHsKICAgICAvLyBBIGxvbmctcHJl c3MgZ2VzdHVyZSBjYW4gbm90IGJlIHJlY29nbml6ZWQgd2hpbGUgcGFubmluZywgYnV0IGEgcGFu IGNhbiBiZSByZWNvZ25pemVkCkBAIC0xNzc5LDYgKzE3OTYsNyBAQCAtICh2b2lkKV9zdGFydEFz c2lzdGluZ05vZGU6KGNvbnN0IEFzc2lzCiB7CiAgICAgX2lzRWRpdGFibGUgPSBZRVM7CiAgICAg X2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uID0gaW5mb3JtYXRpb247CisgICAgX2lucHV0UGVyaXBo ZXJhbCA9IG5pbDsKICAgICBfdHJhaXRzID0gbmlsOwogICAgIGlmICghW3NlbGYgaXNGaXJzdFJl c3BvbmRlcl0pCiAgICAgICAgIFtzZWxmIGJlY29tZUZpcnN0UmVzcG9uZGVyXTsKQEAgLTE3ODYs MTIgKzE4MDQsMTYgQEAgLSAodm9pZClfc3RhcnRBc3Npc3RpbmdOb2RlOihjb25zdCBBc3Npcwog ICAgIFtzZWxmIF9zdGFydEFzc2lzdGluZ0tleWJvYXJkXTsKICAgICBbc2VsZiByZWxvYWRJbnB1 dFZpZXdzXTsKICAgICBbc2VsZiBfdXBkYXRlQWNjZXNzb3J5XTsKKyAgICAvLyBfaW5wdXRQZXJp cGhlcmFsIGhhcyBiZWVuIGluaXRpYWxpemVkIGluIGlucHV0VmlldyBjYWxsZWQgYnkgcmVsb2Fk SW5wdXRWaWV3cy4KKyAgICBbX2lucHV0UGVyaXBoZXJhbCBiZWdpbkVkaXRpbmddOwogfQogCiAt ICh2b2lkKV9zdG9wQXNzaXN0aW5nTm9kZQogewogICAgIF9pc0VkaXRhYmxlID0gTk87CisgICAg W19pbnB1dFBlcmlwaGVyYWwgZW5kRWRpdGluZ107CiAgICAgX2Fzc2lzdGVkTm9kZUluZm9ybWF0 aW9uLmVsZW1lbnRUeXBlID0gV0tUeXBlTm9uZTsKKyAgICBfaW5wdXRQZXJpcGhlcmFsID0gbmls OwogCiAgICAgW3NlbGYgX3N0b3BBc3Npc3RpbmdLZXlib2FyZF07CiAgICAgW3NlbGYgcmVsb2Fk SW5wdXRWaWV3c107CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLRm9ybUlu cHV0Q29udHJvbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3Mv V0tGb3JtSW5wdXRDb250cm9sLmgJKHJldmlzaW9uIDApCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvaW9zL1dLRm9ybUlucHV0Q29udHJvbC5oCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEs MzIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAor ICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisg KiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICog Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJXS0Zvcm1QZXJpcGhlcmFsLmgiCisKK0BjbGFz cyBXS0NvbnRlbnRWaWV3OworCitAaW50ZXJmYWNlIFdLRm9ybUlucHV0Q29udHJvbCA6IE5TT2Jq ZWN0PFdLRm9ybVBlcmlwaGVyYWw+CisrIChXS0Zvcm1JbnB1dENvbnRyb2wgKiljcmVhdGVQZXJp cGhlcmFsV2l0aFZpZXc6KFdLQ29udGVudFZpZXcgKil2aWV3OworQGVuZApJbmRleDogU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1JbnB1dENvbnRyb2wubW0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1JbnB1dENvbnRyb2wubW0JKHJl dmlzaW9uIDApCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLRm9ybUlucHV0Q29u dHJvbC5tbQkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDM3NCBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bXBvcnQgImNvbmZpZy5oIgorI2ltcG9ydCAiV0tDb250ZW50Vmlldy5oIgorI2ltcG9ydCAiV0tD b250ZW50Vmlld0ludGVyYWN0aW9uLmgiCisjaW1wb3J0ICJXS0Zvcm1JbnB1dENvbnRyb2wuaCIK KyNpbXBvcnQgIldLRm9ybVBvcG92ZXIuaCIKKyNpbXBvcnQgIldlYlBhZ2VQcm94eS5oIgorI2lt cG9ydCA8VUlLaXQvVUlCYXJCdXR0b25JdGVtLmg+CisjaW1wb3J0IDxVSUtpdC9VSUJhckJ1dHRv bkl0ZW1fUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlEYXRlUGlja2VyLmg+CisjaW1wb3J0 IDxVSUtpdC9VSURhdGVQaWNrZXJfUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlEZXZpY2Vf UHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlLZXlib2FyZF9Qcml2YXRlLmg+CisjaW1wb3J0 IDxXZWJDb3JlL0xvY2FsaXplZFN0cmluZ3MuaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4K KwordXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKKworQGludGVyZmFjZSBXS0RhdGVUaW1lUG9wb3Zl clZpZXdDb250cm9sbGVyIDogVUlWaWV3Q29udHJvbGxlciB7CisgICAgUmV0YWluUHRyPE5TT2Jq ZWN0PFdLRm9ybUNvbnRyb2w+PiBfaW5uZXJDb250cm9sOworfQorLSAoaWQpaW5pdFdpdGhWaWV3 OihXS0NvbnRlbnRWaWV3ICopdmlldyBkYXRlUGlja2VyTW9kZTooVUlEYXRlUGlja2VyTW9kZSlk YXRlUGlja2VyTW9kZTsKKy0gKE5TT2JqZWN0PFdLRm9ybUNvbnRyb2w+ICopaW5uZXJDb250cm9s OworQGVuZAorCisvLyBXS0RhdGVUaW1lUGlja2VyCitAaW50ZXJmYWNlIFdLRGF0ZVRpbWVQaWNr ZXIgOiBOU09iamVjdDxXS0Zvcm1Db250cm9sPiB7CisgICAgUmV0YWluUHRyPFVJRGF0ZVBpY2tl cj4gX2RhdGVQaWNrZXI7CisgICAgTlNTdHJpbmcgKl9mb3JtYXRTdHJpbmc7CisgICAgQk9PTCBf c2hvdWxkUmVtb3ZlVGltZVpvbmVJbmZvcm1hdGlvbjsKKyAgICBCT09MIF9pc1RpbWVJbnB1dDsK KyAgICBXS0NvbnRlbnRWaWV3KiBfdmlldzsKK30KKy0gKGlkKWluaXRXaXRoVmlldzooV0tDb250 ZW50VmlldyAqKXZpZXcgZGF0ZVBpY2tlck1vZGU6KFVJRGF0ZVBpY2tlck1vZGUpbW9kZTsKKy0g KFVJRGF0ZVBpY2tlciAqKWRhdGVQaWNrZXI7CitAZW5kCisKKy8vIFdLRGF0ZVRpbWVQb3BvdmVy CitAaW50ZXJmYWNlIFdLRGF0ZVRpbWVQb3BvdmVyIDogV0tGb3JtUm90YXRpbmdBY2Nlc3NvcnlQ b3BvdmVyPFdLRm9ybUNvbnRyb2w+IHsKKyAgICBSZXRhaW5QdHI8V0tEYXRlVGltZVBvcG92ZXJW aWV3Q29udHJvbGxlcj4gX3ZpZXdDb250cm9sbGVyOworICAgIFdLQ29udGVudFZpZXcqIF92aWV3 OworfQorLSAoaWQpaW5pdFdpdGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmlldyBkYXRlUGlja2Vy TW9kZTooVUlEYXRlUGlja2VyTW9kZSltb2RlOworLSAoV0tEYXRlVGltZVBvcG92ZXJWaWV3Q29u dHJvbGxlciAqKSB2aWV3Q29udHJvbGxlcjsKK0BlbmQKKworQGltcGxlbWVudGF0aW9uIFdLRGF0 ZVRpbWVQaWNrZXIKKworc3RhdGljIE5TU3RyaW5nICogY29uc3Qga0RhdGVGb3JtYXRTdHJpbmcg PSBAInl5eXktTU0tZGQiOyAvLyAiMjAxMS0wMS0yNyIuCitzdGF0aWMgTlNTdHJpbmcgKiBjb25z dCBrTW9udGhGb3JtYXRTdHJpbmcgPSBAInl5eXktTU0iOyAvLyAiMjAxMS0wMSIuCitzdGF0aWMg TlNTdHJpbmcgKiBjb25zdCBrVGltZUZvcm1hdFN0cmluZyA9IEAiSEg6bW0iOyAvLyAiMTM6NDUi Lgorc3RhdGljIGNvbnN0IE5TVGltZUludGVydmFsIGtNaWxsaXNlY29uZHNQZXJTZWNvbmQgPSAx MDAwOworCistIChVSURhdGVQaWNrZXIgKilkYXRlUGlja2VyCit7CisgICAgcmV0dXJuIF9kYXRl UGlja2VyLmdldCgpOworfQorCistIChpZClpbml0V2l0aFZpZXc6KFdLQ29udGVudFZpZXcgKil2 aWV3IGRhdGVQaWNrZXJNb2RlOihVSURhdGVQaWNrZXJNb2RlKW1vZGUKK3sKKyAgICBzZWxmID0g W3N1cGVyIGluaXRdOworICAgIGlmICghc2VsZikKKyAgICAgICAgcmV0dXJuIG5pbDsKKworICAg IF92aWV3ID0gdmlldzsKKyAgICBfc2hvdWxkUmVtb3ZlVGltZVpvbmVJbmZvcm1hdGlvbiA9IE5P OworICAgIF9pc1RpbWVJbnB1dCA9IE5POworICAgIF9mb3JtYXRTdHJpbmcgPSBuaWw7CisgICAg c3dpdGNoICh2aWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmVsZW1lbnRUeXBlKSB7CisgICAg Y2FzZSBXZWJLaXQ6OldLVHlwZURhdGU6CisgICAgICAgIF9mb3JtYXRTdHJpbmcgPSBrRGF0ZUZv cm1hdFN0cmluZzsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBXZWJLaXQ6OldLVHlwZU1vbnRo OgorICAgICAgICBfZm9ybWF0U3RyaW5nID0ga01vbnRoRm9ybWF0U3RyaW5nOworICAgICAgICBi cmVhazsKKyAgICBjYXNlIFdlYktpdDo6V0tUeXBlVGltZToKKyAgICAgICAgX2Zvcm1hdFN0cmlu ZyA9IGtUaW1lRm9ybWF0U3RyaW5nOworICAgICAgICBfaXNUaW1lSW5wdXQgPSBZRVM7CisgICAg ICAgIGJyZWFrOworICAgIGNhc2UgV2ViS2l0OjpXS1R5cGVEYXRlVGltZUxvY2FsOgorICAgICAg ICBfc2hvdWxkUmVtb3ZlVGltZVpvbmVJbmZvcm1hdGlvbiA9IFlFUzsKKyAgICAgICAgYnJlYWs7 CisgICAgZGVmYXVsdDoKKyAgICAgICAgYnJlYWs7CisgICB9CisKKyAgICBDR1NpemUgc2l6ZSA9 IFVJQ3VycmVudFVzZXJJbnRlcmZhY2VJZGlvbUlzUGFkKCkgPyBbVUlQaWNrZXJWaWV3IGRlZmF1 bHRTaXplRm9yQ3VycmVudE9yaWVudGF0aW9uXSA6IFtVSUtleWJvYXJkIGRlZmF1bHRTaXplRm9y SW50ZXJmYWNlT3JpZW50YXRpb246W1VJQXBwIGludGVyZmFjZU9yaWVudGF0aW9uXV07CisKKyAg ICBfZGF0ZVBpY2tlciA9IGFkb3B0TlMoW1tVSURhdGVQaWNrZXIgYWxsb2NdIGluaXRXaXRoRnJh bWU6Q0dSZWN0TWFrZSgwLCAwLCBzaXplLndpZHRoLCBzaXplLmhlaWdodCldKTsKKyAgICBfZGF0 ZVBpY2tlci5nZXQoKS5kYXRlUGlja2VyTW9kZSA9IG1vZGU7CisgICAgX2RhdGVQaWNrZXIuZ2V0 KCkuaGlkZGVuID0gTk87CisgICAgW19kYXRlUGlja2VyIGFkZFRhcmdldDpzZWxmIGFjdGlvbjpA c2VsZWN0b3IoX2RhdGVDaGFuZ2VIYW5kbGVyOikgZm9yQ29udHJvbEV2ZW50czpVSUNvbnRyb2xF dmVudFZhbHVlQ2hhbmdlZF07CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9pZClkZWFs bG9jCit7CisgICAgW19kYXRlUGlja2VyIHJlbW92ZVRhcmdldDpzZWxmIGFjdGlvbjpOVUxMIGZv ckNvbnRyb2xFdmVudHM6VUlDb250cm9sRXZlbnRWYWx1ZUNoYW5nZWRdOworICAgIFtzdXBlciBk ZWFsbG9jXTsKK30KKworLSAoVUlWaWV3ICopY29udHJvbFZpZXcKK3sKKyAgICByZXR1cm4gX2Rh dGVQaWNrZXIuZ2V0KCk7Cit9CisKKy0gKE5TSW50ZWdlcilfdGltZVpvbmVPZmZzZXRGcm9tR01U OihOU0RhdGUgKilkYXRlCit7CisgICAgaWYgKCFfc2hvdWxkUmVtb3ZlVGltZVpvbmVJbmZvcm1h dGlvbikKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1cm4gW19kYXRlUGlja2VyLmdldCgp LnRpbWVab25lIHNlY29uZHNGcm9tR01URm9yRGF0ZTpkYXRlXTsKK30KKworLSAoTlNTdHJpbmcg Kilfc2FuaXRpemVJbnB1dFZhbHVlRm9yRm9ybWF0dGVyOihOU1N0cmluZyAqKXZhbHVlCit7Cisg ICAgLy8gVGhlICJ0aW1lIiBpbnB1dCB0eXBlIG1heSBoYXZlIHNlY29uZHMgYW5kIG1pbGxpc2Vj b25kcyBpbmZvcm1hdGlvbiB3aGljaCB3ZQorICAgIC8vIGp1c3QgaWdub3JlLiBGb3IgZXhhbXBs ZTogIjAxOjU2OjIwLjM5MSIgaXMgc2hvcnRlbmVkIHRvIGp1c3QgIjAxOjU2Ii4KKyAgICBpZiAo X2lzVGltZUlucHV0KQorICAgICAgICByZXR1cm4gW3ZhbHVlIHN1YnN0cmluZ1RvSW5kZXg6W2tU aW1lRm9ybWF0U3RyaW5nIGxlbmd0aF1dOworCisgICAgcmV0dXJuIHZhbHVlOworfQorCistICh2 b2lkKV9kYXRlQ2hhbmdlZFNldEFzTnVtYmVyCit7CisgICAgTlNEYXRlICpkYXRlID0gW19kYXRl UGlja2VyIGRhdGVdOworICAgIFtfdmlldyBwYWdlXS0+c2V0QXNzaXN0ZWROb2RlVmFsdWVBc051 bWJlcigoW2RhdGUgdGltZUludGVydmFsU2luY2UxOTcwXSArIFtzZWxmIF90aW1lWm9uZU9mZnNl dEZyb21HTVQ6ZGF0ZV0pICoga01pbGxpc2Vjb25kc1BlclNlY29uZCk7Cit9CisKKy0gKHZvaWQp X2RhdGVDaGFuZ2VkU2V0QXNTdHJpbmcKK3sKKyAgICAvLyBGb3JjZSBFbmdsaXNoIGxvY2FsZSBi ZWNhdXNlIHRoYXQgaXMgd2hhdCBIVE1MNSB2YWx1ZSBwYXJzaW5nIGV4cGVjdHMuCisgICAgUmV0 YWluUHRyPE5TTG9jYWxlPiBlbmdsaXNoTG9jYWxlID0gYWRvcHROUyhbW05TTG9jYWxlIGFsbG9j XSBpbml0V2l0aExvY2FsZUlkZW50aWZpZXI6QCJlbl9VU19QT1NJWCJdKTsKKyAgICBSZXRhaW5Q dHI8TlNEYXRlRm9ybWF0dGVyPiBkYXRlRm9ybWF0dGVyID0gYWRvcHROUyhbW05TRGF0ZUZvcm1h dHRlciBhbGxvY10gaW5pdF0pOworICAgIFtkYXRlRm9ybWF0dGVyIHNldFRpbWVab25lOl9kYXRl UGlja2VyLmdldCgpLnRpbWVab25lXTsKKyAgICBbZGF0ZUZvcm1hdHRlciBzZXREYXRlRm9ybWF0 Ol9mb3JtYXRTdHJpbmddOworICAgIFtkYXRlRm9ybWF0dGVyIHNldExvY2FsZTplbmdsaXNoTG9j YWxlLmdldCgpXTsKKworICAgIFtfdmlldyBwYWdlXS0+c2V0QXNzaXN0ZWROb2RlVmFsdWUoW2Rh dGVGb3JtYXR0ZXIgc3RyaW5nRnJvbURhdGU6W19kYXRlUGlja2VyIGRhdGVdXSk7Cit9CisKKy0g KHZvaWQpX2RhdGVDaGFuZ2VkCit7CisgICAgLy8gSW50ZXJuYWxseSwgRE9NSFRNTElucHV0RWxl bWVudCBzZXRWYWx1ZUFzKiBlYWNoIHRha2UgZGlmZmVyZW50IHZhbHVlcyBmb3IKKyAgICAvLyBk aWZmZXJlbnQgZGF0ZSB0eXBlcy4gSXQgaXMgc29tZXRpbWVzIGVhc2llciB0byBzZXQgdGhlIGRh dGUgaW4gZGlmZmVyZW50IHdheXM6CisgICAgLy8gICAtIHVzZSBzZXRWYWx1ZUFzU3RyaW5nIGZv ciAiZGF0ZSIsICJtb250aCIsIGFuZCAidGltZSIuCisgICAgLy8gICAtIHVzZSBzZXRWYWx1ZUFz TnVtYmVyIGZvciAiZGF0ZXRpbWUtbG9jYWwiLgorICAgIGlmIChfZm9ybWF0U3RyaW5nKQorICAg ICAgICBbc2VsZiBfZGF0ZUNoYW5nZWRTZXRBc1N0cmluZ107CisgICAgZWxzZQorICAgICAgICBb c2VsZiBfZGF0ZUNoYW5nZWRTZXRBc051bWJlcl07Cit9CisKKy0gKHZvaWQpX2RhdGVDaGFuZ2VI YW5kbGVyOihpZClzZW5kZXIKK3sKKyAgICBbc2VsZiBfZGF0ZUNoYW5nZWRdOworfQorCistICh2 b2lkKWNvbnRyb2xCZWdpbkVkaXRpbmcKK3sKKyAgICAvLyBTZXQgdGhlIHRpbWUgem9uZSBpbiBj YXNlIGl0IGNoYW5nZWQuCisgICAgX2RhdGVQaWNrZXIuZ2V0KCkudGltZVpvbmUgPSBbTlNUaW1l Wm9uZSBsb2NhbFRpbWVab25lXTsKKworICAgIC8vIEN1cnJlbnRseSBubyB2YWx1ZSBmb3IgdGhl IDxpbnB1dD4uIFN0YXJ0IHRoZSBwaWNrZXIgd2l0aCB0aGUgY3VycmVudCB0aW1lLgorICAgIC8v IEFsc28sIHVwZGF0ZSB0aGUgYWN0dWFsIDxpbnB1dD4gdmFsdWUuCisgICAgTlNTdHJpbmcgKnZh bHVlID0gX3ZpZXcuYXNzaXN0ZWROb2RlSW5mb3JtYXRpb24udmFsdWU7CisgICAgaWYgKF92aWV3 LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLnZhbHVlLmlzRW1wdHkoKSkgeworICAgICAgICBbX2Rh dGVQaWNrZXIgc2V0RGF0ZTpbTlNEYXRlIGRhdGVdXTsKKyAgICAgICAgW3NlbGYgX2RhdGVDaGFu Z2VkXTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIC8vIENvbnZlcnQgdGhlIHN0cmlu ZyB2YWx1ZSB0byBhIGRhdGUgb2JqZWN0IGZvciB0aGUgZmllbGRzIHdoZXJlIHdlIGhhdmUgYSBm b3JtYXQgc3RyaW5nLgorICAgIGlmIChfZm9ybWF0U3RyaW5nKSB7CisgICAgICAgIHZhbHVlID0g W3NlbGYgX3Nhbml0aXplSW5wdXRWYWx1ZUZvckZvcm1hdHRlcjp2YWx1ZV07CisgICAgICAgIFJl dGFpblB0cjxOU0xvY2FsZT4gZW5nbGlzaExvY2FsZSA9IGFkb3B0TlMoW1tOU0xvY2FsZSBhbGxv Y10gaW5pdFdpdGhMb2NhbGVJZGVudGlmaWVyOkAiZW5fVVNfUE9TSVgiXSk7CisgICAgICAgIFJl dGFpblB0cjxOU0RhdGVGb3JtYXR0ZXI+IGRhdGVGb3JtYXR0ZXIgPSBhZG9wdE5TKFtbTlNEYXRl Rm9ybWF0dGVyIGFsbG9jXSBpbml0XSk7CisgICAgICAgIFtkYXRlRm9ybWF0dGVyIHNldFRpbWVa b25lOl9kYXRlUGlja2VyLmdldCgpLnRpbWVab25lXTsKKyAgICAgICAgW2RhdGVGb3JtYXR0ZXIg c2V0RGF0ZUZvcm1hdDpfZm9ybWF0U3RyaW5nXTsKKyAgICAgICAgW2RhdGVGb3JtYXR0ZXIgc2V0 TG9jYWxlOmVuZ2xpc2hMb2NhbGUuZ2V0KCldOworICAgICAgICBOU0RhdGUgKnBhcnNlZERhdGUg PSBbZGF0ZUZvcm1hdHRlciBkYXRlRnJvbVN0cmluZzp2YWx1ZV07CisgICAgICAgIFtfZGF0ZVBp Y2tlciBzZXREYXRlOnBhcnNlZERhdGUgPyBwYXJzZWREYXRlIDogW05TRGF0ZSBkYXRlXV07Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyBDb252ZXJ0IHRoZSBudW1iZXIgdmFsdWUg dG8gYSBkYXRlIG9iamVjdCBmb3IgdGhlIGZpZWxkcyBhZmZlY3RlZCBieSB0aW1lem9uZXMuCisg ICAgTlNUaW1lSW50ZXJ2YWwgc2Vjb25kc1NpbmNlMTk3MCA9IF92aWV3LmFzc2lzdGVkTm9kZUlu Zm9ybWF0aW9uLnZhbHVlQXNOdW1iZXIgLyBrTWlsbGlzZWNvbmRzUGVyU2Vjb25kOworICAgIE5T SW50ZWdlciB0aW1lWm9uZU9mZnNldCA9IFtzZWxmIF90aW1lWm9uZU9mZnNldEZyb21HTVQ6W05T RGF0ZSBkYXRlV2l0aFRpbWVJbnRlcnZhbFNpbmNlMTk3MDpzZWNvbmRzU2luY2UxOTcwXV07Cisg ICAgTlNUaW1lSW50ZXJ2YWwgYWRqdXN0ZWRTZWNvbmRzU2luY2UxOTcwID0gc2Vjb25kc1NpbmNl MTk3MCAtIHRpbWVab25lT2Zmc2V0OworICAgIFtfZGF0ZVBpY2tlciBzZXREYXRlOltOU0RhdGUg ZGF0ZVdpdGhUaW1lSW50ZXJ2YWxTaW5jZTE5NzA6YWRqdXN0ZWRTZWNvbmRzU2luY2UxOTcwXV07 Cit9CisKKy0gKHZvaWQpY29udHJvbEVuZEVkaXRpbmcKK3sKK30KKworQGVuZAorCisvLyBXS0Zv cm1JbnB1dENvbnRyb2wKK0BpbXBsZW1lbnRhdGlvbiBXS0Zvcm1JbnB1dENvbnRyb2wgeworICAg IFJldGFpblB0cjxpZDxXS0Zvcm1Db250cm9sPj4gX2NvbnRyb2w7Cit9CisKKy0gKGlkKWluaXRX aXRoVmlldzooV0tDb250ZW50VmlldyAqKXZpZXcKK3sKKyAgICBzZWxmID0gW3N1cGVyIGluaXRd OworICAgIGlmICghc2VsZikKKyAgICAgICAgcmV0dXJuIG5pbDsKKworICAgIFVJRGF0ZVBpY2tl ck1vZGUgbW9kZTsKKworICAgIHN3aXRjaCAodmlldy5hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5l bGVtZW50VHlwZSkgeworICAgICAgICBjYXNlIFdlYktpdDo6V0tUeXBlRGF0ZToKKyAgICAgICAg ICAgIG1vZGUgPSBVSURhdGVQaWNrZXJNb2RlRGF0ZTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICBjYXNlIFdlYktpdDo6V0tUeXBlRGF0ZVRpbWVMb2NhbDoKKyAgICAgICAgICAgIG1vZGUg PSBVSURhdGVQaWNrZXJNb2RlRGF0ZUFuZFRpbWU7CisgICAgICAgICAgICBicmVhazsKKworICAg ICAgICBjYXNlIFdlYktpdDo6V0tUeXBlVGltZToKKyAgICAgICAgICAgIG1vZGUgPSBVSURhdGVQ aWNrZXJNb2RlVGltZTsKKyAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGNhc2UgV2ViS2l0 OjpXS1R5cGVNb250aDoKKyAgICAgICAgICAgIG1vZGUgPSAoVUlEYXRlUGlja2VyTW9kZSlVSURh dGVQaWNrZXJNb2RlWWVhckFuZE1vbnRoOworICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAg ZGVmYXVsdDoKKyAgICAgICAgICAgIFtzZWxmIHJlbGVhc2VdOworICAgICAgICAgICAgcmV0dXJu IG5pbDsKKyAgICB9CisKKyAgICBpZiAoVUlDdXJyZW50VXNlckludGVyZmFjZUlkaW9tSXNQYWQo KSkKKyAgICAgICAgX2NvbnRyb2wgPSBhZG9wdE5TKFtbV0tEYXRlVGltZVBvcG92ZXIgYWxsb2Nd IGluaXRXaXRoVmlldzp2aWV3IGRhdGVQaWNrZXJNb2RlOm1vZGVdKTsKKyAgICBlbHNlCisgICAg ICAgIF9jb250cm9sID0gYWRvcHROUyhbW1dLRGF0ZVRpbWVQaWNrZXIgYWxsb2NdIGluaXRXaXRo Vmlldzp2aWV3IGRhdGVQaWNrZXJNb2RlOm1vZGVdKTsKKworICAgIHJldHVybiBzZWxmOworCit9 CisKKysgKFdLRm9ybUlucHV0Q29udHJvbCAqKWNyZWF0ZVBlcmlwaGVyYWxXaXRoVmlldzooV0tD b250ZW50VmlldyAqKXZpZXcKK3sKKyAgICByZXR1cm4gW1tXS0Zvcm1JbnB1dENvbnRyb2wgYWxs b2NdIGluaXRXaXRoVmlldzp2aWV3XTsKK30KKworLSAodm9pZCliZWdpbkVkaXRpbmcKK3sKKyAg ICBbX2NvbnRyb2wgY29udHJvbEJlZ2luRWRpdGluZ107Cit9CisKKy0gKHZvaWQpZW5kRWRpdGlu ZworeworICAgIFtfY29udHJvbCBjb250cm9sRW5kRWRpdGluZ107Cit9CisKKy0gKFVJVmlldyAq KWFzc2lzdGFudFZpZXcKK3sKKyAgICByZXR1cm4gW19jb250cm9sIGNvbnRyb2xWaWV3XTsKK30K KworQGVuZAorCisKK0BpbXBsZW1lbnRhdGlvbiBXS0RhdGVUaW1lUG9wb3ZlclZpZXdDb250cm9s bGVyCisKKy0gKGlkKWluaXRXaXRoVmlldzooV0tDb250ZW50VmlldyAqKXZpZXcgZGF0ZVBpY2tl ck1vZGU6KFVJRGF0ZVBpY2tlck1vZGUpZGF0ZVBpY2tlck1vZGUKK3sKKyAgICBzZWxmID0gW3N1 cGVyIGluaXRdOworICAgIGlmICghc2VsZikKKyAgICAgICAgcmV0dXJuIG5pbDsKKworICAgIF9p bm5lckNvbnRyb2wgPSBhZG9wdE5TKFtbV0tEYXRlVGltZVBpY2tlciBhbGxvY10gaW5pdFdpdGhW aWV3OnZpZXcgZGF0ZVBpY2tlck1vZGU6ZGF0ZVBpY2tlck1vZGVdKTsKKworICAgIHJldHVybiBz ZWxmOworfQorCistIChOU09iamVjdDxXS0Zvcm1Db250cm9sPiAqKWlubmVyQ29udHJvbAorewor ICAgIHJldHVybiBfaW5uZXJDb250cm9sLmdldCgpOworfQorCistICh2b2lkKWxvYWRWaWV3Cit7 CisgICAgc2VsZi52aWV3ID0gW19pbm5lckNvbnRyb2wgY29udHJvbFZpZXddOworfQorCitAZW5k CisKK0BpbXBsZW1lbnRhdGlvbiBXS0RhdGVUaW1lUG9wb3ZlcgorCistICh2b2lkKWNsZWFyOihp ZClzZW5kZXIKK3sKKyAgICBbX3ZpZXcgcGFnZV0tPnNldEFzc2lzdGVkTm9kZVZhbHVlKFN0cmlu ZygpKTsKK30KKworLSAoaWQpaW5pdFdpdGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmlldyBkYXRl UGlja2VyTW9kZTooVUlEYXRlUGlja2VyTW9kZSltb2RlCit7CisgICAgc2VsZiA9IFtzdXBlciBp bml0V2l0aFZpZXc6dmlld107CisgICAgaWYgKCFzZWxmKQorICAgICAgICByZXR1cm4gbmlsOwor CisgICAgX3ZpZXcgPSB2aWV3OworICAgIF92aWV3Q29udHJvbGxlciA9IGFkb3B0TlMoW1tXS0Rh dGVUaW1lUG9wb3ZlclZpZXdDb250cm9sbGVyIGFsbG9jXSBpbml0V2l0aFZpZXc6dmlldyBkYXRl UGlja2VyTW9kZTptb2RlXSk7CisgICAgVUlEYXRlUGlja2VyICpkYXRlUGlja2VyID0gWyhXS0Rh dGVUaW1lUGlja2VyICopX3ZpZXdDb250cm9sbGVyLmdldCgpLmlubmVyQ29udHJvbCBkYXRlUGlj a2VyXTsKKyAgICBDR0Zsb2F0IHBvcG92ZXJXaWR0aCA9IFtkYXRlUGlja2VyIF9jb250ZW50V2lk dGhdOworICAgIENHRmxvYXQgcG9wb3ZlckhlaWdodCA9IF92aWV3Q29udHJvbGxlci5nZXQoKS52 aWV3LmZyYW1lLnNpemUuaGVpZ2h0OworICAgIFtfdmlld0NvbnRyb2xsZXIgc2V0UHJlZmVycmVk Q29udGVudFNpemU6Q0dTaXplTWFrZShwb3BvdmVyV2lkdGgsIHBvcG92ZXJIZWlnaHQpXTsKKyAg ICBbX3ZpZXdDb250cm9sbGVyIHNldEVkZ2VzRm9yRXh0ZW5kZWRMYXlvdXQ6VUlSZWN0RWRnZU5v bmVdOworICAgIFtfdmlld0NvbnRyb2xsZXIgc2V0VGl0bGU6X3ZpZXcuYXNzaXN0ZWROb2RlSW5m b3JtYXRpb24udGl0bGVdOworCisgICAgLy8gQWx3YXlzIGhhdmUgYSBuYXZpZ2F0aW9uIGNvbnRy b2xsZXIgd2l0aCBhIGNsZWFyIGJ1dHRvbiwgYW5kIGEgdGl0bGUgaWYgdGhlIGlucHV0IGVsZW1l bnQgaGFzIGEgdGl0bGUuCisgICAgUmV0YWluUHRyPFVJTmF2aWdhdGlvbkNvbnRyb2xsZXI+IG5h dmlnYXRpb25Db250cm9sbGVyID0gYWRvcHROUyhbW1VJTmF2aWdhdGlvbkNvbnRyb2xsZXIgYWxs b2NdIGluaXRXaXRoUm9vdFZpZXdDb250cm9sbGVyOl92aWV3Q29udHJvbGxlci5nZXQoKV0pOwor ICAgIFVJTmF2aWdhdGlvbkl0ZW0gKm5hdmlnYXRpb25JdGVtID0gbmF2aWdhdGlvbkNvbnRyb2xs ZXIuZ2V0KCkubmF2aWdhdGlvbkJhci50b3BJdGVtOworICAgIE5TU3RyaW5nICpjbGVhclN0cmlu ZyA9IFdFQl9VSV9TVFJJTkdfS0VZKCJDbGVhciIsICJDbGVhciBCdXR0b24gRGF0ZSBQb3BvdmVy IiwgIkNsZWFyIGJ1dHRvbiBpbiBkYXRlIGlucHV0IHBvcG92ZXIiKTsKKyNwcmFnbWEgY2xhbmcg ZGlhZ25vc3RpYyBwdXNoCisjcHJhZ21hIGNsYW5nIGRpYWdub3N0aWMgaWdub3JlZCAiLVdkZXBy ZWNhdGVkLWRlY2xhcmF0aW9ucyIKKyAgICBVSUJhckJ1dHRvbkl0ZW0gKmNsZWFyQnV0dG9uID0g W1tbVUlCYXJCdXR0b25JdGVtIGFsbG9jXSBpbml0V2l0aFRpdGxlOmNsZWFyU3RyaW5nIHN0eWxl OlVJQmFyQnV0dG9uSXRlbVN0eWxlQm9yZGVyZWQgdGFyZ2V0OnNlbGYgYWN0aW9uOkBzZWxlY3Rv cihjbGVhcjopXSBhdXRvcmVsZWFzZV07CisjcHJhZ21hIGNsYW5nIGRpYWdub3N0aWMgcG9wCisg ICAgW25hdmlnYXRpb25JdGVtIHNldFJpZ2h0QmFyQnV0dG9uSXRlbTpjbGVhckJ1dHRvbl07CisK KyAgICBSZXRhaW5QdHI8VUlQb3BvdmVyQ29udHJvbGxlcj4gY29udHJvbGxlciA9IGFkb3B0TlMo W1tVSVBvcG92ZXJDb250cm9sbGVyIGFsbG9jXSBpbml0V2l0aENvbnRlbnRWaWV3Q29udHJvbGxl cjpuYXZpZ2F0aW9uQ29udHJvbGxlci5nZXQoKV0pOworICAgIFtzZWxmIHNldFBvcG92ZXJDb250 cm9sbGVyOmNvbnRyb2xsZXIuZ2V0KCldOworCisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKFdL RGF0ZVRpbWVQb3BvdmVyVmlld0NvbnRyb2xsZXIgKil2aWV3Q29udHJvbGxlcgoreworICAgIHJl dHVybiBfdmlld0NvbnRyb2xsZXIuZ2V0KCk7Cit9CisKKy0gKHZvaWQpY29udHJvbEJlZ2luRWRp dGluZworeworICAgIFtzZWxmIHByZXNlbnRQb3BvdmVyQW5pbWF0ZWQ6Tk9dOworICAgIFtfdmll d0NvbnRyb2xsZXIuZ2V0KCkuaW5uZXJDb250cm9sIGNvbnRyb2xCZWdpbkVkaXRpbmddOworfQor CistICh2b2lkKWNvbnRyb2xFbmRFZGl0aW5nCit7Cit9CisKKy0gKFVJVmlldyAqKWNvbnRyb2xW aWV3Cit7CisgICAgcmV0dXJuIG5pbDsKK30KKworQGVuZApJbmRleDogU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL2lvcy9XS0Zvcm1QZXJpcGhlcmFsLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1QZXJpcGhlcmFsLmgJKHJldmlzaW9uIDApCisrKyBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLRm9ybVBlcmlwaGVyYWwuaAkod29ya2luZyBj b3B5KQpAQCAtMCwwICsxLDM4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisg KiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICog QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworQGNsYXNzIFVJVmlldzsKKworQHBy b3RvY29sIFdLRm9ybVBlcmlwaGVyYWwKKy0gKHZvaWQpYmVnaW5FZGl0aW5nOworLSAodm9pZCll bmRFZGl0aW5nOworLSAoVUlWaWV3ICopYXNzaXN0YW50VmlldzsKK0BlbmQKKworQHByb3RvY29s IFdLRm9ybUNvbnRyb2wKKy0gKFVJVmlldyAqKWNvbnRyb2xWaWV3OworLSAodm9pZCljb250cm9s QmVnaW5FZGl0aW5nOworLSAodm9pZCljb250cm9sRW5kRWRpdGluZzsKK0BlbmQKSW5kZXg6IFNv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tGb3JtUG9wb3Zlci5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tGb3JtUG9wb3Zlci5oCShyZXZpc2lvbiAw KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1Qb3BvdmVyLmgJKHdvcmtp bmcgY29weSkKQEAgLTAsMCArMSw1NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMn JworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMK KyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAq IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICog VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbXBvcnQgPFVJS2l0L1VJ UG9wb3ZlckNvbnRyb2xsZXIuaD4KKworQGNsYXNzIFdLQ29udGVudFZpZXc7CitAcHJvdG9jb2wg V0tSb3RhdGluZ1BvcG92ZXJEZWxlZ2F0ZTsKKworQGludGVyZmFjZSBXS1JvdGF0aW5nUG9wb3Zl ciA6IE5TT2JqZWN0IDxVSVBvcG92ZXJDb250cm9sbGVyRGVsZWdhdGU+Cit7CisgICAgQk9PTCBf aXNSb3RhdGluZzsKKyAgICBDR1BvaW50IF9wcmVzZW50YXRpb25Qb2ludDsKKyAgICBSZXRhaW5Q dHI8VUlQb3BvdmVyQ29udHJvbGxlcj4gX3BvcG92ZXJDb250cm9sbGVyOworICAgIGlkIDxXS1Jv dGF0aW5nUG9wb3ZlckRlbGVnYXRlPiBfZGlzbWlzc0RlbGVnYXRlOworfQorCistIChpZClpbml0 V2l0aFZpZXc6KFdLQ29udGVudFZpZXcgKil2aWV3OworLSAodm9pZClwcmVzZW50UG9wb3ZlckFu aW1hdGVkOihCT09MKWFuaW1hdGVkOworLSAodm9pZClkaXNtaXNzUG9wb3ZlckFuaW1hdGVkOihC T09MKWFuaW1hdGVkOworLSAoVUlQb3BvdmVyQXJyb3dEaXJlY3Rpb24pcG9wb3ZlckFycm93RGly ZWN0aW9uczsKKworQHByb3BlcnR5KG5vbmF0b21pYyxhc3NpZ24pIENHUG9pbnQgcHJlc2VudGF0 aW9uUG9pbnQ7CitAcHJvcGVydHkobm9uYXRvbWljLHJldGFpbikgVUlQb3BvdmVyQ29udHJvbGxl ciAqcG9wb3ZlckNvbnRyb2xsZXI7CitAcHJvcGVydHkobm9uYXRvbWljLGFzc2lnbikgaWQgPFdL Um90YXRpbmdQb3BvdmVyRGVsZWdhdGU+IGRpc21pc3NEZWxlZ2F0ZTsKK0BlbmQKKworCitAcHJv dG9jb2wgV0tSb3RhdGluZ1BvcG92ZXJEZWxlZ2F0ZQorLSAodm9pZClwb3BvdmVyV2FzRGlzbWlz c2VkOihXS1JvdGF0aW5nUG9wb3ZlciAqKXBvcG92ZXI7CitAZW5kCisKK0BpbnRlcmZhY2UgV0tG b3JtUm90YXRpbmdBY2Nlc3NvcnlQb3BvdmVyIDogV0tSb3RhdGluZ1BvcG92ZXIgPFdLUm90YXRp bmdQb3BvdmVyRGVsZWdhdGU+CistICh2b2lkKWFjY2Vzc29yeURvbmU7CitAZW5kCkluZGV4OiBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLRm9ybVBvcG92ZXIubW0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1Qb3BvdmVyLm1tCShyZXZpc2lv biAwKQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zvcm1Qb3BvdmVyLm1tCSh3 b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsMTcxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0 IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G CisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2ltcG9ydCAiY29u ZmlnLmgiCisjaW1wb3J0ICJXS0NvbnRlbnRWaWV3LmgiCisjaW1wb3J0ICJXS0NvbnRlbnRWaWV3 SW50ZXJhY3Rpb24uaCIKKyNpbXBvcnQgIldLRm9ybVBvcG92ZXIuaCIKKyNpbXBvcnQgIldlYlBh Z2VQcm94eS5oIgorI2ltcG9ydCA8VUlLaXQvVUlQZXJpcGhlcmFsSG9zdC5oPgorI2ltcG9ydCA8 VUlLaXQvVUlXaW5kb3dfUHJpdmF0ZS5oPgorI2ltcG9ydCA8d3RmL1JldGFpblB0ci5oPgorCit1 c2luZyBuYW1lc3BhY2UgV2ViS2l0OworCitAaW1wbGVtZW50YXRpb24gV0tGb3JtUm90YXRpbmdB Y2Nlc3NvcnlQb3BvdmVyIHsKKyAgICBXS0NvbnRlbnRWaWV3ICpfdmlldzsKK30KKworLSAoaWQp aW5pdFdpdGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmlldworeworICAgIHNlbGYgPSBbc3VwZXIg aW5pdFdpdGhWaWV3OnZpZXddOworICAgIGlmICghc2VsZikKKyAgICAgICAgcmV0dXJuIG5pbDsK KyAgICBfdmlldyA9IHZpZXc7CisgICAgc2VsZi5kaXNtaXNzRGVsZWdhdGUgPSBzZWxmOworICAg IHJldHVybiBzZWxmOworfQorCistICh2b2lkKWFjY2Vzc29yeURvbmUKK3sKKyAgICBbX3ZpZXcg YWNjZXNzb3J5RG9uZV07Cit9CisKKy0gKFVJUG9wb3ZlckFycm93RGlyZWN0aW9uKXBvcG92ZXJB cnJvd0RpcmVjdGlvbnMKK3sKKyAgICBVSVBvcG92ZXJBcnJvd0RpcmVjdGlvbiBkaXJlY3Rpb25z ID0gVUlQb3BvdmVyQXJyb3dEaXJlY3Rpb25VcCB8IFVJUG9wb3ZlckFycm93RGlyZWN0aW9uRG93 bjsKKyAgICBpZiAoVUlJbnRlcmZhY2VPcmllbnRhdGlvbklzTGFuZHNjYXBlKFtbVUlBcHBsaWNh dGlvbiBzaGFyZWRBcHBsaWNhdGlvbl0gc3RhdHVzQmFyT3JpZW50YXRpb25dKSAmJiBbW1VJUGVy aXBoZXJhbEhvc3Qgc2hhcmVkSW5zdGFuY2VdIGlzT25TY3JlZW5dKQorICAgICAgICBkaXJlY3Rp b25zID0gVUlQb3BvdmVyQXJyb3dEaXJlY3Rpb25MZWZ0IHwgVUlQb3BvdmVyQXJyb3dEaXJlY3Rp b25SaWdodDsKKyAgICByZXR1cm4gZGlyZWN0aW9uczsKK30KKworLSAodm9pZClwb3BvdmVyV2Fz RGlzbWlzc2VkOihXS1JvdGF0aW5nUG9wb3ZlciAqKXBvcG92ZXIKK3sKKyAgICBbc2VsZiBhY2Nl c3NvcnlEb25lXTsKK30KK0BlbmQKKworQGltcGxlbWVudGF0aW9uIFdLUm90YXRpbmdQb3BvdmVy IHsKKyAgICBXS0NvbnRlbnRWaWV3ICpfdmlldzsKK30KKworLSAoaWQpaW5pdFdpdGhWaWV3OihX S0NvbnRlbnRWaWV3ICopdmlldworeworICAgIHNlbGYgPSBbc3VwZXIgaW5pdF07CisgICAgaWYg KCFzZWxmKQorICAgICAgICByZXR1cm4gbmlsOworCisgICAgX3ZpZXcgPSB2aWV3OworICAgIHNl bGYucHJlc2VudGF0aW9uUG9pbnQgPSBDR1BvaW50WmVybzsKKworICAgIE5TTm90aWZpY2F0aW9u Q2VudGVyICpjZW50ZXIgPSBbTlNOb3RpZmljYXRpb25DZW50ZXIgZGVmYXVsdENlbnRlcl07Cisg ICAgW2NlbnRlciBhZGRPYnNlcnZlcjpzZWxmIHNlbGVjdG9yOkBzZWxlY3Rvcih3aWxsUm90YXRl OikgbmFtZTpVSVdpbmRvd1dpbGxSb3RhdGVOb3RpZmljYXRpb24gb2JqZWN0Om5pbF07CisgICAg W2NlbnRlciBhZGRPYnNlcnZlcjpzZWxmIHNlbGVjdG9yOkBzZWxlY3RvcihkaWRSb3RhdGU6KSBu YW1lOlVJV2luZG93RGlkUm90YXRlTm90aWZpY2F0aW9uIG9iamVjdDpuaWxdOworCisgICAgcmV0 dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpZGVhbGxvYworeworICAgIF92aWV3ID0gbmlsOworCisg ICAgW19wb3BvdmVyQ29udHJvbGxlciBkaXNtaXNzUG9wb3ZlckFuaW1hdGVkOllFU107CisgICAg W19wb3BvdmVyQ29udHJvbGxlciBzZXREZWxlZ2F0ZTpuaWxdOworICAgIHNlbGYucG9wb3ZlckNv bnRyb2xsZXIgPSBuaWw7CisKKyAgICBOU05vdGlmaWNhdGlvbkNlbnRlciAqY2VudGVyID0gW05T Tm90aWZpY2F0aW9uQ2VudGVyIGRlZmF1bHRDZW50ZXJdOworICAgIFtjZW50ZXIgcmVtb3ZlT2Jz ZXJ2ZXI6c2VsZiBuYW1lOlVJV2luZG93V2lsbFJvdGF0ZU5vdGlmaWNhdGlvbiBvYmplY3Q6bmls XTsKKyAgICBbY2VudGVyIHJlbW92ZU9ic2VydmVyOnNlbGYgbmFtZTpVSVdpbmRvd0RpZFJvdGF0 ZU5vdGlmaWNhdGlvbiBvYmplY3Q6bmlsXTsKKworICAgIFtzdXBlciBkZWFsbG9jXTsKK30KKwor LSAoVUlQb3BvdmVyQ29udHJvbGxlciAqKXBvcG92ZXJDb250cm9sbGVyCit7CisgICAgcmV0dXJu IF9wb3BvdmVyQ29udHJvbGxlci5nZXQoKTsKK30KKworLSAodm9pZClzZXRQb3BvdmVyQ29udHJv bGxlcjooVUlQb3BvdmVyQ29udHJvbGxlciAqKXBvcG92ZXJDb250cm9sbGVyCit7CisgICAgaWYg KF9wb3BvdmVyQ29udHJvbGxlciA9PSBwb3BvdmVyQ29udHJvbGxlcikKKyAgICAgICAgcmV0dXJu OworCisgICAgW19wb3BvdmVyQ29udHJvbGxlciBzZXREZWxlZ2F0ZTpuaWxdOworICAgIF9wb3Bv dmVyQ29udHJvbGxlciA9IHBvcG92ZXJDb250cm9sbGVyOworICAgIFtfcG9wb3ZlckNvbnRyb2xs ZXIuIHNldERlbGVnYXRlOnNlbGZdOworfQorCistIChVSVBvcG92ZXJBcnJvd0RpcmVjdGlvbilw b3BvdmVyQXJyb3dEaXJlY3Rpb25zCit7CisgICAgcmV0dXJuIFVJUG9wb3ZlckFycm93RGlyZWN0 aW9uQW55OworfQorCistICh2b2lkKXByZXNlbnRQb3BvdmVyQW5pbWF0ZWQ6KEJPT0wpYW5pbWF0 ZWQKK3sKKyAgICBVSVBvcG92ZXJBcnJvd0RpcmVjdGlvbiBkaXJlY3Rpb25zID0gW3NlbGYgcG9w b3ZlckFycm93RGlyZWN0aW9uc107CisKKyAgICBCT09MIHByZXNlbnRXaXRoUG9pbnQgPSAhQ0dQ b2ludEVxdWFsVG9Qb2ludChzZWxmLnByZXNlbnRhdGlvblBvaW50LCBDR1BvaW50WmVybyk7Cisg ICAgaWYgKHByZXNlbnRXaXRoUG9pbnQpIHsKKyAgICAgICAgQ0dGbG9hdCBzY2FsZSA9IFtfdmll dyBwYWdlXS0+cGFnZVNjYWxlRmFjdG9yKCk7CisgICAgICAgIFtfcG9wb3ZlckNvbnRyb2xsZXIg cHJlc2VudFBvcG92ZXJGcm9tUmVjdDpDR1JlY3RJbnRlZ3JhbChDR1JlY3RNYWtlKHNlbGYucHJl c2VudGF0aW9uUG9pbnQueCAqIHNjYWxlLCBzZWxmLnByZXNlbnRhdGlvblBvaW50LnkgKiBzY2Fs ZSwgMSwgMSkpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlu VmlldzpfdmlldworICAgICAgICAgICAgICAgICAgICAgICAgICBwZXJtaXR0ZWRBcnJvd0RpcmVj dGlvbnM6ZGlyZWN0aW9ucworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgYW5pbWF0ZWQ6YW5pbWF0ZWRdOworICAgIH0gZWxzZSB7CisgICAgICAgIENHUmVjdCBib3Vu ZGluZ0JveE9mRE9NTm9kZSA9IF92aWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmVsZW1lbnRS ZWN0OworICAgICAgICBbX3BvcG92ZXJDb250cm9sbGVyIHByZXNlbnRQb3BvdmVyRnJvbVJlY3Q6 Q0dSZWN0SW50ZWdyYWwoYm91bmRpbmdCb3hPZkRPTU5vZGUpCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGluVmlldzpfdmlldworICAgICAgICAgICAgICAgICAg ICAgICAgICBwZXJtaXR0ZWRBcnJvd0RpcmVjdGlvbnM6ZGlyZWN0aW9ucworICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYW5pbWF0ZWQ6YW5pbWF0ZWRdOworICAgIH0K K30KKworLSAodm9pZClkaXNtaXNzUG9wb3ZlckFuaW1hdGVkOihCT09MKWFuaW1hdGVkCit7Cisg ICAgW19wb3BvdmVyQ29udHJvbGxlciBkaXNtaXNzUG9wb3ZlckFuaW1hdGVkOmFuaW1hdGVkXTsK K30KKworLSAodm9pZCl3aWxsUm90YXRlOihOU05vdGlmaWNhdGlvbiAqKW5vdGlmaWNhdGlvbgor eworICAgIF9pc1JvdGF0aW5nID0gWUVTOworICAgIFtfcG9wb3ZlckNvbnRyb2xsZXIgZGlzbWlz c1BvcG92ZXJBbmltYXRlZDpOT107Cit9CisKKy0gKHZvaWQpZGlkUm90YXRlOihOU05vdGlmaWNh dGlvbiAqKW5vdGlmaWNhdGlvbgoreworICAgIF9pc1JvdGF0aW5nID0gTk87CisgICAgW3NlbGYg cHJlc2VudFBvcG92ZXJBbmltYXRlZDpOT107Cit9CisKKy0gKHZvaWQpcG9wb3ZlckNvbnRyb2xs ZXJEaWREaXNtaXNzUG9wb3ZlcjooVUlQb3BvdmVyQ29udHJvbGxlciAqKXBvcG92ZXJDb250cm9s bGVyCit7CisgICAgaWYgKF9pc1JvdGF0aW5nKQorICAgICAgICByZXR1cm47CisKKyAgICBbX2Rp c21pc3NEZWxlZ2F0ZSBwb3BvdmVyV2FzRGlzbWlzc2VkOnNlbGZdOworfQorCitAZW5kCisKSW5k ZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tGb3JtU2VsZWN0Q29udHJvbC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvV0tGb3JtU2VsZWN0Q29u dHJvbC5oCShyZXZpc2lvbiAwKQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Zv cm1TZWxlY3RDb250cm9sLmgJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSwzMiBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbXBvcnQgIldLRm9ybVBlcmlwaGVyYWwuaCIKKworQGNsYXNzIFdLQ29udGVudFZp ZXc7CisKK0BpbnRlcmZhY2UgV0tGb3JtU2VsZWN0Q29udHJvbCA6IE5TT2JqZWN0PFdLRm9ybVBl cmlwaGVyYWw+CisrIChXS0Zvcm1TZWxlY3RDb250cm9sICopY3JlYXRlUGVyaXBoZXJhbFdpdGhW aWV3OihXS0NvbnRlbnRWaWV3ICopdmlldzsKK0BlbmQKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9pb3MvV2ViUGFnZVByb3h5SU9TLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9pb3MvV2ViUGFnZVByb3h5SU9TLm1tCShyZXZpc2lvbiAxNjQ3NTMpCisr KyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dlYlBhZ2VQcm94eUlPUy5tbQkod29ya2lu ZyBjb3B5KQpAQCAtNDgyLDYgKzQ4MiwxNiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6c3RvcEFzc2lz dGluZ05vZGUoKQogICAgIG1fcGFnZUNsaWVudC5zdG9wQXNzaXN0aW5nTm9kZSgpOwogfQogCit2 b2lkIFdlYlBhZ2VQcm94eTo6c2V0QXNzaXN0ZWROb2RlVmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1 ZSkKK3sKKyAgICBwcm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6U2V0QXNzaXN0ZWRO b2RlVmFsdWUodmFsdWUpLCBtX3BhZ2VJRCk7Cit9CisKK3ZvaWQgV2ViUGFnZVByb3h5OjpzZXRB c3Npc3RlZE5vZGVWYWx1ZUFzTnVtYmVyKGRvdWJsZSB2YWx1ZSkKK3sKKyAgICBwcm9jZXNzKCku c2VuZChNZXNzYWdlczo6V2ViUGFnZTo6U2V0QXNzaXN0ZWROb2RlVmFsdWVBc051bWJlcih2YWx1 ZSksIG1fcGFnZUlEKTsKK30KKwogdm9pZCBXZWJQYWdlUHJveHk6OmRpZFBlcmZvcm1EaWN0aW9u YXJ5TG9va3VwKGNvbnN0IEF0dHJpYnV0ZWRTdHJpbmcmLCBjb25zdCBEaWN0aW9uYXJ5UG9wdXBJ bmZvJikKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwpJbmRleDogU291cmNlL1dlYktpdDIvV2Vi S2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24gMTY0NzUzKQor KysgU291cmNlL1dlYktpdDIvV2ViS2l0Mi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3Jr aW5nIGNvcHkpCkBAIC0xNDAwLDYgKzE0MDAsMTAgQEAKIAkJQzU4Q0RGMkUxODg3NjA5RjAwODcx NTM2IC8qIEludGVyYWN0aW9uSW5mb3JtYXRpb25BdFBvc2l0aW9uLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNThDREYyQzE4ODc2MDlGMDA4NzE1MzYg LyogSW50ZXJhY3Rpb25JbmZvcm1hdGlvbkF0UG9zaXRpb24uaCAqLzsgfTsKIAkJQzU5QzRBNTgx OEI4MTE3NDAwN0JEQ0I2IC8qIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM1OUM0QTU2MThCODExNzQwMDdC RENCNiAvKiBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5jcHAgKi87IH07CiAJCUM1OUM0QTU5MThC ODExNzQwMDdCRENCNiAvKiBBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU5QzRBNTcxOEI4MTE3NDAwN0JEQ0I2 IC8qIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmggKi87IH07CisJCUM1OUM0QTYzMThCRDk3MjYw MDdCRENCNiAvKiBXS0Zvcm1QZXJpcGhlcmFsLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBDNTlDNEE2MjE4QkQ5NzI2MDA3QkRDQjYgLyogV0tGb3JtUGVy aXBoZXJhbC5oICovOyB9OworCQlDNTlDNEE2NTE4QkQ5NzZDMDA3QkRDQjYgLyogV0tGb3JtSW5w dXRDb250cm9sLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBDNTlDNEE2NDE4QkQ5NzZDMDA3QkRDQjYgLyogV0tGb3JtSW5wdXRDb250cm9sLmggKi87IH07 CisJCUM1OUM0QTY3MThCRDk3QUQwMDdCRENCNiAvKiBXS0Zvcm1TZWxlY3RDb250cm9sLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNTlDNEE2NjE4QkQ5 N0FEMDA3QkRDQjYgLyogV0tGb3JtU2VsZWN0Q29udHJvbC5oICovOyB9OworCQlDNTlDNEE2QjE4 QkQ5ODU0MDA3QkRDQjYgLyogV0tGb3JtSW5wdXRDb250cm9sLm1tIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU5QzRBNkExOEJEOTg1NDAwN0JEQ0I2IC8q IFdLRm9ybUlucHV0Q29udHJvbC5tbSAqLzsgfTsKIAkJQzVFMUFGRTgxNkIyMEI2NzAwNkNDMUYy IC8qIFdLV2ViQXJjaGl2ZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBCQzMyOURBNTE2QUNFNUE5MDAzMTZERTIgLyogV0tXZWJBcmNoaXZlLmNwcCAq LzsgfTsKIAkJQzVFMUFGRTkxNkIyMEI3NTAwNkNDMUYyIC8qIFdLV2ViQXJjaGl2ZS5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQkMzMjlEQTYxNkFDRTVB OTAwMzE2REUyIC8qIFdLV2ViQXJjaGl2ZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCUM1RTFBRkVBMTZCMjBCN0IwMDZDQzFGMiAvKiBXS1dlYkFy Y2hpdmVSZXNvdXJjZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBCQzMyOURBOTE2QUNFNUJGMDAzMTZERTIgLyogV0tXZWJBcmNoaXZlUmVzb3VyY2Uu Y3BwICovOyB9OwpAQCAtMTQwOCw2ICsxNDEyLDggQEAKIAkJQzVFMUFGRUQxNkIyMTAxNzAwNkND MUYyIC8qIFdlYkFyY2hpdmUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEJDMzI5RDlBMTZBQ0NFOTkwMDMxNkRFMiAvKiBXZWJBcmNoaXZlLmggKi87IH07 CiAJCUM1RTFBRkVFMTZCMjEwMjUwMDZDQzFGMiAvKiBXZWJBcmNoaXZlUmVzb3VyY2UuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQkMzMjlEOUUxNkFD RDQ3ODAwMzE2REUyIC8qIFdlYkFyY2hpdmVSZXNvdXJjZS5jcHAgKi87IH07CiAJCUM1RTFBRkVG MTZCMjEwMjkwMDZDQzFGMiAvKiBXZWJBcmNoaXZlUmVzb3VyY2UuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEJDMzI5RDlGMTZBQ0Q0NzgwMDMxNkRFMiAv KiBXZWJBcmNoaXZlUmVzb3VyY2UuaCAqLzsgfTsKKwkJQzVGQTY1NzYxOEJFODQ2MzAwQ0U0QjdG IC8qIFdLRm9ybVBvcG92ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEM1RkE2NTc0MThCRTg0NjMwMENFNEI3RiAvKiBXS0Zvcm1Qb3BvdmVyLmggKi87 IH07CisJCUM1RkE2NTc3MThCRTg0NjMwMENFNEI3RiAvKiBXS0Zvcm1Qb3BvdmVyLm1tIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzVGQTY1NzUxOEJFODQ2 MzAwQ0U0QjdGIC8qIFdLRm9ybVBvcG92ZXIubW0gKi87IH07CiAJCUNENUM2NkEwMTM0QjlEMzgw MDRGRTJBOCAvKiBJbmplY3RlZEJ1bmRsZVBhZ2VGdWxsU2NyZWVuQ2xpZW50LmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IENENUM2NjlFMTM0QjlEMzYw MDRGRTJBOCAvKiBJbmplY3RlZEJ1bmRsZVBhZ2VGdWxsU2NyZWVuQ2xpZW50LmNwcCAqLzsgfTsK IAkJQ0Q1QzY2QTExMzRCOUQzODAwNEZFMkE4IC8qIEluamVjdGVkQnVuZGxlUGFnZUZ1bGxTY3Jl ZW5DbGllbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IENENUM2NjlGMTM0QjlEMzcwMDRGRTJBOCAvKiBJbmplY3RlZEJ1bmRsZVBhZ2VGdWxsU2NyZWVu Q2xpZW50LmggKi87IH07CiAJCUNENjdEMzBFMTVDMDhGOUEwMDg0M0FERiAvKiBJbmplY3RlZEJ1 bmRsZVBhZ2VEaWFnbm9zdGljTG9nZ2luZ0NsaWVudC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRDY3RDMwODE1QzA3QkUwMDA4NDNBREYgLyogSW5q ZWN0ZWRCdW5kbGVQYWdlRGlhZ25vc3RpY0xvZ2dpbmdDbGllbnQuY3BwICovOyB9OwpAQCAtMzIy NCw2ICszMjMwLDEyIEBACiAJCUM1OENERjJDMTg4NzYwOUYwMDg3MTUzNiAvKiBJbnRlcmFjdGlv bkluZm9ybWF0aW9uQXRQb3NpdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3NpdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlDNTlDNEE1NjE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3Jt YXRpb24uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXNzaXN0ZWRO b2RlSW5mb3JtYXRpb24uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDNTlDNEE1 NzE4QjgxMTc0MDA3QkRDQjYgLyogQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQzU5QzRBNjIxOEJEOTcyNjAwN0JEQ0I2IC8qIFdLRm9y bVBlcmlwaGVyYWwuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gV0tGb3JtUGVy aXBoZXJhbC5oOyBwYXRoID0gaW9zL1dLRm9ybVBlcmlwaGVyYWwuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJQzU5QzRBNjQxOEJEOTc2QzAwN0JEQ0I2IC8qIFdLRm9ybUlucHV0Q29u dHJvbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBXS0Zvcm1JbnB1dENvbnRy b2wuaDsgcGF0aCA9IGlvcy9XS0Zvcm1JbnB1dENvbnRyb2wuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJQzU5QzRBNjYxOEJEOTdBRDAwN0JEQ0I2IC8qIFdLRm9ybVNlbGVjdENvbnRy b2wuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gV0tGb3JtU2VsZWN0Q29udHJv bC5oOyBwYXRoID0gaW9zL1dLRm9ybVNlbGVjdENvbnRyb2wuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJQzU5QzRBNkExOEJEOTg1NDAwN0JEQ0I2IC8qIFdLRm9ybUlucHV0Q29udHJv bC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgbmFtZSA9IFdLRm9ybUlucHV0 Q29udHJvbC5tbTsgcGF0aCA9IGlvcy9XS0Zvcm1JbnB1dENvbnRyb2wubW07IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCUM1RkE2NTc0MThCRTg0NjMwMENFNEI3RiAvKiBXS0Zvcm1Qb3Bv dmVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdLRm9ybVBvcG92ZXIuaDsg cGF0aCA9IGlvcy9XS0Zvcm1Qb3BvdmVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CUM1RkE2NTc1MThCRTg0NjMwMENFNEI3RiAvKiBXS0Zvcm1Qb3BvdmVyLm1tICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1lID0gV0tGb3JtUG9wb3Zlci5tbTsgcGF0aCA9IGlv cy9XS0Zvcm1Qb3BvdmVyLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDRDVDNjY5 RTEzNEI5RDM2MDA0RkUyQTggLyogSW5qZWN0ZWRCdW5kbGVQYWdlRnVsbFNjcmVlbkNsaWVudC5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBJbmplY3RlZEJ1bmRsZVBh Z2VGdWxsU2NyZWVuQ2xpZW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQ0Q1 QzY2OUYxMzRCOUQzNzAwNEZFMkE4IC8qIEluamVjdGVkQnVuZGxlUGFnZUZ1bGxTY3JlZW5DbGll bnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5qZWN0ZWRCdW5kbGVQYWdl RnVsbFNjcmVlbkNsaWVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDRDY3RDMw ODE1QzA3QkUwMDA4NDNBREYgLyogSW5qZWN0ZWRCdW5kbGVQYWdlRGlhZ25vc3RpY0xvZ2dpbmdD bGllbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSW5qZWN0ZWRC dW5kbGVQYWdlRGlhZ25vc3RpY0xvZ2dpbmdDbGllbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwpAQCAtNDMxNCw2ICs0MzI2LDEyIEBACiAJCQkJMEZDQjRFM0QxOEJCRTA0NDAwMEZD RkM5IC8qIFdLQ29udGVudFZpZXcubW0gKi8sCiAJCQkJMEZDQjRFNkExOEJCRjI2QTAwMEZDRkM5 IC8qIFdLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5oICovLAogCQkJCTBGQ0I0RTZCMThCQkYyNkEw MDBGQ0ZDOSAvKiBXS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24ubW0gKi8sCisJCQkJQzU5QzRBNjQx OEJEOTc2QzAwN0JEQ0I2IC8qIFdLRm9ybUlucHV0Q29udHJvbC5oICovLAorCQkJCUM1OUM0QTZB MThCRDk4NTQwMDdCRENCNiAvKiBXS0Zvcm1JbnB1dENvbnRyb2wubW0gKi8sCisJCQkJQzU5QzRB NjIxOEJEOTcyNjAwN0JEQ0I2IC8qIFdLRm9ybVBlcmlwaGVyYWwuaCAqLywKKwkJCQlDNUZBNjU3 NDE4QkU4NDYzMDBDRTRCN0YgLyogV0tGb3JtUG9wb3Zlci5oICovLAorCQkJCUM1RkE2NTc1MThC RTg0NjMwMENFNEI3RiAvKiBXS0Zvcm1Qb3BvdmVyLm1tICovLAorCQkJCUM1OUM0QTY2MThCRDk3 QUQwMDdCRENCNiAvKiBXS0Zvcm1TZWxlY3RDb250cm9sLmggKi8sCiAJCQkJMEZDQjRFM0YxOEJC RTA0NDAwMEZDRkM5IC8qIFdLR2VvbG9jYXRpb25Qcm92aWRlcklPUy5oICovLAogCQkJCTBGQ0I0 RTQwMThCQkUwNDQwMDBGQ0ZDOSAvKiBXS0dlb2xvY2F0aW9uUHJvdmlkZXJJT1MubW0gKi8sCiAJ CQkJMEZDQjRFNDExOEJCRTA0NDAwMEZDRkM5IC8qIFdLR2VvbG9jYXRpb25Qcm92aWRlcklPU09i akNTZWN1cml0eU9yaWdpbi5tbSAqLywKQEAgLTY1NDgsNiArNjU2Niw3IEBACiAJCQkJMUFCNDc0 RTIxODRENDQ4MDAwNTFCNjIyIC8qIFdLQnVuZGxlUGFnZUZvcm1DbGllbnQuaCBpbiBIZWFkZXJz ICovLAogCQkJCTFBMkQ4MkE1MTI3RjRFQUIwMDFFQjk2MiAvKiBOUE9iamVjdE1lc3NhZ2VSZWNl aXZlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMUEyRDg0M0ExMjdGNjVENTAwMUVCOTYyIC8qIE5Q T2JqZWN0TWVzc2FnZVJlY2VpdmVyTWVzc2FnZXMuaCBpbiBIZWFkZXJzICovLAorCQkJCUM1OUM0 QTY1MThCRDk3NkMwMDdCRENCNiAvKiBXS0Zvcm1JbnB1dENvbnRyb2wuaCBpbiBIZWFkZXJzICov LAogCQkJCTFBMkQ4MkE3MTI3RjRFQUIwMDFFQjk2MiAvKiBOUE9iamVjdFByb3h5LmggaW4gSGVh ZGVycyAqLywKIAkJCQkyRDZCMzcxQjE4QTk2N0FEMDA0MkFFODAgLyogV0tUaHVtYm5haWxWaWV3 LmggaW4gSGVhZGVycyAqLywKIAkJCQkxQTJEODJBOTEyN0Y0RUFCMDAxRUI5NjIgLyogTlBSZW1v dGVPYmplY3RNYXAuaCBpbiBIZWFkZXJzICovLApAQCAtNjU2Nyw2ICs2NTg2LDcgQEAKIAkJCQkx QTkwQzIzNzEyNjUwNzE3MDAzRTQ0RDQgLyogUGFnZU92ZXJsYXkuaCBpbiBIZWFkZXJzICovLAog CQkJCUM1NzRBNTgxMTJFNjY2ODEwMDJERkU5OCAvKiBQYXN0ZWJvYXJkVHlwZXMuaCBpbiBIZWFk ZXJzICovLAogCQkJCUUxOTU4MkQzMTUzQ0JGRDcwMEI2MDg3NSAvKiBQREZLaXRJbXBvcnRzLmgg aW4gSGVhZGVycyAqLywKKwkJCQlDNTlDNEE2MzE4QkQ5NzI2MDA3QkRDQjYgLyogV0tGb3JtUGVy aXBoZXJhbC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNTFGQ0IxODkxN0JCRkUwMzAwMzk0Q0Q4IC8q IFN5bmNocm9ub3VzTmV0d29ya0xvYWRlckNsaWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMUFF MDBENEYxODJENkY1MDAwMDg3REQ3IC8qIFdLQnJvd3NpbmdDb250ZXh0SGFuZGxlSW50ZXJuYWwu aCBpbiBIZWFkZXJzICovLAogCQkJCUJDQzQzQUJCMTI3Qjk1REMwMDMxN0YxNiAvKiBQbGF0Zm9y bVBvcHVwTWVudURhdGEuaCBpbiBIZWFkZXJzICovLApAQCAtNjczMyw2ICs2NzUzLDcgQEAKIAkJ CQkyNjg0MDU1MzE4Qjg2RUQ2MDAyMkMzOEIgLyogVmlld1VwZGF0ZURpc3BhdGNoZXJNZXNzYWdl cy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNTE2QTRBNUQxMjBBMkNDRDAwQzA1QjdGIC8qIEFQSUVy cm9yLmggaW4gSGVhZGVycyAqLywKIAkJCQkxQTQzM0YwRDExM0M1M0REMDBGQUNERTkgLyogV2Vi RXJyb3JzLmggaW4gSGVhZGVycyAqLywKKwkJCQlDNTlDNEE2NzE4QkQ5N0FEMDA3QkRDQjYgLyog V0tGb3JtU2VsZWN0Q29udHJvbC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQkMwMzJEQjkxMEY0Mzgw RjAwNThDMTVBIC8qIFdlYkV2ZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzAzMkRCQjEwRjQz ODBGMDA1OEMxNUEgLyogV2ViRXZlbnRDb252ZXJzaW9uLmggaW4gSGVhZGVycyAqLywKIAkJCQlC QzExMUI1RDExMkY2Mjk4MDAzMzdCQUIgLyogV2ViRXZlbnRGYWN0b3J5LmggaW4gSGVhZGVycyAq LywKQEAgLTY4MzQsNiArNjg1NSw3IEBACiAJCQkJMUFDMTMzODAxODU5MEFFNDAwRjNFQzA1IC8q IFJlbW90ZU9iamVjdFJlZ2lzdHJ5LmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzMwNjZCRjEyNUE0 NDIxMDBFNzEyNzggLyogV2ViUHJvY2Vzc01lc3NhZ2VzLmggaW4gSGVhZGVycyAqLywKIAkJCQlC QzAzMkRENTEwRjQzODlGMDA1OEMxNUEgLyogV2ViUHJvY2Vzc1Byb3h5LmggaW4gSGVhZGVycyAq LywKKwkJCQlDNUZBNjU3NjE4QkU4NDYzMDBDRTRCN0YgLyogV0tGb3JtUG9wb3Zlci5oIGluIEhl YWRlcnMgKi8sCiAJCQkJNzVBOEQyRDYxODdEMUMwRTAwQzM5QzlFIC8qIFdLU2Vzc2lvbkludGVy bmFsLmggaW4gSGVhZGVycyAqLywKIAkJCQk1MTAzMkYxOTE4MEY3M0JCMDA5NjFCQjcgLyogV2Vi VG9EYXRhYmFzZVByb2Nlc3NDb25uZWN0aW9uLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQ0VFN0FE MTEyODE3OTg4MDA5ODI3REEgLyogV2ViUHJvY2Vzc1Byb3h5TWVzc2FnZXMuaCBpbiBIZWFkZXJz ICovLApAQCAtNzg2MSw2ICs3ODgzLDcgQEAKIAkJCQkxQTkxMDA3MjEyNjY3NUM0MDAxODQyRjUg LyogRmluZEluZGljYXRvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCQ0U4MUQ4QzEzMTlGN0VG MDAyNDE5MTAgLyogRm9udEluZm8uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzc4RTFBNDkxODIw OENENjAwMzEwMDdBIC8qIFdLTlNTdHJpbmcubW0gaW4gU291cmNlcyAqLywKKwkJCQlDNUZBNjU3 NzE4QkU4NDYzMDBDRTRCN0YgLyogV0tGb3JtUG9wb3Zlci5tbSBpbiBTb3VyY2VzICovLAogCQkJ CUJDMDZGNDMwMTJEQkI5QjYwMDJENzhERSAvKiBHZW9sb2NhdGlvblBlcm1pc3Npb25SZXF1ZXN0 TWFuYWdlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCQzA2RjQ0QjEyREJEMUY1MDAyRDc4REUg LyogR2VvbG9jYXRpb25QZXJtaXNzaW9uUmVxdWVzdE1hbmFnZXJQcm94eS5jcHAgaW4gU291cmNl cyAqLywKIAkJCQlCQzA2RjQzQjEyREJDQ0ZCMDAyRDc4REUgLyogR2VvbG9jYXRpb25QZXJtaXNz aW9uUmVxdWVzdFByb3h5LmNwcCBpbiBTb3VyY2VzICovLApAQCAtNzk4Miw2ICs4MDA1LDcgQEAK IAkJCQkyRDJBREYwOTE2MzYyREQ1MDAxOTdFNDcgLyogUERGUGx1Z2luVGV4dEFubm90YXRpb24u bW0gaW4gU291cmNlcyAqLywKIAkJCQkzNzFCMzJERDE4NEQ2NzQ5MDAxM0UyQjIgLyogV0tOU1VS TFByb3RlY3Rpb25TcGFjZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUJDQzQzQUJBMTI3Qjk1REMw MDMxN0YxNiAvKiBQbGF0Zm9ybVBvcHVwTWVudURhdGEuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJ QzU5QzRBNkIxOEJEOTg1NDAwN0JEQ0I2IC8qIFdLRm9ybUlucHV0Q29udHJvbC5tbSBpbiBTb3Vy Y2VzICovLAogCQkJCTFBNkZCN0QyMTFFNjUxRTIwMERCMTM3MSAvKiBQbHVnaW4uY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJMzFBNjdFMEMxNjVCMkE5OTAwNkNCQTY2IC8qIFBsdWdJbkF1dG9TdGFy dFByb3ZpZGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTFBOEVGNENDMTI1MjQwMzcwMEY3MDY3 RiAvKiBQbHVnaW5Db250cm9sbGVyUHJveHkuY3BwIGluIFNvdXJjZXMgKi8sCkluZGV4OiBTb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHJldmlzaW9uIDE2NDc1 MykKKysrIFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHdvcmtp bmcgY29weSkKQEAgLTQ2NSw2ICs0NjUsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBzdGFydEludGVy YWN0aW9uV2l0aEVsZW1lbnRBdFBvc2l0aW9uKGNvbnN0IFdlYkNvcmU6OkludFBvaW50Jik7CiAg ICAgdm9pZCBzdG9wSW50ZXJhY3Rpb24oKTsKICAgICB2b2lkIHBlcmZvcm1BY3Rpb25PbkVsZW1l bnQodWludDMyX3QgYWN0aW9uKTsKKyAgICB2b2lkIHNldEFzc2lzdGVkTm9kZVZhbHVlKGNvbnN0 IFN0cmluZyYpOworICAgIHZvaWQgc2V0QXNzaXN0ZWROb2RlVmFsdWVBc051bWJlcihkb3VibGUp OwogI2VuZGlmCiAKICAgICBOb3RpZmljYXRpb25QZXJtaXNzaW9uUmVxdWVzdE1hbmFnZXIqIG5v dGlmaWNhdGlvblBlcm1pc3Npb25SZXF1ZXN0TWFuYWdlcigpOwpJbmRleDogU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW4KPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW4JKHJl dmlzaW9uIDE2NDc1MykKKysrIFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQ YWdlLm1lc3NhZ2VzLmluCSh3b3JraW5nIGNvcHkpCkBAIC02Myw2ICs2Myw4IEBAIG1lc3NhZ2Vz IC0+IFdlYlBhZ2UgTGVnYWN5UmVjZWl2ZXIgewogICAgIFN0YXJ0SW50ZXJhY3Rpb25XaXRoRWxl bWVudEF0UG9zaXRpb24oV2ViQ29yZTo6SW50UG9pbnQgcG9pbnQpCiAgICAgU3RvcEludGVyYWN0 aW9uKCkKICAgICBQZXJmb3JtQWN0aW9uT25FbGVtZW50KHVpbnQzMl90IGFjdGlvbikKKyAgICBT ZXRBc3Npc3RlZE5vZGVWYWx1ZShTdHJpbmcgdmFsdWUpCisgICAgU2V0QXNzaXN0ZWROb2RlVmFs dWVBc051bWJlcihkb3VibGUgdmFsdWUpCiAjZW5kaWYKIAogI2lmIEVOQUJMRShUT1VDSF9FVkVO VFMpCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJ T1MubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL2lv cy9XZWJQYWdlSU9TLm1tCShyZXZpc2lvbiAxNjQ3NTMpCisrKyBTb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0JKHdvcmtpbmcgY29weSkKQEAgLTM5Myw2 ICszOTMsMjcgQEAgdm9pZCBXZWJQYWdlOjpibHVyQXNzaXN0ZWROb2RlKCkKICAgICAgICAgdG9F bGVtZW50KG1fYXNzaXN0ZWROb2RlLmdldCgpKS0+Ymx1cigpOwogfQogCit2b2lkIFdlYlBhZ2U6 OnNldEFzc2lzdGVkTm9kZVZhbHVlKGNvbnN0IFN0cmluZyYgdmFsdWUpCit7CisgICAgaWYgKCFt X2Fzc2lzdGVkTm9kZSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmIChpc0hUTUxJbnB1dEVsZW1l bnQobV9hc3Npc3RlZE5vZGUuZ2V0KCkpKSB7CisgICAgICAgIEhUTUxJbnB1dEVsZW1lbnQgKmVs ZW1lbnQgPSB0b0hUTUxJbnB1dEVsZW1lbnQobV9hc3Npc3RlZE5vZGUuZ2V0KCkpOworICAgICAg ICBlbGVtZW50LT5zZXRWYWx1ZSh2YWx1ZSwgRGlzcGF0Y2hJbnB1dEFuZENoYW5nZUV2ZW50KTsK KyAgICB9CisgICAgLy8gRklYTUU6IHNob3VsZCBhbHNvIGhhbmRsZSB0aGUgY2FzZSBvZiBIVE1M U2VsZWN0RWxlbWVudC4KK30KKwordm9pZCBXZWJQYWdlOjpzZXRBc3Npc3RlZE5vZGVWYWx1ZUFz TnVtYmVyKGRvdWJsZSB2YWx1ZSkKK3sKKyAgICBpZiAoIW1fYXNzaXN0ZWROb2RlKQorICAgICAg ICByZXR1cm47CisgICAgaWYgKGlzSFRNTElucHV0RWxlbWVudChtX2Fzc2lzdGVkTm9kZS5nZXQo KSkpIHsKKyAgICAgICAgSFRNTElucHV0RWxlbWVudCAqZWxlbWVudCA9IHRvSFRNTElucHV0RWxl bWVudChtX2Fzc2lzdGVkTm9kZS5nZXQoKSk7CisgICAgICAgIGVsZW1lbnQtPnNldFZhbHVlQXNO dW1iZXIodmFsdWUsIEFTU0VSVF9OT19FWENFUFRJT04sIERpc3BhdGNoSW5wdXRBbmRDaGFuZ2VF dmVudCk7CisgICAgfQorfQorCiBzdGF0aWMgRmxvYXRRdWFkIGlubmVyRnJhbWVRdWFkKEZyYW1l KiBmcmFtZSwgTm9kZSogYXNzaXN0ZWROb2RlKQogewogICAgIGZyYW1lLT5kb2N1bWVudCgpLT51 cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKTsK 225579 2014-03-01 18:39:09 -0800 2014-03-03 12:02:46 -0800 Patch3 selectelements.txt text/plain 58074 enrica SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE2NDkzNCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDE0LTAzLTAxICBFbnJpY2Eg Q2FzdWNjaSAgPGVucmljYUBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXZWJLaXQyXSBGb3Jt IGNvbnRyb2xzIGhhbmRsaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xMjkzNDQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzE2MDUzNjQzPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVwZGF0ZXMgbG9j YWxpemFibGUgc3RyaW5ncyBhbmQgYWRkcyBzb21lIGV4cG9ydHMuCisKKyAgICAgICAgKiBFbmds aXNoLmxwcm9qL0xvY2FsaXphYmxlLnN0cmluZ3M6CisgICAgICAgICogV2ViQ29yZS5leHAuaW46 CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorCiAyMDE0LTAz LTAxICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgQnVpbGQgZml4 LgpJbmRleDogU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4KPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4JKHJldmlzaW9uIDE2NDkzNCkKKysrIFNvdXJjZS9X ZWJDb3JlL1dlYkNvcmUuZXhwLmluCSh3b3JraW5nIGNvcHkpCkBAIC0yNTQsNiArMjU0LDExIEBA IF9fWk43V2ViQ29yZTE1Rm9jdXNDb250cm9sbGVyMjBuZXh0Rm9jdXMKIF9fWk43V2ViQ29yZTE1 Rm9jdXNDb250cm9sbGVyMjRwcmV2aW91c0ZvY3VzYWJsZUVsZW1lbnRFTlNfMjBGb2N1c05hdmln YXRpb25TY29wZUVQTlNfNE5vZGVFUE5TXzEzS2V5Ym9hcmRFdmVudEUKIF9fWk5LN1dlYkNvcmU5 RmxvYXRSZWN0OGNvbnRhaW5zRVJLUzBfCiBfX1pOSzdXZWJDb3JlMTFIVE1MRWxlbWVudDV0aXRs ZUV2CitfX1pON1dlYkNvcmU5SFRNTE5hbWVzMTFvcHRncm91cFRhZ0UKK19fWk5LN1dlYkNvcmUx OUhUTUxPcHRHcm91cEVsZW1lbnQxNGdyb3VwTGFiZWxUZXh0RXYKK19fWk43V2ViQ29yZTE3SFRN TE9wdGlvbkVsZW1lbnQ4c2VsZWN0ZWRFdgorX19aTjdXZWJDb3JlOUhUTUxOYW1lczEyZGlzYWJs ZWRBdHRyRQorX19aTjdXZWJDb3JlMTdIVE1MU2VsZWN0RWxlbWVudDIwb3B0aW9uU2VsZWN0ZWRC eVVzZXJFaWJiCiBfX1pOSzdXZWJDb3JlMTdIVE1MT3B0aW9uRWxlbWVudDR0ZXh0RXYKIF9fWk5L N1dlYkNvcmUxN0hUTUxTZWxlY3RFbGVtZW50MTNzZWxlY3RlZEluZGV4RXYKIF9fWk5LN1dlYkNv cmUxNkhUTUxJbnB1dEVsZW1lbnQxM2lzU2VhcmNoRmllbGRFdgpJbmRleDogU291cmNlL1dlYkNv cmUvRW5nbGlzaC5scHJvai9Mb2NhbGl6YWJsZS5zdHJpbmdzCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL0VuZ2xpc2gubHByb2ovTG9jYWxpemFibGUuc3RyaW5ncwkocmV2aXNpb24gMTY0 OTM0KQorKysgU291cmNlL1dlYkNvcmUvRW5nbGlzaC5scHJvai9Mb2NhbGl6YWJsZS5zdHJpbmdz CSh3b3JraW5nIGNvcHkpCkBAIC0zMTYsNiArMzE2LDkgQEAKIC8qIE5vIEd1ZXNzZXMgRm91bmQg Y29udGV4dCBtZW51IGl0ZW0gKi8KICJObyBHdWVzc2VzIEZvdW5kIiA9ICJObyBHdWVzc2VzIEZv dW5kIjsKIAorLyogRW1wdHkgc2VsZWN0IGxpc3QgKi8KKyJObyBPcHRpb25zIFNlbGVjdCBQb3Bv dmVyIiA9ICJObyBPcHRpb25zIjsKKwogLyogTGFiZWwgZm9yIG9ubHkgaXRlbSBpbiBtZW51IHRo YXQgYXBwZWFycyB3aGVuIGNsaWNraW5nIG9uIHRoZSBzZWFyY2ggZmllbGQgaW1hZ2UsIHdoZW4g bm8gc2VhcmNoZXMgaGF2ZSBiZWVuIHBlcmZvcm1lZCAqLwogIk5vIHJlY2VudCBzZWFyY2hlcyIg PSAiTm8gcmVjZW50IHNlYXJjaGVzIjsKIApJbmRleDogU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24gMTY0OTM0KQorKysgU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNv cHkpCkBAIC0zODMyLDcgKzM4MzIsNyBAQAogCQlBODEzNjlEQTA5NzM3NEY2MDBENzQ0NjMgLyog SFRNTE9wdGlvbnNDb2xsZWN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBBODEzNjlCRTA5NzM3NEY1MDBENzQ0NjMgLyogSFRNTE9wdGlvbnNDb2xs ZWN0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJQTgxMzY5REMwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxPcHRpb25FbGVtZW50LmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBODEzNjlDMDA5NzM3NEY1 MDBENzQ0NjMgLyogSFRNTE9wdGlvbkVsZW1lbnQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBODEzNjlERDA5NzM3NEY2MDBENzQ0NjMgLyogSFRN TE9wdGlvbkVsZW1lbnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQTgxMzY5QzEwOTczNzRGNTAwRDc0NDYzIC8qIEhUTUxPcHRpb25FbGVtZW50LmNw cCAqLzsgfTsKLQkJQTgxMzY5REUwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxPcHRHcm91cEVsZW1l bnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4MTM2 OUMyMDk3Mzc0RjUwMEQ3NDQ2MyAvKiBIVE1MT3B0R3JvdXBFbGVtZW50LmggKi87IH07CisJCUE4 MTM2OURFMDk3Mzc0RjYwMEQ3NDQ2MyAvKiBIVE1MT3B0R3JvdXBFbGVtZW50LmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBODEzNjlDMjA5NzM3NEY1MDBE NzQ0NjMgLyogSFRNTE9wdEdyb3VwRWxlbWVudC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCUE4MTM2OURGMDk3Mzc0RjYwMEQ3NDQ2MyAvKiBIVE1M T3B0R3JvdXBFbGVtZW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEE4MTM2OUMzMDk3Mzc0RjUwMEQ3NDQ2MyAvKiBIVE1MT3B0R3JvdXBFbGVtZW50 LmNwcCAqLzsgfTsKIAkJQTgxMzY5RTAwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVt ZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBODEz NjlDNDA5NzM3NEY1MDBENzQ0NjMgLyogSFRNTExlZ2VuZEVsZW1lbnQuaCAqLzsgfTsKIAkJQTgx MzY5RTEwOTczNzRGNjAwRDc0NDYzIC8qIEhUTUxMZWdlbmRFbGVtZW50LmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4MTM2OUM1MDk3Mzc0RjUwMEQ3 NDQ2MyAvKiBIVE1MTGVnZW5kRWxlbWVudC5jcHAgKi87IH07CkluZGV4OiBTb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCShyZXZp c2lvbiAxNjQ5MzQpCisrKyBTb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkK QEAgLTEsMyArMSw4NSBAQAorMjAxNC0wMy0wMSAgRW5yaWNhIENhc3VjY2kgIDxlbnJpY2FAYXBw bGUuY29tPgorCisgICAgICAgIFtpT1MgV2ViS2l0Ml0gRm9ybSBjb250cm9scyBoYW5kbGluZwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI5MzQ0Cisg ICAgICAgIDxyZGFyOi8vcHJvYmxlbS8xNjA1MzY0Mz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgc3VwcG9ydCBmb3Igc2VsZWN0IGVsZW1l bnRzIG9uIGlPUy4KKyAgICAgICAgVGhlcmUgaXMgZnVsbCBzdXBwb3J0IG9uIGlQYWQsIHdoaWxl IG9uIGlQaG9uZSBpdCBpcworICAgICAgICBzdGlsbCBsaW1pdGVkIHRvIHNpbmdsZSBzZWxlY3Qg d2l0aCBubyBncm91cHMuCisgICAgICAgIFRoZSBjaGFuZ2UgYWxzbyBmaXhlcyB0aGUgaXNzdWUg b2YgdGhlIGtleWJvYXJkIGFwcGVhcmluZworICAgICAgICBvbiBzY3JlZW4gZm9yIHR5cGVzIG9m IGVsZW1lbnRzIHRoYXQgYXJlIGltcGxlbWVudGVkIHdpdGgKKyAgICAgICAgYSBwb3BvdmVyIG9y IGEgcGlja2VyLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXQyL21lc3NhZ2VzLnB5OgorICAg ICAgICAqIFNoYXJlZC9Bc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5jcHA6CisgICAgICAgIChXZWJL aXQ6OldLT3B0aW9uSXRlbTo6ZW5jb2RlKToKKyAgICAgICAgKFdlYktpdDo6V0tPcHRpb25JdGVt OjpkZWNvZGUpOgorICAgICAgICAoV2ViS2l0OjpBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbjo6ZW5j b2RlKToKKyAgICAgICAgKFdlYktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb246OmRlY29kZSk6 CisgICAgICAgICogU2hhcmVkL0Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmg6CisgICAgICAgIChX ZWJLaXQ6OldLT3B0aW9uSXRlbTo6V0tPcHRpb25JdGVtKToKKyAgICAgICAgKiBVSVByb2Nlc3Mv V2ViUGFnZVByb3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50 ZXJhY3Rpb24uaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvaW9zL1dLQ29udGVudFZpZXdJbnRlcmFj dGlvbi5tbToKKyAgICAgICAgKC1bV0tDb250ZW50VmlldyBpbnB1dFZpZXddKToKKyAgICAgICAg KC1bV0tDb250ZW50VmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXSk6CisgICAgICAgICgt W1dLQ29udGVudFZpZXcgX3N0YXJ0QXNzaXN0aW5nTm9kZTpdKToKKyAgICAgICAgKiBVSVByb2Nl c3MvaW9zL1dlYlBhZ2VQcm94eUlPUy5tbToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5 OjpzZXRBc3Npc3RlZE5vZGVTZWxlY3RlZEluZGV4KToKKyAgICAgICAgKiBVSVByb2Nlc3MvaW9z L2Zvcm1zL1dLRm9ybVNlbGVjdENvbnRyb2wuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvaW9zL2Zv cm1zL1dLRm9ybVNlbGVjdENvbnRyb2wubW06IEFkZGVkLgorICAgICAgICAoLVtXS0Zvcm1TZWxl Y3RDb250cm9sIGluaXRXaXRoVmlldzpdKToKKyAgICAgICAgKCtbV0tGb3JtU2VsZWN0Q29udHJv bCBjcmVhdGVQZXJpcGhlcmFsV2l0aFZpZXc6XSk6CisgICAgICAgICgtW1dLRm9ybVNlbGVjdENv bnRyb2wgYXNzaXN0YW50Vmlld10pOgorICAgICAgICAoLVtXS0Zvcm1TZWxlY3RDb250cm9sIGJl Z2luRWRpdGluZ10pOgorICAgICAgICAoLVtXS0Zvcm1TZWxlY3RDb250cm9sIGVuZEVkaXRpbmdd KToKKyAgICAgICAgKiBVSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdFBpY2tlci5tbTog QWRkZWQuCisgICAgICAgICgtW1dLU2VsZWN0U2luZ2xlUGlja2VyIGluaXRXaXRoVmlldzpdKToK KyAgICAgICAgKC1bV0tTZWxlY3RTaW5nbGVQaWNrZXIgZGVhbGxvY10pOgorICAgICAgICAoLVtX S1NlbGVjdFNpbmdsZVBpY2tlciBjb250cm9sVmlld10pOgorICAgICAgICAoLVtXS1NlbGVjdFNp bmdsZVBpY2tlciBjb250cm9sQmVnaW5FZGl0aW5nXSk6CisgICAgICAgICgtW1dLU2VsZWN0U2lu Z2xlUGlja2VyIGNvbnRyb2xFbmRFZGl0aW5nXSk6CisgICAgICAgICgtW1dLU2VsZWN0U2luZ2xl UGlja2VyIG51bWJlck9mQ29tcG9uZW50c0luUGlja2VyVmlldzpdKToKKyAgICAgICAgKHN0cmlu Z0J5VHJpbW1pbmdXaGl0ZXNwYWNlQW5kTmV3bGluZXMpOgorICAgICAgICAoLVtXS1NlbGVjdFNp bmdsZVBpY2tlciBwaWNrZXJWaWV3Om51bWJlck9mUm93c0luQ29tcG9uZW50Ol0pOgorICAgICAg ICAoLVtXS1NlbGVjdFNpbmdsZVBpY2tlciBwaWNrZXJWaWV3OmF0dHJpYnV0ZWRUaXRsZUZvclJv dzpmb3JDb21wb25lbnQ6XSk6CisgICAgICAgICgtW1dLU2VsZWN0U2luZ2xlUGlja2VyIHBpY2tl clZpZXc6ZGlkU2VsZWN0Um93OmluQ29tcG9uZW50Ol0pOgorICAgICAgICAqIFVJUHJvY2Vzcy9p b3MvZm9ybXMvV0tGb3JtU2VsZWN0UG9wb3Zlci5tbTogQWRkZWQuCisgICAgICAgIChzdHJpbmdX aXRoV3JpdGluZ0RpcmVjdGlvbik6CisgICAgICAgIChhZGp1c3RlZEZvbnRTaXplKToKKyAgICAg ICAgKC1bV0tTZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIGluaXRXaXRoVmlldzpoYXNHcm91cHM6 XSk6CisgICAgICAgICgtW1dLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlciB2aWV3V2lsbEFwcGVh cjpdKToKKyAgICAgICAgKC1bV0tTZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIG51bWJlck9mU2Vj dGlvbnNJblRhYmxlVmlldzpdKToKKyAgICAgICAgKC1bV0tTZWxlY3RUYWJsZVZpZXdDb250cm9s bGVyIHRhYmxlVmlldzpudW1iZXJPZlJvd3NJblNlY3Rpb246XSk6CisgICAgICAgICgtW1dLU2Vs ZWN0VGFibGVWaWV3Q29udHJvbGxlciB0YWJsZVZpZXc6dGl0bGVGb3JIZWFkZXJJblNlY3Rpb246 XSk6CisgICAgICAgICgtW1dLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlciBwb3B1bGF0ZUNlbGw6 d2l0aEl0ZW06XSk6CisgICAgICAgICgtW1dLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlciBmaW5k SXRlbUluZGV4QXQ6XSk6CisgICAgICAgICgtW1dLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlciBm aW5kSXRlbUF0Ol0pOgorICAgICAgICAoLVtXS1NlbGVjdFRhYmxlVmlld0NvbnRyb2xsZXIgdGFi bGVWaWV3OmNlbGxGb3JSb3dBdEluZGV4UGF0aDpdKToKKyAgICAgICAgKC1bV0tTZWxlY3RUYWJs ZVZpZXdDb250cm9sbGVyIHRhYmxlVmlldzpkaWRTZWxlY3RSb3dBdEluZGV4UGF0aDpdKToKKyAg ICAgICAgKC1bV0tTZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIGhhc1RleHRdKToKKyAgICAgICAg KC1bV0tTZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIGluc2VydFRleHQ6XSk6CisgICAgICAgICgt W1dLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlciBkZWxldGVCYWNrd2FyZF0pOgorICAgICAgICAo LVtXS1NlbGVjdFBvcG92ZXIgaW5pdFdpdGhWaWV3Omhhc0dyb3VwczpdKToKKyAgICAgICAgKC1b V0tTZWxlY3RQb3BvdmVyIGRlYWxsb2NdKToKKyAgICAgICAgKC1bV0tTZWxlY3RQb3BvdmVyIGNv bnRyb2xWaWV3XSk6CisgICAgICAgICgtW1dLU2VsZWN0UG9wb3ZlciBjb250cm9sQmVnaW5FZGl0 aW5nXSk6CisgICAgICAgICgtW1dLU2VsZWN0UG9wb3ZlciBjb250cm9sRW5kRWRpdGluZ10pOgor ICAgICAgICAoLVtXS1NlbGVjdFBvcG92ZXIgX3VzZXJBY3Rpb25EaXNtaXNzZWRQb3BvdmVyOl0p OgorICAgICAgICAqIFdlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAg KiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmluOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9p b3MvV2ViUGFnZUlPUy5tbToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6c2V0QXNzaXN0ZWRO b2RlU2VsZWN0ZWRJbmRleCk6CisgICAgICAgIChXZWJLaXQ6OmlubmVyRnJhbWVRdWFkKToKKyAg ICAgICAgKFdlYktpdDo6V2ViUGFnZTo6Z2V0UG9zaXRpb25JbmZvcm1hdGlvbik6CisgICAgICAg IChXZWJLaXQ6Omhhc0ZvY3VzYWJsZU5vZGUpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlOjpn ZXRBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2U6OmVs ZW1lbnREaWRGb2N1cyk6CisKIDIwMTQtMDMtMDEgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0Bp Z2FsaWEuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZm9sbG93LXVwIHRvIHIxNjQ5MDUgYW5k IHIxNjQ5MTIuCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9TY3JpcHRzL3dlYmtpdDIvbWVzc2FnZXMu cHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvU2NyaXB0cy93ZWJraXQyL21lc3NhZ2Vz LnB5CShyZXZpc2lvbiAxNjQ5MzQpCisrKyBTb3VyY2UvV2ViS2l0Mi9TY3JpcHRzL3dlYmtpdDIv bWVzc2FnZXMucHkJKHdvcmtpbmcgY29weSkKQEAgLTIyMiw2ICsyMjIsNyBAQCBkZWYgc3RydWN0 X29yX2NsYXNzKG5hbWVzcGFjZSwgdHlwZSk6CiAgICAgICAgICdXZWJLaXQ6OlNlY3VyaXR5T3Jp Z2luRGF0YScsCiAgICAgICAgICdXZWJLaXQ6OlN0YXRpc3RpY3NEYXRhJywKICAgICAgICAgJ1dl YktpdDo6VGV4dENoZWNrZXJTdGF0ZScsCisgICAgICAgICdXZWJLaXQ6OldLT3B0aW9uSXRlbScs CiAgICAgICAgICdXZWJLaXQ6OldlYk5hdmlnYXRpb25EYXRhU3RvcmUnLAogICAgICAgICAnV2Vi S2l0OjpXZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzJywKICAgICAgICAgJ1dlYktpdDo6V2ViUHJl ZmVyZW5jZXNTdG9yZScsCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9TaGFyZWQvQXNzaXN0ZWROb2Rl SW5mb3JtYXRpb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1NoYXJlZC9Bc3Np c3RlZE5vZGVJbmZvcm1hdGlvbi5jcHAJKHJldmlzaW9uIDE2NDkzNCkKKysrIFNvdXJjZS9XZWJL aXQyL1NoYXJlZC9Bc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTMyLDYgKzMyLDM1IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogI2lmIFBMQVRGT1JNKElPUykK K3ZvaWQgV0tPcHRpb25JdGVtOjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIp IGNvbnN0Cit7CisgICAgZW5jb2RlciA8PCB0ZXh0OworICAgIGVuY29kZXIgPDwgaXNHcm91cDsK KyAgICBlbmNvZGVyIDw8IGlzU2VsZWN0ZWQ7CisgICAgZW5jb2RlciA8PCBkaXNhYmxlZDsKKyAg ICBlbmNvZGVyIDw8IHBhcmVudEdyb3VwSUQ7Cit9CisKK2Jvb2wgV0tPcHRpb25JdGVtOjpkZWNv ZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFdLT3B0aW9uSXRlbSYgcmVzdWx0KQor eworICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LnRleHQpKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5pc0dyb3VwKSkKKyAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShyZXN1bHQuaXNTZWxl Y3RlZCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICghZGVjb2Rlci5kZWNvZGUo cmVzdWx0LmRpc2FibGVkKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFkZWNv ZGVyLmRlY29kZShyZXN1bHQucGFyZW50R3JvdXBJRCkpCisgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICAKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogdm9pZCBBc3Npc3RlZE5vZGVJbmZvcm1hdGlv bjo6ZW5jb2RlKElQQzo6QXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAogewogICAgIGVu Y29kZXIgPDwgZWxlbWVudFJlY3Q7CkBAIC00MSw3ICs3MCw3IEBAIHZvaWQgQXNzaXN0ZWROb2Rl SW5mb3JtYXRpb246OmVuY29kZShJUEMKICAgICBlbmNvZGVyIDw8ICh1aW50MzJfdClhdXRvY2Fw aXRhbGl6ZVR5cGU7CiAgICAgZW5jb2RlciA8PCAodWludDMyX3QpZWxlbWVudFR5cGU7CiAgICAg ZW5jb2RlciA8PCBmb3JtQWN0aW9uOwotICAgIGVuY29kZXIgPDwgc2VsZWN0aW9uT3B0aW9uczsK KyAgICBlbmNvZGVyIDw8IHNlbGVjdE9wdGlvbnM7CiAgICAgZW5jb2RlciA8PCBzZWxlY3RlZElu ZGV4OwogICAgIGVuY29kZXIgPDwgaXNNdWx0aVNlbGVjdDsKICAgICBlbmNvZGVyIDw8IGlzUmVh ZE9ubHk7CkBAIC03Myw3ICsxMDIsNyBAQCBib29sIEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uOjpk ZWNvZGUoSVBDCiAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShyZXN1bHQuZm9ybUFjdGlvbikpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKIAotICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LnNl bGVjdGlvbk9wdGlvbnMpKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0LnNlbGVjdE9w dGlvbnMpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBpZiAoIWRlY29kZXIuZGVjb2Rl KHJlc3VsdC5zZWxlY3RlZEluZGV4KSkKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1NoYXJlZC9Bc3Np c3RlZE5vZGVJbmZvcm1hdGlvbi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1NoYXJl ZC9Bc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5oCShyZXZpc2lvbiAxNjQ5MzQpCisrKyBTb3VyY2Uv V2ViS2l0Mi9TaGFyZWQvQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uaAkod29ya2luZyBjb3B5KQpA QCAtNTUsNiArNTUsNDIgQEAgZW51bSBXS0lucHV0VHlwZSB7CiB9OwogCiAjaWYgUExBVEZPUk0o SU9TKQorc3RydWN0IFdLT3B0aW9uSXRlbSB7CisgICAgV0tPcHRpb25JdGVtKCkKKyAgICAgICAg OiBpc0dyb3VwKGZhbHNlKQorICAgICAgICAsIGlzU2VsZWN0ZWQoZmFsc2UpCisgICAgICAgICwg ZGlzYWJsZWQoZmFsc2UpCisgICAgICAgICwgcGFyZW50R3JvdXBJRCgwKQorICAgIHsKKyAgICB9 CisKKyAgICBXS09wdGlvbkl0ZW0oY29uc3QgV0tPcHRpb25JdGVtJiBpdGVtKQorICAgICAgICA6 IHRleHQoaXRlbS50ZXh0KQorICAgICAgICAsIGlzR3JvdXAoaXRlbS5pc0dyb3VwKQorICAgICAg ICAsIGlzU2VsZWN0ZWQoaXRlbS5pc1NlbGVjdGVkKQorICAgICAgICAsIGRpc2FibGVkKGl0ZW0u ZGlzYWJsZWQpCisgICAgICAgICwgcGFyZW50R3JvdXBJRChpdGVtLnBhcmVudEdyb3VwSUQpCisg ICAgeworICAgIH0KKworICAgIFdLT3B0aW9uSXRlbShjb25zdCBTdHJpbmcmIHRleHQsIGJvb2wg aXNHcm91cCwgaW50IHBhcmVudElELCBib29sIHNlbGVjdGVkLCBib29sIGRpc2FibGVkKQorICAg ICAgICA6IHRleHQodGV4dCkKKyAgICAgICAgLCBpc0dyb3VwKGlzR3JvdXApCisgICAgICAgICwg aXNTZWxlY3RlZChzZWxlY3RlZCkKKyAgICAgICAgLCBkaXNhYmxlZChkaXNhYmxlZCkKKyAgICAg ICAgLCBwYXJlbnRHcm91cElEKHBhcmVudElEKQorICAgIHsKKyAgICB9CisgICAgU3RyaW5nIHRl eHQ7CisgICAgYm9vbCBpc0dyb3VwOworICAgIGJvb2wgaXNTZWxlY3RlZDsKKyAgICBib29sIGRp c2FibGVkOworICAgIGludCBwYXJlbnRHcm91cElEOworCisgICAgdm9pZCBlbmNvZGUoSVBDOjpB cmd1bWVudEVuY29kZXImKSBjb25zdDsKKyAgICBzdGF0aWMgYm9vbCBkZWNvZGUoSVBDOjpBcmd1 bWVudERlY29kZXImLCBXS09wdGlvbkl0ZW0mKTsKK307CisKIHN0cnVjdCBBc3Npc3RlZE5vZGVJ bmZvcm1hdGlvbiB7CiAgICAgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24oKQogICAgICAgICA6IGhh c05leHROb2RlKGZhbHNlKQpAQCAtNzgsNyArMTE0LDcgQEAgc3RydWN0IEFzc2lzdGVkTm9kZUlu Zm9ybWF0aW9uIHsKICAgICBXZWJBdXRvY2FwaXRhbGl6ZVR5cGUgYXV0b2NhcGl0YWxpemVUeXBl OwogICAgIFdLSW5wdXRUeXBlIGVsZW1lbnRUeXBlOwogICAgIFN0cmluZyBmb3JtQWN0aW9uOwot ICAgIFZlY3RvcjxTdHJpbmc+IHNlbGVjdGlvbk9wdGlvbnM7CisgICAgVmVjdG9yPFdLT3B0aW9u SXRlbT4gc2VsZWN0T3B0aW9uczsKICAgICBpbnQgc2VsZWN0ZWRJbmRleDsKICAgICBTdHJpbmcg dmFsdWU7CiAgICAgZG91YmxlIHZhbHVlQXNOdW1iZXI7CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5oCShyZXZpc2lvbiAxNjQ5MzQpCisrKyBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgJKHdvcmtpbmcgY29weSkKQEAgLTQ4MSw2ICs0ODEs NyBAQCBwdWJsaWM6CiAgICAgdm9pZCBkaWRVcGRhdGVCbG9ja1NlbGVjdGlvbldpdGhUb3VjaCh1 aW50MzJfdCB0b3VjaCwgdWludDMyX3QgZmxhZ3MsIGZsb2F0IGdyb3dUaHJlc2hvbGQsIGZsb2F0 IHNocmlua1RocmVzaG9sZCk7CiAgICAgdm9pZCBzZXRBc3Npc3RlZE5vZGVWYWx1ZShjb25zdCBT dHJpbmcmKTsKICAgICB2b2lkIHNldEFzc2lzdGVkTm9kZVZhbHVlQXNOdW1iZXIoZG91YmxlKTsK KyAgICB2b2lkIHNldEFzc2lzdGVkTm9kZVNlbGVjdGVkSW5kZXgodWludDMyX3QgaW5kZXgsIGJv b2wgYWxsb3dNdWx0aXBsZVNlbGVjdGlvbiA9IGZhbHNlKTsKICNlbmRpZgogCiAgICAgY29uc3Qg RWRpdG9yU3RhdGUmIGVkaXRvclN0YXRlKCkgY29uc3QgeyByZXR1cm4gbV9lZGl0b3JTdGF0ZTsg fQpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJh Y3Rpb24uaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLQ29u dGVudFZpZXdJbnRlcmFjdGlvbi5oCShyZXZpc2lvbiAxNjQ5MzQpCisrKyBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvaW9zL1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5oCSh3b3JraW5nIGNvcHkp CkBAIC01MCw4ICs1MCw2IEBAIGNsYXNzIEludFNpemU7CiBuYW1lc3BhY2UgV2ViS2l0IHsKIGNs YXNzIE5hdGl2ZVdlYlRvdWNoRXZlbnQ7CiBjbGFzcyBXZWJQYWdlUHJveHk7Ci1zdHJ1Y3QgQXNz aXN0ZWROb2RlSW5mb3JtYXRpb247Ci1zdHJ1Y3QgSW50ZXJhY3Rpb25JbmZvcm1hdGlvbkF0UG9z aXRpb247CiB9CiAKIEBjbGFzcyBfVUlXZWJIaWdobGlnaHRMb25nUHJlc3NHZXN0dXJlUmVjb2du aXplcjsKQEAgLTExOSw3ICsxMTcsNyBAQCBzdHJ1Y3QgV0tBdXRvQ29ycmVjdGlvbkRhdGEgewog QHByb3BlcnR5IChub25hdG9taWMsIHJlYWRvbmx5KSBjb25zdCBXZWJLaXQ6OkludGVyYWN0aW9u SW5mb3JtYXRpb25BdFBvc2l0aW9uJiBwb3NpdGlvbkluZm9ybWF0aW9uOwogQHByb3BlcnR5IChu b25hdG9taWMsIHJlYWRvbmx5KSBjb25zdCBXZWJLaXQ6OldLQXV0b0NvcnJlY3Rpb25EYXRhJiBh dXRvY29ycmVjdGlvbkRhdGE7CiBAcHJvcGVydHkgKG5vbmF0b21pYywgcmVhZG9ubHkpIGNvbnN0 IFdlYktpdDo6QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mIGFzc2lzdGVkTm9kZUluZm9ybWF0aW9u OwotCistIChWZWN0b3I8V2ViS2l0OjpXS09wdGlvbkl0ZW0+JikgYXNzaXN0ZWROb2RlU2VsZWN0 T3B0aW9uczsKIC0gKHZvaWQpc2V0dXBJbnRlcmFjdGlvbjsKIC0gKHZvaWQpY2xlYW51cEludGVy YWN0aW9uOwogCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dLQ29udGVudFZp ZXdJbnRlcmFjdGlvbi5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv aW9zL1dLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5tbQkocmV2aXNpb24gMTY0OTM0KQorKysgU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJhY3Rpb24ubW0JKHdv cmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBvcnQgIldlYlByb2Nlc3NQcm94eS5o IgogI2ltcG9ydCAiV0tBY3Rpb25TaGVldEFzc2lzdGFudC5oIgogI2ltcG9ydCAiV0tGb3JtSW5w dXRDb250cm9sLmgiCisjaW1wb3J0ICJXS0Zvcm1TZWxlY3RDb250cm9sLmgiCiAjaW1wb3J0IDxE YXRhRGV0ZWN0b3JzVUkvREREZXRlY3Rpb25Db250cm9sbGVyLmg+CiAjaW1wb3J0IDxVSUtpdC9f VUlIaWdobGlnaHRWaWV3Lmg+CiAjaW1wb3J0IDxVSUtpdC9fVUlXZWJIaWdobGlnaHRMb25nUHJl c3NHZXN0dXJlUmVjb2duaXplci5oPgpAQCAtNDAzLDggKzQwNCwxMSBAQCAtICh2b2lkKV9kaXNw bGF5Rm9ybU5vZGVJbnB1dFZpZXcKIAogLSAoVUlWaWV3ICopaW5wdXRWaWV3CiB7CisgICAgaWYg KF9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9PSBXS1R5cGVOb25lKQorICAg ICAgICByZXR1cm4gbmlsOworCiAgICAgaWYgKCFfaW5wdXRQZXJpcGhlcmFsKQotICAgICAgICBf aW5wdXRQZXJpcGhlcmFsID0gYWRvcHROUyhbV0tGb3JtSW5wdXRDb250cm9sIGNyZWF0ZVBlcmlw aGVyYWxXaXRoVmlldzpzZWxmXSk7CisgICAgICAgIF9pbnB1dFBlcmlwaGVyYWwgPSBhZG9wdE5T KF9hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9PSBXS1R5cGVTZWxlY3QgPyBb V0tGb3JtU2VsZWN0Q29udHJvbCBjcmVhdGVQZXJpcGhlcmFsV2l0aFZpZXc6c2VsZl0gOiBbV0tG b3JtSW5wdXRDb250cm9sIGNyZWF0ZVBlcmlwaGVyYWxXaXRoVmlldzpzZWxmXSk7CiAgICAgZWxz ZQogICAgICAgICBbc2VsZiBfZGlzcGxheUZvcm1Ob2RlSW5wdXRWaWV3XTsKIApAQCAtMTgwNSw2 ICsxODA5LDExIEBAIC0gKGNvbnN0IEFzc2lzdGVkTm9kZUluZm9ybWF0aW9uJilhc3Npc3QKICAg ICByZXR1cm4gX2Fzc2lzdGVkTm9kZUluZm9ybWF0aW9uOwogfQogCistIChWZWN0b3I8V0tPcHRp b25JdGVtPiYpIGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnMKK3sKKyAgICByZXR1cm4gX2Fzc2lz dGVkTm9kZUluZm9ybWF0aW9uLnNlbGVjdE9wdGlvbnM7Cit9CisKIC0gKHZvaWQpX3N0YXJ0QXNz aXN0aW5nTm9kZTooY29uc3QgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24mKWluZm9ybWF0aW9uCiB7 CiAgICAgX2lzRWRpdGFibGUgPSBZRVM7CkBAIC0xODE0LDcgKzE4MjMsMTcgQEAgLSAodm9pZClf c3RhcnRBc3Npc3RpbmdOb2RlOihjb25zdCBBc3NpcwogICAgIGlmICghW3NlbGYgaXNGaXJzdFJl c3BvbmRlcl0pCiAgICAgICAgIFtzZWxmIGJlY29tZUZpcnN0UmVzcG9uZGVyXTsKIAotICAgIFtz ZWxmIF9zdGFydEFzc2lzdGluZ0tleWJvYXJkXTsKKyAgICBzd2l0Y2ggKGluZm9ybWF0aW9uLmVs ZW1lbnRUeXBlKSB7CisgICAgICAgIGNhc2UgV0tUeXBlU2VsZWN0OgorICAgICAgICBjYXNlIFdL VHlwZURhdGVUaW1lTG9jYWw6CisgICAgICAgIGNhc2UgV0tUeXBlVGltZToKKyAgICAgICAgY2Fz ZSBXS1R5cGVNb250aDoKKyAgICAgICAgY2FzZSBXS1R5cGVEYXRlOgorICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBbc2VsZiBfc3RhcnRBc3Npc3RpbmdL ZXlib2FyZF07CisgICAgICAgICAgICBicmVhazsKKyAgICB9CiAgICAgW3NlbGYgcmVsb2FkSW5w dXRWaWV3c107CiAgICAgW3NlbGYgX3VwZGF0ZUFjY2Vzc29yeV07CiAgICAgLy8gX2lucHV0UGVy aXBoZXJhbCBoYXMgYmVlbiBpbml0aWFsaXplZCBpbiBpbnB1dFZpZXcgY2FsbGVkIGJ5IHJlbG9h ZElucHV0Vmlld3MuCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dlYlBhZ2VQ cm94eUlPUy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL1dl YlBhZ2VQcm94eUlPUy5tbQkocmV2aXNpb24gMTY0OTM0KQorKysgU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL2lvcy9XZWJQYWdlUHJveHlJT1MubW0JKHdvcmtpbmcgY29weSkKQEAgLTQ5NCw2ICs0 OTQsMTEgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnNldEFzc2lzdGVkTm9kZVZhbHVlQQogICAgIHBy b2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpTZXRBc3Npc3RlZE5vZGVWYWx1ZUFzTnVt YmVyKHZhbHVlKSwgbV9wYWdlSUQpOwogfQogCit2b2lkIFdlYlBhZ2VQcm94eTo6c2V0QXNzaXN0 ZWROb2RlU2VsZWN0ZWRJbmRleCh1aW50MzJfdCBpbmRleCwgYm9vbCBhbGxvd011bHRpcGxlU2Vs ZWN0aW9uKQoreworICAgIHByb2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpTZXRBc3Np c3RlZE5vZGVTZWxlY3RlZEluZGV4KGluZGV4LCBhbGxvd011bHRpcGxlU2VsZWN0aW9uKSwgbV9w YWdlSUQpOworfQorCiB2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkUGVyZm9ybURpY3Rpb25hcnlMb29r dXAoY29uc3QgQXR0cmlidXRlZFN0cmluZyYsIGNvbnN0IERpY3Rpb25hcnlQb3B1cEluZm8mKQog ewogICAgIG5vdEltcGxlbWVudGVkKCk7CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv aW9zL2Zvcm1zL1dLRm9ybVNlbGVjdENvbnRyb2wuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdENvbnRyb2wuaAkocmV2aXNpb24g MTY0OTM0KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9mb3Jtcy9XS0Zvcm1TZWxl Y3RDb250cm9sLmgJKHdvcmtpbmcgY29weSkKQEAgLTIzLDEwICsyMywyNyBAQAogICogVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKKyNpZiBQTEFURk9STShJT1MpCisKICNp bXBvcnQgIldLRm9ybVBlcmlwaGVyYWwuaCIKKyNpbXBvcnQgIldLRm9ybVBvcG92ZXIuaCIKKyNp bXBvcnQgPFVJS2l0L1VJUGlja2VyVmlldy5oPgorI2ltcG9ydCA8VUlLaXQvVUlQaWNrZXJWaWV3 X1ByaXZhdGUuaD4KIAogQGNsYXNzIFdLQ29udGVudFZpZXc7CiAKIEBpbnRlcmZhY2UgV0tGb3Jt U2VsZWN0Q29udHJvbCA6IE5TT2JqZWN0PFdLRm9ybVBlcmlwaGVyYWw+CiArIChXS0Zvcm1TZWxl Y3RDb250cm9sICopY3JlYXRlUGVyaXBoZXJhbFdpdGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmll dzsKIEBlbmQKKworQGludGVyZmFjZSBXS1NlbGVjdFBvcG92ZXIgOiBXS0Zvcm1Sb3RhdGluZ0Fj Y2Vzc29yeVBvcG92ZXI8V0tGb3JtQ29udHJvbD4KKy0gKGlkKWluaXRXaXRoVmlldzooV0tDb250 ZW50VmlldyAqKXZpZXcgaGFzR3JvdXBzOihCT09MKWhhc0dyb3VwczsKKy0gKHZvaWQpX3VzZXJB Y3Rpb25EaXNtaXNzZWRQb3BvdmVyOihpZClzZW5kZXI7CitAZW5kCisKK0BpbnRlcmZhY2UgV0tT ZWxlY3RTaW5nbGVQaWNrZXIgOiBVSVBpY2tlclZpZXcgPFdLRm9ybUNvbnRyb2wsIFVJUGlja2Vy Vmlld0RhdGFTb3VyY2UsIFVJUGlja2VyVmlld0RlbGVnYXRlPgorLSAoaWQpaW5pdFdpdGhWaWV3 OihXS0NvbnRlbnRWaWV3ICopdmlldzsKK0BlbmQKKworI2VuZGlmIC8vIFBMQVRGT1JNKElPUykK KwpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9mb3Jtcy9XS0Zvcm1TZWxlY3RD b250cm9sLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvZm9y bXMvV0tGb3JtU2VsZWN0Q29udHJvbC5tbQkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9pb3MvZm9ybXMvV0tGb3JtU2VsZWN0Q29udHJvbC5tbQkod29ya2luZyBjb3B5 KQpAQCAtMCwwICsxLDk1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICog YXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2ltcG9ydCAiY29uZmlnLmgiCisjaW1w b3J0ICJXS0Zvcm1TZWxlY3RDb250cm9sLmgiCisKKyNpZiBQTEFURk9STShJT1MpCisKKyNpbXBv cnQgIldLQ29udGVudFZpZXcuaCIKKyNpbXBvcnQgIldLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5o IgorI2ltcG9ydCAiV0tGb3JtUG9wb3Zlci5oIgorI2ltcG9ydCAiV2ViUGFnZVByb3h5LmgiCisj aW1wb3J0IDxDb3JlRm91bmRhdGlvbi9DRlVuaUNoYXIuaD4KKyNpbXBvcnQgPFVJS2l0L1VJQXBw bGljYXRpb25fUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlEZXZpY2VfUHJpdmF0ZS5oPgor I2ltcG9ydCA8VUlLaXQvVUlLZXlib2FyZF9Qcml2YXRlLmg+CisjaW1wb3J0IDxVSUtpdC9VSVBp Y2tlclZpZXcuaD4KKyNpbXBvcnQgPFVJS2l0L1VJUGlja2VyVmlld19Qcml2YXRlLmg+CisjaW1w b3J0IDxVSUtpdC9VSVN0cmluZ0RyYXdpbmdfUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlX ZWJGb3JtQWNjZXNzb3J5Lmg+CisjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisKK3VzaW5nIG5h bWVzcGFjZSBXZWJLaXQ7CisKK0BpbXBsZW1lbnRhdGlvbiBXS0Zvcm1TZWxlY3RDb250cm9sIHsK KyAgICBSZXRhaW5QdHI8aWQ8V0tGb3JtQ29udHJvbD4+IF9jb250cm9sOworfQorCistIChpZClp bml0V2l0aFZpZXc6KFdLQ29udGVudFZpZXcgKil2aWV3Cit7CisgICAgaWYgKCEoc2VsZiA9IFtz dXBlciBpbml0XSkpCisgICAgICAgIHJldHVybiBuaWw7CisKKyAgICBib29sIGhhc0dyb3VwcyA9 IGZhbHNlOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgdmlldy5hc3Npc3RlZE5vZGVJbmZv cm1hdGlvbi5zZWxlY3RPcHRpb25zLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmICh2aWV3LmFz c2lzdGVkTm9kZUluZm9ybWF0aW9uLnNlbGVjdE9wdGlvbnNbaV0uaXNHcm91cCkgeworICAgICAg ICAgICAgaGFzR3JvdXBzID0gdHJ1ZTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9Cisg ICAgfQorCisgICAgaWYgKFVJQ3VycmVudFVzZXJJbnRlcmZhY2VJZGlvbUlzUGFkKCkpCisgICAg ICAgIF9jb250cm9sID0gYWRvcHROUyhbW1dLU2VsZWN0UG9wb3ZlciBhbGxvY10gaW5pdFdpdGhW aWV3OnZpZXcgaGFzR3JvdXBzOmhhc0dyb3Vwc10pOworICAgIGVsc2UgaWYgKCF2aWV3LmFzc2lz dGVkTm9kZUluZm9ybWF0aW9uLmlzTXVsdGlTZWxlY3QgJiYgIWhhc0dyb3VwcykKKyAgICAgICAg X2NvbnRyb2wgPSBhZG9wdE5TKFtbV0tTZWxlY3RTaW5nbGVQaWNrZXIgYWxsb2NdIGluaXRXaXRo Vmlldzp2aWV3XSk7CisgICAgICAgIAorICAgIC8vIEZJWE1FOiBBZGQgc3VwcG9ydCBmb3IgaVBo b25lIFVJIHdpdGggbXVsdGlzZWxlY3QgYW5kIG9yIGdyb3Vwcy4KKyAgICByZXR1cm4gc2VsZjsK K30KKworKyAoV0tGb3JtU2VsZWN0Q29udHJvbCAqKWNyZWF0ZVBlcmlwaGVyYWxXaXRoVmlldzoo V0tDb250ZW50VmlldyAqKXZpZXcKK3sKKyAgICByZXR1cm4gW1tXS0Zvcm1TZWxlY3RDb250cm9s IGFsbG9jXSBpbml0V2l0aFZpZXc6dmlld107Cit9CisKKy0gKFVJVmlldyAqKWFzc2lzdGFudFZp ZXcKK3sKKyAgICByZXR1cm4gW19jb250cm9sIGNvbnRyb2xWaWV3XTsKK30KKworLSAodm9pZCli ZWdpbkVkaXRpbmcKK3sKKyAgICBbX2NvbnRyb2wgY29udHJvbEJlZ2luRWRpdGluZ107Cit9CisK Ky0gKHZvaWQpZW5kRWRpdGluZworeworICAgIFtfY29udHJvbCBjb250cm9sRW5kRWRpdGluZ107 Cit9CisKK0BlbmQKKworI2VuZGlmICAvLyBQTEFURk9STShJT1MpCkluZGV4OiBTb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdFBpY2tlci5tbQo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdFBpY2tl ci5tbQkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvZm9ybXMv V0tGb3JtU2VsZWN0UGlja2VyLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsMjA1IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g QU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2ltcG9ydCAiY29uZmlnLmgiCisjaW1wb3J0ICJXS0Zvcm1TZWxlY3RDb250 cm9sLmgiCisKKyNpZiBQTEFURk9STShJT1MpCisKKyNpbXBvcnQgIldLQ29udGVudFZpZXcuaCIK KyNpbXBvcnQgIldLQ29udGVudFZpZXdJbnRlcmFjdGlvbi5oIgorI2ltcG9ydCAiV0tGb3JtUG9w b3Zlci5oIgorI2ltcG9ydCAiV2ViUGFnZVByb3h5LmgiCisjaW1wb3J0IDxDb3JlRm91bmRhdGlv bi9DRlVuaUNoYXIuaD4KKyNpbXBvcnQgPFVJS2l0L1VJQXBwbGljYXRpb25fUHJpdmF0ZS5oPgor I2ltcG9ydCA8VUlLaXQvVUlEZXZpY2VfUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlLZXli b2FyZF9Qcml2YXRlLmg+CisjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisKK3VzaW5nIG5hbWVz cGFjZSBXZWJLaXQ7CisKK3N0YXRpYyBjb25zdCBmbG9hdCBEaXNhYmxlZE9wdGlvbkFscGhhID0g MC4zOworCitAaW1wbGVtZW50YXRpb24gV0tTZWxlY3RTaW5nbGVQaWNrZXIgeworICAgIFdLQ29u dGVudFZpZXcgKl92aWV3OworICAgIFdLT3B0aW9uSXRlbSogX3NlbGVjdGVkT3B0aW9uSXRlbTsK KyAgICBOU0ludGVnZXIgX3NlbGVjdGVkSW5kZXg7CisgICAgV0tPcHRpb25JdGVtKiBfb3B0aW9u VG9TZWxlY3RXaGVuRG9uZTsKKyAgICBOU0ludGVnZXIgX2luZGV4VG9TZWxlY3RXaGVuRG9uZTsK K30KKworLSAoaWQpaW5pdFdpdGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmlldworeworICAgIGlm ICghKHNlbGYgPSBbc3VwZXIgaW5pdFdpdGhGcmFtZTpDR1JlY3RaZXJvXSkpCisgICAgICAgIHJl dHVybiBuaWw7CisKKyAgICBfdmlldyA9IHZpZXc7CisgICAgc2VsZi5kZWxlZ2F0ZSA9IHNlbGY7 CisgICAgc2VsZi5kYXRhU291cmNlID0gc2VsZjsKKyAgICBzZWxmLmF1dG9yZXNpemluZ01hc2sg PSBVSVZpZXdBdXRvcmVzaXppbmdGbGV4aWJsZVdpZHRoIHwgVUlWaWV3QXV0b3Jlc2l6aW5nRmxl eGlibGVIZWlnaHQ7CisKKyAgICBfc2VsZWN0ZWRJbmRleCA9IE5TTm90Rm91bmQ7CisgICAgX2lu ZGV4VG9TZWxlY3RXaGVuRG9uZSA9IE5TTm90Rm91bmQ7CisKKyAgICBpbnQgaW5kZXggPSAwOwor ICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgX3ZpZXcuYXNzaXN0ZWROb2RlSW5mb3JtYXRpb24u c2VsZWN0T3B0aW9ucy5zaXplKCk7ICsraSkgeworICAgICAgICBXS09wdGlvbkl0ZW0qIGl0ZW0g PSAmW192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdW2ldOworICAgICAgICBpZiAoIWl0 ZW0tPmlzR3JvdXApIHsKKyAgICAgICAgICAgIGlmIChpdGVtLT5pc1NlbGVjdGVkKSB7CisgICAg ICAgICAgICAgICAgX3NlbGVjdGVkT3B0aW9uSXRlbSA9IGl0ZW07CisgICAgICAgICAgICAgICAg X3NlbGVjdGVkSW5kZXggPSBpbmRleDsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIGluZGV4Kys7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBbc2Vs ZiByZWxvYWRBbGxDb21wb25lbnRzXTsKKworICAgIGlmIChfc2VsZWN0ZWRJbmRleCAhPSBOU05v dEZvdW5kKQorICAgICAgICBbc2VsZiBzZWxlY3RSb3c6X3NlbGVjdGVkSW5kZXggaW5Db21wb25l bnQ6MCBhbmltYXRlZDpOT107CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9pZClkZWFs bG9jCit7CisgICAgc2VsZi5kZWxlZ2F0ZSA9IG5pbDsKKyAgICBzZWxmLmRhdGFTb3VyY2UgPSBu aWw7CisKKyAgICBbc3VwZXIgZGVhbGxvY107Cit9CisKKy0gKFVJVmlldyAqKWNvbnRyb2xWaWV3 Cit7CisgICAgcmV0dXJuIHNlbGY7Cit9CisKKy0gKHZvaWQpY29udHJvbEJlZ2luRWRpdGluZwor eworfQorCistICh2b2lkKWNvbnRyb2xFbmRFZGl0aW5nCit7CisgICAgaWYgKCFfb3B0aW9uVG9T ZWxlY3RXaGVuRG9uZSB8fCBfb3B0aW9uVG9TZWxlY3RXaGVuRG9uZSA9PSBfc2VsZWN0ZWRPcHRp b25JdGVtKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoX3NlbGVjdGVkT3B0aW9uSXRlbSkK KyAgICAgICAgX3NlbGVjdGVkT3B0aW9uSXRlbS0+aXNTZWxlY3RlZCA9IGZhbHNlOworCisgICAg W192aWV3IHBhZ2VdLT5zZXRBc3Npc3RlZE5vZGVTZWxlY3RlZEluZGV4KF9pbmRleFRvU2VsZWN0 V2hlbkRvbmUpOworICAgIGlmIChfb3B0aW9uVG9TZWxlY3RXaGVuRG9uZSkKKyAgICAgICAgX29w dGlvblRvU2VsZWN0V2hlbkRvbmUtPmlzU2VsZWN0ZWQgPSB0cnVlOworfQorCistIChOU0ludGVn ZXIpbnVtYmVyT2ZDb21wb25lbnRzSW5QaWNrZXJWaWV3OihVSVBpY2tlclZpZXcgKilhUGlja2Vy VmlldworeworICAgIHJldHVybiAxOworfQorCitzdGF0aWMgTlNTdHJpbmcgKnN0cmluZ0J5VHJp bW1pbmdXaGl0ZXNwYWNlQW5kTmV3bGluZXMoTlNTdHJpbmcgKnN0cmluZykKK3sKKyAgICBOU1Jh bmdlIHIgPSBOU01ha2VSYW5nZSgwLCBbc3RyaW5nIGxlbmd0aF0pOworCisgICAgaWYgKCFyLmxl bmd0aCkKKyAgICAgICAgcmV0dXJuIHN0cmluZzsKKworICAgIE5TVUludGVnZXIgb3JpZ2luYWxM ZW5ndGggPSByLmxlbmd0aDsKKworICAgIC8vICBGaXJzdCBzdHJpcCBhbGwgd2hpdGUgc3BhY2Ug b2ZmIHRoZSBlbmQgb2YgdGhlIHJhbmdlCisgICAgd2hpbGUgKHIubGVuZ3RoID4gMCAmJiBDRlVu aUNoYXJJc01lbWJlck9mKFtzdHJpbmcgY2hhcmFjdGVyQXRJbmRleDogci5sZW5ndGggLSAxXSwg a0NGVW5pQ2hhcldoaXRlc3BhY2VBbmROZXdsaW5lQ2hhcmFjdGVyU2V0KSkKKyAgICAgICAgci5s ZW5ndGggLT0gMTsKKworICAgIC8vICBUaGVuLCB0cmltIGFueSB3aGl0ZXNwYWNlIGZyb20gdGhl IHN0YXJ0IG9mIHRoZSByYW5nZS4KKyAgICB3aGlsZSAoci5sZW5ndGggPiAwICYmIENGVW5pQ2hh cklzTWVtYmVyT2YoW3N0cmluZyBjaGFyYWN0ZXJBdEluZGV4OiByLmxvY2F0aW9uXSwga0NGVW5p Q2hhcldoaXRlc3BhY2VBbmROZXdsaW5lQ2hhcmFjdGVyU2V0KSkgeworICAgICAgICByLmxvY2F0 aW9uICs9IDE7CisgICAgICAgIHIubGVuZ3RoIC09IDE7CisgICAgfQorCisgICAgLy8gIElmIHdl IGNoYW5nZWQgdGhlIGxlbmd0aCBvZiB0aGUgc3RyaW5nIGZyb20gd2hhdCBpdCBvcmlnaW5hbGx5 IHdhcywgcmV0dXJuIGEgbmV3IHN0cmluZyB3aXRoIGp1c3QgdGhvc2UKKyAgICAvLyAgY2hhcmFj dGVycy4gIE90aGVyd2lzZSBqdXN0IHJldHVybgorICAgIGlmIChvcmlnaW5hbExlbmd0aCAhPSBy Lmxlbmd0aCkKKyAgICAgICAgcmV0dXJuIFtzdHJpbmcgc3Vic3RyaW5nV2l0aFJhbmdlOiByXTsK KworICAgIHJldHVybiBzdHJpbmc7Cit9CisKKy0gKE5TSW50ZWdlcilwaWNrZXJWaWV3OihVSVBp Y2tlclZpZXcgKilhUGlja2VyVmlldyBudW1iZXJPZlJvd3NJbkNvbXBvbmVudDooTlNJbnRlZ2Vy KWFDb2x1bW5JbmRleAoreworICAgIHJldHVybiBfdmlldy5hc3Npc3RlZE5vZGVJbmZvcm1hdGlv bi5zZWxlY3RPcHRpb25zLnNpemUoKTsKK30KKworLSAoTlNBdHRyaWJ1dGVkU3RyaW5nICopcGlj a2VyVmlldzooVUlQaWNrZXJWaWV3ICopcGlja2VyVmlldyBhdHRyaWJ1dGVkVGl0bGVGb3JSb3c6 KE5TSW50ZWdlcilyb3cgZm9yQ29tcG9uZW50OihOU0ludGVnZXIpY29tcG9uZW50Cit7CisgICAg Y29uc3QgV0tPcHRpb25JdGVtJiBvcHRpb24gPSBbX3ZpZXcgYXNzaXN0ZWROb2RlU2VsZWN0T3B0 aW9uc11bcm93XTsKKyAgICBOU1N0cmluZyAqdGV4dCA9IHN0cmluZ0J5VHJpbW1pbmdXaGl0ZXNw YWNlQW5kTmV3bGluZXMob3B0aW9uLnRleHQpOworCisgICAgTlNNdXRhYmxlQXR0cmlidXRlZFN0 cmluZyAqYXR0cmlidXRlZFN0cmluZyA9IFtbTlNNdXRhYmxlQXR0cmlidXRlZFN0cmluZyBhbGxv Y10gaW5pdFdpdGhTdHJpbmc6dGV4dF07CisgICAgaWYgKG9wdGlvbi5kaXNhYmxlZCkKKyAgICAg ICAgW2F0dHJpYnV0ZWRTdHJpbmcgYWRkQXR0cmlidXRlOk5TRm9yZWdyb3VuZENvbG9yQXR0cmli dXRlTmFtZSB2YWx1ZTpbVUlDb2xvciBjb2xvcldpdGhXaGl0ZTowLjAgYWxwaGE6RGlzYWJsZWRP cHRpb25BbHBoYV0gcmFuZ2U6TlNNYWtlUmFuZ2UoMCwgW3RleHQgbGVuZ3RoXSldOworCisgICAg cmV0dXJuIFthdHRyaWJ1dGVkU3RyaW5nIGF1dG9yZWxlYXNlXTsKK30KKworLSAodm9pZClwaWNr ZXJWaWV3OihVSVBpY2tlclZpZXcgKilwaWNrZXJWaWV3IGRpZFNlbGVjdFJvdzooTlNJbnRlZ2Vy KXJvdyBpbkNvbXBvbmVudDooTlNJbnRlZ2VyKWNvbXBvbmVudAoreworICAgIGNvbnN0IFdLT3B0 aW9uSXRlbSYgbmV3U2VsZWN0ZWRPcHRpb24gPSBbX3ZpZXcgYXNzaXN0ZWROb2RlU2VsZWN0T3B0 aW9uc11bcm93XTsKKyAgICBpZiAobmV3U2VsZWN0ZWRPcHRpb24uZGlzYWJsZWQpIHsKKyAgICAg ICAgTlNJbnRlZ2VyIHJvd1RvU2VsZWN0ID0gTlNOb3RGb3VuZDsKKworICAgICAgICAvLyBTZWFy Y2ggYmFja3dhcmRzIGZvciB0aGUgcHJldmlvdXMgZW5hYmxlZCBvcHRpb24uCisgICAgICAgIGZv ciAoTlNJbnRlZ2VyIGkgPSByb3cgLSAxOyBpID49IDA7IC0taSkgeworICAgICAgICAgICAgY29u c3QgV0tPcHRpb25JdGVtJiBlYXJsaWVyT3B0aW9uID0gW192aWV3IGFzc2lzdGVkTm9kZVNlbGVj dE9wdGlvbnNdW2ldOworICAgICAgICAgICAgaWYgKCFlYXJsaWVyT3B0aW9uLmRpc2FibGVkKSB7 CisgICAgICAgICAgICAgICAgcm93VG9TZWxlY3QgPSBpOworICAgICAgICAgICAgICAgIGJyZWFr OworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgLy8gSWYgbm90aGluZyBwcmV2 aW91cywgc2VhcmNoIGZvcndhcmRzIGZvciB0aGUgbmV4dCBlbmFibGVkIG9wdGlvbi4KKyAgICAg ICAgaWYgKHJvd1RvU2VsZWN0ID09IE5TTm90Rm91bmQpIHsKKyAgICAgICAgICAgIGZvciAoc2l6 ZV90IGkgPSByb3cgKyAxOyBpIDwgW192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdLnNp emUoKTsgKytpKSB7CisgICAgICAgICAgICAgICAgY29uc3QgV0tPcHRpb25JdGVtJiBsYXRlck9w dGlvbiA9IFtfdmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXVtpXTsKKyAgICAgICAgICAg ICAgICBpZiAoIWxhdGVyT3B0aW9uLmRpc2FibGVkKSB7CisgICAgICAgICAgICAgICAgICAgIHJv d1RvU2VsZWN0ID0gaTsKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgaWYgKHJvd1RvU2VsZWN0 ID09IE5TTm90Rm91bmQpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgW3NlbGYgc2Vs ZWN0Um93OnJvd1RvU2VsZWN0IGluQ29tcG9uZW50OjAgYW5pbWF0ZWQ6WUVTXTsKKyAgICAgICAg cm93ID0gcm93VG9TZWxlY3Q7CisgICAgfQorCisgICAgX2luZGV4VG9TZWxlY3RXaGVuRG9uZSA9 IHJvdzsKKyAgICBfb3B0aW9uVG9TZWxlY3RXaGVuRG9uZSA9ICZbX3ZpZXcgYXNzaXN0ZWROb2Rl U2VsZWN0T3B0aW9uc11bcm93XTsKK30KKworQGVuZAorCisjZW5kaWYgIC8vIFBMQVRGT1JNKElP UykKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvZm9ybXMvV0tGb3JtU2VsZWN0 UG9wb3Zlci5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zv cm1zL1dLRm9ybVNlbGVjdFBvcG92ZXIubW0JKHJldmlzaW9uIDApCisrKyBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdFBvcG92ZXIubW0JKHdvcmtpbmcgY29w eSkKQEAgLTAsMCArMSw0NjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAq IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBF WEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJjb25maWcuaCIKKyNp bXBvcnQgIldLRm9ybVNlbGVjdENvbnRyb2wuaCIKKworI2lmIFBMQVRGT1JNKElPUykKKworI2lt cG9ydCAiV0tDb250ZW50Vmlldy5oIgorI2ltcG9ydCAiV0tDb250ZW50Vmlld0ludGVyYWN0aW9u LmgiCisjaW1wb3J0ICJXS0Zvcm1Qb3BvdmVyLmgiCisjaW1wb3J0ICJXZWJQYWdlUHJveHkuaCIK KyNpbXBvcnQgPENvcmVGb3VuZGF0aW9uL0NGVW5pQ2hhci5oPgorI2ltcG9ydCA8VUlLaXQvVUlB cHBsaWNhdGlvbl9Qcml2YXRlLmg+CisjaW1wb3J0IDxVSUtpdC9VSURldmljZV9Qcml2YXRlLmg+ CisjaW1wb3J0IDxVSUtpdC9VSUtleWJvYXJkX1ByaXZhdGUuaD4KKyNpbXBvcnQgPFVJS2l0L1VJ S2V5Ym9hcmRJbXBsLmg+CisjaW1wb3J0IDxVSUtpdC9VSVBpY2tlclZpZXcuaD4KKyNpbXBvcnQg PFVJS2l0L1VJUGlja2VyVmlld19Qcml2YXRlLmg+CisjaW1wb3J0IDxVSUtpdC9VSVRhYmxlVmll d0NlbGxfUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlTdHJpbmdEcmF3aW5nX1ByaXZhdGUu aD4KKyNpbXBvcnQgPFVJS2l0L1VJV2ViRm9ybUFjY2Vzc29yeS5oPgorI2ltcG9ydCA8V2ViQ29y ZS9Mb2NhbGl6ZWRTdHJpbmdzLmg+CisjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisKK3VzaW5n IG5hbWVzcGFjZSBXZWJLaXQ7CisKK3N0YXRpYyBOU1N0cmluZyAqV0tQb3BvdmVyVGFibGVWaWV3 Q2VsbFJldXNlSWRlbnRpZmllciAgPSBAIldLUG9wb3ZlclRhYmxlVmlld0NlbGxSZXVzZUlkZW50 aWZpZXIiOworc3RhdGljIGNvbnN0IGRvdWJsZSBNaW5pbXVtT3B0aW9uRm9udFNpemUgPSAxMjsK KworQGludGVyZmFjZSBVSVRhYmxlVmlld0NlbGwgKEludGVybmFsKQorLSAoQ0dSZWN0KXRleHRS ZWN0Rm9yQ29udGVudFJlY3Q6KENHUmVjdCljb250ZW50UmVjdDsKKy0gKENHUmVjdCljb250ZW50 UmVjdEZvckJvdW5kczooQ0dSZWN0KWJvdW5kczsKK0BlbmQKKworc3RhdGljIE5TU3RyaW5nICpz dHJpbmdXaXRoV3JpdGluZ0RpcmVjdGlvbihOU1N0cmluZyAqc3RyaW5nLCBVSVRleHRXcml0aW5n RGlyZWN0aW9uIHdyaXRpbmdEaXJlY3Rpb24sIGJvb2wgb3ZlcnJpZGUpCit7CisgICAgaWYgKCFb c3RyaW5nIGxlbmd0aF0gfHwgd3JpdGluZ0RpcmVjdGlvbiA9PSBVSVRleHRXcml0aW5nRGlyZWN0 aW9uTmF0dXJhbCkKKyAgICAgICAgcmV0dXJuIHN0cmluZzsKKyAgICAKKyAgICBpZiAoIW92ZXJy aWRlKSB7CisgICAgICAgIFVDaGFyRGlyZWN0aW9uIGZpcnN0Q2hhcmFjdGVyRGlyZWN0aW9uID0g dV9jaGFyRGlyZWN0aW9uKFtzdHJpbmcgY2hhcmFjdGVyQXRJbmRleDowXSk7CisgICAgICAgIGlm ICgoZmlyc3RDaGFyYWN0ZXJEaXJlY3Rpb24gPT0gVV9MRUZUX1RPX1JJR0hUICYmIHdyaXRpbmdE aXJlY3Rpb24gPT0gVUlUZXh0V3JpdGluZ0RpcmVjdGlvbkxlZnRUb1JpZ2h0KQorICAgICAgICAg ICAgfHwgKGZpcnN0Q2hhcmFjdGVyRGlyZWN0aW9uID09IFVfUklHSFRfVE9fTEVGVCAmJiB3cml0 aW5nRGlyZWN0aW9uID09IFVJVGV4dFdyaXRpbmdEaXJlY3Rpb25SaWdodFRvTGVmdCkpCisgICAg ICAgICAgICByZXR1cm4gc3RyaW5nOworICAgIH0KKyAgICAKKyAgICBjb25zdCB1bmljaGFyIGxl ZnRUb1JpZ2h0RW1iZWRkaW5nID0gMHgyMDJBOworICAgIGNvbnN0IHVuaWNoYXIgcmlnaHRUb0xl ZnRFbWJlZGRpbmcgPSAweDIwMkI7CisgICAgY29uc3QgdW5pY2hhciBwb3BEaXJlY3Rpb25hbEZv cm1hdHRpbmcgPSAweDIwMkM7CisgICAgY29uc3QgdW5pY2hhciBsZWZ0VG9SaWdodE92ZXJyaWRl ID0gMHgyMDJEOworICAgIGNvbnN0IHVuaWNoYXIgcmlnaHRUb0xlZnRPdmVycmlkZSA9IDB4MjAy RTsKKyAgICAKKyAgICB1bmljaGFyIGRpcmVjdGlvbmFsRm9ybWF0dGluZ0NoYXJhY3RlciA9ICh3 cml0aW5nRGlyZWN0aW9uID09IFVJVGV4dFdyaXRpbmdEaXJlY3Rpb25MZWZ0VG9SaWdodCkgPyAo b3ZlcnJpZGUgPyBsZWZ0VG9SaWdodE92ZXJyaWRlIDogbGVmdFRvUmlnaHRFbWJlZGRpbmcpCisg ICAgOiAob3ZlcnJpZGUgPyByaWdodFRvTGVmdE92ZXJyaWRlIDogcmlnaHRUb0xlZnRFbWJlZGRp bmcpOworICAgIAorICAgIHJldHVybiBbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVDJUAl QyIsIGRpcmVjdGlvbmFsRm9ybWF0dGluZ0NoYXJhY3Rlciwgc3RyaW5nLCBwb3BEaXJlY3Rpb25h bEZvcm1hdHRpbmddOworfQorCitzdGF0aWMgZmxvYXQgYWRqdXN0ZWRGb250U2l6ZShkb3VibGUg dGV4dFdpZHRoLCBVSUZvbnQgKmZvbnQsIGRvdWJsZSBpbml0aWFsRm9udFNpemUsIGNvbnN0IFZl Y3RvcjxXS09wdGlvbkl0ZW0+JiBpdGVtcykKK3sKKyAgICBkb3VibGUgYWRqdXN0ZWRTaXplID0g aW5pdGlhbEZvbnRTaXplOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgaXRlbXMuc2l6ZSgp OyArK2kpIHsKKyAgICAgICAgY29uc3QgV0tPcHRpb25JdGVtJiBpdGVtID0gaXRlbXNbaV07Cisg ICAgICAgIGlmIChpdGVtLnRleHQuaXNFbXB0eSgpKQorICAgICAgICAgICAgY29udGludWU7Cisg ICAgICAgIAorICAgICAgICBkb3VibGUgYWN0dWFsRm9udFNpemUgPSBpbml0aWFsRm9udFNpemU7 CisgICAgICAgIFsoTlNTdHJpbmcgKilpdGVtLnRleHQgX2xlZ2FjeV9zaXplV2l0aEZvbnQ6Zm9u dCBtaW5Gb250U2l6ZTpNaW5pbXVtT3B0aW9uRm9udFNpemUgYWN0dWFsRm9udFNpemU6JmFjdHVh bEZvbnRTaXplIGZvcldpZHRoOnRleHRXaWR0aCBsaW5lQnJlYWtNb2RlOk5TTGluZUJyZWFrQnlX b3JkV3JhcHBpbmddOworICAgICAgICAKKyAgICAgICAgaWYgKGFjdHVhbEZvbnRTaXplID4gMCAm JiBhY3R1YWxGb250U2l6ZSA8IGFkanVzdGVkU2l6ZSkKKyAgICAgICAgICAgIGFkanVzdGVkU2l6 ZSA9IGFjdHVhbEZvbnRTaXplOworICAgIH0KKyAgICByZXR1cm4gYWRqdXN0ZWRTaXplOworfQor CitAY2xhc3MgV0tTZWxlY3RQb3BvdmVyOworCitAaW50ZXJmYWNlIFdLU2VsZWN0VGFibGVWaWV3 Q29udHJvbGxlciA6IFVJVGFibGVWaWV3Q29udHJvbGxlciA8VUlLZXlJbnB1dD4KK3sKKyAgICBO U1VJbnRlZ2VyIF9zaW5nbGVTZWxlY3Rpb25JbmRleDsKKyAgICBOU1VJbnRlZ2VyIF9zaW5nbGVT ZWxlY3Rpb25TZWN0aW9uOworICAgIE5TSW50ZWdlciBfbnVtYmVyT2ZTZWN0aW9uczsKKyAgICBC T09MIF9hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbjsKKyAgICAKKyAgICBDR0Zsb2F0IF9mb250U2l6 ZTsKKyAgICBDR0Zsb2F0IF9tYXhpbXVtVGV4dFdpZHRoOworICAgIE5TVGV4dEFsaWdubWVudCBf dGV4dEFsaWdubWVudDsKKyAgICAKKyAgICBXS1NlbGVjdFBvcG92ZXIgKl9wb3BvdmVyOworICAg IFdLQ29udGVudFZpZXcgKl9jb250ZW50VmlldzsKK30KKworQHByb3BlcnR5KG5vbmF0b21pYyxh c3NpZ24pIFdLU2VsZWN0UG9wb3ZlciAqcG9wb3ZlcjsKK0BlbmQKKworQGltcGxlbWVudGF0aW9u IFdLU2VsZWN0VGFibGVWaWV3Q29udHJvbGxlcgorCistIChpZClpbml0V2l0aFZpZXc6KFdLQ29u dGVudFZpZXcgKil2aWV3IGhhc0dyb3VwczooQk9PTCloYXNHcm91cHMKK3sKKyAgICBpZiAoIShz ZWxmID0gW3N1cGVyIGluaXRXaXRoU3R5bGU6VUlUYWJsZVZpZXdTdHlsZVBsYWluXSkpCisgICAg ICAgIHJldHVybiBuaWw7CisgICAgCisgICAgX2NvbnRlbnRWaWV3ID0gdmlldzsKKyAgICBWZWN0 b3I8V0tPcHRpb25JdGVtPiYgc2VsZWN0T3B0aW9ucyA9IFtfY29udGVudFZpZXcgYXNzaXN0ZWRO b2RlU2VsZWN0T3B0aW9uc107CisgICAgX2FsbG93c011bHRpcGxlU2VsZWN0aW9uID0gX2NvbnRl bnRWaWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlzTXVsdGlTZWxlY3Q7CisgICAgCisgICAg Ly8gRXZlbiBpZiB0aGUgc2VsZWN0IGlzIGVtcHR5LCB0aGVyZSBpcyBhdCBsZWFzdCBvbmUgdGFi bGV2aWV3IHNlY3Rpb24uCisgICAgX251bWJlck9mU2VjdGlvbnMgPSAxOworICAgIE5TSW50ZWdl ciBjdXJyZW50SW5kZXggPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgc2VsZWN0T3B0 aW9ucy5zaXplKCk7ICsraSkgeworICAgICAgICBjb25zdCBXS09wdGlvbkl0ZW0mIGl0ZW0gPSBz ZWxlY3RPcHRpb25zW2ldOworICAgICAgICBpZiAoaXRlbS5pc0dyb3VwKSB7CisgICAgICAgICAg ICBfbnVtYmVyT2ZTZWN0aW9ucysrOworICAgICAgICAgICAgY3VycmVudEluZGV4ID0gMDsKKyAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisgICAgICAgIGlmICghX2FsbG93c011bHRp cGxlU2VsZWN0aW9uICYmIGl0ZW0uaXNTZWxlY3RlZCkgeworICAgICAgICAgICAgX3NpbmdsZVNl bGVjdGlvbkluZGV4ID0gY3VycmVudEluZGV4OworICAgICAgICAgICAgX3NpbmdsZVNlbGVjdGlv blNlY3Rpb24gPSBpdGVtLnBhcmVudEdyb3VwSUQ7CisgICAgICAgIH0KKyAgICAgICAgY3VycmVu dEluZGV4Kys7CisgICAgfQorICAgIAorICAgIFVJVGV4dFdyaXRpbmdEaXJlY3Rpb24gd3JpdGlu Z0RpcmVjdGlvbiA9IFVJVGV4dFdyaXRpbmdEaXJlY3Rpb25MZWZ0VG9SaWdodDsKKyAgICBCT09M IG92ZXJyaWRlID0gTk87CisgICAgLy8gRklYTUU6IHJldHJpZXZlIGZyb20gV2ViUHJvY2VzcyB3 cml0aW5nIGRpcmVjdGlvbiBhbmQgb3ZlcnJpZGUuCisgICAgX3RleHRBbGlnbm1lbnQgPSAod3Jp dGluZ0RpcmVjdGlvbiA9PSBVSVRleHRXcml0aW5nRGlyZWN0aW9uTGVmdFRvUmlnaHQpID8gTlNU ZXh0QWxpZ25tZW50TGVmdCA6IE5TVGV4dEFsaWdubWVudFJpZ2h0OworICAgIAorICAgIFtzZWxm IHNldFRpdGxlOnN0cmluZ1dpdGhXcml0aW5nRGlyZWN0aW9uKF9jb250ZW50Vmlldy5hc3Npc3Rl ZE5vZGVJbmZvcm1hdGlvbi50aXRsZSwgd3JpdGluZ0RpcmVjdGlvbiwgb3ZlcnJpZGUpXTsKKyAg ICAKKyAgICByZXR1cm4gc2VsZjsKK30KKworLSAodm9pZCl2aWV3V2lsbEFwcGVhcjooQk9PTClh bmltYXRlZAoreworICAgIFtzdXBlciB2aWV3V2lsbEFwcGVhcjphbmltYXRlZF07CisgICAgCisg ICAgaWYgKF9zaW5nbGVTZWxlY3Rpb25JbmRleCAhPSBOU05vdEZvdW5kKSB7CisgICAgICAgIE5T SW5kZXhQYXRoICppbmRleFBhdGggPSBbTlNJbmRleFBhdGggaW5kZXhQYXRoRm9yUm93Ol9zaW5n bGVTZWxlY3Rpb25JbmRleCBpblNlY3Rpb246X3NpbmdsZVNlbGVjdGlvblNlY3Rpb25dOworICAg ICAgICBbc2VsZi50YWJsZVZpZXcgc2Nyb2xsVG9Sb3dBdEluZGV4UGF0aDppbmRleFBhdGggYXRT Y3JvbGxQb3NpdGlvbjpVSVRhYmxlVmlld1Njcm9sbFBvc2l0aW9uTWlkZGxlIGFuaW1hdGVkOk5P XTsKKyAgICB9Cit9CisKKyNwcmFnbWEgbWFyayBVSVRhYmxlVmlldyBkZWxlZ2F0ZSBtZXRob2Rz CisKKy0gKE5TSW50ZWdlciludW1iZXJPZlNlY3Rpb25zSW5UYWJsZVZpZXc6KFVJVGFibGVWaWV3 ICopdGFibGVWaWV3Cit7CisgICAgcmV0dXJuIF9udW1iZXJPZlNlY3Rpb25zOworfQorCistIChO U0ludGVnZXIpdGFibGVWaWV3OihVSVRhYmxlVmlldyAqKXRhYmxlVmlldyBudW1iZXJPZlJvd3NJ blNlY3Rpb246KE5TSW50ZWdlcilzZWN0aW9uCit7CisgICAgaWYgKFtfY29udGVudFZpZXcgYXNz aXN0ZWROb2RlU2VsZWN0T3B0aW9uc10uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMTsKKyAg ICAKKyAgICBpbnQgcm93Q291bnQgPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgW19j b250ZW50VmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXS5zaXplKCk7ICsraSkgeworICAg ICAgICBjb25zdCBXS09wdGlvbkl0ZW0mIGl0ZW0gPSBbX2NvbnRlbnRWaWV3IGFzc2lzdGVkTm9k ZVNlbGVjdE9wdGlvbnNdW2ldOworICAgICAgICBpZiAoaXRlbS5pc0dyb3VwKQorICAgICAgICAg ICAgY29udGludWU7CisgICAgICAgIGlmIChpdGVtLnBhcmVudEdyb3VwSUQgPT0gc2VjdGlvbikK KyAgICAgICAgICAgIHJvd0NvdW50Kys7CisgICAgICAgIGlmIChpdGVtLnBhcmVudEdyb3VwSUQg PiBzZWN0aW9uKQorICAgICAgICAgICAgYnJlYWs7CisgICAgfQorICAgIHJldHVybiByb3dDb3Vu dDsKK30KKworLSAoTlNTdHJpbmcgKil0YWJsZVZpZXc6KFVJVGFibGVWaWV3ICopdGFibGVWaWV3 IHRpdGxlRm9ySGVhZGVySW5TZWN0aW9uOihOU0ludGVnZXIpc2VjdGlvbgoreworICAgIC8vIFRo ZSBmaXJzdCBzZWN0aW9uIG5ldmVyIGhhcyBhIGhlYWRlci4gSXQgaXMgZm9yIHNlbGVjdHMgd2l0 aG91dCBncm91cHMuCisgICAgaWYgKHNlY3Rpb24gPT0gMCkKKyAgICAgICAgcmV0dXJuIG5pbDsK KyAgICAKKyAgICBpbnQgZ3JvdXBDb3VudCA9IDA7CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkg PCBbX2NvbnRlbnRWaWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdLnNpemUoKTsgKytpKSB7 CisgICAgICAgIGNvbnN0IFdLT3B0aW9uSXRlbSYgaXRlbSA9IFtfY29udGVudFZpZXcgYXNzaXN0 ZWROb2RlU2VsZWN0T3B0aW9uc11baV07CisgICAgICAgIGlmICghaXRlbS5pc0dyb3VwKQorICAg ICAgICAgICAgY29udGludWU7CisgICAgICAgIGdyb3VwQ291bnQrKzsKKyAgICAgICAgaWYgKGl0 ZW0uaXNHcm91cCAmJiBncm91cENvdW50ID09IHNlY3Rpb24pCisgICAgICAgICAgICByZXR1cm4g aXRlbS50ZXh0OworICAgIH0KKyAgICByZXR1cm4gbmlsOworfQorCistICh2b2lkKXBvcHVsYXRl Q2VsbDooVUlUYWJsZVZpZXdDZWxsICopY2VsbCB3aXRoSXRlbTooY29uc3QgV0tPcHRpb25JdGVt ICopaXRlbQoreworICAgIFtjZWxsLnRleHRMYWJlbCBzZXRUZXh0Oml0ZW0tPnRleHRdOworICAg IFtjZWxsLnRleHRMYWJlbCBzZXRFbmFibGVkOiFpdGVtLT5kaXNhYmxlZF07CisgICAgW2NlbGwg c2V0U2VsZWN0aW9uU3R5bGU6aXRlbS0+ZGlzYWJsZWQgPyBVSVRhYmxlVmlld0NlbGxTZWxlY3Rp b25TdHlsZU5vbmUgOiBVSVRhYmxlVmlld0NlbGxTZWxlY3Rpb25TdHlsZUJsdWVdOworICAgIFtj ZWxsIHNldEFjY2Vzc29yeVR5cGU6aXRlbS0+aXNTZWxlY3RlZCA/IFVJVGFibGVWaWV3Q2VsbEFj Y2Vzc29yeUNoZWNrbWFyayA6IFVJVGFibGVWaWV3Q2VsbEFjY2Vzc29yeU5vbmVdOworfQorCist IChOU0ludGVnZXIpZmluZEl0ZW1JbmRleEF0OihOU0luZGV4UGF0aCAqKWluZGV4UGF0aAorewor ICAgIEFTU0VSVChpbmRleFBhdGgucm93ID49IDApOworICAgIEFTU0VSVChpbmRleFBhdGguc2Vj dGlvbiA8PSBfbnVtYmVyT2ZTZWN0aW9ucyk7CisgICAgCisgICAgaW50IG9wdGlvbkluZGV4ID0g MDsKKyAgICBpbnQgcm93SW5kZXggPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgW19j b250ZW50VmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXS5zaXplKCk7ICsraSkgeworICAg ICAgICBjb25zdCBXS09wdGlvbkl0ZW0mIGl0ZW0gPSBbX2NvbnRlbnRWaWV3IGFzc2lzdGVkTm9k ZVNlbGVjdE9wdGlvbnNdW2ldOworICAgICAgICBpZiAoaXRlbS5pc0dyb3VwKSB7CisgICAgICAg ICAgICByb3dJbmRleCA9IDA7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorICAg ICAgICBpZiAoaXRlbS5wYXJlbnRHcm91cElEID09IGluZGV4UGF0aC5zZWN0aW9uICYmIHJvd0lu ZGV4ID09IGluZGV4UGF0aC5yb3cpCisgICAgICAgICAgICByZXR1cm4gb3B0aW9uSW5kZXg7Cisg ICAgICAgIG9wdGlvbkluZGV4Kys7CisgICAgICAgIHJvd0luZGV4Kys7CisgICAgfQorICAgIHJl dHVybiBOU05vdEZvdW5kOworfQorCistIChXS09wdGlvbkl0ZW0gKilmaW5kSXRlbUF0OihOU0lu ZGV4UGF0aCAqKWluZGV4UGF0aAoreworICAgIEFTU0VSVChpbmRleFBhdGgucm93ID49IDApOwor ICAgIEFTU0VSVChpbmRleFBhdGguc2VjdGlvbiA8PSBfbnVtYmVyT2ZTZWN0aW9ucyk7CisKKyAg ICBpbnQgaW5kZXggPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgW19jb250ZW50Vmll dyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXS5zaXplKCk7ICsraSkgeworICAgICAgICBXS09w dGlvbkl0ZW0mIGl0ZW0gPSBbX2NvbnRlbnRWaWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNd W2ldOworICAgICAgICBpZiAoaXRlbS5pc0dyb3VwIHx8IGl0ZW0ucGFyZW50R3JvdXBJRCAhPSBp bmRleFBhdGguc2VjdGlvbikKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBpZiAoaW5k ZXggPT0gaW5kZXhQYXRoLnJvdykKKyAgICAgICAgICAgIHJldHVybiAmaXRlbTsKKyAgICAgICAg aW5kZXgrKzsKKyAgICB9CisgICAgcmV0dXJuIG5pbDsKK30KKworLSAoVUlUYWJsZVZpZXdDZWxs ICopdGFibGVWaWV3OihVSVRhYmxlVmlldyAqKXRhYmxlVmlldyBjZWxsRm9yUm93QXRJbmRleFBh dGg6KE5TSW5kZXhQYXRoICopaW5kZXhQYXRoCit7CisgICAgVUlUYWJsZVZpZXdDZWxsICpjZWxs ID0gW3RhYmxlVmlldyBkZXF1ZXVlUmV1c2FibGVDZWxsV2l0aElkZW50aWZpZXI6V0tQb3BvdmVy VGFibGVWaWV3Q2VsbFJldXNlSWRlbnRpZmllcl07CisgICAgaWYgKCFjZWxsKQorICAgICAgICBj ZWxsID0gW1tbVUlUYWJsZVZpZXdDZWxsIGFsbG9jXSBpbml0V2l0aFN0eWxlOlVJVGFibGVWaWV3 Q2VsbFN0eWxlRGVmYXVsdCByZXVzZUlkZW50aWZpZXI6V0tQb3BvdmVyVGFibGVWaWV3Q2VsbFJl dXNlSWRlbnRpZmllcl0gYXV0b3JlbGVhc2VdOworICAgIAorICAgIGNlbGwudGV4dExhYmVsLnRl eHRBbGlnbm1lbnQgPSBfdGV4dEFsaWdubWVudDsKKyAgICAKKyAgICBpZiAoX2NvbnRlbnRWaWV3 LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLnNlbGVjdE9wdGlvbnMuaXNFbXB0eSgpKSB7CisgICAg ICAgIGNlbGwudGV4dExhYmVsLmVuYWJsZWQgPSBOTzsKKyAgICAgICAgY2VsbC50ZXh0TGFiZWwu dGV4dCA9IFdFQl9VSV9TVFJJTkdfS0VZKCJObyBPcHRpb25zIiwgIk5vIE9wdGlvbnMgU2VsZWN0 IFBvcG92ZXIiLCAiRW1wdHkgc2VsZWN0IGxpc3QiKTsKKyAgICAgICAgY2VsbC5hY2Nlc3NvcnlU eXBlID0gVUlUYWJsZVZpZXdDZWxsQWNjZXNzb3J5Tm9uZTsKKyAgICAgICAgY2VsbC5zZWxlY3Rp b25TdHlsZSA9IFVJVGFibGVWaWV3Q2VsbFNlbGVjdGlvblN0eWxlTm9uZTsKKyAgICAgICAgcmV0 dXJuIGNlbGw7CisgICAgfQorICAgIAorICAgIENHUmVjdCB0ZXh0UmVjdCA9IFtjZWxsIHRleHRS ZWN0Rm9yQ29udGVudFJlY3Q6W2NlbGwgY29udGVudFJlY3RGb3JCb3VuZHM6W2NlbGwgYm91bmRz XV1dOworICAgIEFTU0VSVCh0ZXh0UmVjdC5zaXplLndpZHRoID4gMC4wKTsKKyAgICAKKyAgICAv LyBBc3N1bWUgYWxsIGNlbGxzIGhhdmUgdGhlIHNhbWUgYXZhaWxhYmxlIHRleHQgd2lkdGguCisg ICAgQ0dGbG9hdCBpbml0aWFsRm9udFNpemUgPSBfVUlBcHBsaWNhdGlvblVzZXNMZWdhY3lVSSgp ID8gVUlUYWJsZVZpZXdDZWxsRGVmYXVsdEZvbnRTaXplIDogY2VsbC50ZXh0TGFiZWwuZm9udC5w b2ludFNpemU7CisgICAgVUlGb250ICpmb250ID0gX1VJQXBwbGljYXRpb25Vc2VzTGVnYWN5VUko KSA/IFtVSUZvbnQgYm9sZFN5c3RlbUZvbnRPZlNpemU6aW5pdGlhbEZvbnRTaXplXSA6IGNlbGwu dGV4dExhYmVsLmZvbnQ7CisgICAgQVNTRVJUKGluaXRpYWxGb250U2l6ZSk7CisgICAgaWYgKHRl eHRSZWN0LnNpemUud2lkdGggIT0gX21heGltdW1UZXh0V2lkdGggfHwgX2ZvbnRTaXplID09IDAp IHsKKyAgICAgICAgX21heGltdW1UZXh0V2lkdGggPSB0ZXh0UmVjdC5zaXplLndpZHRoOworICAg ICAgICBfZm9udFNpemUgPSBhZGp1c3RlZEZvbnRTaXplKF9tYXhpbXVtVGV4dFdpZHRoLCBmb250 LCBpbml0aWFsRm9udFNpemUsIF9jb250ZW50Vmlldy5hc3Npc3RlZE5vZGVJbmZvcm1hdGlvbi5z ZWxlY3RPcHRpb25zKTsKKyAgICB9CisgICAgCisgICAgY29uc3QgV0tPcHRpb25JdGVtKiBpdGVt ID0gW3NlbGYgZmluZEl0ZW1BdDppbmRleFBhdGhdOworICAgIEFTU0VSVChpdGVtKTsKKyAgICAK KyAgICBbc2VsZiBwb3B1bGF0ZUNlbGw6Y2VsbCB3aXRoSXRlbTppdGVtXTsKKyAgICBbY2VsbC50 ZXh0TGFiZWwgc2V0Rm9udDpbZm9udCBmb250V2l0aFNpemU6X2ZvbnRTaXplXV07CisgICAgW2Nl bGwudGV4dExhYmVsIHNldExpbmVCcmVha01vZGU6TlNMaW5lQnJlYWtCeVdvcmRXcmFwcGluZ107 CisgICAgW2NlbGwudGV4dExhYmVsIHNldE51bWJlck9mTGluZXM6Ml07CisgICAgcmV0dXJuIGNl bGw7Cit9CisKKy0gKHZvaWQpdGFibGVWaWV3OihVSVRhYmxlVmlldyAqKXRhYmxlVmlldyBkaWRT ZWxlY3RSb3dBdEluZGV4UGF0aDooTlNJbmRleFBhdGggKilpbmRleFBhdGgKK3sKKyAgICBpZiAo X2NvbnRlbnRWaWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLnNlbGVjdE9wdGlvbnMuaXNFbXB0 eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgTlNJbnRlZ2VyIGl0ZW1JbmRleCA9IFtz ZWxmIGZpbmRJdGVtSW5kZXhBdDppbmRleFBhdGhdOworICAgIEFTU0VSVChpdGVtSW5kZXggIT0g TlNOb3RGb3VuZCk7CisgICAgCisgICAgaWYgKF9hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbikgewor ICAgICAgICBbdGFibGVWaWV3IGRlc2VsZWN0Um93QXRJbmRleFBhdGg6W3RhYmxlVmlldyBpbmRl eFBhdGhGb3JTZWxlY3RlZFJvd10gYW5pbWF0ZWQ6Tk9dOworICAgICAgICAKKyAgICAgICAgVUlU YWJsZVZpZXdDZWxsICpjZWxsID0gW3RhYmxlVmlldyBjZWxsRm9yUm93QXRJbmRleFBhdGg6aW5k ZXhQYXRoXTsKKyAgICAgICAgaWYgKCFjZWxsLnRleHRMYWJlbC5lbmFibGVkKQorICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICAKKyAgICAgICAgQk9PTCBuZXdTdGF0ZUlzU2VsZWN0ZWQgPSAo Y2VsbC5hY2Nlc3NvcnlUeXBlID09IFVJVGFibGVWaWV3Q2VsbEFjY2Vzc29yeU5vbmUpOworICAg ICAgICAKKyAgICAgICAgY2VsbC5hY2Nlc3NvcnlUeXBlID0gbmV3U3RhdGVJc1NlbGVjdGVkID8g VUlUYWJsZVZpZXdDZWxsQWNjZXNzb3J5Q2hlY2ttYXJrIDogVUlUYWJsZVZpZXdDZWxsQWNjZXNz b3J5Tm9uZTsKKyAgICAgICAgCisgICAgICAgIEFTU0VSVChpdGVtSW5kZXggIT0gTlNOb3RGb3Vu ZCk7CisgICAgICAgIAorICAgICAgICAvLyBUbyB0cmlnZ2VyIG9uY2hhbmdlIGV2ZW50cyBwcm9n cmFtbWF0aWNhbGx5IHdlIG5lZWQgdG8gZ28gdGhyb3VnaCB0aGlzCisgICAgICAgIC8vIFNQSSB3 aGljaCBtaW1pY3MgYSB1c2VyIGFjdGlvbiBvbiB0aGUgPHNlbGVjdD4uIE5vcm1hbGx5IHByb2dy YW1tYXRpYworICAgICAgICAvLyBjaGFuZ2VzIGRvIG5vdCB0cmlnZ2VyICJjaGFuZ2UiIGV2ZW50 cyBvbiBzdWNoIHNlbGVjdHMuCisgICAgCisgICAgICAgIFtfY29udGVudFZpZXcgcGFnZV0tPnNl dEFzc2lzdGVkTm9kZVNlbGVjdGVkSW5kZXgoaXRlbUluZGV4LCB0cnVlKTsKKyAgICAgICAgV0tP cHRpb25JdGVtJiBpdGVtID0gW19jb250ZW50VmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25z XVtpdGVtSW5kZXhdOworICAgICAgICBpdGVtLmlzU2VsZWN0ZWQgPSBuZXdTdGF0ZUlzU2VsZWN0 ZWQ7CisgICAgfSBlbHNlIHsKKyAgICAgICAgW3RhYmxlVmlldyBkZXNlbGVjdFJvd0F0SW5kZXhQ YXRoOmluZGV4UGF0aCBhbmltYXRlZDpOT107CisgICAgICAgIAorICAgICAgICAvLyBJdCBpcyBw b3NzaWJsZSBmb3IgdGhlcmUgdG8gYmUgbm8gc2VsZWN0aW9uLCBmb3IgZXhhbXBsZSB3aXRoIDxz ZWxlY3Qgc2l6ZT0iMiI+LgorICAgICAgICBOU0luZGV4UGF0aCAqb2xkSW5kZXhQYXRoID0gbmls OworICAgICAgICBpZiAoX3NpbmdsZVNlbGVjdGlvbkluZGV4ICE9IE5TTm90Rm91bmQpIHsKKyAg ICAgICAgICAgIG9sZEluZGV4UGF0aCA9IFtOU0luZGV4UGF0aCBpbmRleFBhdGhGb3JSb3c6X3Np bmdsZVNlbGVjdGlvbkluZGV4IGluU2VjdGlvbjpfc2luZ2xlU2VsZWN0aW9uU2VjdGlvbl07Cisg ICAgICAgICAgICBpZiAoW2luZGV4UGF0aCBpc0VxdWFsOm9sZEluZGV4UGF0aF0pIHsKKyAgICAg ICAgICAgICAgICBbX3BvcG92ZXIgX3VzZXJBY3Rpb25EaXNtaXNzZWRQb3BvdmVyOm5pbF07Cisg ICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAg IAorICAgICAgICBVSVRhYmxlVmlld0NlbGwgKm5ld0NlbGwgPSBbdGFibGVWaWV3IGNlbGxGb3JS b3dBdEluZGV4UGF0aDppbmRleFBhdGhdOworICAgICAgICAKKyAgICAgICAgaWYgKCFuZXdDZWxs LnRleHRMYWJlbC5lbmFibGVkKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAKKyAgICAg ICAgaWYgKG9sZEluZGV4UGF0aCkgeworICAgICAgICAgICAgVUlUYWJsZVZpZXdDZWxsICpvbGRD ZWxsID0gW3RhYmxlVmlldyBjZWxsRm9yUm93QXRJbmRleFBhdGg6b2xkSW5kZXhQYXRoXTsKKyAg ICAgICAgICAgIGlmIChvbGRDZWxsICYmIG9sZENlbGwuYWNjZXNzb3J5VHlwZSA9PSBVSVRhYmxl Vmlld0NlbGxBY2Nlc3NvcnlDaGVja21hcmspCisgICAgICAgICAgICAgICAgb2xkQ2VsbC5hY2Nl c3NvcnlUeXBlID0gVUlUYWJsZVZpZXdDZWxsQWNjZXNzb3J5Tm9uZTsKKyAgICAgICAgfQorICAg ICAgICAKKyAgICAgICAgaWYgKG5ld0NlbGwgJiYgbmV3Q2VsbC5hY2Nlc3NvcnlUeXBlID09IFVJ VGFibGVWaWV3Q2VsbEFjY2Vzc29yeU5vbmUpIHsKKyAgICAgICAgICAgIG5ld0NlbGwuYWNjZXNz b3J5VHlwZSA9IFVJVGFibGVWaWV3Q2VsbEFjY2Vzc29yeUNoZWNrbWFyazsKKyAgICAgICAgICAg IAorICAgICAgICAgICAgX3NpbmdsZVNlbGVjdGlvbkluZGV4ID0gaW5kZXhQYXRoLnJvdzsKKyAg ICAgICAgICAgIF9zaW5nbGVTZWxlY3Rpb25TZWN0aW9uID0gaW5kZXhQYXRoLnNlY3Rpb247Cisg CisgICAgICAgICAgICBbX2NvbnRlbnRWaWV3IHBhZ2VdLT5zZXRBc3Npc3RlZE5vZGVTZWxlY3Rl ZEluZGV4KGl0ZW1JbmRleCk7CisgICAgICAgICAgICBXS09wdGlvbkl0ZW0mIG5ld0l0ZW0gPSBb X2NvbnRlbnRWaWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdW2l0ZW1JbmRleF07CisgICAg ICAgICAgICBuZXdJdGVtLmlzU2VsZWN0ZWQgPSB0cnVlOworICAgICAgICB9CisgICAgICAgIAor ICAgICAgICAvLyBOZWVkIHRvIHVwZGF0ZSB0aGUgbW9kZWwgZXZlbiBpZiB0aGVyZSBpc24ndCBh IGNlbGwuCisgICAgICAgIGlmIChvbGRJbmRleFBhdGgpIHsKKyAgICAgICAgICAgIFdLT3B0aW9u SXRlbSogb2xkSXRlbSA9IFtzZWxmIGZpbmRJdGVtQXQ6b2xkSW5kZXhQYXRoXTsKKyAgICAgICAg ICAgIGlmIChvbGRJdGVtKQorICAgICAgICAgICAgICAgIG9sZEl0ZW0tPmlzU2VsZWN0ZWQgPSBm YWxzZTsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgW19wb3BvdmVyIF91c2VyQWN0aW9u RGlzbWlzc2VkUG9wb3ZlcjpuaWxdOworICAgIH0KK30KKworI3ByYWdtYSBtYXJrIFVJS2V5SW5w dXQgZGVsZWdhdGUgbWV0aG9kcworCistIChCT09MKWhhc1RleHQKK3sKKyAgICByZXR1cm4gTk87 Cit9CisKKy0gKHZvaWQpaW5zZXJ0VGV4dDooTlNTdHJpbmcgKil0ZXh0Cit7Cit9CisKKy0gKHZv aWQpZGVsZXRlQmFja3dhcmQKK3sKK30KKworQGVuZAorCitAaW1wbGVtZW50YXRpb24gV0tTZWxl Y3RQb3BvdmVyIHsKKyAgICBXS0NvbnRlbnRWaWV3ICpfdmlldzsKKyAgICBSZXRhaW5QdHI8V0tT ZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyPiBfdGFibGVWaWV3Q29udHJvbGxlcjsKKyAgICBSZXRh aW5QdHI8VUlLZXlib2FyZD4gX2tleWJvYXJkOworfQorCistIChpZClpbml0V2l0aFZpZXc6KFdL Q29udGVudFZpZXcgKil2aWV3IGhhc0dyb3VwczooQk9PTCloYXNHcm91cHMKK3sKKyAgICBpZiAo IShzZWxmID0gW3N1cGVyIGluaXRXaXRoVmlldzp2aWV3XSkpCisgICAgICAgIHJldHVybiBuaWw7 CisgICAgCisgICAgX3ZpZXcgPSB2aWV3OworICAgIENHUmVjdCBmcmFtZTsKKyAgICBmcmFtZS5v cmlnaW4gPSBDR1BvaW50WmVybzsKKyAgICBmcmFtZS5zaXplID0gW1VJS2V5Ym9hcmQgZGVmYXVs dFNpemVGb3JJbnRlcmZhY2VPcmllbnRhdGlvbjpbVUlBcHAgaW50ZXJmYWNlT3JpZW50YXRpb25d XTsKKyAgICBfa2V5Ym9hcmQgPSBhZG9wdE5TKFtbVUlLZXlib2FyZCBhbGxvY10gaW5pdFdpdGhG cmFtZTpmcmFtZV0pOworCisgICAgX3RhYmxlVmlld0NvbnRyb2xsZXIgPSBhZG9wdE5TKFtbV0tT ZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIGFsbG9jXSBpbml0V2l0aFZpZXc6dmlldyBoYXNHcm91 cHM6aGFzR3JvdXBzXSk7CisgICAgX3RhYmxlVmlld0NvbnRyb2xsZXIuZ2V0KCkucG9wb3ZlciA9 IHNlbGY7CisgICAgVUlWaWV3Q29udHJvbGxlciAqcG9wb3ZlclZpZXdDb250cm9sbGVyID0gX3Rh YmxlVmlld0NvbnRyb2xsZXIuZ2V0KCk7CisgICAgVUlOYXZpZ2F0aW9uQ29udHJvbGxlciAqbmF2 Q29udHJvbGxlciA9IG5pbDsKKyAgICBOU1N0cmluZyAqdGl0bGUgPSB2aWV3LmFzc2lzdGVkTm9k ZUluZm9ybWF0aW9uLnRpdGxlOworICAgIENHRmxvYXQgdGl0bGVIZWlnaHQgPSAwLjA7CisgICAg Qk9PTCBuZWVkc05hdmlnYXRpb25Db250cm9sbGVyID0gKF92aWV3ICYmIF9VSUFwcGxpY2F0aW9u VXNlc0xlZ2FjeVVJKCkpIHx8IFt0aXRsZSBsZW5ndGhdOworICAgIGlmIChuZWVkc05hdmlnYXRp b25Db250cm9sbGVyKSB7CisgICAgICAgIG5hdkNvbnRyb2xsZXIgPSBbW1VJTmF2aWdhdGlvbkNv bnRyb2xsZXIgYWxsb2NdIGluaXRXaXRoUm9vdFZpZXdDb250cm9sbGVyOl90YWJsZVZpZXdDb250 cm9sbGVyLmdldCgpXTsKKyAgICAgICAgcG9wb3ZlclZpZXdDb250cm9sbGVyID0gbmF2Q29udHJv bGxlcjsKKyAgICAgICAgCisgICAgICAgIGlmIChfdmlldy5hc3Npc3RlZE5vZGVJbmZvcm1hdGlv bi5pc011bHRpU2VsZWN0ICYmIF9VSUFwcGxpY2F0aW9uVXNlc0xlZ2FjeVVJKCkpCisgICAgICAg ICAgICBfdGFibGVWaWV3Q29udHJvbGxlci5nZXQoKS5uYXZpZ2F0aW9uSXRlbS5yaWdodEJhckJ1 dHRvbkl0ZW0gPSBbW1tVSUJhckJ1dHRvbkl0ZW0gYWxsb2NdIGluaXRXaXRoQmFyQnV0dG9uU3lz dGVtSXRlbTpVSUJhckJ1dHRvblN5c3RlbUl0ZW1Eb25lIHRhcmdldDpzZWxmIGFjdGlvbjpAc2Vs ZWN0b3IoX3VzZXJBY3Rpb25EaXNtaXNzZWRQb3BvdmVyOildIGF1dG9yZWxlYXNlXTsKKyAgICAg ICAgCisgICAgICAgIHRpdGxlSGVpZ2h0ID0gbmF2Q29udHJvbGxlci5uYXZpZ2F0aW9uQmFyLmJv dW5kcy5zaXplLmhlaWdodDsKKyAgICB9CisgICAgCisgICAgQ0dTaXplIHBvcG92ZXJTaXplID0g W190YWJsZVZpZXdDb250cm9sbGVyLmdldCgpLnRhYmxlVmlldyBzaXplVGhhdEZpdHM6Q0dTaXpl TWFrZSgzMjAsIENHRkxPQVRfTUFYKV07CisgICAgaWYgKG5lZWRzTmF2aWdhdGlvbkNvbnRyb2xs ZXIpCisgICAgICAgIFsoVUlOYXZpZ2F0aW9uQ29udHJvbGxlciAqKXBvcG92ZXJWaWV3Q29udHJv bGxlciB0b3BWaWV3Q29udHJvbGxlcl0ucHJlZmVycmVkQ29udGVudFNpemUgPSBwb3BvdmVyU2l6 ZTsKKyAgICBlbHNlCisgICAgICAgIHBvcG92ZXJWaWV3Q29udHJvbGxlci5wcmVmZXJyZWRDb250 ZW50U2l6ZSA9IHBvcG92ZXJTaXplOworICAgIAorICAgIHNlbGYucG9wb3ZlckNvbnRyb2xsZXIg PSBbW1tVSVBvcG92ZXJDb250cm9sbGVyIGFsbG9jXSBpbml0V2l0aENvbnRlbnRWaWV3Q29udHJv bGxlcjpwb3BvdmVyVmlld0NvbnRyb2xsZXJdIGF1dG9yZWxlYXNlXTsKKyAgICBbbmF2Q29udHJv bGxlciByZWxlYXNlXTsKKyAgICAKKyAgICBbW1VJS2V5Ym9hcmRJbXBsIHNoYXJlZEluc3RhbmNl XSBzZXREZWxlZ2F0ZTpfdGFibGVWaWV3Q29udHJvbGxlci5nZXQoKV07CisgICAgW19rZXlib2Fy ZCBzZXRTaXplOltVSUtleWJvYXJkIGRlZmF1bHRTaXplRm9ySW50ZXJmYWNlT3JpZW50YXRpb246 W1VJQXBwIGludGVyZmFjZU9yaWVudGF0aW9uXV1dOworICAgIFtfa2V5Ym9hcmQgcHJlcGFyZUZv ckdlb21ldHJ5Q2hhbmdlXTsKKyAgICBbX2tleWJvYXJkIGdlb21ldHJ5Q2hhbmdlRG9uZTpOT107 CisgICAgW19rZXlib2FyZCBhY3RpdmF0ZV07CisgICAgCisgICAgcmV0dXJuIHNlbGY7Cit9CisK Ky0gKHZvaWQpZGVhbGxvYworeworICAgIF90YWJsZVZpZXdDb250cm9sbGVyLmdldCgpLnBvcG92 ZXIgPSBuaWw7CisgICAgX3RhYmxlVmlld0NvbnRyb2xsZXIuZ2V0KCkudGFibGVWaWV3LmRhdGFT b3VyY2UgPSBuaWw7CisgICAgX3RhYmxlVmlld0NvbnRyb2xsZXIuZ2V0KCkudGFibGVWaWV3LmRl bGVnYXRlID0gbmlsOworICAgIAorICAgIF90YWJsZVZpZXdDb250cm9sbGVyID0gbmlsOworICAg CisgICAgW3N1cGVyIGRlYWxsb2NdOworfQorCistIChVSVZpZXcgKiljb250cm9sVmlldworewor ICAgIHJldHVybiBuaWw7Cit9CisKKy0gKHZvaWQpY29udHJvbEJlZ2luRWRpdGluZworeworICAg IFtzZWxmIHByZXNlbnRQb3BvdmVyQW5pbWF0ZWQ6Tk9dOworfQorCistICh2b2lkKWNvbnRyb2xF bmRFZGl0aW5nCit7Cit9CisKKy0gKHZvaWQpX3VzZXJBY3Rpb25EaXNtaXNzZWRQb3BvdmVyOihp ZClzZW5kZXIKK3sKKyAgICBbc2VsZiBhY2Nlc3NvcnlEb25lXTsKK30KKworQGVuZAorCisjZW5k aWYgIC8vIFBMQVRGT1JNKElPUykKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1dlYktpdDIueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9XZWJLaXQy Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDE2NDkzNCkKKysrIFNvdXJjZS9X ZWJLaXQyL1dlYktpdDIueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpA QCAtMTQwMiw2ICsxNDAyLDkgQEAKIAkJQzU0MjU2QjgxOEJFQzE4QzAwREU0MTc5IC8qIFdLRm9y bVBvcG92ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEM1NDI1NkIyMThCRUMxOEIwMERFNDE3OSAvKiBXS0Zvcm1Qb3BvdmVyLmggKi87IH07CiAJCUM1 NDI1NkI5MThCRUMxOEMwMERFNDE3OSAvKiBXS0Zvcm1Qb3BvdmVyLm1tIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU0MjU2QjMxOEJFQzE4QjAwREU0MTc5 IC8qIFdLRm9ybVBvcG92ZXIubW0gKi87IH07CiAJCUM1NDI1NkJBMThCRUMxOEMwMERFNDE3OSAv KiBXS0Zvcm1TZWxlY3RDb250cm9sLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBDNTQyNTZCNDE4QkVDMThDMDBERTQxNzkgLyogV0tGb3JtU2VsZWN0Q29u dHJvbC5oICovOyB9OworCQlDNTVDQjVCNzE4QzI2OUNGMDBDQTgxRTEgLyogV0tGb3JtU2VsZWN0 UG9wb3Zlci5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEM1NzE5M0JBMThDMTQ5RDAwMDJEMEYxMiAvKiBXS0Zvcm1TZWxlY3RQb3BvdmVyLm1tICovOyB9 OworCQlDNTVDQjVCODE4QzJBNUQ2MDBDQTgxRTEgLyogV0tGb3JtU2VsZWN0UGlja2VyLm1tIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU3MTkzQjkxOEMx NDlEMDAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdFBpY2tlci5tbSAqLzsgfTsKKwkJQzU3MTkzQkUx OEMxNEE0NDAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdENvbnRyb2wubW0gaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNTcxOTNCRDE4QzE0QTQzMDAyRDBGMTIg LyogV0tGb3JtU2VsZWN0Q29udHJvbC5tbSAqLzsgfTsKIAkJQzU3NEEzNzcxMkU2MDk5RDAwMkRG RTk4IC8qIFdlYkRyYWdDbGllbnRNYWMubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBDNTU0RkZBMjEyRTRFOEVBMDAyRjIyQzAgLyogV2ViRHJhZ0NsaWVu dE1hYy5tbSAqLzsgfTsKIAkJQzU3NEE1ODExMkU2NjY4MTAwMkRGRTk4IC8qIFBhc3RlYm9hcmRU eXBlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU3 NEE1N0YxMkU2NjY4MTAwMkRGRTk4IC8qIFBhc3RlYm9hcmRUeXBlcy5oICovOyB9OwogCQlDNTc0 QTU4MjEyRTY2NjgxMDAyREZFOTggLyogUGFzdGVib2FyZFR5cGVzLm1tIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzU3NEE1ODAxMkU2NjY4MTAwMkRGRTk4 IC8qIFBhc3RlYm9hcmRUeXBlcy5tbSAqLzsgfTsKQEAgLTMyMzcsNiArMzI0MCw5IEBACiAJCUM1 NDI1NkIzMThCRUMxOEIwMERFNDE3OSAvKiBXS0Zvcm1Qb3BvdmVyLm1tICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAub2JqY3BwOyBuYW1lID0gV0tGb3JtUG9wb3Zlci5tbTsgcGF0aCA9IGlvcy9m b3Jtcy9XS0Zvcm1Qb3BvdmVyLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDNTQy NTZCNDE4QkVDMThDMDBERTQxNzkgLyogV0tGb3JtU2VsZWN0Q29udHJvbC5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IG5hbWUgPSBXS0Zvcm1TZWxlY3RDb250cm9sLmg7IHBhdGggPSBpb3Mv Zm9ybXMvV0tGb3JtU2VsZWN0Q29udHJvbC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlDNTU0RkZBMjEyRTRFOEVBMDAyRjIyQzAgLyogV2ViRHJhZ0NsaWVudE1hYy5tbSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYkRyYWdDbGllbnRNYWMubW07IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUM1NzE5M0I5MThDMTQ5RDAwMDJEMEYxMiAvKiBX S0Zvcm1TZWxlY3RQaWNrZXIubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5h bWUgPSBXS0Zvcm1TZWxlY3RQaWNrZXIubW07IHBhdGggPSBpb3MvZm9ybXMvV0tGb3JtU2VsZWN0 UGlja2VyLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDNTcxOTNCQTE4QzE0OUQw MDAyRDBGMTIgLyogV0tGb3JtU2VsZWN0UG9wb3Zlci5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLm9iamNwcDsgbmFtZSA9IFdLRm9ybVNlbGVjdFBvcG92ZXIubW07IHBhdGggPSBpb3MvZm9y bXMvV0tGb3JtU2VsZWN0UG9wb3Zlci5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ QzU3MTkzQkQxOEMxNEE0MzAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdENvbnRyb2wubW0gKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBXS0Zvcm1TZWxlY3RDb250cm9sLm1t OyBwYXRoID0gaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdENvbnRyb2wubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUM1NzRBNTdGMTJFNjY2ODEwMDJERkU5OCAvKiBQYXN0ZWJvYXJkVHlw ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGFzdGVib2FyZFR5cGVzLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUM1NzRBNTgwMTJFNjY2ODEwMDJERkU5OCAv KiBQYXN0ZWJvYXJkVHlwZXMubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBh dGggPSBQYXN0ZWJvYXJkVHlwZXMubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUM1 OENERjI4MTg4NzU0OEIwMDg3MTUzNiAvKiBJbnRlcmFjdGlvbkluZm9ybWF0aW9uQXRQb3NpdGlv bi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnRlcmFjdGlvbkluZm9ybWF0 aW9uQXRQb3NpdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNjI3Nyw2ICs2 MjgzLDkgQEAKIAkJCQlDNTQyNTZCMjE4QkVDMThCMDBERTQxNzkgLyogV0tGb3JtUG9wb3Zlci5o ICovLAogCQkJCUM1NDI1NkIzMThCRUMxOEIwMERFNDE3OSAvKiBXS0Zvcm1Qb3BvdmVyLm1tICov LAogCQkJCUM1NDI1NkI0MThCRUMxOEMwMERFNDE3OSAvKiBXS0Zvcm1TZWxlY3RDb250cm9sLmgg Ki8sCisJCQkJQzU3MTkzQkQxOEMxNEE0MzAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdENvbnRyb2wu bW0gKi8sCisJCQkJQzU3MTkzQjkxOEMxNDlEMDAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdFBpY2tl ci5tbSAqLywKKwkJCQlDNTcxOTNCQTE4QzE0OUQwMDAyRDBGMTIgLyogV0tGb3JtU2VsZWN0UG9w b3Zlci5tbSAqLywKIAkJCSk7CiAJCQluYW1lID0gZm9ybXM7CiAJCQlzb3VyY2VUcmVlID0gIjxn cm91cD4iOwpAQCAtNzkwNSw2ICs3OTE0LDcgQEAKIAkJCQkxQTkxMDA3MjEyNjY3NUM0MDAxODQy RjUgLyogRmluZEluZGljYXRvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlCQ0U4MUQ4QzEzMTlG N0VGMDAyNDE5MTAgLyogRm9udEluZm8uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzc4RTFBNDkx ODIwOENENjAwMzEwMDdBIC8qIFdLTlNTdHJpbmcubW0gaW4gU291cmNlcyAqLywKKwkJCQlDNTVD QjVCODE4QzJBNUQ2MDBDQTgxRTEgLyogV0tGb3JtU2VsZWN0UGlja2VyLm1tIGluIFNvdXJjZXMg Ki8sCiAJCQkJQkMwNkY0MzAxMkRCQjlCNjAwMkQ3OERFIC8qIEdlb2xvY2F0aW9uUGVybWlzc2lv blJlcXVlc3RNYW5hZ2VyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUJDMDZGNDRCMTJEQkQxRjUw MDJENzhERSAvKiBHZW9sb2NhdGlvblBlcm1pc3Npb25SZXF1ZXN0TWFuYWdlclByb3h5LmNwcCBp biBTb3VyY2VzICovLAogCQkJCUJDMDZGNDNCMTJEQkNDRkIwMDJENzhERSAvKiBHZW9sb2NhdGlv blBlcm1pc3Npb25SZXF1ZXN0UHJveHkuY3BwIGluIFNvdXJjZXMgKi8sCkBAIC04MDMyLDYgKzgw NDIsNyBAQAogCQkJCTFBMkQ5MUE2MTI4MUQ3MzkwMDFFQjk2MiAvKiBQbHVnaW5Db250cm9sbGVy UHJveHlNYWMubW0gaW4gU291cmNlcyAqLywKIAkJCQkxQThFRjk2RTEyNTJBRjZCMDBGNzA2N0Yg LyogUGx1Z2luQ29udHJvbGxlclByb3h5TWVzc2FnZVJlY2VpdmVyLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTFBMTc5NzdGMTM3RUU4MkMwMEY5N0Q0NSAvKiBQbHVnaW5DcmVhdGlvblBhcmFtZXRl cnMuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJQzU1Q0I1QjcxOEMyNjlDRjAwQ0E4MUUxIC8qIFdL Rm9ybVNlbGVjdFBvcG92ZXIubW0gaW4gU291cmNlcyAqLywKIAkJCQk3QzNGOEM5MDE3M0FGNTJE MDA3QjdGMzkgLyogUGx1Z2luSW5mb3JtYXRpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0Mx MzVBQUMxNzNCMENGRjAwNTg2QUUyIC8qIFBsdWdpbkluZm9ybWF0aW9uTWFjLm1tIGluIFNvdXJj ZXMgKi8sCiAJCQkJMUFFRkNDMTMxMUQwMUY5NjAwODIxOUQzIC8qIFBsdWdpbkluZm9TdG9yZS5j cHAgaW4gU291cmNlcyAqLywKQEAgLTgyMjgsNiArODIzOSw3IEBACiAJCQkJNTExQjI0QUExMzJF MDk3MjAwMDY1QTBDIC8qIFdlYkljb25EYXRhYmFzZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk1 MTgzNDU5MjEzNDUzMkU5MDA5MkI2OTYgLyogV2ViSWNvbkRhdGFiYXNlQ2xpZW50LmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTUxRDAyRjY0MTMyRUM1QjkwMEJFQUE5NiAvKiBXZWJJY29uRGF0YWJh c2VNZXNzYWdlUmVjZWl2ZXIuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJQzU3MTkzQkUxOEMxNEE0 NDAwMkQwRjEyIC8qIFdLRm9ybVNlbGVjdENvbnRyb2wubW0gaW4gU291cmNlcyAqLywKIAkJCQk1 MTFCMjRBNjEzMkUwOTU3MDAwNjVBMEMgLyogV2ViSWNvbkRhdGFiYXNlUHJveHkuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJNTFEMDJGNkIxMzJFQzczNzAwQkVBQTk2IC8qIFdlYkljb25EYXRhYmFz ZVByb3h5TWVzc2FnZVJlY2VpdmVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUJDQ0Y2QUJDMTJD OTFFRjkwMDhGOUMzNSAvKiBXZWJJbWFnZS5jcHAgaW4gU291cmNlcyAqLywKSW5kZXg6IFNvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaAkocmV2aXNpb24gMTY0OTM0 KQorKysgU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaAkod29ya2lu ZyBjb3B5KQpAQCAtNDY3LDYgKzQ2Nyw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHBlcmZvcm1BY3Rp b25PbkVsZW1lbnQodWludDMyX3QgYWN0aW9uKTsKICAgICB2b2lkIHNldEFzc2lzdGVkTm9kZVZh bHVlKGNvbnN0IFN0cmluZyYpOwogICAgIHZvaWQgc2V0QXNzaXN0ZWROb2RlVmFsdWVBc051bWJl cihkb3VibGUpOworICAgIHZvaWQgc2V0QXNzaXN0ZWROb2RlU2VsZWN0ZWRJbmRleCh1aW50MzJf dCBpbmRleCwgYm9vbCBhbGxvd011bHRpcGxlU2VsZWN0aW9uKTsKICNlbmRpZgogCiAgICAgTm90 aWZpY2F0aW9uUGVybWlzc2lvblJlcXVlc3RNYW5hZ2VyKiBub3RpZmljYXRpb25QZXJtaXNzaW9u UmVxdWVzdE1hbmFnZXIoKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFn ZS9XZWJQYWdlLm1lc3NhZ2VzLmluCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmluCShyZXZpc2lvbiAxNjQ5MzQpCisrKyBT b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgkod29y a2luZyBjb3B5KQpAQCAtNjUsNiArNjUsNyBAQCBtZXNzYWdlcyAtPiBXZWJQYWdlIExlZ2FjeVJl Y2VpdmVyIHsKICAgICBQZXJmb3JtQWN0aW9uT25FbGVtZW50KHVpbnQzMl90IGFjdGlvbikKICAg ICBTZXRBc3Npc3RlZE5vZGVWYWx1ZShTdHJpbmcgdmFsdWUpCiAgICAgU2V0QXNzaXN0ZWROb2Rl VmFsdWVBc051bWJlcihkb3VibGUgdmFsdWUpCisgICAgU2V0QXNzaXN0ZWROb2RlU2VsZWN0ZWRJ bmRleCh1aW50MzJfdCBpbmRleCwgYm9vbCBhbGxvd011bHRpcGxlU2VsZWN0aW9uKQogI2VuZGlm CiAKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQpJbmRleDogU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9pb3MvV2ViUGFnZUlPUy5tbQkocmV2aXNpb24gMTY0OTM0 KQorKysgU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1t CSh3b3JraW5nIGNvcHkpCkBAIC01MCw2ICs1MCw4IEBACiAjaW1wb3J0IDxXZWJDb3JlL0hpdFRl c3RSZXN1bHQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSFRNTEVsZW1lbnRUeXBlSGVscGVycy5oPgog I2ltcG9ydCA8V2ViQ29yZS9IVE1MRm9ybUVsZW1lbnQuaD4KKyNpbXBvcnQgPFdlYkNvcmUvSFRN TE9wdEdyb3VwRWxlbWVudC5oPgorI2ltcG9ydCA8V2ViQ29yZS9IVE1MT3B0aW9uRWxlbWVudC5o PgogI2ltcG9ydCA8V2ViQ29yZS9IVE1MSW5wdXRFbGVtZW50Lmg+CiAjaW1wb3J0IDxXZWJDb3Jl L0hUTUxPcHRpb25FbGVtZW50Lmg+CiAjaW1wb3J0IDxXZWJDb3JlL0hUTUxQYXJzZXJJZGlvbXMu aD4KQEAgLTQxNiwxMSArNDE4LDE5IEBAIHZvaWQgV2ViUGFnZTo6c2V0QXNzaXN0ZWROb2RlVmFs dWVBc051bWIKICAgICB9CiB9CiAKK3ZvaWQgV2ViUGFnZTo6c2V0QXNzaXN0ZWROb2RlU2VsZWN0 ZWRJbmRleCh1aW50MzJfdCBpbmRleCwgYm9vbCBhbGxvd011bHRpcGxlU2VsZWN0aW9uKQorewor ICAgIGlmICghbV9hc3Npc3RlZE5vZGUgfHwgIWlzSFRNTFNlbGVjdEVsZW1lbnQobV9hc3Npc3Rl ZE5vZGUuZ2V0KCkpKQorICAgICAgICByZXR1cm47CisgICAgSFRNTFNlbGVjdEVsZW1lbnQqIHNl bGVjdCA9IHRvSFRNTFNlbGVjdEVsZW1lbnQobV9hc3Npc3RlZE5vZGUuZ2V0KCkpOworICAgIHNl bGVjdC0+b3B0aW9uU2VsZWN0ZWRCeVVzZXIoaW5kZXgsIHRydWUsIGFsbG93TXVsdGlwbGVTZWxl Y3Rpb24pOworfQorCiBzdGF0aWMgRmxvYXRRdWFkIGlubmVyRnJhbWVRdWFkKEZyYW1lKiBmcmFt ZSwgTm9kZSogYXNzaXN0ZWROb2RlKQogewogICAgIGZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVM YXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKTsKICAgICBSZW5kZXJPYmplY3QqIHJlbmRl cmVyOwotICAgIGlmIChhc3Npc3RlZE5vZGUtPmhhc1RhZ05hbWUoSFRNTE5hbWVzOjp0ZXh0YXJl YVRhZykgfHwgYXNzaXN0ZWROb2RlLT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6aW5wdXRUYWcpKQor ICAgIGlmIChhc3Npc3RlZE5vZGUtPmhhc1RhZ05hbWUoSFRNTE5hbWVzOjp0ZXh0YXJlYVRhZykg fHwgYXNzaXN0ZWROb2RlLT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6aW5wdXRUYWcpIHx8IGFzc2lz dGVkTm9kZS0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnNlbGVjdFRhZykpCiAgICAgICAgIHJlbmRl cmVyID0gYXNzaXN0ZWROb2RlLT5yZW5kZXJlcigpOwogICAgIGVsc2UKICAgICAgICAgcmVuZGVy ZXIgPSBhc3Npc3RlZE5vZGUtPnJvb3RFZGl0YWJsZUVsZW1lbnQoKS0+cmVuZGVyZXIoKTsKQEAg LTE0MTksNyArMTQyOSw4IEBAIHZvaWQgV2ViUGFnZTo6Z2V0UG9zaXRpb25JbmZvcm1hdGlvbihj b24KICAgICAgICAgaW5mby5jbGlja2FibGVFbGVtZW50TmFtZSA9IGhpdE5vZGUtPm5vZGVOYW1l KCk7CiAKICAgICAgICAgRWxlbWVudCogZWxlbWVudCA9IGhpdE5vZGUtPmlzRWxlbWVudE5vZGUo KSA/IHRvRWxlbWVudChoaXROb2RlKSA6IDA7Ci0gICAgICAgIGlmICghZWxlbWVudCkKKyAgICAg ICAgLy8gRklYTUU6IHNob3VsZCBub3QgcmV0dXJuIGhlcmUgYnV0IGRvIHdoYXQgaXMgdW5kZXIg aWYgKCFlbGVtZW50SXNMaW5rT3JJbWFnZSkKKyAgICAgICAgaWYgKGVsZW1lbnQpCiAgICAgICAg ICAgICByZXR1cm47CiAKICAgICAgICAgRWxlbWVudCogbGlua0VsZW1lbnQgPSBudWxscHRyOwpA QCAtMTUyOCw3ICsxNTM5LDcgQEAgc3RhdGljIGlubGluZSBib29sIGhhc0ZvY3VzYWJsZU5vZGUo Tm9kZQogICAgIGRvIHsKICAgICAgICAgbmV4dE5vZGUgPSBpc0ZvcndhcmQgPyBwYWdlLT5mb2N1 c0NvbnRyb2xsZXIoKS5uZXh0Rm9jdXNhYmxlRWxlbWVudChGb2N1c05hdmlnYXRpb25TY29wZTo6 Zm9jdXNOYXZpZ2F0aW9uU2NvcGVPZigmbmV4dE5vZGUtPmRvY3VtZW50KCkpLCBuZXh0Tm9kZSwg a2V5LmdldCgpKQogICAgICAgICAgICAgOiBwYWdlLT5mb2N1c0NvbnRyb2xsZXIoKS5wcmV2aW91 c0ZvY3VzYWJsZUVsZW1lbnQoRm9jdXNOYXZpZ2F0aW9uU2NvcGU6OmZvY3VzTmF2aWdhdGlvblNj b3BlT2YoJm5leHROb2RlLT5kb2N1bWVudCgpKSwgbmV4dE5vZGUsIGtleS5nZXQoKSk7Ci0gICAg fSB3aGlsZSAobmV4dE5vZGUgJiYgIWlzQXNzaXN0YWJsZU5vZGUoc3RhcnROb2RlKSk7CisgICAg fSB3aGlsZSAobmV4dE5vZGUgJiYgIWlzQXNzaXN0YWJsZU5vZGUobmV4dE5vZGUpKTsKIAogICAg IHJldHVybiBuZXh0Tm9kZTsKIH0KQEAgLTE1NDMsMTAgKzE1NTQsMjAgQEAgdm9pZCBXZWJQYWdl OjpnZXRBc3Npc3RlZE5vZGVJbmZvcm1hdGlvbgogICAgICAgICBIVE1MU2VsZWN0RWxlbWVudCog ZWxlbWVudCA9IHRvSFRNTFNlbGVjdEVsZW1lbnQobV9hc3Npc3RlZE5vZGUuZ2V0KCkpOwogICAg ICAgICBpbmZvcm1hdGlvbi5lbGVtZW50VHlwZSA9IFdLVHlwZVNlbGVjdDsKICAgICAgICAgc2l6 ZV90IGNvdW50ID0gZWxlbWVudC0+bGlzdEl0ZW1zKCkuc2l6ZSgpOwotICAgICAgICAvLyBGSVhN RTogV2UgbmVlZCB0byBoYW5kbGUgZ3JvdXAgZWxlbWVudHMgYXMgd2VsbAorICAgICAgICBpbnQg cGFyZW50R3JvdXBJRCA9IDA7CisgICAgICAgIC8vIFRoZSBwYXJlbnQgZ3JvdXAgSUQgaW5kaWNh dGVzIHRoZSBncm91cCB0aGUgb3B0aW9uIGJlbG9uZ3MgdG8gYW5kIGlzIDAgZm9yIGdyb3VwIGVs ZW1lbnRzLgorICAgICAgICAvLyBJZiB0aGVyZSBhcmUgb3B0aW9uIGVsZW1lbnRzIGluIGJldHdl ZW4gZ3JvdXBzLCB0aGV5IGFyZSBnaXZlbiBpdCdzIG93biBncm91cCBpZGVudGlmaWVyLgorICAg ICAgICAvLyBJZiBhIHNlbGVjdCBkb2VzIG5vdCBoYXZlIGdyb3VwcywgYWxsIHRoZSBvcHRpb24g ZWxlbWVudHMgaGF2ZSBncm91cCBJRCAwLgogICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8 IGNvdW50OyArK2kpIHsKLSAgICAgICAgICAgIEhUTUxPcHRpb25FbGVtZW50KiBpdGVtID0gdG9I VE1MT3B0aW9uRWxlbWVudChlbGVtZW50LT5saXN0SXRlbXMoKVtpXSk7Ci0gICAgICAgICAgICBp bmZvcm1hdGlvbi5zZWxlY3Rpb25PcHRpb25zLmFwcGVuZChpdGVtLT50ZXh0KCkpOworICAgICAg ICAgICAgSFRNTEVsZW1lbnQqIGl0ZW0gPSBlbGVtZW50LT5saXN0SXRlbXMoKVtpXTsKKyAgICAg ICAgICAgIGlmIChpc0hUTUxPcHRpb25FbGVtZW50KGl0ZW0pKSB7CisgICAgICAgICAgICAgICAg SFRNTE9wdGlvbkVsZW1lbnQqIG9wdGlvbiA9IHRvSFRNTE9wdGlvbkVsZW1lbnQoaXRlbSk7Cisg ICAgICAgICAgICAgICAgaW5mb3JtYXRpb24uc2VsZWN0T3B0aW9ucy5hcHBlbmQoV0tPcHRpb25J dGVtKG9wdGlvbi0+dGV4dCgpLCBmYWxzZSwgcGFyZW50R3JvdXBJRCwgb3B0aW9uLT5zZWxlY3Rl ZCgpLCBvcHRpb24tPmZhc3RIYXNBdHRyaWJ1dGUoV2ViQ29yZTo6SFRNTE5hbWVzOjpkaXNhYmxl ZEF0dHIpKSk7CisgICAgICAgICAgICB9IGVsc2UgaWYgKGlzSFRNTE9wdEdyb3VwRWxlbWVudChp dGVtKSkgeworICAgICAgICAgICAgICAgIEhUTUxPcHRHcm91cEVsZW1lbnQqIGdyb3VwID0gdG9I VE1MT3B0R3JvdXBFbGVtZW50KGl0ZW0pOworICAgICAgICAgICAgICAgIHBhcmVudEdyb3VwSUQr KzsKKyAgICAgICAgICAgICAgICBpbmZvcm1hdGlvbi5zZWxlY3RPcHRpb25zLmFwcGVuZChXS09w dGlvbkl0ZW0oZ3JvdXAtPmdyb3VwTGFiZWxUZXh0KCksIHRydWUsIDAsIGZhbHNlLCBncm91cC0+ ZmFzdEhhc0F0dHJpYnV0ZShXZWJDb3JlOjpIVE1MTmFtZXM6OmRpc2FibGVkQXR0cikpKTsKKyAg ICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICBpbmZvcm1hdGlvbi5zZWxlY3RlZEluZGV4 ID0gZWxlbWVudC0+c2VsZWN0ZWRJbmRleCgpOwogICAgICAgICBpbmZvcm1hdGlvbi5pc011bHRp U2VsZWN0ID0gZWxlbWVudC0+bXVsdGlwbGUoKTsKQEAgLTE2MDYsNyArMTYyNyw3IEBAIHZvaWQg V2ViUGFnZTo6Z2V0QXNzaXN0ZWROb2RlSW5mb3JtYXRpb24KIHZvaWQgV2ViUGFnZTo6ZWxlbWVu dERpZEZvY3VzKFdlYkNvcmU6Ok5vZGUqIG5vZGUpCiB7CiAgICAgbV9hc3Npc3RlZE5vZGUgPSBu b2RlOwotICAgIGlmIChub2RlLT5oYXNUYWdOYW1lKFdlYkNvcmU6OkhUTUxOYW1lczo6aW5wdXRU YWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUoV2ViQ29yZTo6SFRNTE5hbWVzOjp0ZXh0YXJlYVRhZykg fHwgbm9kZS0+aGFzRWRpdGFibGVTdHlsZSgpKSB7CisgICAgaWYgKG5vZGUtPmhhc1RhZ05hbWUo V2ViQ29yZTo6SFRNTE5hbWVzOjpzZWxlY3RUYWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUoV2ViQ29y ZTo6SFRNTE5hbWVzOjppbnB1dFRhZykgfHwgbm9kZS0+aGFzVGFnTmFtZShXZWJDb3JlOjpIVE1M TmFtZXM6OnRleHRhcmVhVGFnKSB8fCBub2RlLT5oYXNFZGl0YWJsZVN0eWxlKCkpIHsKICAgICAg ICAgQXNzaXN0ZWROb2RlSW5mb3JtYXRpb24gaW5mb3JtYXRpb247CiAgICAgICAgIGdldEFzc2lz dGVkTm9kZUluZm9ybWF0aW9uKGluZm9ybWF0aW9uKTsKICAgICAgICAgc2VuZChNZXNzYWdlczo6 V2ViUGFnZVByb3h5OjpTdGFydEFzc2lzdGluZ05vZGUoaW5mb3JtYXRpb24pKTsK 225892 2014-03-05 10:38:56 -0800 2014-03-05 11:08:17 -0800 Patch4 selectpickers.txt text/plain 19406 enrica SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDE2NTExMykKKysrIFNvdXJjZS9XZWJLaXQyL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDQ3IEBACisyMDE0LTAzLTA1ICBFbnJpY2Eg Q2FzdWNjaSAgPGVucmljYUBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXZWJLaXQyXSBzdXBw b3J0IG11bHRpLXNlbGVjdCBhbmQgc2VsZWN0IHdpdGggZ3JvdXBzIGZvciBpUGhvbmUuCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjkzNDQKKyAgICAg ICAgPHJkYXI6Ly9wcm9ibGVtLzE2MjA2OTI4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgaXMgdGhlIHJlbWFpbmluZyB3b3JrIG9uIHNlbGVj dCBlbGVtZW50IHN1cHBvcnQgb24gaU9TLgorICAgICAgICBUaGlzIGFkZHMgbXVsdGktc2VsZWN0 IGFuZCBzZWxlY3Qgd2l0aCBncm91cCBzdXBwb3J0IHdpdGggVUkKKyAgICAgICAgZm9yIGlQaG9u ZSB0aGF0IHVzZXMgVUlQaWNrZXJWaWV3LgorCisgICAgICAgICogVUlQcm9jZXNzL2lvcy9XS0Nv bnRlbnRWaWV3SW50ZXJhY3Rpb24ubW06CisgICAgICAgICgtW1dLQ29udGVudFZpZXcgcmVzaWdu Rmlyc3RSZXNwb25kZXJdKToKKyAgICAgICAgKC1bV0tDb250ZW50VmlldyBpbnB1dEFjY2Vzc29y eVZpZXddKTogUmVtb3ZlZCBpbmNvcnJlY3QgZWFybHkgcmV0dXJuLgorICAgICAgICAoLVtXS0Nv bnRlbnRWaWV3IF9zdG9wQXNzaXN0aW5nTm9kZV0pOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3Mv Zm9ybXMvV0tGb3JtU2VsZWN0Q29udHJvbC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9pb3MvZm9y bXMvV0tGb3JtU2VsZWN0Q29udHJvbC5tbToKKyAgICAgICAgKGFkanVzdGVkRm9udFNpemUpOiBN b3ZlZCBoZXJlIHRvIG1ha2UgaXQgYXZhaWxhYmxlIHRvIGJvdGggcGlja2VyIGFuZAorICAgICAg ICBwb3BvdmVyIGJhc2VkIGltcGxlbWVudGF0aW9ucy4KKyAgICAgICAgKC1bV0tGb3JtU2VsZWN0 Q29udHJvbCBpbml0V2l0aFZpZXc6XSk6CisgICAgICAgICogVUlQcm9jZXNzL2lvcy9mb3Jtcy9X S0Zvcm1TZWxlY3RQaWNrZXIubW06CisgICAgICAgIChzdHJpbmdCeVRyaW1taW5nV2hpdGVzcGFj ZUFuZE5ld2xpbmVzKToKKyAgICAgICAgKC1bV0tPcHRpb25QaWNrZXJDZWxsIF9pc1NlbGVjdGFi bGVdKToKKyAgICAgICAgKC1bV0tPcHRpb25QaWNrZXJDZWxsIGluaXRDb21tb25dKToKKyAgICAg ICAgKC1bV0tPcHRpb25QaWNrZXJDZWxsIGluaXRXaXRoT3B0aW9uSXRlbTpdKToKKyAgICAgICAg KC1bV0tPcHRpb25Hcm91cFBpY2tlckNlbGwgaW5pdFdpdGhPcHRpb25JdGVtOl0pOgorICAgICAg ICAoLVtXS09wdGlvbkdyb3VwUGlja2VyQ2VsbCBsYWJlbFdpZHRoRm9yQm91bmRzOl0pOgorICAg ICAgICAoLVtXS09wdGlvbkdyb3VwUGlja2VyQ2VsbCBsYXlvdXRTdWJ2aWV3c10pOgorICAgICAg ICAoLVtXS1NlbGVjdE11bHRpcGxlUGlja2VyIGluaXRXaXRoVmlldzpdKToKKyAgICAgICAgKC1b V0tTZWxlY3RNdWx0aXBsZVBpY2tlciBkZWFsbG9jXSk6CisgICAgICAgICgtW1dLU2VsZWN0TXVs dGlwbGVQaWNrZXIgY29udHJvbFZpZXddKToKKyAgICAgICAgKC1bV0tTZWxlY3RNdWx0aXBsZVBp Y2tlciBjb250cm9sQmVnaW5FZGl0aW5nXSk6CisgICAgICAgICgtW1dLU2VsZWN0TXVsdGlwbGVQ aWNrZXIgY29udHJvbEVuZEVkaXRpbmddKToKKyAgICAgICAgKC1bV0tTZWxlY3RNdWx0aXBsZVBp Y2tlciBsYXlvdXRTdWJ2aWV3c10pOgorICAgICAgICAoLVtXS1NlbGVjdE11bHRpcGxlUGlja2Vy IHBpY2tlclZpZXc6dmlld0ZvclJvdzpmb3JDb21wb25lbnQ6cmV1c2luZ1ZpZXc6XSk6CisgICAg ICAgICgtW1dLU2VsZWN0TXVsdGlwbGVQaWNrZXIgbnVtYmVyT2ZDb21wb25lbnRzSW5QaWNrZXJW aWV3Ol0pOgorICAgICAgICAoLVtXS1NlbGVjdE11bHRpcGxlUGlja2VyIHBpY2tlclZpZXc6bnVt YmVyT2ZSb3dzSW5Db21wb25lbnQ6XSk6CisgICAgICAgICgtW1dLU2VsZWN0TXVsdGlwbGVQaWNr ZXIgZmluZEl0ZW1JbmRleEF0Ol0pOgorICAgICAgICAoLVtXS1NlbGVjdE11bHRpcGxlUGlja2Vy IHBpY2tlclZpZXc6cm93OmNvbHVtbjpjaGVja2VkOl0pOgorICAgICAgICAoLVtXS1NlbGVjdFNp bmdsZVBpY2tlciBpbml0V2l0aFZpZXc6XSk6CisgICAgICAgICgtW1dLU2VsZWN0U2luZ2xlUGlj a2VyIGNvbnRyb2xFbmRFZGl0aW5nXSk6CisgICAgICAgICogVUlQcm9jZXNzL2lvcy9mb3Jtcy9X S0Zvcm1TZWxlY3RQb3BvdmVyLm1tOgorCiAyMDE0LTAzLTA0ICBCZW5qYW1pbiBQb3VsYWluICA8 YnBvdWxhaW5AYXBwbGUuY29tPgogCiAgICAgICAgIEZpeCB0aGUgYnVpbGQgYWZ0ZXIgcjE2NTA5 NQpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0NvbnRlbnRWaWV3SW50ZXJh Y3Rpb24ubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9XS0Nv bnRlbnRWaWV3SW50ZXJhY3Rpb24ubW0JKHJldmlzaW9uIDE2NTA4MSkKKysrIFNvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9pb3MvV0tDb250ZW50Vmlld0ludGVyYWN0aW9uLm1tCSh3b3JraW5nIGNv cHkpCkBAIC0yMjksNiArMjI5LDggQEAgLSAoQk9PTClyZXNpZ25GaXJzdFJlc3BvbmRlcgogewog ICAgIC8vIEZJWE1FOiBNYXliZSB3ZSBzaG91bGQgY2FsbCByZXNpZ25GaXJzdFJlc3BvbmRlciBv biB0aGUgc3VwZXJjbGFzcwogICAgIC8vIGFuZCBkbyBub3RoaW5nIGlmIHRoZSByZXR1cm4gdmFs dWUgaXMgTk8uCisgICAgLy8gV2UgbmVlZCB0byBjb21wbGV0ZSB0aGUgZWRpdGluZyBvcGVyYXRp b24gYmVmb3JlIHdlIGJsdXIgdGhlIGVsZW1lbnQuCisgICAgW19pbnB1dFBlcmlwaGVyYWwgZW5k RWRpdGluZ107CiAgICAgX3BhZ2UtPmJsdXJBc3Npc3RlZE5vZGUoKTsKICAgICBbc2VsZiBfY2Fu Y2VsSW50ZXJhY3Rpb25dOwogICAgIFtfd2ViU2VsZWN0aW9uQXNzaXN0YW50IHJlc2lnbmVkRmly c3RSZXNwb25kZXJdOwpAQCAtNzQxLDkgKzc0Myw2IEBAIC0gKHZvaWQpX2RpZEVuZFNjcm9sbGlu Z09yWm9vbWluZwogCiAtIChVSVZpZXcgKilpbnB1dEFjY2Vzc29yeVZpZXcKIHsKLSAgICBpZiAo IV9pc0VkaXRhYmxlKQotICAgICAgICByZXR1cm4gbmlsOwotICAgIAogICAgIGlmICghX2Zvcm1B Y2Nlc3NvcnlWaWV3KSB7CiAgICAgICAgIF9mb3JtQWNjZXNzb3J5VmlldyA9IGFkb3B0TlMoW1tV SVdlYkZvcm1BY2Nlc3NvcnkgYWxsb2NdIGluaXRdKTsKICAgICAgICAgW19mb3JtQWNjZXNzb3J5 VmlldyBzZXREZWxlZ2F0ZTpzZWxmXTsKQEAgLTE4ODMsNyArMTg4Miw2IEBAIC0gKHZvaWQpX3N0 YXJ0QXNzaXN0aW5nTm9kZTooY29uc3QgQXNzaXMKIC0gKHZvaWQpX3N0b3BBc3Npc3RpbmdOb2Rl CiB7CiAgICAgX2lzRWRpdGFibGUgPSBOTzsKLSAgICBbX2lucHV0UGVyaXBoZXJhbCBlbmRFZGl0 aW5nXTsKICAgICBfYXNzaXN0ZWROb2RlSW5mb3JtYXRpb24uZWxlbWVudFR5cGUgPSBXS1R5cGVO b25lOwogICAgIF9pbnB1dFBlcmlwaGVyYWwgPSBuaWw7CiAKSW5kZXg6IFNvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9pb3MvZm9ybXMvV0tGb3JtU2VsZWN0Q29udHJvbC5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9pb3MvZm9ybXMvV0tGb3JtU2VsZWN0Q29udHJvbC5o CShyZXZpc2lvbiAxNjUwNzQpCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1z L1dLRm9ybVNlbGVjdENvbnRyb2wuaAkod29ya2luZyBjb3B5KQpAQCAtMjUsMTEgKzI1LDE0IEBA CiAKICNpZiBQTEFURk9STShJT1MpCiAKKyNpbXBvcnQgIkFzc2lzdGVkTm9kZUluZm9ybWF0aW9u LmgiCiAjaW1wb3J0ICJXS0Zvcm1QZXJpcGhlcmFsLmgiCiAjaW1wb3J0ICJXS0Zvcm1Qb3BvdmVy LmgiCiAjaW1wb3J0IDxVSUtpdC9VSVBpY2tlclZpZXcuaD4KICNpbXBvcnQgPFVJS2l0L1VJUGlj a2VyVmlld19Qcml2YXRlLmg+CiAKK2V4dGVybiBDR0Zsb2F0IGFkanVzdGVkRm9udFNpemUoQ0dG bG9hdCB0ZXh0V2lkdGgsIFVJRm9udCAqZm9udCwgQ0dGbG9hdCBpbml0aWFsRm9udFNpemUsIGNv bnN0IFZlY3RvcjxXZWJLaXQ6OldLT3B0aW9uSXRlbT4mIGl0ZW1zKTsKKwogQGNsYXNzIFdLQ29u dGVudFZpZXc7CiAKIEBpbnRlcmZhY2UgV0tGb3JtU2VsZWN0Q29udHJvbCA6IE5TT2JqZWN0PFdL Rm9ybVBlcmlwaGVyYWw+CkBAIC00NSw1ICs0OCw5IEBACiAtIChpbnN0YW5jZXR5cGUpaW5pdFdp dGhWaWV3OihXS0NvbnRlbnRWaWV3ICopdmlldzsKIEBlbmQKIAorQGludGVyZmFjZSBXS1NlbGVj dE11bHRpcGxlUGlja2VyIDogVUlQaWNrZXJWaWV3IDxXS0Zvcm1Db250cm9sLCBVSVBpY2tlclZp ZXdEYXRhU291cmNlLCBVSVBpY2tlclZpZXdEZWxlZ2F0ZT4KKy0gKGluc3RhbmNldHlwZSlpbml0 V2l0aFZpZXc6KFdLQ29udGVudFZpZXcgKil2aWV3OworQGVuZAorCiAjZW5kaWYgLy8gUExBVEZP Uk0oSU9TKQogCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9y bVNlbGVjdENvbnRyb2wubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L2lvcy9mb3Jtcy9XS0Zvcm1TZWxlY3RDb250cm9sLm1tCShyZXZpc2lvbiAxNjUwNzQpCisrKyBT b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNlbGVjdENvbnRyb2wubW0J KHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0LDI1IEBACiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJL aXQ7CiAKK3N0YXRpYyBjb25zdCBDR0Zsb2F0IG1pbmltdW1PcHRpb25Gb250U2l6ZSA9IDEyOwor CitDR0Zsb2F0IGFkanVzdGVkRm9udFNpemUoQ0dGbG9hdCB0ZXh0V2lkdGgsIFVJRm9udCAqZm9u dCwgQ0dGbG9hdCBpbml0aWFsRm9udFNpemUsIGNvbnN0IFZlY3RvcjxXS09wdGlvbkl0ZW0+JiBp dGVtcykKK3sKKyAgICBDR0Zsb2F0IGFkanVzdGVkU2l6ZSA9IGluaXRpYWxGb250U2l6ZTsKKyAg ICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGl0ZW1zLnNpemUoKTsgKytpKSB7CisgICAgICAgIGNv bnN0IFdLT3B0aW9uSXRlbSYgaXRlbSA9IGl0ZW1zW2ldOworICAgICAgICBpZiAoaXRlbS50ZXh0 LmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIENHRmxvYXQgYWN0 dWFsRm9udFNpemUgPSBpbml0aWFsRm9udFNpemU7CisgICAgICAgIFsoTlNTdHJpbmcgKilpdGVt LnRleHQgX2xlZ2FjeV9zaXplV2l0aEZvbnQ6Zm9udCBtaW5Gb250U2l6ZTptaW5pbXVtT3B0aW9u Rm9udFNpemUgYWN0dWFsRm9udFNpemU6JmFjdHVhbEZvbnRTaXplIGZvcldpZHRoOnRleHRXaWR0 aCBsaW5lQnJlYWtNb2RlOk5TTGluZUJyZWFrQnlXb3JkV3JhcHBpbmddOworCisgICAgICAgIGlm IChhY3R1YWxGb250U2l6ZSA+IDAgJiYgYWN0dWFsRm9udFNpemUgPCBhZGp1c3RlZFNpemUpCisg ICAgICAgICAgICBhZGp1c3RlZFNpemUgPSBhY3R1YWxGb250U2l6ZTsKKyAgICB9CisgICAgcmV0 dXJuIGFkanVzdGVkU2l6ZTsKK30KKwogQGltcGxlbWVudGF0aW9uIFdLRm9ybVNlbGVjdENvbnRy b2wgewogICAgIFJldGFpblB0cjxpZDxXS0Zvcm1Db250cm9sPj4gX2NvbnRyb2w7CiB9CkBAIC02 MywxMCArODIsMTEgQEAgLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoVmlldzooV0tDb250ZW50Vgog CiAgICAgaWYgKFVJQ3VycmVudFVzZXJJbnRlcmZhY2VJZGlvbUlzUGFkKCkpCiAgICAgICAgIF9j b250cm9sID0gYWRvcHROUyhbW1dLU2VsZWN0UG9wb3ZlciBhbGxvY10gaW5pdFdpdGhWaWV3OnZp ZXcgaGFzR3JvdXBzOmhhc0dyb3Vwc10pOwotICAgIGVsc2UgaWYgKCF2aWV3LmFzc2lzdGVkTm9k ZUluZm9ybWF0aW9uLmlzTXVsdGlTZWxlY3QgJiYgIWhhc0dyb3VwcykKKyAgICBlbHNlIGlmICh2 aWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlzTXVsdGlTZWxlY3QgfHwgaGFzR3JvdXBzKQor ICAgICAgICBfY29udHJvbCA9IGFkb3B0TlMoW1tXS1NlbGVjdE11bHRpcGxlUGlja2VyIGFsbG9j XSBpbml0V2l0aFZpZXc6dmlld10pOworICAgIGVsc2UKICAgICAgICAgX2NvbnRyb2wgPSBhZG9w dE5TKFtbV0tTZWxlY3RTaW5nbGVQaWNrZXIgYWxsb2NdIGluaXRXaXRoVmlldzp2aWV3XSk7CiAg ICAgICAgIAotICAgIC8vIEZJWE1FOiBBZGQgc3VwcG9ydCBmb3IgaVBob25lIFVJIHdpdGggbXVs dGlzZWxlY3QgYW5kIG9yIGdyb3Vwcy4KICAgICByZXR1cm4gc2VsZjsKIH0KIApJbmRleDogU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9mb3Jtcy9XS0Zvcm1TZWxlY3RQaWNrZXIubW0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2lvcy9mb3Jtcy9XS0Zvcm1TZWxl Y3RQaWNrZXIubW0JKHJldmlzaW9uIDE2NTA3NCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9pb3MvZm9ybXMvV0tGb3JtU2VsZWN0UGlja2VyLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwx MiArMzYsMjkxIEBACiAjaW1wb3J0IDxVSUtpdC9VSUFwcGxpY2F0aW9uX1ByaXZhdGUuaD4KICNp bXBvcnQgPFVJS2l0L1VJRGV2aWNlX1ByaXZhdGUuaD4KICNpbXBvcnQgPFVJS2l0L1VJS2V5Ym9h cmRfUHJpdmF0ZS5oPgorI2ltcG9ydCA8VUlLaXQvVUlQaWNrZXJDb250ZW50Vmlld19Qcml2YXRl Lmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7 CiAKIHN0YXRpYyBjb25zdCBmbG9hdCBEaXNhYmxlZE9wdGlvbkFscGhhID0gMC4zOwogCitAaW50 ZXJmYWNlIFVJUGlja2VyVmlldyAoVUlQaWNrZXJWaWV3SW50ZXJuYWwpCistIChCT09MKWFsbG93 c011bHRpcGxlU2VsZWN0aW9uOworLSAodm9pZClzZXRBbGxvd3NNdWx0aXBsZVNlbGVjdGlvbjoo Qk9PTClhRmxhZzsKKy0gKFVJVGFibGVWaWV3Kil0YWJsZVZpZXdGb3JDb2x1bW46KE5TSW50ZWdl ciljb2x1bW47CitAZW5kCisKK3N0YXRpYyBOU1N0cmluZyAqc3RyaW5nQnlUcmltbWluZ1doaXRl c3BhY2VBbmROZXdsaW5lcyhOU1N0cmluZyAqc3RyaW5nKQoreworICAgIE5TUmFuZ2UgciA9IE5T TWFrZVJhbmdlKDAsIFtzdHJpbmcgbGVuZ3RoXSk7CisKKyAgICBpZiAoIXIubGVuZ3RoKQorICAg ICAgICByZXR1cm4gc3RyaW5nOworCisgICAgTlNVSW50ZWdlciBvcmlnaW5hbExlbmd0aCA9IHIu bGVuZ3RoOworCisgICAgLy8gRmlyc3Qgc3RyaXAgYWxsIHdoaXRlIHNwYWNlIG9mZiB0aGUgZW5k IG9mIHRoZSByYW5nZQorICAgIHdoaWxlIChyLmxlbmd0aCA+IDAgJiYgQ0ZVbmlDaGFySXNNZW1i ZXJPZihbc3RyaW5nIGNoYXJhY3RlckF0SW5kZXg6IHIubGVuZ3RoIC0gMV0sIGtDRlVuaUNoYXJX aGl0ZXNwYWNlQW5kTmV3bGluZUNoYXJhY3RlclNldCkpCisgICAgICAgIHIubGVuZ3RoIC09IDE7 CisKKyAgICAvLyBUaGVuLCB0cmltIGFueSB3aGl0ZXNwYWNlIGZyb20gdGhlIHN0YXJ0IG9mIHRo ZSByYW5nZS4KKyAgICB3aGlsZSAoci5sZW5ndGggPiAwICYmIENGVW5pQ2hhcklzTWVtYmVyT2Yo W3N0cmluZyBjaGFyYWN0ZXJBdEluZGV4OiByLmxvY2F0aW9uXSwga0NGVW5pQ2hhcldoaXRlc3Bh Y2VBbmROZXdsaW5lQ2hhcmFjdGVyU2V0KSkgeworICAgICAgICByLmxvY2F0aW9uICs9IDE7Cisg ICAgICAgIHIubGVuZ3RoIC09IDE7CisgICAgfQorCisgICAgLy8gSWYgd2UgY2hhbmdlZCB0aGUg bGVuZ3RoIG9mIHRoZSBzdHJpbmcgZnJvbSB3aGF0IGl0IG9yaWdpbmFsbHkgd2FzLCByZXR1cm4g YSBuZXcgc3RyaW5nIHdpdGgganVzdCB0aG9zZQorICAgIC8vIGNoYXJhY3RlcnMuICBPdGhlcndp c2UganVzdCByZXR1cm4uCisgICAgaWYgKG9yaWdpbmFsTGVuZ3RoICE9IHIubGVuZ3RoKQorICAg ICAgICByZXR1cm4gW3N0cmluZyBzdWJzdHJpbmdXaXRoUmFuZ2U6cl07CisKKyAgICByZXR1cm4g c3RyaW5nOworfQorCitAaW50ZXJmYWNlIFdLT3B0aW9uUGlja2VyQ2VsbCA6IFVJUGlja2VyQ29u dGVudFZpZXcgeworICAgIEJPT0wgX2Rpc2FibGVkOworfQorCitAcHJvcGVydHkobm9uYXRvbWlj KSBCT09MIGRpc2FibGVkOworCistIChpbnN0YW5jZXR5cGUpaW5pdENvbW1vbjsKKy0gKGluc3Rh bmNldHlwZSlpbml0V2l0aE9wdGlvbkl0ZW06KGNvbnN0IFdLT3B0aW9uSXRlbSYpaXRlbTsKKwor QGVuZAorCitAaW1wbGVtZW50YXRpb24gV0tPcHRpb25QaWNrZXJDZWxsCisKKy0gKEJPT0wpX2lz U2VsZWN0YWJsZQoreworICAgIHJldHVybiAhc2VsZi5kaXNhYmxlZDsKK30KKworLSAoaW5zdGFu Y2V0eXBlKWluaXRDb21tb24KK3sKKyAgICBpZiAoIShzZWxmID0gW3N1cGVyIGluaXRXaXRoRnJh bWU6Q0dSZWN0WmVyb10pKQorICAgICAgICByZXR1cm4gbmlsOworICAgIFtzZWxmLnRpdGxlTGFi ZWwgc2V0TGluZUJyZWFrTW9kZTpOU0xpbmVCcmVha0J5VHJ1bmNhdGluZ01pZGRsZV07CisgICAg cmV0dXJuIHNlbGY7Cit9CisKKy0gKGluc3RhbmNldHlwZSlpbml0V2l0aE9wdGlvbkl0ZW06KGNv bnN0IFdLT3B0aW9uSXRlbSYpaXRlbQoreworICAgIGlmICghKHNlbGYgPSBbc2VsZiBpbml0Q29t bW9uXSkpCisgICAgICAgIHJldHVybiBuaWw7CisKKyAgICBzZWxmLnRpdGxlTGFiZWwudGV4dCA9 IHN0cmluZ0J5VHJpbW1pbmdXaGl0ZXNwYWNlQW5kTmV3bGluZXMoaXRlbS50ZXh0KTsKKyAgICBz ZWxmLmNoZWNrZWQgPSBpdGVtLmlzU2VsZWN0ZWQ7CisgICAgc2VsZi5kaXNhYmxlZCA9IGl0ZW0u ZGlzYWJsZWQ7CisgICAgaWYgKHNlbGYuZGlzYWJsZWQpCisgICAgICAgIHNlbGYudGl0bGVMYWJl bC50ZXh0Q29sb3IgPSBbVUlDb2xvciBjb2xvcldpdGhXaGl0ZTowLjAgYWxwaGE6RGlzYWJsZWRP cHRpb25BbHBoYV07CisKKyAgICByZXR1cm4gc2VsZjsKK30KKworQGVuZAorCisKK0BpbnRlcmZh Y2UgV0tPcHRpb25Hcm91cFBpY2tlckNlbGwgOiBXS09wdGlvblBpY2tlckNlbGwKKy0gKGluc3Rh bmNldHlwZSlpbml0V2l0aE9wdGlvbkl0ZW06KGNvbnN0IFdLT3B0aW9uSXRlbSYpaXRlbTsKK0Bl bmQKKworQGltcGxlbWVudGF0aW9uIFdLT3B0aW9uR3JvdXBQaWNrZXJDZWxsCisKKy0gKGluc3Rh bmNldHlwZSlpbml0V2l0aE9wdGlvbkl0ZW06KGNvbnN0IFdLT3B0aW9uSXRlbSYpaXRlbQorewor ICAgIGlmICghKHNlbGYgPSBbc2VsZiBpbml0Q29tbW9uXSkpCisgICAgICAgIHJldHVybiBuaWw7 CisKKyAgICBzZWxmLnRpdGxlTGFiZWwudGV4dCA9IHN0cmluZ0J5VHJpbW1pbmdXaGl0ZXNwYWNl QW5kTmV3bGluZXMoaXRlbS50ZXh0KTsKKyAgICBzZWxmLmNoZWNrZWQgPSBOTzsKKyAgICBzZWxm LnRpdGxlTGFiZWwudGV4dENvbG9yID0gW1VJQ29sb3IgY29sb3JXaXRoV2hpdGU6MC4wIGFscGhh OjAuNV07CisgICAgc2VsZi5kaXNhYmxlZCA9IFlFUzsKKworICAgIHJldHVybiBzZWxmOworfQor CistIChDR0Zsb2F0KWxhYmVsV2lkdGhGb3JCb3VuZHM6KENHUmVjdClib3VuZHMKK3sKKyAgICBy ZXR1cm4gQ0dSZWN0R2V0V2lkdGgoYm91bmRzKSAtIFtVSVBpY2tlckNvbnRlbnRWaWV3IF9jaGVj a21hcmtPZmZzZXRdOworfQorCistICh2b2lkKWxheW91dFN1YnZpZXdzCit7CisgICAgaWYgKCFz ZWxmLnRpdGxlTGFiZWwpCisgICAgICAgIHJldHVybjsKKworICAgIENHUmVjdCBib3VuZHMgPSBz ZWxmLmJvdW5kczsKKyAgICBzZWxmLnRpdGxlTGFiZWwuZnJhbWUgPSBDR1JlY3RNYWtlKFtVSVBp Y2tlckNvbnRlbnRWaWV3IF9jaGVja21hcmtPZmZzZXRdLCAwLCBDR1JlY3RHZXRNYXhYKGJvdW5k cykgLSBbVUlQaWNrZXJDb250ZW50VmlldyBfY2hlY2ttYXJrT2Zmc2V0XSwgQ0dSZWN0R2V0SGVp Z2h0KGJvdW5kcykpOworfQorCitAZW5kCisKKworQGltcGxlbWVudGF0aW9uIFdLU2VsZWN0TXVs dGlwbGVQaWNrZXIgeworICAgIFdLQ29udGVudFZpZXcgKl92aWV3OworICAgIE5TVGV4dEFsaWdu bWVudCBfdGV4dEFsaWdubWVudDsKKyAgICBOU1VJbnRlZ2VyIF9zaW5nbGVTZWxlY3Rpb25JbmRl eDsKKyAgICBib29sIF9hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbjsKKyAgICBmbG9hdCBfbGF5b3V0 V2lkdGg7CisgICAgQ0dGbG9hdCBfZm9udFNpemU7CisgICAgQ0dGbG9hdCBfbWF4aW11bVRleHRX aWR0aDsKK30KKworLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoVmlldzooV0tDb250ZW50VmlldyAq KXZpZXcKK3sKKyAgICBpZiAoIShzZWxmID0gW3N1cGVyIGluaXRXaXRoRnJhbWU6Q0dSZWN0WmVy b10pKQorICAgICAgICByZXR1cm4gbmlsOworCisgICAgX3ZpZXcgPSB2aWV3OworICAgIF9hbGxv d3NNdWx0aXBsZVNlbGVjdGlvbiA9IF92aWV3LmFzc2lzdGVkTm9kZUluZm9ybWF0aW9uLmlzTXVs dGlTZWxlY3Q7CisgICAgX3NpbmdsZVNlbGVjdGlvbkluZGV4ID0gTlNOb3RGb3VuZDsKKyAgICBz ZWxmLmF1dG9yZXNpemluZ01hc2sgPSBVSVZpZXdBdXRvcmVzaXppbmdGbGV4aWJsZVdpZHRoIHwg VUlWaWV3QXV0b3Jlc2l6aW5nRmxleGlibGVIZWlnaHQ7CisgICAgc2VsZi5kYXRhU291cmNlID0g c2VsZjsKKyAgICBzZWxmLmRlbGVnYXRlID0gc2VsZjsKKyAgICBbc2VsZiBfc2V0VXNlc0NoZWNr ZWRTZWxlY3Rpb246WUVTXTsKKworICAgIHNlbGYuX21hZ25pZmllckVuYWJsZWQgPSBOTzsKKwor ICAgIFVJVGV4dFdyaXRpbmdEaXJlY3Rpb24gd3JpdGluZ0RpcmVjdGlvbiA9IFVJVGV4dFdyaXRp bmdEaXJlY3Rpb25MZWZ0VG9SaWdodDsKKyAgICAvLyBGSVhNRTogcmV0cmlldmUgZnJvbSBXZWJQ cm9jZXNzIHdyaXRpbmcgZGlyZWN0aW9uLgorICAgIF90ZXh0QWxpZ25tZW50ID0gKHdyaXRpbmdE aXJlY3Rpb24gPT0gVUlUZXh0V3JpdGluZ0RpcmVjdGlvbkxlZnRUb1JpZ2h0KSA/IE5TVGV4dEFs aWdubWVudExlZnQgOiBOU1RleHRBbGlnbm1lbnRSaWdodDsKKworICAgIFtzZWxmIHNldEFsbG93 c011bHRpcGxlU2VsZWN0aW9uOl9hbGxvd3NNdWx0aXBsZVNlbGVjdGlvbl07CisgICAgW3NlbGYg c2V0U2l6ZTpbVUlLZXlib2FyZCBkZWZhdWx0U2l6ZUZvckludGVyZmFjZU9yaWVudGF0aW9uOltV SUFwcCBpbnRlcmZhY2VPcmllbnRhdGlvbl1dXTsKKyAgICBbc2VsZiByZWxvYWRBbGxDb21wb25l bnRzXTsKKworICAgIGNvbnN0IFZlY3RvcjxXS09wdGlvbkl0ZW0+JiBzZWxlY3RPcHRpb25zID0g W192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdOworICAgIGludCBjdXJyZW50SW5kZXgg PSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgc2VsZWN0T3B0aW9ucy5zaXplKCk7ICsr aSkgeworICAgICAgICBjb25zdCBXS09wdGlvbkl0ZW0mIGl0ZW0gPSBzZWxlY3RPcHRpb25zW2ld OworICAgICAgICBpZiAoaXRlbS5pc0dyb3VwKQorICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgaWYgKCFfYWxsb3dzTXVsdGlwbGVTZWxlY3Rpb24gJiYgaXRlbS5pc1NlbGVjdGVkKSB7 CisgICAgICAgICAgICBfc2luZ2xlU2VsZWN0aW9uSW5kZXggPSBjdXJyZW50SW5kZXg7CisgICAg ICAgIH0KKyAgICAgICAgY3VycmVudEluZGV4Kys7CisgICAgfQorCisgICAgaWYgKF9zaW5nbGVT ZWxlY3Rpb25JbmRleCAhPSBOU05vdEZvdW5kKQorICAgICAgICBbc2VsZiBzZWxlY3RSb3c6X3Np bmdsZVNlbGVjdGlvbkluZGV4IGluQ29tcG9uZW50OjAgYW5pbWF0ZWQ6Tk9dOworICAgIAorICAg IHJldHVybiBzZWxmOworfQorCistICh2b2lkKWRlYWxsb2MKK3sKKyAgICBzZWxmLmRhdGFTb3Vy Y2UgPSBuaWw7CisgICAgc2VsZi5kZWxlZ2F0ZSA9IG5pbDsKKworICAgIFtzdXBlciBkZWFsbG9j XTsKK30KKworLSAoVUlWaWV3ICopY29udHJvbFZpZXcKK3sKKyAgICByZXR1cm4gc2VsZjsKK30K KworLSAodm9pZCljb250cm9sQmVnaW5FZGl0aW5nCit7Cit9CisKKy0gKHZvaWQpY29udHJvbEVu ZEVkaXRpbmcKK3sKK30KKworLSAodm9pZClsYXlvdXRTdWJ2aWV3cworeworICAgIFtzdXBlciBs YXlvdXRTdWJ2aWV3c107CisgICAgaWYgKF9zaW5nbGVTZWxlY3Rpb25JbmRleCAhPSBOU05vdEZv dW5kKSB7CisgICAgICAgIFtzZWxmIHNlbGVjdFJvdzpfc2luZ2xlU2VsZWN0aW9uSW5kZXggaW5D b21wb25lbnQ6MCBhbmltYXRlZDpOT107CisgICAgfQorCisgICAgLy8gTWFrZSBzdXJlIGFsbCBy b3dzIGFyZSBzaXplZCBwcm9wZXJseSBhZnRlciBhIHJvdGF0aW9uLgorICAgIGlmIChfbGF5b3V0 V2lkdGggIT0gc2VsZi5mcmFtZS5zaXplLndpZHRoKSB7CisgICAgICAgIFtzZWxmIHJlbG9hZEFs bENvbXBvbmVudHNdOworICAgICAgICBfbGF5b3V0V2lkdGggPSBzZWxmLmZyYW1lLnNpemUud2lk dGg7CisgICAgfQorfQorCistIChVSVZpZXcgKilwaWNrZXJWaWV3OihVSVBpY2tlclZpZXcgKilw aWNrZXJWaWV3IHZpZXdGb3JSb3c6KE5TSW50ZWdlcilyb3dJbmRleCBmb3JDb21wb25lbnQ6KE5T SW50ZWdlciljb2x1bW5JbmRleCByZXVzaW5nVmlldzooVUlWaWV3ICopdmlldworeworICAgIGNv bnN0IFdLT3B0aW9uSXRlbSYgaXRlbSA9IFtfdmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25z XVtyb3dJbmRleF07CisgICAgVUlQaWNrZXJDb250ZW50VmlldyogcGlja2VySXRlbSA9IGl0ZW0u aXNHcm91cCA/IFtbW1dLT3B0aW9uR3JvdXBQaWNrZXJDZWxsIGFsbG9jXSBpbml0V2l0aE9wdGlv bkl0ZW06aXRlbV0gYXV0b3JlbGVhc2VdIDogW1tbV0tPcHRpb25QaWNrZXJDZWxsIGFsbG9jXSBp bml0V2l0aE9wdGlvbkl0ZW06aXRlbV0gYXV0b3JlbGVhc2VdOworCisgICAgLy8gVGhlIGNlbGwg c3RhcnRzIG91dCB3aXRoIGEgbnVsbCBmcmFtZS4gV2UgbmVlZCB0byBzZXQgaXRzIGZyYW1lIG5v dyBzbyB3ZSBjYW4gZmluZCB0aGUgcmlnaHQgZm9udCBzaXplLgorICAgIFVJVGFibGVWaWV3ICp0 YWJsZSA9IFtwaWNrZXJWaWV3IHRhYmxlVmlld0ZvckNvbHVtbjowXTsKKyAgICBDR1JlY3QgZnJh bWUgPSBbdGFibGUgcmVjdEZvclJvd0F0SW5kZXhQYXRoOltOU0luZGV4UGF0aCBpbmRleFBhdGhG b3JSb3c6cm93SW5kZXggaW5TZWN0aW9uOjBdXTsKKyAgICBwaWNrZXJJdGVtLmZyYW1lID0gZnJh bWU7CisKKyAgICBVSUxhYmVsICp0aXRsZVRleHRMYWJlbCA9IHBpY2tlckl0ZW0udGl0bGVMYWJl bDsKKyAgICBmbG9hdCB3aWR0aCA9IFtwaWNrZXJJdGVtIGxhYmVsV2lkdGhGb3JCb3VuZHM6Q0dS ZWN0TWFrZSgwLCAwLCBDR1JlY3RHZXRXaWR0aChmcmFtZSksIENHUmVjdEdldEhlaWdodChmcmFt ZSkpXTsKKyAgICBBU1NFUlQod2lkdGggPiAwKTsKKworICAgIC8vIEFzc3VtZSBhbGwgY2VsbHMg aGF2ZSB0aGUgc2FtZSBhdmFpbGFibGUgdGV4dCB3aWR0aC4KKyAgICBVSUZvbnQgKmZvbnQgPSB0 aXRsZVRleHRMYWJlbC5mb250OworICAgIGlmICh3aWR0aCAhPSBfbWF4aW11bVRleHRXaWR0aCB8 fCBfZm9udFNpemUgPT0gMCkgeworICAgICAgICBfbWF4aW11bVRleHRXaWR0aCA9IHdpZHRoOwor ICAgICAgICBfZm9udFNpemUgPSBhZGp1c3RlZEZvbnRTaXplKF9tYXhpbXVtVGV4dFdpZHRoLCBm b250LCB0aXRsZVRleHRMYWJlbC5mb250LnBvaW50U2l6ZSwgW192aWV3IGFzc2lzdGVkTm9kZVNl bGVjdE9wdGlvbnNdKTsKKyAgICB9CisKKyAgICBbdGl0bGVUZXh0TGFiZWwgc2V0Rm9udDpbZm9u dCBmb250V2l0aFNpemU6X2ZvbnRTaXplXV07CisgICAgW3RpdGxlVGV4dExhYmVsIHNldExpbmVC cmVha01vZGU6TlNMaW5lQnJlYWtCeVdvcmRXcmFwcGluZ107CisgICAgW3RpdGxlVGV4dExhYmVs IHNldE51bWJlck9mTGluZXM6Ml07CisgICAgW3RpdGxlVGV4dExhYmVsIHNldFRleHRBbGlnbm1l bnQ6X3RleHRBbGlnbm1lbnRdOworCisgICAgcmV0dXJuIHBpY2tlckl0ZW07Cit9CisKKy0gKE5T SW50ZWdlciludW1iZXJPZkNvbXBvbmVudHNJblBpY2tlclZpZXc6KFVJUGlja2VyVmlldyAqKWFQ aWNrZXJWaWV3Cit7CisgICAgcmV0dXJuIDE7Cit9CisKKy0gKE5TSW50ZWdlcilwaWNrZXJWaWV3 OihVSVBpY2tlclZpZXcgKilwaWNrZXJWaWV3IG51bWJlck9mUm93c0luQ29tcG9uZW50OihOU0lu dGVnZXIpY29sdW1uSW5kZXgKK3sKKyAgICByZXR1cm4gW192aWV3IGFzc2lzdGVkTm9kZVNlbGVj dE9wdGlvbnNdLnNpemUoKTsKK30KKworLSAoTlNJbnRlZ2VyKWZpbmRJdGVtSW5kZXhBdDooaW50 KXJvd0luZGV4Cit7CisgICAgQVNTRVJUKHJvd0luZGV4ID49IDAgJiYgKHNpemVfdClyb3dJbmRl eCA8IFtfdmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXS5zaXplKCkpOworICAgIE5TSW50 ZWdlciBpdGVtSW5kZXggPSAwOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgcm93SW5kZXg7ICsr aSkgeworICAgICAgICBpZiAoW192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdW2ldLmlz R3JvdXApCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgaXRlbUluZGV4Kys7CisgICAg fQorCisgICAgQVNTRVJUKGl0ZW1JbmRleCA+PSAwKTsKKyAgICByZXR1cm4gaXRlbUluZGV4Owor fQorCistICh2b2lkKXBpY2tlclZpZXc6KFVJUGlja2VyVmlldyAqKXBpY2tlclZpZXcgcm93Oihp bnQpcm93SW5kZXggY29sdW1uOihpbnQpY29sdW1uSW5kZXggY2hlY2tlZDooQk9PTClpc0NoZWNr ZWQKK3sKKyAgICBpZiAoKHNpemVfdClyb3dJbmRleCA+PSBbX3ZpZXcgYXNzaXN0ZWROb2RlU2Vs ZWN0T3B0aW9uc10uc2l6ZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBXS09wdGlvbkl0ZW0m IGl0ZW0gPSBbX3ZpZXcgYXNzaXN0ZWROb2RlU2VsZWN0T3B0aW9uc11bcm93SW5kZXhdOworCisg ICAgaWYgKFtzZWxmIGFsbG93c011bHRpcGxlU2VsZWN0aW9uXSkgeworICAgICAgICBbX3ZpZXcg cGFnZV0tPnNldEFzc2lzdGVkTm9kZVNlbGVjdGVkSW5kZXgoW3NlbGYgZmluZEl0ZW1JbmRleEF0 OnJvd0luZGV4XSwgaXNDaGVja2VkKTsKKyAgICAgICAgaXRlbS5pc1NlbGVjdGVkID0gaXNDaGVj a2VkOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIFNpbmdsZSBzZWxlY3Rpb24uCisgICAgICAg IGl0ZW0uaXNTZWxlY3RlZCA9IE5POworICAgICAgICBfc2luZ2xlU2VsZWN0aW9uSW5kZXggPSBy b3dJbmRleDsKKworICAgICAgICAvLyBUaGlzIHByaXZhdGUgZGVsZWdhdGUgb2Z0ZW4gZ2V0cyBj YWxsZWQgZm9yIG11bHRpcGxlIHJvd3MgaW4gdGhlIHBpY2tlciwKKyAgICAgICAgLy8gc28gd2Ug b25seSBhY3RpdmF0ZSBhbmQgc2V0IGFzIHNlbGVjdGVkIHRoZSBjaGVja2VkIGl0ZW0gaW4gc2lu Z2xlIHNlbGVjdGlvbi4KKyAgICAgICAgaWYgKGlzQ2hlY2tlZCkgeworICAgICAgICAgICAgW192 aWV3IHBhZ2VdLT5zZXRBc3Npc3RlZE5vZGVTZWxlY3RlZEluZGV4KFtzZWxmIGZpbmRJdGVtSW5k ZXhBdDpyb3dJbmRleF0sIGlzQ2hlY2tlZCk7CisgICAgICAgICAgICBpdGVtLmlzU2VsZWN0ZWQg PSBZRVM7CisgICAgICAgIH0KKyAgICB9Cit9CisKK0BlbmQKKwogQGltcGxlbWVudGF0aW9uIFdL U2VsZWN0U2luZ2xlUGlja2VyIHsKICAgICBXS0NvbnRlbnRWaWV3ICpfdmlldzsKICAgICBOU0lu dGVnZXIgX3NlbGVjdGVkSW5kZXg7CkBAIC02MCw4ICszMzksNyBAQCAtIChpbnN0YW5jZXR5cGUp aW5pdFdpdGhWaWV3OihXS0NvbnRlbnRWCiAgICAgX3NlbGVjdGVkSW5kZXggPSBOU05vdEZvdW5k OwogCiAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBbdmlldyBhc3Npc3RlZE5vZGVTZWxlY3RP cHRpb25zXS5zaXplKCk7ICsraSkgewotICAgICAgICBjb25zdCBXS09wdGlvbkl0ZW0gaXRlbSA9 IFtfdmlldyBhc3Npc3RlZE5vZGVTZWxlY3RPcHRpb25zXVtpXTsKLSAgICAgICAgaWYgKGl0ZW0u aXNTZWxlY3RlZCkgeworICAgICAgICBpZiAoW192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlv bnNdW2ldLmlzU2VsZWN0ZWQpIHsKICAgICAgICAgICAgIF9zZWxlY3RlZEluZGV4ID0gaTsKICAg ICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CkBAIC05OCw3ICszNzYsNyBAQCAtICh2b2lkKWNv bnRyb2xFbmRFZGl0aW5nCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChfc2VsZWN0ZWRJbmRl eCA8IChOU0ludGVnZXIpW192aWV3IGFzc2lzdGVkTm9kZVNlbGVjdE9wdGlvbnNdLnNpemUoKSkg ewotICAgICAgICBbX3ZpZXcgYXNzaXN0ZWROb2RlU2VsZWN0T3B0aW9uc11bX3NlbGVjdGVkSW5k ZXhdLmlzU2VsZWN0ZWQgPSBmYWxzZTsKKyAgICAgICAgW192aWV3IGFzc2lzdGVkTm9kZVNlbGVj dE9wdGlvbnNdW19zZWxlY3RlZEluZGV4XS5pc1NlbGVjdGVkID0gdHJ1ZTsKICAgICAgICAgW192 aWV3IHBhZ2VdLT5zZXRBc3Npc3RlZE5vZGVTZWxlY3RlZEluZGV4KF9zZWxlY3RlZEluZGV4KTsK ICAgICB9CiB9CkBAIC0xMDgsMzMgKzM4Niw2IEBAIC0gKE5TSW50ZWdlciludW1iZXJPZkNvbXBv bmVudHNJblBpY2tlclYKICAgICByZXR1cm4gMTsKIH0KIAotc3RhdGljIE5TU3RyaW5nICpzdHJp bmdCeVRyaW1taW5nV2hpdGVzcGFjZUFuZE5ld2xpbmVzKE5TU3RyaW5nICpzdHJpbmcpCi17Ci0g ICAgTlNSYW5nZSByID0gTlNNYWtlUmFuZ2UoMCwgW3N0cmluZyBsZW5ndGhdKTsKLQotICAgIGlm ICghci5sZW5ndGgpCi0gICAgICAgIHJldHVybiBzdHJpbmc7Ci0KLSAgICBOU1VJbnRlZ2VyIG9y aWdpbmFsTGVuZ3RoID0gci5sZW5ndGg7Ci0KLSAgICAvLyBGaXJzdCBzdHJpcCBhbGwgd2hpdGUg c3BhY2Ugb2ZmIHRoZSBlbmQgb2YgdGhlIHJhbmdlCi0gICAgd2hpbGUgKHIubGVuZ3RoID4gMCAm JiBDRlVuaUNoYXJJc01lbWJlck9mKFtzdHJpbmcgY2hhcmFjdGVyQXRJbmRleDogci5sZW5ndGgg LSAxXSwga0NGVW5pQ2hhcldoaXRlc3BhY2VBbmROZXdsaW5lQ2hhcmFjdGVyU2V0KSkKLSAgICAg ICAgci5sZW5ndGggLT0gMTsKLQotICAgIC8vIFRoZW4sIHRyaW0gYW55IHdoaXRlc3BhY2UgZnJv bSB0aGUgc3RhcnQgb2YgdGhlIHJhbmdlLgotICAgIHdoaWxlIChyLmxlbmd0aCA+IDAgJiYgQ0ZV bmlDaGFySXNNZW1iZXJPZihbc3RyaW5nIGNoYXJhY3RlckF0SW5kZXg6IHIubG9jYXRpb25dLCBr Q0ZVbmlDaGFyV2hpdGVzcGFjZUFuZE5ld2xpbmVDaGFyYWN0ZXJTZXQpKSB7Ci0gICAgICAgIHIu bG9jYXRpb24gKz0gMTsKLSAgICAgICAgci5sZW5ndGggLT0gMTsKLSAgICB9Ci0KLSAgICAvLyBJ ZiB3ZSBjaGFuZ2VkIHRoZSBsZW5ndGggb2YgdGhlIHN0cmluZyBmcm9tIHdoYXQgaXQgb3JpZ2lu YWxseSB3YXMsIHJldHVybiBhIG5ldyBzdHJpbmcgd2l0aCBqdXN0IHRob3NlCi0gICAgLy8gY2hh cmFjdGVycy4gIE90aGVyd2lzZSBqdXN0IHJldHVybi4KLSAgICBpZiAob3JpZ2luYWxMZW5ndGgg IT0gci5sZW5ndGgpCi0gICAgICAgIHJldHVybiBbc3RyaW5nIHN1YnN0cmluZ1dpdGhSYW5nZTpy XTsKLQotICAgIHJldHVybiBzdHJpbmc7Ci19Ci0KIC0gKE5TSW50ZWdlcilwaWNrZXJWaWV3OihV SVBpY2tlclZpZXcgKilwaWNrZXJWaWV3IG51bWJlck9mUm93c0luQ29tcG9uZW50OihOU0ludGVn ZXIpY29sdW1uSW5kZXgKIHsKICAgICByZXR1cm4gX3ZpZXcuYXNzaXN0ZWROb2RlSW5mb3JtYXRp b24uc2VsZWN0T3B0aW9ucy5zaXplKCk7CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv aW9zL2Zvcm1zL1dLRm9ybVNlbGVjdFBvcG92ZXIubW0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2lvcy9mb3Jtcy9XS0Zvcm1TZWxlY3RQb3BvdmVyLm1tCShyZXZpc2lv biAxNjUwNzQpCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvaW9zL2Zvcm1zL1dLRm9ybVNl bGVjdFBvcG92ZXIubW0JKHdvcmtpbmcgY29weSkKQEAgLTQ4LDcgKzQ4LDYgQEAKIHVzaW5nIG5h bWVzcGFjZSBXZWJLaXQ7CiAKIHN0YXRpYyBOU1N0cmluZyogV0tQb3BvdmVyVGFibGVWaWV3Q2Vs bFJldXNlSWRlbnRpZmllciAgPSBAIldLUG9wb3ZlclRhYmxlVmlld0NlbGxSZXVzZUlkZW50aWZp ZXIiOwotc3RhdGljIGNvbnN0IENHRmxvYXQgbWluaW11bU9wdGlvbkZvbnRTaXplID0gMTI7CiAK IEBpbnRlcmZhY2UgVUlUYWJsZVZpZXdDZWxsIChJbnRlcm5hbCkKIC0gKENHUmVjdCl0ZXh0UmVj dEZvckNvbnRlbnRSZWN0OihDR1JlY3QpY29udGVudFJlY3Q7CkBAIC04MiwyMyArODEsNiBAQCBz dGF0aWMgTlNTdHJpbmcgKnN0cmluZ1dpdGhXcml0aW5nRGlyZWN0CiAgICAgcmV0dXJuIFtOU1N0 cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUMlQCVDIiwgZGlyZWN0aW9uYWxGb3JtYXR0aW5nQ2hh cmFjdGVyLCBzdHJpbmcsIHBvcERpcmVjdGlvbmFsRm9ybWF0dGluZ107CiB9CiAKLXN0YXRpYyBD R0Zsb2F0IGFkanVzdGVkRm9udFNpemUoQ0dGbG9hdCB0ZXh0V2lkdGgsIFVJRm9udCAqZm9udCwg Q0dGbG9hdCBpbml0aWFsRm9udFNpemUsIGNvbnN0IFZlY3RvcjxXS09wdGlvbkl0ZW0+JiBpdGVt cykKLXsKLSAgICBDR0Zsb2F0IGFkanVzdGVkU2l6ZSA9IGluaXRpYWxGb250U2l6ZTsKLSAgICBm b3IgKHNpemVfdCBpID0gMDsgaSA8IGl0ZW1zLnNpemUoKTsgKytpKSB7Ci0gICAgICAgIGNvbnN0 IFdLT3B0aW9uSXRlbSYgaXRlbSA9IGl0ZW1zW2ldOwotICAgICAgICBpZiAoaXRlbS50ZXh0Lmlz RW1wdHkoKSkKLSAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAKLSAgICAgICAgQ0dGbG9h dCBhY3R1YWxGb250U2l6ZSA9IGluaXRpYWxGb250U2l6ZTsKLSAgICAgICAgWyhOU1N0cmluZyAq KWl0ZW0udGV4dCBfbGVnYWN5X3NpemVXaXRoRm9udDpmb250IG1pbkZvbnRTaXplOm1pbmltdW1P cHRpb25Gb250U2l6ZSBhY3R1YWxGb250U2l6ZTomYWN0dWFsRm9udFNpemUgZm9yV2lkdGg6dGV4 dFdpZHRoIGxpbmVCcmVha01vZGU6TlNMaW5lQnJlYWtCeVdvcmRXcmFwcGluZ107Ci0gICAgICAg IAotICAgICAgICBpZiAoYWN0dWFsRm9udFNpemUgPiAwICYmIGFjdHVhbEZvbnRTaXplIDwgYWRq dXN0ZWRTaXplKQotICAgICAgICAgICAgYWRqdXN0ZWRTaXplID0gYWN0dWFsRm9udFNpemU7Ci0g ICAgfQotICAgIHJldHVybiBhZGp1c3RlZFNpemU7Ci19Ci0KIEBjbGFzcyBXS1NlbGVjdFBvcG92 ZXI7CiAKIEBpbnRlcmZhY2UgV0tTZWxlY3RUYWJsZVZpZXdDb250cm9sbGVyIDogVUlUYWJsZVZp ZXdDb250cm9sbGVyIDxVSUtleUlucHV0Pgo=