211498 2020-05-05 23:37:24 -0700 Cut and paste from Google Doc to Notes in several (non-Latin) languages doesn't work 2020-05-06 14:02:23 -0700 1 1 1 Unclassified WebKit HTML Editing WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh ap bdakin cdumez darin esprehn+autocc ews-watchlist kangil.han megan_gardner mifenton thorton webkit-bug-importer wenson_hsieh oldest_to_newest 1649513 0 wenson_hsieh 2020-05-05 23:37:24 -0700 <rdar://problem/56675345> 1649526 1 398598 wenson_hsieh 2020-05-06 00:09:34 -0700 Created attachment 398598 Patch 1649527 2 398598 wenson_hsieh 2020-05-06 00:20:15 -0700 Comment on attachment 398598 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398598&action=review > Source/WebCore/ChangeLog:22 > + Later, when pasting in Notes or TextEdit, both apps use `-[NSAttributedString initWithData:...:]` to convert the > + HTML data on the pasteboard into an NSAttributedString. This takes the NSPasteboard's HTML data (a blob of > + `NSData`) and synchronously loads it in a new legacy WebKit view by calling `-[WebFrame > + loadData:MIMEType:textEncodingName:baseURL:]`, passing in `nil` as the text encoding name. Since WebKit is only > + given a blob of data and no particular encoding, we fall back to default Latin-1 encoding, which produces > + gibberish for CJK text. An aside: I explored a solution that involves adjusting UIFoundation’s NSHTMLReader to use a default encoding of UTF-8 in its WebView, but ended up not going down this route because (1) defaulting to UTF-8 seemed largely arbitrary when all we’re given is a chunk of NSData, and (2) a fix there wouldn’t help fix the bug in macOS 10.14 and 10.15. 1649607 3 398598 darin 2020-05-06 08:02:23 -0700 Comment on attachment 398598 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398598&action=review > Source/WebCore/ChangeLog:26 > + To fix this, we preserve any meta tag with a valid charset that the page attempts to write to the clipboard when > + sanitizing markup. This matches behavior in both Chrome and Firefox; this fix is also effective on shipping and > + older versions of macOS. I am not happy with this solution. Preserving the character set in the fragment doesn’t make sense when putting markup in a WTF::String, which contains UTF-16 characters. The character set would be determined when the WTF::String is converted back to bytes. The original character set that was used to decode the fragment won’t be correct. This only will do the right thing when the character set happens to be UTF-8. I would like to see where this WTF::String is turned into UTF-8 bytes. That is where we should be adding the character set. Or if we add a character set in markup code long before converting the WTF::String to UTF-8, we should do it whether or not the incoming markup has a meta charset in it, based on the presence of non-ASCII characters, and always write the character set "UTF-8" since that’s what we will be serializing the WTF::String to. 1649609 4 398598 darin 2020-05-06 08:04:59 -0700 Comment on attachment 398598 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398598&action=review > Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:112 > + " e.clipboardData.setData('text/html', `<head><meta charset='utf-8'></head><body><span style='color: red;'>æå«è¬ææ</span></body>`);" A non-UTF-8 test case would likely prove that this code does the wrong thing. > Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:125 > + EXPECT_TRUE([copiedMarkup containsString:@"<meta charset=\"UTF-8\">"]); This is unnecessary behavior. > Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:134 > + EXPECT_WK_STREQ("æå«è¬ææ", [attributedString string]); This is a good test of the bug, but we should cover a non-UTF-8 encoding. 1649610 5 398598 darin 2020-05-06 08:07:08 -0700 Comment on attachment 398598 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398598&action=review >> Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:125 >> + EXPECT_TRUE([copiedMarkup containsString:@"<meta charset=\"UTF-8\">"]); > > This is unnecessary behavior. Let me clarify. This is strange, *possibly* unnecessary, behavior, but it’s possibly helpful for compatibility if there are mistakes in how apps decode pasteboard strings where they convert an NSString to UTF-8. 1649614 6 wenson_hsieh 2020-05-06 08:09:27 -0700 (In reply to Darin Adler from comment #3) > Comment on attachment 398598 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=398598&action=review > > > Source/WebCore/ChangeLog:26 > > + To fix this, we preserve any meta tag with a valid charset that the page attempts to write to the clipboard when > > + sanitizing markup. This matches behavior in both Chrome and Firefox; this fix is also effective on shipping and > > + older versions of macOS. > > I am not happy with this solution. > > Preserving the character set in the fragment doesn’t make sense when putting > markup in a WTF::String, which contains UTF-16 characters. The character set > would be determined when the WTF::String is converted back to bytes. The > original character set that was used to decode the fragment won’t be > correct. This only will do the right thing when the character set happens to > be UTF-8. > > I would like to see where this WTF::String is turned into UTF-8 bytes. That > is where we should be adding the character set. > > Or if we add a character set in markup code long before converting the > WTF::String to UTF-8, we should do it whether or not the incoming markup has > a meta charset in it, based on the presence of non-ASCII characters, and > always write the character set "UTF-8" since that’s what we will be > serializing the WTF::String to. The pasteboard string is being converted into UTF-8 bytes in AppKit, when it calls into CoreFoundation’s CFPasteboardCreateDataForString while serializing the string to the pasteboard. At our layer, we take the sanitized markup string and call -[NSPasteboard setString:forType:] to write it to the pasteboard. 1649616 7 darin 2020-05-06 08:12:46 -0700 (In reply to Wenson Hsieh from comment #6) > The pasteboard string is being converted into UTF-8 bytes in AppKit, when it > calls into CoreFoundation’s CFPasteboardCreateDataForString while > serializing the string to the pasteboard. OK, then this is a workaround for that. Since AppKit always converts to UTF-8, then we need to add a meta tag that sets the charset to UTF-8 if there are non-ASCII characters present. And make sure it overrides any other misleading conflicting character set indicators, such as other meta tags inserted explicitly by websites, by either removing them or considering "priority order". For economy we can leave one out if the characters are all ASCII. 1649629 8 darin 2020-05-06 08:34:00 -0700 Two further thoughts now that I know the conversion to UTF-8 is done by CFPasteboardCreateDataForString: I looked at the Apple internal source code for that function and it has a comment saying the format is “currently” UTF-8. Someone should let the Foundation team know that it’s not OK for them to change to something else since we are all hard-coding UTF-8 into our HTML markup! CFPasteboardCreateDataForString uses CFStringCreateExternalRepresentation, so it seems like it would be inserting a BOM. The presence of a UTF-8 BOM character at the start of the data buffer *should* cause us to correctly decode as UTF-8 rather than Windows Latin-1 and *ignore* the presence or absence of a <meta> tag, overriding it with the stronger evidence of the BOM. Not sure why that doesn’t kick in and prevent this bug. 1649657 9 ap 2020-05-06 09:28:46 -0700 Inspecting pasteboard contents after running the test manually in Safari, I see three flavors: - public.html - Apple HTML Pasteboard Type - com.apple.WebKit.custom-pasteboard-data The latter is a binary format that's presumably not used by any other code, so it's not relevant. The two HTML flavors are identical, and contain UTF-8 fragment without a BOM. It may or may not be an accurate assumption that consumers handle these identically though! I don't think that stepping through what happens when pasting into TextEdit is necessarily sufficient. I guess one ugly workaround could be to encode all text using HTML entities, that way it's all ASCII. But also, since AppKit always converts to UTF-8, shouldn't it just pass the encoding to -[WebFrame loadData:MIMEType:textEncodingName:baseURL:]? 1649668 10 darin 2020-05-06 09:47:22 -0700 (In reply to Alexey Proskuryakov from comment #9) > But also, since AppKit always converts to UTF-8, shouldn't it just pass the > encoding to -[WebFrame loadData:MIMEType:textEncodingName:baseURL:]? That might work if AppKit is always used to decode the HTML. I was assuming that some apps might not use AppKit to decode and parse. 1649669 11 wenson_hsieh 2020-05-06 09:49:52 -0700 (In reply to Darin Adler from comment #10) > (In reply to Alexey Proskuryakov from comment #9) > > But also, since AppKit always converts to UTF-8, shouldn't it just pass the > > encoding to -[WebFrame loadData:MIMEType:textEncodingName:baseURL:]? > > That might work if AppKit is always used to decode the HTML. I was assuming > that some apps might not use AppKit to decode and parse. And also, this impacts any client or app that tries to load markup as NSData from the pasteboard using -loadData:…: (or similar). 1649672 12 398630 wenson_hsieh 2020-05-06 09:54:01 -0700 Created attachment 398630 Patch 1649677 13 398630 darin 2020-05-06 10:07:23 -0700 Comment on attachment 398630 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398630&action=review Looks good to me. > Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:144 > +#if PLATFORM(MAC) > + NSColor *color = (NSColor *)value; > +#else > + UIColor *color = (UIColor *)value; > +#endif We need a CocoaColor typedef so we can write code like this without #if. I think David Kilzer added CocoaImage recently. 1649678 14 398630 darin 2020-05-06 10:09:43 -0700 Comment on attachment 398630 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398630&action=review > Source/WebCore/editing/markup.cpp:970 > + if (!result.isAllASCII()) > + builder.appendLiteral("<meta charset=\"UTF-8\">"); This is expedient, but I want to reiterate that this is working around specific problems in code in the Cocoa family platforms, and this doesn’t seem like the perfect place to do it, especially unconditionally. 1649690 15 398630 wenson_hsieh 2020-05-06 10:26:53 -0700 Comment on attachment 398630 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398630&action=review >> Source/WebCore/editing/markup.cpp:970 >> + builder.appendLiteral("<meta charset=\"UTF-8\">"); > > This is expedient, but I want to reiterate that this is working around specific problems in code in the Cocoa family platforms, and this doesn’t seem like the perfect place to do it, especially unconditionally. Good point; I’ll limit this to Cocoa, then. What do you think about adding something like: static bool shouldAppendMetaCharsetWhenSanitizingMarkup() { #If PLATFORM(COCOA) return true; #else return false; #endif } …above sanitizedMarkupForFragmentInDocument, and consulting it here? I could otherwise call out to the client layer via an EditorClient hook, but it seems like that might be overkill. >> Tools/TestWebKitAPI/Tests/WebKitCocoa/CopyHTML.mm:144 >> +#endif > > We need a CocoaColor typedef so we can write code like this without #if. I think David Kilzer added CocoaImage recently. I see! Yes, I think that would be a nice refactor. I noticed that CocoaImage.h is in WebKit; we could add a CocoaColor.h alongside it, but since this is in TestWebKitAPI, I’ll need to either mark it as an SPI header, or tweak HEADER_SEARCH_PATHS in the TestWebKitAPI project to include this directory using a relative path. We do a similar thing in the WebKitTestRunner project, for header files in Source/WebKit/Platform/spi/ios. I prefer the latter, since the only “client” of this SPI header (if we were to expose it) would be our own testing infrastructure. 1649692 16 ap 2020-05-06 10:30:17 -0700 What are the apps that don't use AppKit, and are broken? I tested a couple Adobe and Microsoft applications, and those didn't accept these pasteboard flavors at all. Neither did BBEdit. Do we have any examples of apps using -loadData? That doesn't seem like an obvious idea for fragments. 1649706 17 398637 wenson_hsieh 2020-05-06 11:10:22 -0700 Created attachment 398637 Address review feedback 1649712 18 darin 2020-05-06 11:22:10 -0700 (In reply to Wenson Hsieh from comment #15) > Good point; I’ll limit this to Cocoa, then. That’s not what I was driving at. We predict that Cocoa will convert to UTF-8 so we protect ourselves by adding a meta element. This is about the *prediction* that some code *later* will convert to UTF-8. > What do you think about adding something like: > > static bool shouldAppendMetaCharsetWhenSanitizingMarkup() > { > #If PLATFORM(COCOA) > return true; > #else > return false; > #endif > } > > …above sanitizedMarkupForFragmentInDocument, and consulting it here? I could > otherwise call out to the client layer via an EditorClient hook, but it > seems like that might be overkill. I don’t think this helps much. Seems like it would likely not do any harm elsewhere. What seems “opportunistic” and possibly wrong here is the use of the “sanitize” function to do this. It’s not really logical. It seems too early to predict how the markup would be used. Also doesn’t seem guaranteed that all content that ends up on the pasteboard passes through this function. At the very least I think there should be a function explaining why this is done here. I would want the comment to be brief, but there are 3 elements I think are non-obvious: 1) We predict someone might encode this as UTF-8, and add this meta element does no harm when this is encoded as UTF-16. 2) We know this is needed on Cocoa platforms; the platforms convert UTF-16 strings to UTF-8 automatically as part of pasteboard handling. 3) This is a good place to do this for the cut and copy to pasteboard operation because ... (compelling reason here). > I see! Yes, I think that would be a nice refactor. I noticed that > CocoaImage.h is in WebKit; we could add a CocoaColor.h alongside it, but > since this is in TestWebKitAPI, I’ll need to either mark it as an SPI > header, or tweak HEADER_SEARCH_PATHS in the TestWebKitAPI project to include > this directory using a relative path. We do a similar thing in the > WebKitTestRunner project, for header files in Source/WebKit/Platform/spi/ios. > > I prefer the latter, since the only “client” of this SPI header (if we were > to expose it) would be our own testing infrastructure. I believe that right now we have a lot of Private headers just for testing. I didn’t know about this "testing-only" option. Would be nice to eliminate "using Private but really only for testing" headers and have them use this mechanism instead. 1649713 19 darin 2020-05-06 11:22:36 -0700 I think a comment is helpful. Not sure the function is needed. 1649730 20 wenson_hsieh 2020-05-06 12:00:10 -0700 (In reply to Darin Adler from comment #18) > (In reply to Wenson Hsieh from comment #15) > > Good point; I’ll limit this to Cocoa, then. > > That’s not what I was driving at. We predict that Cocoa will convert to > UTF-8 so we protect ourselves by adding a meta element. This is about the > *prediction* that some code *later* will convert to UTF-8. Okay, I think I see… It seems we’ll only want to apply this hack when writing markup strings then, and not when we’re sanitizing natively written data that we want to expose to bindings. > > > What do you think about adding something like: > > > > static bool shouldAppendMetaCharsetWhenSanitizingMarkup() > > { > > #If PLATFORM(COCOA) > > return true; > > #else > > return false; > > #endif > > } > > > > …above sanitizedMarkupForFragmentInDocument, and consulting it here? I could > > otherwise call out to the client layer via an EditorClient hook, but it > > seems like that might be overkill. > > I don’t think this helps much. Seems like it would likely not do any harm > elsewhere. > > What seems “opportunistic” and possibly wrong here is the use of the > “sanitize” function to do this. It’s not really logical. It seems too early > to predict how the markup would be used. Also doesn’t seem guaranteed that > all content that ends up on the pasteboard passes through this function. > > At the very least I think there should be a function explaining why this is > done here. I would want the comment to be brief, but there are 3 elements I > think are non-obvious: > > 1) We predict someone might encode this as UTF-8, and add this meta element > does no harm when this is encoded as UTF-16. > > 2) We know this is needed on Cocoa platforms; the platforms convert UTF-16 > strings to UTF-8 automatically as part of pasteboard handling. > > 3) This is a good place to do this for the cut and copy to pasteboard > operation because ... (compelling reason here). > > > I see! Yes, I think that would be a nice refactor. I noticed that > > CocoaImage.h is in WebKit; we could add a CocoaColor.h alongside it, but > > since this is in TestWebKitAPI, I’ll need to either mark it as an SPI > > header, or tweak HEADER_SEARCH_PATHS in the TestWebKitAPI project to include > > this directory using a relative path. We do a similar thing in the > > WebKitTestRunner project, for header files in Source/WebKit/Platform/spi/ios. > > > > I prefer the latter, since the only “client” of this SPI header (if we were > > to expose it) would be our own testing infrastructure. > > I believe that right now we have a lot of Private headers just for testing. > I didn’t know about this "testing-only" option. Would be nice to eliminate > "using Private but really only for testing" headers and have them use this > mechanism instead. (In reply to Darin Adler from comment #18) > (In reply to Wenson Hsieh from comment #15) > > Good point; I’ll limit this to Cocoa, then. > > That’s not what I was driving at. We predict that Cocoa will convert to > UTF-8 so we protect ourselves by adding a meta element. This is about the > *prediction* that some code *later* will convert to UTF-8. > > > What do you think about adding something like: > > > > static bool shouldAppendMetaCharsetWhenSanitizingMarkup() > > { > > #If PLATFORM(COCOA) > > return true; > > #else > > return false; > > #endif > > } > > > > …above sanitizedMarkupForFragmentInDocument, and consulting it here? I could > > otherwise call out to the client layer via an EditorClient hook, but it > > seems like that might be overkill. > > I don’t think this helps much. Seems like it would likely not do any harm > elsewhere. > > What seems “opportunistic” and possibly wrong here is the use of the > “sanitize” function to do this. It’s not really logical. It seems too early > to predict how the markup would be used. Also doesn’t seem guaranteed that > all content that ends up on the pasteboard passes through this function. > > At the very least I think there should be a function explaining why this is > done here. I would want the comment to be brief, but there are 3 elements I > think are non-obvious: > > 1) We predict someone might encode this as UTF-8, and add this meta element > does no harm when this is encoded as UTF-16. > > 2) We know this is needed on Cocoa platforms; the platforms convert UTF-16 > strings to UTF-8 automatically as part of pasteboard handling. > > 3) This is a good place to do this for the cut and copy to pasteboard > operation because ... (compelling reason here). > > > I see! Yes, I think that would be a nice refactor. I noticed that > > CocoaImage.h is in WebKit; we could add a CocoaColor.h alongside it, but > > since this is in TestWebKitAPI, I’ll need to either mark it as an SPI > > header, or tweak HEADER_SEARCH_PATHS in the TestWebKitAPI project to include > > this directory using a relative path. We do a similar thing in the > > WebKitTestRunner project, for header files in Source/WebKit/Platform/spi/ios. > > > > I prefer the latter, since the only “client” of this SPI header (if we were > > to expose it) would be our own testing infrastructure. > > I believe that right now we have a lot of Private headers just for testing. > I didn’t know about this "testing-only" option. Would be nice to eliminate > "using Private but really only for testing" headers and have them use this > mechanism instead. 1649738 21 398643 wenson_hsieh 2020-05-06 12:10:12 -0700 Created attachment 398643 Address review feedback (2) 1649745 22 398643 darin 2020-05-06 12:25:33 -0700 Comment on attachment 398643 Address review feedback (2) Not thrilled that this makes things more complicated. Kind of liked just doing it unconditionally. Not sure how we know we found all the places that AddMetaCharsetIfNeeded is needed. Something about the AddMetaCharsetIfNeeded name doesn’t seem perfect. It seems to concentrate too much on "which tag we are adding" as opposed to "make string that will work if converted to UTF-8". r=me as is, though 1649750 23 wenson_hsieh 2020-05-06 12:36:58 -0700 (In reply to Darin Adler from comment #22) > Comment on attachment 398643 [details] > Address review feedback (2) > > Not thrilled that this makes things more complicated. Kind of liked just > doing it unconditionally. Not sure how we know we found all the places that > AddMetaCharsetIfNeeded is needed. Something about the AddMetaCharsetIfNeeded > name doesn’t seem perfect. It seems to concentrate too much on "which tag we > are adding" as opposed to "make string that will work if converted to > UTF-8". r=me as is, though From code inspection, these are the only two places in WebKit where we take markup strings provided directly to us from the page through DOM API, and sanitize it with the purpose of writing to the system clipboard. I will use <https://bugs.webkit.org/show_bug.cgi?id=211524> to track finding a better name for this enum (or possibly replacing it altogether). 1649761 24 darin 2020-05-06 13:02:33 -0700 (In reply to Wenson Hsieh from comment #23) > From code inspection, these are the only two places in WebKit where we take > markup strings provided directly to us from the page through DOM API, and > sanitize it with the purpose of writing to the system clipboard. What limits this to markup strings provided by the page? Seems like we could have the same kind of problem when serializing markup from the DOM as part of a copy operation. 1649762 25 ews-feeder 2020-05-06 13:02:43 -0700 Committed r261247: <https://trac.webkit.org/changeset/261247> All reviewed patches have been landed. Closing bug and clearing flags on attachment 398643. 1649768 26 wenson_hsieh 2020-05-06 13:26:24 -0700 (In reply to Darin Adler from comment #24) > (In reply to Wenson Hsieh from comment #23) > > From code inspection, these are the only two places in WebKit where we take > > markup strings provided directly to us from the page through DOM API, and > > sanitize it with the purpose of writing to the system clipboard. > > What limits this to markup strings provided by the page? Seems like we could > have the same kind of problem when serializing markup from the DOM as part > of a copy operation. When copying from the DOM (e.g. selected text), we also write RTF and web archive data to the pasteboard, which don’t have the same problem. Both Notes and TextEdit prefer these representations over markup. It is true, however, that if a client were to still grab the HTML data and try to load it in a web page, it would be broken due to lack of encoding information. This sounds like a good reason to push the `meta charset` hack down to `serializePreservingVisualAppearanceInternal`, and add a test for this case (where the user is copying selected text). 1649778 27 darin 2020-05-06 13:49:32 -0700 (In reply to Wenson Hsieh from comment #26) > This sounds like a good reason to push the `meta charset` hack down to > `serializePreservingVisualAppearanceInternal`, and add a test for this case > (where the user is copying selected text). Yes, that’s the kind of follow through I was thinking about! 1649786 28 wenson_hsieh 2020-05-06 14:02:23 -0700 (In reply to Darin Adler from comment #27) > (In reply to Wenson Hsieh from comment #26) > > This sounds like a good reason to push the `meta charset` hack down to > > `serializePreservingVisualAppearanceInternal`, and add a test for this case > > (where the user is copying selected text). > > Yes, that’s the kind of follow through I was thinking about! I will follow up on this soon, in https://bugs.webkit.org/show_bug.cgi?id=211524! 398598 2020-05-06 00:09:34 -0700 2020-05-06 09:54:00 -0700 Patch bug-211498-20200506000933.patch text/plain 11739 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjYxMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzg1ZDIzZDYzM2RmYTkw MWFjMWQwMmM1YzcwMzBhMzQyYzc4NzJiMi4uYWFiMmEzZWZhYWZhNDM4ODY2MTdkYjliMzc1MDZk YjQyY2FmMDMyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDIwLTA1LTA1ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEN1dCBhbmQgcGFz dGUgZnJvbSBHb29nbGUgRG9jIHRvIE5vdGVzIGluIHNldmVyYWwgKG5vbi1MYXRpbikgbGFuZ3Vh Z2VzIGRvZXNuJ3Qgd29yaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjExNDk4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81NjY3NTM0NT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIGNvcHlpbmcg dGV4dCBpbiBHb29nbGUgRG9jcywgdGhlIHBhZ2UgdXNlcyBgRGF0YVRyYW5zZmVyLnNldERhdGFg IHRvIHdyaXRlIHRleHQvaHRtbCBkYXRhIHRvIHRoZSBzeXN0ZW0KKyAgICAgICAgcGFzdGVib2Fy ZC4gVGhpcyBtYXJrdXAgc3RyaW5nIGluY2x1ZGVzIGEgbWV0YSB0YWcgd2l0aCBgY2hhcnNldD0i dXRmLTgiYCwgaW5kaWNhdGluZyB0aGF0IHRoZSBIVE1MIHN0cmluZyB0aGF0CisgICAgICAgIHdh cyBjb3BpZWQgc2hvdWxkIGJlIGludGVycHJldGVkIGFzIFVURi04IGRhdGEuCisKKyAgICAgICAg SG93ZXZlciwgYmVmb3JlIHdlIHdyaXRlIHRoaXMgZGF0YSB0byB0aGUgc3lzdGVtIHBhc3RlYm9h cmQsIHdlIGZpcnN0IHNhbml0aXplIGl0IGJ5IGxvYWRpbmcgaXQgaW4gYSBzZXBhcmF0ZQorICAg ICAgICBwYWdlLCBhbmQgdGhlbiBidWlsZCB0aGUgZmluYWwgc2FuaXRpemVkIG1hcmt1cCBzdHJp bmcgdG8gd3JpdGUgYnkgaXRlcmF0aW5nIG92ZXIgb25seSB2aXNpYmxlIGNvbnRlbnQgaW4gdGhl CisgICAgICAgIG1haW4gZG9jdW1lbnQgb2YgdGhpcyBwYWdlLiBJbXBvcnRhbnRseSwgdGhpcyBs YXN0IHN0ZXAgc2tpcHMgb3ZlciB0aGUgbWV0YSBlbGVtZW50IGNvbnRhaW5pbmcgdGhlIGNoYXJz ZXQuCisKKyAgICAgICAgTGF0ZXIsIHdoZW4gcGFzdGluZyBpbiBOb3RlcyBvciBUZXh0RWRpdCwg Ym90aCBhcHBzIHVzZSBgLVtOU0F0dHJpYnV0ZWRTdHJpbmcgaW5pdFdpdGhEYXRhOi4uLjpdYCB0 byBjb252ZXJ0IHRoZQorICAgICAgICBIVE1MIGRhdGEgb24gdGhlIHBhc3RlYm9hcmQgaW50byBh biBOU0F0dHJpYnV0ZWRTdHJpbmcuIFRoaXMgdGFrZXMgdGhlIE5TUGFzdGVib2FyZCdzIEhUTUwg ZGF0YSAoYSBibG9iIG9mCisgICAgICAgIGBOU0RhdGFgKSBhbmQgc3luY2hyb25vdXNseSBsb2Fk cyBpdCBpbiBhIG5ldyBsZWdhY3kgV2ViS2l0IHZpZXcgYnkgY2FsbGluZyBgLVtXZWJGcmFtZQor ICAgICAgICBsb2FkRGF0YTpNSU1FVHlwZTp0ZXh0RW5jb2RpbmdOYW1lOmJhc2VVUkw6XWAsIHBh c3NpbmcgaW4gYG5pbGAgYXMgdGhlIHRleHQgZW5jb2RpbmcgbmFtZS4gU2luY2UgV2ViS2l0IGlz IG9ubHkKKyAgICAgICAgZ2l2ZW4gYSBibG9iIG9mIGRhdGEgYW5kIG5vIHBhcnRpY3VsYXIgZW5j b2RpbmcsIHdlIGZhbGwgYmFjayB0byBkZWZhdWx0IExhdGluLTEgZW5jb2RpbmcsIHdoaWNoIHBy b2R1Y2VzCisgICAgICAgIGdpYmJlcmlzaCBmb3IgQ0pLIHRleHQuCisKKyAgICAgICAgVG8gZml4 IHRoaXMsIHdlIHByZXNlcnZlIGFueSBtZXRhIHRhZyB3aXRoIGEgdmFsaWQgY2hhcnNldCB0aGF0 IHRoZSBwYWdlIGF0dGVtcHRzIHRvIHdyaXRlIHRvIHRoZSBjbGlwYm9hcmQgd2hlbgorICAgICAg ICBzYW5pdGl6aW5nIG1hcmt1cC4gVGhpcyBtYXRjaGVzIGJlaGF2aW9yIGluIGJvdGggQ2hyb21l IGFuZCBGaXJlZm94OyB0aGlzIGZpeCBpcyBhbHNvIGVmZmVjdGl2ZSBvbiBzaGlwcGluZyBhbmQK KyAgICAgICAgb2xkZXIgdmVyc2lvbnMgb2YgbWFjT1MuCisKKyAgICAgICAgVGVzdDogQ29weUhU TUwuU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hhcmFjdGVyU2V0CisKKyAgICAgICAgKiBlZGl0aW5n L21hcmt1cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpjaGFyYWN0ZXJTZXRFbmNvZGluZ0Zyb21N ZXRhVGFnSW5GcmFnbWVudCk6CisKKyAgICAgICAgSGVscGVyIG1ldGhvZCB0byBkZXRlcm1pbmUg YSB2YWxpZCBtZXRhIGNoYXJzZXQsIGdpdmVuIGEgZG9jdW1lbnQgZnJhZ21lbnQgdGhhdCBpcyBi ZWluZyBzYW5pdGl6ZWQuCisKKyAgICAgICAgKFdlYkNvcmU6OnNhbml0aXplZE1hcmt1cEZvckZy YWdtZW50SW5Eb2N1bWVudCk6CisKKyAgICAgICAgSWYgYSB2YWxpZCBgbWV0YSBjaGFyc2V0YCBp cyBwcmVzZW50LCByZW1lbWJlciB0aGUgYGNoYXJzZXRgIHZhbHVlIGFuZCBwcmVwZW5kIGEgbWV0 YSB0YWcgaW4gdGhlIGZpbmFsIHNhbml0aXplZAorICAgICAgICBtYXJrdXAgd2l0aCB0aGlzIGNo YXJhY3RlciBzZXQuCisKIDIwMjAtMDUtMDQgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBh cHBsZS5jb20+CiAKICAgICAgICAgQ29kZSBjbGVhbnVwIGluIEV2ZW50SGFuZGxlcgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9tYXJrdXAuY3BwIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9tYXJrdXAuY3BwCmluZGV4IGNiZjYyODhlOWJhZWM1ZTI5MzUxNWY1MDZhY2Q1OTJh M2IyOGVjZGEuLjRlZDZhNTljYjc0Njc0NmViMGViZGEyYmMyMDJhODExYzM5NjI0M2YgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL21hcmt1cC5jcHAKQEAgLTU3LDYgKzU3LDggQEAKICNpbmNsdWRlICJIVE1M SGVhZEVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSHRtbEVsZW1lbnQuaCIKICNpbmNsdWRlICJI VE1MSW1hZ2VFbGVtZW50LmgiCisjaW5jbHVkZSAiSFRNTE1ldGFDaGFyc2V0UGFyc2VyLmgiCisj aW5jbHVkZSAiSFRNTE1ldGFFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5j bHVkZSAiSFRNTFN0eWxlRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxUYWJsZUVsZW1lbnQuaCIK QEAgLTk0NSwxMSArOTQ3LDMyIEBAIHN0YXRpYyBib29sIHNob3VsZFByZXNlcnZlTVNPTGlzdHMo Y29uc3QgU3RyaW5nJiBtYXJrdXApCiAgICAgICAgICYmIGh0bWxUYWcuY29udGFpbnMoInhtbG5z Onc9XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkXCIiKTsKIH0KIAorc3Rh dGljIE9wdGlvbmFsPFRleHRFbmNvZGluZz4gY2hhcmFjdGVyU2V0RW5jb2RpbmdGcm9tTWV0YVRh Z0luRnJhZ21lbnQoY29uc3QgRG9jdW1lbnRGcmFnbWVudCYgZnJhZ21lbnQpCit7CisgICAgZm9y IChhdXRvJiBtZXRhIDogZGVzY2VuZGFudHNPZlR5cGU8SFRNTE1ldGFFbGVtZW50PihmcmFnbWVu dCkpIHsKKyAgICAgICAgaWYgKCFtZXRhLmhhc0F0dHJpYnV0ZXMoKSkKKyAgICAgICAgICAgIGNv bnRpbnVlOworCisgICAgICAgIEhUTUxNZXRhQ2hhcnNldFBhcnNlcjo6QXR0cmlidXRlTGlzdCBh dHRyaWJ1dGVzOworICAgICAgICBhdHRyaWJ1dGVzLnJlc2VydmVJbml0aWFsQ2FwYWNpdHkobWV0 YS5hdHRyaWJ1dGVDb3VudCgpKTsKKyAgICAgICAgZm9yIChhdXRvJiBhdHRyaWJ1dGUgOiBtZXRh LmF0dHJpYnV0ZXNJdGVyYXRvcigpKQorICAgICAgICAgICAgYXR0cmlidXRlcy51bmNoZWNrZWRB cHBlbmQoeyBhdHRyaWJ1dGUubmFtZSgpLnRvU3RyaW5nKCksIGF0dHJpYnV0ZS52YWx1ZSgpLnN0 cmluZygpIH0pOworICAgICAgICBhdXRvIGVuY29kaW5nID0gSFRNTE1ldGFDaGFyc2V0UGFyc2Vy OjplbmNvZGluZ0Zyb21NZXRhQXR0cmlidXRlcyhhdHRyaWJ1dGVzKTsKKyAgICAgICAgaWYgKGVu Y29kaW5nLmlzVmFsaWQoKSkKKyAgICAgICAgICAgIHJldHVybiBlbmNvZGluZzsKKyAgICB9Cisg ICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKK30KKwogU3RyaW5nIHNhbml0aXplZE1hcmt1cEZvckZy YWdtZW50SW5Eb2N1bWVudChSZWY8RG9jdW1lbnRGcmFnbWVudD4mJiBmcmFnbWVudCwgRG9jdW1l bnQmIGRvY3VtZW50LCBNU09MaXN0UXVpcmtzIG1zb0xpc3RRdWlya3MsIGNvbnN0IFN0cmluZyYg b3JpZ2luYWxNYXJrdXApCiB7CiAgICAgTVNPTGlzdE1vZGUgbXNvTGlzdE1vZGUgPSBtc29MaXN0 UXVpcmtzID09IE1TT0xpc3RRdWlya3M6OkNoZWNrSWZOZWVkZWQgJiYgc2hvdWxkUHJlc2VydmVN U09MaXN0cyhvcmlnaW5hbE1hcmt1cCkKICAgICAgICAgPyBNU09MaXN0TW9kZTo6UHJlc2VydmUg OiBNU09MaXN0TW9kZTo6RG9Ob3RQcmVzZXJ2ZTsKIAorICAgIFN0cmluZyBjaGFyYWN0ZXJTZXRF bmNvZGluZzsKKyAgICBpZiAoYXV0byBlbmNvZGluZyA9IGNoYXJhY3RlclNldEVuY29kaW5nRnJv bU1ldGFUYWdJbkZyYWdtZW50KGZyYWdtZW50LmdldCgpKSkKKyAgICAgICAgY2hhcmFjdGVyU2V0 RW5jb2RpbmcgPSBlbmNvZGluZy0+ZG9tTmFtZSgpOworCiAgICAgYXV0byBib2R5RWxlbWVudCA9 IG1ha2VSZWZQdHIoZG9jdW1lbnQuYm9keSgpKTsKICAgICBBU1NFUlQoYm9keUVsZW1lbnQpOwog ICAgIGJvZHlFbGVtZW50LT5hcHBlbmRDaGlsZChmcmFnbWVudC5nZXQoKSk7CkBAIC05NTgsMTgg Kzk4MSwyMyBAQCBTdHJpbmcgc2FuaXRpemVkTWFya3VwRm9yRnJhZ21lbnRJbkRvY3VtZW50KFJl ZjxEb2N1bWVudEZyYWdtZW50PiYmIGZyYWdtZW50LCBEbwogICAgIGF1dG8gcmVzdWx0ID0gc2Vy aWFsaXplUHJlc2VydmluZ1Zpc3VhbEFwcGVhcmFuY2VJbnRlcm5hbChmaXJzdFBvc2l0aW9uSW5O b2RlKGJvZHlFbGVtZW50LmdldCgpKSwgbGFzdFBvc2l0aW9uSW5Ob2RlKGJvZHlFbGVtZW50Lmdl dCgpKSwgbnVsbHB0ciwKICAgICAgICAgUmVzb2x2ZVVSTHM6Olllc0V4Y2x1ZGluZ0xvY2FsRmls ZVVSTHNGb3JQcml2YWN5LCBTZXJpYWxpemVDb21wb3NlZFRyZWU6Ok5vLCBBbm5vdGF0ZUZvcklu dGVyY2hhbmdlOjpZZXMsIENvbnZlcnRCbG9ja3NUb0lubGluZXM6Ok5vLCAgU3RhbmRhcmRGb250 RmFtaWx5U2VyaWFsaXphdGlvbk1vZGU6OlN0cmlwLCBtc29MaXN0TW9kZSk7CiAKKyAgICBTdHJp bmdCdWlsZGVyIGJ1aWxkZXI7CiAgICAgaWYgKG1zb0xpc3RNb2RlID09IE1TT0xpc3RNb2RlOjpQ cmVzZXJ2ZSkgewotICAgICAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7CiAgICAgICAgIGJ1aWxk ZXIuYXBwZW5kTGl0ZXJhbCgiPGh0bWwgeG1sbnM6bz1cInVybjpzY2hlbWFzLW1pY3Jvc29mdC1j b206b2ZmaWNlOm9mZmljZVwiXG4iCiAgICAgICAgICAgICAieG1sbnM6dz1cInVybjpzY2hlbWFz LW1pY3Jvc29mdC1jb206b2ZmaWNlOndvcmRcIlxuIgogICAgICAgICAgICAgInhtbG5zOm09XCJo dHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL29mZmljZS8yMDA0LzEyL29tbWxcIlxuIgogICAg ICAgICAgICAgInhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MFwiPiIpOwot ICAgICAgICBidWlsZGVyLmFwcGVuZChyZXN1bHQpOwotICAgICAgICBidWlsZGVyLmFwcGVuZExp dGVyYWwoIjwvaHRtbD4iKTsKLSAgICAgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKICAg ICB9CiAKLSAgICByZXR1cm4gcmVzdWx0OworICAgIGlmICghY2hhcmFjdGVyU2V0RW5jb2Rpbmcu aXNFbXB0eSgpKQorICAgICAgICBidWlsZGVyLmFwcGVuZChtYWtlU3RyaW5nKCI8bWV0YSBjaGFy c2V0PVwiIiwgY2hhcmFjdGVyU2V0RW5jb2RpbmcsICJcIj4iKSk7CisKKyAgICBidWlsZGVyLmFw cGVuZChyZXN1bHQpOworCisgICAgaWYgKG1zb0xpc3RNb2RlID09IE1TT0xpc3RNb2RlOjpQcmVz ZXJ2ZSkKKyAgICAgICAgYnVpbGRlci5hcHBlbmRMaXRlcmFsKCI8L2h0bWw+Iik7CisKKyAgICBy ZXR1cm4gYnVpbGRlci50b1N0cmluZygpOwogfQogCiBzdGF0aWMgdm9pZCByZXN0b3JlQXR0YWNo bWVudEVsZW1lbnRzSW5GcmFnbWVudChEb2N1bWVudEZyYWdtZW50JiBmcmFnbWVudCkKZGlmZiAt LWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBkODYzODgzMmYy ZmRhOWZjNjZkMWY4ODg4YTA5ZTdkOGM0NzI5YTgxLi5jOTQ4NTBjYTM5OWM3MWU1ZWZjZDdlMzg5 Zjg0YjhhZGFjYWZmYzNlIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDUtMDUgIFdlbnNvbiBIc2llaCAgPHdl bnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgQ3V0IGFuZCBwYXN0ZSBmcm9tIEdvb2ds ZSBEb2MgdG8gTm90ZXMgaW4gc2V2ZXJhbCAobm9uLUxhdGluKSBsYW5ndWFnZXMgZG9lc24ndCB3 b3JrCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTE0 OTgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU2Njc1MzQ1PgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIHRlc3QgdG8gdmVyaWZ5IHRoYXQg d2hlbiB3cml0aW5nIG1hcmt1cCB0byB0aGUgY2xpcGJvYXJkIHZpYSBET00gQVBJLCBzYW5pdGl6 YXRpb24gcHJlc2VydmVzIGFueSBjaGFyc2V0CisgICAgICAgIHNwZWNpZmllZCB2aWEgbWV0YSB0 YWcgaW4gdGhlIHJhdyB0ZXh0L2h0bWwgc3RyaW5nIGdpdmVuIHRvIHVzIGJ5IHRoZSBwYWdlLiBU aGUgdGVzdCBhZGRpdGlvbmFsbHkgdmVyaWZpZXMgdGhhdAorICAgICAgICBjb252ZXJ0aW5nIHRo ZSBIVE1MIGRhdGEgd3JpdHRlbiB0byB0aGUgcGFzdGVib2FyZCB0byBhbiBhdHRyaWJ1dGVkIHN0 cmluZyB1c2luZyBOU0F0dHJpYnV0ZWRTdHJpbmcgQVBJIHdpbGwKKyAgICAgICAgcmVzdWx0IGlu IGFuIGBOU0F0dHJpYnV0ZWRTdHJpbmdgLCB3aG9zZSBgLXN0cmluZ2AgcmVmbGVjdHMgdGhlIGNv bnRlbnRzIG9mIHRoZSBzdHJpbmcgd3JpdHRlbiB0byB0aGUgcGFzdGVib2FyZAorICAgICAgICBi eSB0aGUgcGFnZS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2Ev Q29weUhUTUwubW06CisgICAgICAgIChyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCk6CisgICAg ICAgIChyZWFkSFRNTFN0cmluZ0Zyb21QYXN0ZWJvYXJkKToKKyAgICAgICAgKHJlYWRIVE1MRnJv bVBhc3RlYm9hcmQpOiBEZWxldGVkLgorCiAyMDIwLTA1LTA0ICBCZW4gTmhhbSAgPG5oYW1AYXBw bGUuY29tPgogCiAgICAgICAgIEluZGV4ZWREQiBXQUwgZmlsZSBrZWVwcyBncm93aW5nIHdoaWxl IGFwcCBpcyBpbiB1c2UKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Q29jb2EvQ29weUhUTUwubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENv Y29hL0NvcHlIVE1MLm1tCmluZGV4IGNmYjlkOGNlZGM5ODU2YjdjZDg3YmEzYzc1ODQwZjZhNjQ2 OTFjMGQuLmY1NjNjYWQwOWE4ZWMxZGM2Mzk5OGVmNjRmODdlNjZlNzYzMzdkMzYgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29weUhUTUwubW0KKysr IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db3B5SFRNTC5tbQpAQCAt NDQsMTIgKzQ0LDI1IEBAIC0gKHZvaWQpcGFzdGU6KGlkKXNlbmRlcjsKIEBlbmQKIAogI2lmIFBM QVRGT1JNKE1BQykKLU5TU3RyaW5nICpyZWFkSFRNTEZyb21QYXN0ZWJvYXJkKCkKKworTlNEYXRh ICpyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCgpCit7CisgICAgcmV0dXJuIFtbTlNQYXN0ZWJv YXJkIGdlbmVyYWxQYXN0ZWJvYXJkXSBkYXRhRm9yVHlwZTpOU0hUTUxQYm9hcmRUeXBlXTsKK30K KworTlNTdHJpbmcgKnJlYWRIVE1MU3RyaW5nRnJvbVBhc3RlYm9hcmQoKQogewogICAgIHJldHVy biBbW05TUGFzdGVib2FyZCBnZW5lcmFsUGFzdGVib2FyZF0gc3RyaW5nRm9yVHlwZTpOU0hUTUxQ Ym9hcmRUeXBlXTsKIH0KKwogI2Vsc2UKLU5TU3RyaW5nICpyZWFkSFRNTEZyb21QYXN0ZWJvYXJk KCkKKworTlNEYXRhICpyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCgpCit7CisgICAgcmV0dXJu IFtbVUlQYXN0ZWJvYXJkIGdlbmVyYWxQYXN0ZWJvYXJkXSBkYXRhRm9yUGFzdGVib2FyZFR5cGU6 KF9fYnJpZGdlIE5TU3RyaW5nICopa1VUVHlwZUhUTUxdOworfQorCitOU1N0cmluZyAqcmVhZEhU TUxTdHJpbmdGcm9tUGFzdGVib2FyZCgpCiB7CiAgICAgaWQgdmFsdWUgPSBbW1VJUGFzdGVib2Fy ZCBnZW5lcmFsUGFzdGVib2FyZF0gdmFsdWVGb3JQYXN0ZWJvYXJkVHlwZTooX19icmlkZ2UgTlNT dHJpbmcgKilrVVRUeXBlSFRNTF07CiAgICAgaWYgKFt2YWx1ZSBpc0tpbmRPZkNsYXNzOltOU0Rh dGEgY2xhc3NdXSkKQEAgLTU3LDYgKzcwLDcgQEAgTlNTdHJpbmcgKnJlYWRIVE1MRnJvbVBhc3Rl Ym9hcmQoKQogICAgIEFTU0VSVChbdmFsdWUgaXNLaW5kT2ZDbGFzczpbTlNTdHJpbmcgY2xhc3Nd XSk7CiAgICAgcmV0dXJuIChOU1N0cmluZyAqKXZhbHVlOwogfQorCiAjZW5kaWYKIAogc3RhdGlj IFJldGFpblB0cjxUZXN0V0tXZWJWaWV3PiBjcmVhdGVXZWJWaWV3V2l0aEN1c3RvbVBhc3RlYm9h cmREYXRhRW5hYmxlZCgpCkBAIC04MCwxMyArOTQsNjUgQEAgVEVTVChDb3B5SFRNTCwgU2FuaXRp emVzKQogICAgIEVYUEVDVF9UUlVFKFt3ZWJWaWV3IHN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3Jp cHQ6QCJkaWRQYXN0ZSJdLmJvb2xWYWx1ZSk7CiAgICAgRVhQRUNUX1dLX1NUUkVRKCI8bWV0YSBj b250ZW50PVwic2VjcmV0XCI+PGIgb25tb3VzZW92ZXI9XCJkYW5nZXJvdXNDb2RlKClcIj5oZWxs bzwvYj48IS0tIHNlY3JldC0tPiwgd29ybGQ8c2NyaXB0PmRhbmdlcm91c0NvZGUoKTwvc2NyaXB0 PiIsCiAgICAgICAgIFt3ZWJWaWV3IHN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3JpcHQ6QCJwYXN0 ZWRIVE1MIl0pOwotICAgIFN0cmluZyBodG1sSW5OYXRpdmVQYXN0ZWJvYXJkID0gcmVhZEhUTUxG cm9tUGFzdGVib2FyZCgpOworICAgIFN0cmluZyBodG1sSW5OYXRpdmVQYXN0ZWJvYXJkID0gcmVh ZEhUTUxTdHJpbmdGcm9tUGFzdGVib2FyZCgpOwogICAgIEVYUEVDVF9UUlVFKGh0bWxJbk5hdGl2 ZVBhc3RlYm9hcmQuY29udGFpbnMoImhlbGxvIikpOwogICAgIEVYUEVDVF9UUlVFKGh0bWxJbk5h dGl2ZVBhc3RlYm9hcmQuY29udGFpbnMoIiwgd29ybGQiKSk7CiAgICAgRVhQRUNUX0ZBTFNFKGh0 bWxJbk5hdGl2ZVBhc3RlYm9hcmQuY29udGFpbnMoInNlY3JldCIpKTsKICAgICBFWFBFQ1RfRkFM U0UoaHRtbEluTmF0aXZlUGFzdGVib2FyZC5jb250YWlucygiZGFuZ2Vyb3VzQ29kZSIpKTsKIH0K IAorVEVTVChDb3B5SFRNTCwgU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hhcmFjdGVyU2V0KQorewor ICAgIE5TU3RyaW5nICptYXJrdXAgPSBAIjwhRE9DVFlQRSBodG1sPiIKKyAgICAgICAgIjxib2R5 PiIKKyAgICAgICAgIjxtZXRhIGNoYXJzZXQ9J3V0Zi04Jz4iCisgICAgICAgICI8cCBpZD0nY29w eSc+Q29weSBtZTwvcD4iCisgICAgICAgICI8c2NyaXB0PiIKKyAgICAgICAgImNvcHkuYWRkRXZl bnRMaXN0ZW5lcignY29weScsIGUgPT4geyIKKyAgICAgICAgIiAgICBlLmNsaXBib2FyZERhdGEu c2V0RGF0YSgndGV4dC9odG1sJywgYDxoZWFkPjxtZXRhIGNoYXJzZXQ9J3V0Zi04Jz48L2hlYWQ+ PGJvZHk+PHNwYW4gc3R5bGU9J2NvbG9yOiByZWQ7Jz7miJHlj6vorJ3mlofmmIc8L3NwYW4+PC9i b2R5PmApOyIKKyAgICAgICAgIiAgICBlLnByZXZlbnREZWZhdWx0KCk7IgorICAgICAgICAifSk7 IgorICAgICAgICAiZ2V0U2VsZWN0aW9uKCkuc2VsZWN0QWxsQ2hpbGRyZW4oY29weSk7IgorICAg ICAgICAiPC9zY3JpcHQ+IgorICAgICAgICAiPC9ib2R5PiI7CisKKyAgICBhdXRvIHdlYlZpZXcg PSBjcmVhdGVXZWJWaWV3V2l0aEN1c3RvbVBhc3RlYm9hcmREYXRhRW5hYmxlZCgpOworICAgIFt3 ZWJWaWV3IHN5bmNocm9ub3VzbHlMb2FkSFRNTFN0cmluZzptYXJrdXBdOworICAgIFt3ZWJWaWV3 IGNvcHk6bmlsXTsKKyAgICBbd2ViVmlldyB3YWl0Rm9yTmV4dFByZXNlbnRhdGlvblVwZGF0ZV07 CisKKyAgICBOU1N0cmluZyAqY29waWVkTWFya3VwID0gcmVhZEhUTUxTdHJpbmdGcm9tUGFzdGVi b2FyZCgpOworICAgIEVYUEVDVF9UUlVFKFtjb3BpZWRNYXJrdXAgY29udGFpbnNTdHJpbmc6QCI8 bWV0YSBjaGFyc2V0PVwiVVRGLThcIj4iXSk7CisgICAgRVhQRUNUX1RSVUUoW2NvcGllZE1hcmt1 cCBjb250YWluc1N0cmluZzpAIjxzcGFuICJdKTsKKyAgICBFWFBFQ1RfVFJVRShbY29waWVkTWFy a3VwIGNvbnRhaW5zU3RyaW5nOkAiY29sb3I6IHJlZDsiXSk7CisgICAgRVhQRUNUX1RSVUUoW2Nv cGllZE1hcmt1cCBjb250YWluc1N0cmluZzpAIuaIkeWPq+isneaWh+aYhyJdKTsKKyAgICBFWFBF Q1RfVFJVRShbY29waWVkTWFya3VwIGNvbnRhaW5zU3RyaW5nOkAiPC9zcGFuPiJdKTsKKworICAg IE5TRGF0YSAqY29waWVkRGF0YSA9IHJlYWRIVE1MRGF0YUZyb21QYXN0ZWJvYXJkKCk7CisgICAg TlNFcnJvciAqYXR0cmlidXRlZFN0cmluZ0NvbnZlcnNpb25FcnJvciA9IG5pbDsKKyAgICBhdXRv IGF0dHJpYnV0ZWRTdHJpbmcgPSBhZG9wdE5TKFtbTlNBdHRyaWJ1dGVkU3RyaW5nIGFsbG9jXSBp bml0V2l0aERhdGE6Y29waWVkRGF0YSBvcHRpb25zOkB7IE5TRG9jdW1lbnRUeXBlRG9jdW1lbnRP cHRpb246IE5TSFRNTFRleHREb2N1bWVudFR5cGUgfSBkb2N1bWVudEF0dHJpYnV0ZXM6bmlsIGVy cm9yOiZhdHRyaWJ1dGVkU3RyaW5nQ29udmVyc2lvbkVycm9yXSk7CisgICAgRVhQRUNUX1dLX1NU UkVRKCLmiJHlj6vorJ3mlofmmIciLCBbYXR0cmlidXRlZFN0cmluZyBzdHJpbmddKTsKKworICAg IF9fYmxvY2sgQk9PTCBmb3VuZENvbG9yQXR0cmlidXRlID0gTk87CisgICAgW2F0dHJpYnV0ZWRT dHJpbmcgZW51bWVyYXRlQXR0cmlidXRlOk5TRm9yZWdyb3VuZENvbG9yQXR0cmlidXRlTmFtZSBp blJhbmdlOk5TTWFrZVJhbmdlKDAsIDUpIG9wdGlvbnM6MCB1c2luZ0Jsb2NrOl4oaWQgdmFsdWUs IE5TUmFuZ2UgcmFuZ2UsIEJPT0wgKikgeworI2lmIFBMQVRGT1JNKE1BQykKKyAgICAgICAgTlND b2xvciAqY29sb3IgPSAoTlNDb2xvciAqKXZhbHVlOworI2Vsc2UKKyAgICAgICAgVUlDb2xvciAq Y29sb3IgPSAoVUlDb2xvciAqKXZhbHVlOworI2VuZGlmCisgICAgICAgIENHRmxvYXQgcmVkQ29t cG9uZW50ID0gMDsKKyAgICAgICAgQ0dGbG9hdCBncmVlbkNvbXBvbmVudCA9IDA7CisgICAgICAg IENHRmxvYXQgYmx1ZUNvbXBvbmVudCA9IDA7CisgICAgICAgIFtjb2xvciBnZXRSZWQ6JnJlZENv bXBvbmVudCBncmVlbjomZ3JlZW5Db21wb25lbnQgYmx1ZTomYmx1ZUNvbXBvbmVudCBhbHBoYTpu aWxdOworCisgICAgICAgIEVYUEVDVF9FUSgxLiwgcmVkQ29tcG9uZW50KTsKKyAgICAgICAgRVhQ RUNUX0VRKDAuLCBncmVlbkNvbXBvbmVudCk7CisgICAgICAgIEVYUEVDVF9FUSgwLiwgYmx1ZUNv bXBvbmVudCk7CisgICAgICAgIGZvdW5kQ29sb3JBdHRyaWJ1dGUgPSBZRVM7CisgICAgfV07Cisg ICAgRVhQRUNUX1RSVUUoZm91bmRDb2xvckF0dHJpYnV0ZSk7Cit9CisKICNpZiBQTEFURk9STShN QUMpCiAKIFRFU1QoQ29weUhUTUwsIEl0ZW1UeXBlc1doZW5Db3B5aW5nV2ViQ29udGVudCkK 398630 2020-05-06 09:54:01 -0700 2020-05-06 11:10:21 -0700 Patch bug-211498-20200506095400.patch text/plain 9487 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjYxMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzg1ZDIzZDYzM2RmYTkw MWFjMWQwMmM1YzcwMzBhMzQyYzc4NzJiMi4uY2U0YTJhOTEwMGVlYzdhNmMzOGYzNjczMTkyM2Yz ODdjNmQ1NTBiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDIwLTA1LTA2ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEN1dCBhbmQgcGFz dGUgZnJvbSBHb29nbGUgRG9jIHRvIE5vdGVzIGluIHNldmVyYWwgKG5vbi1MYXRpbikgbGFuZ3Vh Z2VzIGRvZXNuJ3Qgd29yaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjExNDk4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81NjY3NTM0NT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIGNvcHlpbmcg dGV4dCBpbiBHb29nbGUgRG9jcywgdGhlIHBhZ2UgdXNlcyBgRGF0YVRyYW5zZmVyLnNldERhdGFg IHRvIHdyaXRlIHRleHQvaHRtbCBkYXRhIHRvIHRoZSBzeXN0ZW0KKyAgICAgICAgcGFzdGVib2Fy ZC4gVGhpcyBtYXJrdXAgc3RyaW5nIGluY2x1ZGVzIGEgbWV0YSB0YWcgd2l0aCBgY2hhcnNldD0i dXRmLTgiYCwgaW5kaWNhdGluZyB0aGF0IHRoZSBIVE1MIHN0cmluZyB0aGF0CisgICAgICAgIHdh cyBjb3BpZWQgc2hvdWxkIGJlIGludGVycHJldGVkIGFzIFVURi04IGRhdGEuCisKKyAgICAgICAg SG93ZXZlciwgYmVmb3JlIHdlIHdyaXRlIHRoaXMgZGF0YSB0byB0aGUgc3lzdGVtIHBhc3RlYm9h cmQsIHdlIGZpcnN0IHNhbml0aXplIGl0IGJ5IGxvYWRpbmcgaXQgaW4gYSBzZXBhcmF0ZQorICAg ICAgICBwYWdlLCBhbmQgdGhlbiBidWlsZCB0aGUgZmluYWwgc2FuaXRpemVkIG1hcmt1cCBzdHJp bmcgdG8gd3JpdGUgYnkgaXRlcmF0aW5nIG92ZXIgb25seSB2aXNpYmxlIGNvbnRlbnQgaW4gdGhl CisgICAgICAgIG1haW4gZG9jdW1lbnQgb2YgdGhpcyBwYWdlLiBJbXBvcnRhbnRseSwgdGhpcyBs YXN0IHN0ZXAgc2tpcHMgb3ZlciB0aGUgbWV0YSBlbGVtZW50IGNvbnRhaW5pbmcgdGhlIGNoYXJz ZXQuCisKKyAgICAgICAgTGF0ZXIsIHdoZW4gcGFzdGluZyBpbiBOb3RlcyBvciBUZXh0RWRpdCwg Ym90aCBhcHBzIHVzZSBgLVtOU0F0dHJpYnV0ZWRTdHJpbmcgaW5pdFdpdGhEYXRhOi4uLjpdYCB0 byBjb252ZXJ0IHRoZQorICAgICAgICBIVE1MIGRhdGEgb24gdGhlIHBhc3RlYm9hcmQgaW50byBh biBOU0F0dHJpYnV0ZWRTdHJpbmcuIFRoaXMgdGFrZXMgdGhlIE5TUGFzdGVib2FyZCdzIEhUTUwg ZGF0YSAoYSBibG9iIG9mCisgICAgICAgIGBOU0RhdGFgKSBhbmQgc3luY2hyb25vdXNseSBsb2Fk cyBpdCBpbiBhIG5ldyBsZWdhY3kgV2ViS2l0IHZpZXcgYnkgY2FsbGluZyBgLVtXZWJGcmFtZQor ICAgICAgICBsb2FkRGF0YTpNSU1FVHlwZTp0ZXh0RW5jb2RpbmdOYW1lOmJhc2VVUkw6XWAsIHBh c3NpbmcgaW4gYG5pbGAgYXMgdGhlIHRleHQgZW5jb2RpbmcgbmFtZS4gU2luY2UgV2ViS2l0IGlz IG9ubHkKKyAgICAgICAgZ2l2ZW4gYSBibG9iIG9mIGRhdGEgYW5kIG5vIHBhcnRpY3VsYXIgZW5j b2RpbmcsIHdlIGZhbGwgYmFjayB0byBkZWZhdWx0IExhdGluLTEgZW5jb2RpbmcsIHdoaWNoIHBy b2R1Y2VzCisgICAgICAgIGdpYmJlcmlzaCBmb3IgQ0pLIHRleHQuCisKKyAgICAgICAgVG8gZml4 IHRoaXMsIHdlIGF1dG9tYXRpY2FsbHkgaW5zZXJ0IGEgYDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij5g IHRhZyB3aGVuIHdyaXRpbmcgSFRNTCB0byB0aGUgcGFzdGVib2FyZCwgaWYgdGhlCisgICAgICAg IHNhbml0aXplZCBtYXJrdXAgY29udGFpbnMgbm9uLUFTQ0lJIGNoYXJhY3RlcnMuCisKKyAgICAg ICAgVGVzdDogQ29weUhUTUwuU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hhcmFjdGVyU2V0CisKKyAg ICAgICAgKiBlZGl0aW5nL21hcmt1cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpzYW5pdGl6ZWRN YXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQpOgorCiAyMDIwLTA1LTA0ICBTaW1vbiBGcmFzZXIg IDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIENvZGUgY2xlYW51cCBpbiBFdmVu dEhhbmRsZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNwcCBi L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNwcAppbmRleCBjYmY2Mjg4ZTliYWVjNWUy OTM1MTVmNTA2YWNkNTkyYTNiMjhlY2RhLi40M2M0MTg3ZTY3ZTIzMWIwYThhYmFiZDc5MzVhZjBj ODc3ZDI0MWUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL21hcmt1cC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9tYXJrdXAuY3BwCkBAIC05NTgsMTggKzk1OCwy MyBAQCBTdHJpbmcgc2FuaXRpemVkTWFya3VwRm9yRnJhZ21lbnRJbkRvY3VtZW50KFJlZjxEb2N1 bWVudEZyYWdtZW50PiYmIGZyYWdtZW50LCBEbwogICAgIGF1dG8gcmVzdWx0ID0gc2VyaWFsaXpl UHJlc2VydmluZ1Zpc3VhbEFwcGVhcmFuY2VJbnRlcm5hbChmaXJzdFBvc2l0aW9uSW5Ob2RlKGJv ZHlFbGVtZW50LmdldCgpKSwgbGFzdFBvc2l0aW9uSW5Ob2RlKGJvZHlFbGVtZW50LmdldCgpKSwg bnVsbHB0ciwKICAgICAgICAgUmVzb2x2ZVVSTHM6Olllc0V4Y2x1ZGluZ0xvY2FsRmlsZVVSTHNG b3JQcml2YWN5LCBTZXJpYWxpemVDb21wb3NlZFRyZWU6Ok5vLCBBbm5vdGF0ZUZvckludGVyY2hh bmdlOjpZZXMsIENvbnZlcnRCbG9ja3NUb0lubGluZXM6Ok5vLCAgU3RhbmRhcmRGb250RmFtaWx5 U2VyaWFsaXphdGlvbk1vZGU6OlN0cmlwLCBtc29MaXN0TW9kZSk7CiAKKyAgICBTdHJpbmdCdWls ZGVyIGJ1aWxkZXI7CiAgICAgaWYgKG1zb0xpc3RNb2RlID09IE1TT0xpc3RNb2RlOjpQcmVzZXJ2 ZSkgewotICAgICAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7CiAgICAgICAgIGJ1aWxkZXIuYXBw ZW5kTGl0ZXJhbCgiPGh0bWwgeG1sbnM6bz1cInVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2Zm aWNlOm9mZmljZVwiXG4iCiAgICAgICAgICAgICAieG1sbnM6dz1cInVybjpzY2hlbWFzLW1pY3Jv c29mdC1jb206b2ZmaWNlOndvcmRcIlxuIgogICAgICAgICAgICAgInhtbG5zOm09XCJodHRwOi8v c2NoZW1hcy5taWNyb3NvZnQuY29tL29mZmljZS8yMDA0LzEyL29tbWxcIlxuIgogICAgICAgICAg ICAgInhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MFwiPiIpOwotICAgICAg ICBidWlsZGVyLmFwcGVuZChyZXN1bHQpOwotICAgICAgICBidWlsZGVyLmFwcGVuZExpdGVyYWwo IjwvaHRtbD4iKTsKLSAgICAgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKICAgICB9CiAK LSAgICByZXR1cm4gcmVzdWx0OworICAgIGlmICghcmVzdWx0LmlzQWxsQVNDSUkoKSkKKyAgICAg ICAgYnVpbGRlci5hcHBlbmRMaXRlcmFsKCI8bWV0YSBjaGFyc2V0PVwiVVRGLThcIj4iKTsKKwor ICAgIGJ1aWxkZXIuYXBwZW5kKHJlc3VsdCk7CisKKyAgICBpZiAobXNvTGlzdE1vZGUgPT0gTVNP TGlzdE1vZGU6OlByZXNlcnZlKQorICAgICAgICBidWlsZGVyLmFwcGVuZExpdGVyYWwoIjwvaHRt bD4iKTsKKworICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCk7CiB9CiAKIHN0YXRpYyB2b2lk IHJlc3RvcmVBdHRhY2htZW50RWxlbWVudHNJbkZyYWdtZW50KERvY3VtZW50RnJhZ21lbnQmIGZy YWdtZW50KQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmlu ZGV4IGQ4NjM4ODMyZjJmZGE5ZmM2NmQxZjg4ODhhMDllN2Q4YzQ3MjlhODEuLjNlMjE0ZDM5ZDli Nzk4NjUzNGI5YzAxOTJhYWMwZGY1ZGNkOWFmNTkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxv ZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAyMC0wNS0wNSAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDdXQgYW5kIHBh c3RlIGZyb20gR29vZ2xlIERvYyB0byBOb3RlcyBpbiBzZXZlcmFsIChub24tTGF0aW4pIGxhbmd1 YWdlcyBkb2Vzbid0IHdvcmsKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxMTQ5OAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTY2NzUzNDU+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgdGVzdCB0 byB2ZXJpZnkgdGhhdCB3aGVuIHdyaXRpbmcgbWFya3VwIHRvIHRoZSBjbGlwYm9hcmQgdmlhIERP TSBBUEksIGlmIG5vbi1BU0NJSSBjaGFyYWN0ZXJzIGFwcGVhciBpbgorICAgICAgICB0aGUgd3Jp dHRlbiBtYXJrdXAsIHRoZXkgY2FuIHN0aWxsIGJlIGNvbnZlcnRlZCB0byBgTlNBdHRyaWJ1dGVk U3RyaW5nYHMgY29udGFpbmluZyB0aGUgZXhwZWN0ZWQgbm9uLUxhdGluIHRleHQuCisKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0NvcHlIVE1MLm1tOgorICAgICAg ICAocmVhZEhUTUxEYXRhRnJvbVBhc3RlYm9hcmQpOgorICAgICAgICAocmVhZEhUTUxTdHJpbmdG cm9tUGFzdGVib2FyZCk6CisgICAgICAgIChyZWFkSFRNTEZyb21QYXN0ZWJvYXJkKTogRGVsZXRl ZC4KKwogMjAyMC0wNS0wNCAgQmVuIE5oYW0gIDxuaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBJ bmRleGVkREIgV0FMIGZpbGUga2VlcHMgZ3Jvd2luZyB3aGlsZSBhcHAgaXMgaW4gdXNlCmRpZmYg LS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0NvcHlIVE1MLm1t IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db3B5SFRNTC5tbQppbmRl eCBjZmI5ZDhjZWRjOTg1NmI3Y2Q4N2JhM2M3NTg0MGY2YTY0NjkxYzBkLi4yMWUzZjFlNjk1ZDNj Y2RmNzYwZGFlZTZmYWY0NmM5OTA2ODY2YjA1IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdENvY29hL0NvcHlIVE1MLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29weUhUTUwubW0KQEAgLTQ0LDEyICs0NCwyNSBAQCAtICh2 b2lkKXBhc3RlOihpZClzZW5kZXI7CiBAZW5kCiAKICNpZiBQTEFURk9STShNQUMpCi1OU1N0cmlu ZyAqcmVhZEhUTUxGcm9tUGFzdGVib2FyZCgpCisKK05TRGF0YSAqcmVhZEhUTUxEYXRhRnJvbVBh c3RlYm9hcmQoKQoreworICAgIHJldHVybiBbW05TUGFzdGVib2FyZCBnZW5lcmFsUGFzdGVib2Fy ZF0gZGF0YUZvclR5cGU6TlNIVE1MUGJvYXJkVHlwZV07Cit9CisKK05TU3RyaW5nICpyZWFkSFRN TFN0cmluZ0Zyb21QYXN0ZWJvYXJkKCkKIHsKICAgICByZXR1cm4gW1tOU1Bhc3RlYm9hcmQgZ2Vu ZXJhbFBhc3RlYm9hcmRdIHN0cmluZ0ZvclR5cGU6TlNIVE1MUGJvYXJkVHlwZV07CiB9CisKICNl bHNlCi1OU1N0cmluZyAqcmVhZEhUTUxGcm9tUGFzdGVib2FyZCgpCisKK05TRGF0YSAqcmVhZEhU TUxEYXRhRnJvbVBhc3RlYm9hcmQoKQoreworICAgIHJldHVybiBbW1VJUGFzdGVib2FyZCBnZW5l cmFsUGFzdGVib2FyZF0gZGF0YUZvclBhc3RlYm9hcmRUeXBlOihfX2JyaWRnZSBOU1N0cmluZyAq KWtVVFR5cGVIVE1MXTsKK30KKworTlNTdHJpbmcgKnJlYWRIVE1MU3RyaW5nRnJvbVBhc3RlYm9h cmQoKQogewogICAgIGlkIHZhbHVlID0gW1tVSVBhc3RlYm9hcmQgZ2VuZXJhbFBhc3RlYm9hcmRd IHZhbHVlRm9yUGFzdGVib2FyZFR5cGU6KF9fYnJpZGdlIE5TU3RyaW5nICopa1VUVHlwZUhUTUxd OwogICAgIGlmIChbdmFsdWUgaXNLaW5kT2ZDbGFzczpbTlNEYXRhIGNsYXNzXV0pCkBAIC01Nyw2 ICs3MCw3IEBAIE5TU3RyaW5nICpyZWFkSFRNTEZyb21QYXN0ZWJvYXJkKCkKICAgICBBU1NFUlQo W3ZhbHVlIGlzS2luZE9mQ2xhc3M6W05TU3RyaW5nIGNsYXNzXV0pOwogICAgIHJldHVybiAoTlNT dHJpbmcgKil2YWx1ZTsKIH0KKwogI2VuZGlmCiAKIHN0YXRpYyBSZXRhaW5QdHI8VGVzdFdLV2Vi Vmlldz4gY3JlYXRlV2ViVmlld1dpdGhDdXN0b21QYXN0ZWJvYXJkRGF0YUVuYWJsZWQoKQpAQCAt ODAsMTMgKzk0LDY4IEBAIFRFU1QoQ29weUhUTUwsIFNhbml0aXplcykKICAgICBFWFBFQ1RfVFJV RShbd2ViVmlldyBzdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0OkAiZGlkUGFzdGUiXS5ib29s VmFsdWUpOwogICAgIEVYUEVDVF9XS19TVFJFUSgiPG1ldGEgY29udGVudD1cInNlY3JldFwiPjxi IG9ubW91c2VvdmVyPVwiZGFuZ2Vyb3VzQ29kZSgpXCI+aGVsbG88L2I+PCEtLSBzZWNyZXQtLT4s IHdvcmxkPHNjcmlwdD5kYW5nZXJvdXNDb2RlKCk8L3NjcmlwdD4iLAogICAgICAgICBbd2ViVmll dyBzdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0OkAicGFzdGVkSFRNTCJdKTsKLSAgICBTdHJp bmcgaHRtbEluTmF0aXZlUGFzdGVib2FyZCA9IHJlYWRIVE1MRnJvbVBhc3RlYm9hcmQoKTsKKyAg ICBTdHJpbmcgaHRtbEluTmF0aXZlUGFzdGVib2FyZCA9IHJlYWRIVE1MU3RyaW5nRnJvbVBhc3Rl Ym9hcmQoKTsKICAgICBFWFBFQ1RfVFJVRShodG1sSW5OYXRpdmVQYXN0ZWJvYXJkLmNvbnRhaW5z KCJoZWxsbyIpKTsKICAgICBFWFBFQ1RfVFJVRShodG1sSW5OYXRpdmVQYXN0ZWJvYXJkLmNvbnRh aW5zKCIsIHdvcmxkIikpOwogICAgIEVYUEVDVF9GQUxTRShodG1sSW5OYXRpdmVQYXN0ZWJvYXJk LmNvbnRhaW5zKCJzZWNyZXQiKSk7CiAgICAgRVhQRUNUX0ZBTFNFKGh0bWxJbk5hdGl2ZVBhc3Rl Ym9hcmQuY29udGFpbnMoImRhbmdlcm91c0NvZGUiKSk7CiB9CiAKK1RFU1QoQ29weUhUTUwsIFNh bml0aXphdGlvblByZXNlcnZlc0NoYXJhY3RlclNldCkKK3sKKyAgICBWZWN0b3I8c3RkOjpwYWly PFJldGFpblB0cjxOU1N0cmluZz4sIFJldGFpblB0cjxOU0RhdGE+PiwgMz4gbWFya3VwU3RyaW5n c0FuZERhdGE7CisgICAgYXV0byB3ZWJWaWV3ID0gY3JlYXRlV2ViVmlld1dpdGhDdXN0b21QYXN0 ZWJvYXJkRGF0YUVuYWJsZWQoKTsKKyAgICBmb3IgKE5TU3RyaW5nICplbmNvZGluZ05hbWUgaW4g QFsgQCJ1dGYtOCIsIEAid2luZG93cy0xMjUyIiwgQCJib2d1cy1lbmNvZGluZyIgXSkgeworICAg ICAgICBbd2ViVmlldyBzeW5jaHJvbm91c2x5TG9hZEhUTUxTdHJpbmc6W05TU3RyaW5nIHN0cmlu Z1dpdGhGb3JtYXQ6QCI8IURPQ1RZUEUgaHRtbD4iCisgICAgICAgICAgICAiPGJvZHk+IgorICAg ICAgICAgICAgIjxtZXRhIGNoYXJzZXQ9JyVAJz4iCisgICAgICAgICAgICAiPHAgaWQ9J2NvcHkn PkNvcHkgbWU8L3A+IgorICAgICAgICAgICAgIjxzY3JpcHQ+IgorICAgICAgICAgICAgImNvcHku YWRkRXZlbnRMaXN0ZW5lcignY29weScsIGUgPT4geyIKKyAgICAgICAgICAgICIgICAgZS5jbGlw Ym9hcmREYXRhLnNldERhdGEoJ3RleHQvaHRtbCcsIGA8c3BhbiBzdHlsZT0nY29sb3I6IHJlZDsn PuaIkeWPq+isneaWh+aYhzwvc3Bhbj5gKTsiCisgICAgICAgICAgICAiICAgIGUucHJldmVudERl ZmF1bHQoKTsiCisgICAgICAgICAgICAifSk7IgorICAgICAgICAgICAgImdldFNlbGVjdGlvbigp LnNlbGVjdEFsbENoaWxkcmVuKGNvcHkpOyIKKyAgICAgICAgICAgICI8L3NjcmlwdD4iCisgICAg ICAgICAgICAiPC9ib2R5PiIsIGVuY29kaW5nTmFtZV1dOworICAgICAgICBbd2ViVmlldyBjb3B5 Om5pbF07CisgICAgICAgIFt3ZWJWaWV3IHdhaXRGb3JOZXh0UHJlc2VudGF0aW9uVXBkYXRlXTsK KworICAgICAgICBtYXJrdXBTdHJpbmdzQW5kRGF0YS5hcHBlbmQoeyByZWFkSFRNTFN0cmluZ0Zy b21QYXN0ZWJvYXJkKCksIHJlYWRIVE1MRGF0YUZyb21QYXN0ZWJvYXJkKCkgfSk7CisgICAgfQor CisgICAgZm9yIChhdXRvJiBbY29waWVkTWFya3VwLCBjb3BpZWREYXRhXSA6IG1hcmt1cFN0cmlu Z3NBbmREYXRhKSB7CisgICAgICAgIEVYUEVDVF9UUlVFKFtjb3BpZWRNYXJrdXAgY29udGFpbnNT dHJpbmc6QCI8c3BhbiAiXSk7CisgICAgICAgIEVYUEVDVF9UUlVFKFtjb3BpZWRNYXJrdXAgY29u dGFpbnNTdHJpbmc6QCJjb2xvcjogcmVkOyJdKTsKKyAgICAgICAgRVhQRUNUX1RSVUUoW2NvcGll ZE1hcmt1cCBjb250YWluc1N0cmluZzpAIuaIkeWPq+isneaWh+aYhyJdKTsKKyAgICAgICAgRVhQ RUNUX1RSVUUoW2NvcGllZE1hcmt1cCBjb250YWluc1N0cmluZzpAIjwvc3Bhbj4iXSk7CisKKyAg ICAgICAgTlNFcnJvciAqYXR0cmlidXRlZFN0cmluZ0NvbnZlcnNpb25FcnJvciA9IG5pbDsKKwor ICAgICAgICBhdXRvIGF0dHJpYnV0ZWRTdHJpbmcgPSBhZG9wdE5TKFtbTlNBdHRyaWJ1dGVkU3Ry aW5nIGFsbG9jXSBpbml0V2l0aERhdGE6Y29waWVkRGF0YS5nZXQoKSBvcHRpb25zOkB7IE5TRG9j dW1lbnRUeXBlRG9jdW1lbnRPcHRpb246IE5TSFRNTFRleHREb2N1bWVudFR5cGUgfSBkb2N1bWVu dEF0dHJpYnV0ZXM6bmlsIGVycm9yOiZhdHRyaWJ1dGVkU3RyaW5nQ29udmVyc2lvbkVycm9yXSk7 CisgICAgICAgIEVYUEVDVF9XS19TVFJFUSgi5oiR5Y+r6Kyd5paH5piHIiwgW2F0dHJpYnV0ZWRT dHJpbmcgc3RyaW5nXSk7CisKKyAgICAgICAgX19ibG9jayBCT09MIGZvdW5kQ29sb3JBdHRyaWJ1 dGUgPSBOTzsKKyAgICAgICAgW2F0dHJpYnV0ZWRTdHJpbmcgZW51bWVyYXRlQXR0cmlidXRlOk5T Rm9yZWdyb3VuZENvbG9yQXR0cmlidXRlTmFtZSBpblJhbmdlOk5TTWFrZVJhbmdlKDAsIDUpIG9w dGlvbnM6MCB1c2luZ0Jsb2NrOl4oaWQgdmFsdWUsIE5TUmFuZ2UgcmFuZ2UsIEJPT0wgKikgewor I2lmIFBMQVRGT1JNKE1BQykKKyAgICAgICAgICAgIE5TQ29sb3IgKmNvbG9yID0gKE5TQ29sb3Ig Kil2YWx1ZTsKKyNlbHNlCisgICAgICAgICAgICBVSUNvbG9yICpjb2xvciA9IChVSUNvbG9yICop dmFsdWU7CisjZW5kaWYKKyAgICAgICAgICAgIENHRmxvYXQgcmVkQ29tcG9uZW50ID0gMDsKKyAg ICAgICAgICAgIENHRmxvYXQgZ3JlZW5Db21wb25lbnQgPSAwOworICAgICAgICAgICAgQ0dGbG9h dCBibHVlQ29tcG9uZW50ID0gMDsKKyAgICAgICAgICAgIFtjb2xvciBnZXRSZWQ6JnJlZENvbXBv bmVudCBncmVlbjomZ3JlZW5Db21wb25lbnQgYmx1ZTomYmx1ZUNvbXBvbmVudCBhbHBoYTpuaWxd OworCisgICAgICAgICAgICBFWFBFQ1RfRVEoMS4sIHJlZENvbXBvbmVudCk7CisgICAgICAgICAg ICBFWFBFQ1RfRVEoMC4sIGdyZWVuQ29tcG9uZW50KTsKKyAgICAgICAgICAgIEVYUEVDVF9FUSgw LiwgYmx1ZUNvbXBvbmVudCk7CisgICAgICAgICAgICBmb3VuZENvbG9yQXR0cmlidXRlID0gWUVT OworICAgICAgICB9XTsKKyAgICAgICAgRVhQRUNUX1RSVUUoZm91bmRDb2xvckF0dHJpYnV0ZSk7 CisgICAgfQorfQorCiAjaWYgUExBVEZPUk0oTUFDKQogCiBURVNUKENvcHlIVE1MLCBJdGVtVHlw ZXNXaGVuQ29weWluZ1dlYkNvbnRlbnQpCg== 398637 2020-05-06 11:10:22 -0700 2020-05-06 12:10:10 -0700 Address review feedback bug-211498-20200506111021.patch text/plain 18373 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjYxMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzg1ZDIzZDYzM2RmYTkw MWFjMWQwMmM1YzcwMzBhMzQyYzc4NzJiMi4uNmQ2YmQ1OTA1MjJhMWUwYmFiZWE4NDA3OWQ1OTYy YWUwZWIzNDRiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDIwLTA1LTA2ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEN1dCBhbmQgcGFz dGUgZnJvbSBHb29nbGUgRG9jIHRvIE5vdGVzIGluIHNldmVyYWwgKG5vbi1MYXRpbikgbGFuZ3Vh Z2VzIGRvZXNuJ3Qgd29yaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjExNDk4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81NjY3NTM0NT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIGNvcHlpbmcg dGV4dCBpbiBHb29nbGUgRG9jcywgdGhlIHBhZ2UgdXNlcyBgRGF0YVRyYW5zZmVyLnNldERhdGFg IHRvIHdyaXRlIHRleHQvaHRtbCBkYXRhIHRvIHRoZSBzeXN0ZW0KKyAgICAgICAgcGFzdGVib2Fy ZC4gVGhpcyBtYXJrdXAgc3RyaW5nIGluY2x1ZGVzIGEgbWV0YSB0YWcgd2l0aCBgY2hhcnNldD0i dXRmLTgiYCwgaW5kaWNhdGluZyB0aGF0IHRoZSBIVE1MIHN0cmluZyB0aGF0CisgICAgICAgIHdh cyBjb3BpZWQgc2hvdWxkIGJlIGludGVycHJldGVkIGFzIFVURi04IGRhdGEuCisKKyAgICAgICAg SG93ZXZlciwgYmVmb3JlIHdlIHdyaXRlIHRoaXMgZGF0YSB0byB0aGUgc3lzdGVtIHBhc3RlYm9h cmQsIHdlIGZpcnN0IHNhbml0aXplIGl0IGJ5IGxvYWRpbmcgaXQgaW4gYSBzZXBhcmF0ZQorICAg ICAgICBwYWdlLCBhbmQgdGhlbiBidWlsZCB0aGUgZmluYWwgc2FuaXRpemVkIG1hcmt1cCBzdHJp bmcgdG8gd3JpdGUgYnkgaXRlcmF0aW5nIG92ZXIgb25seSB2aXNpYmxlIGNvbnRlbnQgaW4gdGhl CisgICAgICAgIG1haW4gZG9jdW1lbnQgb2YgdGhpcyBwYWdlLiBJbXBvcnRhbnRseSwgdGhpcyBs YXN0IHN0ZXAgc2tpcHMgb3ZlciB0aGUgbWV0YSBlbGVtZW50IGNvbnRhaW5pbmcgdGhlIGNoYXJz ZXQuCisKKyAgICAgICAgTGF0ZXIsIHdoZW4gcGFzdGluZyBpbiBOb3RlcyBvciBUZXh0RWRpdCwg Ym90aCBhcHBzIHVzZSBgLVtOU0F0dHJpYnV0ZWRTdHJpbmcgaW5pdFdpdGhEYXRhOi4uLjpdYCB0 byBjb252ZXJ0IHRoZQorICAgICAgICBIVE1MIGRhdGEgb24gdGhlIHBhc3RlYm9hcmQgaW50byBh biBOU0F0dHJpYnV0ZWRTdHJpbmcuIFRoaXMgdGFrZXMgdGhlIE5TUGFzdGVib2FyZCdzIEhUTUwg ZGF0YSAoYSBibG9iIG9mCisgICAgICAgIGBOU0RhdGFgKSBhbmQgc3luY2hyb25vdXNseSBsb2Fk cyBpdCBpbiBhIG5ldyBsZWdhY3kgV2ViS2l0IHZpZXcgYnkgY2FsbGluZyBgLVtXZWJGcmFtZQor ICAgICAgICBsb2FkRGF0YTpNSU1FVHlwZTp0ZXh0RW5jb2RpbmdOYW1lOmJhc2VVUkw6XWAsIHBh c3NpbmcgaW4gYG5pbGAgYXMgdGhlIHRleHQgZW5jb2RpbmcgbmFtZS4gU2luY2UgV2ViS2l0IGlz IG9ubHkKKyAgICAgICAgZ2l2ZW4gYSBibG9iIG9mIGRhdGEgYW5kIG5vIHBhcnRpY3VsYXIgZW5j b2RpbmcsIHdlIGZhbGwgYmFjayB0byBkZWZhdWx0IExhdGluLTEgZW5jb2RpbmcsIHdoaWNoIHBy b2R1Y2VzCisgICAgICAgIGdpYmJlcmlzaCBmb3IgQ0pLIHRleHQuCisKKyAgICAgICAgVG8gZml4 IHRoaXMsIHdlIGF1dG9tYXRpY2FsbHkgaW5zZXJ0IGEgYDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij5g IHRhZyB3aGVuIHdyaXRpbmcgSFRNTCB0byB0aGUgcGFzdGVib2FyZCwgaWYgdGhlCisgICAgICAg IHNhbml0aXplZCBtYXJrdXAgY29udGFpbnMgbm9uLUFTQ0lJIGNoYXJhY3RlcnMuCisKKyAgICAg ICAgVGVzdDogQ29weUhUTUwuU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hhcmFjdGVyU2V0CisKKyAg ICAgICAgKiBlZGl0aW5nL21hcmt1cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpzaG91bGRBcHBl bmRNZXRhQ2hhcnNldFdoZW5TYW5pdGl6aW5nTWFya3VwKToKKworICAgICAgICBMaW1pdCB0aGlz IGhhY2sgdG8gQ29jb2EgcGxhdGZvcm1zLCB3aGVyZSBkYXRhIGlzIHdyaXR0ZW4gdG8gdGhlIHBh c3RlYm9hcmQgYXMgdW5lbmNvZGVkIGJ5dGVzLgorCisgICAgICAgIChXZWJDb3JlOjpzYW5pdGl6 ZWRNYXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQpOgorCiAyMDIwLTA1LTA0ICBTaW1vbiBGcmFz ZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIENvZGUgY2xlYW51cCBpbiBF dmVudEhhbmRsZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNl L1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggYmNiMjc1MjY1MjE2MDViYmE4MjA1ZGRjYzZhNDYzNjBm OGRhMGRkNC4uMDk0ZDE4MGUxMmI4MzY3ZjZjYzFhMjdlMjJjYTVjZTA3M2U3YzVkOCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxOCBAQAorMjAyMC0wNS0wNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hz aWVoQGFwcGxlLmNvbT4KKworICAgICAgICBDdXQgYW5kIHBhc3RlIGZyb20gR29vZ2xlIERvYyB0 byBOb3RlcyBpbiBzZXZlcmFsIChub24tTGF0aW4pIGxhbmd1YWdlcyBkb2Vzbid0IHdvcmsKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMTQ5OAorICAg ICAgICA8cmRhcjovL3Byb2JsZW0vNTY2NzUzNDU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgbmV3IGhlYWRlciB0byBhbGxvdyBDb2NvYSBj b2RlIHRvIHJlYXNvbiBhYm91dCBVSUNvbG9ycyBhbmQgTlNDb2xvcnMgb24gaU9TIGFuZCBtYWNP UyAocmVzcGVjdGl2ZWx5KQorICAgICAgICB3aXRob3V0IHJlcXVpcmluZyBwbGF0Zm9ybSBpZmRl ZnMuIEEgZm9sbG93dXAgcGF0Y2ggd2lsbCBhZG9wdCB0aGlzIGluIHNldmVyYWwgcGxhY2VzIGlu IFdlYktpdCwgd2hlcmUgd2UKKyAgICAgICAgY3VycmVudGx5IG5lZWQgaWZkZWZzIGZvciBpT1Mg YW5kIG1hY09TLgorCisgICAgICAgICogUGxhdGZvcm0vY29jb2EvQ29jb2FDb2xvci5oOiBBZGRl ZC4KKyAgICAgICAgKiBXZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKwogMjAyMC0w NS0wNCAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgogCiAgICAgICAgIFtpT1NdIE1h a2Ugc3VyZSBUZXN0Q29udHJvbGxlcjo6c3RhdGlzdGljc1Jlc2V0VG9Db25zaXN0ZW50U3RhdGUo KSBkb2VzIG5vdCBoYW5nIGR1ZSB0byBwcm9jZXNzIHN1c3BlbnNpb24KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv bWFya3VwLmNwcAppbmRleCBjYmY2Mjg4ZTliYWVjNWUyOTM1MTVmNTA2YWNkNTkyYTNiMjhlY2Rh Li41MzdkOGJiNzQ5MzRlYzI3MmE2ZmE1MDM0NTgyN2Y5ZGY1M2ZmOGI2IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9lZGl0aW5nL21hcmt1cC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRp dGluZy9tYXJrdXAuY3BwCkBAIC05NDUsNiArOTQ1LDE1IEBAIHN0YXRpYyBib29sIHNob3VsZFBy ZXNlcnZlTVNPTGlzdHMoY29uc3QgU3RyaW5nJiBtYXJrdXApCiAgICAgICAgICYmIGh0bWxUYWcu Y29udGFpbnMoInhtbG5zOnc9XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3Jk XCIiKTsKIH0KIAorc3RhdGljIGJvb2wgc2hvdWxkQXBwZW5kTWV0YUNoYXJzZXRXaGVuU2FuaXRp emluZ01hcmt1cCgpCit7CisjaWYgUExBVEZPUk0oQ09DT0EpCisgICAgcmV0dXJuIHRydWU7Cisj ZWxzZQorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCiBTdHJpbmcgc2FuaXRpemVkTWFy a3VwRm9yRnJhZ21lbnRJbkRvY3VtZW50KFJlZjxEb2N1bWVudEZyYWdtZW50PiYmIGZyYWdtZW50 LCBEb2N1bWVudCYgZG9jdW1lbnQsIE1TT0xpc3RRdWlya3MgbXNvTGlzdFF1aXJrcywgY29uc3Qg U3RyaW5nJiBvcmlnaW5hbE1hcmt1cCkKIHsKICAgICBNU09MaXN0TW9kZSBtc29MaXN0TW9kZSA9 IG1zb0xpc3RRdWlya3MgPT0gTVNPTGlzdFF1aXJrczo6Q2hlY2tJZk5lZWRlZCAmJiBzaG91bGRQ cmVzZXJ2ZU1TT0xpc3RzKG9yaWdpbmFsTWFya3VwKQpAQCAtOTU4LDE4ICs5NjcsMjMgQEAgU3Ry aW5nIHNhbml0aXplZE1hcmt1cEZvckZyYWdtZW50SW5Eb2N1bWVudChSZWY8RG9jdW1lbnRGcmFn bWVudD4mJiBmcmFnbWVudCwgRG8KICAgICBhdXRvIHJlc3VsdCA9IHNlcmlhbGl6ZVByZXNlcnZp bmdWaXN1YWxBcHBlYXJhbmNlSW50ZXJuYWwoZmlyc3RQb3NpdGlvbkluTm9kZShib2R5RWxlbWVu dC5nZXQoKSksIGxhc3RQb3NpdGlvbkluTm9kZShib2R5RWxlbWVudC5nZXQoKSksIG51bGxwdHIs CiAgICAgICAgIFJlc29sdmVVUkxzOjpZZXNFeGNsdWRpbmdMb2NhbEZpbGVVUkxzRm9yUHJpdmFj eSwgU2VyaWFsaXplQ29tcG9zZWRUcmVlOjpObywgQW5ub3RhdGVGb3JJbnRlcmNoYW5nZTo6WWVz LCBDb252ZXJ0QmxvY2tzVG9JbmxpbmVzOjpObywgIFN0YW5kYXJkRm9udEZhbWlseVNlcmlhbGl6 YXRpb25Nb2RlOjpTdHJpcCwgbXNvTGlzdE1vZGUpOwogCisgICAgU3RyaW5nQnVpbGRlciBidWls ZGVyOwogICAgIGlmIChtc29MaXN0TW9kZSA9PSBNU09MaXN0TW9kZTo6UHJlc2VydmUpIHsKLSAg ICAgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOwogICAgICAgICBidWlsZGVyLmFwcGVuZExpdGVy YWwoIjxodG1sIHhtbG5zOm89XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZp Y2VcIlxuIgogICAgICAgICAgICAgInhtbG5zOnc9XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29t Om9mZmljZTp3b3JkXCJcbiIKICAgICAgICAgICAgICJ4bWxuczptPVwiaHR0cDovL3NjaGVtYXMu bWljcm9zb2Z0LmNvbS9vZmZpY2UvMjAwNC8xMi9vbW1sXCJcbiIKICAgICAgICAgICAgICJ4bWxu cz1cImh0dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDBcIj4iKTsKLSAgICAgICAgYnVpbGRl ci5hcHBlbmQocmVzdWx0KTsKLSAgICAgICAgYnVpbGRlci5hcHBlbmRMaXRlcmFsKCI8L2h0bWw+ Iik7Ci0gICAgICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCk7CiAgICAgfQogCi0gICAgcmV0 dXJuIHJlc3VsdDsKKyAgICBpZiAoc2hvdWxkQXBwZW5kTWV0YUNoYXJzZXRXaGVuU2FuaXRpemlu Z01hcmt1cCgpICYmICFyZXN1bHQuaXNBbGxBU0NJSSgpKQorICAgICAgICBidWlsZGVyLmFwcGVu ZExpdGVyYWwoIjxtZXRhIGNoYXJzZXQ9XCJVVEYtOFwiPiIpOworCisgICAgYnVpbGRlci5hcHBl bmQocmVzdWx0KTsKKworICAgIGlmIChtc29MaXN0TW9kZSA9PSBNU09MaXN0TW9kZTo6UHJlc2Vy dmUpCisgICAgICAgIGJ1aWxkZXIuYXBwZW5kTGl0ZXJhbCgiPC9odG1sPiIpOworCisgICAgcmV0 dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKIH0KIAogc3RhdGljIHZvaWQgcmVzdG9yZUF0dGFjaG1l bnRFbGVtZW50c0luRnJhZ21lbnQoRG9jdW1lbnRGcmFnbWVudCYgZnJhZ21lbnQpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL0NvY29hQ29sb3IuaCBiL1NvdXJjZS9X ZWJLaXQvUGxhdGZvcm0vY29jb2EvQ29jb2FDb2xvci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg5NzE2YjlhZjkw MzczOTI2NmI4NWE2NWFlZWVkZWRkODU3ZWU5MGYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViS2l0L1BsYXRmb3JtL2NvY29hL0NvY29hQ29sb3IuaApAQCAtMCwwICsxLDM0IEBACisvKgor KiBDb3B5cmlnaHQgKEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorKgor KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisqIGFyZSBtZXQ6CisqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorKgor KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklC VVRPUlMgYGBBUyBJUycnCisqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorKiBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUworKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisqIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUworKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTgorKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorKiBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G CisqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyovCisKKyNwcmFnbWEgb25jZQor CisjaWYgVVNFKEFQUEtJVCkKK0BjbGFzcyBOU0NvbG9yOwordXNpbmcgQ29jb2FDb2xvciA9IE5T Q29sb3I7CisjZWxzZQorQGNsYXNzIFVJQ29sb3I7Cit1c2luZyBDb2NvYUNvbG9yID0gVUlDb2xv cjsKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKaW5kZXggNTBmMDQyYWQwMzZhZmYzYzNiMGQ5NGRmYjUxNzk2MjMxMTI3MmY1ZS4uMTQ1 MTE2NjY0MmU0NTcyMjFjZDNkMWZhODMzNmQ2ZTE5ZmY0ZmNiMiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2Vi S2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xODQ3LDYgKzE4NDcsNyBA QAogCQlGNEQ1RjUxRjIwNjA4N0ExMDAzOEJCQTggLyogV0tRdWlja2JvYXJkTGlzdFZpZXdDb250 cm9sbGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBG NEQ1RjUxQjIwNjA4N0ExMDAzOEJCQTggLyogV0tRdWlja2JvYXJkTGlzdFZpZXdDb250cm9sbGVy LmggKi87IH07CiAJCUY0REI1NEU2MjMxOUU3MzMwMDlFMzE1NSAvKiBXS0hpZ2hsaWdodExvbmdQ cmVzc0dlc3R1cmVSZWNvZ25pemVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGNERCNTRFNDIzMTlFNzMzMDA5RTMxNTUgLyogV0tIaWdobGlnaHRMb25n UHJlc3NHZXN0dXJlUmVjb2duaXplci5oICovOyB9OwogCQlGNEVDOTRFMzIzNTZDQzU3MDAwQkI2 MTQgLyogQXBwbGljYXRpb25TZXJ2aWNlc1NQSS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gMjlEMDRFMjgyMUY3QzczRDAwNzY3NDFEIC8qIEFwcGxpY2F0 aW9uU2VydmljZXNTUEkuaCAqLzsgfTsKKwkJRjRGRTBBM0IyNDYzMkI2MDAwMjYzMUUxIC8qIENv Y29hQ29sb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEY0RkUwQTNBMjQ2MzJCMTAwMDI2MzFFMSAvKiBDb2NvYUNvbG9yLmggKi87IH07CiAJCUY2MTEz RTI1MTI2Q0UxODIwMDU3RDBBNyAvKiBBUElVc2VyQ29udGVudFVSTFBhdHRlcm4uaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY2MTEzRTI0MTI2Q0UxODIw MDU3RDBBNyAvKiBBUElVc2VyQ29udGVudFVSTFBhdHRlcm4uaCAqLzsgfTsKIAkJRjYxMTNFMjkx MjZDRTE5QjAwNTdEMEE3IC8qIFdLVXNlckNvbnRlbnRVUkxQYXR0ZXJuLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNjExM0UyNzEyNkNFMTlCMDA1N0Qw QTcgLyogV0tVc2VyQ29udGVudFVSTFBhdHRlcm4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNjM0NDQ1NjEyQTg4NUM4MDAwNjEyRDggLyogQVBJ U2VjdXJpdHlPcmlnaW4uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEY2MzQ0NDU1MTJBODg1QzgwMDA2MTJEOCAvKiBBUElTZWN1cml0eU9yaWdpbi5oICov OyB9OwpAQCAtNTM3MCw2ICs1MzcxLDcgQEAKIAkJRjREQjU0RTUyMzE5RTczMzAwOUUzMTU1IC8q IFdLSGlnaGxpZ2h0TG9uZ1ByZXNzR2VzdHVyZVJlY29nbml6ZXIubW0gKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBXS0hpZ2hsaWdodExvbmdQcmVzc0dlc3R1cmVSZWNv Z25pemVyLm1tOyBwYXRoID0gaW9zL1dLSGlnaGxpZ2h0TG9uZ1ByZXNzR2VzdHVyZVJlY29nbml6 ZXIubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY0RjU5QUQzMjA2NUE1QzkwMDZD QUE0NiAvKiBXS1NlbGVjdE1lbnVMaXN0Vmlld0NvbnRyb2xsZXIubW0gKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBXS1NlbGVjdE1lbnVMaXN0Vmlld0NvbnRyb2xsZXIu bW07IHBhdGggPSBpb3MvZm9ybXMvV0tTZWxlY3RNZW51TGlzdFZpZXdDb250cm9sbGVyLm1tOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNEY1OUFENDIwNjVBNUNBMDA2Q0FBNDYgLyog V0tTZWxlY3RNZW51TGlzdFZpZXdDb250cm9sbGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgbmFtZSA9IFdLU2VsZWN0TWVudUxpc3RWaWV3Q29udHJvbGxlci5oOyBwYXRoID0gaW9zL2Zv cm1zL1dLU2VsZWN0TWVudUxpc3RWaWV3Q29udHJvbGxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQlGNEZFMEEzQTI0NjMyQjEwMDAyNjMxRTEgLyogQ29jb2FDb2xvci5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBDb2NvYUNvbG9yLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY2 MTEzRTI0MTI2Q0UxODIwMDU3RDBBNyAvKiBBUElVc2VyQ29udGVudFVSTFBhdHRlcm4uaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQVBJVXNlckNvbnRlbnRVUkxQYXR0ZXJuLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY2MTEzRTI2MTI2Q0UxOUIwMDU3RDBBNyAv KiBXS1VzZXJDb250ZW50VVJMUGF0dGVybi5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBXS1VzZXJDb250ZW50VVJMUGF0dGVybi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUY2MTEzRTI3MTI2Q0UxOUIwMDU3RDBBNyAvKiBXS1VzZXJDb250ZW50VVJM UGF0dGVybi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXS1VzZXJDb250ZW50 VVJMUGF0dGVybi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzY4MCw2ICs3Njgy LDcgQEAKIAkJNDQ1MEFFQkUxREMzRkFBQzAwOTk0M0YyIC8qIGNvY29hICovID0gewogCQkJaXNh ID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQlGNEZFMEEzQTI0NjMyQjEwMDAyNjMx RTEgLyogQ29jb2FDb2xvci5oICovLAogCQkJCTQ0ODI3MzQ2MjQ1MjhGNjAwMEE5NTQ5MyAvKiBD b2NvYUltYWdlLmggKi8sCiAJCQkJQkNFMDkzNzYxNEZCMTI4QjAwMTEzOEQ5IC8qIExheWVySG9z dGluZ0NvbnRleHQuaCAqLywKIAkJCQlCQ0UwOTM3NTE0RkIxMjhCMDAxMTM4RDkgLyogTGF5ZXJI b3N0aW5nQ29udGV4dC5tbSAqLywKQEAgLTEwNzI0LDYgKzEwNzI3LDcgQEAKIAkJCQk0MTg5N0VE QTFGNDE1RDhBMDAxNkZBNDIgLyogQ2FjaGVTdG9yYWdlRW5naW5lQ29ubmVjdGlvbi5oIGluIEhl YWRlcnMgKi8sCiAJCQkJMUFBMkU1MUQxMkU0QzA1RTAwQkM0OTY2IC8qIENHVXRpbGl0aWVzLmgg aW4gSGVhZGVycyAqLywKIAkJCQk1N0I0QjQ2MDIwQjUwNEFDMDBENEFENzkgLyogQ2xpZW50Q2Vy dGlmaWNhdGVBdXRoZW50aWNhdGlvblhQQ0NvbnN0YW50cy5oIGluIEhlYWRlcnMgKi8sCisJCQkJ RjRGRTBBM0IyNDYzMkI2MDAwMjYzMUUxIC8qIENvY29hQ29sb3IuaCBpbiBIZWFkZXJzICovLAog CQkJCTQ0ODI3MzQ3MjQ1MjhGNjAwMEE5NTQ5MyAvKiBDb2NvYUltYWdlLmggaW4gSGVhZGVycyAq LywKIAkJCQlDRTExQUQ1MjFDQkM0ODJGMDA2ODFFRTUgLyogQ29kZVNpZ25pbmcuaCBpbiBIZWFk ZXJzICovLAogCQkJCTM3QkVDNEUxMTk0OTE0ODYwMDhCNDI4NiAvKiBDb21wbGV0aW9uSGFuZGxl ckNhbGxDaGVja2VyLmggaW4gSGVhZGVycyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxv ZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBkODYzODgzMmYyZmRhOWZjNjZkMWY4ODg4YTA5ZTdk OGM0NzI5YTgxLi45ZGU2YzJmYzRiM2RjM2Y4MWM0ZDc0ODBiNzdkOWQ4NzllMmRlZTVhIDEwMDY0 NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MjMgQEAKKzIwMjAtMDUtMDUgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+ CisKKyAgICAgICAgQ3V0IGFuZCBwYXN0ZSBmcm9tIEdvb2dsZSBEb2MgdG8gTm90ZXMgaW4gc2V2 ZXJhbCAobm9uLUxhdGluKSBsYW5ndWFnZXMgZG9lc24ndCB3b3JrCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTE0OTgKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzU2Njc1MzQ1PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBhIHRlc3QgdG8gdmVyaWZ5IHRoYXQgd2hlbiB3cml0aW5nIG1hcmt1cCB0 byB0aGUgY2xpcGJvYXJkIHZpYSBET00gQVBJLCBpZiBub24tQVNDSUkgY2hhcmFjdGVycyBhcHBl YXIgaW4KKyAgICAgICAgdGhlIHdyaXR0ZW4gbWFya3VwLCB0aGV5IGNhbiBzdGlsbCBiZSBjb252 ZXJ0ZWQgdG8gYE5TQXR0cmlidXRlZFN0cmluZ2BzIGNvbnRhaW5pbmcgdGhlIGV4cGVjdGVkIG5v bi1MYXRpbiB0ZXh0LgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9C YXNlLnhjY29uZmlnOgorCisgICAgICAgIEFkanVzdCBoZWFkZXIgc2VhcmNoIHBhdGhzIHNvIHRo YXQgd2UgY2FuIGltcG9ydCBDb2NvYUNvbG9yLmggaW4gV2ViS2l0LgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db3B5SFRNTC5tbToKKyAgICAgICAgKHJlYWRI VE1MRGF0YUZyb21QYXN0ZWJvYXJkKToKKyAgICAgICAgKHJlYWRIVE1MU3RyaW5nRnJvbVBhc3Rl Ym9hcmQpOgorICAgICAgICAocmVhZEhUTUxGcm9tUGFzdGVib2FyZCk6IERlbGV0ZWQuCisKIDIw MjAtMDUtMDQgIEJlbiBOaGFtICA8bmhhbUBhcHBsZS5jb20+CiAKICAgICAgICAgSW5kZXhlZERC IFdBTCBmaWxlIGtlZXBzIGdyb3dpbmcgd2hpbGUgYXBwIGlzIGluIHVzZQpkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9CYXNlLnhjY29uZmlnIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9CYXNlLnhjY29uZmlnCmluZGV4IGE2NzRmNmQ1 ZGVkZWVjYmJkNWE3M2FkMjM0Y2NlMGRlOTAyN2U2ZmQuLmY1ZTJmYWU5ZGEwMDBiNTFiMGQzOTFk NjgzNjc3MjNmMTMxZWM4MGQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmln dXJhdGlvbnMvQmFzZS54Y2NvbmZpZworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL0NvbmZpZ3Vy YXRpb25zL0Jhc2UueGNjb25maWcKQEAgLTMzLDcgKzMzLDcgQEAgQ0xBTkdfQ1hYX0xBTkdVQUdF X1NUQU5EQVJEID0gZ251KysxejsKIENMQU5HX0NYWF9MSUJSQVJZID0gbGliYysrOwogQ0xBTkdf RU5BQkxFX09CSkNfV0VBSyA9IFlFUzsKIENMQU5HX1dBUk5fQ1hYMFhfRVhURU5TSU9OUyA9IE5P OwotSEVBREVSX1NFQVJDSF9QQVRIUyA9ICR7QlVJTFRfUFJPRFVDVFNfRElSfS91c3IvbG9jYWwv aW5jbHVkZSAkKFdFQkNPUkVfUFJJVkFURV9IRUFERVJTX0RJUikvRm9yd2FyZGluZ0hlYWRlcnMg JChCVUlMVF9QUk9EVUNUU19ESVIpL1dlYkNvcmVUZXN0U3VwcG9ydCAke1NSQ1JPT1R9OworSEVB REVSX1NFQVJDSF9QQVRIUyA9ICR7QlVJTFRfUFJPRFVDVFNfRElSfS91c3IvbG9jYWwvaW5jbHVk ZSAkKFdFQkNPUkVfUFJJVkFURV9IRUFERVJTX0RJUikvRm9yd2FyZGluZ0hlYWRlcnMgJChCVUlM VF9QUk9EVUNUU19ESVIpL1dlYkNvcmVUZXN0U3VwcG9ydCAke1NSQ1JPT1R9ICQoU1JDUk9PVCkv Li4vLi4vU291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYTsKIAogR0NDX05PX0NPTU1PTl9CTE9D S1MgPSBZRVM7CiBHQ0NfUFJFUFJPQ0VTU09SX0RFRklOSVRJT05TID0gJChERUJVR19ERUZJTkVT KSAkKEZFQVRVUkVfREVGSU5FUykgVV9ESVNBQkxFX1JFTkFNSU5HPTEgVV9TSE9XX0NQTFVTUExV U19BUEk9MCAkKEdDQ19QUkVQUk9DRVNTT1JfREVGSU5JVElPTlNfJChQTEFURk9STV9OQU1FKSk7 CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0NvcHlI VE1MLm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db3B5SFRNTC5t bQppbmRleCBjZmI5ZDhjZWRjOTg1NmI3Y2Q4N2JhM2M3NTg0MGY2YTY0NjkxYzBkLi43NmVkYTIz MmVkM2EzZjAyNjVjNmQ1NTMxZTExNDk1NTE5ZTIyODE3IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0NvcHlIVE1MLm1tCisrKyBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29weUhUTUwubW0KQEAgLTI4LDYgKzI4LDcgQEAK IAogI2lmIFBMQVRGT1JNKENPQ09BKQogCisjaW1wb3J0ICJDb2NvYUNvbG9yLmgiCiAjaW1wb3J0 ICJQbGF0Zm9ybVV0aWxpdGllcy5oIgogI2ltcG9ydCAiVGVzdFdLV2ViVmlldy5oIgogI2ltcG9y dCA8V2ViS2l0L1dLUHJlZmVyZW5jZXNQcml2YXRlLmg+CkBAIC00NCwxMiArNDUsMjUgQEAgLSAo dm9pZClwYXN0ZTooaWQpc2VuZGVyOwogQGVuZAogCiAjaWYgUExBVEZPUk0oTUFDKQotTlNTdHJp bmcgKnJlYWRIVE1MRnJvbVBhc3RlYm9hcmQoKQorCitOU0RhdGEgKnJlYWRIVE1MRGF0YUZyb21Q YXN0ZWJvYXJkKCkKK3sKKyAgICByZXR1cm4gW1tOU1Bhc3RlYm9hcmQgZ2VuZXJhbFBhc3RlYm9h cmRdIGRhdGFGb3JUeXBlOk5TSFRNTFBib2FyZFR5cGVdOworfQorCitOU1N0cmluZyAqcmVhZEhU TUxTdHJpbmdGcm9tUGFzdGVib2FyZCgpCiB7CiAgICAgcmV0dXJuIFtbTlNQYXN0ZWJvYXJkIGdl bmVyYWxQYXN0ZWJvYXJkXSBzdHJpbmdGb3JUeXBlOk5TSFRNTFBib2FyZFR5cGVdOwogfQorCiAj ZWxzZQotTlNTdHJpbmcgKnJlYWRIVE1MRnJvbVBhc3RlYm9hcmQoKQorCitOU0RhdGEgKnJlYWRI VE1MRGF0YUZyb21QYXN0ZWJvYXJkKCkKK3sKKyAgICByZXR1cm4gW1tVSVBhc3RlYm9hcmQgZ2Vu ZXJhbFBhc3RlYm9hcmRdIGRhdGFGb3JQYXN0ZWJvYXJkVHlwZTooX19icmlkZ2UgTlNTdHJpbmcg KilrVVRUeXBlSFRNTF07Cit9CisKK05TU3RyaW5nICpyZWFkSFRNTFN0cmluZ0Zyb21QYXN0ZWJv YXJkKCkKIHsKICAgICBpZCB2YWx1ZSA9IFtbVUlQYXN0ZWJvYXJkIGdlbmVyYWxQYXN0ZWJvYXJk XSB2YWx1ZUZvclBhc3RlYm9hcmRUeXBlOihfX2JyaWRnZSBOU1N0cmluZyAqKWtVVFR5cGVIVE1M XTsKICAgICBpZiAoW3ZhbHVlIGlzS2luZE9mQ2xhc3M6W05TRGF0YSBjbGFzc11dKQpAQCAtNTcs NiArNzEsNyBAQCBOU1N0cmluZyAqcmVhZEhUTUxGcm9tUGFzdGVib2FyZCgpCiAgICAgQVNTRVJU KFt2YWx1ZSBpc0tpbmRPZkNsYXNzOltOU1N0cmluZyBjbGFzc11dKTsKICAgICByZXR1cm4gKE5T U3RyaW5nICopdmFsdWU7CiB9CisKICNlbmRpZgogCiBzdGF0aWMgUmV0YWluUHRyPFRlc3RXS1dl YlZpZXc+IGNyZWF0ZVdlYlZpZXdXaXRoQ3VzdG9tUGFzdGVib2FyZERhdGFFbmFibGVkKCkKQEAg LTgwLDEzICs5NSw2MyBAQCBURVNUKENvcHlIVE1MLCBTYW5pdGl6ZXMpCiAgICAgRVhQRUNUX1RS VUUoW3dlYlZpZXcgc3RyaW5nQnlFdmFsdWF0aW5nSmF2YVNjcmlwdDpAImRpZFBhc3RlIl0uYm9v bFZhbHVlKTsKICAgICBFWFBFQ1RfV0tfU1RSRVEoIjxtZXRhIGNvbnRlbnQ9XCJzZWNyZXRcIj48 YiBvbm1vdXNlb3Zlcj1cImRhbmdlcm91c0NvZGUoKVwiPmhlbGxvPC9iPjwhLS0gc2VjcmV0LS0+ LCB3b3JsZDxzY3JpcHQ+ZGFuZ2Vyb3VzQ29kZSgpPC9zY3JpcHQ+IiwKICAgICAgICAgW3dlYlZp ZXcgc3RyaW5nQnlFdmFsdWF0aW5nSmF2YVNjcmlwdDpAInBhc3RlZEhUTUwiXSk7Ci0gICAgU3Ry aW5nIGh0bWxJbk5hdGl2ZVBhc3RlYm9hcmQgPSByZWFkSFRNTEZyb21QYXN0ZWJvYXJkKCk7Cisg ICAgU3RyaW5nIGh0bWxJbk5hdGl2ZVBhc3RlYm9hcmQgPSByZWFkSFRNTFN0cmluZ0Zyb21QYXN0 ZWJvYXJkKCk7CiAgICAgRVhQRUNUX1RSVUUoaHRtbEluTmF0aXZlUGFzdGVib2FyZC5jb250YWlu cygiaGVsbG8iKSk7CiAgICAgRVhQRUNUX1RSVUUoaHRtbEluTmF0aXZlUGFzdGVib2FyZC5jb250 YWlucygiLCB3b3JsZCIpKTsKICAgICBFWFBFQ1RfRkFMU0UoaHRtbEluTmF0aXZlUGFzdGVib2Fy ZC5jb250YWlucygic2VjcmV0IikpOwogICAgIEVYUEVDVF9GQUxTRShodG1sSW5OYXRpdmVQYXN0 ZWJvYXJkLmNvbnRhaW5zKCJkYW5nZXJvdXNDb2RlIikpOwogfQogCitURVNUKENvcHlIVE1MLCBT YW5pdGl6YXRpb25QcmVzZXJ2ZXNDaGFyYWN0ZXJTZXQpCit7CisgICAgVmVjdG9yPHN0ZDo6cGFp cjxSZXRhaW5QdHI8TlNTdHJpbmc+LCBSZXRhaW5QdHI8TlNEYXRhPj4sIDM+IG1hcmt1cFN0cmlu Z3NBbmREYXRhOworICAgIGF1dG8gd2ViVmlldyA9IGNyZWF0ZVdlYlZpZXdXaXRoQ3VzdG9tUGFz dGVib2FyZERhdGFFbmFibGVkKCk7CisgICAgZm9yIChOU1N0cmluZyAqZW5jb2RpbmdOYW1lIGlu IEBbIEAidXRmLTgiLCBAIndpbmRvd3MtMTI1MiIsIEAiYm9ndXMtZW5jb2RpbmciIF0pIHsKKyAg ICAgICAgW3dlYlZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nOltOU1N0cmluZyBzdHJp bmdXaXRoRm9ybWF0OkAiPCFET0NUWVBFIGh0bWw+IgorICAgICAgICAgICAgIjxib2R5PiIKKyAg ICAgICAgICAgICI8bWV0YSBjaGFyc2V0PSclQCc+IgorICAgICAgICAgICAgIjxwIGlkPSdjb3B5 Jz5Db3B5IG1lPC9wPiIKKyAgICAgICAgICAgICI8c2NyaXB0PiIKKyAgICAgICAgICAgICJjb3B5 LmFkZEV2ZW50TGlzdGVuZXIoJ2NvcHknLCBlID0+IHsiCisgICAgICAgICAgICAiICAgIGUuY2xp cGJvYXJkRGF0YS5zZXREYXRhKCd0ZXh0L2h0bWwnLCBgPHNwYW4gc3R5bGU9J2NvbG9yOiByZWQ7 Jz7miJHlj6vorJ3mlofmmIc8L3NwYW4+YCk7IgorICAgICAgICAgICAgIiAgICBlLnByZXZlbnRE ZWZhdWx0KCk7IgorICAgICAgICAgICAgIn0pOyIKKyAgICAgICAgICAgICJnZXRTZWxlY3Rpb24o KS5zZWxlY3RBbGxDaGlsZHJlbihjb3B5KTsiCisgICAgICAgICAgICAiPC9zY3JpcHQ+IgorICAg ICAgICAgICAgIjwvYm9keT4iLCBlbmNvZGluZ05hbWVdXTsKKyAgICAgICAgW3dlYlZpZXcgY29w eTpuaWxdOworICAgICAgICBbd2ViVmlldyB3YWl0Rm9yTmV4dFByZXNlbnRhdGlvblVwZGF0ZV07 CisKKyAgICAgICAgbWFya3VwU3RyaW5nc0FuZERhdGEuYXBwZW5kKHsgcmVhZEhUTUxTdHJpbmdG cm9tUGFzdGVib2FyZCgpLCByZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCgpIH0pOworICAgIH0K KworICAgIGZvciAoYXV0byYgW2NvcGllZE1hcmt1cCwgY29waWVkRGF0YV0gOiBtYXJrdXBTdHJp bmdzQW5kRGF0YSkgeworICAgICAgICBFWFBFQ1RfVFJVRShbY29waWVkTWFya3VwIGNvbnRhaW5z U3RyaW5nOkAiPHNwYW4gIl0pOworICAgICAgICBFWFBFQ1RfVFJVRShbY29waWVkTWFya3VwIGNv bnRhaW5zU3RyaW5nOkAiY29sb3I6IHJlZDsiXSk7CisgICAgICAgIEVYUEVDVF9UUlVFKFtjb3Bp ZWRNYXJrdXAgY29udGFpbnNTdHJpbmc6QCLmiJHlj6vorJ3mlofmmIciXSk7CisgICAgICAgIEVY UEVDVF9UUlVFKFtjb3BpZWRNYXJrdXAgY29udGFpbnNTdHJpbmc6QCI8L3NwYW4+Il0pOworCisg ICAgICAgIE5TRXJyb3IgKmF0dHJpYnV0ZWRTdHJpbmdDb252ZXJzaW9uRXJyb3IgPSBuaWw7CisK KyAgICAgICAgYXV0byBhdHRyaWJ1dGVkU3RyaW5nID0gYWRvcHROUyhbW05TQXR0cmlidXRlZFN0 cmluZyBhbGxvY10gaW5pdFdpdGhEYXRhOmNvcGllZERhdGEuZ2V0KCkgb3B0aW9uczpAeyBOU0Rv Y3VtZW50VHlwZURvY3VtZW50T3B0aW9uOiBOU0hUTUxUZXh0RG9jdW1lbnRUeXBlIH0gZG9jdW1l bnRBdHRyaWJ1dGVzOm5pbCBlcnJvcjomYXR0cmlidXRlZFN0cmluZ0NvbnZlcnNpb25FcnJvcl0p OworICAgICAgICBFWFBFQ1RfV0tfU1RSRVEoIuaIkeWPq+isneaWh+aYhyIsIFthdHRyaWJ1dGVk U3RyaW5nIHN0cmluZ10pOworCisgICAgICAgIF9fYmxvY2sgQk9PTCBmb3VuZENvbG9yQXR0cmli dXRlID0gTk87CisgICAgICAgIFthdHRyaWJ1dGVkU3RyaW5nIGVudW1lcmF0ZUF0dHJpYnV0ZTpO U0ZvcmVncm91bmRDb2xvckF0dHJpYnV0ZU5hbWUgaW5SYW5nZTpOU01ha2VSYW5nZSgwLCA1KSBv cHRpb25zOjAgdXNpbmdCbG9jazpeKENvY29hQ29sb3IgKmNvbG9yLCBOU1JhbmdlIHJhbmdlLCBC T09MICopIHsKKyAgICAgICAgICAgIENHRmxvYXQgcmVkQ29tcG9uZW50ID0gMDsKKyAgICAgICAg ICAgIENHRmxvYXQgZ3JlZW5Db21wb25lbnQgPSAwOworICAgICAgICAgICAgQ0dGbG9hdCBibHVl Q29tcG9uZW50ID0gMDsKKyAgICAgICAgICAgIFtjb2xvciBnZXRSZWQ6JnJlZENvbXBvbmVudCBn cmVlbjomZ3JlZW5Db21wb25lbnQgYmx1ZTomYmx1ZUNvbXBvbmVudCBhbHBoYTpuaWxdOworCisg ICAgICAgICAgICBFWFBFQ1RfRVEoMS4sIHJlZENvbXBvbmVudCk7CisgICAgICAgICAgICBFWFBF Q1RfRVEoMC4sIGdyZWVuQ29tcG9uZW50KTsKKyAgICAgICAgICAgIEVYUEVDVF9FUSgwLiwgYmx1 ZUNvbXBvbmVudCk7CisgICAgICAgICAgICBmb3VuZENvbG9yQXR0cmlidXRlID0gWUVTOworICAg ICAgICB9XTsKKyAgICAgICAgRVhQRUNUX1RSVUUoZm91bmRDb2xvckF0dHJpYnV0ZSk7CisgICAg fQorfQorCiAjaWYgUExBVEZPUk0oTUFDKQogCiBURVNUKENvcHlIVE1MLCBJdGVtVHlwZXNXaGVu Q29weWluZ1dlYkNvbnRlbnQpCg== 398643 2020-05-06 12:10:12 -0700 2020-05-06 13:02:44 -0700 Address review feedback (2) bug-211498-20200506121010.patch text/plain 26501 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjYxMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzg1ZDIzZDYzM2RmYTkw MWFjMWQwMmM1YzcwMzBhMzQyYzc4NzJiMi4uYTIxZGVmZDRjYzdlZjIxZTE0YzlhZTU2MmQyNzcw YTgzMTVhMWFiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDIwLTA1LTA2ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEN1dCBhbmQgcGFz dGUgZnJvbSBHb29nbGUgRG9jIHRvIE5vdGVzIGluIHNldmVyYWwgKG5vbi1MYXRpbikgbGFuZ3Vh Z2VzIGRvZXNuJ3Qgd29yaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjExNDk4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81NjY3NTM0NT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIGNvcHlpbmcg dGV4dCBpbiBHb29nbGUgRG9jcywgdGhlIHBhZ2UgdXNlcyBgRGF0YVRyYW5zZmVyLnNldERhdGFg IHRvIHdyaXRlIHRleHQvaHRtbCBkYXRhIHRvIHRoZSBzeXN0ZW0KKyAgICAgICAgcGFzdGVib2Fy ZC4gVGhpcyBtYXJrdXAgc3RyaW5nIGluY2x1ZGVzIGEgbWV0YSB0YWcgd2l0aCBgY2hhcnNldD0i dXRmLTgiYCwgaW5kaWNhdGluZyB0aGF0IHRoZSBIVE1MIHN0cmluZyB0aGF0CisgICAgICAgIHdh cyBjb3BpZWQgc2hvdWxkIGJlIGludGVycHJldGVkIGFzIFVURi04IGRhdGEuCisKKyAgICAgICAg SG93ZXZlciwgYmVmb3JlIHdlIHdyaXRlIHRoaXMgZGF0YSB0byB0aGUgc3lzdGVtIHBhc3RlYm9h cmQsIHdlIGZpcnN0IHNhbml0aXplIGl0IGJ5IGxvYWRpbmcgaXQgaW4gYSBzZXBhcmF0ZQorICAg ICAgICBwYWdlLCBhbmQgdGhlbiBidWlsZCB0aGUgZmluYWwgc2FuaXRpemVkIG1hcmt1cCBzdHJp bmcgdG8gd3JpdGUgYnkgaXRlcmF0aW5nIG92ZXIgb25seSB2aXNpYmxlIGNvbnRlbnQgaW4gdGhl CisgICAgICAgIG1haW4gZG9jdW1lbnQgb2YgdGhpcyBwYWdlLiBJbXBvcnRhbnRseSwgdGhpcyBs YXN0IHN0ZXAgc2tpcHMgb3ZlciB0aGUgbWV0YSBlbGVtZW50IGNvbnRhaW5pbmcgdGhlIGNoYXJz ZXQuCisKKyAgICAgICAgTGF0ZXIsIHdoZW4gcGFzdGluZyBpbiBOb3RlcyBvciBUZXh0RWRpdCwg Ym90aCBhcHBzIHVzZSBgLVtOU0F0dHJpYnV0ZWRTdHJpbmcgaW5pdFdpdGhEYXRhOi4uLjpdYCB0 byBjb252ZXJ0IHRoZQorICAgICAgICBIVE1MIGRhdGEgb24gdGhlIHBhc3RlYm9hcmQgaW50byBh biBOU0F0dHJpYnV0ZWRTdHJpbmcuIFRoaXMgdGFrZXMgdGhlIE5TUGFzdGVib2FyZCdzIEhUTUwg ZGF0YSAoYSBibG9iIG9mCisgICAgICAgIGBOU0RhdGFgKSBhbmQgc3luY2hyb25vdXNseSBsb2Fk cyBpdCBpbiBhIG5ldyBsZWdhY3kgV2ViS2l0IHZpZXcgYnkgY2FsbGluZyBgLVtXZWJGcmFtZQor ICAgICAgICBsb2FkRGF0YTpNSU1FVHlwZTp0ZXh0RW5jb2RpbmdOYW1lOmJhc2VVUkw6XWAsIHBh c3NpbmcgaW4gYG5pbGAgYXMgdGhlIHRleHQgZW5jb2RpbmcgbmFtZS4gU2luY2UgV2ViS2l0IGlz IG9ubHkKKyAgICAgICAgZ2l2ZW4gYSBibG9iIG9mIGRhdGEgYW5kIG5vIHBhcnRpY3VsYXIgZW5j b2RpbmcsIHdlIGZhbGwgYmFjayB0byBkZWZhdWx0IExhdGluLTEgZW5jb2RpbmcsIHdoaWNoIHBy b2R1Y2VzCisgICAgICAgIGdpYmJlcmlzaCBmb3IgQ0pLIHRleHQuCisKKyAgICAgICAgVG8gZml4 IHRoaXMsIHdlIGF1dG9tYXRpY2FsbHkgaW5zZXJ0IGEgYDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij5g IHRhZyB3aGVuIHdyaXRpbmcgSFRNTCB0byB0aGUgcGFzdGVib2FyZCwgaWYgdGhlCisgICAgICAg IHNhbml0aXplZCBtYXJrdXAgY29udGFpbnMgbm9uLUFTQ0lJIGNoYXJhY3RlcnMuCisKKyAgICAg ICAgVGVzdDogQ29weUhUTUwuU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hhcmFjdGVyU2V0CisKKyAg ICAgICAgKiBNb2R1bGVzL2FzeW5jLWNsaXBib2FyZC9DbGlwYm9hcmRJdGVtQmluZGluZ3NEYXRh U291cmNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNsaXBib2FyZEl0ZW1CaW5kaW5nc0RhdGFT b3VyY2U6OkNsaXBib2FyZEl0ZW1UeXBlTG9hZGVyOjpzYW5pdGl6ZURhdGFJZk5lZWRlZCk6CisK KyAgICAgICAgUGFzcyBpbiBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpZZXMuCisKKyAgICAgICAg KiBkb20vRGF0YVRyYW5zZmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFUcmFuc2Zlcjo6 c2V0RGF0YUZyb21JdGVtTGlzdCk6CisKKyAgICAgICAgUGFzcyBpbiBBZGRNZXRhQ2hhcnNldElm TmVlZGVkOjpZZXMgaGVyZSB0b28uCisKKyAgICAgICAgKiBlZGl0aW5nL2NvY29hL1dlYkNvbnRl bnRSZWFkZXJDb2NvYS5tbToKKyAgICAgICAgKFdlYkNvcmU6OnNhbml0aXplTWFya3VwV2l0aEFy Y2hpdmUpOgorICAgICAgICAoV2ViQ29yZTo6V2ViQ29udGVudFJlYWRlcjo6cmVhZEhUTUwpOgor ICAgICAgICAoV2ViQ29yZTo6V2ViQ29udGVudE1hcmt1cFJlYWRlcjo6cmVhZEhUTUwpOgorICAg ICAgICAqIGVkaXRpbmcvbWFya3VwLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnNhbml0aXplTWFy a3VwKToKKworICAgICAgICBBZGQgYSBuZXcgZW51bSBzbyB0aGF0IHdlIG9ubHkgYWRkIHRoZSBl eHRyYSBtZXRhIHRhZyB3aGVuIHNhbml0aXppbmcgY29udGVudCB0aGF0IGlzIGJlaW5nIHdyaXR0 ZW4gdG8gdGhlCisgICAgICAgIHN5c3RlbSBwYXN0ZWJvYXJkIHRocm91Z2ggb25lIG9mIHRoZSBj bGlwYm9hcmQgRE9NIEFQSXMuCisKKyAgICAgICAgKFdlYkNvcmU6OnNhbml0aXplZE1hcmt1cEZv ckZyYWdtZW50SW5Eb2N1bWVudCk6CisgICAgICAgICogZWRpdGluZy9tYXJrdXAuaDoKKwogMjAy MC0wNS0wNCAgU2ltb24gRnJhc2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAg ICBDb2RlIGNsZWFudXAgaW4gRXZlbnRIYW5kbGVyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGJjYjI3NTI2NTIxNjA1 YmJhODIwNWRkY2M2YTQ2MzYwZjhkYTBkZDQuLjA5NGQxODBlMTJiODM2N2Y2Y2MxYTI3ZTIyY2E1 Y2UwNzNlN2M1ZDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMjAtMDUtMDYgIFdlbnNv biBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgQ3V0IGFuZCBwYXN0 ZSBmcm9tIEdvb2dsZSBEb2MgdG8gTm90ZXMgaW4gc2V2ZXJhbCAobm9uLUxhdGluKSBsYW5ndWFn ZXMgZG9lc24ndCB3b3JrCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMTE0OTgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU2Njc1MzQ1PgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIG5ldyBoZWFk ZXIgdG8gYWxsb3cgQ29jb2EgY29kZSB0byByZWFzb24gYWJvdXQgVUlDb2xvcnMgYW5kIE5TQ29s b3JzIG9uIGlPUyBhbmQgbWFjT1MgKHJlc3BlY3RpdmVseSkKKyAgICAgICAgd2l0aG91dCByZXF1 aXJpbmcgcGxhdGZvcm0gaWZkZWZzLiBBIGZvbGxvd3VwIHBhdGNoIHdpbGwgYWRvcHQgdGhpcyBp biBzZXZlcmFsIHBsYWNlcyBpbiBXZWJLaXQsIHdoZXJlIHdlCisgICAgICAgIGN1cnJlbnRseSBu ZWVkIGlmZGVmcyBmb3IgaU9TIGFuZCBtYWNPUy4KKworICAgICAgICAqIFBsYXRmb3JtL2NvY29h L0NvY29hQ29sb3IuaDogQWRkZWQuCisgICAgICAgICogV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2o6CisKIDIwMjAtMDUtMDQgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4K IAogICAgICAgICBbaU9TXSBNYWtlIHN1cmUgVGVzdENvbnRyb2xsZXI6OnN0YXRpc3RpY3NSZXNl dFRvQ29uc2lzdGVudFN0YXRlKCkgZG9lcyBub3QgaGFuZyBkdWUgdG8gcHJvY2VzcyBzdXNwZW5z aW9uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2FzeW5jLWNsaXBib2FyZC9D bGlwYm9hcmRJdGVtQmluZGluZ3NEYXRhU291cmNlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvYXN5bmMtY2xpcGJvYXJkL0NsaXBib2FyZEl0ZW1CaW5kaW5nc0RhdGFTb3VyY2UuY3BwCmlu ZGV4IDc0NjVkMGU2YTg2Njg3MzhmNGViZGM1NzRmOTI2Yzc0ODhlN2FhNGUuLjBmZDZmMjA5MmU0 N2FhNmY5Zjk1ZWUyNGRlMWNmOGVlY2UwZmViOWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvYXN5bmMtY2xpcGJvYXJkL0NsaXBib2FyZEl0ZW1CaW5kaW5nc0RhdGFTb3VyY2Uu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvYXN5bmMtY2xpcGJvYXJkL0NsaXBib2Fy ZEl0ZW1CaW5kaW5nc0RhdGFTb3VyY2UuY3BwCkBAIC0yNjksNyArMjY5LDcgQEAgdm9pZCBDbGlw Ym9hcmRJdGVtQmluZGluZ3NEYXRhU291cmNlOjpDbGlwYm9hcmRJdGVtVHlwZUxvYWRlcjo6c2Fu aXRpemVEYXRhSWZOZWUKICAgICAgICAgaWYgKG1hcmt1cFRvU2FuaXRpemUuaXNFbXB0eSgpKQog ICAgICAgICAgICAgcmV0dXJuOwogCi0gICAgICAgIG1fZGF0YSA9IHsgc2FuaXRpemVNYXJrdXAo bWFya3VwVG9TYW5pdGl6ZSkgfTsKKyAgICAgICAgbV9kYXRhID0geyBzYW5pdGl6ZU1hcmt1cCht YXJrdXBUb1Nhbml0aXplLCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpZZXMpIH07CiAgICAgfQog CiAgICAgaWYgKG1fdHlwZSA9PSAiaW1hZ2UvcG5nIl9zKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9kb20vRGF0YVRyYW5zZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9EYXRhVHJh bnNmZXIuY3BwCmluZGV4IDg0NjNhNDhlOTc0ZmJlM2Y3N2Y2NjllNTE3ODI0NzliOTRjYjEwOTYu Ljg0ZjJiMTEyZDBkZDkwNGVlMWNlM2ExODQ5MDU2ZWVmZDU3YTExYzYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9EYXRhVHJhbnNmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9EYXRhVHJhbnNmZXIuY3BwCkBAIC0yNTMsNyArMjUzLDcgQEAgdm9pZCBEYXRhVHJhbnNmZXI6 OnNldERhdGFGcm9tSXRlbUxpc3QoY29uc3QgU3RyaW5nJiB0eXBlLCBjb25zdCBTdHJpbmcmIGRh dGEpCiAKICAgICBTdHJpbmcgc2FuaXRpemVkRGF0YTsKICAgICBpZiAodHlwZSA9PSAidGV4dC9o dG1sIikKLSAgICAgICAgc2FuaXRpemVkRGF0YSA9IHNhbml0aXplTWFya3VwKGRhdGEpOworICAg ICAgICBzYW5pdGl6ZWREYXRhID0gc2FuaXRpemVNYXJrdXAoZGF0YSwgQWRkTWV0YUNoYXJzZXRJ Zk5lZWRlZDo6WWVzKTsKICAgICBlbHNlIGlmICh0eXBlID09ICJ0ZXh0L3VyaS1saXN0Iikgewog ICAgICAgICBhdXRvIHVybCA9IFVSTCh7IH0sIGRhdGEpOwogICAgICAgICBpZiAodXJsLmlzVmFs aWQoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvY29jb2EvV2ViQ29udGVu dFJlYWRlckNvY29hLm1tIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9jb2NvYS9XZWJDb250ZW50 UmVhZGVyQ29jb2EubW0KaW5kZXggMjg5OWYzNWU4MDhhYzA0NGNlNWE3MWEwNDk1MTYyYjE1MWUy ZjZjYS4uYTQ4ZTU1YWI0OWE2ZmEzMTkxY2M2N2QzMWYzYWIyMjVjN2MzYmI3NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9jb2NvYS9XZWJDb250ZW50UmVhZGVyQ29jb2EubW0K KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9jb2NvYS9XZWJDb250ZW50UmVhZGVyQ29jb2Eu bW0KQEAgLTQ0OSw3ICs0NDksNyBAQCBzdGF0aWMgU3RyaW5nIHNhbml0aXplTWFya3VwV2l0aEFy Y2hpdmUoRnJhbWUmIGZyYW1lLCBEb2N1bWVudCYgZGVzdGluYXRpb25Eb2N1bQogCiAgICAgaWYg KHNob3VsZFJlcGxhY2VSaWNoQ29udGVudFdpdGhBdHRhY2htZW50cygpKSB7CiAgICAgICAgIHJl cGxhY2VSaWNoQ29udGVudFdpdGhBdHRhY2htZW50cyhmcmFtZSwgZnJhZ21lbnQsIG1hcmt1cEFu ZEFyY2hpdmUuYXJjaGl2ZS0+c3VicmVzb3VyY2VzKCkpOwotICAgICAgICByZXR1cm4gc2FuaXRp emVkTWFya3VwRm9yRnJhZ21lbnRJbkRvY3VtZW50KFdURk1vdmUoZnJhZ21lbnQpLCAqc3RhZ2lu Z0RvY3VtZW50LCBtc29MaXN0UXVpcmtzLCBtYXJrdXBBbmRBcmNoaXZlLm1hcmt1cCk7CisgICAg ICAgIHJldHVybiBzYW5pdGl6ZWRNYXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQoV1RGTW92ZShm cmFnbWVudCksICpzdGFnaW5nRG9jdW1lbnQsIEFkZE1ldGFDaGFyc2V0SWZOZWVkZWQ6Ok5vLCBt c29MaXN0UXVpcmtzLCBtYXJrdXBBbmRBcmNoaXZlLm1hcmt1cCk7CiAgICAgfQogCiAgICAgSGFz aE1hcDxBdG9tU3RyaW5nLCBBdG9tU3RyaW5nPiBibG9iVVJMTWFwOwpAQCAtNDkyLDcgKzQ5Miw3 IEBAIHN0YXRpYyBTdHJpbmcgc2FuaXRpemVNYXJrdXBXaXRoQXJjaGl2ZShGcmFtZSYgZnJhbWUs IERvY3VtZW50JiBkZXN0aW5hdGlvbkRvY3VtCiAKICAgICByZXBsYWNlU3VicmVzb3VyY2VVUkxz KGZyYWdtZW50LmdldCgpLCBXVEZNb3ZlKGJsb2JVUkxNYXApKTsKIAotICAgIHJldHVybiBzYW5p dGl6ZWRNYXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQoV1RGTW92ZShmcmFnbWVudCksICpzdGFn aW5nRG9jdW1lbnQsIG1zb0xpc3RRdWlya3MsIG1hcmt1cEFuZEFyY2hpdmUubWFya3VwKTsKKyAg ICByZXR1cm4gc2FuaXRpemVkTWFya3VwRm9yRnJhZ21lbnRJbkRvY3VtZW50KFdURk1vdmUoZnJh Z21lbnQpLCAqc3RhZ2luZ0RvY3VtZW50LCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpObywgbXNv TGlzdFF1aXJrcywgbWFya3VwQW5kQXJjaGl2ZS5tYXJrdXApOwogfQogCiBib29sIFdlYkNvbnRl bnRSZWFkZXI6OnJlYWRXZWJBcmNoaXZlKFNoYXJlZEJ1ZmZlciYgYnVmZmVyKQpAQCAtNTgwLDcg KzU4MCw3IEBAIGJvb2wgV2ViQ29udGVudFJlYWRlcjo6cmVhZEhUTUwoY29uc3QgU3RyaW5nJiBz dHJpbmcpCiAKICAgICBTdHJpbmcgbWFya3VwOwogICAgIGlmIChSdW50aW1lRW5hYmxlZEZlYXR1 cmVzOjpzaGFyZWRGZWF0dXJlcygpLmN1c3RvbVBhc3RlYm9hcmREYXRhRW5hYmxlZCgpICYmIHNo b3VsZFNhbml0aXplKCkpIHsKLSAgICAgICAgbWFya3VwID0gc2FuaXRpemVNYXJrdXAoc3RyaW5n T21pdHRpbmdNaWNyb3NvZnRQcmVmaXgsIG1zb0xpc3RRdWlya3NGb3JNYXJrdXAoKSwgV1RGOjpG dW5jdGlvbjx2b2lkIChEb2N1bWVudEZyYWdtZW50Jik+IHsgW10gKERvY3VtZW50RnJhZ21lbnQm IGZyYWdtZW50KSB7CisgICAgICAgIG1hcmt1cCA9IHNhbml0aXplTWFya3VwKHN0cmluZ09taXR0 aW5nTWljcm9zb2Z0UHJlZml4LCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpObywgbXNvTGlzdFF1 aXJrc0Zvck1hcmt1cCgpLCBXVEY6OkZ1bmN0aW9uPHZvaWQgKERvY3VtZW50RnJhZ21lbnQmKT4g eyBbXSAoRG9jdW1lbnRGcmFnbWVudCYgZnJhZ21lbnQpIHsKICAgICAgICAgICAgIHJlbW92ZVN1 YnJlc291cmNlVVJMQXR0cmlidXRlcyhmcmFnbWVudCwgW10gKGNvbnN0IFVSTCYgdXJsKSB7CiAg ICAgICAgICAgICAgICAgcmV0dXJuIHNob3VsZFJlcGxhY2VTdWJyZXNvdXJjZVVSTCh1cmwpOwog ICAgICAgICAgICAgfSk7CkBAIC01OTksNyArNTk5LDcgQEAgYm9vbCBXZWJDb250ZW50TWFya3Vw UmVhZGVyOjpyZWFkSFRNTChjb25zdCBTdHJpbmcmIHN0cmluZykKIAogICAgIFN0cmluZyByYXdI VE1MID0gc3RyaXBNaWNyb3NvZnRQcmVmaXgoc3RyaW5nKTsKICAgICBpZiAoc2hvdWxkU2FuaXRp emUoKSkgewotICAgICAgICBtYXJrdXAgPSBzYW5pdGl6ZU1hcmt1cChyYXdIVE1MLCBtc29MaXN0 UXVpcmtzRm9yTWFya3VwKCksIFdURjo6RnVuY3Rpb248dm9pZCAoRG9jdW1lbnRGcmFnbWVudCYp PiB7IFtdIChEb2N1bWVudEZyYWdtZW50JiBmcmFnbWVudCkgeworICAgICAgICBtYXJrdXAgPSBz YW5pdGl6ZU1hcmt1cChyYXdIVE1MLCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpObywgbXNvTGlz dFF1aXJrc0Zvck1hcmt1cCgpLCBXVEY6OkZ1bmN0aW9uPHZvaWQgKERvY3VtZW50RnJhZ21lbnQm KT4geyBbXSAoRG9jdW1lbnRGcmFnbWVudCYgZnJhZ21lbnQpIHsKICAgICAgICAgICAgIHJlbW92 ZVN1YnJlc291cmNlVVJMQXR0cmlidXRlcyhmcmFnbWVudCwgW10gKGNvbnN0IFVSTCYgdXJsKSB7 CiAgICAgICAgICAgICAgICAgcmV0dXJuIHNob3VsZFJlcGxhY2VTdWJyZXNvdXJjZVVSTCh1cmwp OwogICAgICAgICAgICAgfSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL21h cmt1cC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL21hcmt1cC5jcHAKaW5kZXggY2JmNjI4 OGU5YmFlYzVlMjkzNTE1ZjUwNmFjZDU5MmEzYjI4ZWNkYS4uN2FmYjg1OGQ4MzkyM2UyZWMyMDgx NmY1M2EzNTZkNDllZGE5ZjcyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9t YXJrdXAuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNwcApAQCAtMjAx LDcgKzIwMSw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxQYWdlPiBjcmVhdGVQYWdlRm9yU2FuaXRpemlu Z1dlYkNvbnRlbnQoKQogICAgIHJldHVybiBwYWdlOwogfQogCi1TdHJpbmcgc2FuaXRpemVNYXJr dXAoY29uc3QgU3RyaW5nJiByYXdIVE1MLCBNU09MaXN0UXVpcmtzIG1zb0xpc3RRdWlya3MsIE9w dGlvbmFsPFdURjo6RnVuY3Rpb248dm9pZChEb2N1bWVudEZyYWdtZW50Jik+PiBmcmFnbWVudFNh bml0aXplcikKK1N0cmluZyBzYW5pdGl6ZU1hcmt1cChjb25zdCBTdHJpbmcmIHJhd0hUTUwsIEFk ZE1ldGFDaGFyc2V0SWZOZWVkZWQgYWRkTWV0YUNoYXJzZXRJZk5lZWRlZCwgTVNPTGlzdFF1aXJr cyBtc29MaXN0UXVpcmtzLCBPcHRpb25hbDxXVEY6OkZ1bmN0aW9uPHZvaWQoRG9jdW1lbnRGcmFn bWVudCYpPj4gZnJhZ21lbnRTYW5pdGl6ZXIpCiB7CiAgICAgYXV0byBwYWdlID0gY3JlYXRlUGFn ZUZvclNhbml0aXppbmdXZWJDb250ZW50KCk7CiAgICAgRG9jdW1lbnQqIHN0YWdpbmdEb2N1bWVu dCA9IHBhZ2UtPm1haW5GcmFtZSgpLmRvY3VtZW50KCk7CkBAIC0yMTIsNyArMjEyLDcgQEAgU3Ry aW5nIHNhbml0aXplTWFya3VwKGNvbnN0IFN0cmluZyYgcmF3SFRNTCwgTVNPTGlzdFF1aXJrcyBt c29MaXN0UXVpcmtzLCBPcHRpb24KICAgICBpZiAoZnJhZ21lbnRTYW5pdGl6ZXIpCiAgICAgICAg ICgqZnJhZ21lbnRTYW5pdGl6ZXIpKGZyYWdtZW50KTsKIAotICAgIHJldHVybiBzYW5pdGl6ZWRN YXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQoV1RGTW92ZShmcmFnbWVudCksICpzdGFnaW5nRG9j dW1lbnQsIG1zb0xpc3RRdWlya3MsIHJhd0hUTUwpOworICAgIHJldHVybiBzYW5pdGl6ZWRNYXJr dXBGb3JGcmFnbWVudEluRG9jdW1lbnQoV1RGTW92ZShmcmFnbWVudCksICpzdGFnaW5nRG9jdW1l bnQsIGFkZE1ldGFDaGFyc2V0SWZOZWVkZWQsIG1zb0xpc3RRdWlya3MsIHJhd0hUTUwpOwogfQog CiBlbnVtIGNsYXNzIE1TT0xpc3RNb2RlIHsgUHJlc2VydmUsIERvTm90UHJlc2VydmUgfTsKQEAg LTk0NSw3ICs5NDUsNyBAQCBzdGF0aWMgYm9vbCBzaG91bGRQcmVzZXJ2ZU1TT0xpc3RzKGNvbnN0 IFN0cmluZyYgbWFya3VwKQogICAgICAgICAmJiBodG1sVGFnLmNvbnRhaW5zKCJ4bWxuczp3PVwi dXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6d29yZFwiIik7CiB9CiAKLVN0cmluZyBz YW5pdGl6ZWRNYXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQoUmVmPERvY3VtZW50RnJhZ21lbnQ+ JiYgZnJhZ21lbnQsIERvY3VtZW50JiBkb2N1bWVudCwgTVNPTGlzdFF1aXJrcyBtc29MaXN0UXVp cmtzLCBjb25zdCBTdHJpbmcmIG9yaWdpbmFsTWFya3VwKQorU3RyaW5nIHNhbml0aXplZE1hcmt1 cEZvckZyYWdtZW50SW5Eb2N1bWVudChSZWY8RG9jdW1lbnRGcmFnbWVudD4mJiBmcmFnbWVudCwg RG9jdW1lbnQmIGRvY3VtZW50LCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkIGFkZE1ldGFDaGFyc2V0 SWZOZWVkZWQsIE1TT0xpc3RRdWlya3MgbXNvTGlzdFF1aXJrcywgY29uc3QgU3RyaW5nJiBvcmln aW5hbE1hcmt1cCkKIHsKICAgICBNU09MaXN0TW9kZSBtc29MaXN0TW9kZSA9IG1zb0xpc3RRdWly a3MgPT0gTVNPTGlzdFF1aXJrczo6Q2hlY2tJZk5lZWRlZCAmJiBzaG91bGRQcmVzZXJ2ZU1TT0xp c3RzKG9yaWdpbmFsTWFya3VwKQogICAgICAgICA/IE1TT0xpc3RNb2RlOjpQcmVzZXJ2ZSA6IE1T T0xpc3RNb2RlOjpEb05vdFByZXNlcnZlOwpAQCAtOTU4LDE4ICs5NTgsMzEgQEAgU3RyaW5nIHNh bml0aXplZE1hcmt1cEZvckZyYWdtZW50SW5Eb2N1bWVudChSZWY8RG9jdW1lbnRGcmFnbWVudD4m JiBmcmFnbWVudCwgRG8KICAgICBhdXRvIHJlc3VsdCA9IHNlcmlhbGl6ZVByZXNlcnZpbmdWaXN1 YWxBcHBlYXJhbmNlSW50ZXJuYWwoZmlyc3RQb3NpdGlvbkluTm9kZShib2R5RWxlbWVudC5nZXQo KSksIGxhc3RQb3NpdGlvbkluTm9kZShib2R5RWxlbWVudC5nZXQoKSksIG51bGxwdHIsCiAgICAg ICAgIFJlc29sdmVVUkxzOjpZZXNFeGNsdWRpbmdMb2NhbEZpbGVVUkxzRm9yUHJpdmFjeSwgU2Vy aWFsaXplQ29tcG9zZWRUcmVlOjpObywgQW5ub3RhdGVGb3JJbnRlcmNoYW5nZTo6WWVzLCBDb252 ZXJ0QmxvY2tzVG9JbmxpbmVzOjpObywgIFN0YW5kYXJkRm9udEZhbWlseVNlcmlhbGl6YXRpb25N b2RlOjpTdHJpcCwgbXNvTGlzdE1vZGUpOwogCisgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOwog ICAgIGlmIChtc29MaXN0TW9kZSA9PSBNU09MaXN0TW9kZTo6UHJlc2VydmUpIHsKLSAgICAgICAg U3RyaW5nQnVpbGRlciBidWlsZGVyOwogICAgICAgICBidWlsZGVyLmFwcGVuZExpdGVyYWwoIjxo dG1sIHhtbG5zOm89XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2VcIlxu IgogICAgICAgICAgICAgInhtbG5zOnc9XCJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmlj ZTp3b3JkXCJcbiIKICAgICAgICAgICAgICJ4bWxuczptPVwiaHR0cDovL3NjaGVtYXMubWljcm9z b2Z0LmNvbS9vZmZpY2UvMjAwNC8xMi9vbW1sXCJcbiIKICAgICAgICAgICAgICJ4bWxucz1cImh0 dHA6Ly93d3cudzMub3JnL1RSL1JFQy1odG1sNDBcIj4iKTsKLSAgICAgICAgYnVpbGRlci5hcHBl bmQocmVzdWx0KTsKLSAgICAgICAgYnVpbGRlci5hcHBlbmRMaXRlcmFsKCI8L2h0bWw+Iik7Ci0g ICAgICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCk7CiAgICAgfQogCi0gICAgcmV0dXJuIHJl c3VsdDsKKyNpZiBQTEFURk9STShDT0NPQSkKKyAgICBpZiAoYWRkTWV0YUNoYXJzZXRJZk5lZWRl ZCA9PSBBZGRNZXRhQ2hhcnNldElmTmVlZGVkOjpZZXMgJiYgIXJlc3VsdC5pc0FsbEFTQ0lJKCkp IHsKKyAgICAgICAgLy8gT24gQ29jb2EgcGxhdGZvcm1zLCB0aGlzIG1hcmt1cCBpcyBldmVudHVh bGx5IHBlcnNpc3RlZCB0byB0aGUgcGFzdGVib2FyZCBhbmQgcmVhZCBiYWNrIGFzIFVURi04IGRh dGEsCisgICAgICAgIC8vIHNvIHRoaXMgbWV0YSB0YWcgaXMgbmVlZGVkIGZvciBjbGllbnRzIHRo YXQgcmVhZCB0aGlzIGRhdGEgaW4gdGhlIGZ1dHVyZSBmcm9tIHRoZSBwYXN0ZWJvYXJkIGFuZCBs b2FkIGl0LgorICAgICAgICAvLyBUaGlzIGxvZ2ljIGlzIHVzZWQgYnkgYm90aCBEYXRhVHJhbnNm ZXIgYW5kIENsaXBib2FyZCBBUElzIHRvIHNhbml0aXplICJ0ZXh0L2h0bWwiIGZyb20gdGhlIHBh Z2UuCisgICAgICAgIGJ1aWxkZXIuYXBwZW5kTGl0ZXJhbCgiPG1ldGEgY2hhcnNldD1cIlVURi04 XCI+Iik7CisgICAgfQorI2Vsc2UKKyAgICBVTlVTRURfUEFSQU0oYWRkTWV0YUNoYXJzZXRJZk5l ZWRlZCk7CisjZW5kaWYKKworICAgIGJ1aWxkZXIuYXBwZW5kKHJlc3VsdCk7CisKKyAgICBpZiAo bXNvTGlzdE1vZGUgPT0gTVNPTGlzdE1vZGU6OlByZXNlcnZlKQorICAgICAgICBidWlsZGVyLmFw cGVuZExpdGVyYWwoIjwvaHRtbD4iKTsKKworICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCk7 CiB9CiAKIHN0YXRpYyB2b2lkIHJlc3RvcmVBdHRhY2htZW50RWxlbWVudHNJbkZyYWdtZW50KERv Y3VtZW50RnJhZ21lbnQmIGZyYWdtZW50KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9tYXJrdXAuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmgKaW5kZXggMTAw ZmJmMzViNGNmMjE0MWQ4NDQ0Yzc0OTM5ZWFkZGU5NmU1YjU4MS4uZDQyN2U5MGQ4MGEwMDAyZTU1 ZTJkMjhiNWFkNjFlOTVmZTFjNTBiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9tYXJrdXAuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL21hcmt1cC5oCkBAIC01Miwx MCArNTIsMTEgQEAgY2xhc3MgVmlzaWJsZVNlbGVjdGlvbjsKIHZvaWQgcmVwbGFjZVN1YnJlc291 cmNlVVJMcyhSZWY8RG9jdW1lbnRGcmFnbWVudD4mJiwgSGFzaE1hcDxBdG9tU3RyaW5nLCBBdG9t U3RyaW5nPiYmKTsKIHZvaWQgcmVtb3ZlU3VicmVzb3VyY2VVUkxBdHRyaWJ1dGVzKFJlZjxEb2N1 bWVudEZyYWdtZW50PiYmLCBXVEY6OkZ1bmN0aW9uPGJvb2woY29uc3QgVVJMJik+IHNob3VsZFJl bW92ZVVSTCk7CiAKLWVudW0gY2xhc3MgTVNPTGlzdFF1aXJrcyB7IENoZWNrSWZOZWVkZWQsIERp c2FibGVkIH07CiBzdGQ6OnVuaXF1ZV9wdHI8UGFnZT4gY3JlYXRlUGFnZUZvclNhbml0aXppbmdX ZWJDb250ZW50KCk7Ci1TdHJpbmcgc2FuaXRpemVNYXJrdXAoY29uc3QgU3RyaW5nJiwgTVNPTGlz dFF1aXJrcyA9IE1TT0xpc3RRdWlya3M6OkRpc2FibGVkLCBPcHRpb25hbDxXVEY6OkZ1bmN0aW9u PHZvaWQoRG9jdW1lbnRGcmFnbWVudCYpPj4gZnJhZ21lbnRTYW5pdGl6ZXIgPSBXVEY6Om51bGxv cHQpOwotU3RyaW5nIHNhbml0aXplZE1hcmt1cEZvckZyYWdtZW50SW5Eb2N1bWVudChSZWY8RG9j dW1lbnRGcmFnbWVudD4mJiwgRG9jdW1lbnQmLCBNU09MaXN0UXVpcmtzLCBjb25zdCBTdHJpbmcm IG9yaWdpbmFsTWFya3VwKTsKK2VudW0gY2xhc3MgTVNPTGlzdFF1aXJrcyA6IGJvb2wgeyBDaGVj a0lmTmVlZGVkLCBEaXNhYmxlZCB9OworZW51bSBjbGFzcyBBZGRNZXRhQ2hhcnNldElmTmVlZGVk IDogYm9vbCB7IE5vLCBZZXMgfTsKK1N0cmluZyBzYW5pdGl6ZU1hcmt1cChjb25zdCBTdHJpbmcm LCBBZGRNZXRhQ2hhcnNldElmTmVlZGVkID0gQWRkTWV0YUNoYXJzZXRJZk5lZWRlZDo6Tm8sIE1T T0xpc3RRdWlya3MgPSBNU09MaXN0UXVpcmtzOjpEaXNhYmxlZCwgT3B0aW9uYWw8V1RGOjpGdW5j dGlvbjx2b2lkKERvY3VtZW50RnJhZ21lbnQmKT4+IGZyYWdtZW50U2FuaXRpemVyID0gV1RGOjpu dWxsb3B0KTsKK1N0cmluZyBzYW5pdGl6ZWRNYXJrdXBGb3JGcmFnbWVudEluRG9jdW1lbnQoUmVm PERvY3VtZW50RnJhZ21lbnQ+JiYsIERvY3VtZW50JiwgQWRkTWV0YUNoYXJzZXRJZk5lZWRlZCwg TVNPTGlzdFF1aXJrcywgY29uc3QgU3RyaW5nJiBvcmlnaW5hbE1hcmt1cCk7CiAKIFdFQkNPUkVf RVhQT1JUIFJlZjxEb2N1bWVudEZyYWdtZW50PiBjcmVhdGVGcmFnbWVudEZyb21UZXh0KFJhbmdl JiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIHRleHQpOwogV0VCQ09SRV9FWFBPUlQgUmVmPERvY3Vt ZW50RnJhZ21lbnQ+IGNyZWF0ZUZyYWdtZW50RnJvbU1hcmt1cChEb2N1bWVudCYsIGNvbnN0IFN0 cmluZyYgbWFya3VwLCBjb25zdCBTdHJpbmcmIGJhc2VVUkwsIFBhcnNlckNvbnRlbnRQb2xpY3kg PSBBbGxvd1NjcmlwdGluZ0NvbnRlbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0 Zm9ybS9jb2NvYS9Db2NvYUNvbG9yLmggYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL0Nv Y29hQ29sb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44OTcxNmI5YWY5MDM3MzkyNjZiODVhNjVhZWVlZGVkZDg1 N2VlOTBmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9D b2NvYUNvbG9yLmgKQEAgLTAsMCArMSwzNCBAQAorLyoKKyogQ29weXJpZ2h0IChDKSAyMDIwIEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyoKKyogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworKiBhcmUgbWV0OgorKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyoKKyogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworKiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyogQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUgorKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRgorKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkKKyogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisqLworCisjcHJhZ21hIG9uY2UKKworI2lmIFVTRShBUFBLSVQpCitAY2xh c3MgTlNDb2xvcjsKK3VzaW5nIENvY29hQ29sb3IgPSBOU0NvbG9yOworI2Vsc2UKK0BjbGFzcyBV SUNvbG9yOwordXNpbmcgQ29jb2FDb2xvciA9IFVJQ29sb3I7CisjZW5kaWYKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2Uv V2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDUwZjA0MmFkMDM2 YWZmM2MzYjBkOTRkZmI1MTc5NjIzMTEyNzJmNWUuLjE0NTExNjY2NDJlNDU3MjIxY2QzZDFmYTgz MzZkNmUxOWZmNGZjYjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagpAQCAtMTg0Nyw2ICsxODQ3LDcgQEAKIAkJRjRENUY1MUYyMDYwODdBMTAw MzhCQkE4IC8qIFdLUXVpY2tib2FyZExpc3RWaWV3Q29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjRENUY1MUIyMDYwODdBMTAwMzhCQkE4 IC8qIFdLUXVpY2tib2FyZExpc3RWaWV3Q29udHJvbGxlci5oICovOyB9OwogCQlGNERCNTRFNjIz MTlFNzMzMDA5RTMxNTUgLyogV0tIaWdobGlnaHRMb25nUHJlc3NHZXN0dXJlUmVjb2duaXplci5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjREQjU0RTQy MzE5RTczMzAwOUUzMTU1IC8qIFdLSGlnaGxpZ2h0TG9uZ1ByZXNzR2VzdHVyZVJlY29nbml6ZXIu aCAqLzsgfTsKIAkJRjRFQzk0RTMyMzU2Q0M1NzAwMEJCNjE0IC8qIEFwcGxpY2F0aW9uU2Vydmlj ZXNTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDI5 RDA0RTI4MjFGN0M3M0QwMDc2NzQxRCAvKiBBcHBsaWNhdGlvblNlcnZpY2VzU1BJLmggKi87IH07 CisJCUY0RkUwQTNCMjQ2MzJCNjAwMDI2MzFFMSAvKiBDb2NvYUNvbG9yLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNEZFMEEzQTI0NjMyQjEwMDAyNjMx RTEgLyogQ29jb2FDb2xvci5oICovOyB9OwogCQlGNjExM0UyNTEyNkNFMTgyMDA1N0QwQTcgLyog QVBJVXNlckNvbnRlbnRVUkxQYXR0ZXJuLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBGNjExM0UyNDEyNkNFMTgyMDA1N0QwQTcgLyogQVBJVXNlckNvbnRl bnRVUkxQYXR0ZXJuLmggKi87IH07CiAJCUY2MTEzRTI5MTI2Q0UxOUIwMDU3RDBBNyAvKiBXS1Vz ZXJDb250ZW50VVJMUGF0dGVybi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gRjYxMTNFMjcxMjZDRTE5QjAwNTdEMEE3IC8qIFdLVXNlckNvbnRlbnRVUkxQ YXR0ZXJuLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJRjYzNDQ0NTYxMkE4ODVDODAwMDYxMkQ4IC8qIEFQSVNlY3VyaXR5T3JpZ2luLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNjM0NDQ1NTEyQTg4NUM4 MDAwNjEyRDggLyogQVBJU2VjdXJpdHlPcmlnaW4uaCAqLzsgfTsKQEAgLTUzNzAsNiArNTM3MSw3 IEBACiAJCUY0REI1NEU1MjMxOUU3MzMwMDlFMzE1NSAvKiBXS0hpZ2hsaWdodExvbmdQcmVzc0dl c3R1cmVSZWNvZ25pemVyLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1l ID0gV0tIaWdobGlnaHRMb25nUHJlc3NHZXN0dXJlUmVjb2duaXplci5tbTsgcGF0aCA9IGlvcy9X S0hpZ2hsaWdodExvbmdQcmVzc0dlc3R1cmVSZWNvZ25pemVyLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlGNEY1OUFEMzIwNjVBNUM5MDA2Q0FBNDYgLyogV0tTZWxlY3RNZW51TGlz dFZpZXdDb250cm9sbGVyLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1l ID0gV0tTZWxlY3RNZW51TGlzdFZpZXdDb250cm9sbGVyLm1tOyBwYXRoID0gaW9zL2Zvcm1zL1dL U2VsZWN0TWVudUxpc3RWaWV3Q29udHJvbGxlci5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRjRGNTlBRDQyMDY1QTVDQTAwNkNBQTQ2IC8qIFdLU2VsZWN0TWVudUxpc3RWaWV3Q29u dHJvbGxlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBXS1NlbGVjdE1lbnVM aXN0Vmlld0NvbnRyb2xsZXIuaDsgcGF0aCA9IGlvcy9mb3Jtcy9XS1NlbGVjdE1lbnVMaXN0Vmll d0NvbnRyb2xsZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRjRGRTBBM0EyNDYz MkIxMDAwMjYzMUUxIC8qIENvY29hQ29sb3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ29jb2FDb2xvci5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNjExM0UyNDEyNkNFMTgyMDA1N0QwQTcg LyogQVBJVXNlckNvbnRlbnRVUkxQYXR0ZXJuLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEFQSVVzZXJDb250ZW50VVJMUGF0dGVybi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlGNjExM0UyNjEyNkNFMTlCMDA1N0QwQTcgLyogV0tVc2VyQ29udGVudFVSTFBhdHRl cm4uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV0tVc2VyQ29udGVu dFVSTFBhdHRlcm4uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNjExM0UyNzEy NkNFMTlCMDA1N0QwQTcgLyogV0tVc2VyQ29udGVudFVSTFBhdHRlcm4uaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gV0tVc2VyQ29udGVudFVSTFBhdHRlcm4uaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTc2ODAsNiArNzY4Miw3IEBACiAJCTQ0NTBBRUJFMURDM0ZB QUMwMDk5NDNGMiAvKiBjb2NvYSAqLyA9IHsKIAkJCWlzYSA9IFBCWEdyb3VwOwogCQkJY2hpbGRy ZW4gPSAoCisJCQkJRjRGRTBBM0EyNDYzMkIxMDAwMjYzMUUxIC8qIENvY29hQ29sb3IuaCAqLywK IAkJCQk0NDgyNzM0NjI0NTI4RjYwMDBBOTU0OTMgLyogQ29jb2FJbWFnZS5oICovLAogCQkJCUJD RTA5Mzc2MTRGQjEyOEIwMDExMzhEOSAvKiBMYXllckhvc3RpbmdDb250ZXh0LmggKi8sCiAJCQkJ QkNFMDkzNzUxNEZCMTI4QjAwMTEzOEQ5IC8qIExheWVySG9zdGluZ0NvbnRleHQubW0gKi8sCkBA IC0xMDcyNCw2ICsxMDcyNyw3IEBACiAJCQkJNDE4OTdFREExRjQxNUQ4QTAwMTZGQTQyIC8qIENh Y2hlU3RvcmFnZUVuZ2luZUNvbm5lY3Rpb24uaCBpbiBIZWFkZXJzICovLAogCQkJCTFBQTJFNTFE MTJFNEMwNUUwMEJDNDk2NiAvKiBDR1V0aWxpdGllcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNTdC NEI0NjAyMEI1MDRBQzAwRDRBRDc5IC8qIENsaWVudENlcnRpZmljYXRlQXV0aGVudGljYXRpb25Y UENDb25zdGFudHMuaCBpbiBIZWFkZXJzICovLAorCQkJCUY0RkUwQTNCMjQ2MzJCNjAwMDI2MzFF MSAvKiBDb2NvYUNvbG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQk0NDgyNzM0NzI0NTI4RjYwMDBB OTU0OTMgLyogQ29jb2FJbWFnZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQ0UxMUFENTIxQ0JDNDgy RjAwNjgxRUU1IC8qIENvZGVTaWduaW5nLmggaW4gSGVhZGVycyAqLywKIAkJCQkzN0JFQzRFMTE5 NDkxNDg2MDA4QjQyODYgLyogQ29tcGxldGlvbkhhbmRsZXJDYWxsQ2hlY2tlci5oIGluIEhlYWRl cnMgKi8sCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5k ZXggZDg2Mzg4MzJmMmZkYTlmYzY2ZDFmODg4OGEwOWU3ZDhjNDcyOWE4MS4uOWRlNmMyZmM0YjNk YzNmODFjNGQ3NDgwYjc3ZDlkODc5ZTJkZWU1YSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9n CisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDIwLTA1LTA1ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIEN1dCBhbmQgcGFz dGUgZnJvbSBHb29nbGUgRG9jIHRvIE5vdGVzIGluIHNldmVyYWwgKG5vbi1MYXRpbikgbGFuZ3Vh Z2VzIGRvZXNuJ3Qgd29yaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjExNDk4CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81NjY3NTM0NT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSB0ZXN0IHRv IHZlcmlmeSB0aGF0IHdoZW4gd3JpdGluZyBtYXJrdXAgdG8gdGhlIGNsaXBib2FyZCB2aWEgRE9N IEFQSSwgaWYgbm9uLUFTQ0lJIGNoYXJhY3RlcnMgYXBwZWFyIGluCisgICAgICAgIHRoZSB3cml0 dGVuIG1hcmt1cCwgdGhleSBjYW4gc3RpbGwgYmUgY29udmVydGVkIHRvIGBOU0F0dHJpYnV0ZWRT dHJpbmdgcyBjb250YWluaW5nIHRoZSBleHBlY3RlZCBub24tTGF0aW4gdGV4dC4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlvbnMvQmFzZS54Y2NvbmZpZzoKKworICAgICAg ICBBZGp1c3QgaGVhZGVyIHNlYXJjaCBwYXRocyBzbyB0aGF0IHdlIGNhbiBpbXBvcnQgQ29jb2FD b2xvci5oIGluIFdlYktpdC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Q29jb2EvQ29weUhUTUwubW06CisgICAgICAgIChyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCk6 CisgICAgICAgIChyZWFkSFRNTFN0cmluZ0Zyb21QYXN0ZWJvYXJkKToKKyAgICAgICAgKHJlYWRI VE1MRnJvbVBhc3RlYm9hcmQpOiBEZWxldGVkLgorCiAyMDIwLTA1LTA0ICBCZW4gTmhhbSAgPG5o YW1AYXBwbGUuY29tPgogCiAgICAgICAgIEluZGV4ZWREQiBXQUwgZmlsZSBrZWVwcyBncm93aW5n IHdoaWxlIGFwcCBpcyBpbiB1c2UKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29u ZmlndXJhdGlvbnMvQmFzZS54Y2NvbmZpZyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJh dGlvbnMvQmFzZS54Y2NvbmZpZwppbmRleCBhNjc0ZjZkNWRlZGVlY2JiZDVhNzNhZDIzNGNjZTBk ZTkwMjdlNmZkLi5mNWUyZmFlOWRhMDAwYjUxYjBkMzkxZDY4MzY3NzIzZjEzMWVjODBkIDEwMDY0 NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL0Jhc2UueGNjb25maWcK KysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9CYXNlLnhjY29uZmlnCkBA IC0zMyw3ICszMyw3IEBAIENMQU5HX0NYWF9MQU5HVUFHRV9TVEFOREFSRCA9IGdudSsrMXo7CiBD TEFOR19DWFhfTElCUkFSWSA9IGxpYmMrKzsKIENMQU5HX0VOQUJMRV9PQkpDX1dFQUsgPSBZRVM7 CiBDTEFOR19XQVJOX0NYWDBYX0VYVEVOU0lPTlMgPSBOTzsKLUhFQURFUl9TRUFSQ0hfUEFUSFMg PSAke0JVSUxUX1BST0RVQ1RTX0RJUn0vdXNyL2xvY2FsL2luY2x1ZGUgJChXRUJDT1JFX1BSSVZB VEVfSEVBREVSU19ESVIpL0ZvcndhcmRpbmdIZWFkZXJzICQoQlVJTFRfUFJPRFVDVFNfRElSKS9X ZWJDb3JlVGVzdFN1cHBvcnQgJHtTUkNST09UfTsKK0hFQURFUl9TRUFSQ0hfUEFUSFMgPSAke0JV SUxUX1BST0RVQ1RTX0RJUn0vdXNyL2xvY2FsL2luY2x1ZGUgJChXRUJDT1JFX1BSSVZBVEVfSEVB REVSU19ESVIpL0ZvcndhcmRpbmdIZWFkZXJzICQoQlVJTFRfUFJPRFVDVFNfRElSKS9XZWJDb3Jl VGVzdFN1cHBvcnQgJHtTUkNST09UfSAkKFNSQ1JPT1QpLy4uLy4uL1NvdXJjZS9XZWJLaXQvUGxh dGZvcm0vY29jb2E7CiAKIEdDQ19OT19DT01NT05fQkxPQ0tTID0gWUVTOwogR0NDX1BSRVBST0NF U1NPUl9ERUZJTklUSU9OUyA9ICQoREVCVUdfREVGSU5FUykgJChGRUFUVVJFX0RFRklORVMpIFVf RElTQUJMRV9SRU5BTUlORz0xIFVfU0hPV19DUExVU1BMVVNfQVBJPTAgJChHQ0NfUFJFUFJPQ0VT U09SX0RFRklOSVRJT05TXyQoUExBVEZPUk1fTkFNRSkpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db3B5SFRNTC5tbSBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29weUhUTUwubW0KaW5kZXggY2ZiOWQ4Y2VkYzk4NTZi N2NkODdiYTNjNzU4NDBmNmE2NDY5MWMwZC4uNzZlZGEyMzJlZDNhM2YwMjY1YzZkNTUzMWUxMTQ5 NTUxOWUyMjgxNyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRD b2NvYS9Db3B5SFRNTC5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENv Y29hL0NvcHlIVE1MLm1tCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpZiBQTEFURk9STShDT0NPQSkK IAorI2ltcG9ydCAiQ29jb2FDb2xvci5oIgogI2ltcG9ydCAiUGxhdGZvcm1VdGlsaXRpZXMuaCIK ICNpbXBvcnQgIlRlc3RXS1dlYlZpZXcuaCIKICNpbXBvcnQgPFdlYktpdC9XS1ByZWZlcmVuY2Vz UHJpdmF0ZS5oPgpAQCAtNDQsMTIgKzQ1LDI1IEBAIC0gKHZvaWQpcGFzdGU6KGlkKXNlbmRlcjsK IEBlbmQKIAogI2lmIFBMQVRGT1JNKE1BQykKLU5TU3RyaW5nICpyZWFkSFRNTEZyb21QYXN0ZWJv YXJkKCkKKworTlNEYXRhICpyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCgpCit7CisgICAgcmV0 dXJuIFtbTlNQYXN0ZWJvYXJkIGdlbmVyYWxQYXN0ZWJvYXJkXSBkYXRhRm9yVHlwZTpOU0hUTUxQ Ym9hcmRUeXBlXTsKK30KKworTlNTdHJpbmcgKnJlYWRIVE1MU3RyaW5nRnJvbVBhc3RlYm9hcmQo KQogewogICAgIHJldHVybiBbW05TUGFzdGVib2FyZCBnZW5lcmFsUGFzdGVib2FyZF0gc3RyaW5n Rm9yVHlwZTpOU0hUTUxQYm9hcmRUeXBlXTsKIH0KKwogI2Vsc2UKLU5TU3RyaW5nICpyZWFkSFRN TEZyb21QYXN0ZWJvYXJkKCkKKworTlNEYXRhICpyZWFkSFRNTERhdGFGcm9tUGFzdGVib2FyZCgp Cit7CisgICAgcmV0dXJuIFtbVUlQYXN0ZWJvYXJkIGdlbmVyYWxQYXN0ZWJvYXJkXSBkYXRhRm9y UGFzdGVib2FyZFR5cGU6KF9fYnJpZGdlIE5TU3RyaW5nICopa1VUVHlwZUhUTUxdOworfQorCitO U1N0cmluZyAqcmVhZEhUTUxTdHJpbmdGcm9tUGFzdGVib2FyZCgpCiB7CiAgICAgaWQgdmFsdWUg PSBbW1VJUGFzdGVib2FyZCBnZW5lcmFsUGFzdGVib2FyZF0gdmFsdWVGb3JQYXN0ZWJvYXJkVHlw ZTooX19icmlkZ2UgTlNTdHJpbmcgKilrVVRUeXBlSFRNTF07CiAgICAgaWYgKFt2YWx1ZSBpc0tp bmRPZkNsYXNzOltOU0RhdGEgY2xhc3NdXSkKQEAgLTU3LDYgKzcxLDcgQEAgTlNTdHJpbmcgKnJl YWRIVE1MRnJvbVBhc3RlYm9hcmQoKQogICAgIEFTU0VSVChbdmFsdWUgaXNLaW5kT2ZDbGFzczpb TlNTdHJpbmcgY2xhc3NdXSk7CiAgICAgcmV0dXJuIChOU1N0cmluZyAqKXZhbHVlOwogfQorCiAj ZW5kaWYKIAogc3RhdGljIFJldGFpblB0cjxUZXN0V0tXZWJWaWV3PiBjcmVhdGVXZWJWaWV3V2l0 aEN1c3RvbVBhc3RlYm9hcmREYXRhRW5hYmxlZCgpCkBAIC04MCwxMyArOTUsNjMgQEAgVEVTVChD b3B5SFRNTCwgU2FuaXRpemVzKQogICAgIEVYUEVDVF9UUlVFKFt3ZWJWaWV3IHN0cmluZ0J5RXZh bHVhdGluZ0phdmFTY3JpcHQ6QCJkaWRQYXN0ZSJdLmJvb2xWYWx1ZSk7CiAgICAgRVhQRUNUX1dL X1NUUkVRKCI8bWV0YSBjb250ZW50PVwic2VjcmV0XCI+PGIgb25tb3VzZW92ZXI9XCJkYW5nZXJv dXNDb2RlKClcIj5oZWxsbzwvYj48IS0tIHNlY3JldC0tPiwgd29ybGQ8c2NyaXB0PmRhbmdlcm91 c0NvZGUoKTwvc2NyaXB0PiIsCiAgICAgICAgIFt3ZWJWaWV3IHN0cmluZ0J5RXZhbHVhdGluZ0ph dmFTY3JpcHQ6QCJwYXN0ZWRIVE1MIl0pOwotICAgIFN0cmluZyBodG1sSW5OYXRpdmVQYXN0ZWJv YXJkID0gcmVhZEhUTUxGcm9tUGFzdGVib2FyZCgpOworICAgIFN0cmluZyBodG1sSW5OYXRpdmVQ YXN0ZWJvYXJkID0gcmVhZEhUTUxTdHJpbmdGcm9tUGFzdGVib2FyZCgpOwogICAgIEVYUEVDVF9U UlVFKGh0bWxJbk5hdGl2ZVBhc3RlYm9hcmQuY29udGFpbnMoImhlbGxvIikpOwogICAgIEVYUEVD VF9UUlVFKGh0bWxJbk5hdGl2ZVBhc3RlYm9hcmQuY29udGFpbnMoIiwgd29ybGQiKSk7CiAgICAg RVhQRUNUX0ZBTFNFKGh0bWxJbk5hdGl2ZVBhc3RlYm9hcmQuY29udGFpbnMoInNlY3JldCIpKTsK ICAgICBFWFBFQ1RfRkFMU0UoaHRtbEluTmF0aXZlUGFzdGVib2FyZC5jb250YWlucygiZGFuZ2Vy b3VzQ29kZSIpKTsKIH0KIAorVEVTVChDb3B5SFRNTCwgU2FuaXRpemF0aW9uUHJlc2VydmVzQ2hh cmFjdGVyU2V0KQoreworICAgIFZlY3RvcjxzdGQ6OnBhaXI8UmV0YWluUHRyPE5TU3RyaW5nPiwg UmV0YWluUHRyPE5TRGF0YT4+LCAzPiBtYXJrdXBTdHJpbmdzQW5kRGF0YTsKKyAgICBhdXRvIHdl YlZpZXcgPSBjcmVhdGVXZWJWaWV3V2l0aEN1c3RvbVBhc3RlYm9hcmREYXRhRW5hYmxlZCgpOwor ICAgIGZvciAoTlNTdHJpbmcgKmVuY29kaW5nTmFtZSBpbiBAWyBAInV0Zi04IiwgQCJ3aW5kb3dz LTEyNTIiLCBAImJvZ3VzLWVuY29kaW5nIiBdKSB7CisgICAgICAgIFt3ZWJWaWV3IHN5bmNocm9u b3VzbHlMb2FkSFRNTFN0cmluZzpbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIjwhRE9DVFlQ RSBodG1sPiIKKyAgICAgICAgICAgICI8Ym9keT4iCisgICAgICAgICAgICAiPG1ldGEgY2hhcnNl dD0nJUAnPiIKKyAgICAgICAgICAgICI8cCBpZD0nY29weSc+Q29weSBtZTwvcD4iCisgICAgICAg ICAgICAiPHNjcmlwdD4iCisgICAgICAgICAgICAiY29weS5hZGRFdmVudExpc3RlbmVyKCdjb3B5 JywgZSA9PiB7IgorICAgICAgICAgICAgIiAgICBlLmNsaXBib2FyZERhdGEuc2V0RGF0YSgndGV4 dC9odG1sJywgYDxzcGFuIHN0eWxlPSdjb2xvcjogcmVkOyc+5oiR5Y+r6Kyd5paH5piHPC9zcGFu PmApOyIKKyAgICAgICAgICAgICIgICAgZS5wcmV2ZW50RGVmYXVsdCgpOyIKKyAgICAgICAgICAg ICJ9KTsiCisgICAgICAgICAgICAiZ2V0U2VsZWN0aW9uKCkuc2VsZWN0QWxsQ2hpbGRyZW4oY29w eSk7IgorICAgICAgICAgICAgIjwvc2NyaXB0PiIKKyAgICAgICAgICAgICI8L2JvZHk+IiwgZW5j b2RpbmdOYW1lXV07CisgICAgICAgIFt3ZWJWaWV3IGNvcHk6bmlsXTsKKyAgICAgICAgW3dlYlZp ZXcgd2FpdEZvck5leHRQcmVzZW50YXRpb25VcGRhdGVdOworCisgICAgICAgIG1hcmt1cFN0cmlu Z3NBbmREYXRhLmFwcGVuZCh7IHJlYWRIVE1MU3RyaW5nRnJvbVBhc3RlYm9hcmQoKSwgcmVhZEhU TUxEYXRhRnJvbVBhc3RlYm9hcmQoKSB9KTsKKyAgICB9CisKKyAgICBmb3IgKGF1dG8mIFtjb3Bp ZWRNYXJrdXAsIGNvcGllZERhdGFdIDogbWFya3VwU3RyaW5nc0FuZERhdGEpIHsKKyAgICAgICAg RVhQRUNUX1RSVUUoW2NvcGllZE1hcmt1cCBjb250YWluc1N0cmluZzpAIjxzcGFuICJdKTsKKyAg ICAgICAgRVhQRUNUX1RSVUUoW2NvcGllZE1hcmt1cCBjb250YWluc1N0cmluZzpAImNvbG9yOiBy ZWQ7Il0pOworICAgICAgICBFWFBFQ1RfVFJVRShbY29waWVkTWFya3VwIGNvbnRhaW5zU3RyaW5n OkAi5oiR5Y+r6Kyd5paH5piHIl0pOworICAgICAgICBFWFBFQ1RfVFJVRShbY29waWVkTWFya3Vw IGNvbnRhaW5zU3RyaW5nOkAiPC9zcGFuPiJdKTsKKworICAgICAgICBOU0Vycm9yICphdHRyaWJ1 dGVkU3RyaW5nQ29udmVyc2lvbkVycm9yID0gbmlsOworCisgICAgICAgIGF1dG8gYXR0cmlidXRl ZFN0cmluZyA9IGFkb3B0TlMoW1tOU0F0dHJpYnV0ZWRTdHJpbmcgYWxsb2NdIGluaXRXaXRoRGF0 YTpjb3BpZWREYXRhLmdldCgpIG9wdGlvbnM6QHsgTlNEb2N1bWVudFR5cGVEb2N1bWVudE9wdGlv bjogTlNIVE1MVGV4dERvY3VtZW50VHlwZSB9IGRvY3VtZW50QXR0cmlidXRlczpuaWwgZXJyb3I6 JmF0dHJpYnV0ZWRTdHJpbmdDb252ZXJzaW9uRXJyb3JdKTsKKyAgICAgICAgRVhQRUNUX1dLX1NU UkVRKCLmiJHlj6vorJ3mlofmmIciLCBbYXR0cmlidXRlZFN0cmluZyBzdHJpbmddKTsKKworICAg ICAgICBfX2Jsb2NrIEJPT0wgZm91bmRDb2xvckF0dHJpYnV0ZSA9IE5POworICAgICAgICBbYXR0 cmlidXRlZFN0cmluZyBlbnVtZXJhdGVBdHRyaWJ1dGU6TlNGb3JlZ3JvdW5kQ29sb3JBdHRyaWJ1 dGVOYW1lIGluUmFuZ2U6TlNNYWtlUmFuZ2UoMCwgNSkgb3B0aW9uczowIHVzaW5nQmxvY2s6XihD b2NvYUNvbG9yICpjb2xvciwgTlNSYW5nZSByYW5nZSwgQk9PTCAqKSB7CisgICAgICAgICAgICBD R0Zsb2F0IHJlZENvbXBvbmVudCA9IDA7CisgICAgICAgICAgICBDR0Zsb2F0IGdyZWVuQ29tcG9u ZW50ID0gMDsKKyAgICAgICAgICAgIENHRmxvYXQgYmx1ZUNvbXBvbmVudCA9IDA7CisgICAgICAg ICAgICBbY29sb3IgZ2V0UmVkOiZyZWRDb21wb25lbnQgZ3JlZW46JmdyZWVuQ29tcG9uZW50IGJs dWU6JmJsdWVDb21wb25lbnQgYWxwaGE6bmlsXTsKKworICAgICAgICAgICAgRVhQRUNUX0VRKDEu LCByZWRDb21wb25lbnQpOworICAgICAgICAgICAgRVhQRUNUX0VRKDAuLCBncmVlbkNvbXBvbmVu dCk7CisgICAgICAgICAgICBFWFBFQ1RfRVEoMC4sIGJsdWVDb21wb25lbnQpOworICAgICAgICAg ICAgZm91bmRDb2xvckF0dHJpYnV0ZSA9IFlFUzsKKyAgICAgICAgfV07CisgICAgICAgIEVYUEVD VF9UUlVFKGZvdW5kQ29sb3JBdHRyaWJ1dGUpOworICAgIH0KK30KKwogI2lmIFBMQVRGT1JNKE1B QykKIAogVEVTVChDb3B5SFRNTCwgSXRlbVR5cGVzV2hlbkNvcHlpbmdXZWJDb250ZW50KQo=