36627 2010-03-25 16:21:52 -0700 Needs a "LinuxEditingBehavior", perhaps with a better name 2010-10-30 06:34:37 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 38603 39854 23351 1 gustavo tonikitoo christian darin eric evan joone manyoso mrobinson ojan ossy rniwa tonikitoo tony webkit.review.bot xan.lopez oldest_to_newest 204288 0 gustavo 2010-03-25 16:21:52 -0700 GTK+, and Qt have editing behaviors that mostly match windows, with a few twists. Clicking under the last line of text, for instance, should put the cursor in the last character of the last sentence, not in the character that is in the same x position as the click. We need a new editing behavior to accomodate all of these slight differences. This new editing behavior could likely be shared by Chromium, GTK+, and Qt on Linux. 205214 1 mrobinson 2010-03-28 13:06:16 -0700 Just from sniffing around a bit, it seems that Qt and GTK+ have different editing behaviors, so getting things to work in a Qt-ish way and a GTK+-ish may require more granularity than just "Linux", "Mac" and "Windows." 205231 2 ojan 2010-03-28 13:52:45 -0700 (In reply to comment #1) > Just from sniffing around a bit, it seems that Qt and GTK+ have different > editing behaviors, so getting things to work in a Qt-ish way and a GTK+-ish may > require more granularity than just "Linux", "Mac" and "Windows." Can you give an example of a difference between Qt and GTK+ editing behaviors? 205258 3 mrobinson 2010-03-28 16:16:22 -0700 On further investigation it seems the difference in behavior that I've seen so far is mostly due to: https://bugzilla.gnome.org/show_bug.cgi?id=605466 . GTK+ (except GTKTextView), Qt a. double-click a word b. modify selection via shift+right arrow ---> selection becomes one character longer GTK+ (GTKTextView) a. double-click a word b. modify selection via shift+right arrow ---> selection becomes one character shorter For the sake of simplicity, I think it makes sense for both Qt and GTK+ to follow the same behavior here. Perhaps this isn't as complicated as I thought. 205273 4 evan 2010-03-28 17:59:53 -0700 Wow, yeah, I think the GtkTextView behavior has to be a bug! I had to try it myself to believe it. 206616 5 christian 2010-03-31 11:51:14 -0700 I didn't realize double-click selection in GtkTextView is the reverse of GtkEntry. I think it should definitely be consistent. I will try to find some GTK+ core hackers to ask about making this conistent I would for now suggest to implement GtkEntry/ Qt behaviour in WebKit "Linux". Maybe a better name would be "Freedesktop" since that is the common denominator shared by KDE, GNOME, XFCE and LXDE? 230770 6 tonikitoo 2010-05-26 11:03:08 -0700 I am working in some initial steps on this. 230774 7 darin 2010-05-26 11:06:01 -0700 Once we have a third behavior or fourth, I think we need some functions that translate the overall behavior policy into specific behaviors rather than directly saying "behavior == Mac" or "behavior == Windows". Helper functions that expression the different rules in plain language. I think that should be straightforward and we can do that refactoring before adding a new behavior value. 230778 8 tonikitoo 2010-05-26 11:13:59 -0700 (In reply to comment #7) > Once we have a third behavior or fourth, I think we need some functions that translate the overall behavior policy into specific behaviors rather than directly saying "behavior == Mac" or "behavior == Windows". Helper functions that expression the different rules in plain language. > > I think that should be straightforward and we can do that refactoring before adding a new behavior value. Do you mean something like isMacEditingBehavior(), isWindowsEditingBehaviour(), etc? 230779 9 darin 2010-05-26 11:15:54 -0700 (In reply to comment #8) > Do you mean something like isMacEditingBehavior(), isWindowsEditingBehaviour(), etc? No, things like: shouldDoubleClickSelectSpaceAfterWord Although maybe not specifically that one; I’d have to look at the differences. Generally speaking I’d like the editing behavior policies clearly stated in some central place and this is one good way to clearly state them. 230799 10 tonikitoo 2010-05-26 11:43:49 -0700 > > Do you mean something like isMacEditingBehavior(), isWindowsEditingBehaviour(), etc? > > No, things like: > > shouldDoubleClickSelectSpaceAfterWord > > Although maybe not specifically that one; I’d have to look at the differences. Generally speaking I’d like the editing behavior policies clearly stated in some central place and this is one good way to clearly state them. Hum, I see you point now. I am worried if we could end up with too many methods like this, e.g.: - shouldSelectWordUnderContextMenu <- right click on top of text; - shouldExtendSelectionWorkAsOnWindows, shouldExtendSelectionWorkAsOnLinux, etc; - shouldClickingBelowTheLastLineOfTextboxGoToEnd - etc. (sorry for the bad fake names) My point is if different editing behavior are generally plaform specific ones, should we really have all those methods? 230936 11 darin 2010-05-26 14:55:05 -0700 (In reply to comment #10) > My point is if different editing behavior are generally plaform specific ones, should we really have all those methods? I think we should. They can be inline functions. The best way to document things like this is with code. The actual compiled code will be identical to what otherwise would be spread at the different call sites. By putting these functions in a single header we can make it clear what these different editing "behaviors" mean. 230983 12 ojan 2010-05-26 15:47:51 -0700 (In reply to comment #11) > (In reply to comment #10) > > My point is if different editing behavior are generally plaform specific ones, should we really have all those methods? > > I think we should. They can be inline functions. The best way to document things like this is with code. The actual compiled code will be identical to what otherwise would be spread at the different call sites. > > By putting these functions in a single header we can make it clear what these different editing "behaviors" mean. I think this is a great idea. It will make the code much more readable. Also, it will make it very easy for people new to the editing code to figure out what the behaviors of each platform are. Finally, if we ever were to add a new platform, there'd only be a single file we'd need to modify. 231292 13 tonikitoo 2010-05-27 07:36:59 -0700 Ok. We can go that direction. As a start, grep'ed WebCore/ looking for the current call sites of Settings::editingBehavior(), and tried to understand each situation. Summary follows: - RenderBlock::positionForPointWithInlineChildren(...) It handlers where to put the caret (by returning a VisiblePosition) if clicking under the last line of a editable area (e.g. <textarea>). Current difference: Windows moves caret to the last line, but obeying the X position of the click. On Linux and Mac, caret goes to the end of the last line. - static bool executeToggleStyle(...), at EditorCommand.cpp Method toggles on/off a given style (for example, italic or bold) of a selected text in a editable area. On Mac, it considers the selection as already styled id the start of the selection is styled. On non EditingMacBeviour case, current selection is only considered as already styled if the whole selection is styled. Based on that, the method toggles on or off the style. - EventHandler::handleMousePressEventSingleClick(...) It handles how a selection is extended by a click when SHIFT is being held. On Mac, it calculates if the clicked position is closer to the start or to the end of the current selected text and moves selection towards the closer. Windows and Linux work rather differently. __________________ I've also seen some related stuff that are likely platform specific editing behavior as well but are controlled by Settings::editingBehavior, including: - right clicking on a text opens the context sensitive menu and selects the word under the mouse point on anything but Gtk and Chromium. It is defined in EventHandler::sendContextMenuEvent (see GTK and CHROMIUM guards there). - "Pushing the down arrow key on the last line puts the caret at the end of the last line on Mac and Linux, but does nothing on Windows. A similar case exists on the top line." as described in Settings.h, landed by Darin. @darin, ojan: should all these cases become the "helper functions that expression the different rules in plain language" you are agreeing with? 231360 14 tonikitoo 2010-05-27 10:46:21 -0700 (In reply to comment #13) correcting a few typos: > On Mac, it considers the selection as already styled id the start of the s/id/if > __________________ > > I've also seen some related stuff that are likely platform specific editing behavior as well but are controlled by Settings::editingBehavior, including: s/are controlled/are NOT controlled/ 231413 15 ojan 2010-05-27 12:04:17 -0700 We should probably put this in a new file. EditingBehavior.h? (In reply to comment #13) > - RenderBlock::positionForPointWithInlineChildren(...) > > It handlers where to put the caret (by returning a VisiblePosition) if clicking under the last line of a editable area (e.g. <textarea>). Current difference: > Windows moves caret to the last line, but obeying the X position of the click. On Linux and Mac, caret goes to the end of the last line. Almost correct. It's also for clicking above a line. On Mac/Linux it should move to the beginning of the line. ON Windows, it obeys the X position. Also, it's not just for clicking, it also applies to keyboard movement (i.e. hitting up in the middle of the top line or down in the middle of the bottom line). > - static bool executeToggleStyle(...), at EditorCommand.cpp > > Method toggles on/off a given style (for example, italic or bold) of a selected text in a editable area. > > On Mac, it considers the selection as already styled id the start of the selection is styled. On non EditingMacBeviour case, current selection is only considered as already styled if the whole selection is styled. Based on that, the method toggles on or off the style. > > - EventHandler::handleMousePressEventSingleClick(...) > > It handles how a selection is extended by a click when SHIFT is being held. On Mac, it calculates if the clicked position is closer to the start or to the end of the current selected text and moves selection towards the closer. Windows and Linux work rather differently. Specifically, Win/Linux always move the extent end of the selection. > I've also seen some related stuff that are likely platform specific editing behavior as well but are controlled by Settings::editingBehavior, including: > > - right clicking on a text opens the context sensitive menu and selects the word under the mouse point on anything but Gtk and Chromium. It is defined in EventHandler::sendContextMenuEvent (see GTK and CHROMIUM guards there). This one should be using editingBehavior, but it's not as straightforward as the other ones. Currently, all Chromium is avoided. Really, this behavior should only happen for Mac. I see the word get selected in Chromium-mac though, so it must be doing so down a different code path. > - "Pushing the down arrow key on the last line puts the caret at the end of the last line on Mac and Linux, but does nothing on Windows. A similar case exists on the top line." as described in Settings.h, landed by Darin. Isn't this the usage in RenderBlock::positionForPointWithInlineChildren? > @darin, ojan: should all these cases become the "helper functions that expression the different rules in plain language" you are agreeing with? We should replace any usages of editingBehavior outside of EditingSettings.h. In fact, I think we should remove the getter entirely if possible. There's a couple cases you missed as well. http://trac.webkit.org/browser/trunk/WebCore/editing/SelectionController.cpp#L167 Whether the revealing the selection top-aligns or center-aligns the selection. http://trac.webkit.org/browser/trunk/WebCore/editing/SelectionController.cpp#L247 Whether mouse-based selections are directional http://trac.webkit.org/browser/trunk/WebCore/editing/SelectionController.cpp#L302 Whether keyboard-based selections move the extent for some horizontal navigations. I would guess that there are other cases where we want to change to use this style (e.g. selecting the space after a word on double-click, whether to smartInsertDelete, etc.). But, I suggest leaving those to later. So you can: 1. Move all uses of editingBehavior to EditingBehavior.h. 2. Add EditingLinuxBehavior 3. Move the remaining things that should be in EditingBehavior 231448 16 darin 2010-05-27 13:45:47 -0700 That all sounds pretty good. The trick here is to carefully chose the names for the functions so they are as clear as possible. 231451 17 tonikitoo 2010-05-27 13:49:38 -0700 Great input Darin and Ojan. I am on it ... will probably will need help with namings when I come up with the first version of the patch. Also this change has morphed from the original goal of this but. We are now on a preparation change. Should we file another bug and block this one? 231453 18 darin 2010-05-27 13:59:58 -0700 (In reply to comment #17) > Also this change has morphed from the original goal of this but. We are now on a preparation change. Should we file another bug and block this one? Yes. 231465 19 tonikitoo 2010-05-27 14:21:17 -0700 (In reply to comment #18) > (In reply to comment #17) > > Also this change has morphed from the original goal of this but. We are now on a preparation change. Should we file another bug and block this one? > Yes. s/but/bug Filed bug 39854 (by clone of this one) 298019 20 tonikitoo 2010-10-22 09:47:19 -0700 Back working on this. 298731 21 71715 tonikitoo 2010-10-24 22:50:28 -0700 Created attachment 71715 Patch v0.1 - WIP - (real patch coming...) 298736 22 mrobinson 2010-10-24 23:32:51 -0700 Not to bikeshed too quickly, but any chance of using something more generic like "XDG" or "FDO" instead of "Linux"? I'm not sure what the most appropriate term is here. 298846 23 ojan 2010-10-25 08:04:54 -0700 EditingUnixBehavior? I know that technically, mac is unix too, but I don't expect that to be as confusing as terms that many people (e.g. me) wouldn't know. For example I don't know what XDG and FDO are. Otherwise, patch looks great. Happy to see this get in! 298853 24 tonikitoo 2010-10-25 08:11:20 -0700 martin, also pointed out 'EditingFreetypeBehavior' on IRC a while ago, iirc. We have to make sure all affected ports were running freetype. (In reply to comment #23) > EditingUnixBehavior? I know that technically, mac is unix too, but I don't expect that to be as confusing as terms that many people (e.g. me) wouldn't know. For example I don't know what XDG and FDO are. Mac is not listed as a unix-based system (below), so I would not worry much about it. 434 /* OS(UNIX) - Any Unix-like system */ 435 #if OS(AIX) \ 436 || OS(ANDROID) \ 437 || OS(DARWIN) \ 438 || OS(FREEBSD) \ 439 || OS(HAIKU) \ 440 || OS(LINUX) \ 441 || OS(NETBSD) \ 442 || OS(OPENBSD) \ 443 || OS(QNX) \ 444 || OS(SOLARIS) \ 445 || OS(SYMBIAN) \ 446 || defined(unix) \ 447 || defined(__unix) \ 448 || defined(__unix__) 449 #define WTF_OS_UNIX 1 298855 25 tonikitoo 2010-10-25 08:12:49 -0700 ah, it is: DARWIN > Mac is not listed as a unix-based system (below), so I would not worry much about it. > > 434 /* OS(UNIX) - Any Unix-like system */ > 435 #if OS(AIX) \ > 436 || OS(ANDROID) \ > 437 || OS(DARWIN) \ > 438 || OS(FREEBSD) \ 298882 26 tonikitoo 2010-10-25 09:00:31 -0700 (In reply to comment #23) > EditingUnixBehavior? I know that technically, mac is unix too, but I don't expect that to be as confusing as terms that many people (e.g. me) wouldn't know. For example I don't know what XDG and FDO are. quick reference: * XGD: http://www.freedesktop.org/wiki/Software/xdg-user-dirs * FDO = freedesktop(?) 298891 27 mrobinson 2010-10-25 09:06:50 -0700 (In reply to comment #23) > EditingUnixBehavior? I know that technically, mac is unix too, but I don't expect that to be as confusing as terms that many people (e.g. me) wouldn't know. For example I don't know what XDG and FDO are. Fair enough. There's always EditingFreedesktopOrgBehavior, EditingFreedesktopBehavior, or EditingXWindowsBehavior, I reckon. 298909 28 darin 2010-10-25 09:31:47 -0700 Definitely not freetype! That has nothing to do with user interface. 298920 29 tonikitoo 2010-10-25 09:47:07 -0700 err, s/freetype/freedesktop. Not sure where freetype came from =/ sorry about the confusion. I will come up with a patch later today, but first I have some questions about two things I do not know if should come together in this patch: 1) the WIP patch I uploaded (attachment 71715) not only adds a "linux" behavior, but also changes the default behavior in Settings.cpp: +static EditingBehaviorType editingBehaviorTypeForPlatform() +{ + return +#if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN)) || (PLATFORM(QT) && defined(Q_WS_MAC)) + // (PLATFORM(MAC) is always false in Chromium and Qt, hence the extra condition. + EditingMacBehavior +#elif OS(WINDOWS) || (PLATFORM(QT) && defined(Q_WS_WIN)) + EditingWindowsBehavior +#elif OS(UNIX) + EditingLinuxBehavior +#else + // Fallback + EditingMacBehavior +#endif + ; +} Basically - WebKitGtk that currently uses Mac editing behavior would be switching to "linux"; - QtWebKit that uses Windows editing behavior unconditionally would be switching to {mac, win,"linux"}, depending on the platform it is build on; - Ditto for Chromium. So there are big changes happening here ... Please let me know the best way you think to proceed. Should it be a big patch changing it all, or we go incrementally? 2) Also I have to add LayoutTestController::setEditingMode("linux") to all editing tests using this API today. 298924 30 mrobinson 2010-10-25 09:51:15 -0700 (In reply to comment #29) > - WebKitGtk that currently uses Mac editing behavior would be switching to "linux"; At least for WebKitGTK+, this is highly desirable. When building the GTK+ port on Windows or Mac, we'd probably want to align with GTK+ on those platforms as well. 298960 31 tony 2010-10-25 10:46:56 -0700 (In reply to comment #29) > - Ditto for Chromium. This change seems fine for Chromium. We're just adding Linux since it was already using mac behavior on OS(DARWIN). Can we simplify the #if's to just be #if OS(DARWIN) EditingMacBehavior #elif OS(WINDOWS) EditingWindowsBehavior #elif OS(UNIX) EditingLinuxBehavior #else // Fallback EditingMacBehavior #endif ? I'm not sure if this would work for QT or not. 298973 32 ojan 2010-10-25 11:05:11 -0700 (In reply to comment #29) > Please let me know the best way you think to proceed. Should it be a big patch changing it all, or we go incrementally? Incrementally will almost certainly be easier to avoid needing to rollback. There will be lots of tests affected by this. It'll likely be easier to make sense of everything if you do one platform at a time. Either way is fine with me though as long as you get the tree green. :) 301583 33 72294 tonikitoo 2010-10-28 22:02:37 -0700 Created attachment 72294 (committed r70975, r=ojan) patch v1 Added EditingUnixBehavior. Patch also: * updates all corresponding port specific APIs, including Mac, Win, Gtk and Chromium. * update Qt,Gtk,Mac,Win and Chromium LayoutTestController::setEditingBehavior methods to support the newly added editing behavior type. Patch updating all tests that go through platform specific code paths will be in a follow up, so we keep this one clean. 301584 34 webkit.review.bot 2010-10-28 22:06:07 -0700 Attachment 72294 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebKit/win/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] WebKit/gtk/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] WebCore/page/Settings.cpp:85: Line contains only semicolon. If this should be an empty statement, use { } instead. [whitespace/semicolon] [5] WebKit/mac/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] Total errors found: 4 in 21 files If any of these errors are false positives, please file a bug against check-webkit-style. 301585 35 tonikitoo 2010-10-28 22:15:01 -0700 (In reply to comment #34) > Attachment 72294 [details] did not pass style-queue: > > Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 > WebKit/win/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] > WebKit/gtk/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] > WebCore/page/Settings.cpp:85: Line contains only semicolon. If this should be an empty statement, use { } instead. [whitespace/semicolon] [5] > WebKit/mac/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] > Total errors found: 4 in 21 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. Fixed locally. 302258 36 72294 tonikitoo 2010-10-29 22:43:58 -0700 Comment on attachment 72294 (committed r70975, r=ojan) patch v1 Clearing review flags on attachment: 72294 Committed r70975: <http://trac.webkit.org/changeset/70975> 71715 2010-10-24 22:50:28 -0700 2010-10-28 22:02:37 -0700 Patch v0.1 - WIP - (real patch coming...) 0001-2010-10-24-Antonio-Gomes-agomes-rim.com.patch text/plain 8658 tonikitoo RnJvbSBiYmQ4MDEyZmI5ODhjNTliMWMwNTZmYmM1Njk1OWU2NzgyOGU2M2YyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDxhZ29tZXNAcmltLmNvbT4KRGF0ZTog TW9uLCAyNSBPY3QgMjAxMCAwMTo0NjoyMiAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIDIwMTAtMTAt MjQgIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4KCiAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgogICAgICAgIE5lZWRzIGEgIkxpbnV4RWRpdGluZ0JlaGF2aW9yIiwg cGVyaGFwcyB3aXRoIGEgYmV0dGVyIG5hbWUKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzY2MjcKCiAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCgpX ZWJDb3JlOgogICAgICAgICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oOgogICAgICAg ICogcGFnZS9TZXR0aW5ncy5jcHA6CiAgICAgICAgKFdlYkNvcmU6OmVkaXRpbmdCZWhhdmlvclR5 cGVGb3JQbGF0Zm9ybSk6CiAgICAgICAgKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CgpX ZWJLaXQvY2hyb21pdW06CgogICAgICAgICogcHVibGljL1dlYlNldHRpbmdzLmg6CiAgICAgICAg KiBzcmMvQXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHA6CgpXZWJLaXQvZ3RrOgoKICAgICAgICAqIHdl YmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5jcHA6CiAgICAgICAgKHdlYmtpdF93ZWJfc2V0dGluZ3Nf Y2xhc3NfaW5pdCk6CiAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaDoKCldlYktp dC9tYWM6CgogICAgICAgICogV2ViVmlldy9XZWJGcmFtZS5tbToKICAgICAgICAoY29yZSk6CiAg ICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oOgoKV2ViS2l0L3dpbjoKCiAg ICAgICAgKiBJbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlcy5pZGw6Ci0tLQogV2ViQ29yZS9lZGl0 aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmggICAgICB8ICAgIDMgKy0KIFdlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAgICAgICAgICAgICAgICAgICAgfCAgIDMxICsrKysrKysrKysrKysrKysrKysr LS0tLS0tLQogV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oICAgICAgICB8ICAg IDMgKy0KIFdlYktpdC9jaHJvbWl1bS9zcmMvQXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHAgfCAgICAx ICsKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmNwcCAgICAgfCAgICAzICst CiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oICAgICAgIHwgICAgMyArLQog V2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tICAgICAgICAgICAgICB8ICAgIDIgKwogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oICB8ICAgIDMgKy0KIFdlYktp dC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsICAgfCAgICAzICstCiA5IGZpbGVz IGNoYW5nZWQsIDM4IGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIGIvV2ViQ29yZS9lZGl0aW5n L0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKaW5kZXggMjZiYTE4ZS4uZjhlOWQxYyAxMDA2NDQKLS0t IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKKysrIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKQEAgLTM4LDcgKzM4LDggQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KIGVudW0gRWRpdGluZ0Jl aGF2aW9yVHlwZSB7CiAgICAgRWRpdGluZ01hY0JlaGF2aW9yLAotICAgIEVkaXRpbmdXaW5kb3dz QmVoYXZpb3IKKyAgICBFZGl0aW5nV2luZG93c0JlaGF2aW9yLAorICAgIEVkaXRpbmdMaW51eEJl aGF2aW9yCiB9OwogCiB9IC8vIFdlYkNvcmUgbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BhZ2UvU2V0dGluZ3MuY3BwIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCBkYzhm Y2I1Li4zNTNjYzgxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBi L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKQEAgLTY0LDYgKzY0LDI4IEBAIGJvb2wgU2V0dGlu Z3M6OmdTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzID0gdHJ1ZTsKIGJvb2wgU2V0dGluZ3M6OmdT aG91bGRVc2VIaWdoUmVzb2x1dGlvblRpbWVycyA9IHRydWU7CiAjZW5kaWYKIAorLy8gTk9URXMK Ky8vICAxKSBNYWMgaGVyZSBjb21wcmlzZXMgVGlnZXIsIExlb3BhcmQgYW5kIFNub3dMZW9wYXJk IGJ1aWxkcywgYXMgd2VsbCBhcyBRdFdlYktpdCBhbmQgQ2hyb21pdW0gd2hlbiBidWlsdCBvbiBN YWM7CisvLyAgMikgV2luZG93cyBjb21wcmlzZXMgV2luMzIgYW5kIFdpbkNFIGJ1aWxkcywgYXMg d2VsbCBhcyBRdFdlYktpdCBhbmQgQ2hyb21pdW0gd2hlbiBidWlsdCBvbiBXaW5kb3dzOworLy8g IDMpIExpbnV4IGNvbXByaXNlcyBhbGwgdW5peC1iYXNlZCBzeXN0ZW1zIChhYnVzaW5nIHRoZSB0 ZXJtaW5vbG9neSk7CisvLyA5OSkgTWFjRWRpdGluZ0JlaGF2aW9yIGlzIHVzZWQgYSBmYWxsYmFj ay4KK3N0YXRpYyBFZGl0aW5nQmVoYXZpb3JUeXBlIGVkaXRpbmdCZWhhdmlvclR5cGVGb3JQbGF0 Zm9ybSgpCit7CisgICAgcmV0dXJuCisjaWYgUExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hS T01JVU0pICYmIE9TKERBUldJTikpIHx8IChQTEFURk9STShRVCkgJiYgZGVmaW5lZChRX1dTX01B QykpCisgICAgLy8gKFBMQVRGT1JNKE1BQykgaXMgYWx3YXlzIGZhbHNlIGluIENocm9taXVtIGFu ZCBRdCwgaGVuY2UgdGhlIGV4dHJhIGNvbmRpdGlvbi4KKyAgICBFZGl0aW5nTWFjQmVoYXZpb3IK KyNlbGlmIE9TKFdJTkRPV1MpIHx8IChQTEFURk9STShRVCkgJiYgZGVmaW5lZChRX1dTX1dJTikp CisgICAgRWRpdGluZ1dpbmRvd3NCZWhhdmlvcgorI2VsaWYgT1MoVU5JWCkKKyAgICBFZGl0aW5n TGludXhCZWhhdmlvcgorI2Vsc2UKKyAgICAvLyBGYWxsYmFjaworICAgIEVkaXRpbmdNYWNCZWhh dmlvcgorI2VuZGlmCisgICAgOworfQorCiBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSogcGFnZSkK ICAgICA6IG1fcGFnZShwYWdlKQogICAgICwgbV9lZGl0YWJsZUxpbmtCZWhhdmlvcihFZGl0YWJs ZUxpbmtEZWZhdWx0QmVoYXZpb3IpCkBAIC0xMjAsMTQgKzE0Miw3IEBAIFNldHRpbmdzOjpTZXR0 aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9lbmZvcmNlQ1NTTUlNRVR5cGVJbk5vUXVpcmtzTW9k ZSh0cnVlKQogICAgICwgbV91c2VzRW5jb2RpbmdEZXRlY3RvcihmYWxzZSkKICAgICAsIG1fYWxs b3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoZmFsc2UpCi0gICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5 cGUoCi0jaWYgUExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJ TikpCi0gICAgICAgIC8vIChQTEFURk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1 bSwgaGVuY2UgdGhlIGV4dHJhIGNvbmRpdGlvbi4pCi0gICAgICAgIEVkaXRpbmdNYWNCZWhhdmlv cgotI2Vsc2UKLSAgICAgICAgRWRpdGluZ1dpbmRvd3NCZWhhdmlvcgotI2VuZGlmCi0gICAgICAg ICkKKyAgICAsIG1fZWRpdGluZ0JlaGF2aW9yVHlwZShlZGl0aW5nQmVoYXZpb3JUeXBlRm9yUGxh dGZvcm0oKSkKICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcmVhbGx5IGJlIGRpc2FibGVkIGJ5 IGRlZmF1bHQgYXMgaXQgbWFrZXMgcGxhdGZvcm1zIHRoYXQgZG9uJ3Qgc3VwcG9ydCB0aGUgZmVh dHVyZSBkb3dubG9hZCBmaWxlcwogICAgIC8vIHRoZXkgY2FuJ3QgdXNlIGJ5LiBMZWF2aW5nIGVu YWJsZWQgZm9yIG5vdyB0byBub3QgY2hhbmdlIGV4aXN0aW5nIGJlaGF2aW9yLgogICAgICwgbV9k b3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQodHJ1ZSkKZGlmZiAtLWdpdCBhL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViU2V0dGluZ3MuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi U2V0dGluZ3MuaAppbmRleCA2YTM3ZTA4Li45N2M5YzZkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlNldHRpbmdzLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJTZXR0aW5ncy5oCkBAIC00NSw3ICs0NSw4IEBAIGNsYXNzIFdlYlNldHRpbmdzIHsKIHB1Ymxp YzoKICAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7CiAgICAgICAgIEVkaXRpbmdCZWhhdmlvck1h YywKLSAgICAgICAgRWRpdGluZ0JlaGF2aW9yV2luCisgICAgICAgIEVkaXRpbmdCZWhhdmlvcldp biwKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yTGludXgKICAgICB9OwogCiAgICAgdmlydHVhbCB2 b2lkIHNldFN0YW5kYXJkRm9udEZhbWlseShjb25zdCBXZWJTdHJpbmcmKSA9IDA7CmRpZmYgLS1n aXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMuY3BwIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcAppbmRleCA5NjQ3YTQ0Li4yMDdh NDNjIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMu Y3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvQXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHAKQEAg LTM0MCw2ICszNDAsNyBAQCBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNjcm9sbGJh cjo6U2Nyb2xsQnlQaXhlbCwgU2Nyb2xsQnlQaXhlbCk7CiAKIENPTVBJTEVfQVNTRVJUX01BVENI SU5HX0VOVU0oV2ViU2V0dGluZ3M6OkVkaXRpbmdCZWhhdmlvck1hYywgRWRpdGluZ01hY0JlaGF2 aW9yKTsKIENPTVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViU2V0dGluZ3M6OkVkaXRpbmdC ZWhhdmlvcldpbiwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvcik7CitDT01QSUxFX0FTU0VSVF9NQVRD SElOR19FTlVNKFdlYlNldHRpbmdzOjpFZGl0aW5nQmVoYXZpb3JMaW51eCwgRWRpdGluZ0xpbnV4 QmVoYXZpb3IpOwogCiBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlRleHRBZmZpbml0 eVVwc3RyZWFtLCBVUFNUUkVBTSk7CiBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlRl eHRBZmZpbml0eURvd25zdHJlYW0sIERPV05TVFJFQU0pOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2Vic2V0dGluZ3MuY3BwCmluZGV4IGNkNTliZGIuLmU1NTk0NDQgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJzZXR0aW5ncy5jcHAKQEAgLTY4OSw2ICs2ODksNyBAQCBzdGF0aWMgdm9pZCB3 ZWJraXRfd2ViX3NldHRpbmdzX2NsYXNzX2luaXQoV2ViS2l0V2ViU2V0dGluZ3NDbGFzcyoga2xh c3MpCiAKICAgICBDT01QSUxFX0FTU0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdFQktJVF9FRElUSU5H X0JFSEFWSU9SX01BQykgPT0gc3RhdGljX2Nhc3Q8aW50PihXZWJDb3JlOjpFZGl0aW5nTWFjQmVo YXZpb3IpLCBlZGl0aW5nX2JlaGF2aW9yX3R5cGVfbWFjX21hdGNoKTsKICAgICBDT01QSUxFX0FT U0VSVChzdGF0aWNfY2FzdDxpbnQ+KFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX1dJTkRPV1MpID09 IHN0YXRpY19jYXN0PGludD4oV2ViQ29yZTo6RWRpdGluZ1dpbmRvd3NCZWhhdmlvciksIGVkaXRp bmdfYmVoYXZpb3JfdHlwZV93aW5kb3dzX21hdGNoKTsKKyAgICBDT01QSUxFX0FTU0VSVChzdGF0 aWNfY2FzdDxpbnQ+KFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX0xJTlVYKSA9PSBzdGF0aWNfY2Fz dDxpbnQ+KFdlYkNvcmU6OkVkaXRpbmdMaW51eEJlaGF2aW9yKSwgZWRpdGluZ19iZWhhdmlvcl90 eXBlX2xpbnV4X21hdGNoKTsKIAogICAgIC8qKgogICAgICogV2ViS2l0V2ViU2V0dGluZ3M6ZWRp dGluZy1iZWhhdmlvcgpAQCAtNzEzLDcgKzcxNCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf c2V0dGluZ3NfY2xhc3NfaW5pdChXZWJLaXRXZWJTZXR0aW5nc0NsYXNzKiBrbGFzcykKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIkVkaXRp bmcgYmVoYXZpb3IiKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIF8oIlRoZSBiZWhhdmlvciBtb2RlIHRvIHVzZSBpbiBlZGl0aW5nIG1vZGUi KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFdFQktJVF9UWVBFX0VESVRJTkdfQkVIQVZJT1IsCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfRURJVElOR19CRUhBVklPUl9NQUMs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBX RUJLSVRfRURJVElOR19CRUhBVklPUl9MSU5VWCwKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzKSk7CiAKICAgICAvKioKZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmggYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oCmluZGV4IGQ4ZGFmZDkuLjFiNmQ4Y2UgMTAwNjQ0Ci0t LSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmgKKysrIGIvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaApAQCAtMzYsNyArMzYsOCBAQCBHX0JFR0lOX0RF Q0xTCiAKIHR5cGVkZWYgZW51bSB7CiAgICAgV0VCS0lUX0VESVRJTkdfQkVIQVZJT1JfTUFDLAot ICAgIFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX1dJTkRPV1MKKyAgICBXRUJLSVRfRURJVElOR19C RUhBVklPUl9XSU5ET1dTLAorICAgIFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX0xJTlVYCiB9IFdl YktpdEVkaXRpbmdCZWhhdmlvcjsKIAogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYlNldHRpbmdz UHJpdmF0ZSBXZWJLaXRXZWJTZXR0aW5nc1ByaXZhdGU7CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KaW5k ZXggNGY4YzFiYS4uNDA1NzAwYSAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZy YW1lLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbQpAQCAtMjAzLDYgKzIw Myw4IEBAIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVo YXZpb3IgYmVoYXZpb3IpCiAgICAgICAgICAgICByZXR1cm4gV2ViQ29yZTo6RWRpdGluZ01hY0Jl aGF2aW9yOwogICAgICAgICBjYXNlIFdlYktpdEVkaXRpbmdXaW5CZWhhdmlvcjoKICAgICAgICAg ICAgIHJldHVybiBXZWJDb3JlOjpFZGl0aW5nV2luZG93c0JlaGF2aW9yOworICAgICAgICBjYXNl IFdlYktpdEVkaXRpbmdMaW51eEJlaGF2aW9yOgorICAgICAgICAgICAgcmV0dXJuIFdlYkNvcmU6 OkVkaXRpbmdMaW51eEJlaGF2aW9yOwogICAgIH0KICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsK ICAgICByZXR1cm4gV2ViQ29yZTo6RWRpdGluZ01hY0JlaGF2aW9yOwpkaWZmIC0tZ2l0IGEvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oIGIvV2ViS2l0L21hYy9XZWJW aWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCmluZGV4IDQ3ZTZkNzEuLmU4OTcxNWQgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAorKysgYi9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKQEAgLTQ1LDcgKzQ1LDgg QEAgdHlwZWRlZiBlbnVtIHsKIAogdHlwZWRlZiBlbnVtIHsKICAgICBXZWJLaXRFZGl0aW5nTWFj QmVoYXZpb3IsCi0gICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yCisgICAgV2ViS2l0RWRpdGlu Z1dpbkJlaGF2aW9yLAorICAgIFdlYktpdEVkaXRpbmdMaW51eEJlaGF2aW9yCiB9IFdlYktpdEVk aXRpbmdCZWhhdmlvcjsKIAogZXh0ZXJuIE5TU3RyaW5nICpXZWJQcmVmZXJlbmNlc0NoYW5nZWRO b3RpZmljYXRpb247CmRpZmYgLS1naXQgYS9XZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZl cmVuY2VzLmlkbCBiL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsCmlu ZGV4IDRmYjNkZTguLmVhM2RiYjIgMTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vSW50ZXJmYWNlcy9J V2ViUHJlZmVyZW5jZXMuaWRsCisrKyBiL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVy ZW5jZXMuaWRsCkBAIC00OSw3ICs0OSw4IEBAIHR5cGVkZWYgZW51bSBXZWJLaXRFZGl0YWJsZUxp bmtCZWhhdmlvciB7CiAKIHR5cGVkZWYgZW51bSBXZWJLaXRFZGl0aW5nQmVoYXZpb3IgewogICAg IFdlYktpdEVkaXRpbmdNYWNCZWhhdmlvciA9IDAsCi0gICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2 aW9yCisgICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yLAorICAgIFdlYktpdEVkaXRpbmdMaW51 eEJlaGF2aW9yCiB9IFdlYktpdEVkaXRpbmdCZWhhdmlvcjsKIAogCi0tIAoxLjcuMQoK 72294 2010-10-28 22:02:37 -0700 2010-10-29 22:43:58 -0700 (committed r70975, r=ojan) patch v1 0001-Needs-a-LinuxEditingBehavior-perhaps-with-a-better-n.patch text/plain 20452 tonikitoo RnJvbSA4OTAzMDI1N2U4YjI1Y2Y2ZTlmYTVmZWZiOTdkNmVlMjczZTQzYTFlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDxhZ29tZXNAcmltLmNvbT4KRGF0ZTog RnJpLCAyOSBPY3QgMjAxMCAwMDo1NjoyNiAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIE5lZWRzIGEg IkxpbnV4RWRpdGluZ0JlaGF2aW9yIiwgcGVyaGFwcyB3aXRoIGEgYmV0dGVyIG5hbWUKIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNwoKUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPGFnb21lc0ByaW0uY29tPgoKV2Vi Q29yZToKCkFkZGVkIEVkaXRpbmdVbml4QmVoYXZpb3IgZWRpdGluZyB0eXBlIGFpbSB0byBjb3Zl ciB0aGUgY2FzZXMgd2hlbgpuZWl0aGVyIE1hYyBvciBXaW5kb3dzIGJlaGF2aW9ycyBhcmUgYXBw cm9wcmlhdGVkLgoKSXQgd2FzIGRlY2lkZWQgdG8gbmFtZSBpdCBVbml4IG5vdCBMaW51eC4KCk5v IG5ldyB0ZXN0cy4gVGhlIGN1cnJlbnQgZWRpdGluZyB0ZXN0cyB0aGF0IGludm9sdmUgcGxhdGZv cm0gc3BlY2lmaWMKYmFoYXZpb3JzIGFyZSBjb2RlZCBzbyB0aGF0IHRoZXkgZ28gdGhyb3VnaCBh bGwgZWRpdGluZyBiZWhhdmlvcgp0eXBlcyBwb3NzaWJsZS4gVGhlcmUgd2lsbCBiZSBhIGZvbGxv dyB1cCBidWcgd2hlcmUgYWxsIG9mIHRoZW0gd2lsbApiZSB1cGRhdGVkIHRvIGluY2x1ZGUgdGhl IG5ldyBlZGl0aW5nIGJlaGF2aW9yICgidW5peCIpLgoKKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlv clR5cGVzLmg6CiogcGFnZS9TZXR0aW5ncy5jcHA6CihXZWJDb3JlOjplZGl0aW5nQmVoYXZpb3JU eXBlRm9yUGxhdGZvcm0pOgooV2ViQ29yZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKCldlYktpdC9j aHJvbWl1bToKCkFkZGVkIHRoZSBjb3JyZXNwb25kaW5nIENocm9taXVtIHNldHRpbmcgdG8gV2Vi Q29yZSdzIEVkaXRpbmdVbml4QmVoYXZpb3I6IEVkaXRpbmdCZWhhdmlvclVuaXguCgoqIHB1Ymxp Yy9XZWJTZXR0aW5ncy5oOgoqIHNyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcDoKCldlYktpdC9n dGs6CgoJCUFkZGVkIHRoZSBjb3JyZXNwb25kaW5nIEdUSysgc2V0dGluZyB0byBXZWJDb3JlJ3Mg RWRpdGluZ1VuaXhCZWhhdmlvcjogV0VCS0lUX0VESVRJTkdfQkVIQVZJT1JfVU5JWC4KCiogd2Vi a2l0L3dlYmtpdHdlYnNldHRpbmdzLmNwcDoKKHdlYmtpdF93ZWJfc2V0dGluZ3NfY2xhc3NfaW5p dCk6Ciogd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg6CgpXZWJLaXQvbWFjOgoKCQlBZGRlZCB0 aGUgY29ycmVzcG9uZGluZyBHVEsrIHNldHRpbmcgdG8gV2ViQ29yZSdzIEVkaXRpbmdVbml4QmVo YXZpb3I6IFdlYktpdEVkaXRpbmdVbml4QmVoYXZpb3IuCgoqIFdlYlZpZXcvV2ViRnJhbWUubW06 Cihjb3JlKToKKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oOgoKV2ViS2l0L3F0OgoK QWRkaW5nIHN1cHBvcnQgdG8gUXQncyBEUlRTdXBwb3J0IGNsYXNzIHRvIHRlc3QgdGhlIG5ld2x5 IGludHJvZHVjZWQgVW5peCBlZGl0aW5nIGJlaGF2aW9yLgoKKiBXZWJDb3JlU3VwcG9ydC9EdW1w UmVuZGVyVHJlZVN1cHBvcnRRdC5jcHA6CihEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRp dGluZ0JlaGF2aW9yKToKCldlYktpdC93aW46CgoJCUFkZGVkIHRoZSBjb3JyZXNwb25kaW5nIEdU Sysgc2V0dGluZyB0byBXZWJDb3JlJ3MgRWRpdGluZ1VuaXhCZWhhdmlvcjogV2ViS2l0RWRpdGlu Z1VuaXhCZWhhdmlvci4KCiogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsOgoKV2ViS2l0 VG9vbHM6CgpBZGRpbmcgc3VwcG9ydCB0byBNYWMncywgR1RLKydzLCBXaW5kb3dzJyBhbmQgQ2hy b21pdW0ncyBMYXlvdXRUZXN0Q29udHJvbGxlciBjbGFzcyB0byB0ZXN0IHRoZSBuZXdseSBpbnRy b2R1Y2VkIFVuaXggZWRpdGluZyBiZWhhdmlvci4KCiogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0v TGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgooTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldEVkaXRp bmdCZWhhdmlvcik6CiogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3Rr LmNwcDoKKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRFZGl0aW5nQmVoYXZpb3IpOgoqIER1bXBS ZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbToKKExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRFZGl0aW5nQmVoYXZpb3IpOgoqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRU ZXN0Q29udHJvbGxlcldpbi5jcHA6CihMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RWRpdGluZ0Jl aGF2aW9yKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMjIgKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oICAgICAgICAgICAgIHwgICAgMyArLQogV2ViQ29yZS9wYWdlL1NldHRpbmdz LmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMwICsrKysrKysrKysrKysrLS0tLS0K IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAx MiArKysrKysrKwogV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oICAgICAgICAg ICAgICAgfCAgICAzICstCiBXZWJLaXQvY2hyb21pdW0vc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMu Y3BwICAgICAgICB8ICAgIDEgKwogV2ViS2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDEzICsrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJzZXR0aW5ncy5jcHAgICAgICAgICAgICB8ICAgIDMgKy0KIFdlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnNldHRpbmdzLmggICAgICAgICAgICAgIHwgICAgMyArLQogV2ViS2l0L21hYy9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysrKysrCiBXZWJL aXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwog V2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oICAgICAgICAgfCAgICAz ICstCiBXZWJLaXQvcXQvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgMTIgKysrKysrKysKIC4uLi9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBv cnRRdC5jcHAgIHwgICAgMiArCiBXZWJLaXQvd2luL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTEgKysrKysrKwogV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQ cmVmZXJlbmNlcy5pZGwgICAgICAgICAgfCAgICAzICstCiBXZWJLaXRUb29scy9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTggKysrKysrKysrKysrCiAuLi4vY2hy b21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwICAgICAgICAgICAgICB8ICAgIDMgKysKIC4u Li9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIHwgICAgNCAr Ky0KIC4uLi9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gIHwg ICAgNCArKy0KIC4uLi9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4u Y3BwIHwgICAgNCArKy0KIDIxIGZpbGVzIGNoYW5nZWQsIDE1MiBpbnNlcnRpb25zKCspLCAxNyBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGI0NWI2NWIuLmE3NzVjNTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMTAtMTAtMjgg IEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZWVkcyBhICJMaW51eEVkaXRpbmdCZWhhdmlvciIs IHBlcmhhcHMgd2l0aCBhIGJldHRlciBuYW1lCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNworCisgICAgICAgIEFkZGVkIEVkaXRpbmdVbml4QmVo YXZpb3IgZWRpdGluZyB0eXBlIGFpbSB0byBjb3ZlciB0aGUgY2FzZXMgd2hlbgorICAgICAgICBu ZWl0aGVyIE1hYyBvciBXaW5kb3dzIGJlaGF2aW9ycyBhcmUgYXBwcm9wcmlhdGVkLgorCisgICAg ICAgIEl0IHdhcyBkZWNpZGVkIHRvIG5hbWUgaXQgVW5peCBub3QgTGludXguCisKKyAgICAgICAg Tm8gbmV3IHRlc3RzLiBUaGUgY3VycmVudCBlZGl0aW5nIHRlc3RzIHRoYXQgaW52b2x2ZSBwbGF0 Zm9ybSBzcGVjaWZpYworICAgICAgICBiYWhhdmlvcnMgYXJlIGNvZGVkIHNvIHRoYXQgdGhleSBn byB0aHJvdWdoIGFsbCBlZGl0aW5nIGJlaGF2aW9yCisgICAgICAgIHR5cGVzIHBvc3NpYmxlLiBU aGVyZSB3aWxsIGJlIGEgZm9sbG93IHVwIGJ1ZyB3aGVyZSBhbGwgb2YgdGhlbSB3aWxsCisgICAg ICAgIGJlIHVwZGF0ZWQgdG8gaW5jbHVkZSB0aGUgbmV3IGVkaXRpbmcgYmVoYXZpb3IgKCJ1bml4 IikuCisKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6CisgICAgICAg ICogcGFnZS9TZXR0aW5ncy5jcHA6CisgICAgICAgIChXZWJDb3JlOjplZGl0aW5nQmVoYXZpb3JU eXBlRm9yUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OlNldHRpbmdzKToK KwogMjAxMC0xMC0yNyAgRXJpYyBVaHJoYW5lICA8ZXJpY3VAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERhdmlkIExldmluLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5n L0VkaXRpbmdCZWhhdmlvclR5cGVzLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9y VHlwZXMuaAppbmRleCAyNmJhMThlLi4xMTM0NWRhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0Jl aGF2aW9yVHlwZXMuaApAQCAtMzgsNyArMzgsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAvLyBp ZiBwb3NzaWJsZSBpbiB0aGUgZnV0dXJlLgogZW51bSBFZGl0aW5nQmVoYXZpb3JUeXBlIHsKICAg ICBFZGl0aW5nTWFjQmVoYXZpb3IsCi0gICAgRWRpdGluZ1dpbmRvd3NCZWhhdmlvcgorICAgIEVk aXRpbmdXaW5kb3dzQmVoYXZpb3IsCisgICAgRWRpdGluZ1VuaXhCZWhhdmlvcgogfTsKIAogfSAv LyBXZWJDb3JlIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cCBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggZmFjMzViZS4uMTQwNjFkNCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuY3BwCkBAIC02NCw2ICs2NCwyNyBAQCBib29sIFNldHRpbmdzOjpnU2hvdWxkUGFpbnRO YXRpdmVDb250cm9scyA9IHRydWU7CiBib29sIFNldHRpbmdzOjpnU2hvdWxkVXNlSGlnaFJlc29s dXRpb25UaW1lcnMgPSB0cnVlOwogI2VuZGlmCiAKKy8vIE5PVEVzCisvLyAgMSkgRWRpdGluZ01h Y0JlaGF2aW9yIGNvbXByaXNlcyBUaWdlciwgTGVvcGFyZCwgU25vd0xlb3BhcmQgYW5kIGlPUyBi dWlsZHMsIGFzIHdlbGwgUXRXZWJLaXQgYW5kIENocm9taXVtIHdoZW4gYnVpbHQgb24gTWFjOwor Ly8gIDIpIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IgY29tcHJpc2VzIFdpbjMyIGFuZCBXaW5DRSBi dWlsZHMsIGFzIHdlbGwgYXMgUXRXZWJLaXQgYW5kIENocm9taXVtIHdoZW4gYnVpbHQgb24gV2lu ZG93czsKKy8vICAzKSBFZGl0aW5nVW5peEJlaGF2aW9yIGNvbXByaXNlcyBhbGwgdW5peC1iYXNl ZCBzeXN0ZW1zLCBidXQgRGFyd2luL01hY09TIChhbmQgdGhlbiBhYnVzaW5nIHRoZSB0ZXJtaW5v bG9neSk7CisvLyA5OSkgTWFjRWRpdGluZ0JlaGF2aW9yIGlzIHVzZWQgYSBmYWxsYmFjay4KK3N0 YXRpYyBFZGl0aW5nQmVoYXZpb3JUeXBlIGVkaXRpbmdCZWhhdmlvclR5cGVGb3JQbGF0Zm9ybSgp Cit7CisgICAgcmV0dXJuCisjaWYgT1MoREFSV0lOKQorICAgIEVkaXRpbmdNYWNCZWhhdmlvcgor I2VsaWYgT1MoV0lORE9XUykKKyAgICBFZGl0aW5nV2luZG93c0JlaGF2aW9yCisjZWxpZiBPUyhV TklYKQorICAgIEVkaXRpbmdVbml4QmVoYXZpb3IKKyNlbHNlCisgICAgLy8gRmFsbGJhY2sKKyAg ICBFZGl0aW5nTWFjQmVoYXZpb3IKKyNlbmRpZgorICAgIDsKK30KKwogU2V0dGluZ3M6OlNldHRp bmdzKFBhZ2UqIHBhZ2UpCiAgICAgOiBtX3BhZ2UocGFnZSkKICAgICAsIG1fZWRpdGFibGVMaW5r QmVoYXZpb3IoRWRpdGFibGVMaW5rRGVmYXVsdEJlaGF2aW9yKQpAQCAtMTIwLDE0ICsxNDEsNyBA QCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSogcGFnZSkKICAgICAsIG1fZW5mb3JjZUNTU01JTUVU eXBlSW5Ob1F1aXJrc01vZGUodHJ1ZSkKICAgICAsIG1fdXNlc0VuY29kaW5nRGV0ZWN0b3IoZmFs c2UpCiAgICAgLCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGZhbHNlKQotICAgICwgbV9l ZGl0aW5nQmVoYXZpb3JUeXBlKAotI2lmIFBMQVRGT1JNKE1BQykgfHwgKFBMQVRGT1JNKENIUk9N SVVNKSAmJiBPUyhEQVJXSU4pKQotICAgICAgICAvLyAoUExBVEZPUk0oTUFDKSBpcyBhbHdheXMg ZmFsc2UgaW4gQ2hyb21pdW0sIGhlbmNlIHRoZSBleHRyYSBjb25kaXRpb24uKQotICAgICAgICBF ZGl0aW5nTWFjQmVoYXZpb3IKLSNlbHNlCi0gICAgICAgIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IK LSNlbmRpZgotICAgICAgICApCisgICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5cGUoZWRpdGluZ0Jl aGF2aW9yVHlwZUZvclBsYXRmb3JtKCkpCiAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHJlYWxs eSBiZSBkaXNhYmxlZCBieSBkZWZhdWx0IGFzIGl0IG1ha2VzIHBsYXRmb3JtcyB0aGF0IGRvbid0 IHN1cHBvcnQgdGhlIGZlYXR1cmUgZG93bmxvYWQgZmlsZXMKICAgICAvLyB0aGV5IGNhbid0IHVz ZSBieS4gTGVhdmluZyBlbmFibGVkIGZvciBub3cgdG8gbm90IGNoYW5nZSBleGlzdGluZyBiZWhh dmlvci4KICAgICAsIG1fZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKHRydWUpCmRpZmYg LS1naXQgYS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwppbmRleCBhMmQ3NTI5Li5mMzM2ZGE4IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCisrKyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBA QAorMjAxMC0xMC0yOCAgQW50b25pbyBHb21lcyAgPGFnb21lc0ByaW0uY29tPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5lZWRzIGEgIkxpbnV4RWRp dGluZ0JlaGF2aW9yIiwgcGVyaGFwcyB3aXRoIGEgYmV0dGVyIG5hbWUKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM2NjI3CisKKyAgICAgICAgQWRkZWQg dGhlIGNvcnJlc3BvbmRpbmcgQ2hyb21pdW0gc2V0dGluZyB0byBXZWJDb3JlJ3MgRWRpdGluZ1Vu aXhCZWhhdmlvcjogRWRpdGluZ0JlaGF2aW9yVW5peC4KKworICAgICAgICAqIHB1YmxpYy9XZWJT ZXR0aW5ncy5oOgorICAgICAgICAqIHNyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcDoKKwogMjAx MC0xMC0yNyAgRXJpYyBVaHJoYW5lICA8ZXJpY3VAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IERhdmlkIExldmluLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1Ymxp Yy9XZWJTZXR0aW5ncy5oIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oCmlu ZGV4IDZhMzdlMDguLjQ2OWRiMDUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViU2V0dGluZ3MuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlNldHRpbmdzLmgK QEAgLTQ1LDcgKzQ1LDggQEAgY2xhc3MgV2ViU2V0dGluZ3MgewogcHVibGljOgogICAgIGVudW0g RWRpdGluZ0JlaGF2aW9yIHsKICAgICAgICAgRWRpdGluZ0JlaGF2aW9yTWFjLAotICAgICAgICBF ZGl0aW5nQmVoYXZpb3JXaW4KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yV2luLAorICAgICAgICBF ZGl0aW5nQmVoYXZpb3JVbml4CiAgICAgfTsKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRTdGFuZGFy ZEZvbnRGYW1pbHkoY29uc3QgV2ViU3RyaW5nJikgPSAwOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2No cm9taXVtL3NyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv QXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHAKaW5kZXggYzZhYjg1YS4uM2ZmZmQ2MCAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMuY3BwCkBAIC0zNDQsNiArMzQ0LDcg QEAgQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJTY3JvbGxiYXI6OlNjcm9sbEJ5UGl4 ZWwsIFNjcm9sbEJ5UGl4ZWwpOwogCiBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNl dHRpbmdzOjpFZGl0aW5nQmVoYXZpb3JNYWMsIEVkaXRpbmdNYWNCZWhhdmlvcik7CiBDT01QSUxF X0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNldHRpbmdzOjpFZGl0aW5nQmVoYXZpb3JXaW4sIEVk aXRpbmdXaW5kb3dzQmVoYXZpb3IpOworQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJT ZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yVW5peCwgRWRpdGluZ1VuaXhCZWhhdmlvcik7CiAKIENP TVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViVGV4dEFmZmluaXR5VXBzdHJlYW0sIFVQU1RS RUFNKTsKIENPTVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViVGV4dEFmZmluaXR5RG93bnN0 cmVhbSwgRE9XTlNUUkVBTSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dl YktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDU3YzNlMjcuLjkzOWRjY2UgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTYgQEAKKzIwMTAtMTAtMjggIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZWVkcyBhICJMaW51 eEVkaXRpbmdCZWhhdmlvciIsIHBlcmhhcHMgd2l0aCBhIGJldHRlciBuYW1lCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNworCisJCUFkZGVkIHRo ZSBjb3JyZXNwb25kaW5nIEdUSysgc2V0dGluZyB0byBXZWJDb3JlJ3MgRWRpdGluZ1VuaXhCZWhh dmlvcjogV0VCS0lUX0VESVRJTkdfQkVIQVZJT1JfVU5JWC4KKworICAgICAgICAqIHdlYmtpdC93 ZWJraXR3ZWJzZXR0aW5ncy5jcHA6CisgICAgICAgICh3ZWJraXRfd2ViX3NldHRpbmdzX2NsYXNz X2luaXQpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oOgorCiAyMDEwLTEw LTI3ICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBNYXJ0aW4gUm9iaW5zb24uCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJz ZXR0aW5ncy5jcHAKaW5kZXggY2Q1OWJkYi4uMjY2MWI4MiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnNldHRpbmdzLmNwcApAQCAtNjg5LDYgKzY4OSw3IEBAIHN0YXRpYyB2b2lkIHdlYmtp dF93ZWJfc2V0dGluZ3NfY2xhc3NfaW5pdChXZWJLaXRXZWJTZXR0aW5nc0NsYXNzKiBrbGFzcykK IAogICAgIENPTVBJTEVfQVNTRVJUKHN0YXRpY19jYXN0PGludD4oV0VCS0lUX0VESVRJTkdfQkVI QVZJT1JfTUFDKSA9PSBzdGF0aWNfY2FzdDxpbnQ+KFdlYkNvcmU6OkVkaXRpbmdNYWNCZWhhdmlv ciksIGVkaXRpbmdfYmVoYXZpb3JfdHlwZV9tYWNfbWF0Y2gpOwogICAgIENPTVBJTEVfQVNTRVJU KHN0YXRpY19jYXN0PGludD4oV0VCS0lUX0VESVRJTkdfQkVIQVZJT1JfV0lORE9XUykgPT0gc3Rh dGljX2Nhc3Q8aW50PihXZWJDb3JlOjpFZGl0aW5nV2luZG93c0JlaGF2aW9yKSwgZWRpdGluZ19i ZWhhdmlvcl90eXBlX3dpbmRvd3NfbWF0Y2gpOworICAgIENPTVBJTEVfQVNTRVJUKHN0YXRpY19j YXN0PGludD4oV0VCS0lUX0VESVRJTkdfQkVIQVZJT1JfVU5JWCkgPT0gc3RhdGljX2Nhc3Q8aW50 PihXZWJDb3JlOjpFZGl0aW5nVW5peEJlaGF2aW9yKSwgZWRpdGluZ19iZWhhdmlvcl90eXBlX3Vu aXhfbWF0Y2gpOwogCiAgICAgLyoqCiAgICAgKiBXZWJLaXRXZWJTZXR0aW5nczplZGl0aW5nLWJl aGF2aW9yCkBAIC03MTMsNyArNzE0LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl9zZXR0aW5n c19jbGFzc19pbml0KFdlYktpdFdlYlNldHRpbmdzQ2xhc3MqIGtsYXNzKQogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiRWRpdGluZyBiZWhh dmlvciIpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXygiVGhlIGJlaGF2aW9yIG1vZGUgdG8gdXNlIGluIGVkaXRpbmcgbW9kZSIpLAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lU X1RZUEVfRURJVElOR19CRUhBVklPUiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX01BQywKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9F RElUSU5HX0JFSEFWSU9SX1VOSVgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBmbGFncykpOwogCiAgICAgLyoqCmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vic2V0dGluZ3MuaAppbmRleCBkOGRhZmQ5Li5lZWUwZDA0IDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHdlYnNldHRpbmdzLmgKQEAgLTM2LDcgKzM2LDggQEAgR19CRUdJTl9ERUNMUwogCiB0 eXBlZGVmIGVudW0gewogICAgIFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX01BQywKLSAgICBXRUJL SVRfRURJVElOR19CRUhBVklPUl9XSU5ET1dTCisgICAgV0VCS0lUX0VESVRJTkdfQkVIQVZJT1Jf V0lORE9XUywKKyAgICBXRUJLSVRfRURJVElOR19CRUhBVklPUl9VTklYCiB9IFdlYktpdEVkaXRp bmdCZWhhdmlvcjsKIAogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYlNldHRpbmdzUHJpdmF0ZSBX ZWJLaXRXZWJTZXR0aW5nc1ByaXZhdGU7CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxv ZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IGQ1OGRmNzguLjQzZDg5M2MgMTAwNjQ0Ci0t LSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMTAtMTAtMjggIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZWVkcyBh ICJMaW51eEVkaXRpbmdCZWhhdmlvciIsIHBlcmhhcHMgd2l0aCBhIGJldHRlciBuYW1lCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNworCisJCUFk ZGVkIHRoZSBjb3JyZXNwb25kaW5nIEdUSysgc2V0dGluZyB0byBXZWJDb3JlJ3MgRWRpdGluZ1Vu aXhCZWhhdmlvcjogV2ViS2l0RWRpdGluZ1VuaXhCZWhhdmlvci4KKworICAgICAgICAqIFdlYlZp ZXcvV2ViRnJhbWUubW06CisgICAgICAgIChjb3JlKToKKyAgICAgICAgKiBXZWJWaWV3L1dlYlBy ZWZlcmVuY2VzUHJpdmF0ZS5oOgorCiAyMDEwLTEwLTI3ICBQcmF0aWsgU29sYW5raSAgPHBzb2xh bmtpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAt LWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbSBiL1dlYktpdC9tYWMvV2ViVmll dy9XZWJGcmFtZS5tbQppbmRleCA0ZjhjMWJhLi5kN2RiNWEyIDEwMDY0NAotLS0gYS9XZWJLaXQv bWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l Lm1tCkBAIC0yMDMsNiArMjAzLDggQEAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3Jl KFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKICAgICAgICAgICAgIHJldHVybiBXZWJD b3JlOjpFZGl0aW5nTWFjQmVoYXZpb3I7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ1dpbkJl aGF2aW9yOgogICAgICAgICAgICAgcmV0dXJuIFdlYkNvcmU6OkVkaXRpbmdXaW5kb3dzQmVoYXZp b3I7CisgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ1VuaXhCZWhhdmlvcjoKKyAgICAgICAgICAg IHJldHVybiBXZWJDb3JlOjpFZGl0aW5nVW5peEJlaGF2aW9yOwogICAgIH0KICAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsKICAgICByZXR1cm4gV2ViQ29yZTo6RWRpdGluZ01hY0JlaGF2aW9yOwpk aWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oIGIv V2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCmluZGV4IDQ3ZTZkNzEu LmFlOTNkYjEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1By aXZhdGUuaAorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgK QEAgLTQ1LDcgKzQ1LDggQEAgdHlwZWRlZiBlbnVtIHsKIAogdHlwZWRlZiBlbnVtIHsKICAgICBX ZWJLaXRFZGl0aW5nTWFjQmVoYXZpb3IsCi0gICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yCisg ICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yLAorICAgIFdlYktpdEVkaXRpbmdVbml4QmVoYXZp b3IKIH0gV2ViS2l0RWRpdGluZ0JlaGF2aW9yOwogCiBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZl cmVuY2VzQ2hhbmdlZE5vdGlmaWNhdGlvbjsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VM b2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDM4OWY4NjQuLmQ1MGE3YmEgMTAwNjQ0Ci0t LSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE1IEBACisyMDEwLTEwLTI4ICBBbnRvbmlvIEdvbWVzICA8YWdvbWVzQHJpbS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTmVlZHMgYSAi TGludXhFZGl0aW5nQmVoYXZpb3IiLCBwZXJoYXBzIHdpdGggYSBiZXR0ZXIgbmFtZQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzY2MjcKKworICAgICAg ICBBZGRpbmcgc3VwcG9ydCB0byBRdCdzIERSVFN1cHBvcnQgY2xhc3MgdG8gdGVzdCB0aGUgbmV3 bHkgaW50cm9kdWNlZCBVbml4IGVkaXRpbmcgYmVoYXZpb3IuCisKKyAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHA6CisgICAgICAgIChEdW1wUmVuZGVy VHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0xMC0yNyAgSm9jZWx5 biBUdXJjb3R0ZSAgPGpvY2VseW4udHVyY290dGVAbm9raWEuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0 L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCBiL1dlYktpdC9xdC9X ZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKaW5kZXggNDMwOWU1Yy4u NmExZDUwNiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJU cmVlU3VwcG9ydFF0LmNwcAorKysgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRl clRyZWVTdXBwb3J0UXQuY3BwCkBAIC01NDQsNiArNTQ0LDggQEAgdm9pZCBEdW1wUmVuZGVyVHJl ZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0JlaGF2aW9yKFFXZWJQYWdlKiBwYWdlLCBjb25zdCBRU3Ry aW5nJgogICAgICAgICBjb3JlRWRpdGluZ0JlaGF2aW9yID0gRWRpdGluZ1dpbmRvd3NCZWhhdmlv cjsKICAgICBlbHNlIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIm1hYyIpCiAgICAgICAgIGNvcmVF ZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nTWFjQmVoYXZpb3I7CisgICAgZWxzZSBpZiAoZWRpdGlu Z0JlaGF2aW9yID09ICJ1bml4IikKKyAgICAgICAgY29yZUVkaXRpbmdCZWhhdmlvciA9IEVkaXRp bmdVbml4QmVoYXZpb3I7CiAgICAgZWxzZSB7CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgp OwogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9XZWJLaXQvd2luL0NoYW5nZUxvZyBiL1dl YktpdC93aW4vQ2hhbmdlTG9nCmluZGV4IDM1MzkzYmEuLjI1NmQ1NjMgMTAwNjQ0Ci0tLSBhL1dl YktpdC93aW4vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC93aW4vQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTQgQEAKKzIwMTAtMTAtMjggIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZWVkcyBhICJMaW51 eEVkaXRpbmdCZWhhdmlvciIsIHBlcmhhcHMgd2l0aCBhIGJldHRlciBuYW1lCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNworCisJCUFkZGVkIHRo ZSBjb3JyZXNwb25kaW5nIEdUSysgc2V0dGluZyB0byBXZWJDb3JlJ3MgRWRpdGluZ1VuaXhCZWhh dmlvcjogV2ViS2l0RWRpdGluZ1VuaXhCZWhhdmlvci4KKworICAgICAgICAqIEludGVyZmFjZXMv SVdlYlByZWZlcmVuY2VzLmlkbDoKKwogMjAxMC0xMC0yNiAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxn aGFtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCBidWlsZCBmaXguCmRpZmYgLS1n aXQgYS9XZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzLmlkbCBiL1dlYktpdC93 aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsCmluZGV4IDRmYjNkZTguLmRkN2YyODIg MTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsCisr KyBiL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsCkBAIC00OSw3ICs0 OSw4IEBAIHR5cGVkZWYgZW51bSBXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvciB7CiAKIHR5cGVk ZWYgZW51bSBXZWJLaXRFZGl0aW5nQmVoYXZpb3IgewogICAgIFdlYktpdEVkaXRpbmdNYWNCZWhh dmlvciA9IDAsCi0gICAgV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yCisgICAgV2ViS2l0RWRpdGlu Z1dpbkJlaGF2aW9yLAorICAgIFdlYktpdEVkaXRpbmdVbml4QmVoYXZpb3IKIH0gV2ViS2l0RWRp dGluZ0JlaGF2aW9yOwogCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dl YktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCBlNjcyMTdhLi5lMjkzMDEyIDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMjEgQEAKKzIwMTAtMTAtMjggIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmltLmNvbT4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZWVkcyBhICJM aW51eEVkaXRpbmdCZWhhdmlvciIsIHBlcmhhcHMgd2l0aCBhIGJldHRlciBuYW1lCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyNworCisgICAgICAg IEFkZGluZyBzdXBwb3J0IHRvIE1hYydzLCBHVEsrJ3MsIFdpbmRvd3MnIGFuZCBDaHJvbWl1bSdz IExheW91dFRlc3RDb250cm9sbGVyIGNsYXNzIHRvIHRlc3QgdGhlIG5ld2x5IGludHJvZHVjZWQg VW5peCBlZGl0aW5nIGJlaGF2aW9yLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldEVkaXRpbmdCZWhhdmlvcik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xh eW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjpzZXRFZGl0aW5nQmVoYXZpb3IpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlv dXRUZXN0Q29udHJvbGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRFZGl0aW5nQmVoYXZpb3IpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRU ZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0xMC0yNyAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtp dC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNw cCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9s bGVyLmNwcAppbmRleCAxYTYxODdlLi5mY2RkYzEzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CkBAIC0xNDg2LDYgKzE0ODYsOSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRFZGl0 aW5nQmVoYXZpb3IoY29uc3QgQ3BwQXJndW1lbnRMaXN0JiBhcmd1bWVudHMsCiAgICAgfSBlbHNl IGlmIChrZXkgPT0gIndpbiIpIHsKICAgICAgICAgbV9zaGVsbC0+cHJlZmVyZW5jZXMoKS0+ZWRp dGluZ0JlaGF2aW9yID0gV2ViU2V0dGluZ3M6OkVkaXRpbmdCZWhhdmlvcldpbjsKICAgICAgICAg bV9zaGVsbC0+YXBwbHlQcmVmZXJlbmNlcygpOworICAgIH0gZWxzZSBpZiAoa2V5ID09ICJ1bml4 IikgeworICAgICAgICBtX3NoZWxsLT5wcmVmZXJlbmNlcygpLT5lZGl0aW5nQmVoYXZpb3IgPSBX ZWJTZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yVW5peDsKKyAgICAgICAgbV9zaGVsbC0+YXBwbHlQ cmVmZXJlbmNlcygpOwogICAgIH0gZWxzZQogICAgICAgICBsb2dFcnJvclRvQ29uc29sZSgiUGFz c2VkIGludmFsaWQgZWRpdGluZyBiZWhhdmlvci4gU2hvdWxkIGJlICdtYWMnIG9yICd3aW4nLiIp OwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRl c3RDb250cm9sbGVyR3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlv dXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5kZXggMDRkOTdlYi4uNDM4MGVjOCAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3Rr LmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRy b2xsZXJHdGsuY3BwCkBAIC04MTMsOCArODEzLDEwIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldEVkaXRpbmdCZWhhdmlvcihjb25zdCBjaGFyKiBlZGl0aW5nQmVoYXZpb3IpCiAKICAg ICBpZiAoIXN0cmNtcChlZGl0aW5nQmVoYXZpb3IsICJ3aW4iKSkKICAgICAgICAgZ19vYmplY3Rf c2V0KEdfT0JKRUNUKHNldHRpbmdzKSwgImVkaXRpbmctYmVoYXZpb3IiLCBXRUJLSVRfRURJVElO R19CRUhBVklPUl9XSU5ET1dTLCBOVUxMKTsKLSAgICBpZiAoIXN0cmNtcChlZGl0aW5nQmVoYXZp b3IsICJtYWMiKSkKKyAgICBlbHNlIGlmICghc3RyY21wKGVkaXRpbmdCZWhhdmlvciwgIm1hYyIp KQogICAgICAgICBnX29iamVjdF9zZXQoR19PQkpFQ1Qoc2V0dGluZ3MpLCAiZWRpdGluZy1iZWhh dmlvciIsIFdFQktJVF9FRElUSU5HX0JFSEFWSU9SX01BQywgTlVMTCk7CisgICAgZWxzZSBpZiAo IXN0cmNtcChlZGl0aW5nQmVoYXZpb3IsICJ1bml4IikpCisgICAgICAgIGdfb2JqZWN0X3NldChH X09CSkVDVChzZXR0aW5ncyksICJlZGl0aW5nLWJlaGF2aW9yIiwgV0VCS0lUX0VESVRJTkdfQkVI QVZJT1JfVU5JWCwgTlVMTCk7CiB9CiAKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmFib3J0 TW9kYWwoKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91 dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xh eW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGM1ZDVhOTAuLmVmYTMzYWEgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1h Yy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRy b2xsZXJNYWMubW0KQEAgLTkzNSw4ICs5MzUsMTAgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0RWRpdGluZ0JlaGF2aW9yKGNvbnN0IGNoYXIqIGVkaXRpbmdCZWhhdmlvcikKICAgICBO U1N0cmluZyogZWRpdGluZ0JlaGF2aW9yTlMgPSBbW05TU3RyaW5nIGFsbG9jXSBpbml0V2l0aFVU RjhTdHJpbmc6ZWRpdGluZ0JlaGF2aW9yXTsKICAgICBpZiAoW2VkaXRpbmdCZWhhdmlvck5TIGlz RXF1YWxUb1N0cmluZzpAIm1hYyJdKQogICAgICAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJk UHJlZmVyZW5jZXNdIHNldEVkaXRpbmdCZWhhdmlvcjpXZWJLaXRFZGl0aW5nTWFjQmVoYXZpb3Jd OwotICAgIGlmIChbZWRpdGluZ0JlaGF2aW9yTlMgaXNFcXVhbFRvU3RyaW5nOkAid2luIl0pCisg ICAgZWxzZSBpZiAoW2VkaXRpbmdCZWhhdmlvck5TIGlzRXF1YWxUb1N0cmluZzpAIndpbiJdKQog ICAgICAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5jZXNdIHNldEVkaXRpbmdC ZWhhdmlvcjpXZWJLaXRFZGl0aW5nV2luQmVoYXZpb3JdOworICAgIGVsc2UgaWYgKFtlZGl0aW5n QmVoYXZpb3JOUyBpc0VxdWFsVG9TdHJpbmc6QCJ1bml4Il0pCisgICAgICAgIFtbV2ViUHJlZmVy ZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0RWRpdGluZ0JlaGF2aW9yOldlYktpdEVkaXRp bmdVbml4QmVoYXZpb3JdOwogICAgIFtlZGl0aW5nQmVoYXZpb3JOUyByZWxlYXNlXTsKIH0KIApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250 cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0 Q29udHJvbGxlcldpbi5jcHAKaW5kZXggOWU4ZWQxZS4uNGNmNDJkOCAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCkBAIC0xMzgzLDggKzEzODMsMTAgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c2V0RWRpdGluZ0JlaGF2aW9yKGNvbnN0IGNoYXIqIGVkaXRpbmdCZWhhdmlvcikKICAgICBzdHJp bmcgYmVoYXZpb3JTdHJpbmcoZWRpdGluZ0JlaGF2aW9yKTsKICAgICBpZiAoYmVoYXZpb3JTdHJp bmcgPT0gIm1hYyIpCiAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRFZGl0aW5nQmVoYXZpb3IoV2Vi S2l0RWRpdGluZ01hY0JlaGF2aW9yKTsKLSAgICBpZiAoYmVoYXZpb3JTdHJpbmcgPT0gIndpbiIp CisgICAgZWxzZSBpZiAoYmVoYXZpb3JTdHJpbmcgPT0gIndpbiIpCiAgICAgICAgIHByZWZlcmVu Y2VzLT5zZXRFZGl0aW5nQmVoYXZpb3IoV2ViS2l0RWRpdGluZ1dpbkJlaGF2aW9yKTsKKyAgICBl bHNlIGlmIChiZWhhdmlvclN0cmluZyA9PSAidW5peCIpCisgICAgICAgIHByZWZlcmVuY2VzLT5z ZXRFZGl0aW5nQmVoYXZpb3IoV2ViS2l0RWRpdGluZ1VuaXhCZWhhdmlvcik7CiB9CiAKIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OmFib3J0TW9kYWwoKQotLSAKMS43LjEKCg==