39854 2010-05-27 14:19:59 -0700 Refactor platform dependent editing behavior code out of Settings 2010-07-09 14:39:05 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) PC All RESOLVED FIXED P2 Normal --- 36627 41975 41976 41977 41989 1 tonikitoo tonikitoo abarth christian darin dglazkov eric evan mrobinson ojan ossy robert tonikitoo webkit-ews webkit.review.bot xan.lopez oldest_to_newest 231463 0 tonikitoo 2010-05-27 14:19:59 -0700 ... as discussed suggested by Darin and Ojan in bug 36627 "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." +++ This bug was initially created as a clone of Bug #36627 +++ 231469 1 57277 tonikitoo 2010-05-27 14:39:56 -0700 Created attachment 57277 wip - first materialization of the idea A quick prototype of the idea we discussed. Basically, it adds a EditorSettings class, also owned by Page. The idea is to gradually move all EditingBehavior stuff in Settings to this new EditorSettings class, and change callsites of Settings::editorBehavior() to use the methods we add into this class. I've showed how it is going to happen in the RenderBlock case, for now. (please ignore the method name) Darin, Ojan, could you please validate that before I go on? 231481 2 57277 ojan 2010-05-27 15:27:42 -0700 Comment on attachment 57277 wip - first materialization of the idea This is close to what I had in mind. Except I was picturing EditingBehavior that is a member of Settings. There's a lot of plumbing to get at Settings (e.g. Frame and Document already have settings methods). Actually, I was originally picturing something more like WebCore/editing/htmlediting.h, but the fact that the behavior is runtime settable means we can't just use a bunch of helper functions like that. I think we probably don't need the cpp file though. These methods should all be really dumb if-statements that check the editing behavior and return booleans. That's all nit-picking though. What you have seems fine to me. I defer to darin here though. 231482 3 darin 2010-05-27 15:29:22 -0700 I originally had imagined an enum and functions that took that enum as an argument. A class is OK too, but I don't think it needs to be mutable. Instead the constructor can take an argument of the behavior, and to change it you can just replace the object with an entirely new one. There's no need to ever take a pointer to one of these. 231485 4 ojan 2010-05-27 15:32:11 -0700 (In reply to comment #3) > A class is OK too, but I don't think it needs to be mutable. Instead the constructor can take an argument of the behavior, and to change it you can just replace the object with an entirely new one. There's no need to ever take a pointer to one of these. I don't feel strongly, but this sounds best to me. 231720 5 57331 tonikitoo 2010-05-28 08:38:00 -0700 Created attachment 57331 wip - second prototype of the idea > I think we probably don't need the cpp file though. These methods should all > be really dumb if-statements that check the editing behavior and return > booleans. Not using dedicated .cpp/.h files for the class anymore. Instead it is not a private class of Settings and it is now called EditingBehaviorController > A class is OK too, but I don't think it needs to be mutable. Instead the constructor can take an argument of the behavior, and to change it you can just replace the object with an entirely new one. There's no need to ever take a pointer to one of these. Ok, also made it not mutable: wheneven Settings::setEditingBehavior(EditingBehavior) is called, a new Object is created on the stack. In this design, for each specific editing behavior there would be a method in Settings and a correspondent method in EditingBehaviorController. The former returns a forward the call of the latter. The changes in RenderBlock is still shown as an example call site. What do you think? 231729 6 darin 2010-05-28 08:51:22 -0700 (In reply to comment #5) > In this design, for each specific editing behavior there would be a method in Settings and a correspondent method in EditingBehaviorController. The former returns a forward the call of the latter. General idea looks good, but I think this is something to be avoided. We don't want to have to add two functions every time we add a new editing behavior. I suggest making the "controller" class public, and in fact the class itself could be in a separate header file and not be a member of settings. There should be a getter on the Settings class that returns it with a short name. Then you can say: settings->editing().shouldMoveCaretToBoundary() The only part I'm not sure of is what the optimal name for EditingBehaviorController and Settings::editing() are. I think the object represents editing behavior details, interpretation, or policy. Controller might be an OK term too. For the Settings member, the key is brevity. 231730 7 57331 darin 2010-05-28 08:59:25 -0700 Comment on attachment 57331 wip - second prototype of the idea > + bool moveCaretToBoundary = settings && settings->shouldMoveCaretToBoundary(); This will need to have a longer name like: shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom Maybe not that exact name, but one more like it. > - // We hit this case for Mac behavior when the Y coordinate is below the last box. > - ASSERT(!useWindowsBehavior); > + // We hit this case for non Windows behavior when the Y coordinate is below the last box. > + ASSERT(moveCaretToBoundary); I think it's OK, and clearer, for the comment to call this "Mac behavior". It's so annoying that Document::settings() can return 0. Maybe we should have a getter on Document that returns the editing behavior directly instead of always having to go via settings. 231750 8 ojan 2010-05-28 09:55:14 -0700 (In reply to comment #7) > > - // We hit this case for Mac behavior when the Y coordinate is below the last box. > > - ASSERT(!useWindowsBehavior); > > + // We hit this case for non Windows behavior when the Y coordinate is below the last box. > > + ASSERT(moveCaretToBoundary); > > I think it's OK, and clearer, for the comment to call this "Mac behavior". In this specific case, once we add Linux behavior in, it will apply to Mac and Linux. But in that case we could just change "Mac" to "Mac/Linux". > It's so annoying that Document::settings() can return 0. Maybe we should have a getter on Document that returns the editing behavior directly instead of always having to go via settings. This sounds great! The null-checks are super-annoying. 231760 9 darin 2010-05-28 10:12:50 -0700 (In reply to comment #8) > (In reply to comment #7) > > > - // We hit this case for Mac behavior when the Y coordinate is below the last box. > > > - ASSERT(!useWindowsBehavior); > > > + // We hit this case for non Windows behavior when the Y coordinate is below the last box. > > > + ASSERT(moveCaretToBoundary); > > > > I think it's OK, and clearer, for the comment to call this "Mac behavior". > > In this specific case, once we add Linux behavior in, it will apply to Mac and Linux. But in that case we could just change "Mac" to "Mac/Linux". Right, but I think even if the comment says "the Mac behavior" it's OK if it's actually used on more platforms than just Mac. > > It's so annoying that Document::settings() can return 0. Maybe we should have a getter on Document that returns the editing behavior directly instead of always having to go via settings. > > This sounds great! The null-checks are super-annoying. Maybe Editor is the right object to put this on, rather than Document, though. 231795 10 tonikitoo 2010-05-28 11:00:57 -0700 maybe EditingBehaviorController naming the class and EditingBehaviorPolicy naming the enum? 231879 11 tonikitoo 2010-05-28 12:41:23 -0700 Eric suggested something else, which sounds reasonable to me: EditingBehavior (the class) to be very self contained and not even know about Settings and all. <eseidel> anyway if you have EditingBehavior(settings->editingBehavior()) then you can ask nice questions like .shouldIDoAwesomeEditingStuff() <eseidel> EditingBehavior is simply about trying to make the individual code lines not have to make policy decisions about mac vs. linux <eseidel> they ask the question they want, in "plain english" as functions on the EditingBehavior, adn that class maps from the policy enum to a bool for that behavior <eseidel> tonikitoo: so I don't think that SEttings would even know about the new EditingBehavior <eseidel> tonikitoo: it could, but if it does, only to just call EditingBehavior(editingBehavior()) ... we would end up with call sites doing EditingBehavior foo(settings->editingBehavior()); if (foo.shouldXXXYYYZZZ()) { // cool stuff } of course, enum would be renamed to something else to avoid collision. thoughts? ps: it is good that we are putting cards over table, and I am sure we will find out the solution that all would be happy in the end 231882 12 darin 2010-05-28 12:47:41 -0700 > <eseidel> anyway if you have EditingBehavior(settings->editingBehavior()) then you can ask nice questions like .shouldIDoAwesomeEditingStuff() > <eseidel> EditingBehavior is simply about trying to make the individual code lines not have to make policy decisions about mac vs. linux > <eseidel> they ask the question they want, in "plain english" as functions on the EditingBehavior, adn that class maps from the policy enum to a bool for that behavior Sure that's the right concept. I agree with Eric. > <eseidel> tonikitoo: so I don't think that SEttings would even know about the new EditingBehavior > <eseidel> tonikitoo: it could, but if it does, only to just call EditingBehavior(editingBehavior()) > > ... we would end up with call sites doing > > EditingBehavior foo(settings->editingBehavior()); > if (foo.shouldXXXYYYZZZ()) { > // cool stuff > } > > of course, enum would be renamed to something else to avoid collision. > > thoughts? I think if taken literally it will make the code at the call site too wordy. I want something more like this: if (frame->editor()->behavior().shouldFlashCaretNeonWhenTypingOjansName()) And less like this: Settings* settings = document->settings(); if (settings && EditingBehavior(settings->editingBehaviorType()).shouldFlashCaretNeonWhenTypingOjansName()) We could have Settings only know about the enum if we like, but that's not critical. What is critical is that the mapping from enum values to all the functions be in its own header and not mixed in with other stuff. I don't even think all those functions need to be in a class. That style could be like this: Settings* settings = document->settings(); if (settings && shouldFlashCaretNeonWhenTypingOjansName(settings->editingBehavior())) Or this: if (shouldFlashCaretNeonWhenTypingOjansName(frame->editor()->behavior())) 231901 13 ojan 2010-05-28 13:17:27 -0700 (In reply to comment #12) > if (frame->editor()->behavior().shouldFlashCaretNeonWhenTypingOjansName()) > if (shouldFlashCaretNeonWhenTypingOjansName(frame->editor()->behavior())) Either one of these is fine with me. I prefer to avoid the other ones where we need to null-check settings. The latter seems simplest to implement, but I don't really care which of these two we do. Also, can I add this as my own personal easter egg? :) 232244 14 57430 tonikitoo 2010-05-30 20:56:12 -0700 Created attachment 57430 3rd simple design - feedback? Summary: * Implemented it so that call sites will look like the quoted code below: > if (frame->editor()->behavior().shouldFlashCaretNeonWhenTypingOjansName()) > if (shouldFlashCaretNeonWhenTypingOjansName(frame->editor()->behavior())) * Added WebCore/editing/EditingBehavior.{cpp,h} so all editing behavior methods can will be grouped together on their own header. * Implemented it so that Settings class only knows about the enum. * Renamed the enum in Settings from EditingBehavior to EditingBehaviorType, and changed places in WebKit referring to it. 232246 15 57430 tonikitoo 2010-05-30 21:01:09 -0700 Comment on attachment 57430 3rd simple design - feedback? err ... wrong file :(, sorry for bug spamming 232247 16 57431 tonikitoo 2010-05-30 21:02:05 -0700 Created attachment 57431 3rd simple design (right file) - feedback? 232248 17 57430 darin 2010-05-30 21:02:28 -0700 Comment on attachment 57430 3rd simple design - feedback? > +bool EditingBehavior::shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const > +{ > + if (Settings* settings = settingsForEditor()) > + return settings->editingBehavior() != EditingWindowsBehavior; > + > + return false; > +} We need to write a lot of these functions, so I'd like these to be as streamlined as possible. I suggest a helper function named type() that returns the editing behavior type and then: bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return type() != EditingWindowsBehavior; } And I'd like to see these in the header if possible, since we want these to be easy to read. But I think what we actually want is this: class EditingBehavior { public: EditingBehavior(EditingBehaviorType type) : m_type(type) { } bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return m_type != EditingWindowsBehavior; } private: EditingBehaviorType m_type; } There's no reason for EditingBehavior to have an Editor* in it. 232249 18 tonikitoo 2010-05-30 21:05:46 -0700 (In reply to comment #17) > (From update of attachment 57430 [details]) > > +bool EditingBehavior::shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const > > +{ > > + if (Settings* settings = settingsForEditor()) > > + return settings->editingBehavior() != EditingWindowsBehavior; > > + > > + return false; > > +} > > We need to write a lot of these functions, so I'd like these to be as streamlined as possible. I suggest a helper function named type() that returns the editing behavior type and then: > > bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return type() != EditingWindowsBehavior; } > > And I'd like to see these in the header if possible, since we want these to be easy to read. > > But I think what we actually want is this: > > class EditingBehavior { > public: > EditingBehavior(EditingBehaviorType type) : m_type(type) { } > > bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return m_type != EditingWindowsBehavior; } > > private: > EditingBehaviorType m_type; > } > > There's no reason for EditingBehavior to have an Editor* in it. darin, I uploaded a wrong file. could you re-check the later, please? Or your comments remain the same for that new one? 232252 19 darin 2010-05-30 21:19:38 -0700 (In reply to comment #18) > darin, I uploaded a wrong file. could you re-check the later, please? Or your comments remain the same for that new one? The same comments apply to the new one, but about Settings* rather than Editor*. 232253 20 darin 2010-05-30 21:21:09 -0700 In Settings: void setEditingBehaviorType(EditingBehaviorType type) { m_editingBehaviorType = type; } EditingBehavior editingBehavior() const { return static_cast<EditingBehaviorType>(m_editingBehavior); } Note that the getter returns EditingBehavior, not EditingBehaviorType. That's where the "magic" happens. 232377 21 57468 tonikitoo 2010-05-31 08:17:24 -0700 Created attachment 57468 4th try - feedback? Summary: * Renamed EditingBehavior enum in Settings to EditingBehaviorType * Added EditingBehavior class, living in WebCore/editing/EditingBehavior.h . It does not know about external classes but EditingBehaviorType * Settings now has: - a setter for the EditingBehaviorType: setEditingBehaviorType(EditingBehaviorType) - a getter for the EditinbeBehavior, based on the type: EditingBehavior editingBehavior() * Call sites in WebKit/ adjusted to work with the above changes. * Editor.cpp has a behavior() getter, relying on Settings' editingBehavior method. * Call sites will look like: if (frame->editor()->behavior().shouldThisDesignBeUsed_questionMark())) /// do xxx 232422 22 57468 darin 2010-05-31 09:36:23 -0700 Comment on attachment 57468 4th try - feedback? > +#ifndef EditingBehavior_h > +#define EditingBehavior_h > + > +#include "Settings.h" It seems shame to have to have EditingBehavior.h include the whole Settings.h file just to get the definition of the EditingBehaviorType enum. I would put that enum into its own file. > + // Platform variant editing behavior methods. I would not call these "methods" and nor would I use the phrase them "platform variant". I would say something more like: // Individual functions for each case where we have more than one style of editing behavior. // Create a new function for any platform difference so we can control it here. My comment isn't perfect either, but I think it may be a bit easier to understand. > +} // namspace WebCore Typo "namspace". > + EditingBehavior editingBehavior() const; Since we have an Editor function that returns EditingBehavior, we could make this Settings function just return EditingBehaviorType and make it so that Settings doesn't know anything about EditingBehavior at all. > --- a/WebCore/rendering/RenderBlock.cpp > +++ b/WebCore/rendering/RenderBlock.cpp > @@ -19,16 +19,17 @@ > * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, > * Boston, MA 02110-1301, USA. > */ > > #include "config.h" > #include "RenderBlock.h" > > #include "Document.h" > +#include "EditingBehavior.h" This include is not needed because Editor.h takes care of it already. Otherwise this looks great to me. 232518 23 57495 tonikitoo 2010-05-31 14:33:36 -0700 Created attachment 57495 patch v1 - functional * Addresses Darin's previously requests for feedback{1,2,3,4} Summary: * EditingBehavior enum renamed to EditingBehaviorTypes and move out to editing/EditingBehaviorTypes.h - Also done with changes needed in WebKit/ due to the enum change. * EditingBehavior class added. It is not to be directly instantiated, but rather accessed via Editor::behavior() getter. - Settings class will only know about the EditingBehaviorTypes enum, not about EditingBehavior class - EditingBehavior will only know about the EditingBehaviorTypes enum, not about Settings or Editor. * All existing Settings::defaultBehavior() == Editing{Mac,Windows}Behavior changed to call methods in EditingBehavior class - (please review the methods names, I am open to suggestions). * Added new files to the build various sytems (hope I did not miss any). 232519 24 webkit.review.bot 2010-05-31 14:38:41 -0700 Attachment 57495 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebCore/editing/EditingBehaviorTypes.h:39: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 in 29 files If any of these errors are false positives, please file a bug against check-webkit-style. 232526 25 webkit.review.bot 2010-05-31 15:25:25 -0700 Attachment 57495 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/2805024 232552 26 57502 tonikitoo 2010-05-31 17:49:00 -0700 Created attachment 57502 patch v2 Same patch as patch 57495 (see comment #23 for a summary), but includes a fix for Chromium-linux build (in comment #25) and style nit in comment #24. As for the Mac build, I can not see the error log, and it gets hard to fix, but I will fix at office tomorrow. Apart from that, patch is ready for review. 232732 27 57540 tonikitoo 2010-06-01 07:04:22 -0700 Created attachment 57540 patch v2.1 - same as v2, but builds on Mac Same as patch 57502, but builds on Mac. See comment #26 232774 28 57550 tonikitoo 2010-06-01 08:56:12 -0700 Created attachment 57550 patch v2.2 - same as v2, but really builds on Mac err. I missed settings it as private header. see comment #23 for summary. 232866 29 57550 darin 2010-06-01 11:27:50 -0700 Comment on attachment 57550 patch v2.2 - same as v2, but really builds on Mac Patch is great. What we need to work on are the names of the behaviors. For each one, we should write a plain language sentence or paragraph describing the behavior and then summarize that for the name of the function. > + bool shouldConsiderStylePresentOnlyIfThroughoutTheSelection() const { return m_type != EditingMacBehavior; } I think this name is a little vague. What this controls is style-toggling behavior. It doesn't affect other "is style present" situations, such as when to check the "Bold" menu item in an application. Does it? > + bool shouldExtendSelectionFromEndPointAlways() const { return m_type != EditingMacBehavior; } This name is too broad. It controls only shift-click behavior, not selection extension that's done with shift-arrow-keys for example. > + bool shouldKeybardSelectionExtendForHorizontalNavigation() const { return m_type == EditingMacBehavior; } What does "extend for horizontal navigation" mean? This one needs work. > + bool shouldGrowSelectionWhenExtendingToBoundary() const { return m_type == EditingMacBehavior; } If you don't grow the selection when extending to a boundary, what do you do? Shrink the selection? 232972 30 57550 ojan 2010-06-01 15:45:33 -0700 Comment on attachment 57550 patch v2.2 - same as v2, but really builds on Mac WebCore/editing/Editor.cpp:104 + if (!m_frame || !m_frame->page() || !m_frame->settings()) Do you need to null check page here? Looks like m_frame and settings should be sufficient. WebCore/editing/EditingBehavior.h:43 + bool shouldKeybardSelectionExtendForHorizontalNavigation() const { return m_type == EditingMacBehavior; } typo: Keybard 233020 31 57550 tonikitoo 2010-06-01 18:34:53 -0700 Comment on attachment 57550 patch v2.2 - same as v2, but really builds on Mac Removing the review flag for now based on current not-so-good names patch comes up with. I will work on each method naming by deeply understanding what exactly it tries to work around by looking at the original commits that introduced it. help welcome. 233562 32 darin 2010-06-02 19:02:00 -0700 We can land the patch with names for the ones we have good names for, and then add more incrementally. They don't all have to change at once. 233777 33 tonikitoo 2010-06-03 08:57:13 -0700 (In reply to comment #32) > We can land the patch with names for the ones we have good names for, and then add more incrementally. They don't all have to change at once. Ok, Darin. I can prepare it later today (today and tomorrow are holidays in Brazil) 234353 34 tonikitoo 2010-06-04 13:08:09 -0700 > > We can land the patch with names for the ones we have good names for, and then add more incrementally. They don't all have to change at once. > > Ok, Darin. I can prepare it later today (today and tomorrow are holidays in Brazil) ... finally back on it. @darin: you did not commented about these ones: bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { ... } bool shouldCenterAlignWhenSelectionIsRevealed() const { ... } bool shouldConsiderMouseSelectionAsDirectional() const { ... } Do you these are good to go as-are? If so, we could start with them, and incrementally working on the missing ones. 234382 35 57916 tonikitoo 2010-06-04 14:37:33 -0700 Created attachment 57916 patch v2.3 - part I As per suggestion in comment #32, patch "v2.3 - part I" introduces the following methods to EditingBehavior.h: bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { ... } bool shouldCenterAlignWhenSelectionIsRevealed() const { ... } bool shouldConsiderMouseSelectionAsDirectional() const { ... } Follow up work will replace all remaining calls to Editing{Mac,Windows}Behavior by new functions in EditingBehavior class. remaing ones, currently bad named are: (these are close imo) bool shouldConsiderStylePresentOnlyIfThroughoutTheSelection() const { ... } bool shouldExtendSelectionFromEndPointAlways() const { ... } (these need love) bool shouldKeybardSelectionExtendForHorizontalNavigation() const { ... } bool shouldGrowSelectionWhenExtendingToBoundary() const { ...} 234388 36 57916 tonikitoo 2010-06-04 14:42:20 -0700 Comment on attachment 57916 patch v2.3 - part I wrong patch 234392 37 57919 tonikitoo 2010-06-04 14:44:58 -0700 Created attachment 57919 patch v2.3 - part I (right file) see comment #35 for summary 234992 38 58070 tonikitoo 2010-06-07 12:14:45 -0700 Created attachment 58070 patch v2.3 - part I (agaisnt ToT) Same as patch 57919 (patch v2.3 - part I (right file)), but rebased against ToT for the bots to build it. Details: Patch did not build on EWS's bot because it had a conflit in WebCore/WebCore.xcodeproj/project.pbxproj For summary see comment #35. 234994 39 webkit-ews 2010-06-07 12:25:06 -0700 Attachment 58070 did not build on qt: Build output: http://webkit-commit-queue.appspot.com/results/3160141 235028 40 58081 tonikitoo 2010-06-07 13:55:09 -0700 Created attachment 58081 (committed with r60841, reviewed by Ojan and Darin) patch v2.3 - part I (agaisnt ToT and builds) Same as patch v2.3 (see comment #35), but now against ToT and fixed build issue in comment #39. 235080 41 58081 ojan 2010-06-07 18:28:20 -0700 Comment on attachment 58081 (committed with r60841, reviewed by Ojan and Darin) patch v2.3 - part I (agaisnt ToT and builds) This looks good to me with the nit below fixed. WebCore/editing/Editor.cpp:104 + if (!m_frame || !m_frame->page() || !m_frame->settings()) Do you need to null-check page here? m_frame and settings should be sufficient. 235114 42 webkit.review.bot 2010-06-07 20:24:33 -0700 http://trac.webkit.org/changeset/60816 might have broken GTK Linux 64-bit Debug 235235 43 58081 tonikitoo 2010-06-08 06:49:04 -0700 Comment on attachment 58081 (committed with r60841, reviewed by Ojan and Darin) patch v2.3 - part I (agaisnt ToT and builds) Clearing flags on attachment: 58081 Committed r60841: <http://trac.webkit.org/changeset/60841> 243658 44 tonikitoo 2010-06-28 05:17:59 -0700 Finally some time to back work on this! I will follow Darin's suggestion to follow up incrementally here, case by case. > > + bool shouldConsiderStylePresentOnlyIfThroughoutTheSelection() const { return m_type != EditingMacBehavior; } > > I think this name is a little vague. What this controls is style-toggling behavior. It doesn't affect other "is style present" situations, such as when to check the "Bold" menu item in an application. Does it? In fact, it is a possible situation, yes. In QtWebKit we have something called 'WebAction' (see [1]), accessible through the QWebPage::WebAction enum. It does include some text specific styles including bold, italic, underline , subscript, superscriput, strikethrough. [1] http://doc.qt.nokia.com/4.7-snapshot/qwebpage.html#WebAction-enum It is possible app developers to connect a menu item to, say for instance, QWebPage::ToggleBold, like in the snippet below: void MainWindow::editMenu() { QToolBar* bar = addToolBar("Edit"); bar->addAction(page()->action(QWebPage::ToggleBold)); ... } It enables QtWebKit to enable/disable and to check/uncheck menu items in the application chrome side, according to the WebCore state. Same mechanism is applied to Edit->Paste|Copy|Cut menu items. If no text is in clipboard then Paste menu item will be disable. If no text selected in content, Copy will be disabled, and so on ... Specifically about ToggleBold, suppose user makes a text selection with mouse. At some point, EditorClient::respondToChangedSelection will be called. void EditorClientQt::respondToChangedSelection() { ... m_page->d->updateEditorActions(); ... } which will end up calling QWebPagePrivate::updateAction(QWebPage::WebAction action) void QWebPagePrivate::updateEditorActions() { updateAction(QWebPage::Cut); updateAction(QWebPage::Copy); updateAction(QWebPage::Paste); ... updateAction(QWebPage::ToggleBold); ... } void QWebPagePrivate::updateAction(QWebPage::WebAction action) { ... WebCore::FrameLoader *loader = mainFrame->d->frame->loader(); WebCore::Editor *editor = page->focusController()->focusedOrMainFrame()->editor(); bool enabled = a->isEnabled(); bool checked = a->isChecked(); switch (action) { case QWebPage::Back: ... default: { // see if it's an editor command const char* commandName = editorCommandForWebActions(action); // if it's an editor command, let it's logic determine state if (commandName) { Editor::Command command = editor->command(commandName); enabled = command.isEnabled(); if (enabled) checked = command.state() != FalseTriState; else checked = false; } break; } If the user open up the Edit menu item, "command.state()" will do the trick of saying if the menu item has to be enabled, checked, or not for the ToggleBold action. 243664 45 59894 tonikitoo 2010-06-28 05:35:40 -0700 Created attachment 59894 patch v3 - part II Patch addresses the situation described in comment #44. 243701 46 59894 tonikitoo 2010-06-28 08:10:31 -0700 Comment on attachment 59894 patch v3 - part II cq- so I can fix some bad English in "Patch makes situations that depend on this check like this to be controlled by the EditingBehavior class." in the ChangeLog. supposing it gets r+, of course. 245063 47 60186 tonikitoo 2010-06-30 20:01:31 -0700 Created attachment 60186 patch v3.1 - part II Same as patch v3 - part II (attachment 59894), but fixed ChangeLog entry. @Darin or Ojan, could you please review? (please read comment #44) 246797 48 tonikitoo 2010-07-05 15:25:05 -0700 (In reply to comment #47) > Created an attachment (id=60186) [details] > patch v3.1 - part II > > Same as patch v3 - part II (attachment 59894 [details]), but fixed ChangeLog entry. > > @Darin or Ojan, could you please review? (please read comment #44) Ping review(?) 247753 49 60186 ojan 2010-07-07 14:21:51 -0700 Comment on attachment 60186 patch v3.1 - part II > static TriState stateStyle(Frame* frame, int propertyID, const char* desiredValue) > { > RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); > - style->setProperty(propertyID, desiredValue); > - return frame->editor()->selectionHasStyle(style.get()); > + style->setProperty(propertyID, desiredValue); // We need to add this style to pass it to selectionStartHasStyle / selectionHasStyle > + > + TriState styleIsPresent; > + if (!frame->editor()->behavior().shouldConsiderStylePresentOnlyIfThroughoutTheSelection()) > + styleIsPresent = frame->editor()->selectionStartHasStyle(style.get()) ? TrueTriState : FalseTriState; > + else > + styleIsPresent = frame->editor()->selectionHasStyle(style.get()); > + > + return styleIsPresent; This is a change in behavior. If we keep it, it should have a layout test and should maybe be a separate patch. In either case, I'm not sure this change is correct. I think Darin was just asking that the name of the EditingBehavior method be more specific. How about something like shouldToggleStyleBasedOnStartOfSelection? 248237 50 tonikitoo 2010-07-08 08:57:23 -0700 (In reply to comment #49) > I think Darin was just asking that the name of the EditingBehavior method be more specific. How about something like shouldToggleStyleBasedOnStartOfSelection? Thank you for the comments, Ojan! What I tried to explain in comment #44 is the situation "consider text as styled if style is present in all text nodes of a selection" encloses the following cases: 1) the toggle style behavior. For that situation, shouldToggleStyleBasedOnStartOfSelection as a name it great. - example: the BOLD button of a rich text editor. 2) the "what is style state" situation? For that one, the method name you suggested does not work very well. - example: an application menu item that has its checked/unchecked status relying on the style considered as present or not. What do you think? > This is a change in behavior. If we keep it, it should have a layout test and should maybe be a separate patch. In either case, I'm not sure this change is correct. Could you tell why you think it is wrong? 248329 51 darin 2010-07-08 10:48:06 -0700 I think Ojan’s main point is that first we want to refactor these settings and give them good names without changing behavior. Changing behavior should be handled separately. 248352 52 ojan 2010-07-08 11:13:20 -0700 (In reply to comment #50) > What I tried to explain in comment #44 is the situation "consider text as styled if style is present in all text nodes of a selection" encloses the following cases: Doh. Sorry, I missed that whole set of comments. On a side note, in the future, followup patches for a given issue should be done in new bugs. They new bug can point to the original, but it makes it easier to follow the relevant bits for the patch in question. In general, it should be one patch per bug. > > This is a change in behavior. If we keep it, it should have a layout test and should maybe be a separate patch. In either case, I'm not sure this change is correct. > > Could you tell why you think it is wrong? When shouldConsiderStylePresentOnlyIfThroughoutTheSelection is true it's taking what used to be a tri-state and making it a boolean. Specifically, I think we'd return the wrong value in the following case: <div id=foo contentEditable>foo<b>bar</b></div> <script> window.getSelection().selectAllChildren(foo); console.log(document.queryCommandIndeterm('bold')); </script> That should log "true" to the console. With your patch, I think it would log "false". On the other hand, this patch fixes queryCommandState to return the correct value in this case. Currently it would return true for the above and should return false. It would be unfortunate to fix one case and break the other. Can we do this as two separate patches? 1. Just change the current editingBehavior call. Call the method shouldToggleStyleBasedOnStartOfSelection, but also put a FIXME to use that method in stateStyle for the cases where it's used for queryCommandState. 2. Rename shouldToggleStyleBasedOnStartOfSelection to shouldConsiderStylePresentOnlyIfThroughoutTheSelection and use it in stateStyle, but not if it's being used to get a return value for queryCommandIndeterm. This is a bit complicated because right now both queryCommandState and queryCommandIndeterm end up calling the same method. So it would require a few more changes to EditorCommand.cpp. 248395 53 60921 tonikitoo 2010-07-08 11:54:24 -0700 Created attachment 60921 (r62815,r=ojan) patch v3.2 - part II As suggested by Ojan and Darin, keep only refactor work happening in this bug. No behavioral should happen here. 248415 54 60921 tonikitoo 2010-07-08 12:13:14 -0700 Comment on attachment 60921 (r62815,r=ojan) patch v3.2 - part II Clearing flags on attachment: 60921 Committed r62815: <http://trac.webkit.org/changeset/62815> 248454 55 webkit.review.bot 2010-07-08 12:55:38 -0700 http://trac.webkit.org/changeset/62815 might have broken Qt Linux Release 248461 56 tonikitoo 2010-07-08 13:00:09 -0700 (In reply to comment #55) > http://trac.webkit.org/changeset/62815 might have broken Qt Linux Release Fixed in r62815 . Bogus ! in the IF statement. 248501 57 robert 2010-07-08 13:42:48 -0700 This broke editing/5195166-1.html on the Qt bot. 248520 58 tonikitoo 2010-07-08 14:06:04 -0700 (In reply to comment #57) > This broke editing/5195166-1.html on the Qt bot. robert, this breakage is related to http://trac.webkit.org/changeset/62816 not this bug. 249145 59 tonikitoo 2010-07-09 11:39:22 -0700 Given the amount of comments in this bug and that its main goal is also accomplished, lets consider it as FIXED, and move the work involving specific missing bits in follow up bugs. I will file all of them now, and link to this one for the record. Thank you Darin and Ojan. 249281 60 tonikitoo 2010-07-09 14:37:59 -0700 (In reply to comment #29) > > + bool shouldExtendSelectionFromEndPointAlways() const { return m_type != EditingMacBehavior; } > > This name is too broad. It controls only shift-click behavior, not selection extension that's done with shift-arrow-keys for example. bug 41977. > > + bool shouldKeybardSelectionExtendForHorizontalNavigation() const { return m_type == EditingMacBehavior; } > > What does "extend for horizontal navigation" mean? This one needs work. bug 41976. > > + bool shouldGrowSelectionWhenExtendingToBoundary() const { return m_type == EditingMacBehavior; } > > If you don't grow the selection when extending to a boundary, what do you do? Shrink the selection? bug 41975. 249284 61 tonikitoo 2010-07-09 14:39:05 -0700 (In reply to comment #52) > 2. Rename shouldToggleStyleBasedOnStartOfSelection to shouldConsiderStylePresentOnlyIfThroughoutTheSelection and use it in stateStyle, but not if it's being used to get a return value for queryCommandIndeterm. This is a bit complicated because right now both queryCommandState and queryCommandIndeterm end up calling the same method. So it would require a few more changes to EditorCommand.cpp. bug 41989. And we're done here. 57277 2010-05-27 14:39:56 -0700 2010-05-28 08:38:00 -0700 wip - first materialization of the idea 0001-Quick-prototype-that-shows-how-I-am-doing-so-far.patch text/plain 14425 tonikitoo RnJvbSAyOTRmNDAxNGRlMGJlOTQ2NWQ2ZDUzZDE0Zjc4NmJjY2M1ZDEzYzZmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCAyNyBNYXkgMjAxMCAxNzoyNTo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFF1 aWNrIHByb3RvdHlwZSB0aGF0IHNob3dzIGhvdyBJIGFtIGRvaW5nIHNvIGZhciAuLi4KCi0tLQog V2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL3BhZ2Uv RWRpdG9yU2V0dGluZ3MuY3BwICAgfCAgIDY2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKIFdlYkNvcmUvcGFnZS9FZGl0b3JTZXR0aW5ncy5oICAgICB8ICAgNzcgKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9wYWdlL1BhZ2UuY3BwICAgICAgICAg ICAgIHwgICAgMiArCiBXZWJDb3JlL3BhZ2UvUGFnZS5oICAgICAgICAgICAgICAgfCAgICA0ICsr CiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgfCAgIDEzICsrKy0tLQogNiBmaWxl cyBjaGFuZ2VkLCAxNTggaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBXZWJDb3JlL3BhZ2UvRWRpdG9yU2V0dGluZ3MuY3BwCiBjcmVhdGUgbW9kZSAxMDA2 NDQgV2ViQ29yZS9wYWdlL0VkaXRvclNldHRpbmdzLmgKCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dl YkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCA2NGY3YTIwLi4xNTFiZjI0IDEw MDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8K QEAgLTc3MSwxNiArNzcxLDE3IEBAIFNPVVJDRVMgKz0gXAogICAgIHBhZ2UvQ29uc29sZS5jcHAg XAogICAgIHBhZ2UvQ29udGV4dE1lbnVDb250cm9sbGVyLmNwcCBcCiAgICAgcGFnZS9ET01TZWxl Y3Rpb24uY3BwIFwKICAgICBwYWdlL0RPTVRpbWVyLmNwcCBcCiAgICAgcGFnZS9ET01XaW5kb3cu Y3BwIFwKICAgICBwYWdlL05hdmlnYXRvci5jcHAgXAogICAgIHBhZ2UvTmF2aWdhdG9yQmFzZS5j cHAgXAogICAgIHBhZ2UvRHJhZ0NvbnRyb2xsZXIuY3BwIFwKKyAgICBwYWdlL0VkaXRvclNldHRp bmdzLmNwcCBcCiAgICAgcGFnZS9FdmVudEhhbmRsZXIuY3BwIFwKICAgICBwYWdlL0V2ZW50U291 cmNlLmNwcCBcCiAgICAgcGFnZS9Gb2N1c0NvbnRyb2xsZXIuY3BwIFwKICAgICBwYWdlL0ZyYW1l LmNwcCBcCiAgICAgcGFnZS9GcmFtZVRyZWUuY3BwIFwKICAgICBwYWdlL0ZyYW1lVmlldy5jcHAg XAogICAgIHBhZ2UvR2VvbG9jYXRpb24uY3BwIFwKICAgICBwYWdlL0dlb2xvY2F0aW9uQ29udHJv bGxlci5jcHAgXApAQCAtMTUyMiwxNiArMTUyMywxNyBAQCBIRUFERVJTICs9IFwKICAgICBwYWdl L0NvbnNvbGUuaCBcCiAgICAgcGFnZS9Db250ZXh0TWVudUNvbnRyb2xsZXIuaCBcCiAgICAgcGFn ZS9Db250ZXh0TWVudVByb3ZpZGVyLmggXAogICAgIHBhZ2UvQ29vcmRpbmF0ZXMuaCBcCiAgICAg cGFnZS9ET01TZWxlY3Rpb24uaCBcCiAgICAgcGFnZS9ET01UaW1lci5oIFwKICAgICBwYWdlL0RP TVdpbmRvdy5oIFwKICAgICBwYWdlL0RyYWdDb250cm9sbGVyLmggXAorICAgIHBhZ2UvRWRpdG9y U2V0dGluZ3MuaCBcCiAgICAgcGFnZS9FdmVudEhhbmRsZXIuaCBcCiAgICAgcGFnZS9FdmVudFNv dXJjZS5oIFwKICAgICBwYWdlL0ZvY3VzQ29udHJvbGxlci5oIFwKICAgICBwYWdlL0ZyYW1lLmgg XAogICAgIHBhZ2UvRnJhbWVUcmVlLmggXAogICAgIHBhZ2UvRnJhbWVWaWV3LmggXAogICAgIHBh Z2UvR2VvbG9jYXRpb24uaCBcCiAgICAgcGFnZS9HZW9sb2NhdGlvblBvc2l0aW9uQ2FjaGUuaCBc CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRWRpdG9yU2V0dGluZ3MuY3BwIGIvV2ViQ29yZS9w YWdlL0VkaXRvclNldHRpbmdzLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5kMmU3OWJlCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL0VkaXRvclNldHRpbmdz LmNwcApAQCAtMCwwICsxLDY2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENv cnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29weXJpZ2h0IChDKSAy MDEwIEFudG9uaW8gR29tZXMgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorICoKKyAqIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6 CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAq IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkVkaXRv clNldHRpbmdzLmgiCisKKyNpbmNsdWRlICJQYWdlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworRWRpdG9yU2V0dGluZ3M6OkVkaXRvclNldHRpbmdzKCkKK3sKKyAgICByZXNldEVkaXRpbmdC ZWhhdmlvcigpOworfQorCit2b2lkIEVkaXRvclNldHRpbmdzOjpyZXNldEVkaXRpbmdCZWhhdmlv cigpCit7CisjaWYgUExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERB UldJTikpCisgICAgLy8gKFBMQVRGT1JNKE1BQykgaXMgYWx3YXlzIGZhbHNlIGluIENocm9taXVt LCBoZW5jZSB0aGUgZXh0cmEgY29uZGl0aW9uKS4KKyAgICBtX2VkaXRpbmdCZWhhdmlvciA9IEVk aXRpbmdNYWNCZWhhdmlvcjsKKyNlbHNlCisgICAgbV9lZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5n V2luZG93c0JlaGF2aW9yOworI2VuZGlmCit9CisKK2Jvb2wgRWRpdG9yU2V0dGluZ3M6OnNob3Vs ZE1vdmVDYXJldFRvQm91bmRhcnkoKSBjb25zdAoreworICAgIHN3aXRjaChtX2VkaXRpbmdCZWhh dmlvcikgeworICAgIGNhc2UgRWRpdGluZ01hY0JlaGF2aW9yOgorICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICBjYXNlIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I6CisgICAgICAgIHJldHVybiBmYWxz ZTsKKyAgICBkZWZhdWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisK KyAgICByZXR1cm4gZmFsc2U7Cit9CisKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL0VkaXRvclNldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvRWRpdG9y U2V0dGluZ3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZTk4YWY1Ci0t LSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wYWdlL0VkaXRvclNldHRpbmdzLmgKQEAgLTAsMCAr MSw3NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQv b3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBbnRvbmlvIEdv bWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKyAqCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVU RVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRF UiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IK KyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgRWRpdG9yU2V0dGluZ3NfaAorI2RlZmluZSBFZGl0b3JTZXR0aW5nc19o CisKKyNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisg ICAgLy8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJl bnQgb24gV2luZG93cywgTGludXggYW5kIE1hY2ludG9zaC4KKyAgICAvLyBTb21lIGV4YW1wbGVz OgorICAgIC8vCisgICAgLy8gICAgMSkgQ2xpY2tpbmcgYmVsb3cgdGhlIGxhc3QgbGluZSBvZiBh biBlZGl0YWJsZSBhcmVhIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQKKyAgICAvLyAgICAgICBv ZiB0aGUgbGFzdCBsaW5lIG9uIE1hYyBhbmQgb24gTGludXgsIGJ1dCBpbiB0aGUgbWlkZGxlIG9m IHRoZSBsYXN0IGxpbmUgb24KKyAgICAvLyAgICAgICBXaW5kb3dzLgorICAgIC8vICAgIDIpIFB1 c2hpbmcgdGhlIGRvd24gYXJyb3cga2V5IG9uIHRoZSBsYXN0IGxpbmUgcHV0cyB0aGUgY2FyZXQg YXQgdGhlIGVuZCBvZiB0aGUKKyAgICAvLyAgICAgICBsYXN0IGxpbmUgb24gTWFjIGFuZCBMaW51 eCwgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWlsYXIgY2FzZSBleGlzdHMKKyAg ICAvLyAgICAgICBvbiB0aGUgdG9wIGxpbmUuCisgICAgLy8gICAgMykgQ2xpY2tpbmcgdG8gZXh0 ZW5kIGEgc2VsZWN0aW9uIG9uIE1hYyAoaS5lLiBzaGl0ZiBpcyBoZWxkKSBjYWxjdWxhdGVzIGlm IHRoZQorICAgIC8vICAgICAgIGNsaWNrZWQgcG9zaXRpb24gaXMgY2xvc2VyIHRvIHRoZSBzdGFy dCBvciB0byB0aGUgZW5kIG9mIHRoZSBjdXJyZW50IHNlbGVjdGVkCisgICAgLy8gICAgICAgdGV4 dCBhbmQgbW92ZXMgc2VsZWN0aW9uIHRvd2FyZHMgdGhlIGNsb3Nlci4gV2luZG93cyBhbmQgTGlu dXggd29yayByYXRoZXIKKyAgICAvLyAgICAgICBkaWZmZXJlbnRseS4KKyAgICAvLyAgICA0KSBS aWdodCBjbGlja2luZyBvbiBhIHRleHQgb3BlbnMgdGhlIGNvbnRleHQgc2Vuc2l0aXZlIG1lbnUg YW5kIHNlbGVjdHMgdGhlIHdvcmQKKyAgICAvLyAgICAgICB1bmRlciB0aGUgbW91c2UgcG9pbnQg b24gTWFjIGFuZCBXaW5kb3dzLCBidXQgbm90IG9uIExpbnV4LgorICAgIC8vCisgICAgLy8gVGhp cyBzZXR0aW5nIGlzIGludGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2YgYmVoYXZpb3Jz LiBUaGVyZSBhcmUgc29tZSBvdGhlcgorICAgIC8vIGJlaGF2aW9ycyB3aXRoIGluZGl2aWR1YWwg ZnVuY3Rpb24gY2FsbHMgb24gRWRpdG9yQ2xpZW50IChzbWFydCBjb3B5IGFuZCBwYXN0ZSBhbmQK KyAgICAvLyBzZWxlY3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNv dWxkIGJlIGNvbWJpbmVkIHdpdGggdGhpcyBpZgorICAgIC8vIGlmIHBvc3NpYmxlIGluIHRoZSBm dXR1cmUuCisgICAgZW51bSBFZGl0aW5nQmVoYXZpb3IgeworICAgICAgICBFZGl0aW5nTWFjQmVo YXZpb3IsCisgICAgICAgIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IsCisgICAgfTsKKworICAgIGNs YXNzIEVkaXRvclNldHRpbmdzIDogcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6Cisg ICAgICAgIEVkaXRvclNldHRpbmdzKCk7CisKKyAgICAgICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZp b3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZp b3I7IH0KKworICAgICAgICBib29sIHNob3VsZE1vdmVDYXJldFRvQm91bmRhcnkoKSBjb25zdDsK KworICAgIHByaXZhdGU6CisgICAgICAgIHZvaWQgcmVzZXRFZGl0aW5nQmVoYXZpb3IoKTsKKwor ICAgICAgICBFZGl0aW5nQmVoYXZpb3IgbV9lZGl0aW5nQmVoYXZpb3I7CisgICAgfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRWRpdG9yU2V0dGluZ3NfaApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwIGIvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCmluZGV4 IDQ4ZjU3NTMuLjdiZThiNjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9QYWdlLmNwcAorKysg Yi9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKQEAgLTI3LDE2ICsyNywxNyBAQAogI2luY2x1ZGUgIkNo cm9tZS5oIgogI2luY2x1ZGUgIkNocm9tZUNsaWVudC5oIgogI2luY2x1ZGUgIkNvbnRleHRNZW51 Q2xpZW50LmgiCiAjaW5jbHVkZSAiQ29udGV4dE1lbnVDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAi RE9NV2luZG93LmgiCiAjaW5jbHVkZSAiRGV2aWNlT3JpZW50YXRpb24uaCIKICNpbmNsdWRlICJE cmFnQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkVkaXRvckNsaWVudC5oIgorI2luY2x1ZGUgIkVk aXRvclNldHRpbmdzLmgiCiAjaW5jbHVkZSAiRXZlbnQuaCIKICNpbmNsdWRlICJFdmVudE5hbWVz LmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIK ICNpbmNsdWRlICJGb2N1c0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1 ZGUgIkZyYW1lTG9hZGVyLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKQEAgLTEy NCwxNiArMTI1LDE3IEBAIFBhZ2U6OlBhZ2UoQ2hyb21lQ2xpZW50KiBjaHJvbWVDbGllbnQsIENv bnRleHRNZW51Q2xpZW50KiBjb250ZXh0TWVudUNsaWVudCwgRWRpCiAjZW5kaWYKICNpZiBFTkFC TEUoQ0xJRU5UX0JBU0VEX0dFT0xPQ0FUSU9OKQogICAgICwgbV9nZW9sb2NhdGlvbkNvbnRyb2xs ZXIobmV3IEdlb2xvY2F0aW9uQ29udHJvbGxlcih0aGlzLCBnZW9sb2NhdGlvbkNvbnRyb2xsZXJD bGllbnQpKQogI2VuZGlmCiAjaWYgRU5BQkxFKERFVklDRV9PUklFTlRBVElPTikKICAgICAsIG1f ZGV2aWNlT3JpZW50YXRpb24obmV3IERldmljZU9yaWVudGF0aW9uKHRoaXMsIGRldmljZU9yaWVu dGF0aW9uQ2xpZW50KSkKICNlbmRpZgogICAgICwgbV9zZXR0aW5ncyhuZXcgU2V0dGluZ3ModGhp cykpCisgICAgLCBtX2VkaXRvclNldHRpbmdzKG5ldyBFZGl0b3JTZXR0aW5ncykKICAgICAsIG1f cHJvZ3Jlc3MobmV3IFByb2dyZXNzVHJhY2tlcikKICAgICAsIG1fYmFja0ZvcndhcmRMaXN0KEJh Y2tGb3J3YXJkTGlzdDo6Y3JlYXRlKHRoaXMpKQogICAgICwgbV90aGVtZShSZW5kZXJUaGVtZTo6 dGhlbWVGb3JQYWdlKHRoaXMpKQogICAgICwgbV9lZGl0b3JDbGllbnQoZWRpdG9yQ2xpZW50KQog ICAgICwgbV9mcmFtZUNvdW50KDApCiAgICAgLCBtX29wZW5lZEJ5RE9NKGZhbHNlKQogICAgICwg bV90YWJLZXlDeWNsZXNUaHJvdWdoRWxlbWVudHModHJ1ZSkKICAgICAsIG1fZGVmZXJzTG9hZGlu ZyhmYWxzZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9QYWdlLmggYi9XZWJDb3JlL3BhZ2Uv UGFnZS5oCmluZGV4IGFhN2JhZTEuLmI5ODUzYTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9Q YWdlLmgKKysrIGIvV2ViQ29yZS9wYWdlL1BhZ2UuaApAQCAtNjMsMTYgKzYzLDE3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICBjbGFzcyBQbHVnaW5EYXRhOwogICAgIGNsYXNzIFBsdWdpbkhh bHRlcjsKICAgICBjbGFzcyBQbHVnaW5IYWx0ZXJDbGllbnQ7CiAgICAgY2xhc3MgUHJvZ3Jlc3NU cmFja2VyOwogICAgIGNsYXNzIFJlbmRlclRoZW1lOwogICAgIGNsYXNzIFZpc2libGVTZWxlY3Rp b247CiAgICAgY2xhc3MgU2VsZWN0aW9uQ29udHJvbGxlcjsKICAgICBjbGFzcyBTZXR0aW5nczsK KyAgICBjbGFzcyBFZGl0b3JTZXR0aW5nczsKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKICAg ICBjbGFzcyBTdG9yYWdlTmFtZXNwYWNlOwogI2VuZGlmCiAjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpCiAgICAgY2xhc3MgTm90aWZpY2F0aW9uUHJlc2VudGVyOwogI2VuZGlmCiAjaWYgRU5BQkxF KFdNTCkKQEAgLTE0NiwxNiArMTQ3LDE4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgog I2lmIEVOQUJMRShDTElFTlRfQkFTRURfR0VPTE9DQVRJT04pCiAgICAgICAgIEdlb2xvY2F0aW9u Q29udHJvbGxlciogZ2VvbG9jYXRpb25Db250cm9sbGVyKCkgY29uc3QgeyByZXR1cm4gbV9nZW9s b2NhdGlvbkNvbnRyb2xsZXIuZ2V0KCk7IH0KICNlbmRpZgogI2lmIEVOQUJMRShERVZJQ0VfT1JJ RU5UQVRJT04pCiAgICAgICAgIERldmljZU9yaWVudGF0aW9uKiBkZXZpY2VPcmllbnRhdGlvbigp IGNvbnN0IHsgcmV0dXJuIG1fZGV2aWNlT3JpZW50YXRpb24uZ2V0KCk7IH0KICNlbmRpZgogICAg ICAgICBTZXR0aW5ncyogc2V0dGluZ3MoKSBjb25zdCB7IHJldHVybiBtX3NldHRpbmdzLmdldCgp OyB9CisgICAgICAgIEVkaXRvclNldHRpbmdzKiBlZGl0b3JTZXR0aW5ncygpIGNvbnN0IHsgcmV0 dXJuIG1fZWRpdG9yU2V0dGluZ3MuZ2V0KCk7IH0KKwogICAgICAgICBQcm9ncmVzc1RyYWNrZXIq IHByb2dyZXNzKCkgY29uc3QgeyByZXR1cm4gbV9wcm9ncmVzcy5nZXQoKTsgfQogICAgICAgICAK ICAgICAgICAgdm9pZCBzZXRUYWJLZXlDeWNsZXNUaHJvdWdoRWxlbWVudHMoYm9vbCBiKSB7IG1f dGFiS2V5Q3ljbGVzVGhyb3VnaEVsZW1lbnRzID0gYjsgfQogICAgICAgICBib29sIHRhYktleUN5 Y2xlc1Rocm91Z2hFbGVtZW50cygpIGNvbnN0IHsgcmV0dXJuIG1fdGFiS2V5Q3ljbGVzVGhyb3Vn aEVsZW1lbnRzOyB9CiAKICAgICAgICAgYm9vbCBmaW5kU3RyaW5nKGNvbnN0IFN0cmluZyYsIFRl eHRDYXNlU2Vuc2l0aXZpdHksIEZpbmREaXJlY3Rpb24sIGJvb2wgc2hvdWxkV3JhcCk7CiAgICAg ICAgIHVuc2lnbmVkIGludCBtYXJrQWxsTWF0Y2hlc0ZvclRleHQoY29uc3QgU3RyaW5nJiwgVGV4 dENhc2VTZW5zaXRpdml0eSwgYm9vbCBzaG91bGRIaWdobGlnaHQsIHVuc2lnbmVkKTsKICAgICAg ICAgdm9pZCB1bm1hcmtBbGxUZXh0TWF0Y2hlcygpOwpAQCAtMjU3LDE2ICsyNjAsMTcgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAjaWYgRU5BQkxFKENMSUVOVF9CQVNFRF9HRU9MT0NB VElPTikKICAgICAgICAgT3duUHRyPEdlb2xvY2F0aW9uQ29udHJvbGxlcj4gbV9nZW9sb2NhdGlv bkNvbnRyb2xsZXI7CiAjZW5kaWYKICNpZiBFTkFCTEUoREVWSUNFX09SSUVOVEFUSU9OKQogICAg ICAgICBPd25QdHI8RGV2aWNlT3JpZW50YXRpb24+IG1fZGV2aWNlT3JpZW50YXRpb247CiAjZW5k aWYKICAgICAgICAgT3duUHRyPFNldHRpbmdzPiBtX3NldHRpbmdzOworICAgICAgICBPd25QdHI8 RWRpdG9yU2V0dGluZ3M+IG1fZWRpdG9yU2V0dGluZ3M7CiAgICAgICAgIE93blB0cjxQcm9ncmVz c1RyYWNrZXI+IG1fcHJvZ3Jlc3M7CiAgICAgICAgIAogICAgICAgICBSZWZQdHI8QmFja0Zvcndh cmRMaXN0PiBtX2JhY2tGb3J3YXJkTGlzdDsKICAgICAgICAgUmVmUHRyPEZyYW1lPiBtX21haW5G cmFtZTsKIAogICAgICAgICBSZWZQdHI8SGlzdG9yeUl0ZW0+IG1fZ2xvYmFsSGlzdG9yeUl0ZW07 CiAKICAgICAgICAgbXV0YWJsZSBSZWZQdHI8UGx1Z2luRGF0YT4gbV9wbHVnaW5EYXRhOwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQmxvY2suY3BwCmluZGV4IDQwNzYwN2MuLmQ5NTk0ZmEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJCbG9jay5jcHAKQEAgLTE5LDE2ICsxOSwxNyBAQAogICogdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKICAq IEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIK ICNpbmNsdWRlICJSZW5kZXJCbG9jay5oIgogCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNpbmNs dWRlICJFZGl0b3JTZXR0aW5ncy5oIgogI2luY2x1ZGUgIkVsZW1lbnQuaCIKICNpbmNsdWRlICJG bG9hdFF1YWQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgog I2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2luY2x1ZGUgIkhUTUxGb3JtRWxlbWVudC5o IgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhpdFRlc3RSZXN1bHQuaCIKQEAg LTM3ODAsMzcgKzM3ODEsMzcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlv bkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogICAgICAgICAvLyBj aGVjayBpZiB0aGlzIHJvb3QgbGluZSBib3ggaXMgbG9jYXRlZCBhdCB0aGlzIHkgY29vcmRpbmF0 ZQogICAgICAgICBpZiAocG9pbnRJbkNvbnRlbnRzLnkoKSA8IGJvdHRvbSkgewogICAgICAgICAg ICAgY2xvc2VzdEJveCA9IHJvb3QtPmNsb3Nlc3RMZWFmQ2hpbGRGb3JYUG9zKHBvaW50SW5Db250 ZW50cy54KCkpOwogICAgICAgICAgICAgaWYgKGNsb3Nlc3RCb3gpCiAgICAgICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1 bWVudCgpLT5zZXR0aW5ncygpOwotICAgIGJvb2wgdXNlV2luZG93c0JlaGF2aW9yID0gc2V0dGlu Z3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdXaW5kb3dzQmVoYXZp b3I7CisgICAgRWRpdG9yU2V0dGluZ3MqIHNldHRpbmdzID0gZG9jdW1lbnQoKS0+cGFnZSgpLT5l ZGl0b3JTZXR0aW5ncygpOworICAgIGJvb2wgbW92ZUNhcmV0VG9Cb3VuZGFyeSA9IHNldHRpbmdz ICYmIHNldHRpbmdzLT5zaG91bGRNb3ZlQ2FyZXRUb0JvdW5kYXJ5KCk7CiAKLSAgICBpZiAodXNl V2luZG93c0JlaGF2aW9yICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVu KSB7CisgICAgaWYgKCFtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmICFjbG9zZXN0Qm94ICYmIGxhc3RS b290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBiZWxvdyBs YXN0IHJvb3QgbGluZSBib3gsIHByZXRlbmQgd2UgaGl0IGl0CiAgICAgICAgIGNsb3Nlc3RCb3gg PSBsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+Y2xvc2VzdExlYWZDaGlsZEZvclhQb3MocG9pbnRJ bkNvbnRlbnRzLngoKSk7CiAgICAgfQogCiAgICAgaWYgKGNsb3Nlc3RCb3gpIHsKLSAgICAgICAg aWYgKCF1c2VXaW5kb3dzQmVoYXZpb3IgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9v dEJveFdpdGhDaGlsZHJlbi0+bGluZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3Rv cikgeworICAgICAgICBpZiAobW92ZUNhcmV0VG9Cb3VuZGFyeSAmJiBwb2ludEluQ29udGVudHMu eSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVD bGlja0Z1ZGdlRmFjdG9yKSB7CiAgICAgICAgICAgICAvLyB5IGNvb3JkaW5hdGUgaXMgYWJvdmUg Zmlyc3Qgcm9vdCBsaW5lIGJveCwgc28gcmV0dXJuIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QKICAg ICAgICAgICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3goZmlyc3RSb290 Qm94V2l0aENoaWxkcmVuLT5maXJzdExlYWZDaGlsZCgpLCB0cnVlKSwgRE9XTlNUUkVBTSk7CiAg ICAgICAgIH0KIAogICAgICAgICAvLyBwYXNzIHRoZSBib3ggYSB5IHBvc2l0aW9uIHRoYXQgaXMg aW5zaWRlIGl0CiAgICAgICAgIHJldHVybiBjbG9zZXN0Qm94LT5yZW5kZXJlcigpLT5wb3NpdGlv bkZvclBvaW50KEludFBvaW50KHBvaW50SW5Db250ZW50cy54KCksIGNsb3Nlc3RCb3gtPm1feSkp OwogICAgIH0KIAogICAgIGlmIChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewotICAgICAgICAv LyBXZSBoaXQgdGhpcyBjYXNlIGZvciBNYWMgYmVoYXZpb3Igd2hlbiB0aGUgWSBjb29yZGluYXRl IGlzIGJlbG93IHRoZSBsYXN0IGJveC4KLSAgICAgICAgQVNTRVJUKCF1c2VXaW5kb3dzQmVoYXZp b3IpOworICAgICAgICAvLyBXZSBoaXQgdGhpcyBjYXNlIGZvciBub24gV2luZG93cyBiZWhhdmlv ciB3aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgorICAgICAgICBB U1NFUlQobW92ZUNhcmV0VG9Cb3VuZGFyeSk7CiAgICAgICAgIHJldHVybiBWaXNpYmxlUG9zaXRp b24ocG9zaXRpb25Gb3JCb3gobGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxhc3RMZWFmQ2hpbGQo KSwgZmFsc2UpLCBET1dOU1RSRUFNKTsKICAgICB9CiAKICAgICAvLyBDYW4ndCByZWFjaCB0aGlz LiBXZSBoYXZlIGEgcm9vdCBsaW5lIGJveCwgYnV0IGl0IGhhcyBubyBraWRzLgogICAgIC8vIEZJ WE1FOiBUaGlzIHNob3VsZCBBU1NFUlRfTk9UX1JFQUNIRUQoKSwgYnV0IGNsaWNraW5nIG9uIHBs YWNlaG9sZGVyIHRleHQKICAgICAvLyBzZWVtcyB0byBoaXQgdGhpcyBjb2RlIHBhdGguCiAgICAg cmV0dXJuIGNyZWF0ZVZpc2libGVQb3NpdGlvbigwLCBET1dOU1RSRUFNKTsKIH0KLS0gCjEuNy4w LjQKCg== 57331 2010-05-28 08:38:00 -0700 2010-05-30 20:56:12 -0700 wip - second prototype of the idea 0001-Second-quick-prototype-that-shows-how-I-am-doing-so-.patch text/plain 6450 tonikitoo RnJvbSAyNDkyNTYxOTYxNmU1MTAwNTQ0OTZhODU0MGU4NDJhN2Q2NWJjMDE5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCAyNyBNYXkgMjAxMCAxNzoyNTo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFNl Y29uZCBxdWljayBwcm90b3R5cGUgdGhhdCBzaG93cyBob3cgSSBhbSBkb2luZyBzbyBmYXIgLi4u CgotLS0KIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgICAgICAgICB8ICAgMTYgKysrKysrKyst LS0tLS0tLQogV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggICAgICAgICAgIHwgICAzMSArKysrKysr KysrKysrKysrKysrKysrKysrKystLS0tCiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5j cHAgfCAgIDEyICsrKysrKy0tLS0tLQogMyBmaWxlcyBjaGFuZ2VkLCA0MSBpbnNlcnRpb25zKCsp LCAxOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3Bw IGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCA2ZjZiYjA0Li5mNDE1M2VmIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0 aW5ncy5jcHAKQEAgLTExMywxNCArMTEzLDYgQEAgU2V0dGluZ3M6OlNldHRpbmdzKFBhZ2UqIHBh Z2UpCiAgICAgLCBtX2VuZm9yY2VDU1NNSU1FVHlwZUluU3RyaWN0TW9kZSh0cnVlKQogICAgICwg bV91c2VzRW5jb2RpbmdEZXRlY3RvcihmYWxzZSkKICAgICAsIG1fYWxsb3dTY3JpcHRzVG9DbG9z ZVdpbmRvd3MoZmFsc2UpCi0gICAgLCBtX2VkaXRpbmdCZWhhdmlvcigKLSNpZiBQTEFURk9STShN QUMpIHx8IChQTEFURk9STShDSFJPTUlVTSkgJiYgT1MoREFSV0lOKSkKLSAgICAgICAgLy8gKFBM QVRGT1JNKE1BQykgaXMgYWx3YXlzIGZhbHNlIGluIENocm9taXVtLCBoZW5jZSB0aGUgZXh0cmEg Y29uZGl0aW9uLikKLSAgICAgICAgRWRpdGluZ01hY0JlaGF2aW9yCi0jZWxzZQotICAgICAgICBF ZGl0aW5nV2luZG93c0JlaGF2aW9yCi0jZW5kaWYKLSAgICAgICAgKQogICAgIC8vIEZJWE1FOiBU aGlzIHNob3VsZCByZWFsbHkgYmUgZGlzYWJsZWQgYnkgZGVmYXVsdCBhcyBpdCBtYWtlcyBwbGF0 Zm9ybXMgdGhhdCBkb24ndCBzdXBwb3J0IHRoZSBmZWF0dXJlIGRvd25sb2FkIGZpbGVzCiAgICAg Ly8gdGhleSBjYW4ndCB1c2UgYnkuIExlYXZpbmcgZW5hYmxlZCBmb3Igbm93IHRvIG5vdCBjaGFu Z2UgZXhpc3RpbmcgYmVoYXZpb3IuCiAgICAgLCBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5h YmxlZCh0cnVlKQpAQCAtMTMzLDYgKzEyNSwxNCBAQCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSog cGFnZSkKICAgICAsIG1fbG9hZERlZmVycmluZ0VuYWJsZWQodHJ1ZSkKICAgICAsIG1fdGlsZWRC YWNraW5nU3RvcmVFbmFibGVkKGZhbHNlKQogICAgICwgbV9odG1sNVBhcnNlckVuYWJsZWQoZmFs c2UpCisgICAgLCBtX2VkaXRpbmdCZWhhdmlvckNvbnRyb2xsZXIoCisjaWYgUExBVEZPUk0oTUFD KSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJTikpCisgICAgICAgIC8vIChQTEFU Rk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1bSwgaGVuY2UgdGhlIGV4dHJhIGNv bmRpdGlvbi4pCisgICAgICAgIEVkaXRpbmdCZWhhdmlvckNvbnRyb2xsZXIoRWRpdGluZ01hY0Jl aGF2aW9yKQorI2Vsc2UKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yQ29udHJvbGxlcihFZGl0aW5n V2luZG93c0JlaGF2aW9yKQorI2VuZGlmCisgICAgKQogewogICAgIC8vIEEgRnJhbWUgbWF5IG5v dCBoYXZlIGJlZW4gY3JlYXRlZCB5ZXQsIHNvIHdlIGluaXRpYWxpemUgdGhlIEF0b21pY1N0cmlu ZyAKICAgICAvLyBoYXNoIGJlZm9yZSB0cnlpbmcgdG8gdXNlIGl0LgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRleCBkYzNi NTBmLi5lNjFmMjMxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAorKysgYi9X ZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjcwLDkgKzI3MCwxMyBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIHZvaWQgc2V0QWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7 CiAgICAgICAgIGJvb2wgYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVy biBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0 aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9y ID0gYmVoYXZpb3I7IH0KLSAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigp IGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVo YXZpb3IpOyB9Ci0gICAgICAgIAorICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvcihFZGl0 aW5nQmVoYXZpb3IgYmVoYXZpb3IpIHsgbV9lZGl0aW5nQmVoYXZpb3JDb250cm9sbGVyID0gRWRp dGluZ0JlaGF2aW9yQ29udHJvbGxlcihiZWhhdmlvcik7IH0KKyAgICAgICAgRWRpdGluZ0JlaGF2 aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIG1fZWRpdGluZ0JlaGF2aW9yQ29u dHJvbGxlci5iZWhhdmlvcigpOyB9CisKKyAgICAgICAgLy8gUGxhdGZvcm0gdmFyaWFudCBlZGl0 aW5nIGJlaGF2aW9yIG1ldGhvZHMuIEluIHByYWN0aWNlLCB0aGVzZSBhcmUgYmFzaWNhbGx5IHdy YXBwZXIgY2FsbHMgZm9yCisgICAgICAgIC8vIGVxdWl2YWxlbnQgRWRpdGluZ0JlaGF2aW9yQ29u dHJvbGxlciBtZXRob2RzLgorICAgICAgICBib29sIHNob3VsZE1vdmVDYXJldFRvQm91bmRhcnko KSBjb25zdCB7IHJldHVybiBtX2VkaXRpbmdCZWhhdmlvckNvbnRyb2xsZXIuc2hvdWxkTW92ZUNh cmV0VG9Cb3VuZGFyeSgpOyB9CisKICAgICAgICAgdm9pZCBzZXREb3dubG9hZGFibGVCaW5hcnlG b250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJvb2wgZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNF bmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQ7 IH0KIApAQCAtMzEyLDYgKzMxNiwyNCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGJv b2wgaHRtbDVQYXJzZXJFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9odG1sNVBhcnNlckVuYWJs ZWQ7IH0KIAogICAgIHByaXZhdGU6CisKKyAgICAgICAgY2xhc3MgRWRpdGluZ0JlaGF2aW9yQ29u dHJvbGxlciB7CisgICAgICAgIHB1YmxpYzoKKworICAgICAgICAgICAgRWRpdGluZ0JlaGF2aW9y Q29udHJvbGxlcihFZGl0aW5nQmVoYXZpb3IgYikKKyAgICAgICAgICAgICAgICA6IG1fYmVoYXZp b3IoYikKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgRWRpdGlu Z0JlaGF2aW9yIGJlaGF2aW9yKCkgY29uc3QgeyByZXR1cm4gbV9iZWhhdmlvcjsgfQorCisgICAg ICAgICAgICAvLyBQbGF0Zm9ybSB2YXJpYW50IGVkaXRpbmcgYmVoYXZpb3IgbWV0aG9kcy4KKyAg ICAgICAgICAgIGJvb2wgc2hvdWxkTW92ZUNhcmV0VG9Cb3VuZGFyeSgpIGNvbnN0IHsgcmV0dXJu IG1fYmVoYXZpb3IgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsgfQorCisgICAgICAgIHByaXZh dGU6CisgICAgICAgICAgICBFZGl0aW5nQmVoYXZpb3IgbV9iZWhhdmlvcjsKKyAgICAgICAgfTsK KwogICAgICAgICBQYWdlKiBtX3BhZ2U7CiAgICAgICAgIAogICAgICAgICBTdHJpbmcgbV9kZWZh dWx0VGV4dEVuY29kaW5nTmFtZTsKQEAgLTM4MCw3ICs0MDIsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIGJvb2wgbV9lbmZvcmNlQ1NTTUlNRVR5cGVJblN0cmljdE1vZGUgOiAxOwog ICAgICAgICBib29sIG1fdXNlc0VuY29kaW5nRGV0ZWN0b3IgOiAxOwogICAgICAgICBib29sIG1f YWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MgOiAxOwotICAgICAgICB1bnNpZ25lZCBtX2VkaXRp bmdCZWhhdmlvciA6IDE7CiAgICAgICAgIGJvb2wgbV9kb3dubG9hZGFibGVCaW5hcnlGb250c0Vu YWJsZWQgOiAxOwogICAgICAgICBib29sIG1feHNzQXVkaXRvckVuYWJsZWQgOiAxOwogICAgICAg ICBib29sIG1fYWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQgOiAxOwpAQCAtMzkyLDYgKzQx Myw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgYm9vbCBtX3RpbGVkQmFja2luZ1N0 b3JlRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV9odG1sNVBhcnNlckVuYWJsZWQ6IDE7CiAK KyAgICAgICAgRWRpdGluZ0JlaGF2aW9yQ29udHJvbGxlciBtX2VkaXRpbmdCZWhhdmlvckNvbnRy b2xsZXI7CisKICNpZiBVU0UoU0FGQVJJX1RIRU1FKQogICAgICAgICBzdGF0aWMgYm9vbCBnU2hv dWxkUGFpbnROYXRpdmVDb250cm9sczsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQmxvY2suY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3Bw CmluZGV4IGI5MjFkNTIuLmVlMTFjMjAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckJsb2NrLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKQEAg LTM3MzcsMTYgKzM3MzcsMTYgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlv bkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogICAgICAgICB9CiAg ICAgfQogCi0gICAgU2V0dGluZ3MqIHNldHRpbmdzID0gZG9jdW1lbnQoKS0+c2V0dGluZ3MoKTsK LSAgICBib29sIHVzZVdpbmRvd3NCZWhhdmlvciA9IHNldHRpbmdzICYmIHNldHRpbmdzLT5lZGl0 aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOworICAgIFNldHRpbmdzKiBz ZXR0aW5ncyA9IGRvY3VtZW50KCktPnBhZ2UoKS0+c2V0dGluZ3MoKTsKKyAgICBib29sIG1vdmVD YXJldFRvQm91bmRhcnkgPSBzZXR0aW5ncyAmJiBzZXR0aW5ncy0+c2hvdWxkTW92ZUNhcmV0VG9C b3VuZGFyeSgpOwogCi0gICAgaWYgKHVzZVdpbmRvd3NCZWhhdmlvciAmJiAhY2xvc2VzdEJveCAm JiBsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgeworICAgIGlmICghbW92ZUNhcmV0VG9Cb3VuZGFy eSAmJiAhY2xvc2VzdEJveCAmJiBsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewogICAgICAgICAv LyB5IGNvb3JkaW5hdGUgaXMgYmVsb3cgbGFzdCByb290IGxpbmUgYm94LCBwcmV0ZW5kIHdlIGhp dCBpdAogICAgICAgICBjbG9zZXN0Qm94ID0gbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmNsb3Nl c3RMZWFmQ2hpbGRGb3JYUG9zKHBvaW50SW5Db250ZW50cy54KCkpOwogICAgIH0KIAogICAgIGlm IChjbG9zZXN0Qm94KSB7Ci0gICAgICAgIGlmICghdXNlV2luZG93c0JlaGF2aW9yICYmIHBvaW50 SW5Db250ZW50cy55KCkgPCBmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxpbmVUb3AoKSAtIHZl cnRpY2FsTGluZUNsaWNrRnVkZ2VGYWN0b3IpIHsKKyAgICAgICAgaWYgKG1vdmVDYXJldFRvQm91 bmRhcnkgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9vdEJveFdpdGhDaGlsZHJlbi0+ bGluZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3RvcikgewogICAgICAgICAgICAg Ly8geSBjb29yZGluYXRlIGlzIGFib3ZlIGZpcnN0IHJvb3QgbGluZSBib3gsIHNvIHJldHVybiB0 aGUgc3RhcnQgb2YgdGhlIGZpcnN0CiAgICAgICAgICAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9u KHBvc2l0aW9uRm9yQm94KGZpcnN0Um9vdEJveFdpdGhDaGlsZHJlbi0+Zmlyc3RMZWFmQ2hpbGQo KSwgdHJ1ZSksIERPV05TVFJFQU0pOwogICAgICAgICB9CkBAIC0zNzU2LDggKzM3NTYsOCBAQCBW aXNpYmxlUG9zaXRpb24gUmVuZGVyQmxvY2s6OnBvc2l0aW9uRm9yUG9pbnRXaXRoSW5saW5lQ2hp bGRyZW4oY29uc3QgSW50UG9pbnQmCiAgICAgfQogCiAgICAgaWYgKGxhc3RSb290Qm94V2l0aENo aWxkcmVuKSB7Ci0gICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9yIE1hYyBiZWhhdmlvciB3 aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgotICAgICAgICBBU1NF UlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9y IG5vbiBXaW5kb3dzIGJlaGF2aW9yIHdoZW4gdGhlIFkgY29vcmRpbmF0ZSBpcyBiZWxvdyB0aGUg bGFzdCBib3guCisgICAgICAgIEFTU0VSVChtb3ZlQ2FyZXRUb0JvdW5kYXJ5KTsKICAgICAgICAg cmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChsYXN0Um9vdEJveFdpdGhDaGls ZHJlbi0+bGFzdExlYWZDaGlsZCgpLCBmYWxzZSksIERPV05TVFJFQU0pOwogICAgIH0KIAotLSAK MS43LjAuNAoK 57430 2010-05-30 20:56:12 -0700 2010-05-30 21:10:31 -0700 3rd simple design - feedback? 0001-now-as-per-darin-s-requests.patch text/plain 21730 tonikitoo RnJvbSBiMzAzYmI0NTMxNjQ2MGFmZDg2NThhYmU5OWZhYjJiNDIzMmFmYTVmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCAyNyBNYXkgMjAxMCAxNzoyNTo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIG5v dyBhcyBwZXIgZGFyaW4ncyByZXF1ZXN0cwoKLS0tCiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJDb3JlLnBybyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIFdlYkNvcmUvZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuY3BwICAgICAgICAgICAgICAgIHwgICA0OCArKysrKysrKysrKysrKysr KysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oICAgICAgICAgICAgICAgICAg fCAgIDQ2ICsrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDQgKysKIFdlYkNvcmUvcGFnZS9TZXR0aW5n cy5oICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNiArLQogV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQmxvY2suY3BwICAgICAgICAgICAgICAgICAgfCAgIDEwICsrLS0KIFdlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5oICAgICAgICAgICAgICAgICAgIHwgICAgNCArLQogV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAgfCAgICA0ICst CiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8ICAg IDIgKy0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbSAgICAgICAgICAgICAgICAgICAg IHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCAgICAgICAg ICAgICAgfCAgICAyICstCiAuLi4vcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwICB8ICAgIDIgKy0KIFdlYktpdC93aW4vV2ViVmlldy5jcHAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAgMiArLQogMTUgZmlsZXMgY2hhbmdlZCwgMTIxIGluc2VydGlv bnMoKyksIDE2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3IuY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5n L0VkaXRpbmdCZWhhdmlvci5oCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBi L1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggZWY5ZjMxOC4uODU2YmVjMCAxMDA2NDQKLS0t IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBA IC05NDMsMTYgKzk0MywxOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGlu Zy9EZWxldGVCdXR0b25Db250cm9sbGVyLmggXAogCVdlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9t VGV4dE5vZGVDb21tYW5kLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9k ZUNvbW1hbmQuaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3Bw IFwKIAlXZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5oIFwKIAlXZWJDb3Jl L2VkaXRpbmcvRWRpdEFjdGlvbi5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdENvbW1hbmQuY3Bw IFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisJV2ViQ29yZS9lZGl0aW5nL0Vk aXRpbmdCZWhhdmlvci5jcHAgXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBc CiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0b3Iu aCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwIFwKIAlXZWJDb3JlL2VkaXRp bmcvRWRpdG9yRGVsZXRlQWN0aW9uLmggXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0b3JJbnNlcnRB Y3Rpb24uaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAgXAogCVdl YkNvcmUvZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0hU TUxJbnRlcmNoYW5nZS5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dl YkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggZDNlYjExNS4uOTVmZTAyNyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC01NDEsMTYgKzU0 MSwxNyBAQCBTT1VSQ0VTICs9IFwKICAgICBlZGl0aW5nL0JyZWFrQmxvY2txdW90ZUNvbW1hbmQu Y3BwIFwKICAgICBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcCBcCiAgICAgZWRpdGlu Zy9DcmVhdGVMaW5rQ29tbWFuZC5jcHAgXAogICAgIGVkaXRpbmcvRGVsZXRlQnV0dG9uQ29udHJv bGxlci5jcHAgXAogICAgIGVkaXRpbmcvRGVsZXRlQnV0dG9uLmNwcCBcCiAgICAgZWRpdGluZy9E ZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rp b25Db21tYW5kLmNwcCBcCiAgICAgZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAgXAorICAgIGVkaXRp bmcvRWRpdGluZ0JlaGF2aW9yLmNwcCBcCiAgICAgZWRpdGluZy9FZGl0b3IuY3BwIFwKICAgICBl ZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwIFwKICAgICBlZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFu ZC5jcHAgXAogICAgIGVkaXRpbmcvaHRtbGVkaXRpbmcuY3BwIFwKICAgICBlZGl0aW5nL0hUTUxJ bnRlcmNoYW5nZS5jcHAgXAogICAgIGVkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwIFwK ICAgICBlZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwIFwKICAgICBlZGl0aW5n L0luc2VydExpbmVCcmVha0NvbW1hbmQuY3BwIFwKQEAgLTEyNzIsMTYgKzEyNzMsMTcgQEAgSEVB REVSUyArPSBcCiAgICAgZWRpdGluZy9CcmVha0Jsb2NrcXVvdGVDb21tYW5kLmggXAogICAgIGVk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9DcmVhdGVMaW5rQ29t bWFuZC5oIFwKICAgICBlZGl0aW5nL0RlbGV0ZUJ1dHRvbkNvbnRyb2xsZXIuaCBcCiAgICAgZWRp dGluZy9EZWxldGVCdXR0b24uaCBcCiAgICAgZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21t YW5kLmggXAogICAgIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5oIFwKICAgICBlZGl0 aW5nL0VkaXRDb21tYW5kLmggXAorICAgIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAogICAg IGVkaXRpbmcvRWRpdG9yLmggXAogICAgIGVkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmggXAog ICAgIGVkaXRpbmcvaHRtbGVkaXRpbmcuaCBcCiAgICAgZWRpdGluZy9IVE1MSW50ZXJjaGFuZ2Uu aCBcCiAgICAgZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oIFwKICAgICBlZGl0aW5nL0lu c2VydEludG9UZXh0Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9JbnNlcnRMaW5lQnJlYWtD b21tYW5kLmggXAogICAgIGVkaXRpbmcvSW5zZXJ0TGlzdENvbW1hbmQuaCBcCmRpZmYgLS1naXQg YS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY4 ZjZmZTkKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9y LmNwcApAQCAtMCwwICsxLDQ4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENv cnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29weXJpZ2h0IChDKSAy MDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2Rp ZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUK KyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog Qm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgorCisjaW5jbHVkZSAiRWRpdG9yLmgiCisjaW5j bHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJTZXR0aW5ncy5oIgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK0VkaXRpbmdCZWhhdmlvcjo6RWRpdGluZ0JlaGF2aW9yKEVkaXRvciogZWRpdG9yKQor ICAgIDogbV9lZGl0b3IoZWRpdG9yKQoreworfQorCitib29sIEVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKCkgY29u c3QKK3sKKyAgICBpZiAoU2V0dGluZ3MqIHNldHRpbmdzID0gc2V0dGluZ3NGb3JFZGl0b3IoKSkK KyAgICAgICAgcmV0dXJuIHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nV2lu ZG93c0JlaGF2aW9yOworCisgICAgcmV0dXJuIGZhbHNlOworfQorCitTZXR0aW5ncyogRWRpdGlu Z0JlaGF2aW9yOjpzZXR0aW5nc0ZvckVkaXRvcigpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fZWRp dG9yLT5mcmFtZSgpLT5zZXR0aW5ncygpOworfQorCit9IC8vIG5hbXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBiL1dlYkNvcmUvZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5mYjcxNjdjCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhh dmlvci5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEg Q29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj CisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u OyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisg KgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0 aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisg KiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIEVkaXRpbmdCZWhh dmlvcl9oCisjZGVmaW5lIEVkaXRpbmdCZWhhdmlvcl9oCisKKyNpbmNsdWRlICJjb25maWcuaCIK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBFZGl0b3I7CitjbGFzcyBTZXR0aW5nczsK KworY2xhc3MgRWRpdGluZ0JlaGF2aW9yIHsKKworcHVibGljOgorICAgIEVkaXRpbmdCZWhhdmlv cihFZGl0b3IqIGVkaXRvcik7CisKKyAgICAvLyBQbGF0Zm9ybSB2YXJpYW50IGVkaXRpbmcgYmVo YXZpb3IgbWV0aG9kcy4KKyAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5k YXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0OworCitwcml2YXRlOgorICAgIFNldHRpbmdz KiBzZXR0aW5nc0ZvckVkaXRvcigpIGNvbnN0OworICAgIEVkaXRvciogbV9lZGl0b3I7Cit9Owor Cit9IC8vIG5hbXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVkaXRpbmdCZWhhdmlvcl9oCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9F ZGl0b3IuY3BwCmluZGV4IDYyYjcxMzQuLmVhZWY5NjUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRp dGluZy9FZGl0b3IuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCkBAIC05MjUs MTYgKzkyNSwxNyBAQCB2b2lkIEVkaXRvcjo6cmVhcHBsaWVkRWRpdGluZyhQYXNzUmVmUHRyPEVk aXRDb21tYW5kPiBjbWQpCiBFZGl0b3I6OkVkaXRvcihGcmFtZSogZnJhbWUpCiAgICAgOiBtX2Zy YW1lKGZyYW1lKQogICAgICwgbV9kZWxldGVCdXR0b25Db250cm9sbGVyKG5ldyBEZWxldGVCdXR0 b25Db250cm9sbGVyKGZyYW1lKSkKICAgICAsIG1faWdub3JlQ29tcG9zaXRpb25TZWxlY3Rpb25D aGFuZ2UoZmFsc2UpCiAgICAgLCBtX3Nob3VsZFN0YXJ0TmV3S2lsbFJpbmdTZXF1ZW5jZShmYWxz ZSkKICAgICAvLyBUaGlzIGlzIG9mZiBieSBkZWZhdWx0LCBzaW5jZSBtb3N0IGVkaXRvcnMgd2Fu dCB0aGlzIGJlaGF2aW9yICh0aGlzIG1hdGNoZXMgSUUgYnV0IG5vdCBGRikuCiAgICAgLCBtX3No b3VsZFN0eWxlV2l0aENTUyhmYWxzZSkKICAgICAsIG1fa2lsbFJpbmcobmV3IEtpbGxSaW5nKQor ICAgICwgbV9lZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yKHRoaXMpKQogeyAKIH0KIAog RWRpdG9yOjp+RWRpdG9yKCkKIHsKIH0KIAogdm9pZCBFZGl0b3I6OmNsZWFyKCkKZGlmZiAtLWdp dCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApp bmRleCAxN2RkM2JiLi5hNzI5YTVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9y LmgKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0yNCwxNiArMjQsMTcgQEAKICAq LwogCiAjaWZuZGVmIEVkaXRvcl9oCiAjZGVmaW5lIEVkaXRvcl9oCiAKICNpbmNsdWRlICJDbGlw Ym9hcmRBY2Nlc3NQb2xpY3kuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUgIkVkaXRB Y3Rpb24uaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3IuaCIKICNpbmNsdWRlICJFZGl0b3JE ZWxldGVBY3Rpb24uaCIKICNpbmNsdWRlICJFZGl0b3JJbnNlcnRBY3Rpb24uaCIKICNpbmNsdWRl ICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3Mg Q1NTU3R5bGVEZWNsYXJhdGlvbjsKIGNsYXNzIENsaXBib2FyZDsKQEAgLTI3NiwxNiArMjc3LDE4 IEBAIHB1YmxpYzoKICAgICBQYXNzUmVmUHRyPFJhbmdlPiByYW5nZUZvclBvaW50KGNvbnN0IElu dFBvaW50JiB3aW5kb3dQb2ludCk7CiAKICAgICB2b2lkIGNsZWFyKCk7CiAKICAgICBWaXNpYmxl U2VsZWN0aW9uIHNlbGVjdGlvbkZvckNvbW1hbmQoRXZlbnQqKTsKIAogICAgIEtpbGxSaW5nKiBr aWxsUmluZygpIGNvbnN0IHsgcmV0dXJuIG1fa2lsbFJpbmcuZ2V0KCk7IH0KIAorICAgIEVkaXRp bmdCZWhhdmlvciBiZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIG1fZWRpdGluZ0JlaGF2aW9yOyB9 CisKICAgICBQYXNzUmVmUHRyPFJhbmdlPiBzZWxlY3RlZFJhbmdlKCk7CiAgICAgCiAgICAgLy8g V2Ugc2hvdWxkIG1ha2UgdGhlc2UgZnVuY3Rpb25zIHByaXZhdGUgd2hlbiB0aGVpciBjYWxsZXJz IGluIEZyYW1lIGFyZSBtb3ZlZCBvdmVyIGhlcmUgdG8gRWRpdG9yCiAgICAgYm9vbCBpbnNpZGVW aXNpYmxlQXJlYShjb25zdCBJbnRQb2ludCYpIGNvbnN0OwogICAgIGJvb2wgaW5zaWRlVmlzaWJs ZUFyZWEoUmFuZ2UqKSBjb25zdDsKICAgICBQYXNzUmVmUHRyPFJhbmdlPiBuZXh0VmlzaWJsZVJh bmdlKFJhbmdlKiwgY29uc3QgU3RyaW5nJiwgYm9vbCBmb3J3YXJkLCBib29sIGNhc2VGbGFnLCBi b29sIHdyYXBGbGFnKTsKICAgICAKICAgICB2b2lkIGFkZFRvS2lsbFJpbmcoUmFuZ2UqLCBib29s IHByZXBlbmQpOwpAQCAtMjk4LDE2ICszMDEsMTcgQEAgcHJpdmF0ZToKICAgICBSZWZQdHI8VGV4 dD4gbV9jb21wb3NpdGlvbk5vZGU7CiAgICAgdW5zaWduZWQgbV9jb21wb3NpdGlvblN0YXJ0Owog ICAgIHVuc2lnbmVkIG1fY29tcG9zaXRpb25FbmQ7CiAgICAgVmVjdG9yPENvbXBvc2l0aW9uVW5k ZXJsaW5lPiBtX2N1c3RvbUNvbXBvc2l0aW9uVW5kZXJsaW5lczsKICAgICBib29sIG1faWdub3Jl Q29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2U7CiAgICAgYm9vbCBtX3Nob3VsZFN0YXJ0TmV3S2ls bFJpbmdTZXF1ZW5jZTsKICAgICBib29sIG1fc2hvdWxkU3R5bGVXaXRoQ1NTOwogICAgIE93blB0 cjxLaWxsUmluZz4gbV9raWxsUmluZzsKKyAgICBFZGl0aW5nQmVoYXZpb3IgbV9lZGl0aW5nQmVo YXZpb3I7CiAKICAgICBib29sIGNhbkRlbGV0ZVJhbmdlKFJhbmdlKikgY29uc3Q7CiAgICAgYm9v bCBjYW5TbWFydFJlcGxhY2VXaXRoUGFzdGVib2FyZChQYXN0ZWJvYXJkKik7CiAgICAgUGFzc1Jl ZlB0cjxDbGlwYm9hcmQ+IG5ld0dlbmVyYWxDbGlwYm9hcmQoQ2xpcGJvYXJkQWNjZXNzUG9saWN5 KTsKICAgICB2b2lkIHBhc3RlQXNQbGFpblRleHRXaXRoUGFzdGVib2FyZChQYXN0ZWJvYXJkKik7 CiAgICAgdm9pZCBwYXN0ZVdpdGhQYXN0ZWJvYXJkKFBhc3RlYm9hcmQqLCBib29sIGFsbG93UGxh aW5UZXh0KTsKICAgICB2b2lkIHJlcGxhY2VTZWxlY3Rpb25XaXRoRnJhZ21lbnQoUGFzc1JlZlB0 cjxEb2N1bWVudEZyYWdtZW50PiwgYm9vbCBzZWxlY3RSZXBsYWNlbWVudCwgYm9vbCBzbWFydFJl cGxhY2UsIGJvb2wgbWF0Y2hTdHlsZSk7CiAgICAgdm9pZCByZXBsYWNlU2VsZWN0aW9uV2l0aFRl eHQoY29uc3QgU3RyaW5nJiwgYm9vbCBzZWxlY3RSZXBsYWNlbWVudCwgYm9vbCBzbWFydFJlcGxh Y2UpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuaAppbmRleCBkYzNiNTBmLi5mNjJhZTMxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtNTgsMTcgKzU4 LDE3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAvLyAgICAyKSBQdXNoaW5nIHRoZSBkb3du IGFycm93IGtleSBvbiB0aGUgbGFzdCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQgb2Yg dGhlCiAgICAgLy8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBX aW5kb3dzLiBBIHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCiAgICAgLy8gICAgICAgdG9wIGxp bmUuCiAgICAgLy8KICAgICAvLyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0 aGVzZSBzb3J0cyBvZiBiZWhhdmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCiAgICAgLy8gYmVo YXZpb3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNt YXJ0IGNvcHkgYW5kIHBhc3RlIGFuZAogICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIg YSBkb3VibGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCiAgICAg Ly8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7 IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OworICAgIGVudW0g RWRpdGluZ0JlaGF2aW9yVHlwZSB7IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NC ZWhhdmlvciB9OwogCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJsaWMgTm9uY29weWFibGUgewog ICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSopOwogCiAgICAgICAgIHZvaWQgc2V0 U3RhbmRhcmRGb250RmFtaWx5KGNvbnN0IEF0b21pY1N0cmluZyYpOwogICAgICAgICBjb25zdCBB dG9taWNTdHJpbmcmIHN0YW5kYXJkRm9udEZhbWlseSgpIGNvbnN0IHsgcmV0dXJuIG1fc3RhbmRh cmRGb250RmFtaWx5OyB9CiAKQEAgLTI2NSwxOCArMjY1LDE4IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgLy8gV2luZG93cyBkZWJ1Z2dpbmcgcHJlZiAoZ2xvYmFsKSBmb3Igc3dpdGNo aW5nIGJldHdlZW4gdGhlIEFxdWEgbG9vayBhbmQgYSBuYXRpdmUgd2luZG93cyBsb29rLgogICAg ICAgICBzdGF0aWMgdm9pZCBzZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKGJvb2wpOwogICAg ICAgICBzdGF0aWMgYm9vbCBzaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKCkgeyByZXR1cm4gZ1No b3VsZFBhaW50TmF0aXZlQ29udHJvbHM7IH0KICNlbmRpZgogCiAgICAgICAgIHZvaWQgc2V0QWxs b3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7CiAgICAgICAgIGJvb2wgYWxsb3dTY3JpcHRz VG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVybiBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5k b3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9y IGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0KLSAgICAgICAgRWRp dGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0 PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVoYXZpb3IpOyB9CisgICAgICAgIHZvaWQgc2V0 RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvclR5cGUgYmVoYXZpb3IpIHsgbV9lZGl0aW5n QmVoYXZpb3IgPSBiZWhhdmlvcjsgfQorICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlIGVkaXRp bmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvclR5 cGU+KG1fZWRpdGluZ0JlaGF2aW9yKTsgfQogICAgICAgICAKICAgICAgICAgdm9pZCBzZXREb3du bG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJvb2wgZG93bmxvYWRh YmxlQmluYXJ5Rm9udHNFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZGFibGVCaW5h cnlGb250c0VuYWJsZWQ7IH0KIAogICAgICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFibGVkKGJv b2wpOwogICAgICAgICBib29sIHhzc0F1ZGl0b3JFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV94 c3NBdWRpdG9yRW5hYmxlZDsgfQogCiAgICAgICAgIHZvaWQgc2V0QWNjZWxlcmF0ZWRDb21wb3Np dGluZ0VuYWJsZWQoYm9vbCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC bG9jay5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggOWM2YjM1 My4uMjM1ZmVkOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3Bw CisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtMTksMTYgKzE5LDE3 IEBACiAgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQsIEZpZnRoIEZsb29yLAogICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCiAgKi8K IAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCiAKICNpbmNs dWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgogI2luY2x1ZGUg IkVsZW1lbnQuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2lu Y2x1ZGUgIkhUTUxGb3JtRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1 ZGUgIkhpdFRlc3RSZXN1bHQuaCIKQEAgLTM3MTMsMzcgKzM3MTQsMzYgQEAgVmlzaWJsZVBvc2l0 aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0 IEludFBvaW50JgogICAgICAgICAvLyBjaGVjayBpZiB0aGlzIHJvb3QgbGluZSBib3ggaXMgbG9j YXRlZCBhdCB0aGlzIHkgY29vcmRpbmF0ZQogICAgICAgICBpZiAocG9pbnRJbkNvbnRlbnRzLnko KSA8IGJvdHRvbSkgewogICAgICAgICAgICAgY2xvc2VzdEJveCA9IHJvb3QtPmNsb3Nlc3RMZWFm Q2hpbGRGb3JYUG9zKHBvaW50SW5Db250ZW50cy54KCkpOwogICAgICAgICAgICAgaWYgKGNsb3Nl c3RCb3gpCiAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBT ZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudCgpLT5zZXR0aW5ncygpOwotICAgIGJvb2wgdXNl V2luZG93c0JlaGF2aW9yID0gc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigp ID09IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CisgICAgYm9vbCBtb3ZlQ2FyZXRUb0JvdW5kYXJ5 ID0gZnJhbWUoKS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9u dGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKCk7CiAKLSAgICBpZiAodXNlV2luZG93c0Jl aGF2aW9yICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CisgICAg aWYgKCFtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0 aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBiZWxvdyBsYXN0IHJvb3Qg bGluZSBib3gsIHByZXRlbmQgd2UgaGl0IGl0CiAgICAgICAgIGNsb3Nlc3RCb3ggPSBsYXN0Um9v dEJveFdpdGhDaGlsZHJlbi0+Y2xvc2VzdExlYWZDaGlsZEZvclhQb3MocG9pbnRJbkNvbnRlbnRz LngoKSk7CiAgICAgfQogCiAgICAgaWYgKGNsb3Nlc3RCb3gpIHsKLSAgICAgICAgaWYgKCF1c2VX aW5kb3dzQmVoYXZpb3IgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9vdEJveFdpdGhD aGlsZHJlbi0+bGluZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3RvcikgeworICAg ICAgICBpZiAobW92ZUNhcmV0VG9Cb3VuZGFyeSAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmly c3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdl RmFjdG9yKSB7CiAgICAgICAgICAgICAvLyB5IGNvb3JkaW5hdGUgaXMgYWJvdmUgZmlyc3Qgcm9v dCBsaW5lIGJveCwgc28gcmV0dXJuIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QKICAgICAgICAgICAg IHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3goZmlyc3RSb290Qm94V2l0aENo aWxkcmVuLT5maXJzdExlYWZDaGlsZCgpLCB0cnVlKSwgRE9XTlNUUkVBTSk7CiAgICAgICAgIH0K IAogICAgICAgICAvLyBwYXNzIHRoZSBib3ggYSB5IHBvc2l0aW9uIHRoYXQgaXMgaW5zaWRlIGl0 CiAgICAgICAgIHJldHVybiBjbG9zZXN0Qm94LT5yZW5kZXJlcigpLT5wb3NpdGlvbkZvclBvaW50 KEludFBvaW50KHBvaW50SW5Db250ZW50cy54KCksIGNsb3Nlc3RCb3gtPm1feSkpOwogICAgIH0K IAogICAgIGlmIChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewogICAgICAgICAvLyBXZSBoaXQg dGhpcyBjYXNlIGZvciBNYWMgYmVoYXZpb3Igd2hlbiB0aGUgWSBjb29yZGluYXRlIGlzIGJlbG93 IHRoZSBsYXN0IGJveC4KLSAgICAgICAgQVNTRVJUKCF1c2VXaW5kb3dzQmVoYXZpb3IpOworICAg ICAgICBBU1NFUlQobW92ZUNhcmV0VG9Cb3VuZGFyeSk7CiAgICAgICAgIHJldHVybiBWaXNpYmxl UG9zaXRpb24ocG9zaXRpb25Gb3JCb3gobGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxhc3RMZWFm Q2hpbGQoKSwgZmFsc2UpLCBET1dOU1RSRUFNKTsKICAgICB9CiAKICAgICAvLyBDYW4ndCByZWFj aCB0aGlzLiBXZSBoYXZlIGEgcm9vdCBsaW5lIGJveCwgYnV0IGl0IGhhcyBubyBraWRzLgogICAg IC8vIEZJWE1FOiBUaGlzIHNob3VsZCBBU1NFUlRfTk9UX1JFQUNIRUQoKSwgYnV0IGNsaWNraW5n IG9uIHBsYWNlaG9sZGVyIHRleHQKICAgICAvLyBzZWVtcyB0byBoaXQgdGhpcyBjb2RlIHBhdGgu CiAgICAgcmV0dXJuIGNyZWF0ZVZpc2libGVQb3NpdGlvbigwLCBET1dOU1RSRUFNKTsKIH0KZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyT2JqZWN0LmgKaW5kZXggM2ZmMzhhYi4uZjJiMzEzOSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmgKQEAgLTQ0NSwxOSArNDQ1LDIxIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgdXBkYXRlRHJhZ1N0YXRlKGJvb2wgZHJhZ09uKTsKIAogICAgIFJlbmRlclZpZXcqIHZp ZXcoKSBjb25zdDsKIAogICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGlzIHJlbmRlcmVyIGlzIHJv b3RlZCwgYW5kIG9wdGlvbmFsbHkgcmV0dXJucyB0aGUgaG9zdGluZyB2aWV3ICh0aGUgcm9vdCBv ZiB0aGUgaGllcmFyY2h5KS4KICAgICBib29sIGlzUm9vdGVkKFJlbmRlclZpZXcqKiA9IDApOwog CiAgICAgTm9kZSogbm9kZSgpIGNvbnN0IHsgcmV0dXJuIG1faXNBbm9ueW1vdXMgPyAwIDogbV9u b2RlOyB9Ci0gICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9ub2RlLT5k b2N1bWVudCgpOyB9CiAgICAgdm9pZCBzZXROb2RlKE5vZGUqIG5vZGUpIHsgbV9ub2RlID0gbm9k ZTsgfQogCisgICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9ub2RlLT5k b2N1bWVudCgpOyB9CisgICAgRnJhbWUqIGZyYW1lKCkgY29uc3QgeyByZXR1cm4gZG9jdW1lbnQo KS0+ZnJhbWUoKTsgfQorCiAgICAgYm9vbCBoYXNPdXRsaW5lQW5ub3RhdGlvbigpIGNvbnN0Owog ICAgIGJvb2wgaGFzT3V0bGluZSgpIGNvbnN0IHsgcmV0dXJuIHN0eWxlKCktPmhhc091dGxpbmUo KSB8fCBoYXNPdXRsaW5lQW5ub3RhdGlvbigpOyB9CiAKICAgICAvLyBSZXR1cm5zIHRoZSBvYmpl Y3QgY29udGFpbmluZyB0aGlzIG9uZS4gQ2FuIGJlIGRpZmZlcmVudCBmcm9tIHBhcmVudCBmb3Ig cG9zaXRpb25lZCBlbGVtZW50cy4KICAgICAvLyBJZiByZXBhaW50Q29udGFpbmVyIGFuZCByZXBh aW50Q29udGFpbmVyU2tpcHBlZCBhcmUgbm90IG51bGwsIG9uIHJldHVybiAqcmVwYWludENvbnRh aW5lclNraXBwZWQKICAgICAvLyBpcyB0cnVlIGlmIHRoZSByZW5kZXJlciByZXR1cm5lZCBpcyBh biBhbmNlc3RvciBvZiByZXBhaW50Q29udGFpbmVyLgogICAgIFJlbmRlck9iamVjdCogY29udGFp bmVyKFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyID0gMCwgYm9vbCogcmVw YWludENvbnRhaW5lclNraXBwZWQgPSAwKSBjb25zdDsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcAppbmRleCBkMjc0NzA4Li43MDlkYzVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcApAQCAtMTI0LDE5ICsxMjQsMTkgQEAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBj b3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCiB7CiAgICAgU291cE1lc3NhZ2Uq IHNvdXBNZXNzYWdlID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2UocmVzcG9u c2UpOwogICAgIGlmIChzb3VwTWVzc2FnZSkKICAgICAgICAgcmV0dXJuIFJlc291cmNlUmVzcG9u c2Uoc291cE1lc3NhZ2UpOwogCiAgICAgcmV0dXJuIFJlc291cmNlUmVzcG9uc2UoKTsKIH0KIAot V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUp CitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9y IHR5cGUpCiB7Ci0gICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IpdHlwZTsKKyAg ICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUpdHlwZTsKIH0KIAogV2ViS2l0 SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNvcmU6OkhpdFRlc3RSZXN1bHQmIHJlc3VsdCkK IHsKICAgICBndWludCBjb250ZXh0ID0gV0VCS0lUX0hJVF9URVNUX1JFU1VMVF9DT05URVhUX0RP Q1VNRU5UOwogICAgIEdPd25QdHI8Y2hhcj4gbGlua1VSSSgwKTsKICAgICBHT3duUHRyPGNoYXI+ IGltYWdlVVJJKDApOwogICAgIEdPd25QdHI8Y2hhcj4gbWVkaWFVUkkoMCk7CmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmgKaW5kZXggMDU3YjBlNS4uNmFlY2MxMyAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaApAQCAtOTAsMTcgKzkwLDE3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAg V2ViS2l0V2ViTmF2aWdhdGlvblJlYXNvbiBraXQoV2ViQ29yZTo6TmF2aWdhdGlvblR5cGUgdHlw ZSk7CiAgICAgV2ViQ29yZTo6TmF2aWdhdGlvblR5cGUgY29yZShXZWJLaXRXZWJOYXZpZ2F0aW9u UmVhc29uIHJlYXNvbik7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgY29yZShXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3Bv bnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CiAKLSAgICBXZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CisgICAg V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0 eXBlKTsKIAogICAgIFdlYktpdFNlY3VyaXR5T3JpZ2luKiBraXQoV2ViQ29yZTo6U2VjdXJpdHlP cmlnaW4qKTsKICAgICBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiogY29yZShXZWJLaXRTZWN1cml0 eU9yaWdpbiopOwogCiAgICAgV2ViS2l0SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNvcmU6 OkhpdFRlc3RSZXN1bHQmKTsKIAogICAgIFdlYktpdDo6UGFzdGVib2FyZEhlbHBlckd0ayogcGFz dGVib2FyZEhlbHBlckluc3RhbmNlKCk7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5 ZjE3Ny4uN2M1OTYxNSAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1t CisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbQpAQCAtMTkxLDE3ICsxOTEsMTcg QEAgRWRpdGFibGVMaW5rQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvciBl ZGl0YWJsZUxpbmtCZWhhdmlvcikKICAgICAgICAgICAgIHJldHVybiBFZGl0YWJsZUxpbmtMaXZl V2hlbk5vdEZvY3VzZWQ7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGFibGVMaW5rTmV2ZXJMaXZl OgogICAgICAgICAgICAgcmV0dXJuIEVkaXRhYmxlTGlua05ldmVyTGl2ZTsKICAgICB9CiAgICAg QVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgcmV0dXJuIEVkaXRhYmxlTGlua0RlZmF1bHRCZWhh dmlvcjsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0Jl aGF2aW9yIGJlaGF2aW9yKQorV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktp dEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKICAgICBzd2l0Y2ggKGJlaGF2aW9yKSB7CiAg ICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ01hY0JlaGF2aW9yOgogICAgICAgICAgICAgcmV0dXJu IFdlYkNvcmU6OkVkaXRpbmdNYWNCZWhhdmlvcjsKICAgICAgICAgY2FzZSBXZWJLaXRFZGl0aW5n V2luQmVoYXZpb3I6CiAgICAgICAgICAgICByZXR1cm4gV2ViQ29yZTo6RWRpdGluZ1dpbmRvd3NC ZWhhdmlvcjsKICAgICB9CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CmRpZmYgLS1naXQgYS9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oIGIvV2ViS2l0L21hYy9XZWJWaWV3 L1dlYkZyYW1lSW50ZXJuYWwuaAppbmRleCA5YjIyNDhhLi41ODZiNGMzIDEwMDY0NAotLS0gYS9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCisrKyBiL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJGcmFtZUludGVybmFsLmgKQEAgLTY2LDE3ICs2NiwxNyBAQCB0eXBlZGVmIFdlYkNv cmU6Okhpc3RvcnlJdGVtIFdlYkNvcmVIaXN0b3J5SXRlbTsKIFdlYkNvcmU6OkZyYW1lKiBjb3Jl KFdlYkZyYW1lICopOwogV2ViRnJhbWUgKmtpdChXZWJDb3JlOjpGcmFtZSAqKTsKIAogV2ViQ29y ZTo6UGFnZSogY29yZShXZWJWaWV3ICopOwogV2ViVmlldyAqa2l0KFdlYkNvcmU6OlBhZ2UqKTsK IAogV2ViQ29yZTo6RWRpdGFibGVMaW5rQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0YWJsZUxpbmtC ZWhhdmlvcik7CiBXZWJDb3JlOjpUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9y IGNvcmUoV2ViVGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcik7Ci1XZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IpOworV2ViQ29yZTo6 RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvcik7CiAKIFdlYlZp ZXcgKmdldFdlYlZpZXcoV2ViRnJhbWUgKndlYkZyYW1lKTsKIAogQGludGVyZmFjZSBXZWJGcmFt ZVByaXZhdGUgOiBOU09iamVjdCB7CiBAcHVibGljCiAgICAgV2ViQ29yZTo6RnJhbWUqIGNvcmVG cmFtZTsKICAgICBXZWJGcmFtZVZpZXcgKndlYkZyYW1lVmlldzsKICAgICBXZWJTY3JpcHREZWJ1 Z2dlciogc2NyaXB0RGVidWdnZXI7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBv cnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0 L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcAppbmRleCAwYjJlOWE1Li44MTI3NjNkIDEwMDY0 NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQu Y3BwCisrKyBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRR dC5jcHAKQEAgLTQ3MSwxNyArNDcxLDE3IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6 OmVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChRV2ViRnJhbWUqCiAKICAg ICByZXR1cm4gKGlucHV0RWxlbWVudC0+aXNUZXh0RmllbGQoKQogICAgICAgICAgICAgJiYgaW5w dXRFbGVtZW50LT5pbnB1dFR5cGUoKSAhPSBIVE1MSW5wdXRFbGVtZW50OjpQQVNTV09SRAogICAg ICAgICAgICAgJiYgaW5wdXRFbGVtZW50LT5hdXRvQ29tcGxldGUoKSk7CiB9CiAKIHZvaWQgRHVt cFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwg Y29uc3QgUVN0cmluZyYgZWRpdGluZ0JlaGF2aW9yKQogewotICAgIFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvciBjb3JlRWRpdGluZ0JlaGF2aW9yOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlv clR5cGUgY29yZUVkaXRpbmdCZWhhdmlvcjsKIAogICAgIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0g IndpbiIpCiAgICAgICAgIGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2luZG93c0JlaGF2 aW9yOwogICAgIGVsc2UgaWYgKGVkaXRpbmdCZWhhdmlvciA9PSAibWFjIikKICAgICAgICAgY29y ZUVkaXRpbmdCZWhhdmlvciA9IEVkaXRpbmdNYWNCZWhhdmlvcjsKIAogICAgIFBhZ2UqIGNvcmVQ YWdlID0gUVdlYlBhZ2VQcml2YXRlOjpjb3JlKHBhZ2UpOwogICAgIGlmICghY29yZVBhZ2UpCmRp ZmYgLS1naXQgYS9XZWJLaXQvd2luL1dlYlZpZXcuY3BwIGIvV2ViS2l0L3dpbi9XZWJWaWV3LmNw cAppbmRleCA1MjUxMDhmLi5mZTg2YmZiIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL1dlYlZpZXcu Y3BwCisrKyBiL1dlYktpdC93aW4vV2ViVmlldy5jcHAKQEAgLTQ2NDksMTcgKzQ2NDksMTcgQEAg SFJFU1VMVCBXZWJWaWV3Ojpub3RpZnlQcmVmZXJlbmNlc0NoYW5nZWQoSVdlYk5vdGlmaWNhdGlv biogbm90aWZpY2F0aW9uKQogICAgIGlmIChGQUlMRUQoaHIpKQogICAgICAgICByZXR1cm4gaHI7 CiAgICAgc2V0dGluZ3MtPnNldEVkaXRhYmxlTGlua0JlaGF2aW9yKChFZGl0YWJsZUxpbmtCZWhh dmlvciliZWhhdmlvcik7CiAKICAgICBXZWJLaXRFZGl0aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2 aW9yOwogICAgIGhyID0gcHJlZmVyZW5jZXMtPmVkaXRpbmdCZWhhdmlvcigmZWRpdGluZ0JlaGF2 aW9yKTsKICAgICBpZiAoRkFJTEVEKGhyKSkKICAgICAgICAgcmV0dXJuIGhyOwotICAgIHNldHRp bmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoKEVkaXRpbmdCZWhhdmlvcillZGl0aW5nQmVoYXZpb3Ip OworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoKEVkaXRpbmdCZWhhdmlvclR5cGUp ZWRpdGluZ0JlaGF2aW9yKTsKIAogICAgIGhyID0gcHJlZmVyZW5jZXMtPnVzZXNQYWdlQ2FjaGUo JmVuYWJsZWQpOwogICAgIGlmIChGQUlMRUQoaHIpKQogICAgICAgICByZXR1cm4gaHI7CiAgICAg c2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoISFlbmFibGVkKTsKIAogICAgIGhyID0gcHJlZmVy ZW5jZXMtPmlzRE9NUGFzdGVBbGxvd2VkKCZlbmFibGVkKTsKICAgICBpZiAoRkFJTEVEKGhyKSkK LS0gCjEuNy4wLjQKCg== 57431 2010-05-30 21:02:05 -0700 2010-05-31 08:17:24 -0700 3rd simple design (right file) - feedback? 0001-now-as-per-darin-s-requests.patch text/plain 13511 tonikitoo RnJvbSBmYTRjNjg1OTI3ZTdkMTdjNTQ3NzcxYTNjZGI0ZDgyMDZjMGJhYzUwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCAyNyBNYXkgMjAxMCAxNzoyNTo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIG5v dyBhcyBwZXIgZGFyaW4ncyByZXF1ZXN0cwoKLS0tCiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJDb3JlLnBybyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIFdlYkNvcmUvZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuY3BwICAgICAgICAgICAgICAgIHwgICAzOCArKysrKysrKysrKysrKysr CiBXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggICAgICAgICAgICAgICAgICB8ICAg NDYgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAgNSArKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAzICsKIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5o ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNiArLQogV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyQmxvY2suY3BwICAgICAgICAgICAgICAgICAgfCAgIDEwICsrLS0KIFdlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAgICAgIHwgICAgNCArLQogV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBX ZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gICAgICAgICAgICAgICAgICAgICB8ICAgIDIg Ky0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmggICAgICAgICAgICAgIHwg ICAgMiArLQogLi4uL3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNw cCAgfCAgICAyICstCiBXZWJLaXQvd2luL1dlYlZpZXcuY3BwICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgIDIgKy0KIDE0IGZpbGVzIGNoYW5nZWQsIDExMSBpbnNlcnRpb25zKCspLCAx NSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5n QmVoYXZpb3IuaAoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3Jl L0dOVW1ha2VmaWxlLmFtCmluZGV4IGVmOWYzMTguLjg1NmJlYzAgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtOTQ4LDYg Kzk0OCw4IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRBY3Rp b24uaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRDb21tYW5kLmNwcCBcCiAJV2ViQ29yZS9lZGl0 aW5nL0VkaXRDb21tYW5kLmggXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuY3Bw IFwKKwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAogCVdlYkNvcmUvZWRpdGlu Zy9FZGl0b3IuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggXAogCVdlYkNvcmUvZWRp dGluZy9FZGl0b3JDb21tYW5kLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJv IGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCBkM2ViMTE1Li45NWZlMDI3IDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTU0Niw2 ICs1NDYsNyBAQCBTT1VSQ0VTICs9IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQuY3BwIFwKICAgICBlZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwIFwKICAg ICBlZGl0aW5nL0VkaXRDb21tYW5kLmNwcCBcCisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3Iu Y3BwIFwKICAgICBlZGl0aW5nL0VkaXRvci5jcHAgXAogICAgIGVkaXRpbmcvRWRpdG9yQ29tbWFu ZC5jcHAgXAogICAgIGVkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcCBcCkBAIC0xMjc3LDYg KzEyNzgsNyBAQCBIRUFERVJTICs9IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQuaCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmggXAogICAgIGVk aXRpbmcvRWRpdENvbW1hbmQuaCBcCisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBcCiAg ICAgZWRpdGluZy9FZGl0b3IuaCBcCiAgICAgZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuaCBc CiAgICAgZWRpdGluZy9odG1sZWRpdGluZy5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3IuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2U5OGFjOAotLS0gL2Rldi9u dWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuY3BwCkBAIC0wLDAgKzEs MzggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29y IGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRWRpdGlu Z0JlaGF2aW9yLmgiCisKKyNpbmNsdWRlICJFZGl0b3IuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgor I2luY2x1ZGUgIlNldHRpbmdzLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworYm9vbCBFZGl0 aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RU b3BPckJvdHRvbSgpIGNvbnN0Cit7CisgICAgaWYgKCFtX3NldHRpbmdzKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICByZXR1cm4gbV9zZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgIT0g RWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKK30KKworfSAvLyBuYW1zcGFjZSBXZWJDb3JlCmRpZmYg LS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggYi9XZWJDb3JlL2VkaXRp bmcvRWRpdGluZ0JlaGF2aW9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u NDNmZjQ1MAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3IuaApAQCAtMCwwICsxLDQ2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENv cnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29weXJpZ2h0IChDKSAy MDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2Rp ZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUK KyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog Qm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBFZGl0aW5nQmVoYXZp b3JfaAorI2RlZmluZSBFZGl0aW5nQmVoYXZpb3JfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K2NsYXNzIEVkaXRvcjsKK2NsYXNzIFNldHRpbmdzOworCitjbGFzcyBFZGl0aW5nQmVoYXZpb3Ig eworCitwdWJsaWM6CisgICAgRWRpdGluZ0JlaGF2aW9yKFNldHRpbmdzKiBzZXR0aW5ncykKKyAg ICAgICAgOiBtX3NldHRpbmdzKHNldHRpbmdzKQorICAgIHsKKyAgICB9CisKKyAgICAvLyBQbGF0 Zm9ybSB2YXJpYW50IGVkaXRpbmcgYmVoYXZpb3IgbWV0aG9kcy4KKyAgICBib29sIHNob3VsZE1v dmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0Owor Citwcml2YXRlOgorICAgIFNldHRpbmdzKiBtX3NldHRpbmdzOworfTsKKworfSAvLyBuYW1zcGFj ZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFZGl0aW5nQmVoYXZpb3JfaApkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcAppbmRl eCA2MmI3MTM0Li42Y2JlZDMyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNw cAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcApAQCAtOTcsNiArOTcsMTEgQEAgVmlz aWJsZVNlbGVjdGlvbiBFZGl0b3I6OnNlbGVjdGlvbkZvckNvbW1hbmQoRXZlbnQqIGV2ZW50KQog ICAgIHJldHVybiBzZWxlY3Rpb247CiB9CiAKK0VkaXRpbmdCZWhhdmlvciBFZGl0b3I6OmJlaGF2 aW9yKCkgY29uc3QKK3sKKyAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKG1fZnJhbWUtPnNldHRp bmdzKCkpOworfQorCiBFZGl0b3JDbGllbnQqIEVkaXRvcjo6Y2xpZW50KCkgY29uc3QKIHsKICAg ICBpZiAoUGFnZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9FZGl0b3IuaCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAppbmRleCAxN2RkM2Ji Li4zZTIyM2RjIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKKysrIGIvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSAiQ2xpcGJv YXJkQWNjZXNzUG9saWN5LmgiCiAjaW5jbHVkZSAiQ29sb3IuaCIKICNpbmNsdWRlICJFZGl0QWN0 aW9uLmgiCisjaW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5jbHVkZSAiRWRpdG9yRGVs ZXRlQWN0aW9uLmgiCiAjaW5jbHVkZSAiRWRpdG9ySW5zZXJ0QWN0aW9uLmgiCiAjaW5jbHVkZSAi U2VsZWN0aW9uQ29udHJvbGxlci5oIgpAQCAtMjgxLDYgKzI4Miw4IEBAIHB1YmxpYzoKIAogICAg IEtpbGxSaW5nKiBraWxsUmluZygpIGNvbnN0IHsgcmV0dXJuIG1fa2lsbFJpbmcuZ2V0KCk7IH0K IAorICAgIEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcigpIGNvbnN0OworCiAgICAgUGFzc1JlZlB0 cjxSYW5nZT4gc2VsZWN0ZWRSYW5nZSgpOwogICAgIAogICAgIC8vIFdlIHNob3VsZCBtYWtlIHRo ZXNlIGZ1bmN0aW9ucyBwcml2YXRlIHdoZW4gdGhlaXIgY2FsbGVycyBpbiBGcmFtZSBhcmUgbW92 ZWQgb3ZlciBoZXJlIHRvIEVkaXRvcgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRleCBkYzNiNTBmLi5mNjJhZTMxIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuaApAQCAtNjMsNyArNjMsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgLy8gYmVoYXZp b3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0 IGNvcHkgYW5kIHBhc3RlIGFuZAogICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBk b3VibGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCiAgICAgLy8g aWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7IEVk aXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OworICAgIGVudW0gRWRp dGluZ0JlaGF2aW9yVHlwZSB7IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhh dmlvciB9OwogCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJsaWMgTm9uY29weWFibGUgewogICAg IHB1YmxpYzoKQEAgLTI3MCw4ICsyNzAsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAg IHZvaWQgc2V0QWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7CiAgICAgICAgIGJvb2wg YWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVybiBtX2FsbG93U2NyaXB0 c1RvQ2xvc2VXaW5kb3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZpb3IoRWRp dGluZ0JlaGF2aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0K LSAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJu IHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVoYXZpb3IpOyB9CisgICAg ICAgIHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvclR5cGUgYmVoYXZpb3Ip IHsgbV9lZGl0aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsgfQorICAgICAgICBFZGl0aW5nQmVoYXZp b3JUeXBlIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRp bmdCZWhhdmlvclR5cGU+KG1fZWRpdGluZ0JlaGF2aW9yKTsgfQogICAgICAgICAKICAgICAgICAg dm9pZCBzZXREb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJv b2wgZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3du bG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQ7IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApp bmRleCA3ODY2Y2NjLi5lMDdjZmEyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCkBAIC0y NCw2ICsyNCw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKIAogI2luY2x1ZGUgIkRvY3Vt ZW50LmgiCisjaW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5jbHVkZSAiRWxlbWVudC5o IgogI2luY2x1ZGUgIkZsb2F0UXVhZC5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCkBAIC0zNzE4LDE2 ICszNzE5LDE1IEBAIFZpc2libGVQb3NpdGlvbiBSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2lu dFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQb2ludCYKICAgICAgICAgfQogICAgIH0KIAot ICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50KCktPnNldHRpbmdzKCk7Ci0gICAgYm9v bCB1c2VXaW5kb3dzQmVoYXZpb3IgPSBzZXR0aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2 aW9yKCkgPT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKKyAgICBib29sIG1vdmVDYXJldFRvQm91 bmRhcnkgPSBmcmFtZSgpLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRNb3ZlQ2FyZXRUb0hv cml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKTsKIAotICAgIGlmICh1c2VXaW5k b3dzQmVoYXZpb3IgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsK KyAgICBpZiAoIW1vdmVDYXJldFRvQm91bmRhcnkgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RC b3hXaXRoQ2hpbGRyZW4pIHsKICAgICAgICAgLy8geSBjb29yZGluYXRlIGlzIGJlbG93IGxhc3Qg cm9vdCBsaW5lIGJveCwgcHJldGVuZCB3ZSBoaXQgaXQKICAgICAgICAgY2xvc2VzdEJveCA9IGxh c3RSb290Qm94V2l0aENoaWxkcmVuLT5jbG9zZXN0TGVhZkNoaWxkRm9yWFBvcyhwb2ludEluQ29u dGVudHMueCgpKTsKICAgICB9CiAKICAgICBpZiAoY2xvc2VzdEJveCkgewotICAgICAgICBpZiAo IXVzZVdpbmRvd3NCZWhhdmlvciAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94 V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7 CisgICAgICAgIGlmIChtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmIHBvaW50SW5Db250ZW50cy55KCkg PCBmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxpbmVUb3AoKSAtIHZlcnRpY2FsTGluZUNsaWNr RnVkZ2VGYWN0b3IpIHsKICAgICAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBhYm92ZSBmaXJz dCByb290IGxpbmUgYm94LCBzbyByZXR1cm4gdGhlIHN0YXJ0IG9mIHRoZSBmaXJzdAogICAgICAg ICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChmaXJzdFJvb3RCb3hX aXRoQ2hpbGRyZW4tPmZpcnN0TGVhZkNoaWxkKCksIHRydWUpLCBET1dOU1RSRUFNKTsKICAgICAg ICAgfQpAQCAtMzczOCw3ICszNzM4LDcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpw b3NpdGlvbkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogCiAgICAg aWYgKGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNh c2UgZm9yIE1hYyBiZWhhdmlvciB3aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxh c3QgYm94LgotICAgICAgICBBU1NFUlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIEFT U0VSVChtb3ZlQ2FyZXRUb0JvdW5kYXJ5KTsKICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlv bihwb3NpdGlvbkZvckJveChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGFzdExlYWZDaGlsZCgp LCBmYWxzZSksIERPV05TVFJFQU0pOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmNwcAppbmRleCBkMjc0NzA4Li43MDlkYzVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmNwcApAQCAtMTI5LDkgKzEyOSw5IEBAIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgY29yZShX ZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQogICAgIHJldHVybiBSZXNvdXJjZVJlc3Bv bnNlKCk7CiB9CiAKLVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdC ZWhhdmlvciB0eXBlKQorV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVk aXRpbmdCZWhhdmlvciB0eXBlKQogewotICAgIHJldHVybiAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yKXR5cGU7CisgICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlKXR5cGU7 CiB9CiAKIFdlYktpdEhpdFRlc3RSZXN1bHQqIGtpdChjb25zdCBXZWJDb3JlOjpIaXRUZXN0UmVz dWx0JiByZXN1bHQpCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggMDU3YjBlNS4uNmFl Y2MxMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtOTUsNyArOTUsNyBAQCBuYW1l c3BhY2UgV2ViS2l0IHsKIAogICAgIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgY29yZShXZWJL aXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKTsKIAotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKKyAgICBXZWJDb3JlOjpFZGl0 aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpOwogCiAgICAg V2ViS2l0U2VjdXJpdHlPcmlnaW4qIGtpdChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiopOwogICAg IFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luKiBjb3JlKFdlYktpdFNlY3VyaXR5T3JpZ2luKik7CmRp ZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dl YlZpZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5ZjE3Ny4uN2M1OTYxNSAxMDA2NDQKLS0tIGEvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJG cmFtZS5tbQpAQCAtMTk2LDcgKzE5Niw3IEBAIEVkaXRhYmxlTGlua0JlaGF2aW9yIGNvcmUoV2Vi S2l0RWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZpb3IpCiAgICAgcmV0dXJu IEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQorV2ViQ29yZTo6RWRpdGlu Z0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKICAg ICBzd2l0Y2ggKGJlaGF2aW9yKSB7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ01hY0JlaGF2 aW9yOgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCBi L1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKaW5kZXggOWIyMjQ4YS4uNTg2 YjRjMyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaAor KysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCkBAIC03MSw3ICs3MSw3 IEBAIFdlYlZpZXcgKmtpdChXZWJDb3JlOjpQYWdlKik7CiAKIFdlYkNvcmU6OkVkaXRhYmxlTGlu a0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGFibGVMaW5rQmVoYXZpb3IpOwogV2ViQ29yZTo6VGV4 dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciBjb3JlKFdlYlRleHREaXJlY3Rpb25T dWJtZW51SW5jbHVzaW9uQmVoYXZpb3IpOwotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUo V2ViS2l0RWRpdGluZ0JlaGF2aW9yKTsKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29y ZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IpOwogCiBXZWJWaWV3ICpnZXRXZWJWaWV3KFdlYkZyYW1l ICp3ZWJGcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1w UmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQuY3BwCmluZGV4IDBiMmU5YTUuLjgxMjc2M2QgMTAwNjQ0Ci0tLSBh L1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKKysr IGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcApA QCAtNDc2LDcgKzQ3Niw3IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmVsZW1lbnRE b2VzQXV0b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChRV2ViRnJhbWUqCiAKIHZvaWQgRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwgY29u c3QgUVN0cmluZyYgZWRpdGluZ0JlaGF2aW9yKQogewotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvciBjb3JlRWRpdGluZ0JlaGF2aW9yOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5 cGUgY29yZUVkaXRpbmdCZWhhdmlvcjsKIAogICAgIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIndp biIpCiAgICAgICAgIGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2luZG93c0JlaGF2aW9y OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBiL1dlYktpdC93aW4vV2ViVmll dy5jcHAKaW5kZXggNTI1MTA4Zi4uZmU4NmJmYiAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9XZWJW aWV3LmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBAIC00NjU0LDcgKzQ2NTQsNyBA QCBIUkVTVUxUIFdlYlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdlZChJV2ViTm90aWZpY2F0 aW9uKiBub3RpZmljYXRpb24pCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ZWRpdGluZ0JlaGF2aW9y KCZlZGl0aW5nQmVoYXZpb3IpOwogICAgIGlmIChGQUlMRUQoaHIpKQogICAgICAgICByZXR1cm4g aHI7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcigoRWRpdGluZ0JlaGF2aW9yKWVk aXRpbmdCZWhhdmlvcik7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcigoRWRpdGlu Z0JlaGF2aW9yVHlwZSllZGl0aW5nQmVoYXZpb3IpOwogCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ dXNlc1BhZ2VDYWNoZSgmZW5hYmxlZCk7CiAgICAgaWYgKEZBSUxFRChocikpCi0tIAoxLjcuMC40 Cgo= 57468 2010-05-31 08:17:24 -0700 2010-05-31 14:33:36 -0700 4th try - feedback? 0001-Summary.patch text/plain 25449 tonikitoo RnJvbSAxYWUwZTkxMWQxNmM4MjY4NWY5NDBhNzMxOTYwZjliY2Y2MzQxYzI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCAyNyBNYXkgMjAxMCAxNzoyNTo1MSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFN1 bW1hcnk6CiAqIFJlbmFtZWQgRWRpdGluZ0JlaGF2aW9yIGVudW0gaW4gU2V0dGluZ3MgdG8gRWRp dGluZ0JlaGF2aW9yVHlwZQogKiBBZGRlZCBFZGl0aW5nQmVoYXZpb3IgY2xhc3MsIGxpdmluZyBp biBXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggLiBJdCBkb2VzIG5vdCBrbm93IGFi b3V0IGV4dGVybmFsIGNsYXNzZXMgYnV0IEVkaXRpbmdCZWhhdmlvclR5cGUgZW51bSBvZiBTZXR0 aW5ncy4KICogU2V0dGluZ3Mgbm93IGhhczoKICAgICAtIGEgc2V0dGVyIGZvciB0aGUgRWRpdGlu Z0JlaGF2aW9yVHlwZTogc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBl KQogICAgIC0gYSBnZXR0ZXIgZm9yIHRoZSBFZGl0aW5iZUJlaGF2aW9yLCBiYXNlZCBvbiB0aGUg dHlwZTogRWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpCiAqIENhbGwgc2l0ZXMgaW4g V2ViS2l0LyBhZGp1c3RlZCB0byB3b3JrIHdpdGggdGhlIGFib3ZlIGNoYW5nZXMuCiAqIEVkaXRv ci5jcHAgaGFzIGEgYmVoYXZpb3IoKSBnZXR0ZXIsIHJlbHlpbmcgb24gU2V0dGluZ3MnIGVkaXRp bmdCZWhhdmlvciBtZXRob2QuCiAqIENhbGwgc2l0ZXMgd2lsbCBsb29rIGxpa2U6CiAgICAgaWYg KGZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRUaGlzRGVzaWduQmVVc2VkX3F1ZXN0 aW9uTWFyaygpKSkKICAgICAgICAgLy8vIGRvIHh4eAoKLS0tCiBXZWJDb3JlL0dOVW1ha2VmaWxl LmFtICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViQ29yZS9XZWJDb3Jl LnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYkNvcmUvZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAgICAgIHwgICA0NSArKysrKysrKysr KysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgICA5ICsrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0b3IuaCAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMyArCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDYgKysrCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDcgKystCiBXZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJCbG9jay5jcHAgICAgICAgICAgICAgICAgICB8ICAgMTAgKystLQogV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCAgICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCAgICAgICAgICAgICAgICAgIHwgICAgMiArLQog V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAgICAgICAgICAgICAgfCAgICA0 ICstCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gICAgICAgICAgICAgICAgICAgICB8 ICAgIDIgKy0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmggICAgICAgICAg ICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0gICAgICAgICAgICAg ICAgICAgICAgfCAgICAyICstCiAuLi4vcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVT dXBwb3J0UXQuY3BwICB8ICAgIDQgKy0KIFdlYktpdC93aW4vV2ViVmlldy5jcHAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogMTcgZmlsZXMgY2hhbmdlZCwgODYgaW5zZXJ0 aW9ucygrKSwgMjAgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0 aW5nL0VkaXRpbmdCZWhhdmlvci5oCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggOWI5NTMzMC4uZmJmNTdlMiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt CkBAIC05NDMsMTYgKzk0MywxNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRp dGluZy9EZWxldGVCdXR0b25Db250cm9sbGVyLmggXAogCVdlYkNvcmUvZWRpdGluZy9EZWxldGVG cm9tVGV4dE5vZGVDb21tYW5kLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQuaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQu Y3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5oIFwKIAlXZWJD b3JlL2VkaXRpbmcvRWRpdEFjdGlvbi5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdENvbW1hbmQu Y3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisJV2ViQ29yZS9lZGl0aW5n L0VkaXRpbmdCZWhhdmlvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBcCiAJV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5j cHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0b3JEZWxldGVBY3Rpb24uaCBcCiAJV2ViQ29yZS9l ZGl0aW5nL0VkaXRvckluc2VydEFjdGlvbi5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRm9ybWF0Qmxv Y2tDb21tYW5kLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5oIFwK IAlXZWJDb3JlL2VkaXRpbmcvSFRNTEludGVyY2hhbmdlLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJD b3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCBkM2ViMTE1Li40Y2Zh ZDllIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29y ZS5wcm8KQEAgLTEyNzIsMTYgKzEyNzIsMTcgQEAgSEVBREVSUyArPSBcCiAgICAgZWRpdGluZy9C cmVha0Jsb2NrcXVvdGVDb21tYW5kLmggXAogICAgIGVkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1h bmQuaCBcCiAgICAgZWRpdGluZy9DcmVhdGVMaW5rQ29tbWFuZC5oIFwKICAgICBlZGl0aW5nL0Rl bGV0ZUJ1dHRvbkNvbnRyb2xsZXIuaCBcCiAgICAgZWRpdGluZy9EZWxldGVCdXR0b24uaCBcCiAg ICAgZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmggXAogICAgIGVkaXRpbmcvRGVs ZXRlU2VsZWN0aW9uQ29tbWFuZC5oIFwKICAgICBlZGl0aW5nL0VkaXRDb21tYW5kLmggXAorICAg IGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAogICAgIGVkaXRpbmcvRWRpdG9yLmggXAogICAg IGVkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmggXAogICAgIGVkaXRpbmcvaHRtbGVkaXRpbmcu aCBcCiAgICAgZWRpdGluZy9IVE1MSW50ZXJjaGFuZ2UuaCBcCiAgICAgZWRpdGluZy9JbmRlbnRP dXRkZW50Q29tbWFuZC5oIFwKICAgICBlZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQu aCBcCiAgICAgZWRpdGluZy9JbnNlcnRMaW5lQnJlYWtDb21tYW5kLmggXAogICAgIGVkaXRpbmcv SW5zZXJ0TGlzdENvbW1hbmQuaCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWRlNThlNgotLS0gL2Rldi9udWxsCisrKyBiL1dl YkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApAQCAtMCwwICsxLDQ1IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFy eSgtaWVzKQorICogQ29weXJpZ2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xp biBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisg Ki8KKworI2lmbmRlZiBFZGl0aW5nQmVoYXZpb3JfaAorI2RlZmluZSBFZGl0aW5nQmVoYXZpb3Jf aAorCisjaW5jbHVkZSAiU2V0dGluZ3MuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFz cyBFZGl0aW5nQmVoYXZpb3IgeworCitwdWJsaWM6CisgICAgRWRpdGluZ0JlaGF2aW9yKEVkaXRp bmdCZWhhdmlvclR5cGUgdHlwZSkKKyAgICAgICAgOiBtX3R5cGUodHlwZSkKKyAgICB7CisgICAg fQorCisgICAgLy8gUGxhdGZvcm0gdmFyaWFudCBlZGl0aW5nIGJlaGF2aW9yIG1ldGhvZHMuCisg ICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JC b3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsg fQorCitwcml2YXRlOgorICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgbV90eXBlOworfTsKKworfSAv LyBuYW1zcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFZGl0aW5nQmVoYXZpb3JfaApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9y LmNwcAppbmRleCA2MDNmMzVjLi5mNGM3YzEwIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcApAQCAtOTIsMTYgKzky LDI1IEBAIFZpc2libGVTZWxlY3Rpb24gRWRpdG9yOjpzZWxlY3Rpb25Gb3JDb21tYW5kKEV2ZW50 KiBldmVudCkKICAgICAgICAgaWYgKHRhcmdldC0+aGFzVGFnTmFtZShpbnB1dFRhZykgJiYgc3Rh dGljX2Nhc3Q8SFRNTElucHV0RWxlbWVudCo+KHRhcmdldCktPmlzVGV4dEZpZWxkKCkpCiAgICAg ICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8SFRNTElucHV0RWxlbWVudCo+KHRhcmdldCktPnNl bGVjdGlvbigpOwogICAgICAgICBpZiAodGFyZ2V0LT5oYXNUYWdOYW1lKHRleHRhcmVhVGFnKSkK ICAgICAgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxIVE1MVGV4dEFyZWFFbGVtZW50Kj4odGFy Z2V0KS0+c2VsZWN0aW9uKCk7CiAgICAgfQogICAgIHJldHVybiBzZWxlY3Rpb247CiB9CiAKK0Vk aXRpbmdCZWhhdmlvciBFZGl0b3I6OmJlaGF2aW9yKCkgY29uc3QKK3sKKyAgICBpZiAoUGFnZSog cGFnZSA9IG1fZnJhbWUtPnBhZ2UoKSkKKyAgICAgICAgcmV0dXJuIHBhZ2UtPnNldHRpbmdzKCkt PmVkaXRpbmdCZWhhdmlvcigpOworCisgICAgLy8gQ29uc2lkZXJpbmcgTWFjIGVkaXRpbmcgYmVo YXZpb3IgYSBmYWxsYmFjayB3aGVuIFNldHRpbmdzIGlzIG5vdCBhdmFpbGFibGUuCisgICAgcmV0 dXJuIEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nTWFjQmVoYXZpb3IpOworfQorCiBFZGl0b3JDbGll bnQqIEVkaXRvcjo6Y2xpZW50KCkgY29uc3QKIHsKICAgICBpZiAoUGFnZSogcGFnZSA9IG1fZnJh bWUtPnBhZ2UoKSkKICAgICAgICAgcmV0dXJuIHBhZ2UtPmVkaXRvckNsaWVudCgpOwogICAgIHJl dHVybiAwOwogfQogCiB2b2lkIEVkaXRvcjo6aGFuZGxlS2V5Ym9hcmRFdmVudChLZXlib2FyZEV2 ZW50KiBldmVudCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaCBiL1dlYkNv cmUvZWRpdGluZy9FZGl0b3IuaAppbmRleCAxN2RkM2JiLi4zZTIyM2RjIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCkBA IC0yNCwxNiArMjQsMTcgQEAKICAqLwogCiAjaWZuZGVmIEVkaXRvcl9oCiAjZGVmaW5lIEVkaXRv cl9oCiAKICNpbmNsdWRlICJDbGlwYm9hcmRBY2Nlc3NQb2xpY3kuaCIKICNpbmNsdWRlICJDb2xv ci5oIgogI2luY2x1ZGUgIkVkaXRBY3Rpb24uaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3Iu aCIKICNpbmNsdWRlICJFZGl0b3JEZWxldGVBY3Rpb24uaCIKICNpbmNsdWRlICJFZGl0b3JJbnNl cnRBY3Rpb24uaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogY2xhc3MgQ1NTU3R5bGVEZWNsYXJhdGlvbjsKIGNsYXNzIENsaXBib2Fy ZDsKQEAgLTI3NiwxNiArMjc3LDE4IEBAIHB1YmxpYzoKICAgICBQYXNzUmVmUHRyPFJhbmdlPiBy YW5nZUZvclBvaW50KGNvbnN0IEludFBvaW50JiB3aW5kb3dQb2ludCk7CiAKICAgICB2b2lkIGNs ZWFyKCk7CiAKICAgICBWaXNpYmxlU2VsZWN0aW9uIHNlbGVjdGlvbkZvckNvbW1hbmQoRXZlbnQq KTsKIAogICAgIEtpbGxSaW5nKiBraWxsUmluZygpIGNvbnN0IHsgcmV0dXJuIG1fa2lsbFJpbmcu Z2V0KCk7IH0KIAorICAgIEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcigpIGNvbnN0OworCiAgICAg UGFzc1JlZlB0cjxSYW5nZT4gc2VsZWN0ZWRSYW5nZSgpOwogICAgIAogICAgIC8vIFdlIHNob3Vs ZCBtYWtlIHRoZXNlIGZ1bmN0aW9ucyBwcml2YXRlIHdoZW4gdGhlaXIgY2FsbGVycyBpbiBGcmFt ZSBhcmUgbW92ZWQgb3ZlciBoZXJlIHRvIEVkaXRvcgogICAgIGJvb2wgaW5zaWRlVmlzaWJsZUFy ZWEoY29uc3QgSW50UG9pbnQmKSBjb25zdDsKICAgICBib29sIGluc2lkZVZpc2libGVBcmVhKFJh bmdlKikgY29uc3Q7CiAgICAgUGFzc1JlZlB0cjxSYW5nZT4gbmV4dFZpc2libGVSYW5nZShSYW5n ZSosIGNvbnN0IFN0cmluZyYsIGJvb2wgZm9yd2FyZCwgYm9vbCBjYXNlRmxhZywgYm9vbCB3cmFw RmxhZyk7CiAgICAgCiAgICAgdm9pZCBhZGRUb0tpbGxSaW5nKFJhbmdlKiwgYm9vbCBwcmVwZW5k KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuY3BwCmluZGV4IDZmNmJiMDQuLmRhYTQwOTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMjMs MTYgKzIzLDE3IEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgi CiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKIAogI2luY2x1ZGUgIkJhY2tGb3J3YXJkTGlzdC5oIgog I2luY2x1ZGUgIkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5j bHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZVRyZWUuaCIKICNpbmNsdWRlICJGcmFtZVZp ZXcuaCIKICNpbmNsdWRlICJIaXN0b3J5SXRlbS5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNs dWRlICJQYWdlQ2FjaGUuaCIKICNpbmNsdWRlICJTdG9yYWdlTWFwLmgiCiAjaW5jbHVkZSA8bGlt aXRzPgpAQCAtNTIzLDE2ICs1MjQsMjEgQEAgdm9pZCBTZXR0aW5nczo6c2V0VXNlc0VuY29kaW5n RGV0ZWN0b3IoYm9vbCB1c2VzRW5jb2RpbmdEZXRlY3RvcikKICAgICBtX3VzZXNFbmNvZGluZ0Rl dGVjdG9yID0gdXNlc0VuY29kaW5nRGV0ZWN0b3I7CiB9CiAKIHZvaWQgU2V0dGluZ3M6OnNldEFs bG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGJvb2wgYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3Mp CiB7CiAgICAgbV9hbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyA9IGFsbG93U2NyaXB0c1RvQ2xv c2VXaW5kb3dzOwogfQogCitFZGl0aW5nQmVoYXZpb3IgU2V0dGluZ3M6OmVkaXRpbmdCZWhhdmlv cigpIGNvbnN0Cit7CisgICAgcmV0dXJuIEVkaXRpbmdCZWhhdmlvcihzdGF0aWNfY2FzdDxFZGl0 aW5nQmVoYXZpb3JUeXBlPihtX2VkaXRpbmdCZWhhdmlvcikpOworfQorCiB2b2lkIFNldHRpbmdz OjpzZXRDYXJldEJyb3dzaW5nRW5hYmxlZChib29sIGNhcmV0QnJvd3NpbmdFbmFibGVkKQogewog ICAgIG1fY2FyZXRCcm93c2luZ0VuYWJsZWQgPSBjYXJldEJyb3dzaW5nRW5hYmxlZDsKIH0KIAog dm9pZCBTZXR0aW5nczo6c2V0RG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKGJvb2wgZG93 bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKQogewogICAgIG1fZG93bmxvYWRhYmxlQmluYXJ5 Rm9udHNFbmFibGVkID0gZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRl eCBkYzNiNTBmLi5kYTBlMDQxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAor KysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMzAsMTYgKzMwLDE3IEBACiAjaW5jbHVk ZSAiQXRvbWljU3RyaW5nLmgiCiAjaW5jbHVkZSAiRm9udFJlbmRlcmluZ01vZGUuaCIKICNpbmNs dWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiWm9vbU1vZGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCiAgICAgY2xhc3MgUGFnZTsKKyAgICBjbGFzcyBFZGl0aW5nQmVoYXZpb3I7CiAKICAgICBl bnVtIEVkaXRhYmxlTGlua0JlaGF2aW9yIHsKICAgICAgICAgRWRpdGFibGVMaW5rRGVmYXVsdEJl aGF2aW9yLAogICAgICAgICBFZGl0YWJsZUxpbmtBbHdheXNMaXZlLAogICAgICAgICBFZGl0YWJs ZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleSwKICAgICAgICAgRWRpdGFibGVMaW5rTGl2ZVdoZW5O b3RGb2N1c2VkLAogICAgICAgICBFZGl0YWJsZUxpbmtOZXZlckxpdmUKICAgICB9OwpAQCAtNTgs MTcgKzU5LDE3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAvLyAgICAyKSBQdXNoaW5nIHRo ZSBkb3duIGFycm93IGtleSBvbiB0aGUgbGFzdCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBl bmQgb2YgdGhlCiAgICAgLy8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGlu ZyBvbiBXaW5kb3dzLiBBIHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCiAgICAgLy8gICAgICAg dG9wIGxpbmUuCiAgICAgLy8KICAgICAvLyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29u dHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhhdmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCiAgICAg Ly8gYmVoYXZpb3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGll bnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3RlIGFuZAogICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2Ug YWZ0ZXIgYSBkb3VibGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlm CiAgICAgLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhh dmlvciB7IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OworICAg IGVudW0gRWRpdGluZ0JlaGF2aW9yVHlwZSB7IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dp bmRvd3NCZWhhdmlvciB9OwogCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJsaWMgTm9uY29weWFi bGUgewogICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSopOwogCiAgICAgICAgIHZv aWQgc2V0U3RhbmRhcmRGb250RmFtaWx5KGNvbnN0IEF0b21pY1N0cmluZyYpOwogICAgICAgICBj b25zdCBBdG9taWNTdHJpbmcmIHN0YW5kYXJkRm9udEZhbWlseSgpIGNvbnN0IHsgcmV0dXJuIG1f c3RhbmRhcmRGb250RmFtaWx5OyB9CiAKQEAgLTI2NSwxOCArMjY2LDE4IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICAgICAgLy8gV2luZG93cyBkZWJ1Z2dpbmcgcHJlZiAoZ2xvYmFsKSBmb3Ig c3dpdGNoaW5nIGJldHdlZW4gdGhlIEFxdWEgbG9vayBhbmQgYSBuYXRpdmUgd2luZG93cyBsb29r LgogICAgICAgICBzdGF0aWMgdm9pZCBzZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKGJvb2wp OwogICAgICAgICBzdGF0aWMgYm9vbCBzaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKCkgeyByZXR1 cm4gZ1Nob3VsZFBhaW50TmF0aXZlQ29udHJvbHM7IH0KICNlbmRpZgogCiAgICAgICAgIHZvaWQg c2V0QWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7CiAgICAgICAgIGJvb2wgYWxsb3dT Y3JpcHRzVG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVybiBtX2FsbG93U2NyaXB0c1RvQ2xv c2VXaW5kb3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0Jl aGF2aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0KLSAgICAg ICAgRWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRp Y19jYXN0PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVoYXZpb3IpOyB9CisgICAgICAgIHZv aWQgc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBlIGJlaGF2aW9yKSB7 IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9y IGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0OwogICAgICAgICAKICAgICAgICAgdm9pZCBzZXREb3du bG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJvb2wgZG93bmxvYWRh YmxlQmluYXJ5Rm9udHNFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZGFibGVCaW5h cnlGb250c0VuYWJsZWQ7IH0KIAogICAgICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFibGVkKGJv b2wpOwogICAgICAgICBib29sIHhzc0F1ZGl0b3JFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV94 c3NBdWRpdG9yRW5hYmxlZDsgfQogCiAgICAgICAgIHZvaWQgc2V0QWNjZWxlcmF0ZWRDb21wb3Np dGluZ0VuYWJsZWQoYm9vbCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC bG9jay5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggNmZiZWEx NC4uNzYwNTYxYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3Bw CisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtMTksMTYgKzE5LDE3 IEBACiAgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQsIEZpZnRoIEZsb29yLAogICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCiAgKi8K IAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCiAKICNpbmNs dWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgogI2luY2x1ZGUg IkVsZW1lbnQuaCIKICNpbmNsdWRlICJGbG9hdFF1YWQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2lu Y2x1ZGUgIkhUTUxGb3JtRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1 ZGUgIkhpdFRlc3RSZXN1bHQuaCIKQEAgLTM3MTMsMzcgKzM3MTQsMzYgQEAgVmlzaWJsZVBvc2l0 aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0 IEludFBvaW50JgogICAgICAgICAvLyBjaGVjayBpZiB0aGlzIHJvb3QgbGluZSBib3ggaXMgbG9j YXRlZCBhdCB0aGlzIHkgY29vcmRpbmF0ZQogICAgICAgICBpZiAocG9pbnRJbkNvbnRlbnRzLnko KSA8IGJvdHRvbSkgewogICAgICAgICAgICAgY2xvc2VzdEJveCA9IHJvb3QtPmNsb3Nlc3RMZWFm Q2hpbGRGb3JYUG9zKHBvaW50SW5Db250ZW50cy54KCkpOwogICAgICAgICAgICAgaWYgKGNsb3Nl c3RCb3gpCiAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBT ZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudCgpLT5zZXR0aW5ncygpOwotICAgIGJvb2wgdXNl V2luZG93c0JlaGF2aW9yID0gc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigp ID09IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CisgICAgYm9vbCBtb3ZlQ2FyZXRUb0JvdW5kYXJ5 ID0gZnJhbWUoKS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9u dGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKCk7CiAKLSAgICBpZiAodXNlV2luZG93c0Jl aGF2aW9yICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CisgICAg aWYgKCFtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0 aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBiZWxvdyBsYXN0IHJvb3Qg bGluZSBib3gsIHByZXRlbmQgd2UgaGl0IGl0CiAgICAgICAgIGNsb3Nlc3RCb3ggPSBsYXN0Um9v dEJveFdpdGhDaGlsZHJlbi0+Y2xvc2VzdExlYWZDaGlsZEZvclhQb3MocG9pbnRJbkNvbnRlbnRz LngoKSk7CiAgICAgfQogCiAgICAgaWYgKGNsb3Nlc3RCb3gpIHsKLSAgICAgICAgaWYgKCF1c2VX aW5kb3dzQmVoYXZpb3IgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9vdEJveFdpdGhD aGlsZHJlbi0+bGluZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3RvcikgeworICAg ICAgICBpZiAobW92ZUNhcmV0VG9Cb3VuZGFyeSAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmly c3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdl RmFjdG9yKSB7CiAgICAgICAgICAgICAvLyB5IGNvb3JkaW5hdGUgaXMgYWJvdmUgZmlyc3Qgcm9v dCBsaW5lIGJveCwgc28gcmV0dXJuIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QKICAgICAgICAgICAg IHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3goZmlyc3RSb290Qm94V2l0aENo aWxkcmVuLT5maXJzdExlYWZDaGlsZCgpLCB0cnVlKSwgRE9XTlNUUkVBTSk7CiAgICAgICAgIH0K IAogICAgICAgICAvLyBwYXNzIHRoZSBib3ggYSB5IHBvc2l0aW9uIHRoYXQgaXMgaW5zaWRlIGl0 CiAgICAgICAgIHJldHVybiBjbG9zZXN0Qm94LT5yZW5kZXJlcigpLT5wb3NpdGlvbkZvclBvaW50 KEludFBvaW50KHBvaW50SW5Db250ZW50cy54KCksIGNsb3Nlc3RCb3gtPm1feSkpOwogICAgIH0K IAogICAgIGlmIChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewogICAgICAgICAvLyBXZSBoaXQg dGhpcyBjYXNlIGZvciBNYWMgYmVoYXZpb3Igd2hlbiB0aGUgWSBjb29yZGluYXRlIGlzIGJlbG93 IHRoZSBsYXN0IGJveC4KLSAgICAgICAgQVNTRVJUKCF1c2VXaW5kb3dzQmVoYXZpb3IpOworICAg ICAgICBBU1NFUlQobW92ZUNhcmV0VG9Cb3VuZGFyeSk7CiAgICAgICAgIHJldHVybiBWaXNpYmxl UG9zaXRpb24ocG9zaXRpb25Gb3JCb3gobGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxhc3RMZWFm Q2hpbGQoKSwgZmFsc2UpLCBET1dOU1RSRUFNKTsKICAgICB9CiAKICAgICAvLyBDYW4ndCByZWFj aCB0aGlzLiBXZSBoYXZlIGEgcm9vdCBsaW5lIGJveCwgYnV0IGl0IGhhcyBubyBraWRzLgogICAg IC8vIEZJWE1FOiBUaGlzIHNob3VsZCBBU1NFUlRfTk9UX1JFQUNIRUQoKSwgYnV0IGNsaWNraW5n IG9uIHBsYWNlaG9sZGVyIHRleHQKICAgICAvLyBzZWVtcyB0byBoaXQgdGhpcyBjb2RlIHBhdGgu CiAgICAgcmV0dXJuIGNyZWF0ZVZpc2libGVQb3NpdGlvbigwLCBET1dOU1RSRUFNKTsKIH0KZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcCBiL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAppbmRleCAyODQwOTI5Li40ZjRkOTEy IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCkBAIC0yNjYsMTcgKzI2 NiwxNyBAQCB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0RXhwZXJpbWVudGFsV2ViR0xFbmFibGVk KGJvb2wgZW5hYmxlZCkKIAogdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldFNob3dEZWJ1Z0JvcmRl cnMoYm9vbCBzaG93KQogewogICAgIG1fc2V0dGluZ3MtPnNldFNob3dEZWJ1Z0JvcmRlcnMoc2hv dyk7CiB9CiAKIHZvaWQgV2ViU2V0dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGlu Z0JlaGF2aW9yIGJlaGF2aW9yKQogewotICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlv cihzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CisgICAg bV9zZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShzdGF0aWNfY2FzdDxXZWJDb3JlOjpF ZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CiB9CiAKIHZvaWQgV2ViU2V0dGluZ3NJbXBsOjpz ZXRBY2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZChib29sIGVuYWJsZWQpCiB7CiAgICAgbV9z ZXR0aW5ncy0+c2V0QWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQoZW5hYmxlZCk7CiB9CiAK IH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRl eCBkMjc0NzA4Li43MDlkYzVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAt MTI0LDE5ICsxMjQsMTkgQEAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5l dHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCiB7CiAgICAgU291cE1lc3NhZ2UqIHNvdXBNZXNzYWdl ID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2UocmVzcG9uc2UpOwogICAgIGlm IChzb3VwTWVzc2FnZSkKICAgICAgICAgcmV0dXJuIFJlc291cmNlUmVzcG9uc2Uoc291cE1lc3Nh Z2UpOwogCiAgICAgcmV0dXJuIFJlc291cmNlUmVzcG9uc2UoKTsKIH0KIAotV2ViQ29yZTo6RWRp dGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCitXZWJDb3JlOjpF ZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCiB7Ci0g ICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IpdHlwZTsKKyAgICByZXR1cm4gKFdl YkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUpdHlwZTsKIH0KIAogV2ViS2l0SGl0VGVzdFJlc3Vs dCoga2l0KGNvbnN0IFdlYkNvcmU6OkhpdFRlc3RSZXN1bHQmIHJlc3VsdCkKIHsKICAgICBndWlu dCBjb250ZXh0ID0gV0VCS0lUX0hJVF9URVNUX1JFU1VMVF9DT05URVhUX0RPQ1VNRU5UOwogICAg IEdPd25QdHI8Y2hhcj4gbGlua1VSSSgwKTsKICAgICBHT3duUHRyPGNoYXI+IGltYWdlVVJJKDAp OwogICAgIEdPd25QdHI8Y2hhcj4gbWVkaWFVUkkoMCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmgKaW5kZXggMDU3YjBlNS4uNmFlY2MxMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApA QCAtOTAsMTcgKzkwLDE3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViS2l0V2ViTmF2 aWdhdGlvblJlYXNvbiBraXQoV2ViQ29yZTo6TmF2aWdhdGlvblR5cGUgdHlwZSk7CiAgICAgV2Vi Q29yZTo6TmF2aWdhdGlvblR5cGUgY29yZShXZWJLaXRXZWJOYXZpZ2F0aW9uUmVhc29uIHJlYXNv bik7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgY29yZShXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCk7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2Vi S2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CiAKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CisgICAgV2ViQ29yZTo6RWRp dGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKIAogICAg IFdlYktpdFNlY3VyaXR5T3JpZ2luKiBraXQoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qKTsKICAg ICBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiogY29yZShXZWJLaXRTZWN1cml0eU9yaWdpbiopOwog CiAgICAgV2ViS2l0SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNvcmU6OkhpdFRlc3RSZXN1 bHQmKTsKIAogICAgIFdlYktpdDo6UGFzdGVib2FyZEhlbHBlckd0ayogcGFzdGVib2FyZEhlbHBl ckluc3RhbmNlKCk7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDJjOTU1 NTguLjg0MTkzNzUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcu Y3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0yNjkwLDE3 ICsyNjkwLDE3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld191cGRhdGVfc2V0dGluZ3Mo V2ViS2l0V2ViVmlldyogd2ViVmlldykKICAgICBEYXRhYmFzZTo6c2V0SXNBdmFpbGFibGUoZW5h YmxlSFRNTDVEYXRhYmFzZSk7CiAjZW5kaWYKICAgICBzZXR0aW5ncy0+c2V0TG9jYWxTdG9yYWdl RW5hYmxlZChlbmFibGVIVE1MNUxvY2FsU3RvcmFnZSk7CiAgICAgc2V0dGluZ3MtPnNldFhTU0F1 ZGl0b3JFbmFibGVkKGVuYWJsZVhTU0F1ZGl0b3IpOwogICAgIHNldHRpbmdzLT5zZXRTcGF0aWFs TmF2aWdhdGlvbkVuYWJsZWQoZW5hYmxlU3BhdGlhbE5hdmlnYXRpb24pOwogICAgIHNldHRpbmdz LT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5KGphdmFzY3JpcHRDYW5P cGVuV2luZG93cyk7CiAgICAgc2V0dGluZ3MtPnNldEphdmFTY3JpcHRDYW5BY2Nlc3NDbGlwYm9h cmQoamF2YVNjcmlwdENhbkFjY2Vzc0NsaXBib2FyZCk7CiAgICAgc2V0dGluZ3MtPnNldE9mZmxp bmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChlbmFibGVPZmZsaW5lV2ViQXBwQ2FjaGUpOwot ICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsK KyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKGVkaXRpbmdCZWhhdmlv cikpOwogICAgIHNldHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhl bmFibGVVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSSSk7CiAgICAgc2V0dGluZ3MtPnNldEFsbG93 RmlsZUFjY2Vzc0Zyb21GaWxlVVJMcyhlbmFibGVGaWxlQWNjZXNzRnJvbUZpbGVVUkkpOwogICAg IHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoZW5hYmxlRE9NUGFzdGUpOwogICAgIHNldHRp bmdzLT5zZXROZWVkc1NpdGVTcGVjaWZpY1F1aXJrcyhlbmFibGVTaXRlU3BlY2lmaWNRdWlya3Mp OwogICAgIHNldHRpbmdzLT5zZXRVc2VzUGFnZUNhY2hlKHVzZVBhZ2VDYWNoZSk7CiAgICAgc2V0 dGluZ3MtPnNldEphdmFFbmFibGVkKGVuYWJsZUphdmFBcHBsZXQpOwogCiAgICAgUGFnZSogcGFn ZSA9IGNvcmUod2ViVmlldyk7CkBAIC0yNzkxLDE3ICsyNzkxLDE3IEBAIHN0YXRpYyB2b2lkIHdl YmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkoV2ViS2l0V2ViU2V0dGluZ3MqIHdlYlNldHRp bmdzLCBHUGFyCiAgICAgICAgIHNldHRpbmdzLT5zZXRTcGF0aWFsTmF2aWdhdGlvbkVuYWJsZWQo Z192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50 ZXJuX3N0cmluZygiamF2YXNjcmlwdC1jYW4tb3Blbi13aW5kb3dzLWF1dG9tYXRpY2FsbHkiKSkK ICAgICAgICAgc2V0dGluZ3MtPnNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2Fs bHkoZ192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdf aW50ZXJuX3N0cmluZygiamF2YXNjcmlwdC1jYW4tYWNjZXNzLWNsaXBib2FyZCIpKQogICAgICAg ICBzZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENhbkFjY2Vzc0NsaXBib2FyZChnX3ZhbHVlX2dldF9i b29sZWFuKCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJl bmFibGUtb2ZmbGluZS13ZWItYXBwbGljYXRpb24tY2FjaGUiKSkKICAgICAgICAgc2V0dGluZ3Mt PnNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChnX3ZhbHVlX2dldF9ib29sZWFu KCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlZGl0aW5n LWJlaGF2aW9yIikpCi0gICAgICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShz dGF0aWNfY2FzdDxXZWJLaXRFZGl0aW5nQmVoYXZpb3I+KGdfdmFsdWVfZ2V0X2VudW0oJnZhbHVl KSkpKTsKKyAgICAgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoY29yZShzdGF0 aWNfY2FzdDxXZWJLaXRFZGl0aW5nQmVoYXZpb3I+KGdfdmFsdWVfZ2V0X2VudW0oJnZhbHVlKSkp KTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLXVuaXZlcnNh bC1hY2Nlc3MtZnJvbS1maWxlLXVyaXMiKSkKICAgICAgICAgc2V0dGluZ3MtPnNldEFsbG93VW5p dmVyc2FsQWNjZXNzRnJvbUZpbGVVUkxzKGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJnZhbHVlKSk7CiAg ICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVuYWJsZS1maWxlLWFjY2Vzcy1m cm9tLWZpbGUtdXJpcyIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0QWxsb3dGaWxlQWNjZXNzRnJv bUZpbGVVUkxzKGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJnZhbHVlKSk7CiAgICAgZWxzZSBpZiAobmFt ZSA9PSBnX2ludGVybl9zdHJpbmcoImVuYWJsZS1kb20tcGFzdGUiKSkKICAgICAgICAgc2V0dGlu Z3MtPnNldERPTVBhc3RlQWxsb3dlZChnX3ZhbHVlX2dldF9ib29sZWFuKCZ2YWx1ZSkpOwogICAg IGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJ0YWIta2V5LWN5Y2xlcy10aHJvdWdo LWVsZW1lbnRzIikpIHsKICAgICAgICAgUGFnZSogcGFnZSA9IGNvcmUod2ViVmlldyk7CmRpZmYg LS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5ZjE3Ny4uN2M1OTYxNSAxMDA2NDQKLS0tIGEvV2ViS2l0 L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFt ZS5tbQpAQCAtMTkxLDE3ICsxOTEsMTcgQEAgRWRpdGFibGVMaW5rQmVoYXZpb3IgY29yZShXZWJL aXRFZGl0YWJsZUxpbmtCZWhhdmlvciBlZGl0YWJsZUxpbmtCZWhhdmlvcikKICAgICAgICAgICAg IHJldHVybiBFZGl0YWJsZUxpbmtMaXZlV2hlbk5vdEZvY3VzZWQ7CiAgICAgICAgIGNhc2UgV2Vi S2l0RWRpdGFibGVMaW5rTmV2ZXJMaXZlOgogICAgICAgICAgICAgcmV0dXJuIEVkaXRhYmxlTGlu a05ldmVyTGl2ZTsKICAgICB9CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgcmV0dXJu IEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQorV2ViQ29yZTo6RWRpdGlu Z0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKICAg ICBzd2l0Y2ggKGJlaGF2aW9yKSB7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ01hY0JlaGF2 aW9yOgogICAgICAgICAgICAgcmV0dXJuIFdlYkNvcmU6OkVkaXRpbmdNYWNCZWhhdmlvcjsKICAg ICAgICAgY2FzZSBXZWJLaXRFZGl0aW5nV2luQmVoYXZpb3I6CiAgICAgICAgICAgICByZXR1cm4g V2ViQ29yZTo6RWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKICAgICB9CiAgICAgQVNTRVJUX05PVF9S RUFDSEVEKCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5h bC5oIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaAppbmRleCA5YjIyNDhh Li41ODZiNGMzIDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5h bC5oCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKQEAgLTY2LDE3 ICs2NiwxNyBAQCB0eXBlZGVmIFdlYkNvcmU6Okhpc3RvcnlJdGVtIFdlYkNvcmVIaXN0b3J5SXRl bTsKIFdlYkNvcmU6OkZyYW1lKiBjb3JlKFdlYkZyYW1lICopOwogV2ViRnJhbWUgKmtpdChXZWJD b3JlOjpGcmFtZSAqKTsKIAogV2ViQ29yZTo6UGFnZSogY29yZShXZWJWaWV3ICopOwogV2ViVmll dyAqa2l0KFdlYkNvcmU6OlBhZ2UqKTsKIAogV2ViQ29yZTo6RWRpdGFibGVMaW5rQmVoYXZpb3Ig Y29yZShXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcik7CiBXZWJDb3JlOjpUZXh0RGlyZWN0aW9u U3VibWVudUluY2x1c2lvbkJlaGF2aW9yIGNvcmUoV2ViVGV4dERpcmVjdGlvblN1Ym1lbnVJbmNs dXNpb25CZWhhdmlvcik7Ci1XZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0 aW5nQmVoYXZpb3IpOworV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVk aXRpbmdCZWhhdmlvcik7CiAKIFdlYlZpZXcgKmdldFdlYlZpZXcoV2ViRnJhbWUgKndlYkZyYW1l KTsKIAogQGludGVyZmFjZSBXZWJGcmFtZVByaXZhdGUgOiBOU09iamVjdCB7CiBAcHVibGljCiAg ICAgV2ViQ29yZTo6RnJhbWUqIGNvcmVGcmFtZTsKICAgICBXZWJGcmFtZVZpZXcgKndlYkZyYW1l VmlldzsKICAgICBXZWJTY3JpcHREZWJ1Z2dlciogc2NyaXB0RGVidWdnZXI7CmRpZmYgLS1naXQg YS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tCmluZGV4IDk3Yzc5OWIuLjlmM2FkNjAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0x MzY0LDE3ICsxMzY0LDE3IEBAIHN0YXRpYyBib29sIGZhc3REb2N1bWVudFRlYXJkb3duRW5hYmxl ZCgpCiAgICAgc2V0dGluZ3MtPnNldFNhbnNTZXJpZkZvbnRGYW1pbHkoW3ByZWZlcmVuY2VzIHNh bnNTZXJpZkZvbnRGYW1pbHldKTsKICAgICBzZXR0aW5ncy0+c2V0U2VyaWZGb250RmFtaWx5KFtw cmVmZXJlbmNlcyBzZXJpZkZvbnRGYW1pbHldKTsKICAgICBzZXR0aW5ncy0+c2V0U3RhbmRhcmRG b250RmFtaWx5KFtwcmVmZXJlbmNlcyBzdGFuZGFyZEZvbnRGYW1pbHldKTsKICAgICBzZXR0aW5n cy0+c2V0TG9hZHNJbWFnZXNBdXRvbWF0aWNhbGx5KFtwcmVmZXJlbmNlcyBsb2Fkc0ltYWdlc0F1 dG9tYXRpY2FsbHldKTsKICAgICBzZXR0aW5ncy0+c2V0U2hvdWxkUHJpbnRCYWNrZ3JvdW5kcyhb cHJlZmVyZW5jZXMgc2hvdWxkUHJpbnRCYWNrZ3JvdW5kc10pOwogICAgIHNldHRpbmdzLT5zZXRU ZXh0QXJlYXNBcmVSZXNpemFibGUoW3ByZWZlcmVuY2VzIHRleHRBcmVhc0FyZVJlc2l6YWJsZV0p OwogICAgIHNldHRpbmdzLT5zZXRTaHJpbmtzU3RhbmRhbG9uZUltYWdlc1RvRml0KFtwcmVmZXJl bmNlcyBzaHJpbmtzU3RhbmRhbG9uZUltYWdlc1RvRml0XSk7CiAgICAgc2V0dGluZ3MtPnNldEVk aXRhYmxlTGlua0JlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRhYmxlTGlua0JlaGF2aW9y XSkpOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMg ZWRpdGluZ0JlaGF2aW9yXSkpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBl KGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRpbmdCZWhhdmlvcl0pKTsKICAgICBzZXR0aW5ncy0+c2V0 VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyB0 ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5z ZXRET01QYXN0ZUFsbG93ZWQoW3ByZWZlcmVuY2VzIGlzRE9NUGFzdGVBbGxvd2VkXSk7CiAgICAg c2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoW3NlbGYgdXNlc1BhZ2VDYWNoZV0pOwogICAgIHNl dHRpbmdzLT5zZXRTaG93c1VSTHNJblRvb2xUaXBzKFtwcmVmZXJlbmNlcyBzaG93c1VSTHNJblRv b2xUaXBzXSk7CiAgICAgc2V0dGluZ3MtPnNldERldmVsb3BlckV4dHJhc0VuYWJsZWQoW3ByZWZl cmVuY2VzIGRldmVsb3BlckV4dHJhc0VuYWJsZWRdKTsKICAgICBzZXR0aW5ncy0+c2V0QXV0aG9y QW5kVXNlclN0eWxlc0VuYWJsZWQoW3ByZWZlcmVuY2VzIGF1dGhvckFuZFVzZXJTdHlsZXNFbmFi bGVkXSk7CiAgICAgc2V0dGluZ3MtPnNldEFwcGxpY2F0aW9uQ2hyb21lTW9kZShbcHJlZmVyZW5j ZXMgYXBwbGljYXRpb25DaHJvbWVNb2RlRW5hYmxlZF0pOwogICAgIGlmIChbcHJlZmVyZW5jZXMg dXNlclN0eWxlU2hlZXRFbmFibGVkXSkgewpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCBiL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKaW5kZXggMGIyZTlhNS4uYTk1MWE0OSAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9y dFF0LmNwcAorKysgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwCkBAIC00NzEsMjggKzQ3MSwyOCBAQCBib29sIER1bXBSZW5kZXJUcmVlU3VwcG9y dFF0OjplbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVsZW1lbnRXaXRoSWQoUVdlYkZyYW1lKgog CiAgICAgcmV0dXJuIChpbnB1dEVsZW1lbnQtPmlzVGV4dEZpZWxkKCkKICAgICAgICAgICAgICYm IGlucHV0RWxlbWVudC0+aW5wdXRUeXBlKCkgIT0gSFRNTElucHV0RWxlbWVudDo6UEFTU1dPUkQK ICAgICAgICAgICAgICYmIGlucHV0RWxlbWVudC0+YXV0b0NvbXBsZXRlKCkpOwogfQogCiB2b2lk IER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBhZ2UqIHBh Z2UsIGNvbnN0IFFTdHJpbmcmIGVkaXRpbmdCZWhhdmlvcikKIHsKLSAgICBXZWJDb3JlOjpFZGl0 aW5nQmVoYXZpb3IgY29yZUVkaXRpbmdCZWhhdmlvcjsKKyAgICBXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3JUeXBlIGNvcmVFZGl0aW5nQmVoYXZpb3I7CiAKICAgICBpZiAoZWRpdGluZ0JlaGF2aW9y ID09ICJ3aW4iKQogICAgICAgICBjb3JlRWRpdGluZ0JlaGF2aW9yID0gRWRpdGluZ1dpbmRvd3NC ZWhhdmlvcjsKICAgICBlbHNlIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIm1hYyIpCiAgICAgICAg IGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nTWFjQmVoYXZpb3I7CiAKICAgICBQYWdlKiBj b3JlUGFnZSA9IFFXZWJQYWdlUHJpdmF0ZTo6Y29yZShwYWdlKTsKICAgICBpZiAoIWNvcmVQYWdl KQogICAgICAgICByZXR1cm47CiAKLSAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGlu Z0JlaGF2aW9yKGNvcmVFZGl0aW5nQmVoYXZpb3IpOworICAgIGNvcmVQYWdlLT5zZXR0aW5ncygp LT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmVFZGl0aW5nQmVoYXZpb3IpOwogfQogCiB2b2lk IER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpkdW1wRnJhbWVMb2FkZXIoYm9vbCBiKQogewogICAg IEZyYW1lTG9hZGVyQ2xpZW50UXQ6OmR1bXBGcmFtZUxvYWRlckNhbGxiYWNrcyA9IGI7CiB9CiAK IHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmR1bXBSZXNvdXJjZUxvYWRDYWxsYmFja3Mo Ym9vbCBiKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBiL1dlYktpdC93aW4v V2ViVmlldy5jcHAKaW5kZXggNTI1MTA4Zi4uYmE1YmY0NCAxMDA2NDQKLS0tIGEvV2ViS2l0L3dp bi9XZWJWaWV3LmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBAIC00NjQ5LDE3ICs0 NjQ5LDE3IEBAIEhSRVNVTFQgV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKElXZWJO b3RpZmljYXRpb24qIG5vdGlmaWNhdGlvbikKICAgICBpZiAoRkFJTEVEKGhyKSkKICAgICAgICAg cmV0dXJuIGhyOwogICAgIHNldHRpbmdzLT5zZXRFZGl0YWJsZUxpbmtCZWhhdmlvcigoRWRpdGFi bGVMaW5rQmVoYXZpb3IpYmVoYXZpb3IpOwogCiAgICAgV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGVk aXRpbmdCZWhhdmlvcjsKICAgICBociA9IHByZWZlcmVuY2VzLT5lZGl0aW5nQmVoYXZpb3IoJmVk aXRpbmdCZWhhdmlvcik7CiAgICAgaWYgKEZBSUxFRChocikpCiAgICAgICAgIHJldHVybiBocjsK LSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKChFZGl0aW5nQmVoYXZpb3IpZWRpdGlu Z0JlaGF2aW9yKTsKKyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZSgoRWRpdGlu Z0JlaGF2aW9yVHlwZSllZGl0aW5nQmVoYXZpb3IpOwogCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ dXNlc1BhZ2VDYWNoZSgmZW5hYmxlZCk7CiAgICAgaWYgKEZBSUxFRChocikpCiAgICAgICAgIHJl dHVybiBocjsKICAgICBzZXR0aW5ncy0+c2V0VXNlc1BhZ2VDYWNoZSghIWVuYWJsZWQpOwogCiAg ICAgaHIgPSBwcmVmZXJlbmNlcy0+aXNET01QYXN0ZUFsbG93ZWQoJmVuYWJsZWQpOwogICAgIGlm IChGQUlMRUQoaHIpKQotLSAKMS43LjAuNAoK 57495 2010-05-31 14:33:36 -0700 2010-05-31 17:49:00 -0700 patch v1 - functional 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 36956 tonikitoo RnJvbSA0NTk2ODA2OGU2YTE4MmViMDJjYTgxZTA1ZWVlNjJiZjg1YzY4ODYxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAzMSBNYXkgMjAxMCAxNTo1NDo1NSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpQYXRjaCBieSBBbnRvbmlvIEdvbWVzIDx0b25pa2l0 b29Ad2Via2l0Lm9yZz4KCldlYkNvcmU6CgpBcyBwZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2Mjcs IHRoZSBmb2xsb3dpbmcgd2FzIHN1Z2dlc3RlZCBieSBEYXJpbiBBZGxlcjogImJlZm9yZSB0aGUg YWRkaXRpb24gb2YgYW55Cm5ldyBFZGl0aW5nQmVoYXZpb3IsIEkgdGhpbmsgd2UgbmVlZCB0byBh ZGQgZnVuY3Rpb25zIHRvIHRyYW5zbGF0ZSB0aGUgb3ZlcmFsbCBiZWhhdmlvciBwb2xpY3kgaW50 byBzcGVjaWZpYwpiZWhhdmlvcnMgcmF0aGVyIHRoYW4gZGlyZWN0bHkgc2F5aW5nICdiZWhhdmlv ciA9PSBNYWMnIG9yICdiZWhhdmlvciA9PSBXaW5kb3dzJy4gSGVscGVyIGZ1bmN0aW9ucyB0aGF0 CmV4cHJlc3Npb24gdGhlIGRpZmZlcmVudCBydWxlcyBpbiBwbGFpbiBsYW5ndWFnZS4iLgoKUGF0 Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KCk5vIGJlaGF2aW9yIGNoYW5nZSwgc28gbm8gbmV3 IHRlc3RzLgoKKiBHTlVtYWtlZmlsZS5hbToKKiBXZWJDb3JlLnBybzoKKiBwYWdlL1NldHRpbmdz LmNwcDoKKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CiogcGFnZS9TZXR0aW5ncy5oOiBN b3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmgsCmFuZCByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzLgooV2Vi Q29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0 RWRpdGluZ0JlaGF2aW9yLgooV2ViQ29yZTo6U2V0dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUp OiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9yLgoqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9y Lmg6IEFkZGVkLgooV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBD bGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2ludCBmb3IKZWRpdGluZyBiZWhhdmlvciB0aGF0 IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBs YXRmb3Jtcy9wb3J0cy4KQ2xhc3Mgc2hvdWxkIGJlIG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBk aXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5IGNvbnN0cnVjdGVkCnRocm91Z2ggdGhlIEVk aXRvciBjbGFzcy4KKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9I b3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKToKKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CihXZWJD b3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVj dGlvbmFsKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVBy ZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKToKKFdlYkNvcmU6 OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250 YWxOYXZpZ2F0aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVj dGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToKKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5 cGVzLmg6IEFkZGVkLgooV2ViQ29yZTo6KToKKiBlZGl0aW5nL0VkaXRvci5jcHA6CihXZWJDb3Jl OjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCiog ZWRpdGluZy9FZGl0b3IuaDoKKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwOgooV2ViQ29yZTo6 ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgoo V2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKFdlYkNvcmU6OlNl bGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgooV2ViQ29yZTo6U2VsZWN0aW9u Q29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjptb2RpZnkpOgoqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKFdlYkNvcmU6OkV2ZW50 SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xpY2spOgoqIHJlbmRlcmluZy9S ZW5kZXJCbG9jay5jcHA6CihXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdp dGhJbmxpbmVDaGlsZHJlbik6CgotIENhbGwgc2l0ZXMgd2lsbCBsb29rIGxpa2U6CmlmIChmcmFt ZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkVGhpc0lmVGhhdCgpKSkKICAgLy8gZG8gc29t ZXRoaW5nCgpXZWJLaXQ6CgpFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0 aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bwpFZGl0aW5n QmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGlu Z2x5LgoKV2ViS2l0L2Nocm9taXVtOgoqIHNyYy9XZWJTZXR0aW5nc0ltcGwuY3BwOgooV2ViS2l0 OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdCZWhhdmlvcik6CgpXZWJLaXQvZ3RrOgoqIHdl YmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKFdlYktpdDo6Y29yZSk6Ciogd2Via2l0L3dlYmtpdHBy aXZhdGUuaDoKKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6Cih3ZWJraXRfd2ViX3ZpZXdfdXBk YXRlX3NldHRpbmdzKToKKHdlYmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkpOgoKV2ViS2l0 L21hYzoKKiBXZWJWaWV3L1dlYkZyYW1lLm1tOgooY29yZSk6CiogV2ViVmlldy9XZWJGcmFtZUlu dGVybmFsLmg6CiogV2ViVmlldy9XZWJWaWV3Lm1tOgooLVtXZWJWaWV3IF9wcmVmZXJlbmNlc0No YW5nZWROb3RpZmljYXRpb246XSk6CgpXZWJLaXQvcXQ6CiogV2ViQ29yZVN1cHBvcnQvRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQuY3BwOgooRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRp bmdCZWhhdmlvcik6CgpXZWJLaXQvd2luOgoqIFdlYlZpZXcuY3BwOgooV2ViVmlldzo6bm90aWZ5 UHJlZmVyZW5jZXNDaGFuZ2VkKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNTUgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv R05VbWFrZWZpbGUuYW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJD b3JlL1dlYkNvcmUuZ3lwaSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwog V2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAx ICsKIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogICAgICAgICAgICAgIHwg ICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAg ICAgIHwgICA1MiArKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oICAgICAgICAgICAgIHwgICA0NiArKysrKysrKysrKysrKysrCiBXZWJDb3Jl L2VkaXRpbmcvRWRpdG9yLmNwcCAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTAgKysrKwog V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAz ICsKIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCAgICAgICAgICAgICAgICAgIHwg ICAgMyArLQogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAg ICAgfCAgIDEwICsrLS0KIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwICAgICAgICAgICAg ICAgICAgICAgIHwgICAgMiArLQogV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMjQgKystLS0tLS0tCiBXZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJCbG9jay5jcHAgICAgICAgICAgICAgICAgICB8ICAgIDkgKystLQogV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiBXZWJL aXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAgICAgICAgICAgICB8ICAgIDIgKy0K IFdlYktpdC9ndGsvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAx NyArKysrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAg ICAgIHwgICAgNCArLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAg ICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCAg ICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYktpdC9tYWMvQ2hhbmdlTG9nICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysKIFdlYktpdC9tYWMvV2ViVmlldy9XZWJG cmFtZS5tbSAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3 L1dlYkZyYW1lSW50ZXJuYWwuaCAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dl YlZpZXcvV2ViVmlldy5tbSAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9x dC9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysrKwog Li4uL3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCAgfCAgICA0 ICstCiBXZWJLaXQvd2luL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgMTMgKysrKysKIFdlYktpdC93aW4vV2ViVmlldy5jcHAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAgMiArLQogMjkgZmlsZXMgY2hhbmdlZCwgMjc5IGluc2VydGlvbnMoKyksIDQ2 IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5n QmVoYXZpb3IuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhMGJkZTk1Li44YmNhNDZjIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU4IEBACisyMDEwLTA1LTMx ICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5k ZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgQXMgcGVy IGRpc2N1c3Npb24gaW4gYnVnIDM2NjI3LCBEYXJpbiBBZGxlciBzdWdnZXN0ZWQ6ICJiZWZvcmUg dGhlIGFkZGl0aW9uIG9mIGFueSBuZXcgRWRpdGluZ0JlaGF2aW9yLAorICAgICAgICBJIHRoaW5r IHdlIHRvIGFkZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBv bGljeSBpbnRvIHNwZWNpZmljIGJlaGF2aW9ycyByYXRoZXIgdGhhbgorICAgICAgICBkaXJlY3Rs eSBzYXlpbmcgJ2JlaGF2aW9yID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxw ZXIgZnVuY3Rpb25zIHRoYXQgZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50CisgICAgICAgIHJ1bGVz IGluIHBsYWluIGxhbmd1YWdlLiIuIFBhdGNoIGFkZHJlc3NlcyB0aGlzIHJlcXVlc3QuCisKKyAg ICAgICAgTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBH TlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBwYWdlL1Nl dHRpbmdzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CisgICAg ICAgICogcGFnZS9TZXR0aW5ncy5oOiBNb3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8g V2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgsCisgICAgICAgIGFuZCByZW5h bWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzLgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6 OnNldEVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9y LgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5h bWVkIGZyb20gZWRpdGluZ0JlaGF2aW9yLgorICAgICAgICAqIGVkaXRpbmcvRWRpdGluZ0JlaGF2 aW9yLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5n QmVoYXZpb3IpOiBDbGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2ludCBmb3IKKyAgICAgICAg ZWRpdGluZyBiZWhhdmlvciB0aGF0IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRs eSBpbiB0aGUgZGlmZmVyZW50IHBsYXRmb3Jtcy9wb3J0cy4KKyAgICAgICAgQ2xhc3Mgc2hvdWxk IGJlIG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNp dGx5IGNvbnN0cnVjdGVkCisgICAgICAgIHRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFs Qm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CisgICAg ICAgIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rp b25Bc0RpcmVjdGlvbmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKyAg ICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJv bUVuZFBvaW50QWx3YXlzKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRl bmRpbmdUb0JvdW5kYXJ5KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVz Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRv ci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBF ZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisgICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAg ICAgKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0 ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwp OgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0 Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgor ICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50 SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJl bmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6 cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNp dGVzIHdpbGwgbG9vayBsaWtlOgorICAgICAgICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlv cigpLnNob3VsZFRoaXNJZlRoYXQoKSkpCisgICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAy MDEwLTA1LTMwICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1h a2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCA5Yjk1MzMwLi5lMDZlY2U0 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFr ZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNv cmUvZWRpdGluZy9FZGl0QWN0aW9uLmggXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5j cHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcv RWRpdGluZ0JlaGF2aW9yLmggXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0Vk aXRvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA1YjRj NTU5Li4wZTEzM2JiIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJD b3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5MSw2ICsxMjkxLDggQEAKICAgICAgICAgICAgICdlZGl0 aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAgICAgICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAn LAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oJywKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAg ICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2Vi Q29yZS5wcm8KaW5kZXggZDNlYjExNS4uNGNmYWQ5ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJD b3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0xMjc3LDYgKzEyNzcsNyBAQCBI RUFERVJTICs9IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAg ICAgZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENv bW1hbmQuaCBcCisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9F ZGl0b3IuaCBcCiAgICAgZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGlu Zy9odG1sZWRpdGluZy5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4 IGZjYmI3ZjUuLjBkOWY4OWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpA QCAtMzA0NDksNiArMzA0NDksMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQor CQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRpdGluZ1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0K KwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRp dGluZ0JlaGF2aW9yVHlwZXMuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmls ZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggYi9XZWJD b3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZDc4ZTlhMAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0 aW5nQmVoYXZpb3IuaApAQCAtMCwwICsxLDUyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29weXJp Z2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBFZGl0 aW5nQmVoYXZpb3JfaAorI2RlZmluZSBFZGl0aW5nQmVoYXZpb3JfaAorCisjaW5jbHVkZSAiRWRp dGluZ0JlaGF2aW9yVHlwZXMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBFZGl0 aW5nQmVoYXZpb3IgeworCitwdWJsaWM6CisgICAgRWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhh dmlvclR5cGUgdHlwZSkKKyAgICAgICAgOiBtX3R5cGUodHlwZSkKKyAgICB7CisgICAgfQorCisg ICAgLy8gSW5kaXZpZHVhbCBmdW5jdGlvbnMgZm9yIGVhY2ggY2FzZSB3aGVyZSB3ZSBoYXZlIG1v cmUgdGhhbiBvbmUgc3R5bGUgb2YgZWRpdGluZyBiZWhhdmlvci4KKyAgICAvLyBDcmVhdGUgYSBu ZXcgZnVuY3Rpb24gZm9yIGFueSBwbGF0Zm9ybSBkaWZmZXJlbmNlIHNvIHdlIGNhbiBjb250cm9s IGl0IGhlcmUuCisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdo ZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRv d3NCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNS ZXZlYWxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0K KyAgICBib29sIHNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKCkgY29u c3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hv dWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKCkgY29u c3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hv dWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKCkgY29uc3QgeyByZXR1cm4gbV90 eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkS2V5YmFyZFNlbGVj dGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKCkgY29uc3QgeyByZXR1cm4gbV90eXBl ID09IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkR3Jvd1NlbGVjdGlvbldo ZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdN YWNCZWhhdmlvcjsgfQorCitwcml2YXRlOgorICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgbV90eXBl OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRWRpdGluZ0JlaGF2 aW9yX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5o IGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uYWNhOTZkMwotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5 KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaWZuZGVmIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKKyNkZWZpbmUgRWRpdGluZ0JlaGF2 aW9yVHlwZXNfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKyAgICAvLyBUaGVyZSBhcmUgbXVs dGlwbGUgZWRpdGluZyBkZXRhaWxzIHRoYXQgYXJlIGRpZmZlcmVudCBvbiBXaW5kb3dzIHRoYW4g TWFjaW50b3NoLgorICAgIC8vIFdlIHVzZSBhIHNpbmdsZSBzd2l0Y2ggZm9yIGFsbCBvZiB0aGVt LiBTb21lIGV4YW1wbGVzOgorICAgIC8vCisgICAgLy8gICAgMSkgQ2xpY2tpbmcgYmVsb3cgdGhl IGxhc3QgbGluZSBvZiBhbiBlZGl0YWJsZSBhcmVhIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQK KyAgICAvLyAgICAgICBvZiB0aGUgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGluIHRoZSBtaWRkbGUg b2YgdGhlIGxhc3QgbGluZSBvbiBXaW5kb3dzLgorICAgIC8vICAgIDIpIFB1c2hpbmcgdGhlIGRv d24gYXJyb3cga2V5IG9uIHRoZSBsYXN0IGxpbmUgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZCBv ZiB0aGUKKyAgICAvLyAgICAgICBsYXN0IGxpbmUgb24gTWFjLCBidXQgZG9lcyBub3RoaW5nIG9u IFdpbmRvd3MuIEEgc2ltaWxhciBjYXNlIGV4aXN0cyBvbiB0aGUKKyAgICAvLyAgICAgICB0b3Ag bGluZS4KKyAgICAvLworICAgIC8vIFRoaXMgc2V0dGluZyBpcyBpbnRlbmRlZCB0byBjb250cm9s IHRoZXNlIHNvcnRzIG9mIGJlaGF2aW9ycy4gVGhlcmUgYXJlIHNvbWUgb3RoZXIKKyAgICAvLyBi ZWhhdmlvcnMgd2l0aCBpbmRpdmlkdWFsIGZ1bmN0aW9uIGNhbGxzIG9uIEVkaXRvckNsaWVudCAo c21hcnQgY29weSBhbmQgcGFzdGUgYW5kCisgICAgLy8gc2VsZWN0aW5nIHRoZSBzcGFjZSBhZnRl ciBhIGRvdWJsZSBjbGljaykgdGhhdCBjb3VsZCBiZSBjb21iaW5lZCB3aXRoIHRoaXMgaWYKKyAg ICAvLyBpZiBwb3NzaWJsZSBpbiB0aGUgZnV0dXJlLgorICAgIGVudW0gRWRpdGluZ0JlaGF2aW9y VHlwZSB7CisgICAgICAgIEVkaXRpbmdNYWNCZWhhdmlvciwKKyAgICAgICAgRWRpdGluZ1dpbmRv d3NCZWhhdmlvcgorICAgIH07CisKK30gLy8gV2ViQ29yZSBuYW1lc3BhY2UKKworI2VuZGlmIC8v IEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggNjAzZjM1Yy4uN2EyNjk4 NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKKysrIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5jcHAKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlICJSZW5kZXJCbG9j ay5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJSZXBsYWNlU2VsZWN0aW9u Q29tbWFuZC5oIgorI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiU291bmQuaCIKICNp bmNsdWRlICJUZXh0LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCkBAIC05Nyw2ICs5OCwx NSBAQCBWaXNpYmxlU2VsZWN0aW9uIEVkaXRvcjo6c2VsZWN0aW9uRm9yQ29tbWFuZChFdmVudCog ZXZlbnQpCiAgICAgcmV0dXJuIHNlbGVjdGlvbjsKIH0KIAorLy8gRnVuY3Rpb24gY29uc2lkZXJz IE1hYyBlZGl0aW5nIGJlaGF2aW9yIGEgZmFsbGJhY2sgd2hlbiBQYWdlIG9yIFNldHRpbmdzIGlz IG5vdCBhdmFpbGFibGUuCitFZGl0aW5nQmVoYXZpb3IgRWRpdG9yOjpiZWhhdmlvcigpIGNvbnN0 Cit7CisgICAgaWYgKCFtX2ZyYW1lIHx8ICFtX2ZyYW1lLT5wYWdlKCkgfHwgIW1fZnJhbWUtPnNl dHRpbmdzKCkpCisgICAgICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ01hY0JlaGF2 aW9yKTsKKworICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IobV9mcmFtZS0+c2V0dGluZ3MoKS0+ ZWRpdGluZ0JlaGF2aW9yVHlwZSgpKTsKK30KKwogRWRpdG9yQ2xpZW50KiBFZGl0b3I6OmNsaWVu dCgpIGNvbnN0CiB7CiAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBtX2ZyYW1lLT5wYWdlKCkpCmRpZmYg LS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9y LmgKaW5kZXggMTdkZDNiYi4uM2UyMjNkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0Vk aXRvci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMjksNiArMjksNyBAQAog I2luY2x1ZGUgIkNsaXBib2FyZEFjY2Vzc1BvbGljeS5oIgogI2luY2x1ZGUgIkNvbG9yLmgiCiAj aW5jbHVkZSAiRWRpdEFjdGlvbi5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgogI2lu Y2x1ZGUgIkVkaXRvckRlbGV0ZUFjdGlvbi5oIgogI2luY2x1ZGUgIkVkaXRvckluc2VydEFjdGlv bi5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIKQEAgLTI4MSw2ICsyODIsOCBA QCBwdWJsaWM6CiAKICAgICBLaWxsUmluZyoga2lsbFJpbmcoKSBjb25zdCB7IHJldHVybiBtX2tp bGxSaW5nLmdldCgpOyB9CiAKKyAgICBFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IoKSBjb25zdDsK KwogICAgIFBhc3NSZWZQdHI8UmFuZ2U+IHNlbGVjdGVkUmFuZ2UoKTsKICAgICAKICAgICAvLyBX ZSBzaG91bGQgbWFrZSB0aGVzZSBmdW5jdGlvbnMgcHJpdmF0ZSB3aGVuIHRoZWlyIGNhbGxlcnMg aW4gRnJhbWUgYXJlIG1vdmVkIG92ZXIgaGVyZSB0byBFZGl0b3IKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcAppbmRleCA3ZTg1YWE5Li5lMmE2NDg4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwCkBAIC0xNjQsOSArMTY0LDggQEAgc3RhdGljIGJvb2wgZXhlY3V0ZVRvZ2dsZVN0eWxlKEZy YW1lKiBmcmFtZSwgRWRpdG9yQ29tbWFuZFNvdXJjZSBzb3VyY2UsIEVkaXRBY3QKICAgICAvLyBT dHlsZSBpcyBjb25zaWRlcmVkIHByZXNlbnQgd2hlbgogICAgIC8vIG1hYzogcHJlc2VudCBhdCB0 aGUgYmVnaW5uaW5nIG9mIHNlbGVjdGlvbgogICAgIC8vIG90aGVyOiBwcmVzZW50IHRocm91Z2hv dXQgdGhlIHNlbGVjdGlvbgotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGZyYW1lLT5kb2N1bWVu dCgpLT5zZXR0aW5ncygpOwogICAgIGJvb2wgc3R5bGVJc1ByZXNlbnQ7Ci0gICAgaWYgKHNldHRp bmdzICYmIHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3Ip CisgICAgaWYgKCFmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkQ29uc2lkZXJTdHls ZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKCkpCiAgICAgICAgIHN0eWxlSXNQ cmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25TdGFydEhhc1N0eWxlKHN0eWxlLmdl dCgpKTsKICAgICBlbHNlCiAgICAgICAgIHN0eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigp LT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5nZXQoKSkgPT0gVHJ1ZVRyaVN0YXRlOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwIGIvV2ViQ29yZS9l ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IDgxNmY5NjguLjEwN2Q4NTkgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAorKysgYi9X ZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKQEAgLTE2NCw3ICsxNjQsNyBA QCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2Vs ZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaQogICAgIGlmICh1c2VyVHJpZ2dlcmVkKSB7CiAgICAg ICAgIFNjcm9sbEFsaWdubWVudCBhbGlnbm1lbnQ7CiAKLSAgICAgICAgaWYgKG1fZnJhbWUtPnNl dHRpbmdzKCkgJiYgbV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRp dGluZ01hY0JlaGF2aW9yKQorICAgICAgICBpZiAobV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9y KCkuc2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCgpKQogICAgICAgICAg ICAgYWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Ny b2xsQWxpZ25tZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25D ZW50ZXJJZk5lZWRlZDsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgYWxpZ25tZW50ID0gKGFs aWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xsQWxpZ25tZW50OjphbGln blRvcEFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJZk5lZWRlZDsKQEAgLTI0 Myw4ICsyNDMsNyBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om5vZGVXaWxsQmVSZW1vdmVk KE5vZGUgKm5vZGUpCiAgICAgCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0 aW9uYWwoYm9vbCBpc0RpcmVjdGlvbmFsKQogewotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IG1f ZnJhbWUgPyBtX2ZyYW1lLT5zZXR0aW5ncygpIDogMDsKLSAgICBtX2lzRGlyZWN0aW9uYWwgPSAh c2V0dGluZ3MgfHwgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpICE9IEVkaXRpbmdNYWNCZWhh dmlvciB8fCBpc0RpcmVjdGlvbmFsOworICAgIG1faXNEaXJlY3Rpb25hbCA9ICFtX2ZyYW1lIHx8 IG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rp b25Bc0RpcmVjdGlvbmFsKCkgfHwgaXNEaXJlY3Rpb25hbDsKIH0KIAogdm9pZCBTZWxlY3Rpb25D b250cm9sbGVyOjp3aWxsQmVNb2RpZmllZChFQWx0ZXJhdGlvbiBhbHRlciwgRURpcmVjdGlvbiBk aXJlY3Rpb24pCkBAIC0yOTgsOCArMjk3LDcgQEAgVGV4dERpcmVjdGlvbiBTZWxlY3Rpb25Db250 cm9sbGVyOjpkaXJlY3Rpb25PZkVuY2xvc2luZ0Jsb2NrKCkKIFZpc2libGVQb3NpdGlvbiBTZWxl Y3Rpb25Db250cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKGJvb2wgaXNHZXRTdGFydCkgY29u c3QKIHsKICAgICBQb3NpdGlvbiBwb3M7Ci0gICAgU2V0dGluZ3MqIHNldHRpbmdzID0gbV9mcmFt ZSA/IG1fZnJhbWUtPnNldHRpbmdzKCkgOiAwOwotICAgIGlmIChzZXR0aW5ncyAmJiBzZXR0aW5n cy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgIGlmIChtX2Zy YW1lICYmIG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZEtleWJhcmRTZWxlY3Rp b25FeHRlbmRGb3JIb3Jpem9udGFsTmF2aWdhdGlvbigpKQogICAgICAgICBwb3MgPSBpc0dldFN0 YXJ0ID8gbV9zZWxlY3Rpb24uc3RhcnQoKSA6IG1fc2VsZWN0aW9uLmVuZCgpOwogICAgIGVsc2Ug ewogICAgICAgICAvLyBMaW51eCBhbmQgV2luZG93cyBhbHdheXMgZXh0ZW5kIHNlbGVjdGlvbnMg ZnJvbSB0aGUgZXh0ZW50IGVuZHBvaW50LgpAQCAtNjg1LDcgKzY4Myw3IEBAIGJvb2wgU2VsZWN0 aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBFRGlyZWN0aW9uIGRpcmVj dGlvbiwgVGV4dEdyCiAgICAgICAgIG1vdmVUbyhwb3NpdGlvbiwgdXNlclRyaWdnZXJlZCk7CiAg ICAgICAgIGJyZWFrOwogICAgIGNhc2UgRVhURU5EOgotICAgICAgICBpZiAoIXNldHRpbmdzIHx8 IHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nTWFjQmVoYXZpb3IgfHwgbV9z ZWxlY3Rpb24uaXNDYXJldCgpIHx8ICFpc0JvdW5kYXJ5KGdyYW51bGFyaXR5KSkKKyAgICAgICAg aWYgKCFtX2ZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRHcm93U2VsZWN0aW9uV2hl bkV4dGVuZGluZ1RvQm91bmRhcnkoKSB8fCBtX3NlbGVjdGlvbi5pc0NhcmV0KCkgfHwgIWlzQm91 bmRhcnkoZ3JhbnVsYXJpdHkpKQogICAgICAgICAgICAgc2V0RXh0ZW50KHBvc2l0aW9uLCB1c2Vy VHJpZ2dlcmVkKTsKICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAvLyBTdGFuZGFyZCBNYWMg YmVoYXZpb3Igd2hlbiBleHRlbmRpbmcgdG8gYSBib3VuZGFyeSBpcyBncm93IHRoZSBzZWxlY3Rp b24gcmF0aGVyCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1dl YkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCmluZGV4IDVkZDYwYWEuLjgzOWJiNDYgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9F dmVudEhhbmRsZXIuY3BwCkBAIC0zNzAsNyArMzcwLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlUHJlc3NFdmVudFNpbmdsZUNsaWNrKGNvbnN0IE1vdXNlRXZlbnRXaXRoSGl0VGVz dFIKICAgICAgICAgbV9mcmFtZS0+c2VsZWN0aW9uKCktPnNldElzRGlyZWN0aW9uYWwoZmFsc2Up OwogICAgICAgICAKICAgICAgICAgQVNTRVJUKG1fZnJhbWUtPnNldHRpbmdzKCkpOwotICAgICAg ICBpZiAobV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01h Y0JlaGF2aW9yKSB7CisgICAgICAgIGlmICghbV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCku c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKCkpIHsKICAgICAgICAgICAg IC8vIFNlZSA8cmRhcjovL3Byb2JsZW0vMzY2ODE1Nz4gUkVHUkVTU0lPTiAoTWFpbCk6IHNoaWZ0 LWNsaWNrIGRlc2VsZWN0cyB3aGVuIHNlbGVjdGlvbgogICAgICAgICAgICAgLy8gd2FzIGNyZWF0 ZWQgcmlnaHQtdG8tbGVmdAogICAgICAgICAgICAgUG9zaXRpb24gc3RhcnQgPSBuZXdTZWxlY3Rp b24uc3RhcnQoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJD b3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmluZGV4IDZmNmJiMDQuLmRkNDBjNDMgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNw cApAQCAtMTEzLDcgKzExMyw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQogICAg ICwgbV9lbmZvcmNlQ1NTTUlNRVR5cGVJblN0cmljdE1vZGUodHJ1ZSkKICAgICAsIG1fdXNlc0Vu Y29kaW5nRGV0ZWN0b3IoZmFsc2UpCiAgICAgLCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dz KGZhbHNlKQotICAgICwgbV9lZGl0aW5nQmVoYXZpb3IoCisgICAgLCBtX2VkaXRpbmdCZWhhdmlv clR5cGUoCiAjaWYgUExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERB UldJTikpCiAgICAgICAgIC8vIChQTEFURk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJv bWl1bSwgaGVuY2UgdGhlIGV4dHJhIGNvbmRpdGlvbi4pCiAgICAgICAgIEVkaXRpbmdNYWNCZWhh dmlvcgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuaAppbmRleCBkYzNiNTBmLi42YTljMjVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjgsNiArMjgs NyBAQAogI2RlZmluZSBTZXR0aW5nc19oCiAKICNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNp bmNsdWRlICJFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgogI2luY2x1ZGUgIkZvbnRSZW5kZXJpbmdN b2RlLmgiCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlpvb21Nb2RlLmgiCkBAIC01MCwy MSArNTEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFRleHREaXJlY3Rpb25TdWJt ZW51QWx3YXlzSW5jbHVkZWQKICAgICB9OwogCi0gICAgLy8gVGhlcmUgYXJlIG11bHRpcGxlIGVk aXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQgb24gV2luZG93cyB0aGFuIE1hY2ludG9z aC4KLSAgICAvLyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBl eGFtcGxlczoKLSAgICAvLwotICAgIC8vICAgIDEpIENsaWNraW5nIGJlbG93IHRoZSBsYXN0IGxp bmUgb2YgYW4gZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kCi0gICAgLy8g ICAgICAgb2YgdGhlIGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBs YXN0IGxpbmUgb24gV2luZG93cy4KLSAgICAvLyAgICAyKSBQdXNoaW5nIHRoZSBkb3duIGFycm93 IGtleSBvbiB0aGUgbGFzdCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQgb2YgdGhlCi0g ICAgLy8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dz LiBBIHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCi0gICAgLy8gICAgICAgdG9wIGxpbmUuCi0g ICAgLy8KLSAgICAvLyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBz b3J0cyBvZiBiZWhhdmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCi0gICAgLy8gYmVoYXZpb3Jz IHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0IGNv cHkgYW5kIHBhc3RlIGFuZAotICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBkb3Vi bGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCi0gICAgLy8gaWYg cG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7IEVkaXRp bmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OwotCiAgICAgY2xhc3MgU2V0 dGluZ3MgOiBwdWJsaWMgTm9uY29weWFibGUgewogICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGlu Z3MoUGFnZSopOwpAQCAtMjcwLDkgKzI1Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAg ICAgdm9pZCBzZXRBbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyhib29sKTsKICAgICAgICAgYm9v bCBhbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cygpIGNvbnN0IHsgcmV0dXJuIG1fYWxsb3dTY3Jp cHRzVG9DbG9zZVdpbmRvd3M7IH0KIAotICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvcihF ZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IpIHsgbV9lZGl0aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsg fQotICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2aW9yKCkgY29uc3QgeyByZXR1 cm4gc3RhdGljX2Nhc3Q8RWRpdGluZ0JlaGF2aW9yPihtX2VkaXRpbmdCZWhhdmlvcik7IH0KLSAg ICAgICAgCisgICAgICAgIHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZp b3JUeXBlIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yVHlwZSA9IGJlaGF2aW9yOyB9Cisg ICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgZWRpdGluZ0JlaGF2aW9yVHlwZSgpIGNvbnN0IHsg cmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvclR5cGU+KG1fZWRpdGluZ0JlaGF2aW9y VHlwZSk7IH0KKwogICAgICAgICB2b2lkIHNldERvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxl ZChib29sKTsKICAgICAgICAgYm9vbCBkb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoKSBj b25zdCB7IHJldHVybiBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZDsgfQogCkBAIC0z ODAsNyArMzY2LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZW5mb3Jj ZUNTU01JTUVUeXBlSW5TdHJpY3RNb2RlIDogMTsKICAgICAgICAgYm9vbCBtX3VzZXNFbmNvZGlu Z0RldGVjdG9yIDogMTsKICAgICAgICAgYm9vbCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dz IDogMTsKLSAgICAgICAgdW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3IgOiAxOworICAgICAgICB1 bnNpZ25lZCBtX2VkaXRpbmdCZWhhdmlvclR5cGUgOiAxOwogICAgICAgICBib29sIG1fZG93bmxv YWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX3hzc0F1ZGl0b3JF bmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX2FjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVk IDogMTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcAppbmRleCA2ZmJlYTE0Li4wOWVlOWM0IDEw MDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCkBAIC0zNzE4LDE2ICszNzE4LDE1IEBAIFZpc2li bGVQb3NpdGlvbiBSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJl bihjb25zdCBJbnRQb2ludCYKICAgICAgICAgfQogICAgIH0KIAotICAgIFNldHRpbmdzKiBzZXR0 aW5ncyA9IGRvY3VtZW50KCktPnNldHRpbmdzKCk7Ci0gICAgYm9vbCB1c2VXaW5kb3dzQmVoYXZp b3IgPSBzZXR0aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ1dp bmRvd3NCZWhhdmlvcjsKKyAgICBib29sIG1vdmVDYXJldFRvQm91bmRhcnkgPSBkb2N1bWVudCgp LT5mcmFtZSgpLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250 YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKTsKIAotICAgIGlmICh1c2VXaW5kb3dzQmVo YXZpb3IgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKKyAgICBp ZiAoIW1vdmVDYXJldFRvQm91bmRhcnkgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRo Q2hpbGRyZW4pIHsKICAgICAgICAgLy8geSBjb29yZGluYXRlIGlzIGJlbG93IGxhc3Qgcm9vdCBs aW5lIGJveCwgcHJldGVuZCB3ZSBoaXQgaXQKICAgICAgICAgY2xvc2VzdEJveCA9IGxhc3RSb290 Qm94V2l0aENoaWxkcmVuLT5jbG9zZXN0TGVhZkNoaWxkRm9yWFBvcyhwb2ludEluQ29udGVudHMu eCgpKTsKICAgICB9CiAKICAgICBpZiAoY2xvc2VzdEJveCkgewotICAgICAgICBpZiAoIXVzZVdp bmRvd3NCZWhhdmlvciAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0aENo aWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CisgICAg ICAgIGlmIChtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmIHBvaW50SW5Db250ZW50cy55KCkgPCBmaXJz dFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxpbmVUb3AoKSAtIHZlcnRpY2FsTGluZUNsaWNrRnVkZ2VG YWN0b3IpIHsKICAgICAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBhYm92ZSBmaXJzdCByb290 IGxpbmUgYm94LCBzbyByZXR1cm4gdGhlIHN0YXJ0IG9mIHRoZSBmaXJzdAogICAgICAgICAgICAg cmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChmaXJzdFJvb3RCb3hXaXRoQ2hp bGRyZW4tPmZpcnN0TGVhZkNoaWxkKCksIHRydWUpLCBET1dOU1RSRUFNKTsKICAgICAgICAgfQpA QCAtMzczOCw3ICszNzM3LDcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlv bkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogCiAgICAgaWYgKGxh c3RSb290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9y IE1hYyBiZWhhdmlvciB3aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94 LgotICAgICAgICBBU1NFUlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIEFTU0VSVCht b3ZlQ2FyZXRUb0JvdW5kYXJ5KTsKICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3Np dGlvbkZvckJveChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGFzdExlYWZDaGlsZCgpLCBmYWxz ZSksIERPV05TVFJFQU0pOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggZjJhMmMzNS4uNTNhOTA5 MSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29t ZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBi ZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51 bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20g U2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRl cyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogc3JjL1dlYlNl dHRpbmdzSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlNldHRpbmdzSW1wbDo6c2V0RWRp dGluZ0JlaGF2aW9yKToKKwogMjAxMC0wNS0zMCAgTHlvbiBDaGVuICA8bGlhY2hlbkByaW0uY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbnQgVGFtdXJhLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4IDI4NDA5MjkuLjRmNGQ5MTIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKQEAgLTI3MSw3ICsyNzEsNyBAQCB2b2lkIFdlYlNl dHRpbmdzSW1wbDo6c2V0U2hvd0RlYnVnQm9yZGVycyhib29sIHNob3cpCiAKIHZvaWQgV2ViU2V0 dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQog ewotICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihzdGF0aWNfY2FzdDxXZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CisgICAgbV9zZXR0aW5ncy0+c2V0RWRpdGlu Z0JlaGF2aW9yVHlwZShzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2 aW9yKSk7CiB9CiAKIHZvaWQgV2ViU2V0dGluZ3NJbXBsOjpzZXRBY2NlbGVyYXRlZENvbXBvc2l0 aW5nRW5hYmxlZChib29sIGVuYWJsZWQpCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxv ZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDk4NjVjMjYuLjhlMGMzNWYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMjAgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0 Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBS ZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBT ZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0 aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAg ICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVk IGFjY29yZGluZ2x5LgorCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwOgorICAg ICAgICAoV2ViS2l0Ojpjb3JlKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgor ICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHdlYmtpdF93ZWJf dmlld191cGRhdGVfc2V0dGluZ3MpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3NldHRpbmdz X25vdGlmeSk6CisKIDIwMTAtMDUtMjcgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9t ZS5vcmc+CiAKICAgICAgICAgVXBkYXRlIGRvY3VtZW50YXRpb24gY29udHJvbCBmaWxlcywgYW5k IGZpeCBTaW5jZSB0YWdzIGZvciAxLjMuMS4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAK aW5kZXggZDI3NDcwOC4uNzA5ZGM1ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAK QEAgLTEyOSw5ICsxMjksOSBAQCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKICAgICByZXR1cm4gUmVzb3VyY2VSZXNwb25zZSgp OwogfQogCi1XZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZp b3IgdHlwZSkKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5n QmVoYXZpb3IgdHlwZSkKIHsKLSAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcil0 eXBlOworICAgIHJldHVybiAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSl0eXBlOwogfQog CiBXZWJLaXRIaXRUZXN0UmVzdWx0KiBraXQoY29uc3QgV2ViQ29yZTo6SGl0VGVzdFJlc3VsdCYg cmVzdWx0KQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDA1N2IwZTUuLjZhZWNjMTMg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTk1LDcgKzk1LDcgQEAgbmFtZXNwYWNl IFdlYktpdCB7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CiAKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3Ig Y29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CisgICAgV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKIAogICAgIFdlYktp dFNlY3VyaXR5T3JpZ2luKiBraXQoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qKTsKICAgICBXZWJD b3JlOjpTZWN1cml0eU9yaWdpbiogY29yZShXZWJLaXRTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0t Z2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCAyYzk1NTU4Li44NDE5Mzc1IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtMjY5NSw3ICsyNjk1LDcgQEAgc3RhdGljIHZvaWQg d2Via2l0X3dlYl92aWV3X3VwZGF0ZV9zZXR0aW5ncyhXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQog ICAgIHNldHRpbmdzLT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5KGph dmFzY3JpcHRDYW5PcGVuV2luZG93cyk7CiAgICAgc2V0dGluZ3MtPnNldEphdmFTY3JpcHRDYW5B Y2Nlc3NDbGlwYm9hcmQoamF2YVNjcmlwdENhbkFjY2Vzc0NsaXBib2FyZCk7CiAgICAgc2V0dGlu Z3MtPnNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChlbmFibGVPZmZsaW5lV2Vi QXBwQ2FjaGUpOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShlZGl0aW5n QmVoYXZpb3IpKTsKKyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKGVk aXRpbmdCZWhhdmlvcikpOwogICAgIHNldHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zy b21GaWxlVVJMcyhlbmFibGVVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSSSk7CiAgICAgc2V0dGlu Z3MtPnNldEFsbG93RmlsZUFjY2Vzc0Zyb21GaWxlVVJMcyhlbmFibGVGaWxlQWNjZXNzRnJvbUZp bGVVUkkpOwogICAgIHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoZW5hYmxlRE9NUGFzdGUp OwpAQCAtMjc5Niw3ICsyNzk2LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldHRp bmdzX25vdGlmeShXZWJLaXRXZWJTZXR0aW5ncyogd2ViU2V0dGluZ3MsIEdQYXIKICAgICBlbHNl IGlmIChuYW1lID09IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLW9mZmxpbmUtd2ViLWFwcGxpY2F0 aW9uLWNhY2hlIikpCiAgICAgICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25D YWNoZUVuYWJsZWQoZ192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChu YW1lID09IGdfaW50ZXJuX3N0cmluZygiZWRpdGluZy1iZWhhdmlvciIpKQotICAgICAgICBzZXR0 aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0Jl aGF2aW9yPihnX3ZhbHVlX2dldF9lbnVtKCZ2YWx1ZSkpKSk7CisgICAgICAgIHNldHRpbmdzLT5z ZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0JlaGF2 aW9yPihnX3ZhbHVlX2dldF9lbnVtKCZ2YWx1ZSkpKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBn X2ludGVybl9zdHJpbmcoImVuYWJsZS11bml2ZXJzYWwtYWNjZXNzLWZyb20tZmlsZS11cmlzIikp CiAgICAgICAgIHNldHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhn X3ZhbHVlX2dldF9ib29sZWFuKCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRl cm5fc3RyaW5nKCJlbmFibGUtZmlsZS1hY2Nlc3MtZnJvbS1maWxlLXVyaXMiKSkKZGlmZiAtLWdp dCBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggN2Q4 OGZlZC4uMzcwZjZkOCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cKKysrIGIvV2Vi S2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBH b21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5n IGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBl bnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJv bSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNp dGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJWaWV3 L1dlYkZyYW1lLm1tOgorICAgICAgICAoY29yZSk6CisgICAgICAgICogV2ViVmlldy9XZWJGcmFt ZUludGVybmFsLmg6CisgICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOgorICAgICAgICAoLVtX ZWJWaWV3IF9wcmVmZXJlbmNlc0NoYW5nZWROb3RpZmljYXRpb246XSk6CisKIDIwMTAtMDUtMzAg IERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNh bSBXZWluaWcuCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gYi9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5ZjE3Ny4uN2M1OTYxNSAxMDA2 NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCisrKyBiL1dlYktpdC9tYWMv V2ViVmlldy9XZWJGcmFtZS5tbQpAQCAtMTk2LDcgKzE5Niw3IEBAIEVkaXRhYmxlTGlua0JlaGF2 aW9yIGNvcmUoV2ViS2l0RWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZpb3Ip CiAgICAgcmV0dXJuIEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKIH0KIAotV2ViQ29yZTo6 RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQorV2Vi Q29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhh dmlvcikKIHsKICAgICBzd2l0Y2ggKGJlaGF2aW9yKSB7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRp dGluZ01hY0JlaGF2aW9yOgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l SW50ZXJuYWwuaCBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKaW5kZXgg OWIyMjQ4YS4uNTg2YjRjMyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l SW50ZXJuYWwuaAorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCkBA IC03MSw3ICs3MSw3IEBAIFdlYlZpZXcgKmtpdChXZWJDb3JlOjpQYWdlKik7CiAKIFdlYkNvcmU6 OkVkaXRhYmxlTGlua0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGFibGVMaW5rQmVoYXZpb3IpOwog V2ViQ29yZTo6VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciBjb3JlKFdlYlRl eHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3IpOwotV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yKTsKK1dlYkNvcmU6OkVkaXRpbmdCZWhh dmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IpOwogCiBXZWJWaWV3ICpnZXRXZWJW aWV3KFdlYkZyYW1lICp3ZWJGcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmll dy9XZWJWaWV3Lm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KaW5kZXggOTdjNzk5 Yi4uOWYzYWQ2MCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KKysr IGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KQEAgLTEzNjksNyArMTM2OSw3IEBAIHN0 YXRpYyBib29sIGZhc3REb2N1bWVudFRlYXJkb3duRW5hYmxlZCgpCiAgICAgc2V0dGluZ3MtPnNl dFRleHRBcmVhc0FyZVJlc2l6YWJsZShbcHJlZmVyZW5jZXMgdGV4dEFyZWFzQXJlUmVzaXphYmxl XSk7CiAgICAgc2V0dGluZ3MtPnNldFNocmlua3NTdGFuZGFsb25lSW1hZ2VzVG9GaXQoW3ByZWZl cmVuY2VzIHNocmlua3NTdGFuZGFsb25lSW1hZ2VzVG9GaXRdKTsKICAgICBzZXR0aW5ncy0+c2V0 RWRpdGFibGVMaW5rQmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMgZWRpdGFibGVMaW5rQmVoYXZp b3JdKSk7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNl cyBlZGl0aW5nQmVoYXZpb3JdKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5 cGUoY29yZShbcHJlZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5z ZXRUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2Vz IHRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3JdKSk7CiAgICAgc2V0dGluZ3Mt PnNldERPTVBhc3RlQWxsb3dlZChbcHJlZmVyZW5jZXMgaXNET01QYXN0ZUFsbG93ZWRdKTsKICAg ICBzZXR0aW5ncy0+c2V0VXNlc1BhZ2VDYWNoZShbc2VsZiB1c2VzUGFnZUNhY2hlXSk7CmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCA2 OWMxZTJmLi4zN2M0YWNlIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dl YktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBH b21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5n IGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBl bnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJv bSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNp dGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHA6CisgICAgICAgIChEdW1wUmVuZGVy VHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0wNS0zMCAgTHlvbiBD aGVuICA8bGlhY2hlbkByaW0uY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbnQgVGFtdXJh LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3Vw cG9ydFF0LmNwcCBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBv cnRRdC5jcHAKaW5kZXggMGIyZTlhNS4uYTk1MWE0OSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L1dl YkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcAorKysgYi9XZWJLaXQvcXQv V2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwCkBAIC00NzYsNyArNDc2 LDcgQEAgYm9vbCBEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6ZWxlbWVudERvZXNBdXRvQ29tcGxl dGVGb3JFbGVtZW50V2l0aElkKFFXZWJGcmFtZSoKIAogdm9pZCBEdW1wUmVuZGVyVHJlZVN1cHBv cnRRdDo6c2V0RWRpdGluZ0JlaGF2aW9yKFFXZWJQYWdlKiBwYWdlLCBjb25zdCBRU3RyaW5nJiBl ZGl0aW5nQmVoYXZpb3IpCiB7Ci0gICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmVFZGl0 aW5nQmVoYXZpb3I7CisgICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlRWRpdGlu Z0JlaGF2aW9yOwogCiAgICAgaWYgKGVkaXRpbmdCZWhhdmlvciA9PSAid2luIikKICAgICAgICAg Y29yZUVkaXRpbmdCZWhhdmlvciA9IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CkBAIC00ODcsNyAr NDg3LDcgQEAgdm9pZCBEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0JlaGF2aW9y KFFXZWJQYWdlKiBwYWdlLCBjb25zdCBRU3RyaW5nJgogICAgIGlmICghY29yZVBhZ2UpCiAgICAg ICAgIHJldHVybjsKIAotICAgIGNvcmVQYWdlLT5zZXR0aW5ncygpLT5zZXRFZGl0aW5nQmVoYXZp b3IoY29yZUVkaXRpbmdCZWhhdmlvcik7CisgICAgY29yZVBhZ2UtPnNldHRpbmdzKCktPnNldEVk aXRpbmdCZWhhdmlvclR5cGUoY29yZUVkaXRpbmdCZWhhdmlvcik7CiB9CiAKIHZvaWQgRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQ6OmR1bXBGcmFtZUxvYWRlcihib29sIGIpCmRpZmYgLS1naXQgYS9X ZWJLaXQvd2luL0NoYW5nZUxvZyBiL1dlYktpdC93aW4vQ2hhbmdlTG9nCmluZGV4IDk0NGJiNzYu LjcxZWIyZmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC93 aW4vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMg IDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhh dmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3 YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0 dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBp biBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogV2ViVmlldy5jcHA6 CisgICAgICAgIChXZWJWaWV3Ojpub3RpZnlQcmVmZXJlbmNlc0NoYW5nZWQpOgorCiAyMDEwLTA1 LTIyICBKZXIgTm9ibGUgIDxqZXIubm9ibGVAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEFkYW0gUm9iZW4uCmRpZmYgLS1naXQgYS9XZWJLaXQvd2luL1dlYlZpZXcuY3BwIGIvV2Vi S2l0L3dpbi9XZWJWaWV3LmNwcAppbmRleCA1MjUxMDhmLi5iYTViZjQ0IDEwMDY0NAotLS0gYS9X ZWJLaXQvd2luL1dlYlZpZXcuY3BwCisrKyBiL1dlYktpdC93aW4vV2ViVmlldy5jcHAKQEAgLTQ2 NTQsNyArNDY1NCw3IEBAIEhSRVNVTFQgV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2Vk KElXZWJOb3RpZmljYXRpb24qIG5vdGlmaWNhdGlvbikKICAgICBociA9IHByZWZlcmVuY2VzLT5l ZGl0aW5nQmVoYXZpb3IoJmVkaXRpbmdCZWhhdmlvcik7CiAgICAgaWYgKEZBSUxFRChocikpCiAg ICAgICAgIHJldHVybiBocjsKLSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKChFZGl0 aW5nQmVoYXZpb3IpZWRpdGluZ0JlaGF2aW9yKTsKKyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0Jl aGF2aW9yVHlwZSgoRWRpdGluZ0JlaGF2aW9yVHlwZSllZGl0aW5nQmVoYXZpb3IpOwogCiAgICAg aHIgPSBwcmVmZXJlbmNlcy0+dXNlc1BhZ2VDYWNoZSgmZW5hYmxlZCk7CiAgICAgaWYgKEZBSUxF RChocikpCi0tIAoxLjcuMC40Cgo= 57502 2010-05-31 17:49:00 -0700 2010-06-01 07:04:22 -0700 patch v2 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 36892 tonikitoo RnJvbSAwN2M5MTkzNWU4YThmNDE3NmMwY2Y1ZTA4ODEzMDVlMDcyYzE0OTJlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAzMSBNYXkgMjAxMCAxNTo1NDo1NSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpQYXRjaCBieSBBbnRvbmlvIEdvbWVzIDx0b25pa2l0 b29Ad2Via2l0Lm9yZz4KCldlYkNvcmU6CgpBcyBwZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2Mjcs IHRoZSBmb2xsb3dpbmcgd2FzIHN1Z2dlc3RlZCBieSBEYXJpbiBBZGxlcjogImJlZm9yZSB0aGUg YWRkaXRpb24gb2YgYW55Cm5ldyBFZGl0aW5nQmVoYXZpb3IsIEkgdGhpbmsgd2UgbmVlZCB0byBh ZGQgZnVuY3Rpb25zIHRvIHRyYW5zbGF0ZSB0aGUgb3ZlcmFsbCBiZWhhdmlvciBwb2xpY3kgaW50 byBzcGVjaWZpYwpiZWhhdmlvcnMgcmF0aGVyIHRoYW4gZGlyZWN0bHkgc2F5aW5nICdiZWhhdmlv ciA9PSBNYWMnIG9yICdiZWhhdmlvciA9PSBXaW5kb3dzJy4gSGVscGVyIGZ1bmN0aW9ucyB0aGF0 CmV4cHJlc3Npb24gdGhlIGRpZmZlcmVudCBydWxlcyBpbiBwbGFpbiBsYW5ndWFnZS4iLgoKUGF0 Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KCk5vIGJlaGF2aW9yIGNoYW5nZSwgc28gbm8gbmV3 IHRlc3RzLgoKKiBHTlVtYWtlZmlsZS5hbToKKiBXZWJDb3JlLnBybzoKKiBwYWdlL1NldHRpbmdz LmNwcDoKKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CiogcGFnZS9TZXR0aW5ncy5oOiBN b3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmgsCmFuZCByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzLgooV2Vi Q29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0 RWRpdGluZ0JlaGF2aW9yLgooV2ViQ29yZTo6U2V0dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUp OiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9yLgoqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9y Lmg6IEFkZGVkLgooV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBD bGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2ludCBmb3IKZWRpdGluZyBiZWhhdmlvciB0aGF0 IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBs YXRmb3Jtcy9wb3J0cy4KQ2xhc3Mgc2hvdWxkIGJlIG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBk aXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5IGNvbnN0cnVjdGVkCnRocm91Z2ggdGhlIEVk aXRvciBjbGFzcy4KKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9I b3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKToKKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CihXZWJD b3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVj dGlvbmFsKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVBy ZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKToKKFdlYkNvcmU6 OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250 YWxOYXZpZ2F0aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVj dGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToKKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5 cGVzLmg6IEFkZGVkLgooV2ViQ29yZTo6KToKKiBlZGl0aW5nL0VkaXRvci5jcHA6CihXZWJDb3Jl OjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCiog ZWRpdGluZy9FZGl0b3IuaDoKKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwOgooV2ViQ29yZTo6 ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgoo V2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKFdlYkNvcmU6OlNl bGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgooV2ViQ29yZTo6U2VsZWN0aW9u Q29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjptb2RpZnkpOgoqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKFdlYkNvcmU6OkV2ZW50 SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xpY2spOgoqIHJlbmRlcmluZy9S ZW5kZXJCbG9jay5jcHA6CihXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdp dGhJbmxpbmVDaGlsZHJlbik6CgotIENhbGwgc2l0ZXMgd2lsbCBsb29rIGxpa2U6CmlmIChmcmFt ZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkVGhpc0lmVGhhdCgpKSkKICAgLy8gZG8gc29t ZXRoaW5nCgpXZWJLaXQ6CgpFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0 aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bwpFZGl0aW5n QmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGlu Z2x5LgoKV2ViS2l0L2Nocm9taXVtOgoqIHNyYy9XZWJTZXR0aW5nc0ltcGwuY3BwOgooV2ViS2l0 OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdCZWhhdmlvcik6CgpXZWJLaXQvZ3RrOgoqIHdl YmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKFdlYktpdDo6Y29yZSk6Ciogd2Via2l0L3dlYmtpdHBy aXZhdGUuaDoKKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6Cih3ZWJraXRfd2ViX3ZpZXdfdXBk YXRlX3NldHRpbmdzKToKKHdlYmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkpOgoKV2ViS2l0 L21hYzoKKiBXZWJWaWV3L1dlYkZyYW1lLm1tOgooY29yZSk6CiogV2ViVmlldy9XZWJGcmFtZUlu dGVybmFsLmg6CiogV2ViVmlldy9XZWJWaWV3Lm1tOgooLVtXZWJWaWV3IF9wcmVmZXJlbmNlc0No YW5nZWROb3RpZmljYXRpb246XSk6CgpXZWJLaXQvcXQ6CiogV2ViQ29yZVN1cHBvcnQvRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQuY3BwOgooRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRp bmdCZWhhdmlvcik6CgpXZWJLaXQvd2luOgoqIFdlYlZpZXcuY3BwOgooV2ViVmlldzo6bm90aWZ5 UHJlZmVyZW5jZXNDaGFuZ2VkKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNTUgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv R05VbWFrZWZpbGUuYW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJD b3JlL1dlYkNvcmUuZ3lwaSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwog V2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAx ICsKIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogICAgICAgICAgICAgIHwg ICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAg ICAgIHwgICA1MiArKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oICAgICAgICAgICAgIHwgICA0NiArKysrKysrKysrKysrKysrCiBXZWJDb3Jl L2VkaXRpbmcvRWRpdG9yLmNwcCAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTAgKysrKwog V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAz ICsKIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCAgICAgICAgICAgICAgICAgIHwg ICAgMyArLQogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAg ICAgfCAgIDEwICsrLS0KIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwICAgICAgICAgICAg ICAgICAgICAgIHwgICAgMiArLQogV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMjQgKystLS0tLS0tCiBXZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJCbG9jay5jcHAgICAgICAgICAgICAgICAgICB8ICAgIDkgKystLQogV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiBXZWJL aXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAgICAgICAgICAgICB8ICAgIDIgKy0K IFdlYktpdC9ndGsvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAx NyArKysrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAg ICAgIHwgICAgNCArLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAg ICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCAg ICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYktpdC9tYWMvQ2hhbmdlTG9nICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysKIFdlYktpdC9tYWMvV2ViVmlldy9XZWJG cmFtZS5tbSAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3 L1dlYkZyYW1lSW50ZXJuYWwuaCAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dl YlZpZXcvV2ViVmlldy5tbSAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9x dC9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysrKwog Li4uL3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCAgfCAgICA0 ICstCiBXZWJLaXQvd2luL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgMTMgKysrKysKIFdlYktpdC93aW4vV2ViVmlldy5jcHAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAgMiArLQogMjkgZmlsZXMgY2hhbmdlZCwgMjc5IGluc2VydGlvbnMoKyksIDQ2 IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5n QmVoYXZpb3IuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhMGJkZTk1Li44YmNhNDZjIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU4IEBACisyMDEwLTA1LTMx ICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5k ZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgQXMgcGVy IGRpc2N1c3Npb24gaW4gYnVnIDM2NjI3LCBEYXJpbiBBZGxlciBzdWdnZXN0ZWQ6ICJiZWZvcmUg dGhlIGFkZGl0aW9uIG9mIGFueSBuZXcgRWRpdGluZ0JlaGF2aW9yLAorICAgICAgICBJIHRoaW5r IHdlIHRvIGFkZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBv bGljeSBpbnRvIHNwZWNpZmljIGJlaGF2aW9ycyByYXRoZXIgdGhhbgorICAgICAgICBkaXJlY3Rs eSBzYXlpbmcgJ2JlaGF2aW9yID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxw ZXIgZnVuY3Rpb25zIHRoYXQgZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50CisgICAgICAgIHJ1bGVz IGluIHBsYWluIGxhbmd1YWdlLiIuIFBhdGNoIGFkZHJlc3NlcyB0aGlzIHJlcXVlc3QuCisKKyAg ICAgICAgTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBH TlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBwYWdlL1Nl dHRpbmdzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CisgICAg ICAgICogcGFnZS9TZXR0aW5ncy5oOiBNb3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8g V2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgsCisgICAgICAgIGFuZCByZW5h bWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzLgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6 OnNldEVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9y LgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5h bWVkIGZyb20gZWRpdGluZ0JlaGF2aW9yLgorICAgICAgICAqIGVkaXRpbmcvRWRpdGluZ0JlaGF2 aW9yLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5n QmVoYXZpb3IpOiBDbGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2ludCBmb3IKKyAgICAgICAg ZWRpdGluZyBiZWhhdmlvciB0aGF0IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRs eSBpbiB0aGUgZGlmZmVyZW50IHBsYXRmb3Jtcy9wb3J0cy4KKyAgICAgICAgQ2xhc3Mgc2hvdWxk IGJlIG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNp dGx5IGNvbnN0cnVjdGVkCisgICAgICAgIHRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFs Qm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CisgICAg ICAgIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rp b25Bc0RpcmVjdGlvbmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKyAg ICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJv bUVuZFBvaW50QWx3YXlzKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRl bmRpbmdUb0JvdW5kYXJ5KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVz Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRv ci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBF ZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisgICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAg ICAgKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0 ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwp OgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0 Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgor ICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50 SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJl bmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6 cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNp dGVzIHdpbGwgbG9vayBsaWtlOgorICAgICAgICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlv cigpLnNob3VsZFRoaXNJZlRoYXQoKSkpCisgICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAy MDEwLTA1LTMwICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1h a2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCA5Yjk1MzMwLi5lMDZlY2U0 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFr ZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNv cmUvZWRpdGluZy9FZGl0QWN0aW9uLmggXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5j cHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcv RWRpdGluZ0JlaGF2aW9yLmggXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0Vk aXRvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA1YjRj NTU5Li4wZTEzM2JiIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJD b3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5MSw2ICsxMjkxLDggQEAKICAgICAgICAgICAgICdlZGl0 aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAgICAgICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAn LAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oJywKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAg ICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2Vi Q29yZS5wcm8KaW5kZXggZDNlYjExNS4uNGNmYWQ5ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJD b3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0xMjc3LDYgKzEyNzcsNyBAQCBI RUFERVJTICs9IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAg ICAgZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENv bW1hbmQuaCBcCisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9F ZGl0b3IuaCBcCiAgICAgZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGlu Zy9odG1sZWRpdGluZy5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4 IGZjYmI3ZjUuLjBkOWY4OWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpA QCAtMzA0NDksNiArMzA0NDksMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQor CQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRpdGluZ1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0K KwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRp dGluZ0JlaGF2aW9yVHlwZXMuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmls ZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggYi9XZWJD b3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZDc4ZTlhMAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0 aW5nQmVoYXZpb3IuaApAQCAtMCwwICsxLDUyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29weXJp Z2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBFZGl0 aW5nQmVoYXZpb3JfaAorI2RlZmluZSBFZGl0aW5nQmVoYXZpb3JfaAorCisjaW5jbHVkZSAiRWRp dGluZ0JlaGF2aW9yVHlwZXMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBFZGl0 aW5nQmVoYXZpb3IgeworCitwdWJsaWM6CisgICAgRWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhh dmlvclR5cGUgdHlwZSkKKyAgICAgICAgOiBtX3R5cGUodHlwZSkKKyAgICB7CisgICAgfQorCisg ICAgLy8gSW5kaXZpZHVhbCBmdW5jdGlvbnMgZm9yIGVhY2ggY2FzZSB3aGVyZSB3ZSBoYXZlIG1v cmUgdGhhbiBvbmUgc3R5bGUgb2YgZWRpdGluZyBiZWhhdmlvci4KKyAgICAvLyBDcmVhdGUgYSBu ZXcgZnVuY3Rpb24gZm9yIGFueSBwbGF0Zm9ybSBkaWZmZXJlbmNlIHNvIHdlIGNhbiBjb250cm9s IGl0IGhlcmUuCisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdo ZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRv d3NCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNS ZXZlYWxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0K KyAgICBib29sIHNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKCkgY29u c3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hv dWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKCkgY29u c3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hv dWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKCkgY29uc3QgeyByZXR1cm4gbV90 eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkS2V5YmFyZFNlbGVj dGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKCkgY29uc3QgeyByZXR1cm4gbV90eXBl ID09IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkR3Jvd1NlbGVjdGlvbldo ZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdN YWNCZWhhdmlvcjsgfQorCitwcml2YXRlOgorICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgbV90eXBl OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRWRpdGluZ0JlaGF2 aW9yX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5o IGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uMjZiYTE4ZQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5 KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaWZuZGVmIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKKyNkZWZpbmUgRWRpdGluZ0JlaGF2 aW9yVHlwZXNfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIFRoZXJlIGFyZSBtdWx0aXBs ZSBlZGl0aW5nIGRldGFpbHMgdGhhdCBhcmUgZGlmZmVyZW50IG9uIFdpbmRvd3MgdGhhbiBNYWNp bnRvc2guCisvLyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBl eGFtcGxlczoKKy8vCisvLyAgICAxKSBDbGlja2luZyBiZWxvdyB0aGUgbGFzdCBsaW5lIG9mIGFu IGVkaXRhYmxlIGFyZWEgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZAorLy8gICAgICAgb2YgdGhl IGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24g V2luZG93cy4KKy8vICAgIDIpIFB1c2hpbmcgdGhlIGRvd24gYXJyb3cga2V5IG9uIHRoZSBsYXN0 IGxpbmUgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZCBvZiB0aGUKKy8vICAgICAgIGxhc3QgbGlu ZSBvbiBNYWMsIGJ1dCBkb2VzIG5vdGhpbmcgb24gV2luZG93cy4gQSBzaW1pbGFyIGNhc2UgZXhp c3RzIG9uIHRoZQorLy8gICAgICAgdG9wIGxpbmUuCisvLworLy8gVGhpcyBzZXR0aW5nIGlzIGlu dGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2YgYmVoYXZpb3JzLiBUaGVyZSBhcmUgc29t ZSBvdGhlcgorLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBF ZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3RlIGFuZAorLy8gc2VsZWN0aW5nIHRoZSBz cGFjZSBhZnRlciBhIGRvdWJsZSBjbGljaykgdGhhdCBjb3VsZCBiZSBjb21iaW5lZCB3aXRoIHRo aXMgaWYKKy8vIGlmIHBvc3NpYmxlIGluIHRoZSBmdXR1cmUuCitlbnVtIEVkaXRpbmdCZWhhdmlv clR5cGUgeworICAgIEVkaXRpbmdNYWNCZWhhdmlvciwKKyAgICBFZGl0aW5nV2luZG93c0JlaGF2 aW9yCit9OworCit9IC8vIFdlYkNvcmUgbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFZGl0aW5nQmVo YXZpb3JUeXBlc19oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBiL1dl YkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IDYwM2YzNWMuLjdhMjY5ODUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuY3BwCkBAIC02Myw2ICs2Myw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKICNpbmNs dWRlICJSZW5kZXJQYXJ0LmgiCiAjaW5jbHVkZSAiUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQuaCIK KyNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlNvdW5kLmgiCiAjaW5jbHVkZSAiVGV4 dC5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgpAQCAtOTcsNiArOTgsMTUgQEAgVmlzaWJs ZVNlbGVjdGlvbiBFZGl0b3I6OnNlbGVjdGlvbkZvckNvbW1hbmQoRXZlbnQqIGV2ZW50KQogICAg IHJldHVybiBzZWxlY3Rpb247CiB9CiAKKy8vIEZ1bmN0aW9uIGNvbnNpZGVycyBNYWMgZWRpdGlu ZyBiZWhhdmlvciBhIGZhbGxiYWNrIHdoZW4gUGFnZSBvciBTZXR0aW5ncyBpcyBub3QgYXZhaWxh YmxlLgorRWRpdGluZ0JlaGF2aW9yIEVkaXRvcjo6YmVoYXZpb3IoKSBjb25zdAoreworICAgIGlm ICghbV9mcmFtZSB8fCAhbV9mcmFtZS0+cGFnZSgpIHx8ICFtX2ZyYW1lLT5zZXR0aW5ncygpKQor ICAgICAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdNYWNCZWhhdmlvcik7CisKKyAg ICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhh dmlvclR5cGUoKSk7Cit9CisKIEVkaXRvckNsaWVudCogRWRpdG9yOjpjbGllbnQoKSBjb25zdAog ewogICAgIGlmIChQYWdlKiBwYWdlID0gbV9mcmFtZS0+cGFnZSgpKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCmluZGV4IDE3 ZGQzYmIuLjNlMjIzZGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAorKysg Yi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlICJD bGlwYm9hcmRBY2Nlc3NQb2xpY3kuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUgIkVk aXRBY3Rpb24uaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3IuaCIKICNpbmNsdWRlICJFZGl0 b3JEZWxldGVBY3Rpb24uaCIKICNpbmNsdWRlICJFZGl0b3JJbnNlcnRBY3Rpb24uaCIKICNpbmNs dWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCkBAIC0yODEsNiArMjgyLDggQEAgcHVibGljOgog CiAgICAgS2lsbFJpbmcqIGtpbGxSaW5nKCkgY29uc3QgeyByZXR1cm4gbV9raWxsUmluZy5nZXQo KTsgfQogCisgICAgRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKCkgY29uc3Q7CisKICAgICBQYXNz UmVmUHRyPFJhbmdlPiBzZWxlY3RlZFJhbmdlKCk7CiAgICAgCiAgICAgLy8gV2Ugc2hvdWxkIG1h a2UgdGhlc2UgZnVuY3Rpb25zIHByaXZhdGUgd2hlbiB0aGVpciBjYWxsZXJzIGluIEZyYW1lIGFy ZSBtb3ZlZCBvdmVyIGhlcmUgdG8gRWRpdG9yCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcv RWRpdG9yQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKaW5k ZXggN2U4NWFhOS4uZTJhNjQ4OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNv bW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcApAQCAtMTY0 LDkgKzE2NCw4IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVUb2dnbGVTdHlsZShGcmFtZSogZnJhbWUs IEVkaXRvckNvbW1hbmRTb3VyY2Ugc291cmNlLCBFZGl0QWN0CiAgICAgLy8gU3R5bGUgaXMgY29u c2lkZXJlZCBwcmVzZW50IHdoZW4KICAgICAvLyBtYWM6IHByZXNlbnQgYXQgdGhlIGJlZ2lubmlu ZyBvZiBzZWxlY3Rpb24KICAgICAvLyBvdGhlcjogcHJlc2VudCB0aHJvdWdob3V0IHRoZSBzZWxl Y3Rpb24KLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBmcmFtZS0+ZG9jdW1lbnQoKS0+c2V0dGlu Z3MoKTsKICAgICBib29sIHN0eWxlSXNQcmVzZW50OwotICAgIGlmIChzZXR0aW5ncyAmJiBzZXR0 aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgIGlmICgh ZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZENvbnNpZGVyU3R5bGVQcmVzZW50T25s eUlmVGhyb3VnaG91dFRoZVNlbGVjdGlvbigpKQogICAgICAgICBzdHlsZUlzUHJlc2VudCA9IGZy YW1lLT5lZGl0b3IoKS0+c2VsZWN0aW9uU3RhcnRIYXNTdHlsZShzdHlsZS5nZXQoKSk7CiAgICAg ZWxzZQogICAgICAgICBzdHlsZUlzUHJlc2VudCA9IGZyYW1lLT5lZGl0b3IoKS0+c2VsZWN0aW9u SGFzU3R5bGUoc3R5bGUuZ2V0KCkpID09IFRydWVUcmlTdGF0ZTsKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9TZWxl Y3Rpb25Db250cm9sbGVyLmNwcAppbmRleCA4MTZmOTY4Li4xMDdkODU5IDEwMDY0NAotLS0gYS9X ZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0xNjQsNyArMTY0LDcgQEAgdm9pZCBTZWxl Y3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgcywg Ym9vbCBjbG9zZVR5cGkKICAgICBpZiAodXNlclRyaWdnZXJlZCkgewogICAgICAgICBTY3JvbGxB bGlnbm1lbnQgYWxpZ25tZW50OwogCi0gICAgICAgIGlmIChtX2ZyYW1lLT5zZXR0aW5ncygpICYm IG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhh dmlvcikKKyAgICAgICAgaWYgKG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZENl bnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQoKSkKICAgICAgICAgICAgIGFsaWdubWVu dCA9IChhbGlnbiA9PSBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFsaWdubWVu dDo6YWxpZ25DZW50ZXJBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2VudGVySWZOZWVk ZWQ7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGlnbiA9PSBBbGln bkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub3BBbHdheXMg OiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQ7CkBAIC0yNDMsOCArMjQzLDcg QEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpub2RlV2lsbEJlUmVtb3ZlZChOb2RlICpub2Rl KQogICAgIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRJc0RpcmVjdGlvbmFsKGJvb2wg aXNEaXJlY3Rpb25hbCkKIHsKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBtX2ZyYW1lID8gbV9m cmFtZS0+c2V0dGluZ3MoKSA6IDA7Ci0gICAgbV9pc0RpcmVjdGlvbmFsID0gIXNldHRpbmdzIHx8 IHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nTWFjQmVoYXZpb3IgfHwgaXNE aXJlY3Rpb25hbDsKKyAgICBtX2lzRGlyZWN0aW9uYWwgPSAhbV9mcmFtZSB8fCBtX2ZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDb25zaWRlck1vdXNlU2VsZWN0aW9uQXNEaXJlY3Rp b25hbCgpIHx8IGlzRGlyZWN0aW9uYWw7CiB9CiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6 d2lsbEJlTW9kaWZpZWQoRUFsdGVyYXRpb24gYWx0ZXIsIEVEaXJlY3Rpb24gZGlyZWN0aW9uKQpA QCAtMjk4LDggKzI5Nyw3IEBAIFRleHREaXJlY3Rpb24gU2VsZWN0aW9uQ29udHJvbGxlcjo6ZGly ZWN0aW9uT2ZFbmNsb3NpbmdCbG9jaygpCiBWaXNpYmxlUG9zaXRpb24gU2VsZWN0aW9uQ29udHJv bGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybShib29sIGlzR2V0U3RhcnQpIGNvbnN0CiB7CiAgICAg UG9zaXRpb24gcG9zOwotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IG1fZnJhbWUgPyBtX2ZyYW1l LT5zZXR0aW5ncygpIDogMDsKLSAgICBpZiAoc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdC ZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhhdmlvcikKKyAgICBpZiAobV9mcmFtZSAmJiBtX2Zy YW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRLZXliYXJkU2VsZWN0aW9uRXh0ZW5kRm9y SG9yaXpvbnRhbE5hdmlnYXRpb24oKSkKICAgICAgICAgcG9zID0gaXNHZXRTdGFydCA/IG1fc2Vs ZWN0aW9uLnN0YXJ0KCkgOiBtX3NlbGVjdGlvbi5lbmQoKTsKICAgICBlbHNlIHsKICAgICAgICAg Ly8gTGludXggYW5kIFdpbmRvd3MgYWx3YXlzIGV4dGVuZCBzZWxlY3Rpb25zIGZyb20gdGhlIGV4 dGVudCBlbmRwb2ludC4KQEAgLTY4NSw3ICs2ODMsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xs ZXI6Om1vZGlmeShFQWx0ZXJhdGlvbiBhbHRlciwgRURpcmVjdGlvbiBkaXJlY3Rpb24sIFRleHRH cgogICAgICAgICBtb3ZlVG8ocG9zaXRpb24sIHVzZXJUcmlnZ2VyZWQpOwogICAgICAgICBicmVh azsKICAgICBjYXNlIEVYVEVORDoKLSAgICAgICAgaWYgKCFzZXR0aW5ncyB8fCBzZXR0aW5ncy0+ ZWRpdGluZ0JlaGF2aW9yKCkgIT0gRWRpdGluZ01hY0JlaGF2aW9yIHx8IG1fc2VsZWN0aW9uLmlz Q2FyZXQoKSB8fCAhaXNCb3VuZGFyeShncmFudWxhcml0eSkpCisgICAgICAgIGlmICghbV9mcmFt ZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRlbmRpbmdU b0JvdW5kYXJ5KCkgfHwgbV9zZWxlY3Rpb24uaXNDYXJldCgpIHx8ICFpc0JvdW5kYXJ5KGdyYW51 bGFyaXR5KSkKICAgICAgICAgICAgIHNldEV4dGVudChwb3NpdGlvbiwgdXNlclRyaWdnZXJlZCk7 CiAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgLy8gU3RhbmRhcmQgTWFjIGJlaGF2aW9yIHdo ZW4gZXh0ZW5kaW5nIHRvIGEgYm91bmRhcnkgaXMgZ3JvdyB0aGUgc2VsZWN0aW9uIHJhdGhlcgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9XZWJDb3JlL3BhZ2Uv RXZlbnRIYW5kbGVyLmNwcAppbmRleCA1ZGQ2MGFhLi44MzliYjQ2IDEwMDY0NAotLS0gYS9XZWJD b3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVy LmNwcApAQCAtMzcwLDcgKzM3MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVBy ZXNzRXZlbnRTaW5nbGVDbGljayhjb25zdCBNb3VzZUV2ZW50V2l0aEhpdFRlc3RSCiAgICAgICAg IG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZXRJc0RpcmVjdGlvbmFsKGZhbHNlKTsKICAgICAgICAg CiAgICAgICAgIEFTU0VSVChtX2ZyYW1lLT5zZXR0aW5ncygpKTsKLSAgICAgICAgaWYgKG1fZnJh bWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhhdmlvcikg eworICAgICAgICBpZiAoIW1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZEV4dGVu ZFNlbGVjdGlvbkZyb21FbmRQb2ludEFsd2F5cygpKSB7CiAgICAgICAgICAgICAvLyBTZWUgPHJk YXI6Ly9wcm9ibGVtLzM2NjgxNTc+IFJFR1JFU1NJT04gKE1haWwpOiBzaGlmdC1jbGljayBkZXNl bGVjdHMgd2hlbiBzZWxlY3Rpb24KICAgICAgICAgICAgIC8vIHdhcyBjcmVhdGVkIHJpZ2h0LXRv LWxlZnQKICAgICAgICAgICAgIFBvc2l0aW9uIHN0YXJ0ID0gbmV3U2VsZWN0aW9uLnN0YXJ0KCk7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwIGIvV2ViQ29yZS9wYWdlL1Nl dHRpbmdzLmNwcAppbmRleCA2ZjZiYjA0Li5kZDQwYzQzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bh Z2UvU2V0dGluZ3MuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKQEAgLTExMyw3 ICsxMTMsNyBAQCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSogcGFnZSkKICAgICAsIG1fZW5mb3Jj ZUNTU01JTUVUeXBlSW5TdHJpY3RNb2RlKHRydWUpCiAgICAgLCBtX3VzZXNFbmNvZGluZ0RldGVj dG9yKGZhbHNlKQogICAgICwgbV9hbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyhmYWxzZSkKLSAg ICAsIG1fZWRpdGluZ0JlaGF2aW9yKAorICAgICwgbV9lZGl0aW5nQmVoYXZpb3JUeXBlKAogI2lm IFBMQVRGT1JNKE1BQykgfHwgKFBMQVRGT1JNKENIUk9NSVVNKSAmJiBPUyhEQVJXSU4pKQogICAg ICAgICAvLyAoUExBVEZPUk0oTUFDKSBpcyBhbHdheXMgZmFsc2UgaW4gQ2hyb21pdW0sIGhlbmNl IHRoZSBleHRyYSBjb25kaXRpb24uKQogICAgICAgICBFZGl0aW5nTWFjQmVoYXZpb3IKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgK aW5kZXggZGMzYjUwZi4uNmE5YzI1ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdz LmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAgLTI4LDYgKzI4LDcgQEAKICNkZWZp bmUgU2V0dGluZ3NfaAogCiAjaW5jbHVkZSAiQXRvbWljU3RyaW5nLmgiCisjaW5jbHVkZSAiRWRp dGluZ0JlaGF2aW9yVHlwZXMuaCIKICNpbmNsdWRlICJGb250UmVuZGVyaW5nTW9kZS5oIgogI2lu Y2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJab29tTW9kZS5oIgpAQCAtNTAsMjEgKzUxLDYgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBUZXh0RGlyZWN0aW9uU3VibWVudUFsd2F5c0lu Y2x1ZGVkCiAgICAgfTsKIAotICAgIC8vIFRoZXJlIGFyZSBtdWx0aXBsZSBlZGl0aW5nIGRldGFp bHMgdGhhdCBhcmUgZGlmZmVyZW50IG9uIFdpbmRvd3MgdGhhbiBNYWNpbnRvc2guCi0gICAgLy8g V2UgdXNlIGEgc2luZ2xlIHN3aXRjaCBmb3IgYWxsIG9mIHRoZW0uIFNvbWUgZXhhbXBsZXM6Ci0g ICAgLy8KLSAgICAvLyAgICAxKSBDbGlja2luZyBiZWxvdyB0aGUgbGFzdCBsaW5lIG9mIGFuIGVk aXRhYmxlIGFyZWEgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZAotICAgIC8vICAgICAgIG9mIHRo ZSBsYXN0IGxpbmUgb24gTWFjLCBidXQgaW4gdGhlIG1pZGRsZSBvZiB0aGUgbGFzdCBsaW5lIG9u IFdpbmRvd3MuCi0gICAgLy8gICAgMikgUHVzaGluZyB0aGUgZG93biBhcnJvdyBrZXkgb24gdGhl IGxhc3QgbGluZSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kIG9mIHRoZQotICAgIC8vICAgICAg IGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBkb2VzIG5vdGhpbmcgb24gV2luZG93cy4gQSBzaW1pbGFy IGNhc2UgZXhpc3RzIG9uIHRoZQotICAgIC8vICAgICAgIHRvcCBsaW5lLgotICAgIC8vCi0gICAg Ly8gVGhpcyBzZXR0aW5nIGlzIGludGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2YgYmVo YXZpb3JzLiBUaGVyZSBhcmUgc29tZSBvdGhlcgotICAgIC8vIGJlaGF2aW9ycyB3aXRoIGluZGl2 aWR1YWwgZnVuY3Rpb24gY2FsbHMgb24gRWRpdG9yQ2xpZW50IChzbWFydCBjb3B5IGFuZCBwYXN0 ZSBhbmQKLSAgICAvLyBzZWxlY3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0 aGF0IGNvdWxkIGJlIGNvbWJpbmVkIHdpdGggdGhpcyBpZgotICAgIC8vIGlmIHBvc3NpYmxlIGlu IHRoZSBmdXR1cmUuCi0gICAgZW51bSBFZGl0aW5nQmVoYXZpb3IgeyBFZGl0aW5nTWFjQmVoYXZp b3IsIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IgfTsKLQogICAgIGNsYXNzIFNldHRpbmdzIDogcHVi bGljIE5vbmNvcHlhYmxlIHsKICAgICBwdWJsaWM6CiAgICAgICAgIFNldHRpbmdzKFBhZ2UqKTsK QEAgLTI3MCw5ICsyNTYsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0 QWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7CiAgICAgICAgIGJvb2wgYWxsb3dTY3Jp cHRzVG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVybiBtX2FsbG93U2NyaXB0c1RvQ2xvc2VX aW5kb3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2 aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0KLSAgICAgICAg RWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19j YXN0PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVoYXZpb3IpOyB9Ci0gICAgICAgIAorICAg ICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvclR5cGUoRWRpdGluZ0JlaGF2aW9yVHlwZSBiZWhh dmlvcikgeyBtX2VkaXRpbmdCZWhhdmlvclR5cGUgPSBiZWhhdmlvcjsgfQorICAgICAgICBFZGl0 aW5nQmVoYXZpb3JUeXBlIGVkaXRpbmdCZWhhdmlvclR5cGUoKSBjb25zdCB7IHJldHVybiBzdGF0 aWNfY2FzdDxFZGl0aW5nQmVoYXZpb3JUeXBlPihtX2VkaXRpbmdCZWhhdmlvclR5cGUpOyB9CisK ICAgICAgICAgdm9pZCBzZXREb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoYm9vbCk7CiAg ICAgICAgIGJvb2wgZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKCkgY29uc3QgeyByZXR1 cm4gbV9kb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQ7IH0KIApAQCAtMzgwLDcgKzM2Niw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgYm9vbCBtX2VuZm9yY2VDU1NNSU1FVHlw ZUluU3RyaWN0TW9kZSA6IDE7CiAgICAgICAgIGJvb2wgbV91c2VzRW5jb2RpbmdEZXRlY3RvciA6 IDE7CiAgICAgICAgIGJvb2wgbV9hbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyA6IDE7Ci0gICAg ICAgIHVuc2lnbmVkIG1fZWRpdGluZ0JlaGF2aW9yIDogMTsKKyAgICAgICAgdW5zaWduZWQgbV9l ZGl0aW5nQmVoYXZpb3JUeXBlIDogMTsKICAgICAgICAgYm9vbCBtX2Rvd25sb2FkYWJsZUJpbmFy eUZvbnRzRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV94c3NBdWRpdG9yRW5hYmxlZCA6IDE7 CiAgICAgICAgIGJvb2wgbV9hY2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZCA6IDE7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggNmZiZWExNC4uMDllZTljNCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckJsb2NrLmNwcApAQCAtMzcxOCwxNiArMzcxOCwxNSBAQCBWaXNpYmxlUG9zaXRpb24g UmVuZGVyQmxvY2s6OnBvc2l0aW9uRm9yUG9pbnRXaXRoSW5saW5lQ2hpbGRyZW4oY29uc3QgSW50 UG9pbnQmCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1 bWVudCgpLT5zZXR0aW5ncygpOwotICAgIGJvb2wgdXNlV2luZG93c0JlaGF2aW9yID0gc2V0dGlu Z3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdXaW5kb3dzQmVoYXZp b3I7CisgICAgYm9vbCBtb3ZlQ2FyZXRUb0JvdW5kYXJ5ID0gZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlX aGVuUGFzdFRvcE9yQm90dG9tKCk7CiAKLSAgICBpZiAodXNlV2luZG93c0JlaGF2aW9yICYmICFj bG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CisgICAgaWYgKCFtb3ZlQ2Fy ZXRUb0JvdW5kYXJ5ICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7 CiAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBiZWxvdyBsYXN0IHJvb3QgbGluZSBib3gsIHBy ZXRlbmQgd2UgaGl0IGl0CiAgICAgICAgIGNsb3Nlc3RCb3ggPSBsYXN0Um9vdEJveFdpdGhDaGls ZHJlbi0+Y2xvc2VzdExlYWZDaGlsZEZvclhQb3MocG9pbnRJbkNvbnRlbnRzLngoKSk7CiAgICAg fQogCiAgICAgaWYgKGNsb3Nlc3RCb3gpIHsKLSAgICAgICAgaWYgKCF1c2VXaW5kb3dzQmVoYXZp b3IgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGlu ZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3RvcikgeworICAgICAgICBpZiAobW92 ZUNhcmV0VG9Cb3VuZGFyeSAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0 aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CiAg ICAgICAgICAgICAvLyB5IGNvb3JkaW5hdGUgaXMgYWJvdmUgZmlyc3Qgcm9vdCBsaW5lIGJveCwg c28gcmV0dXJuIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QKICAgICAgICAgICAgIHJldHVybiBWaXNp YmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3goZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5maXJz dExlYWZDaGlsZCgpLCB0cnVlKSwgRE9XTlNUUkVBTSk7CiAgICAgICAgIH0KQEAgLTM3MzgsNyAr MzczNyw3IEBAIFZpc2libGVQb3NpdGlvbiBSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdp dGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQb2ludCYKIAogICAgIGlmIChsYXN0Um9vdEJveFdp dGhDaGlsZHJlbikgewogICAgICAgICAvLyBXZSBoaXQgdGhpcyBjYXNlIGZvciBNYWMgYmVoYXZp b3Igd2hlbiB0aGUgWSBjb29yZGluYXRlIGlzIGJlbG93IHRoZSBsYXN0IGJveC4KLSAgICAgICAg QVNTRVJUKCF1c2VXaW5kb3dzQmVoYXZpb3IpOworICAgICAgICBBU1NFUlQobW92ZUNhcmV0VG9C b3VuZGFyeSk7CiAgICAgICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3go bGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxhc3RMZWFmQ2hpbGQoKSwgZmFsc2UpLCBET1dOU1RS RUFNKTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGYyYTJjMzUuLjUzYTkwOTEgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtp dG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29k ZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFt ZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmgg dG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0 LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIHNyYy9XZWJTZXR0aW5nc0ltcGwu Y3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdCZWhhdmlv cik6CisKIDIwMTAtMDUtMzAgIEx5b24gQ2hlbiAgPGxpYWNoZW5AcmltLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViU2V0dGluZ3NJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJ bXBsLmNwcAppbmRleCAyODQwOTI5Li41OTBlNWU1IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJT ZXR0aW5nc0ltcGwuY3BwCkBAIC0yNzEsNyArMjcxLDcgQEAgdm9pZCBXZWJTZXR0aW5nc0ltcGw6 OnNldFNob3dEZWJ1Z0JvcmRlcnMoYm9vbCBzaG93KQogCiB2b2lkIFdlYlNldHRpbmdzSW1wbDo6 c2V0RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKLSAgICBtX3Nl dHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3Ioc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yPihiZWhhdmlvcikpOworICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5 cGUoc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZT4oYmVoYXZpb3IpKTsK IH0KIAogdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFi bGVkKGJvb2wgZW5hYmxlZCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggOTg2NWMyNi4uOGUwYzM1ZiAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy MCBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlZmFjdG9y IHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRpbmdz CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAor CisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdCZWhh dmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVkaXRp bmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3Jk aW5nbHkuCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHA6CisgICAgICAgIChX ZWJLaXQ6OmNvcmUpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAg ICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3Vw ZGF0ZV9zZXR0aW5ncyk6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfc2V0dGluZ3Nfbm90aWZ5 KToKKwogMjAxMC0wNS0yNyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4K IAogICAgICAgICBVcGRhdGUgZG9jdW1lbnRhdGlvbiBjb250cm9sIGZpbGVzLCBhbmQgZml4IFNp bmNlIHRhZ3MgZm9yIDEuMy4xLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCBk Mjc0NzA4Li43MDlkYzVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMTI5 LDkgKzEyOSw5IEBAIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgY29yZShXZWJLaXROZXR3b3Jr UmVzcG9uc2UqIHJlc3BvbnNlKQogICAgIHJldHVybiBSZXNvdXJjZVJlc3BvbnNlKCk7CiB9CiAK LVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBl KQorV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlv ciB0eXBlKQogewotICAgIHJldHVybiAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yKXR5cGU7Cisg ICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlKXR5cGU7CiB9CiAKIFdlYktp dEhpdFRlc3RSZXN1bHQqIGtpdChjb25zdCBXZWJDb3JlOjpIaXRUZXN0UmVzdWx0JiByZXN1bHQp CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggMDU3YjBlNS4uNmFlY2MxMyAxMDA2NDQK LS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtOTUsNyArOTUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0 IHsKIAogICAgIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgY29yZShXZWJLaXROZXR3b3JrUmVz cG9uc2UqIHJlc3BvbnNlKTsKIAotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdl YktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKKyAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JU eXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpOwogCiAgICAgV2ViS2l0U2VjdXJp dHlPcmlnaW4qIGtpdChXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiopOwogICAgIFdlYkNvcmU6OlNl Y3VyaXR5T3JpZ2luKiBjb3JlKFdlYktpdFNlY3VyaXR5T3JpZ2luKik7CmRpZmYgLS1naXQgYS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwCmluZGV4IDJjOTU1NTguLjg0MTkzNzUgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwCkBAIC0yNjk1LDcgKzI2OTUsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRf d2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCiAgICAgc2V0 dGluZ3MtPnNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHkoamF2YXNjcmlw dENhbk9wZW5XaW5kb3dzKTsKICAgICBzZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENhbkFjY2Vzc0Ns aXBib2FyZChqYXZhU2NyaXB0Q2FuQWNjZXNzQ2xpcGJvYXJkKTsKICAgICBzZXR0aW5ncy0+c2V0 T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVkKGVuYWJsZU9mZmxpbmVXZWJBcHBDYWNo ZSk7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKGVkaXRpbmdCZWhhdmlv cikpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmUoZWRpdGluZ0Jl aGF2aW9yKSk7CiAgICAgc2V0dGluZ3MtPnNldEFsbG93VW5pdmVyc2FsQWNjZXNzRnJvbUZpbGVV UkxzKGVuYWJsZVVuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJJKTsKICAgICBzZXR0aW5ncy0+c2V0 QWxsb3dGaWxlQWNjZXNzRnJvbUZpbGVVUkxzKGVuYWJsZUZpbGVBY2Nlc3NGcm9tRmlsZVVSSSk7 CiAgICAgc2V0dGluZ3MtPnNldERPTVBhc3RlQWxsb3dlZChlbmFibGVET01QYXN0ZSk7CkBAIC0y Nzk2LDcgKzI3OTYsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0dGluZ3Nfbm90 aWZ5KFdlYktpdFdlYlNldHRpbmdzKiB3ZWJTZXR0aW5ncywgR1BhcgogICAgIGVsc2UgaWYgKG5h bWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlbmFibGUtb2ZmbGluZS13ZWItYXBwbGljYXRpb24tY2Fj aGUiKSkKICAgICAgICAgc2V0dGluZ3MtPnNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5h YmxlZChnX3ZhbHVlX2dldF9ib29sZWFuKCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0g Z19pbnRlcm5fc3RyaW5nKCJlZGl0aW5nLWJlaGF2aW9yIikpCi0gICAgICAgIHNldHRpbmdzLT5z ZXRFZGl0aW5nQmVoYXZpb3IoY29yZShzdGF0aWNfY2FzdDxXZWJLaXRFZGl0aW5nQmVoYXZpb3I+ KGdfdmFsdWVfZ2V0X2VudW0oJnZhbHVlKSkpKTsKKyAgICAgICAgc2V0dGluZ3MtPnNldEVkaXRp bmdCZWhhdmlvclR5cGUoY29yZShzdGF0aWNfY2FzdDxXZWJLaXRFZGl0aW5nQmVoYXZpb3I+KGdf dmFsdWVfZ2V0X2VudW0oJnZhbHVlKSkpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50ZXJu X3N0cmluZygiZW5hYmxlLXVuaXZlcnNhbC1hY2Nlc3MtZnJvbS1maWxlLXVyaXMiKSkKICAgICAg ICAgc2V0dGluZ3MtPnNldEFsbG93VW5pdmVyc2FsQWNjZXNzRnJvbUZpbGVVUkxzKGdfdmFsdWVf Z2V0X2Jvb2xlYW4oJnZhbHVlKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJp bmcoImVuYWJsZS1maWxlLWFjY2Vzcy1mcm9tLWZpbGUtdXJpcyIpKQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L21hYy9DaGFuZ2VMb2cgYi9XZWJLaXQvbWFjL0NoYW5nZUxvZwppbmRleCA3ZDg4ZmVkLi4z NzBmNmQ4IDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9XZWJLaXQvbWFj L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8 dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZp b3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2Fz IHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRp bmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4g V2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIFdlYlZpZXcvV2ViRnJh bWUubW06CisgICAgICAgIChjb3JlKToKKyAgICAgICAgKiBXZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXcubW06CisgICAgICAgICgtW1dlYlZpZXcg X3ByZWZlcmVuY2VzQ2hhbmdlZE5vdGlmaWNhdGlvbjpdKToKKwogMjAxMC0wNS0zMCAgRGFyaW4g QWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5p Zy4KZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbSBiL1dlYktpdC9t YWMvV2ViVmlldy9XZWJGcmFtZS5tbQppbmRleCA5OTlmMTc3Li43YzU5NjE1IDEwMDY0NAotLS0g YS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3 L1dlYkZyYW1lLm1tCkBAIC0xOTYsNyArMTk2LDcgQEAgRWRpdGFibGVMaW5rQmVoYXZpb3IgY29y ZShXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvciBlZGl0YWJsZUxpbmtCZWhhdmlvcikKICAgICBy ZXR1cm4gRWRpdGFibGVMaW5rRGVmYXVsdEJlaGF2aW9yOwogfQogCi1XZWJDb3JlOjpFZGl0aW5n QmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IpCitXZWJDb3JlOjpF ZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQog ewogICAgIHN3aXRjaCAoYmVoYXZpb3IpIHsKICAgICAgICAgY2FzZSBXZWJLaXRFZGl0aW5nTWFj QmVoYXZpb3I6CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5h bC5oIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaAppbmRleCA5YjIyNDhh Li41ODZiNGMzIDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5h bC5oCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKQEAgLTcxLDcg KzcxLDcgQEAgV2ViVmlldyAqa2l0KFdlYkNvcmU6OlBhZ2UqKTsKIAogV2ViQ29yZTo6RWRpdGFi bGVMaW5rQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcik7CiBXZWJDb3Jl OjpUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yIGNvcmUoV2ViVGV4dERpcmVj dGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcik7Ci1XZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3Ig Y29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IpOworV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlw ZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvcik7CiAKIFdlYlZpZXcgKmdldFdlYlZpZXcoV2Vi RnJhbWUgKndlYkZyYW1lKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZp ZXcubW0gYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQppbmRleCA5N2M3OTliLi45ZjNh ZDYwIDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQorKysgYi9XZWJL aXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQpAQCAtMTM2OSw3ICsxMzY5LDcgQEAgc3RhdGljIGJv b2wgZmFzdERvY3VtZW50VGVhcmRvd25FbmFibGVkKCkKICAgICBzZXR0aW5ncy0+c2V0VGV4dEFy ZWFzQXJlUmVzaXphYmxlKFtwcmVmZXJlbmNlcyB0ZXh0QXJlYXNBcmVSZXNpemFibGVdKTsKICAg ICBzZXR0aW5ncy0+c2V0U2hyaW5rc1N0YW5kYWxvbmVJbWFnZXNUb0ZpdChbcHJlZmVyZW5jZXMg c2hyaW5rc1N0YW5kYWxvbmVJbWFnZXNUb0ZpdF0pOwogICAgIHNldHRpbmdzLT5zZXRFZGl0YWJs ZUxpbmtCZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyBlZGl0YWJsZUxpbmtCZWhhdmlvcl0pKTsK LSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRp bmdCZWhhdmlvcl0pKTsKKyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3Jl KFtwcmVmZXJlbmNlcyBlZGl0aW5nQmVoYXZpb3JdKSk7CiAgICAgc2V0dGluZ3MtPnNldFRleHRE aXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMgdGV4dERp cmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcl0pKTsKICAgICBzZXR0aW5ncy0+c2V0RE9N UGFzdGVBbGxvd2VkKFtwcmVmZXJlbmNlcyBpc0RPTVBhc3RlQWxsb3dlZF0pOwogICAgIHNldHRp bmdzLT5zZXRVc2VzUGFnZUNhY2hlKFtzZWxmIHVzZXNQYWdlQ2FjaGVdKTsKZGlmZiAtLWdpdCBh L1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDY5YzFlMmYu LjM3YzRhY2UgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0 L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8 dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZp b3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2Fz IHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRp bmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4g V2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0 L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcDoKKyAgICAgICAgKER1bXBSZW5kZXJUcmVlU3Vw cG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IpOgorCiAyMDEwLTA1LTMwICBMeW9uIENoZW4gIDxs aWFjaGVuQHJpbS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VudCBUYW11cmEuCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQu Y3BwIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNw cAppbmRleCAwYjJlOWE1Li5hOTUxYTQ5IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1 cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwCisrKyBiL1dlYktpdC9xdC9XZWJDb3Jl U3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKQEAgLTQ3Niw3ICs0NzYsNyBAQCBi b29sIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjplbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVs ZW1lbnRXaXRoSWQoUVdlYkZyYW1lKgogCiB2b2lkIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0Ojpz ZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBhZ2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcmIGVkaXRpbmdC ZWhhdmlvcikKIHsKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZUVkaXRpbmdCZWhh dmlvcjsKKyAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmVFZGl0aW5nQmVoYXZp b3I7CiAKICAgICBpZiAoZWRpdGluZ0JlaGF2aW9yID09ICJ3aW4iKQogICAgICAgICBjb3JlRWRp dGluZ0JlaGF2aW9yID0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKQEAgLTQ4Nyw3ICs0ODcsNyBA QCB2b2lkIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBh Z2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcmCiAgICAgaWYgKCFjb3JlUGFnZSkKICAgICAgICAgcmV0 dXJuOwogCi0gICAgY29yZVBhZ2UtPnNldHRpbmdzKCktPnNldEVkaXRpbmdCZWhhdmlvcihjb3Jl RWRpdGluZ0JlaGF2aW9yKTsKKyAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0Jl aGF2aW9yVHlwZShjb3JlRWRpdGluZ0JlaGF2aW9yKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJl ZVN1cHBvcnRRdDo6ZHVtcEZyYW1lTG9hZGVyKGJvb2wgYikKZGlmZiAtLWdpdCBhL1dlYktpdC93 aW4vQ2hhbmdlTG9nIGIvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKaW5kZXggOTQ0YmI3Ni4uNzFlYjJm ZCAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3dpbi9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlr aXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNv ZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5h bWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5o IHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktp dC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJWaWV3LmNwcDoKKyAgICAg ICAgKFdlYlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdlZCk6CisKIDIwMTAtMDUtMjIgIEpl ciBOb2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRh bSBSb2Jlbi4KZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vV2ViVmlldy5jcHAgYi9XZWJLaXQvd2lu L1dlYlZpZXcuY3BwCmluZGV4IDUyNTEwOGYuLmJhNWJmNDQgMTAwNjQ0Ci0tLSBhL1dlYktpdC93 aW4vV2ViVmlldy5jcHAKKysrIGIvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcApAQCAtNDY1NCw3ICs0 NjU0LDcgQEAgSFJFU1VMVCBXZWJWaWV3Ojpub3RpZnlQcmVmZXJlbmNlc0NoYW5nZWQoSVdlYk5v dGlmaWNhdGlvbiogbm90aWZpY2F0aW9uKQogICAgIGhyID0gcHJlZmVyZW5jZXMtPmVkaXRpbmdC ZWhhdmlvcigmZWRpdGluZ0JlaGF2aW9yKTsKICAgICBpZiAoRkFJTEVEKGhyKSkKICAgICAgICAg cmV0dXJuIGhyOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoKEVkaXRpbmdCZWhh dmlvcillZGl0aW5nQmVoYXZpb3IpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JU eXBlKChFZGl0aW5nQmVoYXZpb3JUeXBlKWVkaXRpbmdCZWhhdmlvcik7CiAKICAgICBociA9IHBy ZWZlcmVuY2VzLT51c2VzUGFnZUNhY2hlKCZlbmFibGVkKTsKICAgICBpZiAoRkFJTEVEKGhyKSkK LS0gCjEuNy4wLjQKCg== 57540 2010-06-01 07:04:22 -0700 2010-06-01 08:56:12 -0700 patch v2.1 - same as v2, but builds on Mac 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 40947 tonikitoo RnJvbSAxMDZlZDk1ZWFhOTgxNDYwNTMwYjAwNGE0MWMxNTc1Y2ZiYjJhMDUyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAzMSBNYXkgMjAxMCAxNTo1NDo1NSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpQYXRjaCBieSBBbnRvbmlvIEdvbWVzIDx0b25pa2l0 b29Ad2Via2l0Lm9yZz4KCldlYkNvcmU6CgpBcyBwZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2Mjcs IHRoZSBmb2xsb3dpbmcgd2FzIHN1Z2dlc3RlZCBieSBEYXJpbiBBZGxlcjogImJlZm9yZSB0aGUg YWRkaXRpb24gb2YgYW55Cm5ldyBFZGl0aW5nQmVoYXZpb3IsIEkgdGhpbmsgd2UgbmVlZCB0byBh ZGQgZnVuY3Rpb25zIHRvIHRyYW5zbGF0ZSB0aGUgb3ZlcmFsbCBiZWhhdmlvciBwb2xpY3kgaW50 byBzcGVjaWZpYwpiZWhhdmlvcnMgcmF0aGVyIHRoYW4gZGlyZWN0bHkgc2F5aW5nICdiZWhhdmlv ciA9PSBNYWMnIG9yICdiZWhhdmlvciA9PSBXaW5kb3dzJy4gSGVscGVyIGZ1bmN0aW9ucyB0aGF0 CmV4cHJlc3Npb24gdGhlIGRpZmZlcmVudCBydWxlcyBpbiBwbGFpbiBsYW5ndWFnZS4iLgoKUGF0 Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KCk5vIGJlaGF2aW9yIGNoYW5nZSwgc28gbm8gbmV3 IHRlc3RzLgoKKiBHTlVtYWtlZmlsZS5hbToKKiBXZWJDb3JlLnBybzoKKiBXZWJDb3JlL1dlYkNv cmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCiogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKKiBwYWdlL1NldHRpbmdzLmNwcDoKKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0 aW5ncyk6CiogcGFnZS9TZXR0aW5ncy5oOiBNb3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0g dG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgsCmFuZCByZW5hbWVkIHRv IEVkaXRpbmdCZWhhdmlvclR5cGVzLgooV2ViQ29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhh dmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9yLgooV2ViQ29yZTo6U2V0 dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9y LgoqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6IEFkZGVkLgooV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBDbGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2lu dCBmb3IKZWRpdGluZyBiZWhhdmlvciB0aGF0IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZm ZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBsYXRmb3Jtcy9wb3J0cy4KQ2xhc3Mgc2hvdWxkIGJl IG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5 IGNvbnN0cnVjdGVkCnRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9y Qm90dG9tKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVu U2VsZWN0aW9uSXNSZXZlYWxlZCk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENv bnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0 aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJv bUVuZFBvaW50QWx3YXlzKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFy ZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKFdlYkNvcmU6OkVkaXRp bmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToK KiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgooV2ViQ29yZTo6KToKKiBl ZGl0aW5nL0VkaXRvci5jcHA6CihXZWJDb3JlOjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZv ciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCiogZWRpdGluZy9FZGl0b3IuaDoKKiBlZGl0aW5nL0Vk aXRvckNvbW1hbmQuY3BwOgooV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgooV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6 c2V0U2VsZWN0aW9uKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0 aW9uYWwpOgooV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9y bSk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgoqIHBhZ2UvRXZlbnRI YW5kbGVyLmNwcDoKKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50 U2luZ2xlQ2xpY2spOgoqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CihXZWJDb3JlOjpSZW5k ZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbik6CgotIENhbGwgc2l0 ZXMgd2lsbCBsb29rIGxpa2U6CmlmIChmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxk VGhpc0lmVGhhdCgpKSkKICAgLy8gZG8gc29tZXRoaW5nCgpXZWJLaXQ6CgpFZGl0aW5nQmVoYXZp b3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0 IGZyb20gU2V0dGluZ3MuaCB0bwpFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBp biBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgoKV2ViS2l0L2Nocm9taXVtOgoqIHNyYy9X ZWJTZXR0aW5nc0ltcGwuY3BwOgooV2ViS2l0OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdC ZWhhdmlvcik6CgpXZWJLaXQvZ3RrOgoqIHdlYmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKFdlYktp dDo6Y29yZSk6Ciogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKiB3ZWJraXQvd2Via2l0d2Vidmll dy5jcHA6Cih3ZWJraXRfd2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKToKKHdlYmtpdF93ZWJfdmll d19zZXR0aW5nc19ub3RpZnkpOgoKV2ViS2l0L21hYzoKKiBXZWJWaWV3L1dlYkZyYW1lLm1tOgoo Y29yZSk6CiogV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmg6CiogV2ViVmlldy9XZWJWaWV3Lm1t OgooLVtXZWJWaWV3IF9wcmVmZXJlbmNlc0NoYW5nZWROb3RpZmljYXRpb246XSk6CgpXZWJLaXQv cXQ6CiogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwOgooRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcik6CgpXZWJLaXQvd2luOgoqIFdl YlZpZXcuY3BwOgooV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKToKLS0tCiBXZWJD b3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNTUgKysr KysrKysrKysrKysrKysrKysKIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL1dlYkNvcmUuZ3lwaSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2ogICAgICAgICAgICAgIHwgICAgOCArKysKIFdlYkNvcmUvV2ViQ29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qICAgICAgICAgIHwgICAgOCArKysKIFdlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAgICAgIHwgICA1MiArKysrKysrKysrKysr KysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oICAgICAgICAgICAg IHwgICA0NiArKysrKysrKysrKysrKysrCiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMTAgKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5o ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAzICsKIFdlYkNvcmUvZWRpdGluZy9FZGl0 b3JDb21tYW5kLmNwcCAgICAgICAgICAgICAgICAgIHwgICAgMyArLQogV2ViQ29yZS9lZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAgICAgfCAgIDEwICsrLS0KIFdlYkNvcmUv cGFnZS9FdmVudEhhbmRsZXIuY3BwICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICst CiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg MjQgKystLS0tLS0tCiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgICAgICAgICAg ICAgICAgICB8ICAgIDkgKystLQogV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRp bmdzSW1wbC5jcHAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9ndGsvQ2hhbmdlTG9nICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNyArKysrKysKIFdlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAgICAgIHwgICAgNCArLQogV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCAgICAgICAgICAgICAgICB8ICAgIDQgKy0K IFdlYktpdC9tYWMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAx NiArKysrKysKIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbSAgICAgICAgICAgICAgICAg ICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCAgICAg ICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSAgICAgICAg ICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9xdC9DaGFuZ2VMb2cgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysrKwogLi4uL3F0L1dlYkNvcmVTdXBwb3J0L0R1 bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCAgfCAgICA0ICstCiBXZWJLaXQvd2luL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysKIFdlYktpdC93aW4v V2ViVmlldy5jcHAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogMzAgZmls ZXMgY2hhbmdlZCwgMjg3IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAogY3JlYXRlIG1vZGUg MTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0ODA1ZjIzLi44 Y2NjN2ZjIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDU4IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtp dG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29k ZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgQXMgcGVyIGRpc2N1c3Npb24gaW4gYnVnIDM2NjI3 LCBEYXJpbiBBZGxlciBzdWdnZXN0ZWQ6ICJiZWZvcmUgdGhlIGFkZGl0aW9uIG9mIGFueSBuZXcg RWRpdGluZ0JlaGF2aW9yLAorICAgICAgICBJIHRoaW5rIHdlIHRvIGFkZCBmdW5jdGlvbnMgdG8g dHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRvIHNwZWNpZmljIGJlaGF2 aW9ycyByYXRoZXIgdGhhbgorICAgICAgICBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9yID09IE1h Yycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQgZXhwcmVz c2lvbiB0aGUgZGlmZmVyZW50CisgICAgICAgIHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuIFBh dGNoIGFkZHJlc3NlcyB0aGlzIHJlcXVlc3QuCisKKyAgICAgICAgTm8gYmVoYXZpb3IgY2hhbmdl LCBzbyBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAg KiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CisgICAgICAgICogcGFnZS9TZXR0aW5ncy5oOiBN b3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmgsCisgICAgICAgIGFuZCByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5 cGVzLgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhhdmlvclR5cGUp OiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9yLgorICAgICAgICAoV2ViQ29yZTo6U2V0 dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9y LgorICAgICAgICAqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBDbGFzcyB0byB3b3Jr IGFzIGEgY2VudHJhbCBwb2ludCBmb3IKKyAgICAgICAgZWRpdGluZyBiZWhhdmlvciB0aGF0IG1p Z2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBsYXRm b3Jtcy9wb3J0cy4KKyAgICAgICAgQ2xhc3Mgc2hvdWxkIGJlIG5vdCB1c2VkIG9yIGluc3RhbnRp YXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5IGNvbnN0cnVjdGVkCisgICAgICAg IHRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90 dG9tKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxp Z25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CisgICAgICAgIChXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRP bmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVu ZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToKKyAgICAg ICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisg ICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNvbW1h bmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAg KiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Vs ZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVj dGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6U2Vs ZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3Jl OjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVz c0V2ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxp bmVDaGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBsaWtlOgorICAg ICAgICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJZlRoYXQoKSkp CisgICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAyMDEwLTA1LTMwICBBbnRvbmlvIEdvbWVz ICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVt YWtlZmlsZS5hbQppbmRleCBmYzZiODE4Li4xZGE5NzhiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dO VW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgs OCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0QWN0aW9uLmgg XAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9F ZGl0Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAorCVdl YkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIFwKIAlXZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkg Yi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBjNjZhMzJiLi5hYzBjYmQ5IDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5 MSw2ICsxMjkxLDggQEAKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAg ICAgICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcv RWRpdENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCcs CisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oJywKICAgICAgICAg ICAgICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgn LAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODcyN2I3OS4u Yzc0NmIzYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dl YkNvcmUucHJvCkBAIC0xMjc5LDYgKzEyNzksNyBAQCBIRUFERVJTICs9IFwKICAgICBlZGl0aW5n L0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rp b25Db21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisgICAgZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9FZGl0b3IuaCBcCiAgICAgZWRpdGluZy9G b3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9odG1sZWRpdGluZy5oIFwKZGlmZiAt LWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dl YkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGY2ZjQ5NjYuLmJkMzU2ZTkgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29y ZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMzA0NDksNiArMzA0NDksMTQgQEAK IAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRp dGluZ1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0K KwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCINCisJ CQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRp bmdcRWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3Jl L1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDljODI1ZDQuLmJmNGUxMGYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMDE2LDYgKzEwMTYsOCBAQAog CQk0RTE5NTkyRTBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEUxOTU5MjgwQTM5REFDQzAwMjIw RkU1IC8qIE1lZGlhUXVlcnlFeHAuaCAqLzsgfTsKIAkJNEYzMjg5QjUxMUE0MkFBQjAwNUFCRTdF IC8qIEluc3BlY3RvclZhbHVlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVz LmNwcCAqLzsgfTsKIAkJNEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVl cy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYzMjg5 QjQxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTRGMTUzNERFMTFCNTMyRUMwMDIxRkQ4 NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3Iu aCAqLzsgfTsKKwkJNEYxNTM0RTAxMUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5 cGVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0RjE1 MzRERjExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAqLzsgfTsKIAkJ NEZEOEQwRjIxMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEZEOEQwRjAxMTlDNzE4QjAwMkZB ODI1IC8qIFNjcmlwdEdDRXZlbnQuY3BwICovOyB9OwogCQk0RkQ4RDBGMzExOUM3MThCMDAyRkE4 MjUgLyogU2NyaXB0R0NFdmVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNEZEOEQwRjExMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCAq LzsgfTsKIAkJNTEwMTg0NjkwQjA4NjAyQTAwNEE4MjVGIC8qIENhY2hlZFBhZ2UuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxMDE4NDY3MEIwODYwMkEw MDRBODI1RiAvKiBDYWNoZWRQYWdlLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJp dmF0ZSwgKTsgfTsgfTsKQEAgLTY2NDAsNiArNjY0Miw4IEBACiAJCTRFMTk1OTI4MEEzOURBQ0Mw MDIyMEZFNSAvKiBNZWRpYVF1ZXJ5RXhwLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBNZWRpYVF1ZXJ5RXhwLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGMzI4 OUIzMTFBNDJBQUIwMDVBQkU3RSAvKiBJbnNwZWN0b3JWYWx1ZXMuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSW5zcGVjdG9yVmFsdWVzLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJNEYzMjg5QjQxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZh bHVlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JWYWx1ZXMu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNEYxNTM0REQxMUI1MzJFQzAwMjFGRDg2 IC8qIEVkaXRpbmdCZWhhdmlvci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBF ZGl0aW5nQmVoYXZpb3IuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNEYxNTM0REYx MUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IEVkaXRpbmdCZWhhdmlvclR5cGVzLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTRGRDhEMEYwMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50 LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNjcmlwdEdDRXZlbnQu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0RkQ4RDBGMTExOUM3MThCMDAyRkE4 MjUgLyogU2NyaXB0R0NFdmVudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBT Y3JpcHRHQ0V2ZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxMDE4NDY3MEIw ODYwMkEwMDRBODI1RiAvKiBDYWNoZWRQYWdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IENhY2hlZFBhZ2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEzMjE5 LDYgKzEzMjIzLDggQEAKIAkJOTMzMDlEODYwOTlFNjQ5MTAwNTZFNTgxIC8qIGVkaXRpbmcgKi8g PSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTRGMTUzNERGMTFC NTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovLAorCQkJCTRGMTUzNERE MTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAqLywKIAkJCQlFRDUwMURDOTBC MjQ5RjM5MDBBRTE4RDkgLyogbWFjICovLAogCQkJCTkzMzA5RDg3MDk5RTY0OTEwMDU2RTU4MSAv KiBBcHBlbmROb2RlQ29tbWFuZC5jcHAgKi8sCiAJCQkJOTMzMDlEODgwOTlFNjQ5MTAwNTZFNTgx IC8qIEFwcGVuZE5vZGVDb21tYW5kLmggKi8sCkBAIC0xOTQxNSw2ICsxOTQyMSw4IEBACiAJCQkJ QzUxREE5QTkxMUFFRjJDMTAwOTc5OUM1IC8qIElEQkluZGV4UmVxdWVzdC5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJQzVCQkM5RDExMUFFRjgzODAwN0MyQkZFIC8qIEpTSURCSW5kZXhSZXF1ZXN0Lmgg aW4gSGVhZGVycyAqLywKIAkJCQk0RjMyODlCNjExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9y VmFsdWVzLmggaW4gSGVhZGVycyAqLywKKwkJCQk0RjE1MzRERTExQjUzMkVDMDAyMUZEODYgLyog RWRpdGluZ0JlaGF2aW9yLmggaW4gSGVhZGVycyAqLywKKwkJCQk0RjE1MzRFMDExQjUzMzAyMDAy MUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJ CXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oIGIvV2ViQ29yZS9lZGl0aW5nL0Vk aXRpbmdCZWhhdmlvci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ3OGU5 YTAKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgK QEAgLTAsMCArMSw1MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3Jh dGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxl IENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rv biwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgRWRpdGluZ0JlaGF2aW9yX2gK KyNkZWZpbmUgRWRpdGluZ0JlaGF2aW9yX2gKKworI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvclR5 cGVzLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgRWRpdGluZ0JlaGF2aW9yIHsK KworcHVibGljOgorICAgIEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVoYXZpb3JUeXBlIHR5cGUp CisgICAgICAgIDogbV90eXBlKHR5cGUpCisgICAgeworICAgIH0KKworICAgIC8vIEluZGl2aWR1 YWwgZnVuY3Rpb25zIGZvciBlYWNoIGNhc2Ugd2hlcmUgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHN0 eWxlIG9mIGVkaXRpbmcgYmVoYXZpb3IuCisgICAgLy8gQ3JlYXRlIGEgbmV3IGZ1bmN0aW9uIGZv ciBhbnkgcGxhdGZvcm0gZGlmZmVyZW5jZSBzbyB3ZSBjYW4gY29udHJvbCBpdCBoZXJlLgorICAg IGJvb2wgc2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90 dG9tKCkgY29uc3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7IH0K KyAgICBib29sIHNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQoKSBjb25z dCB7IHJldHVybiBtX3R5cGUgPT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91 bGRDb25zaWRlck1vdXNlU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCgpIGNvbnN0IHsgcmV0dXJuIG1f dHlwZSAhPSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0KKyAgICBib29sIHNob3VsZENvbnNpZGVyU3R5 bGVQcmVzZW50T25seUlmVGhyb3VnaG91dFRoZVNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1f dHlwZSAhPSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0KKyAgICBib29sIHNob3VsZEV4dGVuZFNlbGVj dGlvbkZyb21FbmRQb2ludEFsd2F5cygpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAhPSBFZGl0aW5n TWFjQmVoYXZpb3I7IH0KKyAgICBib29sIHNob3VsZEtleWJhcmRTZWxlY3Rpb25FeHRlbmRGb3JI b3Jpem9udGFsTmF2aWdhdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFj QmVoYXZpb3I7IH0KKyAgICBib29sIHNob3VsZEdyb3dTZWxlY3Rpb25XaGVuRXh0ZW5kaW5nVG9C b3VuZGFyeSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0K KworcHJpdmF0ZToKKyAgICBFZGl0aW5nQmVoYXZpb3JUeXBlIG1fdHlwZTsKK307CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVkaXRpbmdCZWhhdmlvcl9oCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCBiL1dlYkNvcmUvZWRp dGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjI2YmExOGUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yVHlwZXMuaApAQCAtMCwwICsxLDQ2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEwIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorICogQ29w eXJpZ2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBU aGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRo IEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBF ZGl0aW5nQmVoYXZpb3JUeXBlc19oCisjZGVmaW5lIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBUaGVyZSBhcmUgbXVsdGlwbGUgZWRpdGluZyBkZXRh aWxzIHRoYXQgYXJlIGRpZmZlcmVudCBvbiBXaW5kb3dzIHRoYW4gTWFjaW50b3NoLgorLy8gV2Ug dXNlIGEgc2luZ2xlIHN3aXRjaCBmb3IgYWxsIG9mIHRoZW0uIFNvbWUgZXhhbXBsZXM6CisvLwor Ly8gICAgMSkgQ2xpY2tpbmcgYmVsb3cgdGhlIGxhc3QgbGluZSBvZiBhbiBlZGl0YWJsZSBhcmVh IHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQKKy8vICAgICAgIG9mIHRoZSBsYXN0IGxpbmUgb24g TWFjLCBidXQgaW4gdGhlIG1pZGRsZSBvZiB0aGUgbGFzdCBsaW5lIG9uIFdpbmRvd3MuCisvLyAg ICAyKSBQdXNoaW5nIHRoZSBkb3duIGFycm93IGtleSBvbiB0aGUgbGFzdCBsaW5lIHB1dHMgdGhl IGNhcmV0IGF0IHRoZSBlbmQgb2YgdGhlCisvLyAgICAgICBsYXN0IGxpbmUgb24gTWFjLCBidXQg ZG9lcyBub3RoaW5nIG9uIFdpbmRvd3MuIEEgc2ltaWxhciBjYXNlIGV4aXN0cyBvbiB0aGUKKy8v ICAgICAgIHRvcCBsaW5lLgorLy8KKy8vIFRoaXMgc2V0dGluZyBpcyBpbnRlbmRlZCB0byBjb250 cm9sIHRoZXNlIHNvcnRzIG9mIGJlaGF2aW9ycy4gVGhlcmUgYXJlIHNvbWUgb3RoZXIKKy8vIGJl aGF2aW9ycyB3aXRoIGluZGl2aWR1YWwgZnVuY3Rpb24gY2FsbHMgb24gRWRpdG9yQ2xpZW50IChz bWFydCBjb3B5IGFuZCBwYXN0ZSBhbmQKKy8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBk b3VibGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCisvLyBpZiBw b3NzaWJsZSBpbiB0aGUgZnV0dXJlLgorZW51bSBFZGl0aW5nQmVoYXZpb3JUeXBlIHsKKyAgICBF ZGl0aW5nTWFjQmVoYXZpb3IsCisgICAgRWRpdGluZ1dpbmRvd3NCZWhhdmlvcgorfTsKKworfSAv LyBXZWJDb3JlIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRWRpdGluZ0JlaGF2aW9yVHlwZXNfaApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAgYi9XZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmNwcAppbmRleCA4MDQxMTU5Li41ODkzNDIzIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Vk aXRpbmcvRWRpdG9yLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcApAQCAtNjMs NiArNjMsNyBAQAogI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCiAjaW5jbHVkZSAiUmVuZGVyUGFy dC5oIgogI2luY2x1ZGUgIlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmgiCisjaW5jbHVkZSAiU2V0 dGluZ3MuaCIKICNpbmNsdWRlICJTb3VuZC5oIgogI2luY2x1ZGUgIlRleHQuaCIKICNpbmNsdWRl ICJUZXh0SXRlcmF0b3IuaCIKQEAgLTk3LDYgKzk4LDE1IEBAIFZpc2libGVTZWxlY3Rpb24gRWRp dG9yOjpzZWxlY3Rpb25Gb3JDb21tYW5kKEV2ZW50KiBldmVudCkKICAgICByZXR1cm4gc2VsZWN0 aW9uOwogfQogCisvLyBGdW5jdGlvbiBjb25zaWRlcnMgTWFjIGVkaXRpbmcgYmVoYXZpb3IgYSBm YWxsYmFjayB3aGVuIFBhZ2Ugb3IgU2V0dGluZ3MgaXMgbm90IGF2YWlsYWJsZS4KK0VkaXRpbmdC ZWhhdmlvciBFZGl0b3I6OmJlaGF2aW9yKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fZnJhbWUgfHwg IW1fZnJhbWUtPnBhZ2UoKSB8fCAhbV9mcmFtZS0+c2V0dGluZ3MoKSkKKyAgICAgICAgcmV0dXJu IEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nTWFjQmVoYXZpb3IpOworCisgICAgcmV0dXJuIEVkaXRp bmdCZWhhdmlvcihtX2ZyYW1lLT5zZXR0aW5ncygpLT5lZGl0aW5nQmVoYXZpb3JUeXBlKCkpOwor fQorCiBFZGl0b3JDbGllbnQqIEVkaXRvcjo6Y2xpZW50KCkgY29uc3QKIHsKICAgICBpZiAoUGFn ZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9F ZGl0b3IuaCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAppbmRleCAxN2RkM2JiLi4zZTIyM2Rj IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL0VkaXRvci5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSAiQ2xpcGJvYXJkQWNjZXNz UG9saWN5LmgiCiAjaW5jbHVkZSAiQ29sb3IuaCIKICNpbmNsdWRlICJFZGl0QWN0aW9uLmgiCisj aW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5jbHVkZSAiRWRpdG9yRGVsZXRlQWN0aW9u LmgiCiAjaW5jbHVkZSAiRWRpdG9ySW5zZXJ0QWN0aW9uLmgiCiAjaW5jbHVkZSAiU2VsZWN0aW9u Q29udHJvbGxlci5oIgpAQCAtMjgxLDYgKzI4Miw4IEBAIHB1YmxpYzoKIAogICAgIEtpbGxSaW5n KiBraWxsUmluZygpIGNvbnN0IHsgcmV0dXJuIG1fa2lsbFJpbmcuZ2V0KCk7IH0KIAorICAgIEVk aXRpbmdCZWhhdmlvciBiZWhhdmlvcigpIGNvbnN0OworCiAgICAgUGFzc1JlZlB0cjxSYW5nZT4g c2VsZWN0ZWRSYW5nZSgpOwogICAgIAogICAgIC8vIFdlIHNob3VsZCBtYWtlIHRoZXNlIGZ1bmN0 aW9ucyBwcml2YXRlIHdoZW4gdGhlaXIgY2FsbGVycyBpbiBGcmFtZSBhcmUgbW92ZWQgb3ZlciBo ZXJlIHRvIEVkaXRvcgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCmluZGV4IDc1MDg1ZmIuLjY2 Y2Q3YmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAorKysg Yi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKQEAgLTE2NCw5ICsxNjQsOCBAQCBz dGF0aWMgYm9vbCBleGVjdXRlVG9nZ2xlU3R5bGUoRnJhbWUqIGZyYW1lLCBFZGl0b3JDb21tYW5k U291cmNlIHNvdXJjZSwgRWRpdEFjdAogICAgIC8vIFN0eWxlIGlzIGNvbnNpZGVyZWQgcHJlc2Vu dCB3aGVuCiAgICAgLy8gbWFjOiBwcmVzZW50IGF0IHRoZSBiZWdpbm5pbmcgb2Ygc2VsZWN0aW9u CiAgICAgLy8gb3RoZXI6IHByZXNlbnQgdGhyb3VnaG91dCB0aGUgc2VsZWN0aW9uCi0gICAgU2V0 dGluZ3MqIHNldHRpbmdzID0gZnJhbWUtPmRvY3VtZW50KCktPnNldHRpbmdzKCk7CiAgICAgYm9v bCBzdHlsZUlzUHJlc2VudDsKLSAgICBpZiAoc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdC ZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhhdmlvcikKKyAgICBpZiAoIWZyYW1lLT5lZGl0b3Io KS0+YmVoYXZpb3IoKS5zaG91bGRDb25zaWRlclN0eWxlUHJlc2VudE9ubHlJZlRocm91Z2hvdXRU aGVTZWxlY3Rpb24oKSkKICAgICAgICAgc3R5bGVJc1ByZXNlbnQgPSBmcmFtZS0+ZWRpdG9yKCkt PnNlbGVjdGlvblN0YXJ0SGFzU3R5bGUoc3R5bGUuZ2V0KCkpOwogICAgIGVsc2UKICAgICAgICAg c3R5bGVJc1ByZXNlbnQgPSBmcmFtZS0+ZWRpdG9yKCktPnNlbGVjdGlvbkhhc1N0eWxlKHN0eWxl LmdldCgpKSA9PSBUcnVlVHJpU3RhdGU7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvU2Vs ZWN0aW9uQ29udHJvbGxlci5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxl ci5jcHAKaW5kZXggZjliMzliYi4uNWI4NjllNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25D b250cm9sbGVyLmNwcApAQCAtMTY0LDcgKzE2NCw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxl cjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBp CiAgICAgaWYgKHVzZXJUcmlnZ2VyZWQpIHsKICAgICAgICAgU2Nyb2xsQWxpZ25tZW50IGFsaWdu bWVudDsKIAotICAgICAgICBpZiAobV9mcmFtZS0+c2V0dGluZ3MoKSAmJiBtX2ZyYW1lLT5zZXR0 aW5ncygpLT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3IpCisgICAgICAg IGlmIChtX2ZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDZW50ZXJBbGlnbldoZW5T ZWxlY3Rpb25Jc1JldmVhbGVkKCkpCiAgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24gPT0g QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2VudGVy QWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVlZGVkOwogICAgICAgICBl bHNlCiAgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24gPT0gQWxpZ25DdXJzb3JPblNjcm9s bEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9wQWx3YXlzIDogU2Nyb2xsQWxpZ25t ZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOwpAQCAtMjQzLDggKzI0Myw3IEBAIHZvaWQgU2VsZWN0 aW9uQ29udHJvbGxlcjo6bm9kZVdpbGxCZVJlbW92ZWQoTm9kZSAqbm9kZSkKICAgICAKIHZvaWQg U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbChib29sIGlzRGlyZWN0aW9uYWwp CiB7Ci0gICAgU2V0dGluZ3MqIHNldHRpbmdzID0gbV9mcmFtZSA/IG1fZnJhbWUtPnNldHRpbmdz KCkgOiAwOwotICAgIG1faXNEaXJlY3Rpb25hbCA9ICFzZXR0aW5ncyB8fCBzZXR0aW5ncy0+ZWRp dGluZ0JlaGF2aW9yKCkgIT0gRWRpdGluZ01hY0JlaGF2aW9yIHx8IGlzRGlyZWN0aW9uYWw7Cisg ICAgbV9pc0RpcmVjdGlvbmFsID0gIW1fZnJhbWUgfHwgbV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2 aW9yKCkuc2hvdWxkQ29uc2lkZXJNb3VzZVNlbGVjdGlvbkFzRGlyZWN0aW9uYWwoKSB8fCBpc0Rp cmVjdGlvbmFsOwogfQogCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OndpbGxCZU1vZGlmaWVk KEVBbHRlcmF0aW9uIGFsdGVyLCBFRGlyZWN0aW9uIGRpcmVjdGlvbikKQEAgLTI5OCw4ICsyOTcs NyBAQCBUZXh0RGlyZWN0aW9uIFNlbGVjdGlvbkNvbnRyb2xsZXI6OmRpcmVjdGlvbk9mRW5jbG9z aW5nQmxvY2soKQogVmlzaWJsZVBvc2l0aW9uIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnBvc2l0aW9u Rm9yUGxhdGZvcm0oYm9vbCBpc0dldFN0YXJ0KSBjb25zdAogewogICAgIFBvc2l0aW9uIHBvczsK LSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBtX2ZyYW1lID8gbV9mcmFtZS0+c2V0dGluZ3MoKSA6 IDA7Ci0gICAgaWYgKHNldHRpbmdzICYmIHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBF ZGl0aW5nTWFjQmVoYXZpb3IpCisgICAgaWYgKG1fZnJhbWUgJiYgbV9mcmFtZS0+ZWRpdG9yKCkt PmJlaGF2aW9yKCkuc2hvdWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZp Z2F0aW9uKCkpCiAgICAgICAgIHBvcyA9IGlzR2V0U3RhcnQgPyBtX3NlbGVjdGlvbi5zdGFydCgp IDogbV9zZWxlY3Rpb24uZW5kKCk7CiAgICAgZWxzZSB7CiAgICAgICAgIC8vIExpbnV4IGFuZCBX aW5kb3dzIGFsd2F5cyBleHRlbmQgc2VsZWN0aW9ucyBmcm9tIHRoZSBleHRlbnQgZW5kcG9pbnQu CkBAIC02ODUsNyArNjgzLDcgQEAgYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFs dGVyYXRpb24gYWx0ZXIsIEVEaXJlY3Rpb24gZGlyZWN0aW9uLCBUZXh0R3IKICAgICAgICAgbW92 ZVRvKHBvc2l0aW9uLCB1c2VyVHJpZ2dlcmVkKTsKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBB bHRlcmF0aW9uRXh0ZW5kOgotICAgICAgICBpZiAoIXNldHRpbmdzIHx8IHNldHRpbmdzLT5lZGl0 aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nTWFjQmVoYXZpb3IgfHwgbV9zZWxlY3Rpb24uaXNDYXJl dCgpIHx8ICFpc0JvdW5kYXJ5KGdyYW51bGFyaXR5KSkKKyAgICAgICAgaWYgKCFtX2ZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRHcm93U2VsZWN0aW9uV2hlbkV4dGVuZGluZ1RvQm91 bmRhcnkoKSB8fCBtX3NlbGVjdGlvbi5pc0NhcmV0KCkgfHwgIWlzQm91bmRhcnkoZ3JhbnVsYXJp dHkpKQogICAgICAgICAgICAgc2V0RXh0ZW50KHBvc2l0aW9uLCB1c2VyVHJpZ2dlcmVkKTsKICAg ICAgICAgZWxzZSB7CiAgICAgICAgICAgICAvLyBTdGFuZGFyZCBNYWMgYmVoYXZpb3Igd2hlbiBl eHRlbmRpbmcgdG8gYSBib3VuZGFyeSBpcyBncm93IHRoZSBzZWxlY3Rpb24gcmF0aGVyCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1dlYkNvcmUvcGFnZS9FdmVu dEhhbmRsZXIuY3BwCmluZGV4IDFiZjRjMzguLjlhOTBkYjUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3Bw CkBAIC0zNzAsNyArMzcwLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUHJlc3NF dmVudFNpbmdsZUNsaWNrKGNvbnN0IE1vdXNlRXZlbnRXaXRoSGl0VGVzdFIKICAgICAgICAgbV9m cmFtZS0+c2VsZWN0aW9uKCktPnNldElzRGlyZWN0aW9uYWwoZmFsc2UpOwogICAgICAgICAKICAg ICAgICAgQVNTRVJUKG1fZnJhbWUtPnNldHRpbmdzKCkpOwotICAgICAgICBpZiAobV9mcmFtZS0+ c2V0dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKSB7Cisg ICAgICAgIGlmICghbV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkRXh0ZW5kU2Vs ZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKCkpIHsKICAgICAgICAgICAgIC8vIFNlZSA8cmRhcjov L3Byb2JsZW0vMzY2ODE1Nz4gUkVHUkVTU0lPTiAoTWFpbCk6IHNoaWZ0LWNsaWNrIGRlc2VsZWN0 cyB3aGVuIHNlbGVjdGlvbgogICAgICAgICAgICAgLy8gd2FzIGNyZWF0ZWQgcmlnaHQtdG8tbGVm dAogICAgICAgICAgICAgUG9zaXRpb24gc3RhcnQgPSBuZXdTZWxlY3Rpb24uc3RhcnQoKTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuY3BwCmluZGV4IDZmNmJiMDQuLmRkNDBjNDMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMTEzLDcgKzEx Myw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9lbmZvcmNlQ1NT TUlNRVR5cGVJblN0cmljdE1vZGUodHJ1ZSkKICAgICAsIG1fdXNlc0VuY29kaW5nRGV0ZWN0b3Io ZmFsc2UpCiAgICAgLCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGZhbHNlKQotICAgICwg bV9lZGl0aW5nQmVoYXZpb3IoCisgICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5cGUoCiAjaWYgUExB VEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJTikpCiAgICAgICAg IC8vIChQTEFURk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1bSwgaGVuY2UgdGhl IGV4dHJhIGNvbmRpdGlvbi4pCiAgICAgICAgIEVkaXRpbmdNYWNCZWhhdmlvcgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRl eCBkYzNiNTBmLi42YTljMjVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAor KysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjgsNiArMjgsNyBAQAogI2RlZmluZSBT ZXR0aW5nc19oCiAKICNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNpbmNsdWRlICJFZGl0aW5n QmVoYXZpb3JUeXBlcy5oIgogI2luY2x1ZGUgIkZvbnRSZW5kZXJpbmdNb2RlLmgiCiAjaW5jbHVk ZSAiS1VSTC5oIgogI2luY2x1ZGUgIlpvb21Nb2RlLmgiCkBAIC01MCwyMSArNTEsNiBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFRleHREaXJlY3Rpb25TdWJtZW51QWx3YXlzSW5jbHVk ZWQKICAgICB9OwogCi0gICAgLy8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0 aGF0IGFyZSBkaWZmZXJlbnQgb24gV2luZG93cyB0aGFuIE1hY2ludG9zaC4KLSAgICAvLyBXZSB1 c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBleGFtcGxlczoKLSAgICAv LwotICAgIC8vICAgIDEpIENsaWNraW5nIGJlbG93IHRoZSBsYXN0IGxpbmUgb2YgYW4gZWRpdGFi bGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kCi0gICAgLy8gICAgICAgb2YgdGhlIGxh c3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24gV2lu ZG93cy4KLSAgICAvLyAgICAyKSBQdXNoaW5nIHRoZSBkb3duIGFycm93IGtleSBvbiB0aGUgbGFz dCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQgb2YgdGhlCi0gICAgLy8gICAgICAgbGFz dCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWlsYXIgY2Fz ZSBleGlzdHMgb24gdGhlCi0gICAgLy8gICAgICAgdG9wIGxpbmUuCi0gICAgLy8KLSAgICAvLyBU aGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhhdmlv cnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCi0gICAgLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZpZHVh bCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3RlIGFu ZAotICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBkb3VibGUgY2xpY2spIHRoYXQg Y291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCi0gICAgLy8gaWYgcG9zc2libGUgaW4gdGhl IGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7IEVkaXRpbmdNYWNCZWhhdmlvciwg RWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OwotCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJsaWMg Tm9uY29weWFibGUgewogICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSopOwpAQCAt MjcwLDkgKzI1Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRBbGxv d1NjcmlwdHNUb0Nsb3NlV2luZG93cyhib29sKTsKICAgICAgICAgYm9vbCBhbGxvd1NjcmlwdHNU b0Nsb3NlV2luZG93cygpIGNvbnN0IHsgcmV0dXJuIG1fYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRv d3M7IH0KIAotICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVoYXZpb3Ig YmVoYXZpb3IpIHsgbV9lZGl0aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsgfQotICAgICAgICBFZGl0 aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2aW9yKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8 RWRpdGluZ0JlaGF2aW9yPihtX2VkaXRpbmdCZWhhdmlvcik7IH0KLSAgICAgICAgCisgICAgICAg IHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBlIGJlaGF2aW9y KSB7IG1fZWRpdGluZ0JlaGF2aW9yVHlwZSA9IGJlaGF2aW9yOyB9CisgICAgICAgIEVkaXRpbmdC ZWhhdmlvclR5cGUgZWRpdGluZ0JlaGF2aW9yVHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19j YXN0PEVkaXRpbmdCZWhhdmlvclR5cGU+KG1fZWRpdGluZ0JlaGF2aW9yVHlwZSk7IH0KKwogICAg ICAgICB2b2lkIHNldERvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZChib29sKTsKICAgICAg ICAgYm9vbCBkb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoKSBjb25zdCB7IHJldHVybiBt X2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZDsgfQogCkBAIC0zODAsNyArMzY2LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZW5mb3JjZUNTU01JTUVUeXBlSW5T dHJpY3RNb2RlIDogMTsKICAgICAgICAgYm9vbCBtX3VzZXNFbmNvZGluZ0RldGVjdG9yIDogMTsK ICAgICAgICAgYm9vbCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzIDogMTsKLSAgICAgICAg dW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3IgOiAxOworICAgICAgICB1bnNpZ25lZCBtX2VkaXRp bmdCZWhhdmlvclR5cGUgOiAxOwogICAgICAgICBib29sIG1fZG93bmxvYWRhYmxlQmluYXJ5Rm9u dHNFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX3hzc0F1ZGl0b3JFbmFibGVkIDogMTsKICAg ICAgICAgYm9vbCBtX2FjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkIDogMTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckJsb2NrLmNwcAppbmRleCA2ZmJlYTE0Li4wOWVlOWM0IDEwMDY0NAotLS0gYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQmxvY2suY3BwCkBAIC0zNzE4LDE2ICszNzE4LDE1IEBAIFZpc2libGVQb3NpdGlvbiBSZW5k ZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQb2lu dCYKICAgICAgICAgfQogICAgIH0KIAotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50 KCktPnNldHRpbmdzKCk7Ci0gICAgYm9vbCB1c2VXaW5kb3dzQmVoYXZpb3IgPSBzZXR0aW5ncyAm JiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsK KyAgICBib29sIG1vdmVDYXJldFRvQm91bmRhcnkgPSBkb2N1bWVudCgpLT5mcmFtZSgpLT5lZGl0 b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5Q YXN0VG9wT3JCb3R0b20oKTsKIAotICAgIGlmICh1c2VXaW5kb3dzQmVoYXZpb3IgJiYgIWNsb3Nl c3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKKyAgICBpZiAoIW1vdmVDYXJldFRv Qm91bmRhcnkgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKICAg ICAgICAgLy8geSBjb29yZGluYXRlIGlzIGJlbG93IGxhc3Qgcm9vdCBsaW5lIGJveCwgcHJldGVu ZCB3ZSBoaXQgaXQKICAgICAgICAgY2xvc2VzdEJveCA9IGxhc3RSb290Qm94V2l0aENoaWxkcmVu LT5jbG9zZXN0TGVhZkNoaWxkRm9yWFBvcyhwb2ludEluQ29udGVudHMueCgpKTsKICAgICB9CiAK ICAgICBpZiAoY2xvc2VzdEJveCkgewotICAgICAgICBpZiAoIXVzZVdpbmRvd3NCZWhhdmlvciAm JiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9w KCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CisgICAgICAgIGlmIChtb3ZlQ2Fy ZXRUb0JvdW5kYXJ5ICYmIHBvaW50SW5Db250ZW50cy55KCkgPCBmaXJzdFJvb3RCb3hXaXRoQ2hp bGRyZW4tPmxpbmVUb3AoKSAtIHZlcnRpY2FsTGluZUNsaWNrRnVkZ2VGYWN0b3IpIHsKICAgICAg ICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBhYm92ZSBmaXJzdCByb290IGxpbmUgYm94LCBzbyBy ZXR1cm4gdGhlIHN0YXJ0IG9mIHRoZSBmaXJzdAogICAgICAgICAgICAgcmV0dXJuIFZpc2libGVQ b3NpdGlvbihwb3NpdGlvbkZvckJveChmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmZpcnN0TGVh ZkNoaWxkKCksIHRydWUpLCBET1dOU1RSRUFNKTsKICAgICAgICAgfQpAQCAtMzczOCw3ICszNzM3 LDcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElu bGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogCiAgICAgaWYgKGxhc3RSb290Qm94V2l0aENo aWxkcmVuKSB7CiAgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9yIE1hYyBiZWhhdmlvciB3 aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgotICAgICAgICBBU1NF UlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIEFTU0VSVChtb3ZlQ2FyZXRUb0JvdW5k YXJ5KTsKICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChsYXN0 Um9vdEJveFdpdGhDaGlsZHJlbi0+bGFzdExlYWZDaGlsZCgpLCBmYWxzZSksIERPV05TVFJFQU0p OwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggN2JmNTc5MC4uYzE2NzBhNiAxMDA2NDQKLS0tIGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29A d2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91 dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0 byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bwor ICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFk anVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6 CisgICAgICAgIChXZWJLaXQ6OldlYlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToK KwogMjAxMC0wNi0wMSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+ CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjYwNDcwLgpkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4IDk0Njc4MmIuLjdlODlhNzcgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKQEAgLTI3MSw3ICsyNzEsNyBAQCB2b2lk IFdlYlNldHRpbmdzSW1wbDo6c2V0U2hvd0RlYnVnQm9yZGVycyhib29sIHNob3cpCiAKIHZvaWQg V2ViU2V0dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2 aW9yKQogewotICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihzdGF0aWNfY2FzdDxX ZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CisgICAgbV9zZXR0aW5ncy0+c2V0 RWRpdGluZ0JlaGF2aW9yVHlwZShzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JU eXBlPihiZWhhdmlvcikpOwogfQogCiB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0QWNjZWxlcmF0 ZWRDb21wb3NpdGluZ0VuYWJsZWQoYm9vbCBlbmFibGVkKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBkMjk4YjQ4Li44MmQ1NDdl IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtp dG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29k ZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFt ZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmgg dG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0 LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRl LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Y29yZSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHBy aXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAgICh3 ZWJraXRfd2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmll d19zZXR0aW5nc19ub3RpZnkpOgorCiAyMDEwLTA1LTMxICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEg IDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu Y3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKaW5kZXggZDI3NDcwOC4u NzA5ZGM1ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKQEAgLTEyOSw5ICsxMjks OSBAQCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZSkKICAgICByZXR1cm4gUmVzb3VyY2VSZXNwb25zZSgpOwogfQogCi1XZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSkKK1dlYkNv cmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSkK IHsKLSAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcil0eXBlOworICAgIHJldHVy biAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSl0eXBlOwogfQogCiBXZWJLaXRIaXRUZXN0 UmVzdWx0KiBraXQoY29uc3QgV2ViQ29yZTo6SGl0VGVzdFJlc3VsdCYgcmVzdWx0KQpkaWZmIC0t Z2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDA1N2IwZTUuLjZhZWNjMTMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmgKQEAgLTk1LDcgKzk1LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICAg ICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiBy ZXNwb25zZSk7CiAKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0 aW5nQmVoYXZpb3IgdHlwZSk7CisgICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBjb3Jl KFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKIAogICAgIFdlYktpdFNlY3VyaXR5T3JpZ2lu KiBraXQoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qKTsKICAgICBXZWJDb3JlOjpTZWN1cml0eU9y aWdpbiogY29yZShXZWJLaXRTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmNwcAppbmRleCA5MTM1NGZkLi4xODQ4MjQ1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmNwcApAQCAtMjY5NSw3ICsyNjk1LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3 X3VwZGF0ZV9zZXR0aW5ncyhXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQogICAgIHNldHRpbmdzLT5z ZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5KGphdmFzY3JpcHRDYW5PcGVu V2luZG93cyk7CiAgICAgc2V0dGluZ3MtPnNldEphdmFTY3JpcHRDYW5BY2Nlc3NDbGlwYm9hcmQo amF2YVNjcmlwdENhbkFjY2Vzc0NsaXBib2FyZCk7CiAgICAgc2V0dGluZ3MtPnNldE9mZmxpbmVX ZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChlbmFibGVPZmZsaW5lV2ViQXBwQ2FjaGUpOwotICAg IHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsKKyAg ICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKGVkaXRpbmdCZWhhdmlvcikp OwogICAgIHNldHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhlbmFi bGVVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSSSk7CiAgICAgc2V0dGluZ3MtPnNldEFsbG93Rmls ZUFjY2Vzc0Zyb21GaWxlVVJMcyhlbmFibGVGaWxlQWNjZXNzRnJvbUZpbGVVUkkpOwogICAgIHNl dHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoZW5hYmxlRE9NUGFzdGUpOwpAQCAtMjc5Niw3ICsy Nzk2LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeShXZWJL aXRXZWJTZXR0aW5ncyogd2ViU2V0dGluZ3MsIEdQYXIKICAgICBlbHNlIGlmIChuYW1lID09IGdf aW50ZXJuX3N0cmluZygiZW5hYmxlLW9mZmxpbmUtd2ViLWFwcGxpY2F0aW9uLWNhY2hlIikpCiAg ICAgICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQoZ192 YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50ZXJu X3N0cmluZygiZWRpdGluZy1iZWhhdmlvciIpKQotICAgICAgICBzZXR0aW5ncy0+c2V0RWRpdGlu Z0JlaGF2aW9yKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0JlaGF2aW9yPihnX3ZhbHVl X2dldF9lbnVtKCZ2YWx1ZSkpKSk7CisgICAgICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZp b3JUeXBlKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0JlaGF2aW9yPihnX3ZhbHVlX2dl dF9lbnVtKCZ2YWx1ZSkpKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmco ImVuYWJsZS11bml2ZXJzYWwtYWNjZXNzLWZyb20tZmlsZS11cmlzIikpCiAgICAgICAgIHNldHRp bmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhnX3ZhbHVlX2dldF9ib29s ZWFuKCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlbmFi bGUtZmlsZS1hY2Nlc3MtZnJvbS1maWxlLXVyaXMiKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMv Q2hhbmdlTG9nIGIvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggN2Q4OGZlZC4uMzcwZjZkOCAx MDA2NDQKLS0tIGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L21hYy9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRv b0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUg b3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVk IHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRv CisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8g YWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJWaWV3L1dlYkZyYW1lLm1tOgor ICAgICAgICAoY29yZSk6CisgICAgICAgICogV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmg6Cisg ICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOgorICAgICAgICAoLVtXZWJWaWV3IF9wcmVmZXJl bmNlc0NoYW5nZWROb3RpZmljYXRpb246XSk6CisKIDIwMTAtMDUtMzAgIERhcmluIEFkbGVyICA8 ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCmRpZmYg LS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5ZjE3Ny4uN2M1OTYxNSAxMDA2NDQKLS0tIGEvV2ViS2l0 L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFt ZS5tbQpAQCAtMTk2LDcgKzE5Niw3IEBAIEVkaXRhYmxlTGlua0JlaGF2aW9yIGNvcmUoV2ViS2l0 RWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZpb3IpCiAgICAgcmV0dXJuIEVk aXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9y IGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQorV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKICAgICBz d2l0Y2ggKGJlaGF2aW9yKSB7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ01hY0JlaGF2aW9y OgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCBiL1dl YktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKaW5kZXggOWIyMjQ4YS4uNTg2YjRj MyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaAorKysg Yi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCkBAIC03MSw3ICs3MSw3IEBA IFdlYlZpZXcgKmtpdChXZWJDb3JlOjpQYWdlKik7CiAKIFdlYkNvcmU6OkVkaXRhYmxlTGlua0Jl aGF2aW9yIGNvcmUoV2ViS2l0RWRpdGFibGVMaW5rQmVoYXZpb3IpOwogV2ViQ29yZTo6VGV4dERp cmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciBjb3JlKFdlYlRleHREaXJlY3Rpb25TdWJt ZW51SW5jbHVzaW9uQmVoYXZpb3IpOwotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2Vi S2l0RWRpdGluZ0JlaGF2aW9yKTsKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShX ZWJLaXRFZGl0aW5nQmVoYXZpb3IpOwogCiBXZWJWaWV3ICpnZXRXZWJWaWV3KFdlYkZyYW1lICp3 ZWJGcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tIGIv V2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KaW5kZXggOTdjNzk5Yi4uOWYzYWQ2MCAxMDA2 NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KKysrIGIvV2ViS2l0L21hYy9X ZWJWaWV3L1dlYlZpZXcubW0KQEAgLTEzNjksNyArMTM2OSw3IEBAIHN0YXRpYyBib29sIGZhc3RE b2N1bWVudFRlYXJkb3duRW5hYmxlZCgpCiAgICAgc2V0dGluZ3MtPnNldFRleHRBcmVhc0FyZVJl c2l6YWJsZShbcHJlZmVyZW5jZXMgdGV4dEFyZWFzQXJlUmVzaXphYmxlXSk7CiAgICAgc2V0dGlu Z3MtPnNldFNocmlua3NTdGFuZGFsb25lSW1hZ2VzVG9GaXQoW3ByZWZlcmVuY2VzIHNocmlua3NT dGFuZGFsb25lSW1hZ2VzVG9GaXRdKTsKICAgICBzZXR0aW5ncy0+c2V0RWRpdGFibGVMaW5rQmVo YXZpb3IoY29yZShbcHJlZmVyZW5jZXMgZWRpdGFibGVMaW5rQmVoYXZpb3JdKSk7Ci0gICAgc2V0 dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyBlZGl0aW5nQmVoYXZp b3JdKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoY29yZShbcHJlZmVy ZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5zZXRUZXh0RGlyZWN0aW9u U3VibWVudUluY2x1c2lvbkJlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIHRleHREaXJlY3Rpb25T dWJtZW51SW5jbHVzaW9uQmVoYXZpb3JdKSk7CiAgICAgc2V0dGluZ3MtPnNldERPTVBhc3RlQWxs b3dlZChbcHJlZmVyZW5jZXMgaXNET01QYXN0ZUFsbG93ZWRdKTsKICAgICBzZXR0aW5ncy0+c2V0 VXNlc1BhZ2VDYWNoZShbc2VsZiB1c2VzUGFnZUNhY2hlXSk7CmRpZmYgLS1naXQgYS9XZWJLaXQv cXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCA5YTVkNWFjLi42NGUzNTM4 IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRv b0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUg b3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVk IHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRv CisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8g YWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9EdW1wUmVu ZGVyVHJlZVN1cHBvcnRRdC5jcHA6CisgICAgICAgIChEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6 c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0wNi0wMSAgU2ltb24gSGF1c21hbm4gIDxzaW1v bi5oYXVzbWFubkBub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTGFzemxvIEdvbWJv cy4KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1 cHBvcnRRdC5jcHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwCmluZGV4IDBiMmU5YTUuLmE5NTFhNDkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9X ZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0 L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcApAQCAtNDc2LDcgKzQ3 Niw3IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmVsZW1lbnREb2VzQXV0b0NvbXBs ZXRlRm9yRWxlbWVudFdpdGhJZChRV2ViRnJhbWUqCiAKIHZvaWQgRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmluZyYg ZWRpdGluZ0JlaGF2aW9yKQogewotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlRWRp dGluZ0JlaGF2aW9yOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZUVkaXRp bmdCZWhhdmlvcjsKIAogICAgIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIndpbiIpCiAgICAgICAg IGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOwpAQCAtNDg3LDcg KzQ4Nyw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlv cihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmluZyYKICAgICBpZiAoIWNvcmVQYWdlKQogICAg ICAgICByZXR1cm47CiAKLSAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2 aW9yKGNvcmVFZGl0aW5nQmVoYXZpb3IpOworICAgIGNvcmVQYWdlLT5zZXR0aW5ncygpLT5zZXRF ZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmVFZGl0aW5nQmVoYXZpb3IpOwogfQogCiB2b2lkIER1bXBS ZW5kZXJUcmVlU3VwcG9ydFF0OjpkdW1wRnJhbWVMb2FkZXIoYm9vbCBiKQpkaWZmIC0tZ2l0IGEv V2ViS2l0L3dpbi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwppbmRleCAyOTc5NTU2 Li4yZWI2ODMyIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0NoYW5nZUxvZworKysgYi9XZWJLaXQv d2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVz ICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVo YXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0g d2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNl dHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMg aW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIFdlYlZpZXcuY3Bw OgorICAgICAgICAoV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKToKKwogMjAxMC0w NS0zMCAgRGFuaWVsIEJhdGVzICA8ZGJhdGVzQHJpbS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgYXR0ZW1wdCB0byBmaXggdGhlIGJ1aWxkIGFmdGVyIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcv Y2hhbmdlc2V0LzYwNDE4LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBiL1dl YktpdC93aW4vV2ViVmlldy5jcHAKaW5kZXggNTI1MTA4Zi4uYmE1YmY0NCAxMDA2NDQKLS0tIGEv V2ViS2l0L3dpbi9XZWJWaWV3LmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBAIC00 NjU0LDcgKzQ2NTQsNyBAQCBIUkVTVUxUIFdlYlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdl ZChJV2ViTm90aWZpY2F0aW9uKiBub3RpZmljYXRpb24pCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ ZWRpdGluZ0JlaGF2aW9yKCZlZGl0aW5nQmVoYXZpb3IpOwogICAgIGlmIChGQUlMRUQoaHIpKQog ICAgICAgICByZXR1cm4gaHI7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcigoRWRp dGluZ0JlaGF2aW9yKWVkaXRpbmdCZWhhdmlvcik7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdC ZWhhdmlvclR5cGUoKEVkaXRpbmdCZWhhdmlvclR5cGUpZWRpdGluZ0JlaGF2aW9yKTsKIAogICAg IGhyID0gcHJlZmVyZW5jZXMtPnVzZXNQYWdlQ2FjaGUoJmVuYWJsZWQpOwogICAgIGlmIChGQUlM RUQoaHIpKQotLSAKMS43LjAuNAoK 57550 2010-06-01 08:56:12 -0700 2010-06-04 14:37:33 -0700 patch v2.2 - same as v2, but really builds on Mac 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 41029 tonikitoo RnJvbSBlYzc0MTEzMjBkZTEzNjYzZTUwOTY2ZDg3Mzc2OGU3ZjUwNzAwYTMzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAzMSBNYXkgMjAxMCAxNTo1NDo1NSAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpQYXRjaCBieSBBbnRvbmlvIEdvbWVzIDx0b25pa2l0 b29Ad2Via2l0Lm9yZz4KCldlYkNvcmU6CgpBcyBwZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2Mjcs IHRoZSBmb2xsb3dpbmcgd2FzIHN1Z2dlc3RlZCBieSBEYXJpbiBBZGxlcjogImJlZm9yZSB0aGUg YWRkaXRpb24gb2YgYW55Cm5ldyBFZGl0aW5nQmVoYXZpb3IsIEkgdGhpbmsgd2UgbmVlZCB0byBh ZGQgZnVuY3Rpb25zIHRvIHRyYW5zbGF0ZSB0aGUgb3ZlcmFsbCBiZWhhdmlvciBwb2xpY3kgaW50 byBzcGVjaWZpYwpiZWhhdmlvcnMgcmF0aGVyIHRoYW4gZGlyZWN0bHkgc2F5aW5nICdiZWhhdmlv ciA9PSBNYWMnIG9yICdiZWhhdmlvciA9PSBXaW5kb3dzJy4gSGVscGVyIGZ1bmN0aW9ucyB0aGF0 CmV4cHJlc3Npb24gdGhlIGRpZmZlcmVudCBydWxlcyBpbiBwbGFpbiBsYW5ndWFnZS4iLgoKUGF0 Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KCk5vIGJlaGF2aW9yIGNoYW5nZSwgc28gbm8gbmV3 IHRlc3RzLgoKKiBHTlVtYWtlZmlsZS5hbToKKiBXZWJDb3JlLnBybzoKKiBXZWJDb3JlL1dlYkNv cmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCiogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKKiBwYWdlL1NldHRpbmdzLmNwcDoKKFdlYkNvcmU6OlNldHRpbmdzOjpTZXR0 aW5ncyk6CiogcGFnZS9TZXR0aW5ncy5oOiBNb3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0g dG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgsCmFuZCByZW5hbWVkIHRv IEVkaXRpbmdCZWhhdmlvclR5cGVzLgooV2ViQ29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhh dmlvclR5cGUpOiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9yLgooV2ViQ29yZTo6U2V0 dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9y LgoqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6IEFkZGVkLgooV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBDbGFzcyB0byB3b3JrIGFzIGEgY2VudHJhbCBwb2lu dCBmb3IKZWRpdGluZyBiZWhhdmlvciB0aGF0IG1pZ2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZm ZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBsYXRmb3Jtcy9wb3J0cy4KQ2xhc3Mgc2hvdWxkIGJl IG5vdCB1c2VkIG9yIGluc3RhbnRpYXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5 IGNvbnN0cnVjdGVkCnRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9y Qm90dG9tKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxpZ25XaGVu U2VsZWN0aW9uSXNSZXZlYWxlZCk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZENv bnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0 aW9uKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJv bUVuZFBvaW50QWx3YXlzKToKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFy ZFNlbGVjdGlvbkV4dGVuZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKFdlYkNvcmU6OkVkaXRp bmdCZWhhdmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToK KiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgooV2ViQ29yZTo6KToKKiBl ZGl0aW5nL0VkaXRvci5jcHA6CihXZWJDb3JlOjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZv ciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCiogZWRpdGluZy9FZGl0b3IuaDoKKiBlZGl0aW5nL0Vk aXRvckNvbW1hbmQuY3BwOgooV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgooV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6 c2V0U2VsZWN0aW9uKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0 aW9uYWwpOgooV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9y bSk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgoqIHBhZ2UvRXZlbnRI YW5kbGVyLmNwcDoKKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50 U2luZ2xlQ2xpY2spOgoqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CihXZWJDb3JlOjpSZW5k ZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbik6CgotIENhbGwgc2l0 ZXMgd2lsbCBsb29rIGxpa2U6CmlmIChmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxk VGhpc0lmVGhhdCgpKSkKICAgLy8gZG8gc29tZXRoaW5nCgpXZWJLaXQ6CgpFZGl0aW5nQmVoYXZp b3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0 IGZyb20gU2V0dGluZ3MuaCB0bwpFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBp biBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgoKV2ViS2l0L2Nocm9taXVtOgoqIHNyYy9X ZWJTZXR0aW5nc0ltcGwuY3BwOgooV2ViS2l0OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdC ZWhhdmlvcik6CgpXZWJLaXQvZ3RrOgoqIHdlYmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKFdlYktp dDo6Y29yZSk6Ciogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKiB3ZWJraXQvd2Via2l0d2Vidmll dy5jcHA6Cih3ZWJraXRfd2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKToKKHdlYmtpdF93ZWJfdmll d19zZXR0aW5nc19ub3RpZnkpOgoKV2ViS2l0L21hYzoKKiBXZWJWaWV3L1dlYkZyYW1lLm1tOgoo Y29yZSk6CiogV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmg6CiogV2ViVmlldy9XZWJWaWV3Lm1t OgooLVtXZWJWaWV3IF9wcmVmZXJlbmNlc0NoYW5nZWROb3RpZmljYXRpb246XSk6CgpXZWJLaXQv cXQ6CiogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwOgooRHVtcFJl bmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcik6CgpXZWJLaXQvd2luOgoqIFdl YlZpZXcuY3BwOgooV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKToKLS0tCiBXZWJD b3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNTUgKysr KysrKysrKysrKysrKysrKysKIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL1dlYkNvcmUuZ3lwaSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2ogICAgICAgICAgICAgIHwgICAgOCArKysKIFdlYkNvcmUvV2ViQ29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qICAgICAgICAgIHwgICAgOCArKysKIFdlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAgICAgIHwgICA1MiArKysrKysrKysrKysr KysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oICAgICAgICAgICAg IHwgICA0NiArKysrKysrKysrKysrKysrCiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMTAgKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5o ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAzICsKIFdlYkNvcmUvZWRpdGluZy9FZGl0 b3JDb21tYW5kLmNwcCAgICAgICAgICAgICAgICAgIHwgICAgMyArLQogV2ViQ29yZS9lZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAgICAgfCAgIDEwICsrLS0KIFdlYkNvcmUv cGFnZS9FdmVudEhhbmRsZXIuY3BwICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICst CiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg MjQgKystLS0tLS0tCiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgICAgICAgICAg ICAgICAgICB8ICAgIDkgKystLQogV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRp bmdzSW1wbC5jcHAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9ndGsvQ2hhbmdlTG9nICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNyArKysrKysKIFdlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAgICAgIHwgICAgNCArLQogV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCAgICAgICAgICAgICAgICB8ICAgIDQgKy0K IFdlYktpdC9tYWMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAx NiArKysrKysKIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbSAgICAgICAgICAgICAgICAg ICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCAgICAg ICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSAgICAgICAg ICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9xdC9DaGFuZ2VMb2cgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysrKwogLi4uL3F0L1dlYkNvcmVTdXBwb3J0L0R1 bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCAgfCAgICA0ICstCiBXZWJLaXQvd2luL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysKIFdlYktpdC93aW4v V2ViVmlldy5jcHAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogMzAgZmls ZXMgY2hhbmdlZCwgMjg3IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAogY3JlYXRlIG1vZGUg MTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0ODA1ZjIzLi44 Y2NjN2ZjIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDU4IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtp dG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29k ZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgQXMgcGVyIGRpc2N1c3Npb24gaW4gYnVnIDM2NjI3 LCBEYXJpbiBBZGxlciBzdWdnZXN0ZWQ6ICJiZWZvcmUgdGhlIGFkZGl0aW9uIG9mIGFueSBuZXcg RWRpdGluZ0JlaGF2aW9yLAorICAgICAgICBJIHRoaW5rIHdlIHRvIGFkZCBmdW5jdGlvbnMgdG8g dHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRvIHNwZWNpZmljIGJlaGF2 aW9ycyByYXRoZXIgdGhhbgorICAgICAgICBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9yID09IE1h Yycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQgZXhwcmVz c2lvbiB0aGUgZGlmZmVyZW50CisgICAgICAgIHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuIFBh dGNoIGFkZHJlc3NlcyB0aGlzIHJlcXVlc3QuCisKKyAgICAgICAgTm8gYmVoYXZpb3IgY2hhbmdl LCBzbyBubyBuZXcgdGVzdHMuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAg KiBXZWJDb3JlLnBybzoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlNldHRpbmdzOjpTZXR0aW5ncyk6CisgICAgICAgICogcGFnZS9TZXR0aW5ncy5oOiBN b3ZlZCBvdXQgRWRpdGluZ0JlaGF2aW9yIGVudW0gdG8gV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmgsCisgICAgICAgIGFuZCByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5 cGVzLgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OnNldEVkaXRpbmdCZWhhdmlvclR5cGUp OiBSZW5hbWVkIGZyb20gc2V0RWRpdGluZ0JlaGF2aW9yLgorICAgICAgICAoV2ViQ29yZTo6U2V0 dGluZ3M6OmVkaXRpbmdCZWhhdmlvclR5cGUpOiBSZW5hbWVkIGZyb20gZWRpdGluZ0JlaGF2aW9y LgorICAgICAgICAqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpFZGl0aW5nQmVoYXZpb3IpOiBDbGFzcyB0byB3b3Jr IGFzIGEgY2VudHJhbCBwb2ludCBmb3IKKyAgICAgICAgZWRpdGluZyBiZWhhdmlvciB0aGF0IG1p Z2h0IGhhdmUgdG8gYmUgaGFuZGxlZCBkaWZmZXJlbnRseSBpbiB0aGUgZGlmZmVyZW50IHBsYXRm b3Jtcy9wb3J0cy4KKyAgICAgICAgQ2xhc3Mgc2hvdWxkIGJlIG5vdCB1c2VkIG9yIGluc3RhbnRp YXRlZCBkaXJlY3RseSwgYnV0IHJhdGhlciBpbXBsaWNpdGx5IGNvbnN0cnVjdGVkCisgICAgICAg IHRocm91Z2ggdGhlIEVkaXRvciBjbGFzcy4KKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90 dG9tKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ2VudGVyQWxp Z25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCk6CisgICAgICAgIChXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRP bmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkRXh0ZW5kU2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKToKKyAgICAg ICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkS2V5YmFyZFNlbGVjdGlvbkV4dGVu ZEZvckhvcml6b250YWxOYXZpZ2F0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkR3Jvd1NlbGVjdGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KToKKyAgICAg ICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisg ICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNvbW1h bmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAg KiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2Vs ZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVj dGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6U2Vs ZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3Jl OjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVz c0V2ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxp bmVDaGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBsaWtlOgorICAg ICAgICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJZlRoYXQoKSkp CisgICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAyMDEwLTA1LTMwICBBbnRvbmlvIEdvbWVz ICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVt YWtlZmlsZS5hbQppbmRleCBmYzZiODE4Li4xZGE5NzhiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dO VW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgs OCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0QWN0aW9uLmgg XAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9F ZGl0Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAorCVdl YkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIFwKIAlXZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkg Yi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBjNjZhMzJiLi5hYzBjYmQ5IDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5 MSw2ICsxMjkxLDggQEAKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAg ICAgICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcv RWRpdENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCcs CisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oJywKICAgICAgICAg ICAgICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgn LAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODcyN2I3OS4u Yzc0NmIzYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dl YkNvcmUucHJvCkBAIC0xMjc5LDYgKzEyNzksNyBAQCBIRUFERVJTICs9IFwKICAgICBlZGl0aW5n L0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rp b25Db21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisgICAgZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9FZGl0b3IuaCBcCiAgICAgZWRpdGluZy9G b3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9odG1sZWRpdGluZy5oIFwKZGlmZiAt LWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dl YkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGY2ZjQ5NjYuLmJkMzU2ZTkgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29y ZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMzA0NDksNiArMzA0NDksMTQgQEAK IAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRp dGluZ1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0K KwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCINCisJ CQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRp bmdcRWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3Jl L1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDljODI1ZDQuLmE3ZmUyNWIgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMDE2LDYgKzEwMTYsOCBAQAog CQk0RTE5NTkyRTBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEUxOTU5MjgwQTM5REFDQzAwMjIw RkU1IC8qIE1lZGlhUXVlcnlFeHAuaCAqLzsgfTsKIAkJNEYzMjg5QjUxMUE0MkFBQjAwNUFCRTdF IC8qIEluc3BlY3RvclZhbHVlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVz LmNwcCAqLzsgfTsKIAkJNEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVl cy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYzMjg5 QjQxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTRGMTUzNERFMTFCNTMyRUMwMDIxRkQ4 NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3Iu aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0RjE1 MzRFMDExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMTUzNERGMTFCNTMzMDIwMDIx RkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCTRGRDhEMEYyMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3Jp cHRHQ0V2ZW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDRGRDhEMEYwMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCAqLzsgfTsK IAkJNEZEOEQwRjMxMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhEMEYxMTE5QzcxOEIwMDJG QTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmggKi87IH07CiAJCTUxMDE4NDY5MEIwODYwMkEwMDRBODI1 RiAvKiBDYWNoZWRQYWdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICovOyBzZXR0 aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC02NjQwLDYgKzY2NDIs OCBAQAogCQk0RTE5NTkyODBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTWVkaWFRdWVyeUV4cC5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9y VmFsdWVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEluc3BlY3Rv clZhbHVlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGMzI4OUI0MTFBNDJB QUIwMDVBQkU3RSAvKiBJbnNwZWN0b3JWYWx1ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gSW5zcGVjdG9yVmFsdWVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CTRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRWRpdGluZ0JlaGF2aW9yLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCTRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZp b3JUeXBlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFZGl0aW5nQmVoYXZp b3JUeXBlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0RkQ4RDBGMDExOUM3MThC MDAyRkE4MjUgLyogU2NyaXB0R0NFdmVudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBTY3JpcHRHQ0V2ZW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJNEZEOEQwRjExMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU2NyaXB0R0NFdmVudC5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDYWNoZWRQYWdlLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CkBAIC0xMzIxOSw2ICsxMzIyMyw4IEBACiAJCTkzMzA5RDg2MDk5RTY0 OTEwMDU2RTU4MSAvKiBlZGl0aW5nICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGls ZHJlbiA9ICgKKwkJCQk0RjE1MzRERjExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9y VHlwZXMuaCAqLywKKwkJCQk0RjE1MzRERDExQjUzMkVDMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2 aW9yLmggKi8sCiAJCQkJRUQ1MDFEQzkwQjI0OUYzOTAwQUUxOEQ5IC8qIG1hYyAqLywKIAkJCQk5 MzMwOUQ4NzA5OUU2NDkxMDA1NkU1ODEgLyogQXBwZW5kTm9kZUNvbW1hbmQuY3BwICovLAogCQkJ CTkzMzA5RDg4MDk5RTY0OTEwMDU2RTU4MSAvKiBBcHBlbmROb2RlQ29tbWFuZC5oICovLApAQCAt MTk0MTUsNiArMTk0MjEsOCBAQAogCQkJCUM1MURBOUE5MTFBRUYyQzEwMDk3OTlDNSAvKiBJREJJ bmRleFJlcXVlc3QuaCBpbiBIZWFkZXJzICovLAogCQkJCUM1QkJDOUQxMTFBRUY4MzgwMDdDMkJG RSAvKiBKU0lEQkluZGV4UmVxdWVzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNEYzMjg5QjYxMUE0 MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oIGluIEhlYWRlcnMgKi8sCisJCQkJNEYx NTM0REUxMUI1MzJFQzAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvci5oIGluIEhlYWRlcnMgKi8s CisJCQkJNEYxNTM0RTAxMUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5cGVzLmgg aW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNz aW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3IuaCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi5kNzhlOWEwCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCkBAIC0wLDAgKzEsNTIgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMp CisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwg b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8K KyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVl dCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisj aWZuZGVmIEVkaXRpbmdCZWhhdmlvcl9oCisjZGVmaW5lIEVkaXRpbmdCZWhhdmlvcl9oCisKKyNp bmNsdWRlICJFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K2NsYXNzIEVkaXRpbmdCZWhhdmlvciB7CisKK3B1YmxpYzoKKyAgICBFZGl0aW5nQmVoYXZpb3Io RWRpdGluZ0JlaGF2aW9yVHlwZSB0eXBlKQorICAgICAgICA6IG1fdHlwZSh0eXBlKQorICAgIHsK KyAgICB9CisKKyAgICAvLyBJbmRpdmlkdWFsIGZ1bmN0aW9ucyBmb3IgZWFjaCBjYXNlIHdoZXJl IHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBzdHlsZSBvZiBlZGl0aW5nIGJlaGF2aW9yLgorICAgIC8v IENyZWF0ZSBhIG5ldyBmdW5jdGlvbiBmb3IgYW55IHBsYXRmb3JtIGRpZmZlcmVuY2Ugc28gd2Ug Y2FuIGNvbnRyb2wgaXQgaGVyZS4KKyAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRh bEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAhPSBF ZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRDZW50ZXJBbGlnbldoZW5T ZWxlY3Rpb25Jc1JldmVhbGVkKCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdNYWNC ZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkQ29uc2lkZXJNb3VzZVNlbGVjdGlvbkFzRGlyZWN0 aW9uYWwoKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9Cisg ICAgYm9vbCBzaG91bGRDb25zaWRlclN0eWxlUHJlc2VudE9ubHlJZlRocm91Z2hvdXRUaGVTZWxl Y3Rpb24oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9Cisg ICAgYm9vbCBzaG91bGRFeHRlbmRTZWxlY3Rpb25Gcm9tRW5kUG9pbnRBbHdheXMoKSBjb25zdCB7 IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRL ZXliYXJkU2VsZWN0aW9uRXh0ZW5kRm9ySG9yaXpvbnRhbE5hdmlnYXRpb24oKSBjb25zdCB7IHJl dHVybiBtX3R5cGUgPT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRHcm93 U2VsZWN0aW9uV2hlbkV4dGVuZGluZ1RvQm91bmRhcnkoKSBjb25zdCB7IHJldHVybiBtX3R5cGUg PT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisKK3ByaXZhdGU6CisgICAgRWRpdGluZ0JlaGF2aW9y VHlwZSBtX3R5cGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBF ZGl0aW5nQmVoYXZpb3JfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhh dmlvclR5cGVzLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yNmJhMThlCi0tLSAvZGV2L251bGwKKysr IGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKQEAgLTAsMCArMSw0NiBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRz IHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl CisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAg SWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwg NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgorICovCisKKyNpZm5kZWYgRWRpdGluZ0JlaGF2aW9yVHlwZXNfaAorI2RlZmluZSBF ZGl0aW5nQmVoYXZpb3JUeXBlc19oCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8gVGhlcmUg YXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQgb24gV2luZG93 cyB0aGFuIE1hY2ludG9zaC4KKy8vIFdlIHVzZSBhIHNpbmdsZSBzd2l0Y2ggZm9yIGFsbCBvZiB0 aGVtLiBTb21lIGV4YW1wbGVzOgorLy8KKy8vICAgIDEpIENsaWNraW5nIGJlbG93IHRoZSBsYXN0 IGxpbmUgb2YgYW4gZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kCisvLyAg ICAgICBvZiB0aGUgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGluIHRoZSBtaWRkbGUgb2YgdGhlIGxh c3QgbGluZSBvbiBXaW5kb3dzLgorLy8gICAgMikgUHVzaGluZyB0aGUgZG93biBhcnJvdyBrZXkg b24gdGhlIGxhc3QgbGluZSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kIG9mIHRoZQorLy8gICAg ICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWls YXIgY2FzZSBleGlzdHMgb24gdGhlCisvLyAgICAgICB0b3AgbGluZS4KKy8vCisvLyBUaGlzIHNl dHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhhdmlvcnMuIFRo ZXJlIGFyZSBzb21lIG90aGVyCisvLyBiZWhhdmlvcnMgd2l0aCBpbmRpdmlkdWFsIGZ1bmN0aW9u IGNhbGxzIG9uIEVkaXRvckNsaWVudCAoc21hcnQgY29weSBhbmQgcGFzdGUgYW5kCisvLyBzZWxl Y3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNvdWxkIGJlIGNvbWJp bmVkIHdpdGggdGhpcyBpZgorLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KK2VudW0gRWRp dGluZ0JlaGF2aW9yVHlwZSB7CisgICAgRWRpdGluZ01hY0JlaGF2aW9yLAorICAgIEVkaXRpbmdX aW5kb3dzQmVoYXZpb3IKK307CisKK30gLy8gV2ViQ29yZSBuYW1lc3BhY2UKKworI2VuZGlmIC8v IEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggODA0MTE1OS4uNTg5MzQy MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKKysrIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5jcHAKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlICJSZW5kZXJCbG9j ay5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJSZXBsYWNlU2VsZWN0aW9u Q29tbWFuZC5oIgorI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiU291bmQuaCIKICNp bmNsdWRlICJUZXh0LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCkBAIC05Nyw2ICs5OCwx NSBAQCBWaXNpYmxlU2VsZWN0aW9uIEVkaXRvcjo6c2VsZWN0aW9uRm9yQ29tbWFuZChFdmVudCog ZXZlbnQpCiAgICAgcmV0dXJuIHNlbGVjdGlvbjsKIH0KIAorLy8gRnVuY3Rpb24gY29uc2lkZXJz IE1hYyBlZGl0aW5nIGJlaGF2aW9yIGEgZmFsbGJhY2sgd2hlbiBQYWdlIG9yIFNldHRpbmdzIGlz IG5vdCBhdmFpbGFibGUuCitFZGl0aW5nQmVoYXZpb3IgRWRpdG9yOjpiZWhhdmlvcigpIGNvbnN0 Cit7CisgICAgaWYgKCFtX2ZyYW1lIHx8ICFtX2ZyYW1lLT5wYWdlKCkgfHwgIW1fZnJhbWUtPnNl dHRpbmdzKCkpCisgICAgICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ01hY0JlaGF2 aW9yKTsKKworICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IobV9mcmFtZS0+c2V0dGluZ3MoKS0+ ZWRpdGluZ0JlaGF2aW9yVHlwZSgpKTsKK30KKwogRWRpdG9yQ2xpZW50KiBFZGl0b3I6OmNsaWVu dCgpIGNvbnN0CiB7CiAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBtX2ZyYW1lLT5wYWdlKCkpCmRpZmYg LS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9y LmgKaW5kZXggMTdkZDNiYi4uM2UyMjNkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0Vk aXRvci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMjksNiArMjksNyBAQAog I2luY2x1ZGUgIkNsaXBib2FyZEFjY2Vzc1BvbGljeS5oIgogI2luY2x1ZGUgIkNvbG9yLmgiCiAj aW5jbHVkZSAiRWRpdEFjdGlvbi5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgogI2lu Y2x1ZGUgIkVkaXRvckRlbGV0ZUFjdGlvbi5oIgogI2luY2x1ZGUgIkVkaXRvckluc2VydEFjdGlv bi5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIKQEAgLTI4MSw2ICsyODIsOCBA QCBwdWJsaWM6CiAKICAgICBLaWxsUmluZyoga2lsbFJpbmcoKSBjb25zdCB7IHJldHVybiBtX2tp bGxSaW5nLmdldCgpOyB9CiAKKyAgICBFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IoKSBjb25zdDsK KwogICAgIFBhc3NSZWZQdHI8UmFuZ2U+IHNlbGVjdGVkUmFuZ2UoKTsKICAgICAKICAgICAvLyBX ZSBzaG91bGQgbWFrZSB0aGVzZSBmdW5jdGlvbnMgcHJpdmF0ZSB3aGVuIHRoZWlyIGNhbGxlcnMg aW4gRnJhbWUgYXJlIG1vdmVkIG92ZXIgaGVyZSB0byBFZGl0b3IKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcAppbmRleCA3NTA4NWZiLi42NmNkN2JlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwCkBAIC0xNjQsOSArMTY0LDggQEAgc3RhdGljIGJvb2wgZXhlY3V0ZVRvZ2dsZVN0eWxlKEZy YW1lKiBmcmFtZSwgRWRpdG9yQ29tbWFuZFNvdXJjZSBzb3VyY2UsIEVkaXRBY3QKICAgICAvLyBT dHlsZSBpcyBjb25zaWRlcmVkIHByZXNlbnQgd2hlbgogICAgIC8vIG1hYzogcHJlc2VudCBhdCB0 aGUgYmVnaW5uaW5nIG9mIHNlbGVjdGlvbgogICAgIC8vIG90aGVyOiBwcmVzZW50IHRocm91Z2hv dXQgdGhlIHNlbGVjdGlvbgotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGZyYW1lLT5kb2N1bWVu dCgpLT5zZXR0aW5ncygpOwogICAgIGJvb2wgc3R5bGVJc1ByZXNlbnQ7Ci0gICAgaWYgKHNldHRp bmdzICYmIHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3Ip CisgICAgaWYgKCFmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkQ29uc2lkZXJTdHls ZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKCkpCiAgICAgICAgIHN0eWxlSXNQ cmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25TdGFydEhhc1N0eWxlKHN0eWxlLmdl dCgpKTsKICAgICBlbHNlCiAgICAgICAgIHN0eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigp LT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5nZXQoKSkgPT0gVHJ1ZVRyaVN0YXRlOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwIGIvV2ViQ29yZS9l ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IGY5YjM5YmIuLjViODY5ZTUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAorKysgYi9X ZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKQEAgLTE2NCw3ICsxNjQsNyBA QCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2Vs ZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaQogICAgIGlmICh1c2VyVHJpZ2dlcmVkKSB7CiAgICAg ICAgIFNjcm9sbEFsaWdubWVudCBhbGlnbm1lbnQ7CiAKLSAgICAgICAgaWYgKG1fZnJhbWUtPnNl dHRpbmdzKCkgJiYgbV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRp dGluZ01hY0JlaGF2aW9yKQorICAgICAgICBpZiAobV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9y KCkuc2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxlZCgpKQogICAgICAgICAg ICAgYWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Ny b2xsQWxpZ25tZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25D ZW50ZXJJZk5lZWRlZDsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgYWxpZ25tZW50ID0gKGFs aWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xsQWxpZ25tZW50OjphbGln blRvcEFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJZk5lZWRlZDsKQEAgLTI0 Myw4ICsyNDMsNyBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om5vZGVXaWxsQmVSZW1vdmVk KE5vZGUgKm5vZGUpCiAgICAgCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0 aW9uYWwoYm9vbCBpc0RpcmVjdGlvbmFsKQogewotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IG1f ZnJhbWUgPyBtX2ZyYW1lLT5zZXR0aW5ncygpIDogMDsKLSAgICBtX2lzRGlyZWN0aW9uYWwgPSAh c2V0dGluZ3MgfHwgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpICE9IEVkaXRpbmdNYWNCZWhh dmlvciB8fCBpc0RpcmVjdGlvbmFsOworICAgIG1faXNEaXJlY3Rpb25hbCA9ICFtX2ZyYW1lIHx8 IG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZENvbnNpZGVyTW91c2VTZWxlY3Rp b25Bc0RpcmVjdGlvbmFsKCkgfHwgaXNEaXJlY3Rpb25hbDsKIH0KIAogdm9pZCBTZWxlY3Rpb25D b250cm9sbGVyOjp3aWxsQmVNb2RpZmllZChFQWx0ZXJhdGlvbiBhbHRlciwgRURpcmVjdGlvbiBk aXJlY3Rpb24pCkBAIC0yOTgsOCArMjk3LDcgQEAgVGV4dERpcmVjdGlvbiBTZWxlY3Rpb25Db250 cm9sbGVyOjpkaXJlY3Rpb25PZkVuY2xvc2luZ0Jsb2NrKCkKIFZpc2libGVQb3NpdGlvbiBTZWxl Y3Rpb25Db250cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKGJvb2wgaXNHZXRTdGFydCkgY29u c3QKIHsKICAgICBQb3NpdGlvbiBwb3M7Ci0gICAgU2V0dGluZ3MqIHNldHRpbmdzID0gbV9mcmFt ZSA/IG1fZnJhbWUtPnNldHRpbmdzKCkgOiAwOwotICAgIGlmIChzZXR0aW5ncyAmJiBzZXR0aW5n cy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgIGlmIChtX2Zy YW1lICYmIG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZEtleWJhcmRTZWxlY3Rp b25FeHRlbmRGb3JIb3Jpem9udGFsTmF2aWdhdGlvbigpKQogICAgICAgICBwb3MgPSBpc0dldFN0 YXJ0ID8gbV9zZWxlY3Rpb24uc3RhcnQoKSA6IG1fc2VsZWN0aW9uLmVuZCgpOwogICAgIGVsc2Ug ewogICAgICAgICAvLyBMaW51eCBhbmQgV2luZG93cyBhbHdheXMgZXh0ZW5kIHNlbGVjdGlvbnMg ZnJvbSB0aGUgZXh0ZW50IGVuZHBvaW50LgpAQCAtNjg1LDcgKzY4Myw3IEBAIGJvb2wgU2VsZWN0 aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBFRGlyZWN0aW9uIGRpcmVj dGlvbiwgVGV4dEdyCiAgICAgICAgIG1vdmVUbyhwb3NpdGlvbiwgdXNlclRyaWdnZXJlZCk7CiAg ICAgICAgIGJyZWFrOwogICAgIGNhc2UgQWx0ZXJhdGlvbkV4dGVuZDoKLSAgICAgICAgaWYgKCFz ZXR0aW5ncyB8fCBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgIT0gRWRpdGluZ01hY0JlaGF2 aW9yIHx8IG1fc2VsZWN0aW9uLmlzQ2FyZXQoKSB8fCAhaXNCb3VuZGFyeShncmFudWxhcml0eSkp CisgICAgICAgIGlmICghbV9mcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkR3Jvd1Nl bGVjdGlvbldoZW5FeHRlbmRpbmdUb0JvdW5kYXJ5KCkgfHwgbV9zZWxlY3Rpb24uaXNDYXJldCgp IHx8ICFpc0JvdW5kYXJ5KGdyYW51bGFyaXR5KSkKICAgICAgICAgICAgIHNldEV4dGVudChwb3Np dGlvbiwgdXNlclRyaWdnZXJlZCk7CiAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgLy8gU3Rh bmRhcmQgTWFjIGJlaGF2aW9yIHdoZW4gZXh0ZW5kaW5nIHRvIGEgYm91bmRhcnkgaXMgZ3JvdyB0 aGUgc2VsZWN0aW9uIHJhdGhlcgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxl ci5jcHAgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAppbmRleCAxYmY0YzM4Li45YTkw ZGI1IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJD b3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtMzcwLDcgKzM3MCw3IEBAIGJvb2wgRXZlbnRI YW5kbGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnRTaW5nbGVDbGljayhjb25zdCBNb3VzZUV2ZW50 V2l0aEhpdFRlc3RSCiAgICAgICAgIG1fZnJhbWUtPnNlbGVjdGlvbigpLT5zZXRJc0RpcmVjdGlv bmFsKGZhbHNlKTsKICAgICAgICAgCiAgICAgICAgIEFTU0VSVChtX2ZyYW1lLT5zZXR0aW5ncygp KTsKLSAgICAgICAgaWYgKG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09 IEVkaXRpbmdNYWNCZWhhdmlvcikgeworICAgICAgICBpZiAoIW1fZnJhbWUtPmVkaXRvcigpLT5i ZWhhdmlvcigpLnNob3VsZEV4dGVuZFNlbGVjdGlvbkZyb21FbmRQb2ludEFsd2F5cygpKSB7CiAg ICAgICAgICAgICAvLyBTZWUgPHJkYXI6Ly9wcm9ibGVtLzM2NjgxNTc+IFJFR1JFU1NJT04gKE1h aWwpOiBzaGlmdC1jbGljayBkZXNlbGVjdHMgd2hlbiBzZWxlY3Rpb24KICAgICAgICAgICAgIC8v IHdhcyBjcmVhdGVkIHJpZ2h0LXRvLWxlZnQKICAgICAgICAgICAgIFBvc2l0aW9uIHN0YXJ0ID0g bmV3U2VsZWN0aW9uLnN0YXJ0KCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu Y3BwIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCA2ZjZiYjA0Li5kZDQwYzQzIDEw MDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9T ZXR0aW5ncy5jcHAKQEAgLTExMyw3ICsxMTMsNyBAQCBTZXR0aW5nczo6U2V0dGluZ3MoUGFnZSog cGFnZSkKICAgICAsIG1fZW5mb3JjZUNTU01JTUVUeXBlSW5TdHJpY3RNb2RlKHRydWUpCiAgICAg LCBtX3VzZXNFbmNvZGluZ0RldGVjdG9yKGZhbHNlKQogICAgICwgbV9hbGxvd1NjcmlwdHNUb0Ns b3NlV2luZG93cyhmYWxzZSkKLSAgICAsIG1fZWRpdGluZ0JlaGF2aW9yKAorICAgICwgbV9lZGl0 aW5nQmVoYXZpb3JUeXBlKAogI2lmIFBMQVRGT1JNKE1BQykgfHwgKFBMQVRGT1JNKENIUk9NSVVN KSAmJiBPUyhEQVJXSU4pKQogICAgICAgICAvLyAoUExBVEZPUk0oTUFDKSBpcyBhbHdheXMgZmFs c2UgaW4gQ2hyb21pdW0sIGhlbmNlIHRoZSBleHRyYSBjb25kaXRpb24uKQogICAgICAgICBFZGl0 aW5nTWFjQmVoYXZpb3IKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5oIGIvV2Vi Q29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggZGMzYjUwZi4uNmE5YzI1ZSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKQEAg LTI4LDYgKzI4LDcgQEAKICNkZWZpbmUgU2V0dGluZ3NfaAogCiAjaW5jbHVkZSAiQXRvbWljU3Ry aW5nLmgiCisjaW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCIKICNpbmNsdWRlICJGb250 UmVuZGVyaW5nTW9kZS5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJab29tTW9kZS5o IgpAQCAtNTAsMjEgKzUxLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBUZXh0RGly ZWN0aW9uU3VibWVudUFsd2F5c0luY2x1ZGVkCiAgICAgfTsKIAotICAgIC8vIFRoZXJlIGFyZSBt dWx0aXBsZSBlZGl0aW5nIGRldGFpbHMgdGhhdCBhcmUgZGlmZmVyZW50IG9uIFdpbmRvd3MgdGhh biBNYWNpbnRvc2guCi0gICAgLy8gV2UgdXNlIGEgc2luZ2xlIHN3aXRjaCBmb3IgYWxsIG9mIHRo ZW0uIFNvbWUgZXhhbXBsZXM6Ci0gICAgLy8KLSAgICAvLyAgICAxKSBDbGlja2luZyBiZWxvdyB0 aGUgbGFzdCBsaW5lIG9mIGFuIGVkaXRhYmxlIGFyZWEgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVu ZAotICAgIC8vICAgICAgIG9mIHRoZSBsYXN0IGxpbmUgb24gTWFjLCBidXQgaW4gdGhlIG1pZGRs ZSBvZiB0aGUgbGFzdCBsaW5lIG9uIFdpbmRvd3MuCi0gICAgLy8gICAgMikgUHVzaGluZyB0aGUg ZG93biBhcnJvdyBrZXkgb24gdGhlIGxhc3QgbGluZSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5k IG9mIHRoZQotICAgIC8vICAgICAgIGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBkb2VzIG5vdGhpbmcg b24gV2luZG93cy4gQSBzaW1pbGFyIGNhc2UgZXhpc3RzIG9uIHRoZQotICAgIC8vICAgICAgIHRv cCBsaW5lLgotICAgIC8vCi0gICAgLy8gVGhpcyBzZXR0aW5nIGlzIGludGVuZGVkIHRvIGNvbnRy b2wgdGhlc2Ugc29ydHMgb2YgYmVoYXZpb3JzLiBUaGVyZSBhcmUgc29tZSBvdGhlcgotICAgIC8v IGJlaGF2aW9ycyB3aXRoIGluZGl2aWR1YWwgZnVuY3Rpb24gY2FsbHMgb24gRWRpdG9yQ2xpZW50 IChzbWFydCBjb3B5IGFuZCBwYXN0ZSBhbmQKLSAgICAvLyBzZWxlY3RpbmcgdGhlIHNwYWNlIGFm dGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNvdWxkIGJlIGNvbWJpbmVkIHdpdGggdGhpcyBpZgot ICAgIC8vIGlmIHBvc3NpYmxlIGluIHRoZSBmdXR1cmUuCi0gICAgZW51bSBFZGl0aW5nQmVoYXZp b3IgeyBFZGl0aW5nTWFjQmVoYXZpb3IsIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IgfTsKLQogICAg IGNsYXNzIFNldHRpbmdzIDogcHVibGljIE5vbmNvcHlhYmxlIHsKICAgICBwdWJsaWM6CiAgICAg ICAgIFNldHRpbmdzKFBhZ2UqKTsKQEAgLTI3MCw5ICsyNTYsOSBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIHZvaWQgc2V0QWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoYm9vbCk7CiAg ICAgICAgIGJvb2wgYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3MoKSBjb25zdCB7IHJldHVybiBt X2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzOyB9CiAKLSAgICAgICAgdm9pZCBzZXRFZGl0aW5n QmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yID0g YmVoYXZpb3I7IH0KLSAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVkaXRpbmdCZWhhdmlvcigpIGNv bnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvcj4obV9lZGl0aW5nQmVoYXZp b3IpOyB9Ci0gICAgICAgIAorICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvclR5cGUoRWRp dGluZ0JlaGF2aW9yVHlwZSBiZWhhdmlvcikgeyBtX2VkaXRpbmdCZWhhdmlvclR5cGUgPSBiZWhh dmlvcjsgfQorICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlIGVkaXRpbmdCZWhhdmlvclR5cGUo KSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFZGl0aW5nQmVoYXZpb3JUeXBlPihtX2VkaXRp bmdCZWhhdmlvclR5cGUpOyB9CisKICAgICAgICAgdm9pZCBzZXREb3dubG9hZGFibGVCaW5hcnlG b250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJvb2wgZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNF bmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQ7 IH0KIApAQCAtMzgwLDcgKzM2Niw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgYm9v bCBtX2VuZm9yY2VDU1NNSU1FVHlwZUluU3RyaWN0TW9kZSA6IDE7CiAgICAgICAgIGJvb2wgbV91 c2VzRW5jb2RpbmdEZXRlY3RvciA6IDE7CiAgICAgICAgIGJvb2wgbV9hbGxvd1NjcmlwdHNUb0Ns b3NlV2luZG93cyA6IDE7Ci0gICAgICAgIHVuc2lnbmVkIG1fZWRpdGluZ0JlaGF2aW9yIDogMTsK KyAgICAgICAgdW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3JUeXBlIDogMTsKICAgICAgICAgYm9v bCBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV94 c3NBdWRpdG9yRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV9hY2NlbGVyYXRlZENvbXBvc2l0 aW5nRW5hYmxlZCA6IDE7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9j ay5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggNmZiZWExNC4u MDllZTljNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCisr KyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtMzcxOCwxNiArMzcxOCwx NSBAQCBWaXNpYmxlUG9zaXRpb24gUmVuZGVyQmxvY2s6OnBvc2l0aW9uRm9yUG9pbnRXaXRoSW5s aW5lQ2hpbGRyZW4oY29uc3QgSW50UG9pbnQmCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBTZXR0 aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudCgpLT5zZXR0aW5ncygpOwotICAgIGJvb2wgdXNlV2lu ZG93c0JlaGF2aW9yID0gc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpID09 IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CisgICAgYm9vbCBtb3ZlQ2FyZXRUb0JvdW5kYXJ5ID0g ZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkTW92ZUNhcmV0 VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKCk7CiAKLSAgICBpZiAodXNl V2luZG93c0JlaGF2aW9yICYmICFjbG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVu KSB7CisgICAgaWYgKCFtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmICFjbG9zZXN0Qm94ICYmIGxhc3RS b290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBiZWxvdyBs YXN0IHJvb3QgbGluZSBib3gsIHByZXRlbmQgd2UgaGl0IGl0CiAgICAgICAgIGNsb3Nlc3RCb3gg PSBsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+Y2xvc2VzdExlYWZDaGlsZEZvclhQb3MocG9pbnRJ bkNvbnRlbnRzLngoKSk7CiAgICAgfQogCiAgICAgaWYgKGNsb3Nlc3RCb3gpIHsKLSAgICAgICAg aWYgKCF1c2VXaW5kb3dzQmVoYXZpb3IgJiYgcG9pbnRJbkNvbnRlbnRzLnkoKSA8IGZpcnN0Um9v dEJveFdpdGhDaGlsZHJlbi0+bGluZVRvcCgpIC0gdmVydGljYWxMaW5lQ2xpY2tGdWRnZUZhY3Rv cikgeworICAgICAgICBpZiAobW92ZUNhcmV0VG9Cb3VuZGFyeSAmJiBwb2ludEluQ29udGVudHMu eSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVD bGlja0Z1ZGdlRmFjdG9yKSB7CiAgICAgICAgICAgICAvLyB5IGNvb3JkaW5hdGUgaXMgYWJvdmUg Zmlyc3Qgcm9vdCBsaW5lIGJveCwgc28gcmV0dXJuIHRoZSBzdGFydCBvZiB0aGUgZmlyc3QKICAg ICAgICAgICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3goZmlyc3RSb290 Qm94V2l0aENoaWxkcmVuLT5maXJzdExlYWZDaGlsZCgpLCB0cnVlKSwgRE9XTlNUUkVBTSk7CiAg ICAgICAgIH0KQEAgLTM3MzgsNyArMzczNyw3IEBAIFZpc2libGVQb3NpdGlvbiBSZW5kZXJCbG9j azo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQb2ludCYKIAog ICAgIGlmIChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewogICAgICAgICAvLyBXZSBoaXQgdGhp cyBjYXNlIGZvciBNYWMgYmVoYXZpb3Igd2hlbiB0aGUgWSBjb29yZGluYXRlIGlzIGJlbG93IHRo ZSBsYXN0IGJveC4KLSAgICAgICAgQVNTRVJUKCF1c2VXaW5kb3dzQmVoYXZpb3IpOworICAgICAg ICBBU1NFUlQobW92ZUNhcmV0VG9Cb3VuZGFyeSk7CiAgICAgICAgIHJldHVybiBWaXNpYmxlUG9z aXRpb24ocG9zaXRpb25Gb3JCb3gobGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxhc3RMZWFmQ2hp bGQoKSwgZmFsc2UpLCBET1dOU1RSRUFNKTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDdiZjU3 OTAuLmMxNjcwYTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBB bnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50 IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0Jl aGF2aW9yIGVudW0gd2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVk IG91dCBmcm9tIFNldHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAu IENhbGwgc2l0ZXMgaW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAq IHNyYy9XZWJTZXR0aW5nc0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTZXR0aW5nc0lt cGw6OnNldEVkaXRpbmdCZWhhdmlvcik6CisKIDIwMTAtMDYtMDEgIFNoZXJpZmYgQm90ICA8d2Vi a2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcg b3V0IHI2MDQ3MC4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJ bXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAppbmRleCA5 NDY3ODJiLi43ZTg5YTc3IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRp bmdzSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3Bw CkBAIC0yNzEsNyArMjcxLDcgQEAgdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldFNob3dEZWJ1Z0Jv cmRlcnMoYm9vbCBzaG93KQogCiB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2 aW9yKEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKLSAgICBtX3NldHRpbmdzLT5zZXRFZGl0 aW5nQmVoYXZpb3Ioc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yPihiZWhhdmlv cikpOworICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoc3RhdGljX2Nhc3Q8 V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZT4oYmVoYXZpb3IpKTsKIH0KIAogdm9pZCBXZWJT ZXR0aW5nc0ltcGw6OnNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkKGJvb2wgZW5hYmxl ZCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKaW5kZXggZDI5OGI0OC4uODJkNTQ3ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAxMC0wNS0z MSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVu ZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRp bmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBt b3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVz LmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAg ICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHA6CisgICAgICAgIChXZWJLaXQ6OmNvcmUpOgor ICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3VwZGF0ZV9zZXR0aW5ncyk6 CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfc2V0dGluZ3Nfbm90aWZ5KToKKwogMjAxMC0wNS0z MSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51 az4KIAogICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuY3BwCmluZGV4IGQyNzQ3MDguLjcwOWRjNWUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuY3BwCkBAIC0xMjksOSArMTI5LDkgQEAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBj b3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCiAgICAgcmV0dXJuIFJlc291cmNl UmVzcG9uc2UoKTsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRp dGluZ0JlaGF2aW9yIHR5cGUpCitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2Vi S2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCiB7Ci0gICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5n QmVoYXZpb3IpdHlwZTsKKyAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUp dHlwZTsKIH0KIAogV2ViS2l0SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNvcmU6OkhpdFRl c3RSZXN1bHQmIHJlc3VsdCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCAwNTdiMGU1 Li42YWVjYzEzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC05NSw3ICs5NSw3IEBA IG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBjb3Jl KFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOwogCi0gICAgV2ViQ29yZTo6RWRpdGlu Z0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpOworICAgIFdlYkNvcmU6 OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CiAK ICAgICBXZWJLaXRTZWN1cml0eU9yaWdpbioga2l0KFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luKik7 CiAgICAgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qIGNvcmUoV2ViS2l0U2VjdXJpdHlPcmlnaW4q KTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5kZXggOTEzNTRmZC4uMTg0ODI0NSAx MDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAgLTI2OTUsNyArMjY5NSw3IEBAIHN0 YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld191cGRhdGVfc2V0dGluZ3MoV2ViS2l0V2ViVmlldyog d2ViVmlldykKICAgICBzZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21h dGljYWxseShqYXZhc2NyaXB0Q2FuT3BlbldpbmRvd3MpOwogICAgIHNldHRpbmdzLT5zZXRKYXZh U2NyaXB0Q2FuQWNjZXNzQ2xpcGJvYXJkKGphdmFTY3JpcHRDYW5BY2Nlc3NDbGlwYm9hcmQpOwog ICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQoZW5hYmxl T2ZmbGluZVdlYkFwcENhY2hlKTsKLSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKGNv cmUoZWRpdGluZ0JlaGF2aW9yKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5 cGUoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsKICAgICBzZXR0aW5ncy0+c2V0QWxsb3dVbml2ZXJz YWxBY2Nlc3NGcm9tRmlsZVVSTHMoZW5hYmxlVW5pdmVyc2FsQWNjZXNzRnJvbUZpbGVVUkkpOwog ICAgIHNldHRpbmdzLT5zZXRBbGxvd0ZpbGVBY2Nlc3NGcm9tRmlsZVVSTHMoZW5hYmxlRmlsZUFj Y2Vzc0Zyb21GaWxlVVJJKTsKICAgICBzZXR0aW5ncy0+c2V0RE9NUGFzdGVBbGxvd2VkKGVuYWJs ZURPTVBhc3RlKTsKQEAgLTI3OTYsNyArMjc5Niw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf dmlld19zZXR0aW5nc19ub3RpZnkoV2ViS2l0V2ViU2V0dGluZ3MqIHdlYlNldHRpbmdzLCBHUGFy CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVuYWJsZS1vZmZsaW5lLXdl Yi1hcHBsaWNhdGlvbi1jYWNoZSIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0T2ZmbGluZVdlYkFw cGxpY2F0aW9uQ2FjaGVFbmFibGVkKGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJnZhbHVlKSk7CiAgICAg ZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVkaXRpbmctYmVoYXZpb3IiKSkKLSAg ICAgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKHN0YXRpY19jYXN0PFdlYktp dEVkaXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOworICAgICAgICBz ZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKHN0YXRpY19jYXN0PFdlYktpdEVk aXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOwogICAgIGVsc2UgaWYg KG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlbmFibGUtdW5pdmVyc2FsLWFjY2Vzcy1mcm9tLWZp bGUtdXJpcyIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0QWxsb3dVbml2ZXJzYWxBY2Nlc3NGcm9t RmlsZVVSTHMoZ192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1l ID09IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLWZpbGUtYWNjZXNzLWZyb20tZmlsZS11cmlzIikp CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9n CmluZGV4IDdkODhmZWQuLjM3MGY2ZDggMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9n CisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTAtMDUtMzEg IEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRl bnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5n QmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92 ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5o IC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAg ICogV2ViVmlldy9XZWJGcmFtZS5tbToKKyAgICAgICAgKGNvcmUpOgorICAgICAgICAqIFdlYlZp ZXcvV2ViRnJhbWVJbnRlcm5hbC5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5tbToKKyAg ICAgICAgKC1bV2ViVmlldyBfcHJlZmVyZW5jZXNDaGFuZ2VkTm90aWZpY2F0aW9uOl0pOgorCiAy MDEwLTA1LTMwICBEYXJpbiBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZy YW1lLm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCmluZGV4IDk5OWYxNzcuLjdj NTk2MTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbQorKysgYi9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KQEAgLTE5Niw3ICsxOTYsNyBAQCBFZGl0YWJs ZUxpbmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlua0JlaGF2aW9yIGVkaXRhYmxlTGlu a0JlaGF2aW9yKQogICAgIHJldHVybiBFZGl0YWJsZUxpbmtEZWZhdWx0QmVoYXZpb3I7CiB9CiAK LVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhh dmlvcikKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVo YXZpb3IgYmVoYXZpb3IpCiB7CiAgICAgc3dpdGNoIChiZWhhdmlvcikgewogICAgICAgICBjYXNl IFdlYktpdEVkaXRpbmdNYWNCZWhhdmlvcjoKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmll dy9XZWJGcmFtZUludGVybmFsLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5h bC5oCmluZGV4IDliMjI0OGEuLjU4NmI0YzMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmll dy9XZWJGcmFtZUludGVybmFsLmgKKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50 ZXJuYWwuaApAQCAtNzEsNyArNzEsNyBAQCBXZWJWaWV3ICpraXQoV2ViQ29yZTo6UGFnZSopOwog CiBXZWJDb3JlOjpFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlua0Jl aGF2aW9yKTsKIFdlYkNvcmU6OlRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3Ig Y29yZShXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKTsKLVdlYkNvcmU6 OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvcik7CitXZWJDb3JlOjpF ZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yKTsKIAogV2ViVmll dyAqZ2V0V2ViVmlldyhXZWJGcmFtZSAqd2ViRnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQv bWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCmlu ZGV4IDk3Yzc5OWIuLjlmM2FkNjAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0xMzY5LDcgKzEz NjksNyBAQCBzdGF0aWMgYm9vbCBmYXN0RG9jdW1lbnRUZWFyZG93bkVuYWJsZWQoKQogICAgIHNl dHRpbmdzLT5zZXRUZXh0QXJlYXNBcmVSZXNpemFibGUoW3ByZWZlcmVuY2VzIHRleHRBcmVhc0Fy ZVJlc2l6YWJsZV0pOwogICAgIHNldHRpbmdzLT5zZXRTaHJpbmtzU3RhbmRhbG9uZUltYWdlc1Rv Rml0KFtwcmVmZXJlbmNlcyBzaHJpbmtzU3RhbmRhbG9uZUltYWdlc1RvRml0XSk7CiAgICAgc2V0 dGluZ3MtPnNldEVkaXRhYmxlTGlua0JlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRhYmxl TGlua0JlaGF2aW9yXSkpOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShb cHJlZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5n QmVoYXZpb3JUeXBlKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRpbmdCZWhhdmlvcl0pKTsKICAgICBz ZXR0aW5ncy0+c2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcihjb3JlKFtw cmVmZXJlbmNlcyB0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yXSkpOwogICAg IHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoW3ByZWZlcmVuY2VzIGlzRE9NUGFzdGVBbGxv d2VkXSk7CiAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoW3NlbGYgdXNlc1BhZ2VDYWNo ZV0pOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VM b2cKaW5kZXggOWE1ZDVhYy4uNjRlMzUzOCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEg IEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRl bnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5n QmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92 ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5o IC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAg ICogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwOgorICAgICAgICAo RHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcik6CisKIDIwMTAtMDYt MDEgIFNpbW9uIEhhdXNtYW5uICA8c2ltb24uaGF1c21hbm5Abm9raWEuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IExhc3psbyBHb21ib3MuCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvV2ViQ29y ZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwIGIvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcAppbmRleCAwYjJlOWE1Li5hOTUxYTQ5 IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwCisrKyBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1 cHBvcnRRdC5jcHAKQEAgLTQ3Niw3ICs0NzYsNyBAQCBib29sIER1bXBSZW5kZXJUcmVlU3VwcG9y dFF0OjplbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVsZW1lbnRXaXRoSWQoUVdlYkZyYW1lKgog CiB2b2lkIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBh Z2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcmIGVkaXRpbmdCZWhhdmlvcikKIHsKLSAgICBXZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3IgY29yZUVkaXRpbmdCZWhhdmlvcjsKKyAgICBXZWJDb3JlOjpFZGl0 aW5nQmVoYXZpb3JUeXBlIGNvcmVFZGl0aW5nQmVoYXZpb3I7CiAKICAgICBpZiAoZWRpdGluZ0Jl aGF2aW9yID09ICJ3aW4iKQogICAgICAgICBjb3JlRWRpdGluZ0JlaGF2aW9yID0gRWRpdGluZ1dp bmRvd3NCZWhhdmlvcjsKQEAgLTQ4Nyw3ICs0ODcsNyBAQCB2b2lkIER1bXBSZW5kZXJUcmVlU3Vw cG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBhZ2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcm CiAgICAgaWYgKCFjb3JlUGFnZSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgY29yZVBhZ2UtPnNl dHRpbmdzKCktPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlRWRpdGluZ0JlaGF2aW9yKTsKKyAgICBj b3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlRWRpdGluZ0Jl aGF2aW9yKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6ZHVtcEZyYW1lTG9h ZGVyKGJvb2wgYikKZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vQ2hhbmdlTG9nIGIvV2ViS2l0L3dp bi9DaGFuZ2VMb2cKaW5kZXggMjk3OTU1Ni4uMmViNjgzMiAxMDA2NDQKLS0tIGEvV2ViS2l0L3dp bi9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAor MjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlZmFjdG9yIHBsYXRm b3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRpbmdzCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAorCisgICAg ICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5 cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVkaXRpbmdCZWhh dmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHku CisKKyAgICAgICAgKiBXZWJWaWV3LmNwcDoKKyAgICAgICAgKFdlYlZpZXc6Om5vdGlmeVByZWZl cmVuY2VzQ2hhbmdlZCk6CisKIDIwMTAtMDUtMzAgIERhbmllbCBCYXRlcyAgPGRiYXRlc0ByaW0u Y29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIGF0dGVtcHQgdG8gZml4IHRoZSBidWlsZCBhZnRl ciBodHRwOi8vdHJhYy53ZWJraXQub3JnL2NoYW5nZXNldC82MDQxOC4KZGlmZiAtLWdpdCBhL1dl YktpdC93aW4vV2ViVmlldy5jcHAgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCmluZGV4IDUyNTEw OGYuLmJhNWJmNDQgMTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vV2ViVmlldy5jcHAKKysrIGIvV2Vi S2l0L3dpbi9XZWJWaWV3LmNwcApAQCAtNDY1NCw3ICs0NjU0LDcgQEAgSFJFU1VMVCBXZWJWaWV3 Ojpub3RpZnlQcmVmZXJlbmNlc0NoYW5nZWQoSVdlYk5vdGlmaWNhdGlvbiogbm90aWZpY2F0aW9u KQogICAgIGhyID0gcHJlZmVyZW5jZXMtPmVkaXRpbmdCZWhhdmlvcigmZWRpdGluZ0JlaGF2aW9y KTsKICAgICBpZiAoRkFJTEVEKGhyKSkKICAgICAgICAgcmV0dXJuIGhyOwotICAgIHNldHRpbmdz LT5zZXRFZGl0aW5nQmVoYXZpb3IoKEVkaXRpbmdCZWhhdmlvcillZGl0aW5nQmVoYXZpb3IpOwor ICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKChFZGl0aW5nQmVoYXZpb3JUeXBl KWVkaXRpbmdCZWhhdmlvcik7CiAKICAgICBociA9IHByZWZlcmVuY2VzLT51c2VzUGFnZUNhY2hl KCZlbmFibGVkKTsKICAgICBpZiAoRkFJTEVEKGhyKSkKLS0gCjEuNy4wLjQKCg== 57916 2010-06-04 14:37:33 -0700 2010-06-04 14:44:58 -0700 patch v2.3 - part I 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 38157 tonikitoo RnJvbSBkN2JjOGY3MWVjNTU1YmM5MWZmNjIyMzc1OWVhYTUxMjljZGJiYTEwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogRnJpLCA0IEp1biAyMDEwIDE3OjEyOjMzIC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPHRvbmlraXRv b0B3ZWJraXQub3JnPgoKV2ViQ29yZToKCkFzIHBlciBkaXNjdXNzaW9uIGluIGJ1ZyAzNjYyNywg dGhlIGZvbGxvd2luZyB3YXMgc3VnZ2VzdGVkIGJ5IERhcmluIEFkbGVyOiAiYmVmb3JlIHRoZSBh ZGRpdGlvbiBvZiBhbnkKbmV3IEVkaXRpbmdCZWhhdmlvciwgSSB0aGluayB3ZSBuZWVkIHRvIGFk ZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRv IHNwZWNpZmljCmJlaGF2aW9ycyByYXRoZXIgdGhhbiBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9y ID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQK ZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50IHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuCgpQYXRj aCBpcyBhIGZpcnN0IHN0ZXAgb2YgYW4gaW5jcmVtZW50YWwgYXBwcm9hY2ggdG8gYWRkcmVzcyB0 aGlzIHJlcXVlc3QuIEl0IGRvZXMgbm90IHlldCByZXBsYWNlIGFsbApkaXJlY3QgdXNlIG9mIEVk aXRpbmd7TWFjLFdpbmRvd3N9QmVoYXZpb3JzLCBidXQgYWRkcyBpbmZyYSBmb3IgdGhhdCBhbmQg cmVwbGFjZXMgc29tZSBvZiB0aGVtLgoKTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVz dHMuCgoqIEdOVW1ha2VmaWxlLmFtOgoqIFdlYkNvcmUucHJvOgoqIFdlYkNvcmUvV2ViQ29yZS5n eXBpCiogV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagoqIFdlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCiogcGFnZS9TZXR0aW5ncy5jcHA6CihXZWJD b3JlOjpTZXR0aW5nczo6U2V0dGluZ3MpOgoqIHBhZ2UvU2V0dGluZ3MuaDogTW92ZWQgb3V0IEVk aXRpbmdCZWhhdmlvciBlbnVtIHRvIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oLAphbmQgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcy4KKFdlYkNvcmU6OlNldHRp bmdzOjpzZXRFZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBmcm9tIHNldEVkaXRpbmdCZWhh dmlvci4KKFdlYkNvcmU6OlNldHRpbmdzOjplZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBm cm9tIGVkaXRpbmdCZWhhdmlvci4KKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOiBBZGRlZC4K KFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6RWRpdGluZ0JlaGF2aW9yKTogQ2xhc3MgdG8gd29y ayBhcyBhIGNlbnRyYWwgcG9pbnQgZm9yCmVkaXRpbmcgYmVoYXZpb3IgdGhhdCBtaWdodCBoYXZl IHRvIGJlIGhhbmRsZWQgZGlmZmVyZW50bHkgaW4gdGhlIGRpZmZlcmVudCBwbGF0Zm9ybXMvcG9y dHMuCkNsYXNzIHNob3VsZCBiZSBub3QgdXNlZCBvciBpbnN0YW50aWF0ZWQgZGlyZWN0bHksIGJ1 dCByYXRoZXIgaW1wbGljaXRseSBjb25zdHJ1Y3RlZAp0aHJvdWdoIHRoZSBFZGl0b3IgY2xhc3Mu CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJv dW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNo b3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQpOgoqIGVkaXRp bmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaDogQWRkZWQuCihXZWJDb3JlOjopOgoqIGVkaXRpbmcv RWRpdG9yLmNwcDoKKFdlYkNvcmU6OkVkaXRvcjo6YmVoYXZpb3IpOiBHZXR0ZXIgZm9yIEVkaXRp bmdCZWhhdmlvciBjbGFzcy4KKiBlZGl0aW5nL0VkaXRvci5oOgoqIGVkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHA6CihXZWJDb3JlOjpleGVjdXRlVG9nZ2xlU3R5bGUpOgooV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xs ZXI6Om1vZGlmeSk6CiogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgooV2ViQ29yZTo6RXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnRTaW5nbGVDbGljayk6CiogcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcDoKKFdlYkNvcmU6OlJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElu bGluZUNoaWxkcmVuKToKCi0gQ2FsbCBzaXRlcyB3aWxsIGxvb2sgbGlrZToKaWYgKGZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRUaGlzSWZUaGF0KCkpKQogICAvLyBkbyBzb21ldGhp bmcKCldlYktpdDoKCkVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdC ZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCkVkaXRpbmdCZWhh dmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHku CgpXZWJLaXQvY2hyb21pdW06Ciogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6CihXZWJLaXQ6Oldl YlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKCldlYktpdC9ndGs6Ciogd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwOgooV2ViS2l0Ojpjb3JlKToKKiB3ZWJraXQvd2Via2l0cHJpdmF0 ZS5oOgoqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKHdlYmtpdF93ZWJfdmlld191cGRhdGVf c2V0dGluZ3MpOgood2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeSk6CgpXZWJLaXQvbWFj OgoqIFdlYlZpZXcvV2ViRnJhbWUubW06Cihjb3JlKToKKiBXZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaDoKKiBXZWJWaWV3L1dlYlZpZXcubW06CigtW1dlYlZpZXcgX3ByZWZlcmVuY2VzQ2hhbmdl ZE5vdGlmaWNhdGlvbjpdKToKCldlYktpdC9xdDoKKiBXZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVy VHJlZVN1cHBvcnRRdC5jcHA6CihEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0Jl aGF2aW9yKToKCldlYktpdC93aW46CiogV2ViVmlldy5jcHA6CihXZWJWaWV3Ojpub3RpZnlQcmVm ZXJlbmNlc0NoYW5nZWQpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICA1MyArKysrKysrKysrKysrKysrCiBXZWJDb3JlL0dOVW1ha2Vm aWxlLmFtICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJD b3JlLmd5cGkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIFdlYkNvcmUv V2ViQ29yZS5wcm8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJD b3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qICAgICAgICAgICAgICB8ICAgIDggKysr CiBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICAgICB8ICAg IDggKysrCiBXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggICAgICAgICAgICAgICAg ICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3JUeXBlcy5oICAgICAgICAgICAgIHwgICA0NiArKysrKysrKysrKysrKwogV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5jcHAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEwICsrKwogV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAzICsK IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcCAgICAgICAgICAgIHwgICAg NSArLQogV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgICAyICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaCAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgMjQgKystLS0tLS0KIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCAg ICAgICAgICAgICAgICAgIHwgICAgOSArLS0KIFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysrCiBXZWJLaXQvY2hyb21pdW0vc3JjL1dl YlNldHRpbmdzSW1wbC5jcHAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9ndGsvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNyArKysrKwogV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAgfCAgICA0ICstCiBXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8ICAgIDIgKy0K IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAgICAgICAgICAgIHwgICAg NCArLQogV2ViS2l0L21hYy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDE2ICsrKysrCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gICAgICAgICAgICAg ICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgg ICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0gICAg ICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvcXQvQ2hhbmdlTG9nICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKwogLi4uL3F0L1dlYkNvcmVTdXBwb3J0 L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcCAgfCAgICA0ICstCiBXZWJLaXQvd2luL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKwogV2ViS2l0L3dp bi9XZWJWaWV3LmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICstCiAyOCBm aWxlcyBjaGFuZ2VkLCAyOTIgaW5zZXJ0aW9ucygrKSwgNDAgZGVsZXRpb25zKC0pCiBjcmVhdGUg bW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCiBjcmVhdGUgbW9k ZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKCmRpZmYgLS1n aXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDQ4MDVmMjMu LjhiYjZhYTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25p a2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBj b2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBBcyBwZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2 MjcsIERhcmluIEFkbGVyIHN1Z2dlc3RlZDogImJlZm9yZSB0aGUgYWRkaXRpb24gb2YgYW55IG5l dyBFZGl0aW5nQmVoYXZpb3IsCisgICAgICAgIEkgdGhpbmsgd2UgdG8gYWRkIGZ1bmN0aW9ucyB0 byB0cmFuc2xhdGUgdGhlIG92ZXJhbGwgYmVoYXZpb3IgcG9saWN5IGludG8gc3BlY2lmaWMgYmVo YXZpb3JzIHJhdGhlciB0aGFuCisgICAgICAgIGRpcmVjdGx5IHNheWluZyAnYmVoYXZpb3IgPT0g TWFjJyBvciAnYmVoYXZpb3IgPT0gV2luZG93cycuIEhlbHBlciBmdW5jdGlvbnMgdGhhdCBleHBy ZXNzaW9uIHRoZSBkaWZmZXJlbnQKKyAgICAgICAgcnVsZXMgaW4gcGxhaW4gbGFuZ3VhZ2UuIi4g UGF0Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KKworICAgICAgICBObyBiZWhhdmlvciBjaGFu Z2UsIHNvIG5vIG5ldyB0ZXN0cy4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAg ICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29y ZS52Y3Byb2oKKyAgICAgICAgKiBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2V0 dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6IE1vdmVkIG91dCBF ZGl0aW5nQmVoYXZpb3IgZW51bSB0byBXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaCwKKyAgICAgICAgYW5kIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMuCisgICAg ICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0RWRpdGluZ0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQg ZnJvbSBzZXRFZGl0aW5nQmVoYXZpb3IuCisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6ZWRp dGluZ0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQgZnJvbSBlZGl0aW5nQmVoYXZpb3IuCisgICAgICAg ICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpF ZGl0aW5nQmVoYXZpb3I6OkVkaXRpbmdCZWhhdmlvcik6IENsYXNzIHRvIHdvcmsgYXMgYSBjZW50 cmFsIHBvaW50IGZvcgorICAgICAgICBlZGl0aW5nIGJlaGF2aW9yIHRoYXQgbWlnaHQgaGF2ZSB0 byBiZSBoYW5kbGVkIGRpZmZlcmVudGx5IGluIHRoZSBkaWZmZXJlbnQgcGxhdGZvcm1zL3BvcnRz LgorICAgICAgICBDbGFzcyBzaG91bGQgYmUgbm90IHVzZWQgb3IgaW5zdGFudGlhdGVkIGRpcmVj dGx5LCBidXQgcmF0aGVyIGltcGxpY2l0bHkgY29uc3RydWN0ZWQKKyAgICAgICAgdGhyb3VnaCB0 aGUgRWRpdG9yIGNsYXNzLgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91 bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20pOgorICAg ICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRDb25zaWRlclNlbGVjdGlvbkFz RGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRD ZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVkKToKKyAgICAgICAgKiBlZGl0aW5nL0Vk aXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAg ICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFZGl0b3I6OmJlaGF2 aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisgICAgICAgICogZWRpdGlu Zy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAgKiBlZGl0aW5nL1NlbGVj dGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxl cjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6 OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxl cjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xp Y2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbik6CisK KyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBsaWtlOgorICAgICAgICBpZiAoZnJhbWUt PmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJZlRoYXQoKSkpCisgICAgICAgICAgIC8v IGRvIHNvbWV0aGluZworCiAyMDEwLTA1LTMwICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdl YmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1n aXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRl eCBmYzZiODE4Li4xZGE5NzhiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisr KyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgsOCBAQCB3ZWJjb3JlX3Nv dXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0QWN0aW9uLmggXAogCVdlYkNvcmUvZWRp dGluZy9FZGl0Q29tbWFuZC5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5oIFwK KwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAorCVdlYkNvcmUvZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3JUeXBlcy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBcCiAJ V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFu ZC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9XZWJDb3JlL1dlYkNv cmUuZ3lwaQppbmRleCBjNjZhMzJiLi5hYzBjYmQ5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNv cmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5MSw2ICsxMjkxLDggQEAK ICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAgICAgICAgICAnZWRpdGlu Zy9FZGl0Q29tbWFuZC5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdENvbW1hbmQuaCcs CisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCcsCisgICAgICAgICAgICAn ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oJywKICAgICAgICAgICAgICdlZGl0aW5nL0Vk aXRvci5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgnLAogICAgICAgICAgICAg J2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3Jl LnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODcyN2I3OS4uYzc0NmIzYiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0x Mjc5LDYgKzEyNzksNyBAQCBIRUFERVJTICs9IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmggXAog ICAgIGVkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3Iu aCBcCiAgICAgZWRpdGluZy9FZGl0b3IuaCBcCiAgICAgZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1h bmQuaCBcCiAgICAgZWRpdGluZy9odG1sZWRpdGluZy5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv V2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dl YkNvcmUudmNwcm9qCmluZGV4IGY2ZjQ5NjYuLmJkMzU2ZTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv V2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJv ai9XZWJDb3JlLnZjcHJvagpAQCAtMzA0NDksNiArMzA0NDksMTQgQEAKIAkJCQk+DQogCQkJPC9G aWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRpdGluZ1xFZGl0aW5nQmVo YXZpb3IuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBh dGg9Ii4uXGVkaXRpbmdcRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCINCisJCQkJPg0KKwkJCTwvRmls ZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdG9yLmNwcCIN CiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IDljODI1ZDQuLmE3ZmUyNWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMDE2LDYgKzEwMTYsOCBAQAogCQk0RTE5NTkyRTBBMzlE QUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNEUxOTU5MjgwQTM5REFDQzAwMjIwRkU1IC8qIE1lZGlhUXVl cnlFeHAuaCAqLzsgfTsKIAkJNEYzMjg5QjUxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZh bHVlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0 RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVzLmNwcCAqLzsgfTsKIAkJ NEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYzMjg5QjQxMUE0MkFBQjAwNUFC RTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFBy aXZhdGUsICk7IH07IH07CisJCTRGMTUzNERFMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVo YXZpb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRG MTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0RjE1MzRFMDExQjUzMzAyMDAy MUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5n QmVoYXZpb3JUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CiAJCTRGRDhEMEYyMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhEMEYwMTE5 QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCAqLzsgfTsKIAkJNEZEOEQwRjMxMTlD NzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhEMEYxMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRH Q0V2ZW50LmggKi87IH07CiAJCTUxMDE4NDY5MEIwODYwMkEwMDRBODI1RiAvKiBDYWNoZWRQYWdl LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTAxODQ2 NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJV VEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC02NjQwLDYgKzY2NDIsOCBAQAogCQk0RTE5NTky ODBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gTWVkaWFRdWVyeUV4cC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVzLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEluc3BlY3RvclZhbHVlcy5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGMzI4OUI0MTFBNDJBQUIwMDVBQkU3RSAvKiBJ bnNwZWN0b3JWYWx1ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVj dG9yVmFsdWVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTRGMTUzNEREMTFCNTMy RUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gRWRpdGluZ0JlaGF2aW9yLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CTRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0RkQ4RDBGMDExOUM3MThCMDAyRkE4MjUgLyogU2Ny aXB0R0NFdmVudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBTY3Jp cHRHQ0V2ZW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEZEOEQwRjExMTlD NzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gU2NyaXB0R0NFdmVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1 MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBDYWNoZWRQYWdlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC0xMzIxOSw2ICsxMzIyMyw4IEBACiAJCTkzMzA5RDg2MDk5RTY0OTEwMDU2RTU4MSAvKiBl ZGl0aW5nICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQk0 RjE1MzRERjExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAqLywKKwkJ CQk0RjE1MzRERDExQjUzMkVDMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yLmggKi8sCiAJCQkJ RUQ1MDFEQzkwQjI0OUYzOTAwQUUxOEQ5IC8qIG1hYyAqLywKIAkJCQk5MzMwOUQ4NzA5OUU2NDkx MDA1NkU1ODEgLyogQXBwZW5kTm9kZUNvbW1hbmQuY3BwICovLAogCQkJCTkzMzA5RDg4MDk5RTY0 OTEwMDU2RTU4MSAvKiBBcHBlbmROb2RlQ29tbWFuZC5oICovLApAQCAtMTk0MTUsNiArMTk0MjEs OCBAQAogCQkJCUM1MURBOUE5MTFBRUYyQzEwMDk3OTlDNSAvKiBJREJJbmRleFJlcXVlc3QuaCBp biBIZWFkZXJzICovLAogCQkJCUM1QkJDOUQxMTFBRUY4MzgwMDdDMkJGRSAvKiBKU0lEQkluZGV4 UmVxdWVzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8q IEluc3BlY3RvclZhbHVlcy5oIGluIEhlYWRlcnMgKi8sCisJCQkJNEYxNTM0REUxMUI1MzJFQzAw MjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNEYxNTM0RTAx MUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggaW4gSGVhZGVycyAqLywK IAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBiL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi45OGUwZWJlCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvci5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9r aWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJD SEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhl IEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNl ZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIEVkaXRpbmdC ZWhhdmlvcl9oCisjZGVmaW5lIEVkaXRpbmdCZWhhdmlvcl9oCisKKyNpbmNsdWRlICJFZGl0aW5n QmVoYXZpb3JUeXBlcy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEVkaXRpbmdC ZWhhdmlvciB7CisKK3B1YmxpYzoKKyAgICBFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9y VHlwZSB0eXBlKQorICAgICAgICA6IG1fdHlwZSh0eXBlKQorICAgIHsKKyAgICB9CisKKyAgICAv LyBJbmRpdmlkdWFsIGZ1bmN0aW9ucyBmb3IgZWFjaCBjYXNlIHdoZXJlIHdlIGhhdmUgbW9yZSB0 aGFuIG9uZSBzdHlsZSBvZiBlZGl0aW5nIGJlaGF2aW9yLgorICAgIC8vIENyZWF0ZSBhIG5ldyBm dW5jdGlvbiBmb3IgYW55IHBsYXRmb3JtIGRpZmZlcmVuY2Ugc28gd2UgY2FuIGNvbnRyb2wgaXQg aGVyZS4KKworICAgIC8vIFdoZW4gZXh0ZW5kaW5nIGEgc2VsZWN0aW9uIGJleW9uZCB0aGUgdG9w IG9yIGJvdHRvbSBib3VuZGFyeSBvZiBhbiBlZGl0YWJsZSBhcmVhLAorICAgIC8vIG1haW50YWlu IHRoZSBob3Jpem9udGFsIHBvc2l0aW9uIG9uIFdpbmRvd3MgYnV0IGV4dGVuZCBpdCB0byB0aGUg Ym91bmRhcnkgb2YgdGhlIGVkaXRhYmxlCisgICAgLy8gY29udGVudCBvbiBNYWMuCisgICAgYm9v bCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20o KSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsgfQorCisg ICAgLy8gT24gV2luZG93cywgc2VsZWN0aW9ucyBzaG91bGQgYWx3YXlzIGJlIGNvbnNpZGVyZWQg YXMgZGlyZWN0aW9uYWwsIHJlZ2FyZGxlc3MgaWYgaXQgaXMKKyAgICAvLyBtb3VzZS1iYXNlZCBv ciBrZXlib2FyZC1iYXNlZC4KKyAgICBib29sIHNob3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJl Y3Rpb25hbCgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAhPSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0K KworICAgIC8vIE9uIE1hYywgd2hlbiByZXZlYWxpbmcgYSBzZWxlY3Rpb24gKGZvciBleGFtcGxl IGFzIGEgcmVzdWx0IG9mIGEgRmluZCBvcGVyYXRpb24gb24gdGhlIEJyb3dzZXIpLAorICAgIC8v IGNvbnRlbnQgc2hvdWxkIGJlIHNjcm9sbGVkIHN1Y2ggdGhhdCB0aGUgc2VsZWN0aW9uIGdldHMg Y2VydGVyIGFsaWduZWQuCisgICAgYm9vbCBzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25J c1JldmVhbGVkKCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdNYWNCZWhhdmlvcjsg fQorCisgICAgYm9vbCBzaG91bGRDb25zaWRlclN0eWxlUHJlc2VudE9ubHlJZlRocm91Z2hvdXRU aGVTZWxlY3Rpb24oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2aW9y OyB9CisgICAgYm9vbCBzaG91bGRFeHRlbmRTZWxlY3Rpb25Gcm9tRW5kUG9pbnRBbHdheXMoKSBj b25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisgICAgYm9vbCBz aG91bGRLZXliYXJkU2VsZWN0aW9uRXh0ZW5kRm9ySG9yaXpvbnRhbE5hdmlnYXRpb24oKSBjb25z dCB7IHJldHVybiBtX3R5cGUgPT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91 bGRHcm93U2VsZWN0aW9uV2hlbkV4dGVuZGluZ1RvQm91bmRhcnkoKSBjb25zdCB7IHJldHVybiBt X3R5cGUgPT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisKK3ByaXZhdGU6CisgICAgRWRpdGluZ0Jl aGF2aW9yVHlwZSBtX3R5cGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRp ZiAvLyBFZGl0aW5nQmVoYXZpb3JfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRp bmdCZWhhdmlvclR5cGVzLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMu aApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yNmJhMThlCi0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKQEAgLTAsMCAr MSw0NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQv b3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIx MTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgRWRpdGluZ0JlaGF2aW9yVHlwZXNfaAorI2Rl ZmluZSBFZGl0aW5nQmVoYXZpb3JUeXBlc19oCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8g VGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQgb24g V2luZG93cyB0aGFuIE1hY2ludG9zaC4KKy8vIFdlIHVzZSBhIHNpbmdsZSBzd2l0Y2ggZm9yIGFs bCBvZiB0aGVtLiBTb21lIGV4YW1wbGVzOgorLy8KKy8vICAgIDEpIENsaWNraW5nIGJlbG93IHRo ZSBsYXN0IGxpbmUgb2YgYW4gZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5k CisvLyAgICAgICBvZiB0aGUgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGluIHRoZSBtaWRkbGUgb2Yg dGhlIGxhc3QgbGluZSBvbiBXaW5kb3dzLgorLy8gICAgMikgUHVzaGluZyB0aGUgZG93biBhcnJv dyBrZXkgb24gdGhlIGxhc3QgbGluZSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kIG9mIHRoZQor Ly8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBB IHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCisvLyAgICAgICB0b3AgbGluZS4KKy8vCisvLyBU aGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhhdmlv cnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCisvLyBiZWhhdmlvcnMgd2l0aCBpbmRpdmlkdWFsIGZ1 bmN0aW9uIGNhbGxzIG9uIEVkaXRvckNsaWVudCAoc21hcnQgY29weSBhbmQgcGFzdGUgYW5kCisv LyBzZWxlY3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNvdWxkIGJl IGNvbWJpbmVkIHdpdGggdGhpcyBpZgorLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KK2Vu dW0gRWRpdGluZ0JlaGF2aW9yVHlwZSB7CisgICAgRWRpdGluZ01hY0JlaGF2aW9yLAorICAgIEVk aXRpbmdXaW5kb3dzQmVoYXZpb3IKK307CisKK30gLy8gV2ViQ29yZSBuYW1lc3BhY2UKKworI2Vu ZGlmIC8vIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9FZGl0b3IuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggODA0MTE1OS4u NTg5MzQyMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKKysrIGIvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlICJSZW5k ZXJCbG9jay5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJSZXBsYWNlU2Vs ZWN0aW9uQ29tbWFuZC5oIgorI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiU291bmQu aCIKICNpbmNsdWRlICJUZXh0LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCkBAIC05Nyw2 ICs5OCwxNSBAQCBWaXNpYmxlU2VsZWN0aW9uIEVkaXRvcjo6c2VsZWN0aW9uRm9yQ29tbWFuZChF dmVudCogZXZlbnQpCiAgICAgcmV0dXJuIHNlbGVjdGlvbjsKIH0KIAorLy8gRnVuY3Rpb24gY29u c2lkZXJzIE1hYyBlZGl0aW5nIGJlaGF2aW9yIGEgZmFsbGJhY2sgd2hlbiBQYWdlIG9yIFNldHRp bmdzIGlzIG5vdCBhdmFpbGFibGUuCitFZGl0aW5nQmVoYXZpb3IgRWRpdG9yOjpiZWhhdmlvcigp IGNvbnN0Cit7CisgICAgaWYgKCFtX2ZyYW1lIHx8ICFtX2ZyYW1lLT5wYWdlKCkgfHwgIW1fZnJh bWUtPnNldHRpbmdzKCkpCisgICAgICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ01h Y0JlaGF2aW9yKTsKKworICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IobV9mcmFtZS0+c2V0dGlu Z3MoKS0+ZWRpdGluZ0JlaGF2aW9yVHlwZSgpKTsKK30KKwogRWRpdG9yQ2xpZW50KiBFZGl0b3I6 OmNsaWVudCgpIGNvbnN0CiB7CiAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBtX2ZyYW1lLT5wYWdlKCkp CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggYi9XZWJDb3JlL2VkaXRpbmcv RWRpdG9yLmgKaW5kZXggMTdkZDNiYi4uM2UyMjNkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0 aW5nL0VkaXRvci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMjksNiArMjks NyBAQAogI2luY2x1ZGUgIkNsaXBib2FyZEFjY2Vzc1BvbGljeS5oIgogI2luY2x1ZGUgIkNvbG9y LmgiCiAjaW5jbHVkZSAiRWRpdEFjdGlvbi5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5o IgogI2luY2x1ZGUgIkVkaXRvckRlbGV0ZUFjdGlvbi5oIgogI2luY2x1ZGUgIkVkaXRvckluc2Vy dEFjdGlvbi5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIKQEAgLTI4MSw2ICsy ODIsOCBAQCBwdWJsaWM6CiAKICAgICBLaWxsUmluZyoga2lsbFJpbmcoKSBjb25zdCB7IHJldHVy biBtX2tpbGxSaW5nLmdldCgpOyB9CiAKKyAgICBFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IoKSBj b25zdDsKKwogICAgIFBhc3NSZWZQdHI8UmFuZ2U+IHNlbGVjdGVkUmFuZ2UoKTsKICAgICAKICAg ICAvLyBXZSBzaG91bGQgbWFrZSB0aGVzZSBmdW5jdGlvbnMgcHJpdmF0ZSB3aGVuIHRoZWlyIGNh bGxlcnMgaW4gRnJhbWUgYXJlIG1vdmVkIG92ZXIgaGVyZSB0byBFZGl0b3IKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcCBiL1dlYkNvcmUvZWRpdGlu Zy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAppbmRleCBmOWIzOWJiLi5mMmFlNWE5IDEwMDY0NAot LS0gYS9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvV2ViQ29y ZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0xNjQsNyArMTY0LDcgQEAgdm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlv biYgcywgYm9vbCBjbG9zZVR5cGkKICAgICBpZiAodXNlclRyaWdnZXJlZCkgewogICAgICAgICBT Y3JvbGxBbGlnbm1lbnQgYWxpZ25tZW50OwogCi0gICAgICAgIGlmIChtX2ZyYW1lLT5zZXR0aW5n cygpICYmIG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdN YWNCZWhhdmlvcikKKyAgICAgICAgaWYgKG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNo b3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQoKSkKICAgICAgICAgICAgIGFs aWdubWVudCA9IChhbGlnbiA9PSBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFs aWdubWVudDo6YWxpZ25DZW50ZXJBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2VudGVy SWZOZWVkZWQ7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGlnbiA9 PSBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub3BB bHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQ7CkBAIC0yNDMsOCAr MjQzLDcgQEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpub2RlV2lsbEJlUmVtb3ZlZChOb2Rl ICpub2RlKQogICAgIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRJc0RpcmVjdGlvbmFs KGJvb2wgaXNEaXJlY3Rpb25hbCkKIHsKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBtX2ZyYW1l ID8gbV9mcmFtZS0+c2V0dGluZ3MoKSA6IDA7Ci0gICAgbV9pc0RpcmVjdGlvbmFsID0gIXNldHRp bmdzIHx8IHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nTWFjQmVoYXZpb3Ig fHwgaXNEaXJlY3Rpb25hbDsKKyAgICBtX2lzRGlyZWN0aW9uYWwgPSAhbV9mcmFtZSB8fCBtX2Zy YW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDb25zaWRlclNlbGVjdGlvbkFzRGlyZWN0 aW9uYWwoKSB8fCBpc0RpcmVjdGlvbmFsOwogfQogCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6 OndpbGxCZU1vZGlmaWVkKEVBbHRlcmF0aW9uIGFsdGVyLCBFRGlyZWN0aW9uIGRpcmVjdGlvbikK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MuY3BwCmluZGV4IDZmNmJiMDQuLmRkNDBjNDMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFn ZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMTEzLDcg KzExMyw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9lbmZvcmNl Q1NTTUlNRVR5cGVJblN0cmljdE1vZGUodHJ1ZSkKICAgICAsIG1fdXNlc0VuY29kaW5nRGV0ZWN0 b3IoZmFsc2UpCiAgICAgLCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGZhbHNlKQotICAg ICwgbV9lZGl0aW5nQmVoYXZpb3IoCisgICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5cGUoCiAjaWYg UExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJTikpCiAgICAg ICAgIC8vIChQTEFURk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1bSwgaGVuY2Ug dGhlIGV4dHJhIGNvbmRpdGlvbi4pCiAgICAgICAgIEVkaXRpbmdNYWNCZWhhdmlvcgpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApp bmRleCBkYzNiNTBmLi42YTljMjVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu aAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjgsNiArMjgsNyBAQAogI2RlZmlu ZSBTZXR0aW5nc19oCiAKICNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNpbmNsdWRlICJFZGl0 aW5nQmVoYXZpb3JUeXBlcy5oIgogI2luY2x1ZGUgIkZvbnRSZW5kZXJpbmdNb2RlLmgiCiAjaW5j bHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlpvb21Nb2RlLmgiCkBAIC01MCwyMSArNTEsNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFRleHREaXJlY3Rpb25TdWJtZW51QWx3YXlzSW5j bHVkZWQKICAgICB9OwogCi0gICAgLy8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWls cyB0aGF0IGFyZSBkaWZmZXJlbnQgb24gV2luZG93cyB0aGFuIE1hY2ludG9zaC4KLSAgICAvLyBX ZSB1c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBleGFtcGxlczoKLSAg ICAvLwotICAgIC8vICAgIDEpIENsaWNraW5nIGJlbG93IHRoZSBsYXN0IGxpbmUgb2YgYW4gZWRp dGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kCi0gICAgLy8gICAgICAgb2YgdGhl IGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24g V2luZG93cy4KLSAgICAvLyAgICAyKSBQdXNoaW5nIHRoZSBkb3duIGFycm93IGtleSBvbiB0aGUg bGFzdCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQgb2YgdGhlCi0gICAgLy8gICAgICAg bGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWlsYXIg Y2FzZSBleGlzdHMgb24gdGhlCi0gICAgLy8gICAgICAgdG9wIGxpbmUuCi0gICAgLy8KLSAgICAv LyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhh dmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCi0gICAgLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZp ZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3Rl IGFuZAotICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBkb3VibGUgY2xpY2spIHRo YXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCi0gICAgLy8gaWYgcG9zc2libGUgaW4g dGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7IEVkaXRpbmdNYWNCZWhhdmlv ciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OwotCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJs aWMgTm9uY29weWFibGUgewogICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSopOwpA QCAtMjcwLDkgKzI1Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRB bGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyhib29sKTsKICAgICAgICAgYm9vbCBhbGxvd1Njcmlw dHNUb0Nsb3NlV2luZG93cygpIGNvbnN0IHsgcmV0dXJuIG1fYWxsb3dTY3JpcHRzVG9DbG9zZVdp bmRvd3M7IH0KIAotICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVoYXZp b3IgYmVoYXZpb3IpIHsgbV9lZGl0aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsgfQotICAgICAgICBF ZGl0aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2aW9yKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nh c3Q8RWRpdGluZ0JlaGF2aW9yPihtX2VkaXRpbmdCZWhhdmlvcik7IH0KLSAgICAgICAgCisgICAg ICAgIHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBlIGJlaGF2 aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yVHlwZSA9IGJlaGF2aW9yOyB9CisgICAgICAgIEVkaXRp bmdCZWhhdmlvclR5cGUgZWRpdGluZ0JlaGF2aW9yVHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRp Y19jYXN0PEVkaXRpbmdCZWhhdmlvclR5cGU+KG1fZWRpdGluZ0JlaGF2aW9yVHlwZSk7IH0KKwog ICAgICAgICB2b2lkIHNldERvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZChib29sKTsKICAg ICAgICAgYm9vbCBkb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoKSBjb25zdCB7IHJldHVy biBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZDsgfQogCkBAIC0zODAsNyArMzY2LDcg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZW5mb3JjZUNTU01JTUVUeXBl SW5TdHJpY3RNb2RlIDogMTsKICAgICAgICAgYm9vbCBtX3VzZXNFbmNvZGluZ0RldGVjdG9yIDog MTsKICAgICAgICAgYm9vbCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzIDogMTsKLSAgICAg ICAgdW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3IgOiAxOworICAgICAgICB1bnNpZ25lZCBtX2Vk aXRpbmdCZWhhdmlvclR5cGUgOiAxOwogICAgICAgICBib29sIG1fZG93bmxvYWRhYmxlQmluYXJ5 Rm9udHNFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX3hzc0F1ZGl0b3JFbmFibGVkIDogMTsK ICAgICAgICAgYm9vbCBtX2FjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkIDogMTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckJsb2NrLmNwcAppbmRleCA2ZmJlYTE0Li4wOWVlOWM0IDEwMDY0NAotLS0gYS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyQmxvY2suY3BwCkBAIC0zNzE4LDE2ICszNzE4LDE1IEBAIFZpc2libGVQb3NpdGlvbiBS ZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQ b2ludCYKICAgICAgICAgfQogICAgIH0KIAotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3Vt ZW50KCktPnNldHRpbmdzKCk7Ci0gICAgYm9vbCB1c2VXaW5kb3dzQmVoYXZpb3IgPSBzZXR0aW5n cyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlv cjsKKyAgICBib29sIG1vdmVDYXJldFRvQm91bmRhcnkgPSBkb2N1bWVudCgpLT5mcmFtZSgpLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdo ZW5QYXN0VG9wT3JCb3R0b20oKTsKIAotICAgIGlmICh1c2VXaW5kb3dzQmVoYXZpb3IgJiYgIWNs b3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKKyAgICBpZiAoIW1vdmVDYXJl dFRvQm91bmRhcnkgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsK ICAgICAgICAgLy8geSBjb29yZGluYXRlIGlzIGJlbG93IGxhc3Qgcm9vdCBsaW5lIGJveCwgcHJl dGVuZCB3ZSBoaXQgaXQKICAgICAgICAgY2xvc2VzdEJveCA9IGxhc3RSb290Qm94V2l0aENoaWxk cmVuLT5jbG9zZXN0TGVhZkNoaWxkRm9yWFBvcyhwb2ludEluQ29udGVudHMueCgpKTsKICAgICB9 CiAKICAgICBpZiAoY2xvc2VzdEJveCkgewotICAgICAgICBpZiAoIXVzZVdpbmRvd3NCZWhhdmlv ciAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5l VG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CisgICAgICAgIGlmIChtb3Zl Q2FyZXRUb0JvdW5kYXJ5ICYmIHBvaW50SW5Db250ZW50cy55KCkgPCBmaXJzdFJvb3RCb3hXaXRo Q2hpbGRyZW4tPmxpbmVUb3AoKSAtIHZlcnRpY2FsTGluZUNsaWNrRnVkZ2VGYWN0b3IpIHsKICAg ICAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBhYm92ZSBmaXJzdCByb290IGxpbmUgYm94LCBz byByZXR1cm4gdGhlIHN0YXJ0IG9mIHRoZSBmaXJzdAogICAgICAgICAgICAgcmV0dXJuIFZpc2li bGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmZpcnN0 TGVhZkNoaWxkKCksIHRydWUpLCBET1dOU1RSRUFNKTsKICAgICAgICAgfQpAQCAtMzczOCw3ICsz NzM3LDcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0 aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogCiAgICAgaWYgKGxhc3RSb290Qm94V2l0 aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9yIE1hYyBiZWhhdmlv ciB3aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgotICAgICAgICBB U1NFUlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIEFTU0VSVChtb3ZlQ2FyZXRUb0Jv dW5kYXJ5KTsKICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChs YXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGFzdExlYWZDaGlsZCgpLCBmYWxzZSksIERPV05TVFJF QU0pOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggN2JmNTc5MC4uYzE2NzBhNiAxMDA2NDQKLS0t IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0 b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2Rl IG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1l ZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0 bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQv IGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1wbC5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9y KToKKwogMjAxMC0wNi0wMSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5j b20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjYwNDcwLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4IDk0Njc4MmIuLjdlODlhNzcgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKQEAgLTI3MSw3ICsyNzEsNyBAQCB2 b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0U2hvd0RlYnVnQm9yZGVycyhib29sIHNob3cpCiAKIHZv aWQgV2ViU2V0dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJl aGF2aW9yKQogewotICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihzdGF0aWNfY2Fz dDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CisgICAgbV9zZXR0aW5ncy0+ c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZp b3JUeXBlPihiZWhhdmlvcikpOwogfQogCiB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0QWNjZWxl cmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQoYm9vbCBlbmFibGVkKQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBkMjk4YjQ4Li44MmQ1 NDdlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0No YW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9u aWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3Ig Y29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJl bmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdz LmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2Vi S2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2 YXRlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6Y29yZSk6CisgICAgICAgICogd2Via2l0L3dlYmtp dHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAg ICh3ZWJraXRfd2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKToKKyAgICAgICAgKHdlYmtpdF93ZWJf dmlld19zZXR0aW5nc19ub3RpZnkpOgorCiAyMDEwLTA1LTMxICBHdXN0YXZvIE5vcm9uaGEgU2ls dmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKaW5kZXggZDI3NDcw OC4uNzA5ZGM1ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5j cHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKQEAgLTEyOSw5ICsx MjksOSBAQCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jlc3Bv bnNlKiByZXNwb25zZSkKICAgICByZXR1cm4gUmVzb3VyY2VSZXNwb25zZSgpOwogfQogCi1XZWJD b3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSkKK1dl YkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlw ZSkKIHsKLSAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcil0eXBlOworICAgIHJl dHVybiAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSl0eXBlOwogfQogCiBXZWJLaXRIaXRU ZXN0UmVzdWx0KiBraXQoY29uc3QgV2ViQ29yZTo6SGl0VGVzdFJlc3VsdCYgcmVzdWx0KQpkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDA1N2IwZTUuLjZhZWNjMTMgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKQEAgLTk1LDcgKzk1LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAK ICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZSk7CiAKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRF ZGl0aW5nQmVoYXZpb3IgdHlwZSk7CisgICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZSBj b3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKIAogICAgIFdlYktpdFNlY3VyaXR5T3Jp Z2luKiBraXQoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qKTsKICAgICBXZWJDb3JlOjpTZWN1cml0 eU9yaWdpbiogY29yZShXZWJLaXRTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmNwcAppbmRleCA5MTM1NGZkLi4xODQ4MjQ1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmNwcApAQCAtMjY5NSw3ICsyNjk1LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92 aWV3X3VwZGF0ZV9zZXR0aW5ncyhXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQogICAgIHNldHRpbmdz LT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5KGphdmFzY3JpcHRDYW5P cGVuV2luZG93cyk7CiAgICAgc2V0dGluZ3MtPnNldEphdmFTY3JpcHRDYW5BY2Nlc3NDbGlwYm9h cmQoamF2YVNjcmlwdENhbkFjY2Vzc0NsaXBib2FyZCk7CiAgICAgc2V0dGluZ3MtPnNldE9mZmxp bmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChlbmFibGVPZmZsaW5lV2ViQXBwQ2FjaGUpOwot ICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsK KyAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKGVkaXRpbmdCZWhhdmlv cikpOwogICAgIHNldHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhl bmFibGVVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSSSk7CiAgICAgc2V0dGluZ3MtPnNldEFsbG93 RmlsZUFjY2Vzc0Zyb21GaWxlVVJMcyhlbmFibGVGaWxlQWNjZXNzRnJvbUZpbGVVUkkpOwogICAg IHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoZW5hYmxlRE9NUGFzdGUpOwpAQCAtMjc5Niw3 ICsyNzk2LDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeShX ZWJLaXRXZWJTZXR0aW5ncyogd2ViU2V0dGluZ3MsIEdQYXIKICAgICBlbHNlIGlmIChuYW1lID09 IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLW9mZmxpbmUtd2ViLWFwcGxpY2F0aW9uLWNhY2hlIikp CiAgICAgICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQo Z192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50 ZXJuX3N0cmluZygiZWRpdGluZy1iZWhhdmlvciIpKQotICAgICAgICBzZXR0aW5ncy0+c2V0RWRp dGluZ0JlaGF2aW9yKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0JlaGF2aW9yPihnX3Zh bHVlX2dldF9lbnVtKCZ2YWx1ZSkpKSk7CisgICAgICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVo YXZpb3JUeXBlKGNvcmUoc3RhdGljX2Nhc3Q8V2ViS2l0RWRpdGluZ0JlaGF2aW9yPihnX3ZhbHVl X2dldF9lbnVtKCZ2YWx1ZSkpKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJp bmcoImVuYWJsZS11bml2ZXJzYWwtYWNjZXNzLWZyb20tZmlsZS11cmlzIikpCiAgICAgICAgIHNl dHRpbmdzLT5zZXRBbGxvd1VuaXZlcnNhbEFjY2Vzc0Zyb21GaWxlVVJMcyhnX3ZhbHVlX2dldF9i b29sZWFuKCZ2YWx1ZSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJl bmFibGUtZmlsZS1hY2Nlc3MtZnJvbS1maWxlLXVyaXMiKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9t YWMvQ2hhbmdlTG9nIGIvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggN2Q4OGZlZC4uMzcwZjZk OCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L21hYy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlr aXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNv ZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5h bWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5o IHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktp dC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJWaWV3L1dlYkZyYW1lLm1t OgorICAgICAgICAoY29yZSk6CisgICAgICAgICogV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmg6 CisgICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOgorICAgICAgICAoLVtXZWJWaWV3IF9wcmVm ZXJlbmNlc0NoYW5nZWROb3RpZmljYXRpb246XSk6CisKIDIwMTAtMDUtMzAgIERhcmluIEFkbGVy ICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCmRp ZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0gYi9XZWJLaXQvbWFjL1dl YlZpZXcvV2ViRnJhbWUubW0KaW5kZXggOTk5ZjE3Ny4uN2M1OTYxNSAxMDA2NDQKLS0tIGEvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJG cmFtZS5tbQpAQCAtMTk2LDcgKzE5Niw3IEBAIEVkaXRhYmxlTGlua0JlaGF2aW9yIGNvcmUoV2Vi S2l0RWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZpb3IpCiAgICAgcmV0dXJu IEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQorV2ViQ29yZTo6RWRpdGlu Z0JlaGF2aW9yVHlwZSBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKICAg ICBzd2l0Y2ggKGJlaGF2aW9yKSB7CiAgICAgICAgIGNhc2UgV2ViS2l0RWRpdGluZ01hY0JlaGF2 aW9yOgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaCBi L1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKaW5kZXggOWIyMjQ4YS4uNTg2 YjRjMyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaAor KysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCkBAIC03MSw3ICs3MSw3 IEBAIFdlYlZpZXcgKmtpdChXZWJDb3JlOjpQYWdlKik7CiAKIFdlYkNvcmU6OkVkaXRhYmxlTGlu a0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGFibGVMaW5rQmVoYXZpb3IpOwogV2ViQ29yZTo6VGV4 dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciBjb3JlKFdlYlRleHREaXJlY3Rpb25T dWJtZW51SW5jbHVzaW9uQmVoYXZpb3IpOwotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUo V2ViS2l0RWRpdGluZ0JlaGF2aW9yKTsKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29y ZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IpOwogCiBXZWJWaWV3ICpnZXRXZWJWaWV3KFdlYkZyYW1l ICp3ZWJGcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1t IGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KaW5kZXggOTdjNzk5Yi4uOWYzYWQ2MCAx MDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KKysrIGIvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXcubW0KQEAgLTEzNjksNyArMTM2OSw3IEBAIHN0YXRpYyBib29sIGZh c3REb2N1bWVudFRlYXJkb3duRW5hYmxlZCgpCiAgICAgc2V0dGluZ3MtPnNldFRleHRBcmVhc0Fy ZVJlc2l6YWJsZShbcHJlZmVyZW5jZXMgdGV4dEFyZWFzQXJlUmVzaXphYmxlXSk7CiAgICAgc2V0 dGluZ3MtPnNldFNocmlua3NTdGFuZGFsb25lSW1hZ2VzVG9GaXQoW3ByZWZlcmVuY2VzIHNocmlu a3NTdGFuZGFsb25lSW1hZ2VzVG9GaXRdKTsKICAgICBzZXR0aW5ncy0+c2V0RWRpdGFibGVMaW5r QmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMgZWRpdGFibGVMaW5rQmVoYXZpb3JdKSk7Ci0gICAg c2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyBlZGl0aW5nQmVo YXZpb3JdKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoY29yZShbcHJl ZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5zZXRUZXh0RGlyZWN0 aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIHRleHREaXJlY3Rp b25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3JdKSk7CiAgICAgc2V0dGluZ3MtPnNldERPTVBhc3Rl QWxsb3dlZChbcHJlZmVyZW5jZXMgaXNET01QYXN0ZUFsbG93ZWRdKTsKICAgICBzZXR0aW5ncy0+ c2V0VXNlc1BhZ2VDYWNoZShbc2VsZiB1c2VzUGFnZUNhY2hlXSk7CmRpZmYgLS1naXQgYS9XZWJL aXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCA5YTVkNWFjLi42NGUz NTM4IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlr aXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNv ZGUgb3V0IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5h bWVkIHRvIEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5o IHRvCisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktp dC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9EdW1w UmVuZGVyVHJlZVN1cHBvcnRRdC5jcHA6CisgICAgICAgIChEdW1wUmVuZGVyVHJlZVN1cHBvcnRR dDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0wNi0wMSAgU2ltb24gSGF1c21hbm4gIDxz aW1vbi5oYXVzbWFubkBub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTGFzemxvIEdv bWJvcy4KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJl ZVN1cHBvcnRRdC5jcHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVT dXBwb3J0UXQuY3BwCmluZGV4IDBiMmU5YTUuLmE5NTFhNDkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9x dC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKKysrIGIvV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcApAQCAtNDc2LDcg KzQ3Niw3IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmVsZW1lbnREb2VzQXV0b0Nv bXBsZXRlRm9yRWxlbWVudFdpdGhJZChRV2ViRnJhbWUqCiAKIHZvaWQgRHVtcFJlbmRlclRyZWVT dXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmlu ZyYgZWRpdGluZ0JlaGF2aW9yKQogewotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3Jl RWRpdGluZ0JlaGF2aW9yOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZUVk aXRpbmdCZWhhdmlvcjsKIAogICAgIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIndpbiIpCiAgICAg ICAgIGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOwpAQCAtNDg3 LDcgKzQ4Nyw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhh dmlvcihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmluZyYKICAgICBpZiAoIWNvcmVQYWdlKQog ICAgICAgICByZXR1cm47CiAKLSAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0Jl aGF2aW9yKGNvcmVFZGl0aW5nQmVoYXZpb3IpOworICAgIGNvcmVQYWdlLT5zZXR0aW5ncygpLT5z ZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmVFZGl0aW5nQmVoYXZpb3IpOwogfQogCiB2b2lkIER1 bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpkdW1wRnJhbWVMb2FkZXIoYm9vbCBiKQpkaWZmIC0tZ2l0 IGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwppbmRleCAyOTc5 NTU2Li4yZWI2ODMyIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0NoYW5nZUxvZworKysgYi9XZWJL aXQvd2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdv bWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcg YmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVu dW0gd2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9t IFNldHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0 ZXMgaW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIFdlYlZpZXcu Y3BwOgorICAgICAgICAoV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKToKKwogMjAx MC0wNS0zMCAgRGFuaWVsIEJhdGVzICA8ZGJhdGVzQHJpbS5jb20+CiAKICAgICAgICAgVW5yZXZp ZXdlZCwgYXR0ZW1wdCB0byBmaXggdGhlIGJ1aWxkIGFmdGVyIGh0dHA6Ly90cmFjLndlYmtpdC5v cmcvY2hhbmdlc2V0LzYwNDE4LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBi L1dlYktpdC93aW4vV2ViVmlldy5jcHAKaW5kZXggNTI1MTA4Zi4uYmE1YmY0NCAxMDA2NDQKLS0t IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBA IC00NjU0LDcgKzQ2NTQsNyBAQCBIUkVTVUxUIFdlYlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hh bmdlZChJV2ViTm90aWZpY2F0aW9uKiBub3RpZmljYXRpb24pCiAgICAgaHIgPSBwcmVmZXJlbmNl cy0+ZWRpdGluZ0JlaGF2aW9yKCZlZGl0aW5nQmVoYXZpb3IpOwogICAgIGlmIChGQUlMRUQoaHIp KQogICAgICAgICByZXR1cm4gaHI7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcigo RWRpdGluZ0JlaGF2aW9yKWVkaXRpbmdCZWhhdmlvcik7CisgICAgc2V0dGluZ3MtPnNldEVkaXRp bmdCZWhhdmlvclR5cGUoKEVkaXRpbmdCZWhhdmlvclR5cGUpZWRpdGluZ0JlaGF2aW9yKTsKIAog ICAgIGhyID0gcHJlZmVyZW5jZXMtPnVzZXNQYWdlQ2FjaGUoJmVuYWJsZWQpOwogICAgIGlmIChG QUlMRUQoaHIpKQotLSAKMS43LjAuNAoK 57919 2010-06-04 14:44:58 -0700 2010-06-07 12:14:45 -0700 patch v2.3 - part I (right file) 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 37741 tonikitoo RnJvbSA1OWZjZTUyOTgyMzNhNzAwZmZiNzliMzEyYjI2ZjBkOWIyM2YwNGE5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogRnJpLCA0IEp1biAyMDEwIDE3OjEyOjMzIC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPHRvbmlraXRv b0B3ZWJraXQub3JnPgoKV2ViQ29yZToKCkFzIHBlciBkaXNjdXNzaW9uIGluIGJ1ZyAzNjYyNywg dGhlIGZvbGxvd2luZyB3YXMgc3VnZ2VzdGVkIGJ5IERhcmluIEFkbGVyOiAiYmVmb3JlIHRoZSBh ZGRpdGlvbiBvZiBhbnkKbmV3IEVkaXRpbmdCZWhhdmlvciwgSSB0aGluayB3ZSBuZWVkIHRvIGFk ZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRv IHNwZWNpZmljCmJlaGF2aW9ycyByYXRoZXIgdGhhbiBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9y ID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQK ZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50IHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuCgpQYXRj aCBpcyBhIGZpcnN0IHN0ZXAgb2YgYW4gaW5jcmVtZW50YWwgYXBwcm9hY2ggdG8gYWRkcmVzcyB0 aGlzIHJlcXVlc3QuIEl0IGRvZXMgbm90IHlldCByZXBsYWNlIGFsbApkaXJlY3QgdXNlIG9mIEVk aXRpbmd7TWFjLFdpbmRvd3N9QmVoYXZpb3JzLCBidXQgYWRkcyBpbmZyYSBmb3IgdGhhdCBhbmQg cmVwbGFjZXMgc29tZSBvZiB0aGVtLgoKTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVz dHMuCgoqIEdOVW1ha2VmaWxlLmFtOgoqIFdlYkNvcmUucHJvOgoqIFdlYkNvcmUvV2ViQ29yZS5n eXBpCiogV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagoqIFdlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCiogcGFnZS9TZXR0aW5ncy5jcHA6CihXZWJD b3JlOjpTZXR0aW5nczo6U2V0dGluZ3MpOgoqIHBhZ2UvU2V0dGluZ3MuaDogTW92ZWQgb3V0IEVk aXRpbmdCZWhhdmlvciBlbnVtIHRvIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oLAphbmQgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcy4KKFdlYkNvcmU6OlNldHRp bmdzOjpzZXRFZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBmcm9tIHNldEVkaXRpbmdCZWhh dmlvci4KKFdlYkNvcmU6OlNldHRpbmdzOjplZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBm cm9tIGVkaXRpbmdCZWhhdmlvci4KKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOiBBZGRlZC4K KFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6RWRpdGluZ0JlaGF2aW9yKTogQ2xhc3MgdG8gd29y ayBhcyBhIGNlbnRyYWwgcG9pbnQgZm9yCmVkaXRpbmcgYmVoYXZpb3IgdGhhdCBtaWdodCBoYXZl IHRvIGJlIGhhbmRsZWQgZGlmZmVyZW50bHkgaW4gdGhlIGRpZmZlcmVudCBwbGF0Zm9ybXMvcG9y dHMuCkNsYXNzIHNob3VsZCBiZSBub3QgdXNlZCBvciBpbnN0YW50aWF0ZWQgZGlyZWN0bHksIGJ1 dCByYXRoZXIgaW1wbGljaXRseSBjb25zdHJ1Y3RlZAp0aHJvdWdoIHRoZSBFZGl0b3IgY2xhc3Mu CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJv dW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNo b3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQpOgoqIGVkaXRp bmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaDogQWRkZWQuCihXZWJDb3JlOjopOgoqIGVkaXRpbmcv RWRpdG9yLmNwcDoKKFdlYkNvcmU6OkVkaXRvcjo6YmVoYXZpb3IpOiBHZXR0ZXIgZm9yIEVkaXRp bmdCZWhhdmlvciBjbGFzcy4KKiBlZGl0aW5nL0VkaXRvci5oOgoqIGVkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHA6CihXZWJDb3JlOjpleGVjdXRlVG9nZ2xlU3R5bGUpOgooV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xs ZXI6Om1vZGlmeSk6CiogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgooV2ViQ29yZTo6RXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnRTaW5nbGVDbGljayk6CiogcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcDoKKFdlYkNvcmU6OlJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElu bGluZUNoaWxkcmVuKToKCi0gQ2FsbCBzaXRlcyB3aWxsIGxvb2sgbGlrZToKaWYgKGZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRUaGlzSWZUaGF0KCkpKQogICAvLyBkbyBzb21ldGhp bmcKCldlYktpdDoKCkVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdC ZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCkVkaXRpbmdCZWhh dmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHku CgpXZWJLaXQvY2hyb21pdW06Ciogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6CihXZWJLaXQ6Oldl YlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKCldlYktpdC9ndGs6Ciogd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwOgooV2ViS2l0Ojpjb3JlKToKKiB3ZWJraXQvd2Via2l0cHJpdmF0 ZS5oOgoqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKHdlYmtpdF93ZWJfdmlld191cGRhdGVf c2V0dGluZ3MpOgood2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeSk6CgpXZWJLaXQvbWFj OgoqIFdlYlZpZXcvV2ViRnJhbWUubW06Cihjb3JlKToKKiBXZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaDoKKiBXZWJWaWV3L1dlYlZpZXcubW06CigtW1dlYlZpZXcgX3ByZWZlcmVuY2VzQ2hhbmdl ZE5vdGlmaWNhdGlvbjpdKToKCldlYktpdC9xdDoKKiBXZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVy VHJlZVN1cHBvcnRRdC5jcHA6CihEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0Jl aGF2aW9yKToKCldlYktpdC93aW46CiogV2ViVmlldy5jcHA6CihXZWJWaWV3Ojpub3RpZnlQcmVm ZXJlbmNlc0NoYW5nZWQpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICA1MyArKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvR05VbWFr ZWZpbGUuYW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL1dl YkNvcmUuZ3lwaSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29y ZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogICAgICAgICAgICAgIHwgICAgOCAr KysKIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qICAgICAgICAgIHwg ICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAg ICAgIHwgICA1OCArKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmggICAgICAgICAgICAgfCAgIDQ2ICsrKysrKysrKysrKysrKysKIFdlYkNv cmUvZWRpdGluZy9FZGl0b3IuY3BwICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMCArKysr CiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg IDMgKwogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAgICAg fCAgICA1ICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgIDIgKy0KIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5oICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAyNCArKy0tLS0tLS0KIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2Nr LmNwcCAgICAgICAgICAgICAgICAgIHwgICAgOSArKy0tCiBXZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysKIFdlYktpdC9jaHJvbWl1 bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcCAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L2d0 ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE3ICsrKysrKwog V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAgfCAgICA0 ICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8 ICAgIDIgKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAgICAgICAg ICAgIHwgICAgNCArLQogV2ViS2l0L21hYy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDE2ICsrKysrKwogV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tICAg ICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJ bnRlcm5hbC5oICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L3F0L0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiAuLi4vcXQvV2Vi Q29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwICB8ICAgIDQgKy0KIFdlYktp dC93aW4vQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysr KwogV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg ICAyICstCiAyOCBmaWxlcyBjaGFuZ2VkLCAyODcgaW5zZXJ0aW9ucygrKSwgNDAgZGVsZXRpb25z KC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5o CiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVz LmgKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDQ4MDVmMjMuLjhiYjZhYTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8g R29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGlu ZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBBcyBwZXIgZGlzY3Vzc2lv biBpbiBidWcgMzY2MjcsIERhcmluIEFkbGVyIHN1Z2dlc3RlZDogImJlZm9yZSB0aGUgYWRkaXRp b24gb2YgYW55IG5ldyBFZGl0aW5nQmVoYXZpb3IsCisgICAgICAgIEkgdGhpbmsgd2UgdG8gYWRk IGZ1bmN0aW9ucyB0byB0cmFuc2xhdGUgdGhlIG92ZXJhbGwgYmVoYXZpb3IgcG9saWN5IGludG8g c3BlY2lmaWMgYmVoYXZpb3JzIHJhdGhlciB0aGFuCisgICAgICAgIGRpcmVjdGx5IHNheWluZyAn YmVoYXZpb3IgPT0gTWFjJyBvciAnYmVoYXZpb3IgPT0gV2luZG93cycuIEhlbHBlciBmdW5jdGlv bnMgdGhhdCBleHByZXNzaW9uIHRoZSBkaWZmZXJlbnQKKyAgICAgICAgcnVsZXMgaW4gcGxhaW4g bGFuZ3VhZ2UuIi4gUGF0Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KKworICAgICAgICBObyBi ZWhhdmlvciBjaGFuZ2UsIHNvIG5vIG5ldyB0ZXN0cy4KKworICAgICAgICAqIEdOVW1ha2VmaWxl LmFtOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKyAgICAgICAgKiBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAo V2ViQ29yZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6 IE1vdmVkIG91dCBFZGl0aW5nQmVoYXZpb3IgZW51bSB0byBXZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yVHlwZXMuaCwKKyAgICAgICAgYW5kIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9y VHlwZXMuCisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0RWRpdGluZ0JlaGF2aW9yVHlw ZSk6IFJlbmFtZWQgZnJvbSBzZXRFZGl0aW5nQmVoYXZpb3IuCisgICAgICAgIChXZWJDb3JlOjpT ZXR0aW5nczo6ZWRpdGluZ0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQgZnJvbSBlZGl0aW5nQmVoYXZp b3IuCisgICAgICAgICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OkVkaXRpbmdCZWhhdmlvcik6IENsYXNzIHRvIHdv cmsgYXMgYSBjZW50cmFsIHBvaW50IGZvcgorICAgICAgICBlZGl0aW5nIGJlaGF2aW9yIHRoYXQg bWlnaHQgaGF2ZSB0byBiZSBoYW5kbGVkIGRpZmZlcmVudGx5IGluIHRoZSBkaWZmZXJlbnQgcGxh dGZvcm1zL3BvcnRzLgorICAgICAgICBDbGFzcyBzaG91bGQgYmUgbm90IHVzZWQgb3IgaW5zdGFu dGlhdGVkIGRpcmVjdGx5LCBidXQgcmF0aGVyIGltcGxpY2l0bHkgY29uc3RydWN0ZWQKKyAgICAg ICAgdGhyb3VnaCB0aGUgRWRpdG9yIGNsYXNzLgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JC b3R0b20pOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRDb25zaWRl clNlbGVjdGlvbkFzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yOjpzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVkKToKKyAgICAgICAg KiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpF ZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisgICAg ICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAgKiBl ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlv bkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpT ZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2 ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVD aGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBsaWtlOgorICAgICAg ICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJZlRoYXQoKSkpCisg ICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAyMDEwLTA1LTMwICBBbnRvbmlvIEdvbWVzICA8 dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbQppbmRleCBmYzZiODE4Li4xZGE5NzhiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1h a2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTk0OCw2ICs5NDgsOCBA QCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0QWN0aW9uLmggXAog CVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0 Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggXAorCVdlYkNv cmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRp dG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIFwKIAlXZWJDb3JlL2VkaXRpbmcv RWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBjNjZhMzJiLi5hYzBjYmQ5IDEwMDY0NAotLS0gYS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpAQCAtMTI5MSw2 ICsxMjkxLDggQEAKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRBY3Rpb24uaCcsCiAgICAgICAg ICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRp dENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCcsCisg ICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oJywKICAgICAgICAgICAg ICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yLmgnLAog ICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAnLApkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODcyN2I3OS4uYzc0 NmIzYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNv cmUucHJvCkBAIC0xMjc5LDYgKzEyNzksNyBAQCBIRUFERVJTICs9IFwKICAgICBlZGl0aW5nL0Rl bGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9EZWxldGVTZWxlY3Rpb25D b21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENvbW1hbmQuaCBcCisgICAgZWRpdGluZy9FZGl0 aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9FZGl0b3IuaCBcCiAgICAgZWRpdGluZy9Gb3Jt YXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9odG1sZWRpdGluZy5oIFwKZGlmZiAtLWdp dCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNv cmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGY2ZjQ5NjYuLmJkMzU2ZTkgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMzA0NDksNiArMzA0NDksMTQgQEAKIAkJ CQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRpdGlu Z1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCINCisJCQkJ Pg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdc RWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDljODI1ZDQuLmE3ZmUyNWIgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMDE2LDYgKzEwMTYsOCBAQAogCQk0 RTE5NTkyRTBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEUxOTU5MjgwQTM5REFDQzAwMjIwRkU1 IC8qIE1lZGlhUXVlcnlFeHAuaCAqLzsgfTsKIAkJNEYzMjg5QjUxMUE0MkFBQjAwNUFCRTdFIC8q IEluc3BlY3RvclZhbHVlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVzLmNw cCAqLzsgfTsKIAkJNEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYzMjg5QjQx MUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRS SUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTRGMTUzNERFMTFCNTMyRUMwMDIxRkQ4NiAv KiBFZGl0aW5nQmVoYXZpb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQk0RjE1MzRF MDExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4 NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCTRGRDhEMEYyMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRH Q0V2ZW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDRGRDhEMEYwMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCAqLzsgfTsKIAkJ NEZEOEQwRjMxMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhEMEYxMTE5QzcxOEIwMDJGQTgy NSAvKiBTY3JpcHRHQ0V2ZW50LmggKi87IH07CiAJCTUxMDE4NDY5MEIwODYwMkEwMDRBODI1RiAv KiBDYWNoZWRQYWdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBAIC02NjQwLDYgKzY2NDIsOCBA QAogCQk0RTE5NTkyODBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTWVkaWFRdWVyeUV4cC5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFs dWVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEluc3BlY3RvclZh bHVlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGMzI4OUI0MTFBNDJBQUIw MDVBQkU3RSAvKiBJbnNwZWN0b3JWYWx1ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gSW5zcGVjdG9yVmFsdWVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTRG MTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gRWRpdGluZ0JlaGF2aW9yLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCTRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JU eXBlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFZGl0aW5nQmVoYXZpb3JU eXBlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0RkQ4RDBGMDExOUM3MThCMDAy RkE4MjUgLyogU2NyaXB0R0NFdmVudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IHBhdGggPSBTY3JpcHRHQ0V2ZW50LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NEZEOEQwRjExMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gU2NyaXB0R0NFdmVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVkUGFnZS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDYWNoZWRQYWdlLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CkBAIC0xMzIxOSw2ICsxMzIyMyw4IEBACiAJCTkzMzA5RDg2MDk5RTY0OTEw MDU2RTU4MSAvKiBlZGl0aW5nICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJl biA9ICgKKwkJCQk0RjE1MzRERjExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaCAqLywKKwkJCQk0RjE1MzRERDExQjUzMkVDMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9y LmggKi8sCiAJCQkJRUQ1MDFEQzkwQjI0OUYzOTAwQUUxOEQ5IC8qIG1hYyAqLywKIAkJCQk5MzMw OUQ4NzA5OUU2NDkxMDA1NkU1ODEgLyogQXBwZW5kTm9kZUNvbW1hbmQuY3BwICovLAogCQkJCTkz MzA5RDg4MDk5RTY0OTEwMDU2RTU4MSAvKiBBcHBlbmROb2RlQ29tbWFuZC5oICovLApAQCAtMTk0 MTUsNiArMTk0MjEsOCBAQAogCQkJCUM1MURBOUE5MTFBRUYyQzEwMDk3OTlDNSAvKiBJREJJbmRl eFJlcXVlc3QuaCBpbiBIZWFkZXJzICovLAogCQkJCUM1QkJDOUQxMTFBRUY4MzgwMDdDMkJGRSAv KiBKU0lEQkluZGV4UmVxdWVzdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNEYzMjg5QjYxMUE0MkFB QjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oIGluIEhlYWRlcnMgKi8sCisJCQkJNEYxNTM0 REUxMUI1MzJFQzAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvci5oIGluIEhlYWRlcnMgKi8sCisJ CQkJNEYxNTM0RTAxMUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggaW4g SGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5n ID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3Iu aCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi5mZTA5ZTFiCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL0VkaXRpbmdCZWhhdmlvci5oCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZu ZGVmIEVkaXRpbmdCZWhhdmlvcl9oCisjZGVmaW5lIEVkaXRpbmdCZWhhdmlvcl9oCisKKyNpbmNs dWRlICJFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2Ns YXNzIEVkaXRpbmdCZWhhdmlvciB7CisKK3B1YmxpYzoKKyAgICBFZGl0aW5nQmVoYXZpb3IoRWRp dGluZ0JlaGF2aW9yVHlwZSB0eXBlKQorICAgICAgICA6IG1fdHlwZSh0eXBlKQorICAgIHsKKyAg ICB9CisKKyAgICAvLyBJbmRpdmlkdWFsIGZ1bmN0aW9ucyBmb3IgZWFjaCBjYXNlIHdoZXJlIHdl IGhhdmUgbW9yZSB0aGFuIG9uZSBzdHlsZSBvZiBlZGl0aW5nIGJlaGF2aW9yLgorICAgIC8vIENy ZWF0ZSBhIG5ldyBmdW5jdGlvbiBmb3IgYW55IHBsYXRmb3JtIGRpZmZlcmVuY2Ugc28gd2UgY2Fu IGNvbnRyb2wgaXQgaGVyZS4KKworICAgIC8vIFdoZW4gZXh0ZW5kaW5nIGEgc2VsZWN0aW9uIGJl eW9uZCB0aGUgdG9wIG9yIGJvdHRvbSBib3VuZGFyeSBvZiBhbiBlZGl0YWJsZSBhcmVhLAorICAg IC8vIG1haW50YWluIHRoZSBob3Jpem9udGFsIHBvc2l0aW9uIG9uIFdpbmRvd3MgYnV0IGV4dGVu ZCBpdCB0byB0aGUgYm91bmRhcnkgb2YgdGhlIGVkaXRhYmxlCisgICAgLy8gY29udGVudCBvbiBN YWMuCisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0 VG9wT3JCb3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhh dmlvcjsgfQorCisgICAgLy8gT24gV2luZG93cywgc2VsZWN0aW9ucyBzaG91bGQgYWx3YXlzIGJl IGNvbnNpZGVyZWQgYXMgZGlyZWN0aW9uYWwsIHJlZ2FyZGxlc3MgaWYgaXQgaXMKKyAgICAvLyBt b3VzZS1iYXNlZCBvciBrZXlib2FyZC1iYXNlZC4KKyAgICBib29sIHNob3VsZENvbnNpZGVyU2Vs ZWN0aW9uQXNEaXJlY3Rpb25hbCgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAhPSBFZGl0aW5nTWFj QmVoYXZpb3I7IH0KKworICAgIC8vIE9uIE1hYywgd2hlbiByZXZlYWxpbmcgYSBzZWxlY3Rpb24g KGZvciBleGFtcGxlIGFzIGEgcmVzdWx0IG9mIGEgRmluZCBvcGVyYXRpb24gb24gdGhlIEJyb3dz ZXIpLAorICAgIC8vIGNvbnRlbnQgc2hvdWxkIGJlIHNjcm9sbGVkIHN1Y2ggdGhhdCB0aGUgc2Vs ZWN0aW9uIGdldHMgY2VydGVyIGFsaWduZWQuCisgICAgYm9vbCBzaG91bGRDZW50ZXJBbGlnbldo ZW5TZWxlY3Rpb25Jc1JldmVhbGVkKCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdN YWNCZWhhdmlvcjsgfQorCitwcml2YXRlOgorICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgbV90eXBl OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRWRpdGluZ0JlaGF2 aW9yX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5o IGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uMjZiYTE4ZQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5 KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaWZuZGVmIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKKyNkZWZpbmUgRWRpdGluZ0JlaGF2 aW9yVHlwZXNfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIFRoZXJlIGFyZSBtdWx0aXBs ZSBlZGl0aW5nIGRldGFpbHMgdGhhdCBhcmUgZGlmZmVyZW50IG9uIFdpbmRvd3MgdGhhbiBNYWNp bnRvc2guCisvLyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBl eGFtcGxlczoKKy8vCisvLyAgICAxKSBDbGlja2luZyBiZWxvdyB0aGUgbGFzdCBsaW5lIG9mIGFu IGVkaXRhYmxlIGFyZWEgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZAorLy8gICAgICAgb2YgdGhl IGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24g V2luZG93cy4KKy8vICAgIDIpIFB1c2hpbmcgdGhlIGRvd24gYXJyb3cga2V5IG9uIHRoZSBsYXN0 IGxpbmUgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZCBvZiB0aGUKKy8vICAgICAgIGxhc3QgbGlu ZSBvbiBNYWMsIGJ1dCBkb2VzIG5vdGhpbmcgb24gV2luZG93cy4gQSBzaW1pbGFyIGNhc2UgZXhp c3RzIG9uIHRoZQorLy8gICAgICAgdG9wIGxpbmUuCisvLworLy8gVGhpcyBzZXR0aW5nIGlzIGlu dGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2YgYmVoYXZpb3JzLiBUaGVyZSBhcmUgc29t ZSBvdGhlcgorLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBF ZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3RlIGFuZAorLy8gc2VsZWN0aW5nIHRoZSBz cGFjZSBhZnRlciBhIGRvdWJsZSBjbGljaykgdGhhdCBjb3VsZCBiZSBjb21iaW5lZCB3aXRoIHRo aXMgaWYKKy8vIGlmIHBvc3NpYmxlIGluIHRoZSBmdXR1cmUuCitlbnVtIEVkaXRpbmdCZWhhdmlv clR5cGUgeworICAgIEVkaXRpbmdNYWNCZWhhdmlvciwKKyAgICBFZGl0aW5nV2luZG93c0JlaGF2 aW9yCit9OworCit9IC8vIFdlYkNvcmUgbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFZGl0aW5nQmVo YXZpb3JUeXBlc19oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBiL1dl YkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IDgwNDExNTkuLjU4OTM0MjMgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3IuY3BwCkBAIC02Myw2ICs2Myw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKICNpbmNs dWRlICJSZW5kZXJQYXJ0LmgiCiAjaW5jbHVkZSAiUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQuaCIK KyNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlNvdW5kLmgiCiAjaW5jbHVkZSAiVGV4 dC5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgpAQCAtOTcsNiArOTgsMTUgQEAgVmlzaWJs ZVNlbGVjdGlvbiBFZGl0b3I6OnNlbGVjdGlvbkZvckNvbW1hbmQoRXZlbnQqIGV2ZW50KQogICAg IHJldHVybiBzZWxlY3Rpb247CiB9CiAKKy8vIEZ1bmN0aW9uIGNvbnNpZGVycyBNYWMgZWRpdGlu ZyBiZWhhdmlvciBhIGZhbGxiYWNrIHdoZW4gUGFnZSBvciBTZXR0aW5ncyBpcyBub3QgYXZhaWxh YmxlLgorRWRpdGluZ0JlaGF2aW9yIEVkaXRvcjo6YmVoYXZpb3IoKSBjb25zdAoreworICAgIGlm ICghbV9mcmFtZSB8fCAhbV9mcmFtZS0+cGFnZSgpIHx8ICFtX2ZyYW1lLT5zZXR0aW5ncygpKQor ICAgICAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdNYWNCZWhhdmlvcik7CisKKyAg ICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhh dmlvclR5cGUoKSk7Cit9CisKIEVkaXRvckNsaWVudCogRWRpdG9yOjpjbGllbnQoKSBjb25zdAog ewogICAgIGlmIChQYWdlKiBwYWdlID0gbV9mcmFtZS0+cGFnZSgpKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9lZGl0aW5nL0VkaXRvci5oIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oCmluZGV4IDE3 ZGQzYmIuLjNlMjIzZGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaAorKysg Yi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlICJD bGlwYm9hcmRBY2Nlc3NQb2xpY3kuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUgIkVk aXRBY3Rpb24uaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3IuaCIKICNpbmNsdWRlICJFZGl0 b3JEZWxldGVBY3Rpb24uaCIKICNpbmNsdWRlICJFZGl0b3JJbnNlcnRBY3Rpb24uaCIKICNpbmNs dWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCkBAIC0yODEsNiArMjgyLDggQEAgcHVibGljOgog CiAgICAgS2lsbFJpbmcqIGtpbGxSaW5nKCkgY29uc3QgeyByZXR1cm4gbV9raWxsUmluZy5nZXQo KTsgfQogCisgICAgRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKCkgY29uc3Q7CisKICAgICBQYXNz UmVmUHRyPFJhbmdlPiBzZWxlY3RlZFJhbmdlKCk7CiAgICAgCiAgICAgLy8gV2Ugc2hvdWxkIG1h a2UgdGhlc2UgZnVuY3Rpb25zIHByaXZhdGUgd2hlbiB0aGVpciBjYWxsZXJzIGluIEZyYW1lIGFy ZSBtb3ZlZCBvdmVyIGhlcmUgdG8gRWRpdG9yCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcv U2VsZWN0aW9uQ29udHJvbGxlci5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJv bGxlci5jcHAKaW5kZXggZjliMzliYi4uZjJhZTVhOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0 aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rp b25Db250cm9sbGVyLmNwcApAQCAtMTY0LDcgKzE2NCw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJv bGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VU eXBpCiAgICAgaWYgKHVzZXJUcmlnZ2VyZWQpIHsKICAgICAgICAgU2Nyb2xsQWxpZ25tZW50IGFs aWdubWVudDsKIAotICAgICAgICBpZiAobV9mcmFtZS0+c2V0dGluZ3MoKSAmJiBtX2ZyYW1lLT5z ZXR0aW5ncygpLT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3IpCisgICAg ICAgIGlmIChtX2ZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDZW50ZXJBbGlnbldo ZW5TZWxlY3Rpb25Jc1JldmVhbGVkKCkpCiAgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24g PT0gQWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2Vu dGVyQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVlZGVkOwogICAgICAg ICBlbHNlCiAgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24gPT0gQWxpZ25DdXJzb3JPblNj cm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9wQWx3YXlzIDogU2Nyb2xsQWxp Z25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOwpAQCAtMjQzLDggKzI0Myw3IEBAIHZvaWQgU2Vs ZWN0aW9uQ29udHJvbGxlcjo6bm9kZVdpbGxCZVJlbW92ZWQoTm9kZSAqbm9kZSkKICAgICAKIHZv aWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbChib29sIGlzRGlyZWN0aW9u YWwpCiB7Ci0gICAgU2V0dGluZ3MqIHNldHRpbmdzID0gbV9mcmFtZSA/IG1fZnJhbWUtPnNldHRp bmdzKCkgOiAwOwotICAgIG1faXNEaXJlY3Rpb25hbCA9ICFzZXR0aW5ncyB8fCBzZXR0aW5ncy0+ ZWRpdGluZ0JlaGF2aW9yKCkgIT0gRWRpdGluZ01hY0JlaGF2aW9yIHx8IGlzRGlyZWN0aW9uYWw7 CisgICAgbV9pc0RpcmVjdGlvbmFsID0gIW1fZnJhbWUgfHwgbV9mcmFtZS0+ZWRpdG9yKCktPmJl aGF2aW9yKCkuc2hvdWxkQ29uc2lkZXJTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKCkgfHwgaXNEaXJl Y3Rpb25hbDsKIH0KIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjp3aWxsQmVNb2RpZmllZChF QWx0ZXJhdGlvbiBhbHRlciwgRURpcmVjdGlvbiBkaXJlY3Rpb24pCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BhZ2UvU2V0dGluZ3MuY3BwIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcAppbmRleCA2 ZjZiYjA0Li5kZDQwYzQzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisr KyBiL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKQEAgLTExMyw3ICsxMTMsNyBAQCBTZXR0aW5n czo6U2V0dGluZ3MoUGFnZSogcGFnZSkKICAgICAsIG1fZW5mb3JjZUNTU01JTUVUeXBlSW5TdHJp Y3RNb2RlKHRydWUpCiAgICAgLCBtX3VzZXNFbmNvZGluZ0RldGVjdG9yKGZhbHNlKQogICAgICwg bV9hbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyhmYWxzZSkKLSAgICAsIG1fZWRpdGluZ0JlaGF2 aW9yKAorICAgICwgbV9lZGl0aW5nQmVoYXZpb3JUeXBlKAogI2lmIFBMQVRGT1JNKE1BQykgfHwg KFBMQVRGT1JNKENIUk9NSVVNKSAmJiBPUyhEQVJXSU4pKQogICAgICAgICAvLyAoUExBVEZPUk0o TUFDKSBpcyBhbHdheXMgZmFsc2UgaW4gQ2hyb21pdW0sIGhlbmNlIHRoZSBleHRyYSBjb25kaXRp b24uKQogICAgICAgICBFZGl0aW5nTWFjQmVoYXZpb3IKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFn ZS9TZXR0aW5ncy5oIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKaW5kZXggZGMzYjUwZi4uNmE5 YzI1ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmgKKysrIGIvV2ViQ29yZS9w YWdlL1NldHRpbmdzLmgKQEAgLTI4LDYgKzI4LDcgQEAKICNkZWZpbmUgU2V0dGluZ3NfaAogCiAj aW5jbHVkZSAiQXRvbWljU3RyaW5nLmgiCisjaW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yVHlwZXMu aCIKICNpbmNsdWRlICJGb250UmVuZGVyaW5nTW9kZS5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNp bmNsdWRlICJab29tTW9kZS5oIgpAQCAtNTAsMjEgKzUxLDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICBUZXh0RGlyZWN0aW9uU3VibWVudUFsd2F5c0luY2x1ZGVkCiAgICAgfTsKIAot ICAgIC8vIFRoZXJlIGFyZSBtdWx0aXBsZSBlZGl0aW5nIGRldGFpbHMgdGhhdCBhcmUgZGlmZmVy ZW50IG9uIFdpbmRvd3MgdGhhbiBNYWNpbnRvc2guCi0gICAgLy8gV2UgdXNlIGEgc2luZ2xlIHN3 aXRjaCBmb3IgYWxsIG9mIHRoZW0uIFNvbWUgZXhhbXBsZXM6Ci0gICAgLy8KLSAgICAvLyAgICAx KSBDbGlja2luZyBiZWxvdyB0aGUgbGFzdCBsaW5lIG9mIGFuIGVkaXRhYmxlIGFyZWEgcHV0cyB0 aGUgY2FyZXQgYXQgdGhlIGVuZAotICAgIC8vICAgICAgIG9mIHRoZSBsYXN0IGxpbmUgb24gTWFj LCBidXQgaW4gdGhlIG1pZGRsZSBvZiB0aGUgbGFzdCBsaW5lIG9uIFdpbmRvd3MuCi0gICAgLy8g ICAgMikgUHVzaGluZyB0aGUgZG93biBhcnJvdyBrZXkgb24gdGhlIGxhc3QgbGluZSBwdXRzIHRo ZSBjYXJldCBhdCB0aGUgZW5kIG9mIHRoZQotICAgIC8vICAgICAgIGxhc3QgbGluZSBvbiBNYWMs IGJ1dCBkb2VzIG5vdGhpbmcgb24gV2luZG93cy4gQSBzaW1pbGFyIGNhc2UgZXhpc3RzIG9uIHRo ZQotICAgIC8vICAgICAgIHRvcCBsaW5lLgotICAgIC8vCi0gICAgLy8gVGhpcyBzZXR0aW5nIGlz IGludGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2YgYmVoYXZpb3JzLiBUaGVyZSBhcmUg c29tZSBvdGhlcgotICAgIC8vIGJlaGF2aW9ycyB3aXRoIGluZGl2aWR1YWwgZnVuY3Rpb24gY2Fs bHMgb24gRWRpdG9yQ2xpZW50IChzbWFydCBjb3B5IGFuZCBwYXN0ZSBhbmQKLSAgICAvLyBzZWxl Y3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNvdWxkIGJlIGNvbWJp bmVkIHdpdGggdGhpcyBpZgotICAgIC8vIGlmIHBvc3NpYmxlIGluIHRoZSBmdXR1cmUuCi0gICAg ZW51bSBFZGl0aW5nQmVoYXZpb3IgeyBFZGl0aW5nTWFjQmVoYXZpb3IsIEVkaXRpbmdXaW5kb3dz QmVoYXZpb3IgfTsKLQogICAgIGNsYXNzIFNldHRpbmdzIDogcHVibGljIE5vbmNvcHlhYmxlIHsK ICAgICBwdWJsaWM6CiAgICAgICAgIFNldHRpbmdzKFBhZ2UqKTsKQEAgLTI3MCw5ICsyNTYsOSBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0QWxsb3dTY3JpcHRzVG9DbG9z ZVdpbmRvd3MoYm9vbCk7CiAgICAgICAgIGJvb2wgYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3Mo KSBjb25zdCB7IHJldHVybiBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzOyB9CiAKLSAgICAg ICAgdm9pZCBzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKSB7IG1f ZWRpdGluZ0JlaGF2aW9yID0gYmVoYXZpb3I7IH0KLSAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVk aXRpbmdCZWhhdmlvcigpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlv cj4obV9lZGl0aW5nQmVoYXZpb3IpOyB9Ci0gICAgICAgIAorICAgICAgICB2b2lkIHNldEVkaXRp bmdCZWhhdmlvclR5cGUoRWRpdGluZ0JlaGF2aW9yVHlwZSBiZWhhdmlvcikgeyBtX2VkaXRpbmdC ZWhhdmlvclR5cGUgPSBiZWhhdmlvcjsgfQorICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlIGVk aXRpbmdCZWhhdmlvclR5cGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFZGl0aW5nQmVo YXZpb3JUeXBlPihtX2VkaXRpbmdCZWhhdmlvclR5cGUpOyB9CisKICAgICAgICAgdm9pZCBzZXRE b3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoYm9vbCk7CiAgICAgICAgIGJvb2wgZG93bmxv YWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZGFibGVC aW5hcnlGb250c0VuYWJsZWQ7IH0KIApAQCAtMzgwLDcgKzM2Niw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgYm9vbCBtX2VuZm9yY2VDU1NNSU1FVHlwZUluU3RyaWN0TW9kZSA6IDE7 CiAgICAgICAgIGJvb2wgbV91c2VzRW5jb2RpbmdEZXRlY3RvciA6IDE7CiAgICAgICAgIGJvb2wg bV9hbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyA6IDE7Ci0gICAgICAgIHVuc2lnbmVkIG1fZWRp dGluZ0JlaGF2aW9yIDogMTsKKyAgICAgICAgdW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3JUeXBl IDogMTsKICAgICAgICAgYm9vbCBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZCA6IDE7 CiAgICAgICAgIGJvb2wgbV94c3NBdWRpdG9yRW5hYmxlZCA6IDE7CiAgICAgICAgIGJvb2wgbV9h Y2NlbGVyYXRlZENvbXBvc2l0aW5nRW5hYmxlZCA6IDE7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5j cHAKaW5kZXggNmZiZWExNC4uMDllZTljNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyQmxvY2suY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApA QCAtMzcxOCwxNiArMzcxOCwxNSBAQCBWaXNpYmxlUG9zaXRpb24gUmVuZGVyQmxvY2s6OnBvc2l0 aW9uRm9yUG9pbnRXaXRoSW5saW5lQ2hpbGRyZW4oY29uc3QgSW50UG9pbnQmCiAgICAgICAgIH0K ICAgICB9CiAKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudCgpLT5zZXR0aW5ncygp OwotICAgIGJvb2wgdXNlV2luZG93c0JlaGF2aW9yID0gc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVk aXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CisgICAgYm9vbCBtb3Zl Q2FyZXRUb0JvdW5kYXJ5ID0gZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZWRpdG9yKCktPmJlaGF2aW9y KCkuc2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9t KCk7CiAKLSAgICBpZiAodXNlV2luZG93c0JlaGF2aW9yICYmICFjbG9zZXN0Qm94ICYmIGxhc3RS b290Qm94V2l0aENoaWxkcmVuKSB7CisgICAgaWYgKCFtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmICFj bG9zZXN0Qm94ICYmIGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIHkgY29v cmRpbmF0ZSBpcyBiZWxvdyBsYXN0IHJvb3QgbGluZSBib3gsIHByZXRlbmQgd2UgaGl0IGl0CiAg ICAgICAgIGNsb3Nlc3RCb3ggPSBsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+Y2xvc2VzdExlYWZD aGlsZEZvclhQb3MocG9pbnRJbkNvbnRlbnRzLngoKSk7CiAgICAgfQogCiAgICAgaWYgKGNsb3Nl c3RCb3gpIHsKLSAgICAgICAgaWYgKCF1c2VXaW5kb3dzQmVoYXZpb3IgJiYgcG9pbnRJbkNvbnRl bnRzLnkoKSA8IGZpcnN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGluZVRvcCgpIC0gdmVydGljYWxM aW5lQ2xpY2tGdWRnZUZhY3RvcikgeworICAgICAgICBpZiAobW92ZUNhcmV0VG9Cb3VuZGFyeSAm JiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9w KCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CiAgICAgICAgICAgICAvLyB5IGNv b3JkaW5hdGUgaXMgYWJvdmUgZmlyc3Qgcm9vdCBsaW5lIGJveCwgc28gcmV0dXJuIHRoZSBzdGFy dCBvZiB0aGUgZmlyc3QKICAgICAgICAgICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRp b25Gb3JCb3goZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5maXJzdExlYWZDaGlsZCgpLCB0cnVl KSwgRE9XTlNUUkVBTSk7CiAgICAgICAgIH0KQEAgLTM3MzgsNyArMzczNyw3IEBAIFZpc2libGVQ b3NpdGlvbiBSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihj b25zdCBJbnRQb2ludCYKIAogICAgIGlmIChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbikgewogICAg ICAgICAvLyBXZSBoaXQgdGhpcyBjYXNlIGZvciBNYWMgYmVoYXZpb3Igd2hlbiB0aGUgWSBjb29y ZGluYXRlIGlzIGJlbG93IHRoZSBsYXN0IGJveC4KLSAgICAgICAgQVNTRVJUKCF1c2VXaW5kb3dz QmVoYXZpb3IpOworICAgICAgICBBU1NFUlQobW92ZUNhcmV0VG9Cb3VuZGFyeSk7CiAgICAgICAg IHJldHVybiBWaXNpYmxlUG9zaXRpb24ocG9zaXRpb25Gb3JCb3gobGFzdFJvb3RCb3hXaXRoQ2hp bGRyZW4tPmxhc3RMZWFmQ2hpbGQoKSwgZmFsc2UpLCBET1dOU1RSRUFNKTsKICAgICB9CiAKZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCmluZGV4IDdiZjU3OTAuLmMxNjcwYTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2 IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3Ig cGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisK KyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2 aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGlu Z0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRp bmdseS4KKworICAgICAgICAqIHNyYy9XZWJTZXR0aW5nc0ltcGwuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJTZXR0aW5nc0ltcGw6OnNldEVkaXRpbmdCZWhhdmlvcik6CisKIDIwMTAtMDYtMDEg IFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVu cmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2MDQ3MC4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGlu Z3NJbXBsLmNwcAppbmRleCA5NDY3ODJiLi43ZTg5YTc3IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJTZXR0aW5nc0ltcGwuY3BwCkBAIC0yNzEsNyArMjcxLDcgQEAgdm9pZCBXZWJTZXR0aW5nc0lt cGw6OnNldFNob3dEZWJ1Z0JvcmRlcnMoYm9vbCBzaG93KQogCiB2b2lkIFdlYlNldHRpbmdzSW1w bDo6c2V0RWRpdGluZ0JlaGF2aW9yKEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKIHsKLSAgICBt X3NldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3Ioc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RWRpdGlu Z0JlaGF2aW9yPihiZWhhdmlvcikpOworICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlv clR5cGUoc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yVHlwZT4oYmVoYXZpb3Ip KTsKIH0KIAogdm9pZCBXZWJTZXR0aW5nc0ltcGw6OnNldEFjY2VsZXJhdGVkQ29tcG9zaXRpbmdF bmFibGVkKGJvb2wgZW5hYmxlZCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIv V2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggZDI5OGI0OC4uODJkNTQ3ZSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyMCBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlZmFj dG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRp bmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1 NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdC ZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCisgICAgICAgIEVk aXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNj b3JkaW5nbHkuCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHA6CisgICAgICAg IChXZWJLaXQ6OmNvcmUpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAg ICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAod2Via2l0X3dlYl92aWV3 X3VwZGF0ZV9zZXR0aW5ncyk6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfc2V0dGluZ3Nfbm90 aWZ5KToKKwogMjAxMC0wNS0zMSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3Jv bmhhQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCmluZGV4IGQyNzQ3MDguLjcwOWRjNWUgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCkBAIC0xMjksOSArMTI5LDkgQEAgV2ViQ29yZTo6 UmVzb3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCiAg ICAgcmV0dXJuIFJlc291cmNlUmVzcG9uc2UoKTsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCitXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCiB7Ci0gICAgcmV0dXJu IChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IpdHlwZTsKKyAgICByZXR1cm4gKFdlYkNvcmU6OkVk aXRpbmdCZWhhdmlvclR5cGUpdHlwZTsKIH0KIAogV2ViS2l0SGl0VGVzdFJlc3VsdCoga2l0KGNv bnN0IFdlYkNvcmU6OkhpdFRlc3RSZXN1bHQmIHJlc3VsdCkKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuaAppbmRleCAwNTdiMGU1Li42YWVjYzEzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o CkBAIC05NSw3ICs5NSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViQ29yZTo6UmVz b3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOwogCi0g ICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5 cGUpOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5n QmVoYXZpb3IgdHlwZSk7CiAKICAgICBXZWJLaXRTZWN1cml0eU9yaWdpbioga2l0KFdlYkNvcmU6 OlNlY3VyaXR5T3JpZ2luKik7CiAgICAgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qIGNvcmUoV2Vi S2l0U2VjdXJpdHlPcmlnaW4qKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5kZXgg OTEzNTRmZC4uMTg0ODI0NSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi dmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAgLTI2 OTUsNyArMjY5NSw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld191cGRhdGVfc2V0dGlu Z3MoV2ViS2l0V2ViVmlldyogd2ViVmlldykKICAgICBzZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENh bk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShqYXZhc2NyaXB0Q2FuT3BlbldpbmRvd3MpOwogICAg IHNldHRpbmdzLT5zZXRKYXZhU2NyaXB0Q2FuQWNjZXNzQ2xpcGJvYXJkKGphdmFTY3JpcHRDYW5B Y2Nlc3NDbGlwYm9hcmQpOwogICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25D YWNoZUVuYWJsZWQoZW5hYmxlT2ZmbGluZVdlYkFwcENhY2hlKTsKLSAgICBzZXR0aW5ncy0+c2V0 RWRpdGluZ0JlaGF2aW9yKGNvcmUoZWRpdGluZ0JlaGF2aW9yKSk7CisgICAgc2V0dGluZ3MtPnNl dEVkaXRpbmdCZWhhdmlvclR5cGUoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsKICAgICBzZXR0aW5n cy0+c2V0QWxsb3dVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSTHMoZW5hYmxlVW5pdmVyc2FsQWNj ZXNzRnJvbUZpbGVVUkkpOwogICAgIHNldHRpbmdzLT5zZXRBbGxvd0ZpbGVBY2Nlc3NGcm9tRmls ZVVSTHMoZW5hYmxlRmlsZUFjY2Vzc0Zyb21GaWxlVVJJKTsKICAgICBzZXR0aW5ncy0+c2V0RE9N UGFzdGVBbGxvd2VkKGVuYWJsZURPTVBhc3RlKTsKQEAgLTI3OTYsNyArMjc5Niw3IEBAIHN0YXRp YyB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkoV2ViS2l0V2ViU2V0dGluZ3Mq IHdlYlNldHRpbmdzLCBHUGFyCiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmco ImVuYWJsZS1vZmZsaW5lLXdlYi1hcHBsaWNhdGlvbi1jYWNoZSIpKQogICAgICAgICBzZXR0aW5n cy0+c2V0T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVkKGdfdmFsdWVfZ2V0X2Jvb2xl YW4oJnZhbHVlKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVkaXRp bmctYmVoYXZpb3IiKSkKLSAgICAgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3Jl KHN0YXRpY19jYXN0PFdlYktpdEVkaXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFs dWUpKSkpOworICAgICAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKHN0 YXRpY19jYXN0PFdlYktpdEVkaXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUp KSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlbmFibGUtdW5pdmVy c2FsLWFjY2Vzcy1mcm9tLWZpbGUtdXJpcyIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0QWxsb3dV bml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSTHMoZ192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsK ICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLWZpbGUtYWNjZXNz LWZyb20tZmlsZS11cmlzIikpCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dl YktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDdkODhmZWQuLjM3MGY2ZDggMTAwNjQ0Ci0tLSBhL1dl YktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTkgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3Rv ciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5n cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQK KworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVo YXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0 aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29y ZGluZ2x5LgorCisgICAgICAgICogV2ViVmlldy9XZWJGcmFtZS5tbToKKyAgICAgICAgKGNvcmUp OgorICAgICAgICAqIFdlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oOgorICAgICAgICAqIFdlYlZp ZXcvV2ViVmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfcHJlZmVyZW5jZXNDaGFuZ2VkTm90 aWZpY2F0aW9uOl0pOgorCiAyMDEwLTA1LTMwICBEYXJpbiBBZGxlciAgPGRhcmluQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1t CmluZGV4IDk5OWYxNzcuLjdjNTk2MTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJGcmFtZS5tbQorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KQEAgLTE5Niw3 ICsxOTYsNyBAQCBFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlua0Jl aGF2aW9yIGVkaXRhYmxlTGlua0JlaGF2aW9yKQogICAgIHJldHVybiBFZGl0YWJsZUxpbmtEZWZh dWx0QmVoYXZpb3I7CiB9CiAKLVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVk aXRpbmdCZWhhdmlvciBiZWhhdmlvcikKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29y ZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IpCiB7CiAgICAgc3dpdGNoIChiZWhhdmlv cikgewogICAgICAgICBjYXNlIFdlYktpdEVkaXRpbmdNYWNCZWhhdmlvcjoKZGlmZiAtLWdpdCBh L1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmggYi9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViRnJhbWVJbnRlcm5hbC5oCmluZGV4IDliMjI0OGEuLjU4NmI0YzMgMTAwNjQ0Ci0tLSBh L1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKKysrIGIvV2ViS2l0L21hYy9X ZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaApAQCAtNzEsNyArNzEsNyBAQCBXZWJWaWV3ICpraXQo V2ViQ29yZTo6UGFnZSopOwogCiBXZWJDb3JlOjpFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3JlKFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKTsKIFdlYkNvcmU6OlRleHREaXJlY3Rpb25TdWJtZW51 SW5jbHVzaW9uQmVoYXZpb3IgY29yZShXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJl aGF2aW9yKTsKLVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhh dmlvcik7CitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0Jl aGF2aW9yKTsKIAogV2ViVmlldyAqZ2V0V2ViVmlldyhXZWJGcmFtZSAqd2ViRnJhbWUpOwogCmRp ZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3Lm1tCmluZGV4IDk3Yzc5OWIuLjlmM2FkNjAgMTAwNjQ0Ci0tLSBhL1dlYktp dC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 Lm1tCkBAIC0xMzY5LDcgKzEzNjksNyBAQCBzdGF0aWMgYm9vbCBmYXN0RG9jdW1lbnRUZWFyZG93 bkVuYWJsZWQoKQogICAgIHNldHRpbmdzLT5zZXRUZXh0QXJlYXNBcmVSZXNpemFibGUoW3ByZWZl cmVuY2VzIHRleHRBcmVhc0FyZVJlc2l6YWJsZV0pOwogICAgIHNldHRpbmdzLT5zZXRTaHJpbmtz U3RhbmRhbG9uZUltYWdlc1RvRml0KFtwcmVmZXJlbmNlcyBzaHJpbmtzU3RhbmRhbG9uZUltYWdl c1RvRml0XSk7CiAgICAgc2V0dGluZ3MtPnNldEVkaXRhYmxlTGlua0JlaGF2aW9yKGNvcmUoW3By ZWZlcmVuY2VzIGVkaXRhYmxlTGlua0JlaGF2aW9yXSkpOwotICAgIHNldHRpbmdzLT5zZXRFZGl0 aW5nQmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOworICAgIHNl dHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRpbmdC ZWhhdmlvcl0pKTsKICAgICBzZXR0aW5ncy0+c2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNp b25CZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyB0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lv bkJlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoW3ByZWZlcmVu Y2VzIGlzRE9NUGFzdGVBbGxvd2VkXSk7CiAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUo W3NlbGYgdXNlc1BhZ2VDYWNoZV0pOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBi L1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggOWE1ZDVhYy4uNjRlMzUzOCAxMDA2NDQKLS0tIGEv V2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3Rv ciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5n cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQK KworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVo YXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0 aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29y ZGluZ2x5LgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0 UXQuY3BwOgorICAgICAgICAoRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhh dmlvcik6CisKIDIwMTAtMDYtMDEgIFNpbW9uIEhhdXNtYW5uICA8c2ltb24uaGF1c21hbm5Abm9r aWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IExhc3psbyBHb21ib3MuCmRpZmYgLS1naXQg YS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwIGIv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcAppbmRl eCAwYjJlOWE1Li5hOTUxYTQ5IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQv RHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwCisrKyBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKQEAgLTQ3Niw3ICs0NzYsNyBAQCBib29sIER1 bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjplbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVsZW1lbnRX aXRoSWQoUVdlYkZyYW1lKgogCiB2b2lkIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpzZXRFZGl0 aW5nQmVoYXZpb3IoUVdlYlBhZ2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcmIGVkaXRpbmdCZWhhdmlv cikKIHsKLSAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZUVkaXRpbmdCZWhhdmlvcjsK KyAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmVFZGl0aW5nQmVoYXZpb3I7CiAK ICAgICBpZiAoZWRpdGluZ0JlaGF2aW9yID09ICJ3aW4iKQogICAgICAgICBjb3JlRWRpdGluZ0Jl aGF2aW9yID0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKQEAgLTQ4Nyw3ICs0ODcsNyBAQCB2b2lk IER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpzZXRFZGl0aW5nQmVoYXZpb3IoUVdlYlBhZ2UqIHBh Z2UsIGNvbnN0IFFTdHJpbmcmCiAgICAgaWYgKCFjb3JlUGFnZSkKICAgICAgICAgcmV0dXJuOwog Ci0gICAgY29yZVBhZ2UtPnNldHRpbmdzKCktPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlRWRpdGlu Z0JlaGF2aW9yKTsKKyAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9y VHlwZShjb3JlRWRpdGluZ0JlaGF2aW9yKTsKIH0KIAogdm9pZCBEdW1wUmVuZGVyVHJlZVN1cHBv cnRRdDo6ZHVtcEZyYW1lTG9hZGVyKGJvb2wgYikKZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vQ2hh bmdlTG9nIGIvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKaW5kZXggMjk3OTU1Ni4uMmViNjgzMiAxMDA2 NDQKLS0tIGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3dpbi9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNS0zMSAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIFJlZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0 IG9mIFNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0zOTg1NAorCisgICAgICAgIEVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRv IEVkaXRpbmdCZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCisg ICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRq dXN0ZWQgYWNjb3JkaW5nbHkuCisKKyAgICAgICAgKiBXZWJWaWV3LmNwcDoKKyAgICAgICAgKFdl YlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdlZCk6CisKIDIwMTAtMDUtMzAgIERhbmllbCBC YXRlcyAgPGRiYXRlc0ByaW0uY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIGF0dGVtcHQgdG8g Zml4IHRoZSBidWlsZCBhZnRlciBodHRwOi8vdHJhYy53ZWJraXQub3JnL2NoYW5nZXNldC82MDQx OC4KZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vV2ViVmlldy5jcHAgYi9XZWJLaXQvd2luL1dlYlZp ZXcuY3BwCmluZGV4IDUyNTEwOGYuLmJhNWJmNDQgMTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vV2Vi Vmlldy5jcHAKKysrIGIvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcApAQCAtNDY1NCw3ICs0NjU0LDcg QEAgSFJFU1VMVCBXZWJWaWV3Ojpub3RpZnlQcmVmZXJlbmNlc0NoYW5nZWQoSVdlYk5vdGlmaWNh dGlvbiogbm90aWZpY2F0aW9uKQogICAgIGhyID0gcHJlZmVyZW5jZXMtPmVkaXRpbmdCZWhhdmlv cigmZWRpdGluZ0JlaGF2aW9yKTsKICAgICBpZiAoRkFJTEVEKGhyKSkKICAgICAgICAgcmV0dXJu IGhyOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoKEVkaXRpbmdCZWhhdmlvcill ZGl0aW5nQmVoYXZpb3IpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKChF ZGl0aW5nQmVoYXZpb3JUeXBlKWVkaXRpbmdCZWhhdmlvcik7CiAKICAgICBociA9IHByZWZlcmVu Y2VzLT51c2VzUGFnZUNhY2hlKCZlbmFibGVkKTsKICAgICBpZiAoRkFJTEVEKGhyKSkKLS0gCjEu Ny4wLjQKCg== 58070 2010-06-07 12:14:45 -0700 2010-06-07 13:55:09 -0700 patch v2.3 - part I (agaisnt ToT) 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 37749 tonikitoo RnJvbSA5MzMxZjkzNDU4YTM3Mzg3N2U1MTI1ZjY1NTVlZjAyN2RiYTZjNmIyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogRnJpLCA0IEp1biAyMDEwIDE3OjEyOjMzIC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPHRvbmlraXRv b0B3ZWJraXQub3JnPgoKV2ViQ29yZToKCkFzIHBlciBkaXNjdXNzaW9uIGluIGJ1ZyAzNjYyNywg dGhlIGZvbGxvd2luZyB3YXMgc3VnZ2VzdGVkIGJ5IERhcmluIEFkbGVyOiAiYmVmb3JlIHRoZSBh ZGRpdGlvbiBvZiBhbnkKbmV3IEVkaXRpbmdCZWhhdmlvciwgSSB0aGluayB3ZSBuZWVkIHRvIGFk ZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRv IHNwZWNpZmljCmJlaGF2aW9ycyByYXRoZXIgdGhhbiBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9y ID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQK ZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50IHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuCgpQYXRj aCBpcyBhIGZpcnN0IHN0ZXAgb2YgYW4gaW5jcmVtZW50YWwgYXBwcm9hY2ggdG8gYWRkcmVzcyB0 aGlzIHJlcXVlc3QuIEl0IGRvZXMgbm90IHlldCByZXBsYWNlIGFsbApkaXJlY3QgdXNlIG9mIEVk aXRpbmd7TWFjLFdpbmRvd3N9QmVoYXZpb3JzLCBidXQgYWRkcyBpbmZyYSBmb3IgdGhhdCBhbmQg cmVwbGFjZXMgc29tZSBvZiB0aGVtLgoKTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVz dHMuCgoqIEdOVW1ha2VmaWxlLmFtOgoqIFdlYkNvcmUucHJvOgoqIFdlYkNvcmUvV2ViQ29yZS5n eXBpCiogV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagoqIFdlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCiogcGFnZS9TZXR0aW5ncy5jcHA6CihXZWJD b3JlOjpTZXR0aW5nczo6U2V0dGluZ3MpOgoqIHBhZ2UvU2V0dGluZ3MuaDogTW92ZWQgb3V0IEVk aXRpbmdCZWhhdmlvciBlbnVtIHRvIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oLAphbmQgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcy4KKFdlYkNvcmU6OlNldHRp bmdzOjpzZXRFZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBmcm9tIHNldEVkaXRpbmdCZWhh dmlvci4KKFdlYkNvcmU6OlNldHRpbmdzOjplZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBm cm9tIGVkaXRpbmdCZWhhdmlvci4KKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOiBBZGRlZC4K KFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6RWRpdGluZ0JlaGF2aW9yKTogQ2xhc3MgdG8gd29y ayBhcyBhIGNlbnRyYWwgcG9pbnQgZm9yCmVkaXRpbmcgYmVoYXZpb3IgdGhhdCBtaWdodCBoYXZl IHRvIGJlIGhhbmRsZWQgZGlmZmVyZW50bHkgaW4gdGhlIGRpZmZlcmVudCBwbGF0Zm9ybXMvcG9y dHMuCkNsYXNzIHNob3VsZCBiZSBub3QgdXNlZCBvciBpbnN0YW50aWF0ZWQgZGlyZWN0bHksIGJ1 dCByYXRoZXIgaW1wbGljaXRseSBjb25zdHJ1Y3RlZAp0aHJvdWdoIHRoZSBFZGl0b3IgY2xhc3Mu CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJv dW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNo b3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQpOgoqIGVkaXRp bmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaDogQWRkZWQuCihXZWJDb3JlOjopOgoqIGVkaXRpbmcv RWRpdG9yLmNwcDoKKFdlYkNvcmU6OkVkaXRvcjo6YmVoYXZpb3IpOiBHZXR0ZXIgZm9yIEVkaXRp bmdCZWhhdmlvciBjbGFzcy4KKiBlZGl0aW5nL0VkaXRvci5oOgoqIGVkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHA6CihXZWJDb3JlOjpleGVjdXRlVG9nZ2xlU3R5bGUpOgooV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xs ZXI6Om1vZGlmeSk6CiogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgooV2ViQ29yZTo6RXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnRTaW5nbGVDbGljayk6CiogcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcDoKKFdlYkNvcmU6OlJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElu bGluZUNoaWxkcmVuKToKCi0gQ2FsbCBzaXRlcyB3aWxsIGxvb2sgbGlrZToKaWYgKGZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRUaGlzSWZUaGF0KCkpKQogICAvLyBkbyBzb21ldGhp bmcKCldlYktpdDoKCkVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdC ZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCkVkaXRpbmdCZWhh dmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHku CgpXZWJLaXQvY2hyb21pdW06Ciogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6CihXZWJLaXQ6Oldl YlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKCldlYktpdC9ndGs6Ciogd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwOgooV2ViS2l0Ojpjb3JlKToKKiB3ZWJraXQvd2Via2l0cHJpdmF0 ZS5oOgoqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKHdlYmtpdF93ZWJfdmlld191cGRhdGVf c2V0dGluZ3MpOgood2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeSk6CgpXZWJLaXQvbWFj OgoqIFdlYlZpZXcvV2ViRnJhbWUubW06Cihjb3JlKToKKiBXZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaDoKKiBXZWJWaWV3L1dlYlZpZXcubW06CigtW1dlYlZpZXcgX3ByZWZlcmVuY2VzQ2hhbmdl ZE5vdGlmaWNhdGlvbjpdKToKCldlYktpdC9xdDoKKiBXZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVy VHJlZVN1cHBvcnRRdC5jcHA6CihEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0Jl aGF2aW9yKToKCldlYktpdC93aW46CiogV2ViVmlldy5jcHA6CihXZWJWaWV3Ojpub3RpZnlQcmVm ZXJlbmNlc0NoYW5nZWQpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICA1MyArKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvR05VbWFr ZWZpbGUuYW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL1dl YkNvcmUuZ3lwaSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29y ZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogICAgICAgICAgICAgIHwgICAgOCAr KysKIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qICAgICAgICAgIHwg ICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAg ICAgIHwgICA1OCArKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmggICAgICAgICAgICAgfCAgIDQ2ICsrKysrKysrKysrKysrKysKIFdlYkNv cmUvZWRpdGluZy9FZGl0b3IuY3BwICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMCArKysr CiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg IDMgKwogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwICAgICAgICAgICAg fCAgICA1ICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgIDIgKy0KIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5oICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAyNCArKy0tLS0tLS0KIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2Nr LmNwcCAgICAgICAgICAgICAgICAgIHwgICAgOSArKy0tCiBXZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysKIFdlYktpdC9jaHJvbWl1 bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcCAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L2d0 ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE3ICsrKysrKwog V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAgfCAgICA0 ICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8 ICAgIDIgKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAgICAgICAg ICAgIHwgICAgNCArLQogV2ViS2l0L21hYy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDE2ICsrKysrKwogV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tICAg ICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJ bnRlcm5hbC5oICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0L3F0L0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysrCiAuLi4vcXQvV2Vi Q29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwICB8ICAgIDQgKy0KIFdlYktp dC93aW4vQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysr KwogV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg ICAyICstCiAyOCBmaWxlcyBjaGFuZ2VkLCAyODcgaW5zZXJ0aW9ucygrKSwgNDAgZGVsZXRpb25z KC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5o CiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVz LmgKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDI0ZDI4NDguLmM4ZmFhMzkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8g R29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGlu ZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBBcyBwZXIgZGlzY3Vzc2lv biBpbiBidWcgMzY2MjcsIERhcmluIEFkbGVyIHN1Z2dlc3RlZDogImJlZm9yZSB0aGUgYWRkaXRp b24gb2YgYW55IG5ldyBFZGl0aW5nQmVoYXZpb3IsCisgICAgICAgIEkgdGhpbmsgd2UgdG8gYWRk IGZ1bmN0aW9ucyB0byB0cmFuc2xhdGUgdGhlIG92ZXJhbGwgYmVoYXZpb3IgcG9saWN5IGludG8g c3BlY2lmaWMgYmVoYXZpb3JzIHJhdGhlciB0aGFuCisgICAgICAgIGRpcmVjdGx5IHNheWluZyAn YmVoYXZpb3IgPT0gTWFjJyBvciAnYmVoYXZpb3IgPT0gV2luZG93cycuIEhlbHBlciBmdW5jdGlv bnMgdGhhdCBleHByZXNzaW9uIHRoZSBkaWZmZXJlbnQKKyAgICAgICAgcnVsZXMgaW4gcGxhaW4g bGFuZ3VhZ2UuIi4gUGF0Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KKworICAgICAgICBObyBi ZWhhdmlvciBjaGFuZ2UsIHNvIG5vIG5ldyB0ZXN0cy4KKworICAgICAgICAqIEdOVW1ha2VmaWxl LmFtOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKyAgICAgICAgKiBXZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAo V2ViQ29yZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmg6 IE1vdmVkIG91dCBFZGl0aW5nQmVoYXZpb3IgZW51bSB0byBXZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yVHlwZXMuaCwKKyAgICAgICAgYW5kIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9y VHlwZXMuCisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0RWRpdGluZ0JlaGF2aW9yVHlw ZSk6IFJlbmFtZWQgZnJvbSBzZXRFZGl0aW5nQmVoYXZpb3IuCisgICAgICAgIChXZWJDb3JlOjpT ZXR0aW5nczo6ZWRpdGluZ0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQgZnJvbSBlZGl0aW5nQmVoYXZp b3IuCisgICAgICAgICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OkVkaXRpbmdCZWhhdmlvcik6IENsYXNzIHRvIHdv cmsgYXMgYSBjZW50cmFsIHBvaW50IGZvcgorICAgICAgICBlZGl0aW5nIGJlaGF2aW9yIHRoYXQg bWlnaHQgaGF2ZSB0byBiZSBoYW5kbGVkIGRpZmZlcmVudGx5IGluIHRoZSBkaWZmZXJlbnQgcGxh dGZvcm1zL3BvcnRzLgorICAgICAgICBDbGFzcyBzaG91bGQgYmUgbm90IHVzZWQgb3IgaW5zdGFu dGlhdGVkIGRpcmVjdGx5LCBidXQgcmF0aGVyIGltcGxpY2l0bHkgY29uc3RydWN0ZWQKKyAgICAg ICAgdGhyb3VnaCB0aGUgRWRpdG9yIGNsYXNzLgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JC b3R0b20pOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRDb25zaWRl clNlbGVjdGlvbkFzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yOjpzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVkKToKKyAgICAgICAg KiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29y ZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpF ZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisgICAg ICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAgICAgKiBl ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlv bkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpT ZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVy LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2 ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVD aGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBsaWtlOgorICAgICAg ICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJZlRoYXQoKSkpCisg ICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAyMDEwLTA2LTA3ICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgogCiAgICAgICAgIFJldmll d2VkIGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9X ZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IDI1Yzk0MzMuLjNjNDk5OWYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAt OTQ5LDYgKzk0OSw4IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJV2ViQ29yZS9lZGl0aW5nL0Vk aXRBY3Rpb24uaCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRDb21tYW5kLmNwcCBcCiAJV2ViQ29y ZS9lZGl0aW5nL0VkaXRDb21tYW5kLmggXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3IuaCBcCisJV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmggXAogCVdlYkNv cmUvZWRpdGluZy9FZGl0b3IuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggXAogCVdl YkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dl YkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IGM3NGQ1ODYuLjZkYWZjYzkg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5n eXBpCkBAIC0xMjkyLDYgKzEyOTIsOCBAQAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdEFjdGlv bi5oJywKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRDb21tYW5kLmNwcCcsCiAgICAgICAgICAg ICAnZWRpdGluZy9FZGl0Q29tbWFuZC5oJywKKyAgICAgICAgICAgICdlZGl0aW5nL0VkaXRpbmdC ZWhhdmlvci5oJywKKyAgICAgICAgICAgICdlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgn LAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yLmNwcCcsCiAgICAgICAgICAgICAnZWRpdGlu Zy9FZGl0b3IuaCcsCiAgICAgICAgICAgICAnZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCcsCmRp ZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRl eCA3ZDc5NDQ2Li42NTE5ZmI1IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBi L1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTEyODAsNiArMTI4MCw3IEBAIEhFQURFUlMgKz0gXAog ICAgIGVkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oIFwKICAgICBlZGl0aW5nL0Rl bGV0ZVNlbGVjdGlvbkNvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9FZGl0Q29tbWFuZC5oIFwKKyAg ICBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oIFwKICAgICBlZGl0aW5nL0VkaXRvci5oIFwKICAg ICBlZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5oIFwKICAgICBlZGl0aW5nL2h0bWxlZGl0aW5n LmggXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBi L1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXggZmU3Y2FlNy4uNWVm MGI5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagor KysgYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0zMDUwNSw2ICsz MDUwNSwxNCBAQAogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQ YXRoPSIuLlxlZGl0aW5nXEVkaXRpbmdCZWhhdmlvci5oIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0K KwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cZWRpdGluZ1xFZGl0aW5nQmVoYXZpb3JU eXBlcy5oIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0 aD0iLi5cZWRpdGluZ1xFZGl0b3IuY3BwIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KZGlmZiAtLWdp dCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViQ29yZS9X ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMzE2ZmQzYi4uNGE5MTM3OSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysr IGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTEwMTYsNiAr MTAxNiw4IEBACiAJCTRFMTk1OTJFMEEzOURBQ0MwMDIyMEZFNSAvKiBNZWRpYVF1ZXJ5RXhwLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0RTE5NTkyODBB MzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4cC5oICovOyB9OwogCQk0RjMyODlCNTExQTQy QUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMzI4OUIzMTFBNDJBQUIwMDVBQkU3RSAvKiBJbnNw ZWN0b3JWYWx1ZXMuY3BwICovOyB9OwogCQk0RjMyODlCNjExQTQyQUFCMDA1QUJFN0UgLyogSW5z cGVjdG9yVmFsdWVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA0RjMyODlCNDExQTQyQUFCMDA1QUJFN0UgLyogSW5zcGVjdG9yVmFsdWVzLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJNEYxNTM0REUxMUI1 MzJFQzAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYxNTM0REQxMUI1MzJFQzAwMjFGRDg2IC8qIEVkaXRp bmdCZWhhdmlvci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CisJCTRGMTUzNEUwMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEYxNTM0REYx MUI1MzMwMjAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvclR5cGVzLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNEZEOEQwRjIxMTlDNzE4QjAwMkZB ODI1IC8qIFNjcmlwdEdDRXZlbnQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNEZEOEQwRjAxMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQu Y3BwICovOyB9OwogCQk0RkQ4RDBGMzExOUM3MThCMDAyRkE4MjUgLyogU2NyaXB0R0NFdmVudC5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEZEOEQwRjEx MTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZlbnQuaCAqLzsgfTsKIAkJNTEwMTg0NjkwQjA4 NjAyQTAwNEE4MjVGIC8qIENhY2hlZFBhZ2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDUxMDE4NDY3MEIwODYwMkEwMDRBODI1RiAvKiBDYWNoZWRQYWdl LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTY2 NDAsNiArNjY0Miw4IEBACiAJCTRFMTk1OTI4MEEzOURBQ0MwMDIyMEZFNSAvKiBNZWRpYVF1ZXJ5 RXhwLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBNZWRpYVF1ZXJ5RXhwLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGMzI4OUIzMTFBNDJBQUIwMDVBQkU3RSAv KiBJbnNwZWN0b3JWYWx1ZXMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gSW5zcGVjdG9yVmFsdWVzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEYz Mjg5QjQxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBJbnNwZWN0b3JWYWx1ZXMuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJNEYxNTM0REQxMUI1MzJFQzAwMjFGRDg2IC8qIEVkaXRpbmdCZWhhdmlvci5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFZGl0aW5nQmVoYXZpb3IuaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNEYxNTM0REYxMUI1MzMwMjAwMjFGRDg2IC8qIEVk aXRpbmdCZWhhdmlvclR5cGVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEVk aXRpbmdCZWhhdmlvclR5cGVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRGRDhE MEYwMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNjcmlwdEdDRXZlbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk0RkQ4RDBGMTExOUM3MThCMDAyRkE4MjUgLyogU2NyaXB0R0NFdmVudC5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTY3JpcHRHQ0V2ZW50Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUxMDE4NDY3MEIwODYwMkEwMDRBODI1RiAvKiBDYWNo ZWRQYWdlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENhY2hlZFBhZ2UuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEzMjIwLDYgKzEzMjI0LDggQEAKIAkJOTMz MDlEODYwOTlFNjQ5MTAwNTZFNTgxIC8qIGVkaXRpbmcgKi8gPSB7CiAJCQlpc2EgPSBQQlhHcm91 cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0 aW5nQmVoYXZpb3JUeXBlcy5oICovLAorCQkJCTRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBF ZGl0aW5nQmVoYXZpb3IuaCAqLywKIAkJCQlFRDUwMURDOTBCMjQ5RjM5MDBBRTE4RDkgLyogbWFj ICovLAogCQkJCTkzMzA5RDg3MDk5RTY0OTEwMDU2RTU4MSAvKiBBcHBlbmROb2RlQ29tbWFuZC5j cHAgKi8sCiAJCQkJOTMzMDlEODgwOTlFNjQ5MTAwNTZFNTgxIC8qIEFwcGVuZE5vZGVDb21tYW5k LmggKi8sCkBAIC0xOTQxOCw2ICsxOTQyNCw4IEBACiAJCQkJOUZGRTNFQTYxMUI1QTQzOTAwMzc4 NzRFIC8qIEpTTWVtb3J5SW5mby5oIGluIEhlYWRlcnMgKi8sCiAJCQkJODYyNDNEMDExMUJDMzFG NzAwQ0MwMDZBIC8qIEpTQXJyYXlCdWZmZXJWaWV3SGVscGVyLmggaW4gSGVhZGVycyAqLywKIAkJ CQlCNkIwNTQwQTExQjY4RjEwMDAyNTY0QzUgLyogSURCT2JqZWN0U3RvcmVJbXBsLmggaW4gSGVh ZGVycyAqLywKKwkJCQk0RjE1MzRERTExQjUzMkVDMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9y LmggaW4gSGVhZGVycyAqLywKKwkJCQk0RjE1MzRFMDExQjUzMzAyMDAyMUZEODYgLyogRWRpdGlu Z0JlaGF2aW9yVHlwZXMuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBs b3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0 aW5nL0VkaXRpbmdCZWhhdmlvci5oIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZlMDllMWIKLS0tIC9kZXYvbnVs bAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKQEAgLTAsMCArMSw1OCBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRz IHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl CisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAg SWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwg NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgorICovCisKKyNpZm5kZWYgRWRpdGluZ0JlaGF2aW9yX2gKKyNkZWZpbmUgRWRpdGlu Z0JlaGF2aW9yX2gKKworI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlvclR5cGVzLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworY2xhc3MgRWRpdGluZ0JlaGF2aW9yIHsKKworcHVibGljOgorICAg IEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVoYXZpb3JUeXBlIHR5cGUpCisgICAgICAgIDogbV90 eXBlKHR5cGUpCisgICAgeworICAgIH0KKworICAgIC8vIEluZGl2aWR1YWwgZnVuY3Rpb25zIGZv ciBlYWNoIGNhc2Ugd2hlcmUgd2UgaGF2ZSBtb3JlIHRoYW4gb25lIHN0eWxlIG9mIGVkaXRpbmcg YmVoYXZpb3IuCisgICAgLy8gQ3JlYXRlIGEgbmV3IGZ1bmN0aW9uIGZvciBhbnkgcGxhdGZvcm0g ZGlmZmVyZW5jZSBzbyB3ZSBjYW4gY29udHJvbCBpdCBoZXJlLgorCisgICAgLy8gV2hlbiBleHRl bmRpbmcgYSBzZWxlY3Rpb24gYmV5b25kIHRoZSB0b3Agb3IgYm90dG9tIGJvdW5kYXJ5IG9mIGFu IGVkaXRhYmxlIGFyZWEsCisgICAgLy8gbWFpbnRhaW4gdGhlIGhvcml6b250YWwgcG9zaXRpb24g b24gV2luZG93cyBidXQgZXh0ZW5kIGl0IHRvIHRoZSBib3VuZGFyeSBvZiB0aGUgZWRpdGFibGUK KyAgICAvLyBjb250ZW50IG9uIE1hYy4KKyAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9yaXpv bnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAh PSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisKKyAgICAvLyBPbiBXaW5kb3dzLCBzZWxlY3Rp b25zIHNob3VsZCBhbHdheXMgYmUgY29uc2lkZXJlZCBhcyBkaXJlY3Rpb25hbCwgcmVnYXJkbGVz cyBpZiBpdCBpcworICAgIC8vIG1vdXNlLWJhc2VkIG9yIGtleWJvYXJkLWJhc2VkLgorICAgIGJv b2wgc2hvdWxkQ29uc2lkZXJTZWxlY3Rpb25Bc0RpcmVjdGlvbmFsKCkgY29uc3QgeyByZXR1cm4g bV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorCisgICAgLy8gT24gTWFjLCB3aGVuIHJl dmVhbGluZyBhIHNlbGVjdGlvbiAoZm9yIGV4YW1wbGUgYXMgYSByZXN1bHQgb2YgYSBGaW5kIG9w ZXJhdGlvbiBvbiB0aGUgQnJvd3NlciksCisgICAgLy8gY29udGVudCBzaG91bGQgYmUgc2Nyb2xs ZWQgc3VjaCB0aGF0IHRoZSBzZWxlY3Rpb24gZ2V0cyBjZXJ0ZXIgYWxpZ25lZC4KKyAgICBib29s IHNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQoKSBjb25zdCB7IHJldHVy biBtX3R5cGUgPT0gRWRpdGluZ01hY0JlaGF2aW9yOyB9CisKK3ByaXZhdGU6CisgICAgRWRpdGlu Z0JlaGF2aW9yVHlwZSBtX3R5cGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNl bmRpZiAvLyBFZGl0aW5nQmVoYXZpb3JfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0Vk aXRpbmdCZWhhdmlvclR5cGVzLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yNmJhMThlCi0tLSAvZGV2 L251bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKQEAgLTAs MCArMSw0NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBh bmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICog dmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJ TkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEg MDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgRWRpdGluZ0JlaGF2aW9yVHlwZXNfaAor I2RlZmluZSBFZGl0aW5nQmVoYXZpb3JUeXBlc19oCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor Ly8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQg b24gV2luZG93cyB0aGFuIE1hY2ludG9zaC4KKy8vIFdlIHVzZSBhIHNpbmdsZSBzd2l0Y2ggZm9y IGFsbCBvZiB0aGVtLiBTb21lIGV4YW1wbGVzOgorLy8KKy8vICAgIDEpIENsaWNraW5nIGJlbG93 IHRoZSBsYXN0IGxpbmUgb2YgYW4gZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUg ZW5kCisvLyAgICAgICBvZiB0aGUgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGluIHRoZSBtaWRkbGUg b2YgdGhlIGxhc3QgbGluZSBvbiBXaW5kb3dzLgorLy8gICAgMikgUHVzaGluZyB0aGUgZG93biBh cnJvdyBrZXkgb24gdGhlIGxhc3QgbGluZSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kIG9mIHRo ZQorLy8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dz LiBBIHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCisvLyAgICAgICB0b3AgbGluZS4KKy8vCisv LyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhh dmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCisvLyBiZWhhdmlvcnMgd2l0aCBpbmRpdmlkdWFs IGZ1bmN0aW9uIGNhbGxzIG9uIEVkaXRvckNsaWVudCAoc21hcnQgY29weSBhbmQgcGFzdGUgYW5k CisvLyBzZWxlY3RpbmcgdGhlIHNwYWNlIGFmdGVyIGEgZG91YmxlIGNsaWNrKSB0aGF0IGNvdWxk IGJlIGNvbWJpbmVkIHdpdGggdGhpcyBpZgorLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4K K2VudW0gRWRpdGluZ0JlaGF2aW9yVHlwZSB7CisgICAgRWRpdGluZ01hY0JlaGF2aW9yLAorICAg IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IKK307CisKK30gLy8gV2ViQ29yZSBuYW1lc3BhY2UKKwor I2VuZGlmIC8vIEVkaXRpbmdCZWhhdmlvclR5cGVzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRp dGluZy9FZGl0b3IuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggODA0MTE1 OS4uNTg5MzQyMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKKysrIGIv V2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlICJS ZW5kZXJCbG9jay5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJSZXBsYWNl U2VsZWN0aW9uQ29tbWFuZC5oIgorI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiU291 bmQuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCkBAIC05 Nyw2ICs5OCwxNSBAQCBWaXNpYmxlU2VsZWN0aW9uIEVkaXRvcjo6c2VsZWN0aW9uRm9yQ29tbWFu ZChFdmVudCogZXZlbnQpCiAgICAgcmV0dXJuIHNlbGVjdGlvbjsKIH0KIAorLy8gRnVuY3Rpb24g Y29uc2lkZXJzIE1hYyBlZGl0aW5nIGJlaGF2aW9yIGEgZmFsbGJhY2sgd2hlbiBQYWdlIG9yIFNl dHRpbmdzIGlzIG5vdCBhdmFpbGFibGUuCitFZGl0aW5nQmVoYXZpb3IgRWRpdG9yOjpiZWhhdmlv cigpIGNvbnN0Cit7CisgICAgaWYgKCFtX2ZyYW1lIHx8ICFtX2ZyYW1lLT5wYWdlKCkgfHwgIW1f ZnJhbWUtPnNldHRpbmdzKCkpCisgICAgICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IoRWRpdGlu Z01hY0JlaGF2aW9yKTsKKworICAgIHJldHVybiBFZGl0aW5nQmVoYXZpb3IobV9mcmFtZS0+c2V0 dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yVHlwZSgpKTsKK30KKwogRWRpdG9yQ2xpZW50KiBFZGl0 b3I6OmNsaWVudCgpIGNvbnN0CiB7CiAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBtX2ZyYW1lLT5wYWdl KCkpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggYi9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yLmgKaW5kZXggMTdkZDNiYi4uM2UyMjNkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuaApAQCAtMjksNiAr MjksNyBAQAogI2luY2x1ZGUgIkNsaXBib2FyZEFjY2Vzc1BvbGljeS5oIgogI2luY2x1ZGUgIkNv bG9yLmgiCiAjaW5jbHVkZSAiRWRpdEFjdGlvbi5oIgorI2luY2x1ZGUgIkVkaXRpbmdCZWhhdmlv ci5oIgogI2luY2x1ZGUgIkVkaXRvckRlbGV0ZUFjdGlvbi5oIgogI2luY2x1ZGUgIkVkaXRvcklu c2VydEFjdGlvbi5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIKQEAgLTI4MSw2 ICsyODIsOCBAQCBwdWJsaWM6CiAKICAgICBLaWxsUmluZyoga2lsbFJpbmcoKSBjb25zdCB7IHJl dHVybiBtX2tpbGxSaW5nLmdldCgpOyB9CiAKKyAgICBFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3Io KSBjb25zdDsKKwogICAgIFBhc3NSZWZQdHI8UmFuZ2U+IHNlbGVjdGVkUmFuZ2UoKTsKICAgICAK ICAgICAvLyBXZSBzaG91bGQgbWFrZSB0aGVzZSBmdW5jdGlvbnMgcHJpdmF0ZSB3aGVuIHRoZWly IGNhbGxlcnMgaW4gRnJhbWUgYXJlIG1vdmVkIG92ZXIgaGVyZSB0byBFZGl0b3IKZGlmZiAtLWdp dCBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcCBiL1dlYkNvcmUvZWRp dGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAppbmRleCBmOWIzOWJiLi5mMmFlNWE5IDEwMDY0 NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvV2Vi Q29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0xNjQsNyArMTY0LDcgQEAg dm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVj dGlvbiYgcywgYm9vbCBjbG9zZVR5cGkKICAgICBpZiAodXNlclRyaWdnZXJlZCkgewogICAgICAg ICBTY3JvbGxBbGlnbm1lbnQgYWxpZ25tZW50OwogCi0gICAgICAgIGlmIChtX2ZyYW1lLT5zZXR0 aW5ncygpICYmIG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRp bmdNYWNCZWhhdmlvcikKKyAgICAgICAgaWYgKG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigp LnNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQoKSkKICAgICAgICAgICAg IGFsaWdubWVudCA9IChhbGlnbiA9PSBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9s bEFsaWdubWVudDo6YWxpZ25DZW50ZXJBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2Vu dGVySWZOZWVkZWQ7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGln biA9PSBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25U b3BBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQ7CkBAIC0yNDMs OCArMjQzLDcgQEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpub2RlV2lsbEJlUmVtb3ZlZChO b2RlICpub2RlKQogICAgIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRJc0RpcmVjdGlv bmFsKGJvb2wgaXNEaXJlY3Rpb25hbCkKIHsKLSAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBtX2Zy YW1lID8gbV9mcmFtZS0+c2V0dGluZ3MoKSA6IDA7Ci0gICAgbV9pc0RpcmVjdGlvbmFsID0gIXNl dHRpbmdzIHx8IHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3IoKSAhPSBFZGl0aW5nTWFjQmVoYXZp b3IgfHwgaXNEaXJlY3Rpb25hbDsKKyAgICBtX2lzRGlyZWN0aW9uYWwgPSAhbV9mcmFtZSB8fCBt X2ZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDb25zaWRlclNlbGVjdGlvbkFzRGly ZWN0aW9uYWwoKSB8fCBpc0RpcmVjdGlvbmFsOwogfQogCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xs ZXI6OndpbGxCZU1vZGlmaWVkKEVBbHRlcmF0aW9uIGFsdGVyLCBFRGlyZWN0aW9uIGRpcmVjdGlv bikKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuY3BwCmluZGV4IDIxY2E0ZjUuLmMxOWE5YTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMTEz LDcgKzExMyw3IEBAIFNldHRpbmdzOjpTZXR0aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9lbmZv cmNlQ1NTTUlNRVR5cGVJblN0cmljdE1vZGUodHJ1ZSkKICAgICAsIG1fdXNlc0VuY29kaW5nRGV0 ZWN0b3IoZmFsc2UpCiAgICAgLCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGZhbHNlKQot ICAgICwgbV9lZGl0aW5nQmVoYXZpb3IoCisgICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5cGUoCiAj aWYgUExBVEZPUk0oTUFDKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJTikpCiAg ICAgICAgIC8vIChQTEFURk9STShNQUMpIGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1bSwgaGVu Y2UgdGhlIGV4dHJhIGNvbmRpdGlvbi4pCiAgICAgICAgIEVkaXRpbmdNYWNCZWhhdmlvcgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3Mu aAppbmRleCBlMGRiMjhkLi40ZmJiOWYyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGlu Z3MuaAorKysgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaApAQCAtMjgsNiArMjgsNyBAQAogI2Rl ZmluZSBTZXR0aW5nc19oCiAKICNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNpbmNsdWRlICJF ZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgogI2luY2x1ZGUgIkZvbnRSZW5kZXJpbmdNb2RlLmgiCiAj aW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlpvb21Nb2RlLmgiCkBAIC01MCwyMSArNTEsNiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFRleHREaXJlY3Rpb25TdWJtZW51QWx3YXlz SW5jbHVkZWQKICAgICB9OwogCi0gICAgLy8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0 YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQgb24gV2luZG93cyB0aGFuIE1hY2ludG9zaC4KLSAgICAv LyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNoIGZvciBhbGwgb2YgdGhlbS4gU29tZSBleGFtcGxlczoK LSAgICAvLwotICAgIC8vICAgIDEpIENsaWNraW5nIGJlbG93IHRoZSBsYXN0IGxpbmUgb2YgYW4g ZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBjYXJldCBhdCB0aGUgZW5kCi0gICAgLy8gICAgICAgb2Yg dGhlIGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUg b24gV2luZG93cy4KLSAgICAvLyAgICAyKSBQdXNoaW5nIHRoZSBkb3duIGFycm93IGtleSBvbiB0 aGUgbGFzdCBsaW5lIHB1dHMgdGhlIGNhcmV0IGF0IHRoZSBlbmQgb2YgdGhlCi0gICAgLy8gICAg ICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWls YXIgY2FzZSBleGlzdHMgb24gdGhlCi0gICAgLy8gICAgICAgdG9wIGxpbmUuCi0gICAgLy8KLSAg ICAvLyBUaGlzIHNldHRpbmcgaXMgaW50ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBi ZWhhdmlvcnMuIFRoZXJlIGFyZSBzb21lIG90aGVyCi0gICAgLy8gYmVoYXZpb3JzIHdpdGggaW5k aXZpZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBh c3RlIGFuZAotICAgIC8vIHNlbGVjdGluZyB0aGUgc3BhY2UgYWZ0ZXIgYSBkb3VibGUgY2xpY2sp IHRoYXQgY291bGQgYmUgY29tYmluZWQgd2l0aCB0aGlzIGlmCi0gICAgLy8gaWYgcG9zc2libGUg aW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7IEVkaXRpbmdNYWNCZWhh dmlvciwgRWRpdGluZ1dpbmRvd3NCZWhhdmlvciB9OwotCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBw dWJsaWMgTm9uY29weWFibGUgewogICAgIHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSop OwpAQCAtMjcwLDkgKzI1Niw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBz ZXRBbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cyhib29sKTsKICAgICAgICAgYm9vbCBhbGxvd1Nj cmlwdHNUb0Nsb3NlV2luZG93cygpIGNvbnN0IHsgcmV0dXJuIG1fYWxsb3dTY3JpcHRzVG9DbG9z ZVdpbmRvd3M7IH0KIAotICAgICAgICB2b2lkIHNldEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVo YXZpb3IgYmVoYXZpb3IpIHsgbV9lZGl0aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsgfQotICAgICAg ICBFZGl0aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2aW9yKCkgY29uc3QgeyByZXR1cm4gc3RhdGlj X2Nhc3Q8RWRpdGluZ0JlaGF2aW9yPihtX2VkaXRpbmdCZWhhdmlvcik7IH0KLSAgICAgICAgCisg ICAgICAgIHZvaWQgc2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBlIGJl aGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2aW9yVHlwZSA9IGJlaGF2aW9yOyB9CisgICAgICAgIEVk aXRpbmdCZWhhdmlvclR5cGUgZWRpdGluZ0JlaGF2aW9yVHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0 YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlvclR5cGU+KG1fZWRpdGluZ0JlaGF2aW9yVHlwZSk7IH0K KwogICAgICAgICB2b2lkIHNldERvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZChib29sKTsK ICAgICAgICAgYm9vbCBkb3dubG9hZGFibGVCaW5hcnlGb250c0VuYWJsZWQoKSBjb25zdCB7IHJl dHVybiBtX2Rvd25sb2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZDsgfQogCkBAIC0zODMsNyArMzY5 LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBib29sIG1fZW5mb3JjZUNTU01JTUVU eXBlSW5TdHJpY3RNb2RlIDogMTsKICAgICAgICAgYm9vbCBtX3VzZXNFbmNvZGluZ0RldGVjdG9y IDogMTsKICAgICAgICAgYm9vbCBtX2FsbG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzIDogMTsKLSAg ICAgICAgdW5zaWduZWQgbV9lZGl0aW5nQmVoYXZpb3IgOiAxOworICAgICAgICB1bnNpZ25lZCBt X2VkaXRpbmdCZWhhdmlvclR5cGUgOiAxOwogICAgICAgICBib29sIG1fZG93bmxvYWRhYmxlQmlu YXJ5Rm9udHNFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX3hzc0F1ZGl0b3JFbmFibGVkIDog MTsKICAgICAgICAgYm9vbCBtX2FjY2VsZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkIDogMTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJsb2NrLmNwcAppbmRleCA1NmFlYmQ1Li5mMjNmODkwIDEwMDY0NAotLS0g YS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQmxvY2suY3BwCkBAIC0zOTU1LDE2ICszOTU1LDE1IEBAIFZpc2libGVQb3NpdGlv biBSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJ bnRQb2ludCYKICAgICAgICAgfQogICAgIH0KIAotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRv Y3VtZW50KCktPnNldHRpbmdzKCk7Ci0gICAgYm9vbCB1c2VXaW5kb3dzQmVoYXZpb3IgPSBzZXR0 aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ1dpbmRvd3NCZWhh dmlvcjsKKyAgICBib29sIG1vdmVDYXJldFRvQm91bmRhcnkgPSBkb2N1bWVudCgpLT5mcmFtZSgp LT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFy eVdoZW5QYXN0VG9wT3JCb3R0b20oKTsKIAotICAgIGlmICh1c2VXaW5kb3dzQmVoYXZpb3IgJiYg IWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKKyAgICBpZiAoIW1vdmVD YXJldFRvQm91bmRhcnkgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4p IHsKICAgICAgICAgLy8geSBjb29yZGluYXRlIGlzIGJlbG93IGxhc3Qgcm9vdCBsaW5lIGJveCwg cHJldGVuZCB3ZSBoaXQgaXQKICAgICAgICAgY2xvc2VzdEJveCA9IGxhc3RSb290Qm94V2l0aENo aWxkcmVuLT5jbG9zZXN0TGVhZkNoaWxkRm9yWFBvcyhwb2ludEluQ29udGVudHMueCgpKTsKICAg ICB9CiAKICAgICBpZiAoY2xvc2VzdEJveCkgewotICAgICAgICBpZiAoIXVzZVdpbmRvd3NCZWhh dmlvciAmJiBwb2ludEluQ29udGVudHMueSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5s aW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVDbGlja0Z1ZGdlRmFjdG9yKSB7CisgICAgICAgIGlmICht b3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmIHBvaW50SW5Db250ZW50cy55KCkgPCBmaXJzdFJvb3RCb3hX aXRoQ2hpbGRyZW4tPmxpbmVUb3AoKSAtIHZlcnRpY2FsTGluZUNsaWNrRnVkZ2VGYWN0b3IpIHsK ICAgICAgICAgICAgIC8vIHkgY29vcmRpbmF0ZSBpcyBhYm92ZSBmaXJzdCByb290IGxpbmUgYm94 LCBzbyByZXR1cm4gdGhlIHN0YXJ0IG9mIHRoZSBmaXJzdAogICAgICAgICAgICAgcmV0dXJuIFZp c2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmZp cnN0TGVhZkNoaWxkKCksIHRydWUpLCBET1dOU1RSRUFNKTsKICAgICAgICAgfQpAQCAtMzk3NSw3 ICszOTc0LDcgQEAgVmlzaWJsZVBvc2l0aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50 V2l0aElubGluZUNoaWxkcmVuKGNvbnN0IEludFBvaW50JgogCiAgICAgaWYgKGxhc3RSb290Qm94 V2l0aENoaWxkcmVuKSB7CiAgICAgICAgIC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9yIE1hYyBiZWhh dmlvciB3aGVuIHRoZSBZIGNvb3JkaW5hdGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgotICAgICAg ICBBU1NFUlQoIXVzZVdpbmRvd3NCZWhhdmlvcik7CisgICAgICAgIEFTU0VSVChtb3ZlQ2FyZXRU b0JvdW5kYXJ5KTsKICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJv eChsYXN0Um9vdEJveFdpdGhDaGlsZHJlbi0+bGFzdExlYWZDaGlsZCgpLCBmYWxzZSksIERPV05T VFJFQU0pOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBi L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggNzEzMTVkYS4uZGYxM2VhNCAxMDA2NDQK LS0tIGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25p a2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBj b2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVu YW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3Mu aCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJL aXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1w bC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2 aW9yKToKKwogMjAxMC0wNi0wNyAgQW5kcmVpIFBvcGVzY3UgIDxhbmRyZWlwQGdvb2dsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSmVyZW15IE9ybG93LgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4IDk0Njc4MmIuLjdlODlhNzcgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYlNldHRpbmdzSW1wbC5jcHAKQEAgLTI3MSw3ICsyNzEsNyBAQCB2b2lkIFdlYlNl dHRpbmdzSW1wbDo6c2V0U2hvd0RlYnVnQm9yZGVycyhib29sIHNob3cpCiAKIHZvaWQgV2ViU2V0 dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQog ewotICAgIG1fc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihzdGF0aWNfY2FzdDxXZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2aW9yKSk7CisgICAgbV9zZXR0aW5ncy0+c2V0RWRpdGlu Z0JlaGF2aW9yVHlwZShzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlPihi ZWhhdmlvcikpOwogfQogCiB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0QWNjZWxlcmF0ZWRDb21w b3NpdGluZ0VuYWJsZWQoYm9vbCBlbmFibGVkKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFu Z2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBjZDcwMjY3Li41M2IwMWVkIDEwMDY0 NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpA QCAtMSwzICsxLDIwIEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdl YmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQg b2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFtZWQgdG8g RWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmggdG8KKyAg ICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0LyBhZGp1 c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmNwcDoK KyAgICAgICAgKFdlYktpdDo6Y29yZSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUu aDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAgICh3ZWJraXRf d2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdzKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19zZXR0 aW5nc19ub3RpZnkpOgorCiAyMDEwLTA2LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25A aWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwCmluZGV4IGQyNzQ3MDguLjcwOWRjNWUgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwCkBAIC0xMjksOSArMTI5LDkgQEAgV2ViQ29yZTo6UmVzb3VyY2VS ZXNwb25zZSBjb3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCiAgICAgcmV0dXJu IFJlc291cmNlUmVzcG9uc2UoKTsKIH0KIAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUo V2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBl IGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpCiB7Ci0gICAgcmV0dXJuIChXZWJDb3Jl OjpFZGl0aW5nQmVoYXZpb3IpdHlwZTsKKyAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvclR5cGUpdHlwZTsKIH0KIAogV2ViS2l0SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNv cmU6OkhpdFRlc3RSZXN1bHQmIHJlc3VsdCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRl eCA4NDVjMmQ2Li40NGZmYzFlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC05NSw3 ICs5NSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNw b25zZSBjb3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOwogCi0gICAgV2ViQ29y ZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpOworICAg IFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3Ig dHlwZSk7CiAKICAgICBXZWJLaXRTZWN1cml0eU9yaWdpbioga2l0KFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luKik7CiAgICAgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qIGNvcmUoV2ViS2l0U2VjdXJp dHlPcmlnaW4qKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcu Y3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5kZXggMjUzZDA5Ni4u Njc0NDczMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAgLTI3MzgsNyArMjcz OCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld191cGRhdGVfc2V0dGluZ3MoV2ViS2l0 V2ViVmlldyogd2ViVmlldykKICAgICBzZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5k b3dzQXV0b21hdGljYWxseShqYXZhc2NyaXB0Q2FuT3BlbldpbmRvd3MpOwogICAgIHNldHRpbmdz LT5zZXRKYXZhU2NyaXB0Q2FuQWNjZXNzQ2xpcGJvYXJkKGphdmFTY3JpcHRDYW5BY2Nlc3NDbGlw Ym9hcmQpOwogICAgIHNldHRpbmdzLT5zZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJs ZWQoZW5hYmxlT2ZmbGluZVdlYkFwcENhY2hlKTsKLSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0Jl aGF2aW9yKGNvcmUoZWRpdGluZ0JlaGF2aW9yKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdC ZWhhdmlvclR5cGUoY29yZShlZGl0aW5nQmVoYXZpb3IpKTsKICAgICBzZXR0aW5ncy0+c2V0QWxs b3dVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSTHMoZW5hYmxlVW5pdmVyc2FsQWNjZXNzRnJvbUZp bGVVUkkpOwogICAgIHNldHRpbmdzLT5zZXRBbGxvd0ZpbGVBY2Nlc3NGcm9tRmlsZVVSTHMoZW5h YmxlRmlsZUFjY2Vzc0Zyb21GaWxlVVJJKTsKICAgICBzZXR0aW5ncy0+c2V0RE9NUGFzdGVBbGxv d2VkKGVuYWJsZURPTVBhc3RlKTsKQEAgLTI4MzksNyArMjgzOSw3IEBAIHN0YXRpYyB2b2lkIHdl YmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkoV2ViS2l0V2ViU2V0dGluZ3MqIHdlYlNldHRp bmdzLCBHUGFyCiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVuYWJsZS1v ZmZsaW5lLXdlYi1hcHBsaWNhdGlvbi1jYWNoZSIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0T2Zm bGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVkKGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJnZhbHVl KSk7CiAgICAgZWxzZSBpZiAobmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVkaXRpbmctYmVoYXZp b3IiKSkKLSAgICAgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKHN0YXRpY19j YXN0PFdlYktpdEVkaXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOwor ICAgICAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShjb3JlKHN0YXRpY19jYXN0 PFdlYktpdEVkaXRpbmdCZWhhdmlvcj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOwogICAg IGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRlcm5fc3RyaW5nKCJlbmFibGUtdW5pdmVyc2FsLWFjY2Vz cy1mcm9tLWZpbGUtdXJpcyIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0QWxsb3dVbml2ZXJzYWxB Y2Nlc3NGcm9tRmlsZVVSTHMoZ192YWx1ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNl IGlmIChuYW1lID09IGdfaW50ZXJuX3N0cmluZygiZW5hYmxlLWZpbGUtYWNjZXNzLWZyb20tZmls ZS11cmlzIikpCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMv Q2hhbmdlTG9nCmluZGV4IDg1Zjg2ODMuLmEzMjkyMGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMv Q2hhbmdlTG9nCisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIw MTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9y bSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAg ICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBl cyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZp b3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5Lgor CisgICAgICAgICogV2ViVmlldy9XZWJGcmFtZS5tbToKKyAgICAgICAgKGNvcmUpOgorICAgICAg ICAqIFdlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViVmll dy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfcHJlZmVyZW5jZXNDaGFuZ2VkTm90aWZpY2F0aW9u Ol0pOgorCiAyMDEwLTA2LTA2ICBHYXZpbiBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l Lm1tCmluZGV4IDk5OWYxNzcuLjdjNTk2MTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmll dy9XZWJGcmFtZS5tbQorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KQEAgLTE5 Niw3ICsxOTYsNyBAQCBFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlu a0JlaGF2aW9yIGVkaXRhYmxlTGlua0JlaGF2aW9yKQogICAgIHJldHVybiBFZGl0YWJsZUxpbmtE ZWZhdWx0QmVoYXZpb3I7CiB9CiAKLVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktp dEVkaXRpbmdCZWhhdmlvciBiZWhhdmlvcikKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUg Y29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IpCiB7CiAgICAgc3dpdGNoIChiZWhh dmlvcikgewogICAgICAgICBjYXNlIFdlYktpdEVkaXRpbmdNYWNCZWhhdmlvcjoKZGlmZiAtLWdp dCBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmggYi9XZWJLaXQvbWFjL1dl YlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5oCmluZGV4IDliMjI0OGEuLjU4NmI0YzMgMTAwNjQ0Ci0t LSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZUludGVybmFsLmgKKysrIGIvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJuYWwuaApAQCAtNzEsNyArNzEsNyBAQCBXZWJWaWV3ICpr aXQoV2ViQ29yZTo6UGFnZSopOwogCiBXZWJDb3JlOjpFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3Jl KFdlYktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKTsKIFdlYkNvcmU6OlRleHREaXJlY3Rpb25TdWJt ZW51SW5jbHVzaW9uQmVoYXZpb3IgY29yZShXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lv bkJlaGF2aW9yKTsKLVdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdC ZWhhdmlvcik7CitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGlu Z0JlaGF2aW9yKTsKIAogV2ViVmlldyAqZ2V0V2ViVmlldyhXZWJGcmFtZSAqd2ViRnJhbWUpOwog CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMv V2ViVmlldy9XZWJWaWV3Lm1tCmluZGV4IDUzY2JmY2MuLjAwMjM1MDkgMTAwNjQ0Ci0tLSBhL1dl YktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tCkBAIC0xMzY5LDcgKzEzNjksNyBAQCBzdGF0aWMgYm9vbCBmYXN0RG9jdW1lbnRUZWFy ZG93bkVuYWJsZWQoKQogICAgIHNldHRpbmdzLT5zZXRUZXh0QXJlYXNBcmVSZXNpemFibGUoW3By ZWZlcmVuY2VzIHRleHRBcmVhc0FyZVJlc2l6YWJsZV0pOwogICAgIHNldHRpbmdzLT5zZXRTaHJp bmtzU3RhbmRhbG9uZUltYWdlc1RvRml0KFtwcmVmZXJlbmNlcyBzaHJpbmtzU3RhbmRhbG9uZUlt YWdlc1RvRml0XSk7CiAgICAgc2V0dGluZ3MtPnNldEVkaXRhYmxlTGlua0JlaGF2aW9yKGNvcmUo W3ByZWZlcmVuY2VzIGVkaXRhYmxlTGlua0JlaGF2aW9yXSkpOwotICAgIHNldHRpbmdzLT5zZXRF ZGl0aW5nQmVoYXZpb3IoY29yZShbcHJlZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOworICAg IHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRp bmdCZWhhdmlvcl0pKTsKICAgICBzZXR0aW5ncy0+c2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNs dXNpb25CZWhhdmlvcihjb3JlKFtwcmVmZXJlbmNlcyB0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1 c2lvbkJlaGF2aW9yXSkpOwogICAgIHNldHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoW3ByZWZl cmVuY2VzIGlzRE9NUGFzdGVBbGxvd2VkXSk7CiAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2Fj aGUoW3NlbGYgdXNlc1BhZ2VDYWNoZV0pOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxv ZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggZmQ1OGI2OS4uMjFkMTQ1NSAxMDA2NDQKLS0t IGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZh Y3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0 aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4 NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5n QmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBF ZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFj Y29yZGluZ2x5LgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwOgorICAgICAgICAoRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdC ZWhhdmlvcik6CisKIDIwMTAtMDYtMDYgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0 Lm9yZz4sIExhc3psbyBHb21ib3MgIDxsYXN6bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEtlbm5ldGggQ2hyaXN0aWFuc2VuLCBFcmljIFNlaWRlbC4KZGlmZiAt LWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5j cHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3Bw CmluZGV4IDZjM2U1YzkuLjU0ZGVlYjUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcApAQCAtNDc2LDcgKzQ3Niw3IEBAIGJv b2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9yRWxl bWVudFdpdGhJZChRV2ViRnJhbWUqCiAKIHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNl dEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmluZyYgZWRpdGluZ0Jl aGF2aW9yKQogewotICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlRWRpdGluZ0JlaGF2 aW9yOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZUVkaXRpbmdCZWhhdmlv cjsKIAogICAgIGlmIChlZGl0aW5nQmVoYXZpb3IgPT0gIndpbiIpCiAgICAgICAgIGNvcmVFZGl0 aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOwpAQCAtNDkxLDcgKzQ5MSw3IEBA IHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFn ZSogcGFnZSwgY29uc3QgUVN0cmluZyYKICAgICBpZiAoIWNvcmVQYWdlKQogICAgICAgICByZXR1 cm47CiAKLSAgICBjb3JlUGFnZS0+c2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9yKGNvcmVF ZGl0aW5nQmVoYXZpb3IpOworICAgIGNvcmVQYWdlLT5zZXR0aW5ncygpLT5zZXRFZGl0aW5nQmVo YXZpb3JUeXBlKGNvcmVFZGl0aW5nQmVoYXZpb3IpOwogfQogCiB2b2lkIER1bXBSZW5kZXJUcmVl U3VwcG9ydFF0OjpkdW1wRnJhbWVMb2FkZXIoYm9vbCBiKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dp bi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwppbmRleCA0MjJhZTg3Li5iOWNmZGIy IDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0NoYW5nZUxvZworKysgYi9XZWJLaXQvd2luL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtp dG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29k ZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFt ZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmgg dG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0 LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAgICAgICAqIFdlYlZpZXcuY3BwOgorICAgICAg ICAoV2ViVmlldzo6bm90aWZ5UHJlZmVyZW5jZXNDaGFuZ2VkKToKKwogMjAxMC0wNi0wNCAgQWxp Y2UgTGl1ICA8YWxpY2UubGl1QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBKb24g SG9uZXljdXR0LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBiL1dlYktpdC93 aW4vV2ViVmlldy5jcHAKaW5kZXggOGI3MmNlMi4uYWFkMWExYSAxMDA2NDQKLS0tIGEvV2ViS2l0 L3dpbi9XZWJWaWV3LmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBAIC00NjU0LDcg KzQ2NTQsNyBAQCBIUkVTVUxUIFdlYlZpZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdlZChJV2Vi Tm90aWZpY2F0aW9uKiBub3RpZmljYXRpb24pCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ZWRpdGlu Z0JlaGF2aW9yKCZlZGl0aW5nQmVoYXZpb3IpOwogICAgIGlmIChGQUlMRUQoaHIpKQogICAgICAg ICByZXR1cm4gaHI7Ci0gICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvcigoRWRpdGluZ0Jl aGF2aW9yKWVkaXRpbmdCZWhhdmlvcik7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlv clR5cGUoKEVkaXRpbmdCZWhhdmlvclR5cGUpZWRpdGluZ0JlaGF2aW9yKTsKIAogICAgIGhyID0g cHJlZmVyZW5jZXMtPnVzZXNQYWdlQ2FjaGUoJmVuYWJsZWQpOwogICAgIGlmIChGQUlMRUQoaHIp KQotLSAKMS43LjAuNAoK 58081 2010-06-07 13:55:09 -0700 2010-06-11 15:10:28 -0700 (committed with r60841, reviewed by Ojan and Darin) patch v2.3 - part I (agaisnt ToT and builds) 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 40461 tonikitoo RnJvbSA1NzgyYzIyMWJiZTIzN2ZmZmM5MjIxYTlhZmUyYmE2OGFiZWQ3YTFkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogRnJpLCA0IEp1biAyMDEwIDE3OjEyOjMzIC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MKIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTg1NAoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPHRvbmlraXRv b0B3ZWJraXQub3JnPgoKV2ViQ29yZToKCkFzIHBlciBkaXNjdXNzaW9uIGluIGJ1ZyAzNjYyNywg dGhlIGZvbGxvd2luZyB3YXMgc3VnZ2VzdGVkIGJ5IERhcmluIEFkbGVyOiAiYmVmb3JlIHRoZSBh ZGRpdGlvbiBvZiBhbnkKbmV3IEVkaXRpbmdCZWhhdmlvciwgSSB0aGluayB3ZSBuZWVkIHRvIGFk ZCBmdW5jdGlvbnMgdG8gdHJhbnNsYXRlIHRoZSBvdmVyYWxsIGJlaGF2aW9yIHBvbGljeSBpbnRv IHNwZWNpZmljCmJlaGF2aW9ycyByYXRoZXIgdGhhbiBkaXJlY3RseSBzYXlpbmcgJ2JlaGF2aW9y ID09IE1hYycgb3IgJ2JlaGF2aW9yID09IFdpbmRvd3MnLiBIZWxwZXIgZnVuY3Rpb25zIHRoYXQK ZXhwcmVzc2lvbiB0aGUgZGlmZmVyZW50IHJ1bGVzIGluIHBsYWluIGxhbmd1YWdlLiIuCgpQYXRj aCBpcyBhIGZpcnN0IHN0ZXAgb2YgYW4gaW5jcmVtZW50YWwgYXBwcm9hY2ggdG8gYWRkcmVzcyB0 aGlzIHJlcXVlc3QuIEl0IGRvZXMgbm90IHlldCByZXBsYWNlIGFsbApkaXJlY3QgdXNlIG9mIEVk aXRpbmd7TWFjLFdpbmRvd3N9QmVoYXZpb3JzLCBidXQgYWRkcyBpbmZyYSBmb3IgdGhhdCBhbmQg cmVwbGFjZXMgc29tZSBvZiB0aGVtLgoKTm8gYmVoYXZpb3IgY2hhbmdlLCBzbyBubyBuZXcgdGVz dHMuCgoqIEdOVW1ha2VmaWxlLmFtOgoqIFdlYkNvcmUucHJvOgoqIFdlYkNvcmUvV2ViQ29yZS5n eXBpCiogV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagoqIFdlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCiogcGFnZS9TZXR0aW5ncy5jcHA6CihXZWJD b3JlOjpTZXR0aW5nczo6U2V0dGluZ3MpOgoqIHBhZ2UvU2V0dGluZ3MuaDogTW92ZWQgb3V0IEVk aXRpbmdCZWhhdmlvciBlbnVtIHRvIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oLAphbmQgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcy4KKFdlYkNvcmU6OlNldHRp bmdzOjpzZXRFZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBmcm9tIHNldEVkaXRpbmdCZWhh dmlvci4KKFdlYkNvcmU6OlNldHRpbmdzOjplZGl0aW5nQmVoYXZpb3JUeXBlKTogUmVuYW1lZCBm cm9tIGVkaXRpbmdCZWhhdmlvci4KKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOiBBZGRlZC4K KFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6RWRpdGluZ0JlaGF2aW9yKTogQ2xhc3MgdG8gd29y ayBhcyBhIGNlbnRyYWwgcG9pbnQgZm9yCmVkaXRpbmcgYmVoYXZpb3IgdGhhdCBtaWdodCBoYXZl IHRvIGJlIGhhbmRsZWQgZGlmZmVyZW50bHkgaW4gdGhlIGRpZmZlcmVudCBwbGF0Zm9ybXMvcG9y dHMuCkNsYXNzIHNob3VsZCBiZSBub3QgdXNlZCBvciBpbnN0YW50aWF0ZWQgZGlyZWN0bHksIGJ1 dCByYXRoZXIgaW1wbGljaXRseSBjb25zdHJ1Y3RlZAp0aHJvdWdoIHRoZSBFZGl0b3IgY2xhc3Mu CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJv dW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSk6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNo b3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZENlbnRlckFsaWduV2hlblNlbGVjdGlvbklzUmV2ZWFsZWQpOgoqIGVkaXRp bmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaDogQWRkZWQuCihXZWJDb3JlOjopOgoqIGVkaXRpbmcv RWRpdG9yLmNwcDoKKFdlYkNvcmU6OkVkaXRvcjo6YmVoYXZpb3IpOiBHZXR0ZXIgZm9yIEVkaXRp bmdCZWhhdmlvciBjbGFzcy4KKiBlZGl0aW5nL0VkaXRvci5oOgoqIGVkaXRpbmcvRWRpdG9yQ29t bWFuZC5jcHA6CihXZWJDb3JlOjpleGVjdXRlVG9nZ2xlU3R5bGUpOgooV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6c2V0SXNEaXJlY3Rpb25hbCk6CihXZWJDb3JlOjpTZWxlY3Rpb25Db250 cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKToKKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xs ZXI6Om1vZGlmeSk6CiogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgooV2ViQ29yZTo6RXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnRTaW5nbGVDbGljayk6CiogcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcDoKKFdlYkNvcmU6OlJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElu bGluZUNoaWxkcmVuKToKCi0gQ2FsbCBzaXRlcyB3aWxsIGxvb2sgbGlrZToKaWYgKGZyYW1lLT5l ZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRUaGlzSWZUaGF0KCkpKQogICAvLyBkbyBzb21ldGhp bmcKCldlYktpdDoKCkVkaXRpbmdCZWhhdmlvciBlbnVtIHdhcyByZW5hbWVkIHRvIEVkaXRpbmdC ZWhhdmlvclR5cGVzIGFuZCBtb3ZlZCBvdXQgZnJvbSBTZXR0aW5ncy5oIHRvCkVkaXRpbmdCZWhh dmlvclR5cGVzLmggLiBDYWxsIHNpdGVzIGluIFdlYktpdC8gYWRqdXN0ZWQgYWNjb3JkaW5nbHku CgpXZWJLaXQvY2hyb21pdW06Ciogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6CihXZWJLaXQ6Oldl YlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKCldlYktpdC9ndGs6Ciogd2Via2l0 L3dlYmtpdHByaXZhdGUuY3BwOgooV2ViS2l0Ojpjb3JlKToKKiB3ZWJraXQvd2Via2l0cHJpdmF0 ZS5oOgoqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKHdlYmtpdF93ZWJfdmlld191cGRhdGVf c2V0dGluZ3MpOgood2Via2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeSk6CgpXZWJLaXQvbWFj OgoqIFdlYlZpZXcvV2ViRnJhbWUubW06Cihjb3JlKToKKiBXZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaDoKKiBXZWJWaWV3L1dlYlZpZXcubW06CigtW1dlYlZpZXcgX3ByZWZlcmVuY2VzQ2hhbmdl ZE5vdGlmaWNhdGlvbjpdKToKCldlYktpdC9xdDoKKiBXZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVy VHJlZVN1cHBvcnRRdC5jcHA6CihEdW1wUmVuZGVyVHJlZVN1cHBvcnRRdDo6c2V0RWRpdGluZ0Jl aGF2aW9yKToKCldlYktpdC93aW46CiogV2ViVmlldy5jcHA6CihXZWJWaWV3Ojpub3RpZnlQcmVm ZXJlbmNlc0NoYW5nZWQpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICA1MyArKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvR05VbWFr ZWZpbGUuYW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL1dl YkNvcmUuZ3lwaSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29y ZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIFdl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogICAgICAgICAgICAgIHwgICAgOCAr KysKIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qICAgICAgICAgIHwg ICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCAgICAgICAgICAgICAg ICAgIHwgICA1OCArKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmggICAgICAgICAgICAgfCAgIDQ2ICsrKysrKysrKysrKysrKysKIFdlYkNv cmUvZWRpdGluZy9FZGl0b3IuY3BwICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMCArKysr CiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmggICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg IDMgKwogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwICAgICAgICAgICAgICAgICAg fCAgICAyICstCiBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAgICAgICAg ICAgICB8ICAgIDkgKystLQogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgICAgICAgICAg ICAgICAgICAgICAgfCAgICAyICstCiBXZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYkNvcmUvcGFnZS9TZXR0aW5ncy5oICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAyNCArKy0tLS0tLS0KIFdlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckJsb2NrLmNwcCAgICAgICAgICAgICAgICAgIHwgICAgOSArKy0tCiBXZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysKIFdl YktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0dGluZ3NJbXBsLmNwcCAgICAgICAgICAgIHwgICAgMiAr LQogV2ViS2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDE3ICsrKysrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAg ICAgICAgfCAgICA0ICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAg ICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw ICAgICAgICAgICAgICAgIHwgICAgNCArLQogV2ViS2l0L21hYy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKwogV2ViS2l0L21hYy9XZWJWaWV3L1dl YkZyYW1lLm1tICAgICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJLaXQvbWFjL1dlYlZp ZXcvV2ViRnJhbWVJbnRlcm5hbC5oICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9tYWMv V2ViVmlldy9XZWJWaWV3Lm1tICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArLQogV2ViS2l0 L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrKysr CiAuLi4vcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwICB8ICAg IDQgKy0KIFdlYktpdC93aW4vQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgICAxMyArKysrKwogV2ViS2l0L3dpbi9XZWJWaWV3LmNwcCAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgICAyICstCiAzMCBmaWxlcyBjaGFuZ2VkLCAyOTEgaW5zZXJ0aW9ucygrKSwg NDQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRp bmdCZWhhdmlvci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvclR5cGVzLmgKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDIyN2FjZTYuLjFkMGE2NzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIwMTAtMDUt MzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBl bmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBBcyBw ZXIgZGlzY3Vzc2lvbiBpbiBidWcgMzY2MjcsIERhcmluIEFkbGVyIHN1Z2dlc3RlZDogImJlZm9y ZSB0aGUgYWRkaXRpb24gb2YgYW55IG5ldyBFZGl0aW5nQmVoYXZpb3IsCisgICAgICAgIEkgdGhp bmsgd2UgdG8gYWRkIGZ1bmN0aW9ucyB0byB0cmFuc2xhdGUgdGhlIG92ZXJhbGwgYmVoYXZpb3Ig cG9saWN5IGludG8gc3BlY2lmaWMgYmVoYXZpb3JzIHJhdGhlciB0aGFuCisgICAgICAgIGRpcmVj dGx5IHNheWluZyAnYmVoYXZpb3IgPT0gTWFjJyBvciAnYmVoYXZpb3IgPT0gV2luZG93cycuIEhl bHBlciBmdW5jdGlvbnMgdGhhdCBleHByZXNzaW9uIHRoZSBkaWZmZXJlbnQKKyAgICAgICAgcnVs ZXMgaW4gcGxhaW4gbGFuZ3VhZ2UuIi4gUGF0Y2ggYWRkcmVzc2VzIHRoaXMgcmVxdWVzdC4KKwor ICAgICAgICBObyBiZWhhdmlvciBjaGFuZ2UsIHNvIG5vIG5ldyB0ZXN0cy4KKworICAgICAgICAq IEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNv cmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKyAgICAgICAgKiBXZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6U2V0dGluZ3M6OlNldHRpbmdzKToKKyAgICAgICAgKiBwYWdl L1NldHRpbmdzLmg6IE1vdmVkIG91dCBFZGl0aW5nQmVoYXZpb3IgZW51bSB0byBXZWJDb3JlL2Vk aXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlwZXMuaCwKKyAgICAgICAgYW5kIHJlbmFtZWQgdG8gRWRp dGluZ0JlaGF2aW9yVHlwZXMuCisgICAgICAgIChXZWJDb3JlOjpTZXR0aW5nczo6c2V0RWRpdGlu Z0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQgZnJvbSBzZXRFZGl0aW5nQmVoYXZpb3IuCisgICAgICAg IChXZWJDb3JlOjpTZXR0aW5nczo6ZWRpdGluZ0JlaGF2aW9yVHlwZSk6IFJlbmFtZWQgZnJvbSBl ZGl0aW5nQmVoYXZpb3IuCisgICAgICAgICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OkVkaXRpbmdCZWhhdmlvcik6 IENsYXNzIHRvIHdvcmsgYXMgYSBjZW50cmFsIHBvaW50IGZvcgorICAgICAgICBlZGl0aW5nIGJl aGF2aW9yIHRoYXQgbWlnaHQgaGF2ZSB0byBiZSBoYW5kbGVkIGRpZmZlcmVudGx5IGluIHRoZSBk aWZmZXJlbnQgcGxhdGZvcm1zL3BvcnRzLgorICAgICAgICBDbGFzcyBzaG91bGQgYmUgbm90IHVz ZWQgb3IgaW5zdGFudGlhdGVkIGRpcmVjdGx5LCBidXQgcmF0aGVyIGltcGxpY2l0bHkgY29uc3Ry dWN0ZWQKKyAgICAgICAgdGhyb3VnaCB0aGUgRWRpdG9yIGNsYXNzLgorICAgICAgICAoV2ViQ29y ZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdo ZW5QYXN0VG9wT3JCb3R0b20pOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpz aG91bGRDb25zaWRlclNlbGVjdGlvbkFzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2ViQ29yZTo6 RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVk KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmg6IEFkZGVkLgorICAg ICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvci5jcHA6CisgICAgICAg IChXZWJDb3JlOjpFZGl0b3I6OmJlaGF2aW9yKTogR2V0dGVyIGZvciBFZGl0aW5nQmVoYXZpb3Ig Y2xhc3MuCisgICAgICAgICogZWRpdGluZy9FZGl0b3IuaDoKKyAgICAgICAgKiBlZGl0aW5nL0Vk aXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToK KyAgICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNv cmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldElzRGlyZWN0aW9uYWwpOgorICAgICAgICAoV2Vi Q29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6cG9zaXRpb25Gb3JQbGF0Zm9ybSk6CisgICAgICAg IChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIHBhZ2Uv RXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxl TW91c2VQcmVzc0V2ZW50U2luZ2xlQ2xpY2spOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJC bG9jay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCbG9jazo6cG9zaXRpb25Gb3JQb2lu dFdpdGhJbmxpbmVDaGlsZHJlbik6CisKKyAgICAgICAgLSBDYWxsIHNpdGVzIHdpbGwgbG9vayBs aWtlOgorICAgICAgICBpZiAoZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZFRoaXNJ ZlRoYXQoKSkpCisgICAgICAgICAgIC8vIGRvIHNvbWV0aGluZworCiAyMDEwLTA2LTA3ICBWYW5n ZWxpcyBLb2trZXZpcyAgPHZhbmdlbGlzQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBEaW1pdHJpIEdsYXprb3YuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAyNWM5NDMzLi4zYzQ5OTlmIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTk0OSw2ICs5NDksOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGlu Zy9FZGl0QWN0aW9uLmggXAogCVdlYkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAgXAogCVdl YkNvcmUvZWRpdGluZy9FZGl0Q29tbWFuZC5oIFwKKwlXZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0Jl aGF2aW9yLmggXAorCVdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIFwKIAlX ZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIFwK IAlXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9XZWJDb3JlLmd5cGkgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCBjNzRkNTg2Li42ZGFm Y2M5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNv cmUuZ3lwaQpAQCAtMTI5Miw2ICsxMjkyLDggQEAKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRB Y3Rpb24uaCcsCiAgICAgICAgICAgICAnZWRpdGluZy9FZGl0Q29tbWFuZC5jcHAnLAogICAgICAg ICAgICAgJ2VkaXRpbmcvRWRpdENvbW1hbmQuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0 aW5nQmVoYXZpb3IuaCcsCisgICAgICAgICAgICAnZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBl cy5oJywKICAgICAgICAgICAgICdlZGl0aW5nL0VkaXRvci5jcHAnLAogICAgICAgICAgICAgJ2Vk aXRpbmcvRWRpdG9yLmgnLAogICAgICAgICAgICAgJ2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAn LApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8K aW5kZXggN2Q3OTQ0Ni4uNjUxOWZiNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybwor KysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0xMjgwLDYgKzEyODAsNyBAQCBIRUFERVJTICs9 IFwKICAgICBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCBcCiAgICAgZWRpdGlu Zy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmggXAogICAgIGVkaXRpbmcvRWRpdENvbW1hbmQuaCBc CisgICAgZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBcCiAgICAgZWRpdGluZy9FZGl0b3IuaCBc CiAgICAgZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuaCBcCiAgICAgZWRpdGluZy9odG1sZWRp dGluZy5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3By b2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IGZlN2NhZTcu LjVlZjBiOWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3By b2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMzA1MDUs NiArMzA1MDUsMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0 aXZlUGF0aD0iLi5cZWRpdGluZ1xFZGl0aW5nQmVoYXZpb3IuaCINCisJCQkJPg0KKwkJCTwvRmls ZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdGluZ0JlaGF2 aW9yVHlwZXMuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXGVkaXRpbmdcRWRpdG9yLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYg LS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1dlYkNv cmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDMxNmZkM2IuLjRhOTEz NzkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xMDE2 LDYgKzEwMTYsOCBAQAogCQk0RTE5NTkyRTBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFRdWVyeUV4 cC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEUxOTU5 MjgwQTM5REFDQzAwMjIwRkU1IC8qIE1lZGlhUXVlcnlFeHAuaCAqLzsgfTsKIAkJNEYzMjg5QjUx MUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0RjMyODlCMzExQTQyQUFCMDA1QUJFN0UgLyog SW5zcGVjdG9yVmFsdWVzLmNwcCAqLzsgfTsKIAkJNEYzMjg5QjYxMUE0MkFBQjAwNUFCRTdFIC8q IEluc3BlY3RvclZhbHVlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNEYzMjg5QjQxMUE0MkFBQjAwNUFCRTdFIC8qIEluc3BlY3RvclZhbHVlcy5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTRGMTUzNERF MTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3IuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBF ZGl0aW5nQmVoYXZpb3IuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OworCQk0RjE1MzRFMDExQjUzMzAyMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGMTUz NERGMTFCNTMzMDIwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTRGRDhEMEYyMTE5QzcxOEIw MDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhEMEYwMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2 ZW50LmNwcCAqLzsgfTsKIAkJNEZEOEQwRjMxMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZl bnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDhE MEYxMTE5QzcxOEIwMDJGQTgyNSAvKiBTY3JpcHRHQ0V2ZW50LmggKi87IH07CiAJCTUxMDE4NDY5 MEIwODYwMkEwMDRBODI1RiAvKiBDYWNoZWRQYWdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyogQ2FjaGVk UGFnZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CkBA IC02NjQwLDYgKzY2NDIsOCBAQAogCQk0RTE5NTkyODBBMzlEQUNDMDAyMjBGRTUgLyogTWVkaWFR dWVyeUV4cC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMw OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTWVkaWFRdWVyeUV4 cC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0RjMyODlCMzExQTQyQUFCMDA1QUJF N0UgLyogSW5zcGVjdG9yVmFsdWVzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IEluc3BlY3RvclZhbHVlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTRGMzI4OUI0MTFBNDJBQUIwMDVBQkU3RSAvKiBJbnNwZWN0b3JWYWx1ZXMuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5zcGVjdG9yVmFsdWVzLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCTRGMTUzNEREMTFCNTMyRUMwMDIxRkQ4NiAvKiBFZGl0aW5nQmVoYXZp b3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRWRpdGluZ0JlaGF2aW9yLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTRGMTUzNERGMTFCNTMzMDIwMDIxRkQ4NiAv KiBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0 RkQ4RDBGMDExOUM3MThCMDAyRkE4MjUgLyogU2NyaXB0R0NFdmVudC5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBTY3JpcHRHQ0V2ZW50LmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJNEZEOEQwRjExMTlDNzE4QjAwMkZBODI1IC8qIFNjcmlwdEdDRXZl bnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU2NyaXB0R0NFdmVudC5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MTAxODQ2NzBCMDg2MDJBMDA0QTgyNUYgLyog Q2FjaGVkUGFnZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDYWNoZWRQYWdl Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMzIyMCw2ICsxMzIyNCw4IEBACiAJ CTkzMzA5RDg2MDk5RTY0OTEwMDU2RTU4MSAvKiBlZGl0aW5nICovID0gewogCQkJaXNhID0gUEJY R3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQk0RjE1MzRERjExQjUzMzAyMDAyMUZEODYgLyog RWRpdGluZ0JlaGF2aW9yVHlwZXMuaCAqLywKKwkJCQk0RjE1MzRERDExQjUzMkVDMDAyMUZEODYg LyogRWRpdGluZ0JlaGF2aW9yLmggKi8sCiAJCQkJRUQ1MDFEQzkwQjI0OUYzOTAwQUUxOEQ5IC8q IG1hYyAqLywKIAkJCQk5MzMwOUQ4NzA5OUU2NDkxMDA1NkU1ODEgLyogQXBwZW5kTm9kZUNvbW1h bmQuY3BwICovLAogCQkJCTkzMzA5RDg4MDk5RTY0OTEwMDU2RTU4MSAvKiBBcHBlbmROb2RlQ29t bWFuZC5oICovLApAQCAtMTk0MTgsNiArMTk0MjQsOCBAQAogCQkJCTlGRkUzRUE2MTFCNUE0Mzkw MDM3ODc0RSAvKiBKU01lbW9yeUluZm8uaCBpbiBIZWFkZXJzICovLAogCQkJCTg2MjQzRDAxMTFC QzMxRjcwMENDMDA2QSAvKiBKU0FycmF5QnVmZmVyVmlld0hlbHBlci5oIGluIEhlYWRlcnMgKi8s CiAJCQkJQjZCMDU0MEExMUI2OEYxMDAwMjU2NEM1IC8qIElEQk9iamVjdFN0b3JlSW1wbC5oIGlu IEhlYWRlcnMgKi8sCisJCQkJNEYxNTM0REUxMUI1MzJFQzAwMjFGRDg2IC8qIEVkaXRpbmdCZWhh dmlvci5oIGluIEhlYWRlcnMgKi8sCisJCQkJNEYxNTM0RTAxMUI1MzMwMjAwMjFGRDg2IC8qIEVk aXRpbmdCZWhhdmlvclR5cGVzLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mZTA5ZTFiCi0tLSAvZGV2 L251bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCkBAIC0wLDAgKzEs NTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRpb24gYW5kL29y IGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIEVkaXRpbmdCZWhhdmlvcl9oCisjZGVmaW5lIEVk aXRpbmdCZWhhdmlvcl9oCisKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEVkaXRpbmdCZWhhdmlvciB7CisKK3B1YmxpYzoK KyAgICBFZGl0aW5nQmVoYXZpb3IoRWRpdGluZ0JlaGF2aW9yVHlwZSB0eXBlKQorICAgICAgICA6 IG1fdHlwZSh0eXBlKQorICAgIHsKKyAgICB9CisKKyAgICAvLyBJbmRpdmlkdWFsIGZ1bmN0aW9u cyBmb3IgZWFjaCBjYXNlIHdoZXJlIHdlIGhhdmUgbW9yZSB0aGFuIG9uZSBzdHlsZSBvZiBlZGl0 aW5nIGJlaGF2aW9yLgorICAgIC8vIENyZWF0ZSBhIG5ldyBmdW5jdGlvbiBmb3IgYW55IHBsYXRm b3JtIGRpZmZlcmVuY2Ugc28gd2UgY2FuIGNvbnRyb2wgaXQgaGVyZS4KKworICAgIC8vIFdoZW4g ZXh0ZW5kaW5nIGEgc2VsZWN0aW9uIGJleW9uZCB0aGUgdG9wIG9yIGJvdHRvbSBib3VuZGFyeSBv ZiBhbiBlZGl0YWJsZSBhcmVhLAorICAgIC8vIG1haW50YWluIHRoZSBob3Jpem9udGFsIHBvc2l0 aW9uIG9uIFdpbmRvd3MgYnV0IGV4dGVuZCBpdCB0byB0aGUgYm91bmRhcnkgb2YgdGhlIGVkaXRh YmxlCisgICAgLy8gY29udGVudCBvbiBNYWMuCisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hv cml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5 cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsgfQorCisgICAgLy8gT24gV2luZG93cywgc2Vs ZWN0aW9ucyBzaG91bGQgYWx3YXlzIGJlIGNvbnNpZGVyZWQgYXMgZGlyZWN0aW9uYWwsIHJlZ2Fy ZGxlc3MgaWYgaXQgaXMKKyAgICAvLyBtb3VzZS1iYXNlZCBvciBrZXlib2FyZC1iYXNlZC4KKyAg ICBib29sIHNob3VsZENvbnNpZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCgpIGNvbnN0IHsgcmV0 dXJuIG1fdHlwZSAhPSBFZGl0aW5nTWFjQmVoYXZpb3I7IH0KKworICAgIC8vIE9uIE1hYywgd2hl biByZXZlYWxpbmcgYSBzZWxlY3Rpb24gKGZvciBleGFtcGxlIGFzIGEgcmVzdWx0IG9mIGEgRmlu ZCBvcGVyYXRpb24gb24gdGhlIEJyb3dzZXIpLAorICAgIC8vIGNvbnRlbnQgc2hvdWxkIGJlIHNj cm9sbGVkIHN1Y2ggdGhhdCB0aGUgc2VsZWN0aW9uIGdldHMgY2VydGVyIGFsaWduZWQuCisgICAg Ym9vbCBzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVkKCkgY29uc3QgeyBy ZXR1cm4gbV90eXBlID09IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQorCitwcml2YXRlOgorICAgIEVk aXRpbmdCZWhhdmlvclR5cGUgbV90eXBlOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gRWRpdGluZ0JlaGF2aW9yX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlv clR5cGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjZiYTE4ZQotLS0g L2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCkBA IC0wLDAgKzEsNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRp b24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNl bnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIK KyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhv cGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBD T1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24s IE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIEVkaXRpbmdCZWhhdmlvclR5cGVz X2gKKyNkZWZpbmUgRWRpdGluZ0JlaGF2aW9yVHlwZXNfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKKy8vIFRoZXJlIGFyZSBtdWx0aXBsZSBlZGl0aW5nIGRldGFpbHMgdGhhdCBhcmUgZGlmZmVy ZW50IG9uIFdpbmRvd3MgdGhhbiBNYWNpbnRvc2guCisvLyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNo IGZvciBhbGwgb2YgdGhlbS4gU29tZSBleGFtcGxlczoKKy8vCisvLyAgICAxKSBDbGlja2luZyBi ZWxvdyB0aGUgbGFzdCBsaW5lIG9mIGFuIGVkaXRhYmxlIGFyZWEgcHV0cyB0aGUgY2FyZXQgYXQg dGhlIGVuZAorLy8gICAgICAgb2YgdGhlIGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBpbiB0aGUgbWlk ZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24gV2luZG93cy4KKy8vICAgIDIpIFB1c2hpbmcgdGhlIGRv d24gYXJyb3cga2V5IG9uIHRoZSBsYXN0IGxpbmUgcHV0cyB0aGUgY2FyZXQgYXQgdGhlIGVuZCBv ZiB0aGUKKy8vICAgICAgIGxhc3QgbGluZSBvbiBNYWMsIGJ1dCBkb2VzIG5vdGhpbmcgb24gV2lu ZG93cy4gQSBzaW1pbGFyIGNhc2UgZXhpc3RzIG9uIHRoZQorLy8gICAgICAgdG9wIGxpbmUuCisv LworLy8gVGhpcyBzZXR0aW5nIGlzIGludGVuZGVkIHRvIGNvbnRyb2wgdGhlc2Ugc29ydHMgb2Yg YmVoYXZpb3JzLiBUaGVyZSBhcmUgc29tZSBvdGhlcgorLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZp ZHVhbCBmdW5jdGlvbiBjYWxscyBvbiBFZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3Rl IGFuZAorLy8gc2VsZWN0aW5nIHRoZSBzcGFjZSBhZnRlciBhIGRvdWJsZSBjbGljaykgdGhhdCBj b3VsZCBiZSBjb21iaW5lZCB3aXRoIHRoaXMgaWYKKy8vIGlmIHBvc3NpYmxlIGluIHRoZSBmdXR1 cmUuCitlbnVtIEVkaXRpbmdCZWhhdmlvclR5cGUgeworICAgIEVkaXRpbmdNYWNCZWhhdmlvciwK KyAgICBFZGl0aW5nV2luZG93c0JlaGF2aW9yCit9OworCit9IC8vIFdlYkNvcmUgbmFtZXNwYWNl CisKKyNlbmRpZiAvLyBFZGl0aW5nQmVoYXZpb3JUeXBlc19oCmRpZmYgLS1naXQgYS9XZWJDb3Jl L2VkaXRpbmcvRWRpdG9yLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCmluZGV4IDgw NDExNTkuLjU4OTM0MjMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCisr KyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3BwCkBAIC02Myw2ICs2Myw3IEBACiAjaW5jbHVk ZSAiUmVuZGVyQmxvY2suaCIKICNpbmNsdWRlICJSZW5kZXJQYXJ0LmgiCiAjaW5jbHVkZSAiUmVw bGFjZVNlbGVjdGlvbkNvbW1hbmQuaCIKKyNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUg IlNvdW5kLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgpA QCAtOTcsNiArOTgsMTUgQEAgVmlzaWJsZVNlbGVjdGlvbiBFZGl0b3I6OnNlbGVjdGlvbkZvckNv bW1hbmQoRXZlbnQqIGV2ZW50KQogICAgIHJldHVybiBzZWxlY3Rpb247CiB9CiAKKy8vIEZ1bmN0 aW9uIGNvbnNpZGVycyBNYWMgZWRpdGluZyBiZWhhdmlvciBhIGZhbGxiYWNrIHdoZW4gUGFnZSBv ciBTZXR0aW5ncyBpcyBub3QgYXZhaWxhYmxlLgorRWRpdGluZ0JlaGF2aW9yIEVkaXRvcjo6YmVo YXZpb3IoKSBjb25zdAoreworICAgIGlmICghbV9mcmFtZSB8fCAhbV9mcmFtZS0+cGFnZSgpIHx8 ICFtX2ZyYW1lLT5zZXR0aW5ncygpKQorICAgICAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKEVk aXRpbmdNYWNCZWhhdmlvcik7CisKKyAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKG1fZnJhbWUt PnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvclR5cGUoKSk7Cit9CisKIEVkaXRvckNsaWVudCog RWRpdG9yOjpjbGllbnQoKSBjb25zdAogewogICAgIGlmIChQYWdlKiBwYWdlID0gbV9mcmFtZS0+ cGFnZSgpKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5oIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvci5oCmluZGV4IDE3ZGQzYmIuLjNlMjIzZGMgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvZWRpdGluZy9FZGl0b3IuaAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yLmgKQEAgLTI5 LDYgKzI5LDcgQEAKICNpbmNsdWRlICJDbGlwYm9hcmRBY2Nlc3NQb2xpY3kuaCIKICNpbmNsdWRl ICJDb2xvci5oIgogI2luY2x1ZGUgIkVkaXRBY3Rpb24uaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVo YXZpb3IuaCIKICNpbmNsdWRlICJFZGl0b3JEZWxldGVBY3Rpb24uaCIKICNpbmNsdWRlICJFZGl0 b3JJbnNlcnRBY3Rpb24uaCIKICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCkBAIC0y ODEsNiArMjgyLDggQEAgcHVibGljOgogCiAgICAgS2lsbFJpbmcqIGtpbGxSaW5nKCkgY29uc3Qg eyByZXR1cm4gbV9raWxsUmluZy5nZXQoKTsgfQogCisgICAgRWRpdGluZ0JlaGF2aW9yIGJlaGF2 aW9yKCkgY29uc3Q7CisKICAgICBQYXNzUmVmUHRyPFJhbmdlPiBzZWxlY3RlZFJhbmdlKCk7CiAg ICAgCiAgICAgLy8gV2Ugc2hvdWxkIG1ha2UgdGhlc2UgZnVuY3Rpb25zIHByaXZhdGUgd2hlbiB0 aGVpciBjYWxsZXJzIGluIEZyYW1lIGFyZSBtb3ZlZCBvdmVyIGhlcmUgdG8gRWRpdG9yCmRpZmYg LS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAKaW5kZXggNzUwODVmYi4uMGM5ZDYxZSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9F ZGl0b3JDb21tYW5kLmNwcApAQCAtMTY2LDcgKzE2Niw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVU b2dnbGVTdHlsZShGcmFtZSogZnJhbWUsIEVkaXRvckNvbW1hbmRTb3VyY2Ugc291cmNlLCBFZGl0 QWN0CiAgICAgLy8gb3RoZXI6IHByZXNlbnQgdGhyb3VnaG91dCB0aGUgc2VsZWN0aW9uCiAgICAg U2V0dGluZ3MqIHNldHRpbmdzID0gZnJhbWUtPmRvY3VtZW50KCktPnNldHRpbmdzKCk7CiAgICAg Ym9vbCBzdHlsZUlzUHJlc2VudDsKLSAgICBpZiAoc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRp bmdCZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhhdmlvcikKKyAgICBpZiAoc2V0dGluZ3MgJiYg c2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvclR5cGUoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3IpCiAg ICAgICAgIHN0eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25TdGFydEhh c1N0eWxlKHN0eWxlLmdldCgpKTsKICAgICBlbHNlCiAgICAgICAgIHN0eWxlSXNQcmVzZW50ID0g ZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5nZXQoKSkgPT0gVHJ1ZVRy aVN0YXRlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIu Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IGY5YjM5 YmIuLjAwZjJmNDMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9s bGVyLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKQEAg LTE2NCw3ICsxNjQsNyBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihj b25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaQogICAgIGlmICh1c2VyVHJp Z2dlcmVkKSB7CiAgICAgICAgIFNjcm9sbEFsaWdubWVudCBhbGlnbm1lbnQ7CiAKLSAgICAgICAg aWYgKG1fZnJhbWUtPnNldHRpbmdzKCkgJiYgbV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRpdGluZ0Jl aGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgICAgICBpZiAobV9mcmFtZS0+ZWRp dG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkQ2VudGVyQWxpZ25XaGVuU2VsZWN0aW9uSXNSZXZlYWxl ZCgpKQogICAgICAgICAgICAgYWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3Jv bGxBbHdheXMpID8gU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFs aWdubWVudDo6YWxpZ25DZW50ZXJJZk5lZWRlZDsKICAgICAgICAgZWxzZQogICAgICAgICAgICAg YWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xs QWxpZ25tZW50OjphbGlnblRvcEFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJ Zk5lZWRlZDsKQEAgLTI0Myw4ICsyNDMsNyBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om5v ZGVXaWxsQmVSZW1vdmVkKE5vZGUgKm5vZGUpCiAgICAgCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xs ZXI6OnNldElzRGlyZWN0aW9uYWwoYm9vbCBpc0RpcmVjdGlvbmFsKQogewotICAgIFNldHRpbmdz KiBzZXR0aW5ncyA9IG1fZnJhbWUgPyBtX2ZyYW1lLT5zZXR0aW5ncygpIDogMDsKLSAgICBtX2lz RGlyZWN0aW9uYWwgPSAhc2V0dGluZ3MgfHwgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvcigpICE9 IEVkaXRpbmdNYWNCZWhhdmlvciB8fCBpc0RpcmVjdGlvbmFsOworICAgIG1faXNEaXJlY3Rpb25h bCA9ICFtX2ZyYW1lIHx8IG1fZnJhbWUtPmVkaXRvcigpLT5iZWhhdmlvcigpLnNob3VsZENvbnNp ZGVyU2VsZWN0aW9uQXNEaXJlY3Rpb25hbCgpIHx8IGlzRGlyZWN0aW9uYWw7CiB9CiAKIHZvaWQg U2VsZWN0aW9uQ29udHJvbGxlcjo6d2lsbEJlTW9kaWZpZWQoRUFsdGVyYXRpb24gYWx0ZXIsIEVE aXJlY3Rpb24gZGlyZWN0aW9uKQpAQCAtMjk5LDcgKzI5OCw3IEBAIFZpc2libGVQb3NpdGlvbiBT ZWxlY3Rpb25Db250cm9sbGVyOjpwb3NpdGlvbkZvclBsYXRmb3JtKGJvb2wgaXNHZXRTdGFydCkg Y29uc3QKIHsKICAgICBQb3NpdGlvbiBwb3M7CiAgICAgU2V0dGluZ3MqIHNldHRpbmdzID0gbV9m cmFtZSA/IG1fZnJhbWUtPnNldHRpbmdzKCkgOiAwOwotICAgIGlmIChzZXR0aW5ncyAmJiBzZXR0 aW5ncy0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgIGlmIChz ZXR0aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9yVHlwZSgpID09IEVkaXRpbmdNYWNC ZWhhdmlvcikKICAgICAgICAgcG9zID0gaXNHZXRTdGFydCA/IG1fc2VsZWN0aW9uLnN0YXJ0KCkg OiBtX3NlbGVjdGlvbi5lbmQoKTsKICAgICBlbHNlIHsKICAgICAgICAgLy8gTGludXggYW5kIFdp bmRvd3MgYWx3YXlzIGV4dGVuZCBzZWxlY3Rpb25zIGZyb20gdGhlIGV4dGVudCBlbmRwb2ludC4K QEAgLTY4NSw3ICs2ODQsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0 ZXJhdGlvbiBhbHRlciwgRURpcmVjdGlvbiBkaXJlY3Rpb24sIFRleHRHcgogICAgICAgICBtb3Zl VG8ocG9zaXRpb24sIHVzZXJUcmlnZ2VyZWQpOwogICAgICAgICBicmVhazsKICAgICBjYXNlIEFs dGVyYXRpb25FeHRlbmQ6Ci0gICAgICAgIGlmICghc2V0dGluZ3MgfHwgc2V0dGluZ3MtPmVkaXRp bmdCZWhhdmlvcigpICE9IEVkaXRpbmdNYWNCZWhhdmlvciB8fCBtX3NlbGVjdGlvbi5pc0NhcmV0 KCkgfHwgIWlzQm91bmRhcnkoZ3JhbnVsYXJpdHkpKQorICAgICAgICBpZiAoIXNldHRpbmdzIHx8 IHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3JUeXBlKCkgIT0gRWRpdGluZ01hY0JlaGF2aW9yIHx8 IG1fc2VsZWN0aW9uLmlzQ2FyZXQoKSB8fCAhaXNCb3VuZGFyeShncmFudWxhcml0eSkpCiAgICAg ICAgICAgICBzZXRFeHRlbnQocG9zaXRpb24sIHVzZXJUcmlnZ2VyZWQpOwogICAgICAgICBlbHNl IHsKICAgICAgICAgICAgIC8vIFN0YW5kYXJkIE1hYyBiZWhhdmlvciB3aGVuIGV4dGVuZGluZyB0 byBhIGJvdW5kYXJ5IGlzIGdyb3cgdGhlIHNlbGVjdGlvbiByYXRoZXIKZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5j cHAKaW5kZXggMWJmNGMzOC4uZjQwYjc3MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL0V2ZW50 SGFuZGxlci5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTM3MCw3 ICszNzAsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50U2luZ2xl Q2xpY2soY29uc3QgTW91c2VFdmVudFdpdGhIaXRUZXN0UgogICAgICAgICBtX2ZyYW1lLT5zZWxl Y3Rpb24oKS0+c2V0SXNEaXJlY3Rpb25hbChmYWxzZSk7CiAgICAgICAgIAogICAgICAgICBBU1NF UlQobV9mcmFtZS0+c2V0dGluZ3MoKSk7Ci0gICAgICAgIGlmIChtX2ZyYW1lLT5zZXR0aW5ncygp LT5lZGl0aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3IpIHsKKyAgICAgICAgaWYg KG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvclR5cGUoKSA9PSBFZGl0aW5nTWFj QmVoYXZpb3IpIHsKICAgICAgICAgICAgIC8vIFNlZSA8cmRhcjovL3Byb2JsZW0vMzY2ODE1Nz4g UkVHUkVTU0lPTiAoTWFpbCk6IHNoaWZ0LWNsaWNrIGRlc2VsZWN0cyB3aGVuIHNlbGVjdGlvbgog ICAgICAgICAgICAgLy8gd2FzIGNyZWF0ZWQgcmlnaHQtdG8tbGVmdAogICAgICAgICAgICAgUG9z aXRpb24gc3RhcnQgPSBuZXdTZWxlY3Rpb24uc3RhcnQoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGFnZS9TZXR0aW5ncy5jcHAgYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmluZGV4IDIxY2E0 ZjUuLmMxOWE5YTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIv V2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcApAQCAtMTEzLDcgKzExMyw3IEBAIFNldHRpbmdzOjpT ZXR0aW5ncyhQYWdlKiBwYWdlKQogICAgICwgbV9lbmZvcmNlQ1NTTUlNRVR5cGVJblN0cmljdE1v ZGUodHJ1ZSkKICAgICAsIG1fdXNlc0VuY29kaW5nRGV0ZWN0b3IoZmFsc2UpCiAgICAgLCBtX2Fs bG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzKGZhbHNlKQotICAgICwgbV9lZGl0aW5nQmVoYXZpb3Io CisgICAgLCBtX2VkaXRpbmdCZWhhdmlvclR5cGUoCiAjaWYgUExBVEZPUk0oTUFDKSB8fCAoUExB VEZPUk0oQ0hST01JVU0pICYmIE9TKERBUldJTikpCiAgICAgICAgIC8vIChQTEFURk9STShNQUMp IGlzIGFsd2F5cyBmYWxzZSBpbiBDaHJvbWl1bSwgaGVuY2UgdGhlIGV4dHJhIGNvbmRpdGlvbi4p CiAgICAgICAgIEVkaXRpbmdNYWNCZWhhdmlvcgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1Nl dHRpbmdzLmggYi9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAppbmRleCBlMGRiMjhkLi40ZmJiOWYy IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuaAorKysgYi9XZWJDb3JlL3BhZ2Uv U2V0dGluZ3MuaApAQCAtMjgsNiArMjgsNyBAQAogI2RlZmluZSBTZXR0aW5nc19oCiAKICNpbmNs dWRlICJBdG9taWNTdHJpbmcuaCIKKyNpbmNsdWRlICJFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIgog I2luY2x1ZGUgIkZvbnRSZW5kZXJpbmdNb2RlLmgiCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1 ZGUgIlpvb21Nb2RlLmgiCkBAIC01MCwyMSArNTEsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgICAgIFRleHREaXJlY3Rpb25TdWJtZW51QWx3YXlzSW5jbHVkZWQKICAgICB9OwogCi0gICAg Ly8gVGhlcmUgYXJlIG11bHRpcGxlIGVkaXRpbmcgZGV0YWlscyB0aGF0IGFyZSBkaWZmZXJlbnQg b24gV2luZG93cyB0aGFuIE1hY2ludG9zaC4KLSAgICAvLyBXZSB1c2UgYSBzaW5nbGUgc3dpdGNo IGZvciBhbGwgb2YgdGhlbS4gU29tZSBleGFtcGxlczoKLSAgICAvLwotICAgIC8vICAgIDEpIENs aWNraW5nIGJlbG93IHRoZSBsYXN0IGxpbmUgb2YgYW4gZWRpdGFibGUgYXJlYSBwdXRzIHRoZSBj YXJldCBhdCB0aGUgZW5kCi0gICAgLy8gICAgICAgb2YgdGhlIGxhc3QgbGluZSBvbiBNYWMsIGJ1 dCBpbiB0aGUgbWlkZGxlIG9mIHRoZSBsYXN0IGxpbmUgb24gV2luZG93cy4KLSAgICAvLyAgICAy KSBQdXNoaW5nIHRoZSBkb3duIGFycm93IGtleSBvbiB0aGUgbGFzdCBsaW5lIHB1dHMgdGhlIGNh cmV0IGF0IHRoZSBlbmQgb2YgdGhlCi0gICAgLy8gICAgICAgbGFzdCBsaW5lIG9uIE1hYywgYnV0 IGRvZXMgbm90aGluZyBvbiBXaW5kb3dzLiBBIHNpbWlsYXIgY2FzZSBleGlzdHMgb24gdGhlCi0g ICAgLy8gICAgICAgdG9wIGxpbmUuCi0gICAgLy8KLSAgICAvLyBUaGlzIHNldHRpbmcgaXMgaW50 ZW5kZWQgdG8gY29udHJvbCB0aGVzZSBzb3J0cyBvZiBiZWhhdmlvcnMuIFRoZXJlIGFyZSBzb21l IG90aGVyCi0gICAgLy8gYmVoYXZpb3JzIHdpdGggaW5kaXZpZHVhbCBmdW5jdGlvbiBjYWxscyBv biBFZGl0b3JDbGllbnQgKHNtYXJ0IGNvcHkgYW5kIHBhc3RlIGFuZAotICAgIC8vIHNlbGVjdGlu ZyB0aGUgc3BhY2UgYWZ0ZXIgYSBkb3VibGUgY2xpY2spIHRoYXQgY291bGQgYmUgY29tYmluZWQg d2l0aCB0aGlzIGlmCi0gICAgLy8gaWYgcG9zc2libGUgaW4gdGhlIGZ1dHVyZS4KLSAgICBlbnVt IEVkaXRpbmdCZWhhdmlvciB7IEVkaXRpbmdNYWNCZWhhdmlvciwgRWRpdGluZ1dpbmRvd3NCZWhh dmlvciB9OwotCiAgICAgY2xhc3MgU2V0dGluZ3MgOiBwdWJsaWMgTm9uY29weWFibGUgewogICAg IHB1YmxpYzoKICAgICAgICAgU2V0dGluZ3MoUGFnZSopOwpAQCAtMjcwLDkgKzI1Niw5IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzZXRBbGxvd1NjcmlwdHNUb0Nsb3NlV2lu ZG93cyhib29sKTsKICAgICAgICAgYm9vbCBhbGxvd1NjcmlwdHNUb0Nsb3NlV2luZG93cygpIGNv bnN0IHsgcmV0dXJuIG1fYWxsb3dTY3JpcHRzVG9DbG9zZVdpbmRvd3M7IH0KIAotICAgICAgICB2 b2lkIHNldEVkaXRpbmdCZWhhdmlvcihFZGl0aW5nQmVoYXZpb3IgYmVoYXZpb3IpIHsgbV9lZGl0 aW5nQmVoYXZpb3IgPSBiZWhhdmlvcjsgfQotICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZWRpdGlu Z0JlaGF2aW9yKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8RWRpdGluZ0JlaGF2aW9yPiht X2VkaXRpbmdCZWhhdmlvcik7IH0KLSAgICAgICAgCisgICAgICAgIHZvaWQgc2V0RWRpdGluZ0Jl aGF2aW9yVHlwZShFZGl0aW5nQmVoYXZpb3JUeXBlIGJlaGF2aW9yKSB7IG1fZWRpdGluZ0JlaGF2 aW9yVHlwZSA9IGJlaGF2aW9yOyB9CisgICAgICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgZWRpdGlu Z0JlaGF2aW9yVHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVkaXRpbmdCZWhhdmlv clR5cGU+KG1fZWRpdGluZ0JlaGF2aW9yVHlwZSk7IH0KKwogICAgICAgICB2b2lkIHNldERvd25s b2FkYWJsZUJpbmFyeUZvbnRzRW5hYmxlZChib29sKTsKICAgICAgICAgYm9vbCBkb3dubG9hZGFi bGVCaW5hcnlGb250c0VuYWJsZWQoKSBjb25zdCB7IHJldHVybiBtX2Rvd25sb2FkYWJsZUJpbmFy eUZvbnRzRW5hYmxlZDsgfQogCkBAIC0zODMsNyArMzY5LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICBib29sIG1fZW5mb3JjZUNTU01JTUVUeXBlSW5TdHJpY3RNb2RlIDogMTsKICAg ICAgICAgYm9vbCBtX3VzZXNFbmNvZGluZ0RldGVjdG9yIDogMTsKICAgICAgICAgYm9vbCBtX2Fs bG93U2NyaXB0c1RvQ2xvc2VXaW5kb3dzIDogMTsKLSAgICAgICAgdW5zaWduZWQgbV9lZGl0aW5n QmVoYXZpb3IgOiAxOworICAgICAgICB1bnNpZ25lZCBtX2VkaXRpbmdCZWhhdmlvclR5cGUgOiAx OwogICAgICAgICBib29sIG1fZG93bmxvYWRhYmxlQmluYXJ5Rm9udHNFbmFibGVkIDogMTsKICAg ICAgICAgYm9vbCBtX3hzc0F1ZGl0b3JFbmFibGVkIDogMTsKICAgICAgICAgYm9vbCBtX2FjY2Vs ZXJhdGVkQ29tcG9zaXRpbmdFbmFibGVkIDogMTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApp bmRleCA1NmFlYmQ1Li5mMjNmODkwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCkBAIC0z OTU1LDE2ICszOTU1LDE1IEBAIFZpc2libGVQb3NpdGlvbiBSZW5kZXJCbG9jazo6cG9zaXRpb25G b3JQb2ludFdpdGhJbmxpbmVDaGlsZHJlbihjb25zdCBJbnRQb2ludCYKICAgICAgICAgfQogICAg IH0KIAotICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50KCktPnNldHRpbmdzKCk7Ci0g ICAgYm9vbCB1c2VXaW5kb3dzQmVoYXZpb3IgPSBzZXR0aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGlu Z0JlaGF2aW9yKCkgPT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsKKyAgICBib29sIG1vdmVDYXJl dFRvQm91bmRhcnkgPSBkb2N1bWVudCgpLT5mcmFtZSgpLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5z aG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKTsK IAotICAgIGlmICh1c2VXaW5kb3dzQmVoYXZpb3IgJiYgIWNsb3Nlc3RCb3ggJiYgbGFzdFJvb3RC b3hXaXRoQ2hpbGRyZW4pIHsKKyAgICBpZiAoIW1vdmVDYXJldFRvQm91bmRhcnkgJiYgIWNsb3Nl c3RCb3ggJiYgbGFzdFJvb3RCb3hXaXRoQ2hpbGRyZW4pIHsKICAgICAgICAgLy8geSBjb29yZGlu YXRlIGlzIGJlbG93IGxhc3Qgcm9vdCBsaW5lIGJveCwgcHJldGVuZCB3ZSBoaXQgaXQKICAgICAg ICAgY2xvc2VzdEJveCA9IGxhc3RSb290Qm94V2l0aENoaWxkcmVuLT5jbG9zZXN0TGVhZkNoaWxk Rm9yWFBvcyhwb2ludEluQ29udGVudHMueCgpKTsKICAgICB9CiAKICAgICBpZiAoY2xvc2VzdEJv eCkgewotICAgICAgICBpZiAoIXVzZVdpbmRvd3NCZWhhdmlvciAmJiBwb2ludEluQ29udGVudHMu eSgpIDwgZmlyc3RSb290Qm94V2l0aENoaWxkcmVuLT5saW5lVG9wKCkgLSB2ZXJ0aWNhbExpbmVD bGlja0Z1ZGdlRmFjdG9yKSB7CisgICAgICAgIGlmIChtb3ZlQ2FyZXRUb0JvdW5kYXJ5ICYmIHBv aW50SW5Db250ZW50cy55KCkgPCBmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmxpbmVUb3AoKSAt IHZlcnRpY2FsTGluZUNsaWNrRnVkZ2VGYWN0b3IpIHsKICAgICAgICAgICAgIC8vIHkgY29vcmRp bmF0ZSBpcyBhYm92ZSBmaXJzdCByb290IGxpbmUgYm94LCBzbyByZXR1cm4gdGhlIHN0YXJ0IG9m IHRoZSBmaXJzdAogICAgICAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZv ckJveChmaXJzdFJvb3RCb3hXaXRoQ2hpbGRyZW4tPmZpcnN0TGVhZkNoaWxkKCksIHRydWUpLCBE T1dOU1RSRUFNKTsKICAgICAgICAgfQpAQCAtMzk3NSw3ICszOTc0LDcgQEAgVmlzaWJsZVBvc2l0 aW9uIFJlbmRlckJsb2NrOjpwb3NpdGlvbkZvclBvaW50V2l0aElubGluZUNoaWxkcmVuKGNvbnN0 IEludFBvaW50JgogCiAgICAgaWYgKGxhc3RSb290Qm94V2l0aENoaWxkcmVuKSB7CiAgICAgICAg IC8vIFdlIGhpdCB0aGlzIGNhc2UgZm9yIE1hYyBiZWhhdmlvciB3aGVuIHRoZSBZIGNvb3JkaW5h dGUgaXMgYmVsb3cgdGhlIGxhc3QgYm94LgotICAgICAgICBBU1NFUlQoIXVzZVdpbmRvd3NCZWhh dmlvcik7CisgICAgICAgIEFTU0VSVChtb3ZlQ2FyZXRUb0JvdW5kYXJ5KTsKICAgICAgICAgcmV0 dXJuIFZpc2libGVQb3NpdGlvbihwb3NpdGlvbkZvckJveChsYXN0Um9vdEJveFdpdGhDaGlsZHJl bi0+bGFzdExlYWZDaGlsZCgpLCBmYWxzZSksIERPV05TVFJFQU0pOwogICAgIH0KIApkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VM b2cKaW5kZXggNzEzMTVkYS4uZGYxM2VhNCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0 Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAg ICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JU eXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVo YXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5 LgorCisgICAgICAgICogc3JjL1dlYlNldHRpbmdzSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OldlYlNldHRpbmdzSW1wbDo6c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMC0wNi0wNyAgQW5k cmVpIFBvcGVzY3UgIDxhbmRyZWlwQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg SmVyZW15IE9ybG93LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5n c0ltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTZXR0aW5nc0ltcGwuY3BwCmluZGV4 IDk0Njc4MmIuLjdlODlhNzcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU2V0 dGluZ3NJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlNldHRpbmdzSW1wbC5j cHAKQEAgLTI3MSw3ICsyNzEsNyBAQCB2b2lkIFdlYlNldHRpbmdzSW1wbDo6c2V0U2hvd0RlYnVn Qm9yZGVycyhib29sIHNob3cpCiAKIHZvaWQgV2ViU2V0dGluZ3NJbXBsOjpzZXRFZGl0aW5nQmVo YXZpb3IoRWRpdGluZ0JlaGF2aW9yIGJlaGF2aW9yKQogewotICAgIG1fc2V0dGluZ3MtPnNldEVk aXRpbmdCZWhhdmlvcihzdGF0aWNfY2FzdDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I+KGJlaGF2 aW9yKSk7CisgICAgbV9zZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShzdGF0aWNfY2Fz dDxXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlPihiZWhhdmlvcikpOwogfQogCiB2b2lkIFdl YlNldHRpbmdzSW1wbDo6c2V0QWNjZWxlcmF0ZWRDb21wb3NpdGluZ0VuYWJsZWQoYm9vbCBlbmFi bGVkKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5n ZUxvZwppbmRleCBjZDcwMjY3Li41M2IwMWVkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5n ZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA1 LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZvcm0gZGVw ZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAgICAgRWRp dGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlwZXMgYW5k IG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4KKworICAg ICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6Y29yZSk6 CisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHA6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfdXBkYXRlX3NldHRpbmdz KToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19zZXR0aW5nc19ub3RpZnkpOgorCiAyMDEwLTA2 LTA3ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBYYW4gTG9wZXouCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRwcml2YXRlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCmluZGV4 IGQyNzQ3MDguLjcwOWRjNWUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwCkBAIC0x MjksOSArMTI5LDkgQEAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5ldHdv cmtSZXNwb25zZSogcmVzcG9uc2UpCiAgICAgcmV0dXJuIFJlc291cmNlUmVzcG9uc2UoKTsKIH0K IAotV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5 cGUpCitXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2 aW9yIHR5cGUpCiB7Ci0gICAgcmV0dXJuIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IpdHlwZTsK KyAgICByZXR1cm4gKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUpdHlwZTsKIH0KIAogV2Vi S2l0SGl0VGVzdFJlc3VsdCoga2l0KGNvbnN0IFdlYkNvcmU6OkhpdFRlc3RSZXN1bHQmIHJlc3Vs dCkKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCA4NDVjMmQ2Li40NGZmYzFlIDEwMDY0 NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC05NSw3ICs5NSw3IEBAIG5hbWVzcGFjZSBXZWJL aXQgewogCiAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5ldHdvcmtS ZXNwb25zZSogcmVzcG9uc2UpOwogCi0gICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUo V2ViS2l0RWRpdGluZ0JlaGF2aW9yIHR5cGUpOworICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlv clR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CiAKICAgICBXZWJLaXRTZWN1 cml0eU9yaWdpbioga2l0KFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luKik7CiAgICAgV2ViQ29yZTo6 U2VjdXJpdHlPcmlnaW4qIGNvcmUoV2ViS2l0U2VjdXJpdHlPcmlnaW4qKTsKZGlmZiAtLWdpdCBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0d2Vidmlldy5jcHAKaW5kZXggMjUzZDA5Ni4uNjc0NDczMiAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0d2Vidmlldy5jcHAKQEAgLTI3MzgsNyArMjczOCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtp dF93ZWJfdmlld191cGRhdGVfc2V0dGluZ3MoV2ViS2l0V2ViVmlldyogd2ViVmlldykKICAgICBz ZXR0aW5ncy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShqYXZhc2Ny aXB0Q2FuT3BlbldpbmRvd3MpOwogICAgIHNldHRpbmdzLT5zZXRKYXZhU2NyaXB0Q2FuQWNjZXNz Q2xpcGJvYXJkKGphdmFTY3JpcHRDYW5BY2Nlc3NDbGlwYm9hcmQpOwogICAgIHNldHRpbmdzLT5z ZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQoZW5hYmxlT2ZmbGluZVdlYkFwcENh Y2hlKTsKLSAgICBzZXR0aW5ncy0+c2V0RWRpdGluZ0JlaGF2aW9yKGNvcmUoZWRpdGluZ0JlaGF2 aW9yKSk7CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoY29yZShlZGl0aW5n QmVoYXZpb3IpKTsKICAgICBzZXR0aW5ncy0+c2V0QWxsb3dVbml2ZXJzYWxBY2Nlc3NGcm9tRmls ZVVSTHMoZW5hYmxlVW5pdmVyc2FsQWNjZXNzRnJvbUZpbGVVUkkpOwogICAgIHNldHRpbmdzLT5z ZXRBbGxvd0ZpbGVBY2Nlc3NGcm9tRmlsZVVSTHMoZW5hYmxlRmlsZUFjY2Vzc0Zyb21GaWxlVVJJ KTsKICAgICBzZXR0aW5ncy0+c2V0RE9NUGFzdGVBbGxvd2VkKGVuYWJsZURPTVBhc3RlKTsKQEAg LTI4MzksNyArMjgzOSw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXR0aW5nc19u b3RpZnkoV2ViS2l0V2ViU2V0dGluZ3MqIHdlYlNldHRpbmdzLCBHUGFyCiAgICAgZWxzZSBpZiAo bmFtZSA9PSBnX2ludGVybl9zdHJpbmcoImVuYWJsZS1vZmZsaW5lLXdlYi1hcHBsaWNhdGlvbi1j YWNoZSIpKQogICAgICAgICBzZXR0aW5ncy0+c2V0T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVF bmFibGVkKGdfdmFsdWVfZ2V0X2Jvb2xlYW4oJnZhbHVlKSk7CiAgICAgZWxzZSBpZiAobmFtZSA9 PSBnX2ludGVybl9zdHJpbmcoImVkaXRpbmctYmVoYXZpb3IiKSkKLSAgICAgICAgc2V0dGluZ3Mt PnNldEVkaXRpbmdCZWhhdmlvcihjb3JlKHN0YXRpY19jYXN0PFdlYktpdEVkaXRpbmdCZWhhdmlv cj4oZ192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOworICAgICAgICBzZXR0aW5ncy0+c2V0RWRp dGluZ0JlaGF2aW9yVHlwZShjb3JlKHN0YXRpY19jYXN0PFdlYktpdEVkaXRpbmdCZWhhdmlvcj4o Z192YWx1ZV9nZXRfZW51bSgmdmFsdWUpKSkpOwogICAgIGVsc2UgaWYgKG5hbWUgPT0gZ19pbnRl cm5fc3RyaW5nKCJlbmFibGUtdW5pdmVyc2FsLWFjY2Vzcy1mcm9tLWZpbGUtdXJpcyIpKQogICAg ICAgICBzZXR0aW5ncy0+c2V0QWxsb3dVbml2ZXJzYWxBY2Nlc3NGcm9tRmlsZVVSTHMoZ192YWx1 ZV9nZXRfYm9vbGVhbigmdmFsdWUpKTsKICAgICBlbHNlIGlmIChuYW1lID09IGdfaW50ZXJuX3N0 cmluZygiZW5hYmxlLWZpbGUtYWNjZXNzLWZyb20tZmlsZS11cmlzIikpCmRpZmYgLS1naXQgYS9X ZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDg1Zjg2ODMu LmEzMjkyMGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9t YWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTAtMDUtMzEgIEFudG9uaW8gR29tZXMg IDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQgZWRpdGluZyBiZWhh dmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVoYXZpb3IgZW51bSB3 YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQgb3V0IGZyb20gU2V0 dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4gQ2FsbCBzaXRlcyBp biBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICogV2ViVmlldy9XZWJG cmFtZS5tbToKKyAgICAgICAgKGNvcmUpOgorICAgICAgICAqIFdlYlZpZXcvV2ViRnJhbWVJbnRl cm5hbC5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5tbToKKyAgICAgICAgKC1bV2ViVmll dyBfcHJlZmVyZW5jZXNDaGFuZ2VkTm90aWZpY2F0aW9uOl0pOgorCiAyMDEwLTA2LTA2ICBHYXZp biBCYXJyYWNsb3VnaCAgPGJhcnJhY2xvdWdoQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdl ZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1l Lm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lLm1tCmluZGV4IDk5OWYxNzcuLjdjNTk2 MTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJGcmFtZS5tbQorKysgYi9XZWJL aXQvbWFjL1dlYlZpZXcvV2ViRnJhbWUubW0KQEAgLTE5Niw3ICsxOTYsNyBAQCBFZGl0YWJsZUxp bmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlua0JlaGF2aW9yIGVkaXRhYmxlTGlua0Jl aGF2aW9yKQogICAgIHJldHVybiBFZGl0YWJsZUxpbmtEZWZhdWx0QmVoYXZpb3I7CiB9CiAKLVdl YkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvciBiZWhhdmlv cikKK1dlYkNvcmU6OkVkaXRpbmdCZWhhdmlvclR5cGUgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZp b3IgYmVoYXZpb3IpCiB7CiAgICAgc3dpdGNoIChiZWhhdmlvcikgewogICAgICAgICBjYXNlIFdl YktpdEVkaXRpbmdNYWNCZWhhdmlvcjoKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJGcmFtZUludGVybmFsLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViRnJhbWVJbnRlcm5hbC5o CmluZGV4IDliMjI0OGEuLjU4NmI0YzMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJGcmFtZUludGVybmFsLmgKKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYkZyYW1lSW50ZXJu YWwuaApAQCAtNzEsNyArNzEsNyBAQCBXZWJWaWV3ICpraXQoV2ViQ29yZTo6UGFnZSopOwogCiBX ZWJDb3JlOjpFZGl0YWJsZUxpbmtCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRhYmxlTGlua0JlaGF2 aW9yKTsKIFdlYkNvcmU6OlRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3IgY29y ZShXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKTsKLVdlYkNvcmU6OkVk aXRpbmdCZWhhdmlvciBjb3JlKFdlYktpdEVkaXRpbmdCZWhhdmlvcik7CitXZWJDb3JlOjpFZGl0 aW5nQmVoYXZpb3JUeXBlIGNvcmUoV2ViS2l0RWRpdGluZ0JlaGF2aW9yKTsKIAogV2ViVmlldyAq Z2V0V2ViVmlldyhXZWJGcmFtZSAqd2ViRnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViVmlldy5tbSBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCmluZGV4 IDUzY2JmY2MuLjAwMjM1MDkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 Lm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0xMzY5LDcgKzEzNjks NyBAQCBzdGF0aWMgYm9vbCBmYXN0RG9jdW1lbnRUZWFyZG93bkVuYWJsZWQoKQogICAgIHNldHRp bmdzLT5zZXRUZXh0QXJlYXNBcmVSZXNpemFibGUoW3ByZWZlcmVuY2VzIHRleHRBcmVhc0FyZVJl c2l6YWJsZV0pOwogICAgIHNldHRpbmdzLT5zZXRTaHJpbmtzU3RhbmRhbG9uZUltYWdlc1RvRml0 KFtwcmVmZXJlbmNlcyBzaHJpbmtzU3RhbmRhbG9uZUltYWdlc1RvRml0XSk7CiAgICAgc2V0dGlu Z3MtPnNldEVkaXRhYmxlTGlua0JlaGF2aW9yKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRhYmxlTGlu a0JlaGF2aW9yXSkpOwotICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVoYXZpb3IoY29yZShbcHJl ZmVyZW5jZXMgZWRpdGluZ0JlaGF2aW9yXSkpOworICAgIHNldHRpbmdzLT5zZXRFZGl0aW5nQmVo YXZpb3JUeXBlKGNvcmUoW3ByZWZlcmVuY2VzIGVkaXRpbmdCZWhhdmlvcl0pKTsKICAgICBzZXR0 aW5ncy0+c2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcihjb3JlKFtwcmVm ZXJlbmNlcyB0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yXSkpOwogICAgIHNl dHRpbmdzLT5zZXRET01QYXN0ZUFsbG93ZWQoW3ByZWZlcmVuY2VzIGlzRE9NUGFzdGVBbGxvd2Vk XSk7CiAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2FjaGUoW3NlbGYgdXNlc1BhZ2VDYWNoZV0p OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cK aW5kZXggZmQ1OGI2OS4uMjFkMTQ1NSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxvZwor KysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDUtMzEgIEFu dG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWZhY3RvciBwbGF0Zm9ybSBkZXBlbmRlbnQg ZWRpdGluZyBiZWhhdmlvciBjb2RlIG91dCBvZiBTZXR0aW5ncworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4NTQKKworICAgICAgICBFZGl0aW5nQmVo YXZpb3IgZW51bSB3YXMgcmVuYW1lZCB0byBFZGl0aW5nQmVoYXZpb3JUeXBlcyBhbmQgbW92ZWQg b3V0IGZyb20gU2V0dGluZ3MuaCB0bworICAgICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlcy5oIC4g Q2FsbCBzaXRlcyBpbiBXZWJLaXQvIGFkanVzdGVkIGFjY29yZGluZ2x5LgorCisgICAgICAgICog V2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwOgorICAgICAgICAoRHVt cFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcik6CisKIDIwMTAtMDYtMDYg IEFudG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4sIExhc3psbyBHb21ib3MgIDxs YXN6bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGgg Q2hyaXN0aWFuc2VuLCBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3Jl U3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAgYi9XZWJLaXQvcXQvV2ViQ29yZVN1 cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwCmluZGV4IDZjM2U1YzkuLjU0ZGVlYjUg MTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBv cnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3Vw cG9ydFF0LmNwcApAQCAtNDc2LDcgKzQ3Niw3IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0 UXQ6OmVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChRV2ViRnJhbWUqCiAK IHZvaWQgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFn ZSogcGFnZSwgY29uc3QgUVN0cmluZyYgZWRpdGluZ0JlaGF2aW9yKQogewotICAgIFdlYkNvcmU6 OkVkaXRpbmdCZWhhdmlvciBjb3JlRWRpdGluZ0JlaGF2aW9yOworICAgIFdlYkNvcmU6OkVkaXRp bmdCZWhhdmlvclR5cGUgY29yZUVkaXRpbmdCZWhhdmlvcjsKIAogICAgIGlmIChlZGl0aW5nQmVo YXZpb3IgPT0gIndpbiIpCiAgICAgICAgIGNvcmVFZGl0aW5nQmVoYXZpb3IgPSBFZGl0aW5nV2lu ZG93c0JlaGF2aW9yOwpAQCAtNDkxLDcgKzQ5MSw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQ6OnNldEVkaXRpbmdCZWhhdmlvcihRV2ViUGFnZSogcGFnZSwgY29uc3QgUVN0cmluZyYK ICAgICBpZiAoIWNvcmVQYWdlKQogICAgICAgICByZXR1cm47CiAKLSAgICBjb3JlUGFnZS0+c2V0 dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9yKGNvcmVFZGl0aW5nQmVoYXZpb3IpOworICAgIGNv cmVQYWdlLT5zZXR0aW5ncygpLT5zZXRFZGl0aW5nQmVoYXZpb3JUeXBlKGNvcmVFZGl0aW5nQmVo YXZpb3IpOwogfQogCiB2b2lkIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjpkdW1wRnJhbWVMb2Fk ZXIoYm9vbCBiKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2lu L0NoYW5nZUxvZwppbmRleCA0MjJhZTg3Li5iOWNmZGIyIDEwMDY0NAotLS0gYS9XZWJLaXQvd2lu L0NoYW5nZUxvZworKysgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisy MDEwLTA1LTMxICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgcGxhdGZv cm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3MKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM5ODU0CisKKyAgICAg ICAgRWRpdGluZ0JlaGF2aW9yIGVudW0gd2FzIHJlbmFtZWQgdG8gRWRpdGluZ0JlaGF2aW9yVHlw ZXMgYW5kIG1vdmVkIG91dCBmcm9tIFNldHRpbmdzLmggdG8KKyAgICAgICAgRWRpdGluZ0JlaGF2 aW9yVHlwZXMuaCAuIENhbGwgc2l0ZXMgaW4gV2ViS2l0LyBhZGp1c3RlZCBhY2NvcmRpbmdseS4K KworICAgICAgICAqIFdlYlZpZXcuY3BwOgorICAgICAgICAoV2ViVmlldzo6bm90aWZ5UHJlZmVy ZW5jZXNDaGFuZ2VkKToKKwogMjAxMC0wNi0wNCAgQWxpY2UgTGl1ICA8YWxpY2UubGl1QGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBKb24gSG9uZXljdXR0LgpkaWZmIC0tZ2l0IGEv V2ViS2l0L3dpbi9XZWJWaWV3LmNwcCBiL1dlYktpdC93aW4vV2ViVmlldy5jcHAKaW5kZXggOGI3 MmNlMi4uYWFkMWExYSAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9XZWJWaWV3LmNwcAorKysgYi9X ZWJLaXQvd2luL1dlYlZpZXcuY3BwCkBAIC00NjU0LDcgKzQ2NTQsNyBAQCBIUkVTVUxUIFdlYlZp ZXc6Om5vdGlmeVByZWZlcmVuY2VzQ2hhbmdlZChJV2ViTm90aWZpY2F0aW9uKiBub3RpZmljYXRp b24pCiAgICAgaHIgPSBwcmVmZXJlbmNlcy0+ZWRpdGluZ0JlaGF2aW9yKCZlZGl0aW5nQmVoYXZp b3IpOwogICAgIGlmIChGQUlMRUQoaHIpKQogICAgICAgICByZXR1cm4gaHI7Ci0gICAgc2V0dGlu Z3MtPnNldEVkaXRpbmdCZWhhdmlvcigoRWRpdGluZ0JlaGF2aW9yKWVkaXRpbmdCZWhhdmlvcik7 CisgICAgc2V0dGluZ3MtPnNldEVkaXRpbmdCZWhhdmlvclR5cGUoKEVkaXRpbmdCZWhhdmlvclR5 cGUpZWRpdGluZ0JlaGF2aW9yKTsKIAogICAgIGhyID0gcHJlZmVyZW5jZXMtPnVzZXNQYWdlQ2Fj aGUoJmVuYWJsZWQpOwogICAgIGlmIChGQUlMRUQoaHIpKQotLSAKMS43LjAuNAoK 59894 2010-06-28 05:35:40 -0700 2010-06-30 20:01:31 -0700 patch v3 - part II 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 4906 tonikitoo RnJvbSBkMDI3ZWU0MzJhZjJhMDMzYzEzMjFkMGMzNWUyYmI5YTIzYTI4YzAwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAyOCBKdW4gMjAxMCAwODozMzozMyAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzIChwYXJ0IElJKQogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM5ODU0CgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KUGF0Y2ggYnkgQW50b25pbyBHb21l cyA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CgpNYWMgcG9ydCBpcyBjdXJyZW50bHkgdGhlIG9ubHkg cG9ydCByZWx5aW5nIG9uIGEgc3R5bGUgdG8gYmUgcHJlc2VudCBvbiB0aGUgc3RhcnQKb2YgYSBz ZWxlY3Rpb24gdG8gY29uc2lkZXIgdGhlIHN0eWxlIGFzIGFwcGxpZWQgb3Igbm90LiBBbGwgb3Ro ZXIgcG9ydHMKaGF2ZSB0byBoYXZlIHRoZSBzdHlsZSBwcmVzZW50IGluIGFsbCB0ZXh0IG5vZGUg b2YgdGhlIHNlbGVjdGlvbiBmb3Igc3VjaC4KClBhdGNoIG1ha2VzIHNpdHVhdGlvbnMgdGhhdCBk ZXBlbmQgb24gdGhpcyBjaGVjayBsaWtlIHRoaXMgdG8gYmUgY29udHJvbGxlZCBieQp0aGUgRWRp dGluZ0JlaGF2aW9yIGNsYXNzLgoKUmVmYWN0b3JpbmcsIHNvIG5vIG5ldyB0ZXN0cyBuZWVkZWQu CgoqIGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6 OnNob3VsZENvbnNpZGVyU3R5bGVQcmVzZW50T25seUlmVGhyb3VnaG91dFRoZVNlbGVjdGlvbik6 CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZEV4dGVuZFNlbGVjdGlvbkZyb21FbmRQ b2ludEFsd2F5cyk6CiogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKFdlYkNvcmU6OmV4ZWN1 dGVUb2dnbGVTdHlsZSk6CihXZWJDb3JlOjpzdGF0ZVN0eWxlKToKLS0tCiBXZWJDb3JlL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgfCAgIDIzICsrKysrKysrKysrKysrKysrKysrKysrCiBXZWJD b3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggfCAgICAyICsrCiBXZWJDb3JlL2VkaXRpbmcv RWRpdG9yQ29tbWFuZC5jcHAgfCAgIDE0ICsrKysrKysrKystLS0tCiAzIGZpbGVzIGNoYW5nZWQs IDM1IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9D aGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBkYjFhNTkyLi45OTQ4MDZjIDEwMDY0 NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDI2IEBACisyMDEwLTA2LTI4ICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MgKHBhcnQgSUkpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0zOTg1NAorCisgICAgICAgIE1hYyBwb3J0IGlzIGN1cnJlbnRseSB0aGUgb25seSBw b3J0IHJlbHlpbmcgb24gYSBzdHlsZSB0byBiZSBwcmVzZW50IG9uIHRoZSBzdGFydAorICAgICAg ICBvZiBhIHNlbGVjdGlvbiB0byBjb25zaWRlciB0aGUgc3R5bGUgYXMgYXBwbGllZCBvciBub3Qu IEFsbCBvdGhlciBwb3J0cworICAgICAgICBoYXZlIHRvIGhhdmUgdGhlIHN0eWxlIHByZXNlbnQg aW4gYWxsIHRleHQgbm9kZSBvZiB0aGUgc2VsZWN0aW9uIGZvciBzdWNoLgorCisgICAgICAgIFBh dGNoIG1ha2VzIHNpdHVhdGlvbnMgdGhhdCBkZXBlbmQgb24gdGhpcyBjaGVjayBsaWtlIHRoaXMg dG8gYmUgY29udHJvbGxlZCBieQorICAgICAgICB0aGUgRWRpdGluZ0JlaGF2aW9yIGNsYXNzLgor CisgICAgICAgIFJlZmFjdG9yaW5nLCBzbyBubyBuZXcgdGVzdHMgbmVlZGVkLgorCisgICAgICAg ICogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2Vs ZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkRXh0ZW5k U2VsZWN0aW9uRnJvbUVuZFBvaW50QWx3YXlzKToKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRvckNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZVRvZ2dsZVN0eWxlKToKKyAgICAg ICAgKFdlYkNvcmU6OnN0YXRlU3R5bGUpOgorCiAyMDEwLTA2LTI1ICBBbnRvbmlvIEdvbWVzICA8 dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCBjb21wbGVtZW50YXJ5 IGZpeCBmb3IgcjYxODE4LiBJdCBhZGRlZCBTdGF0aWNIYXNoU2V0TGlzdE5vZGUuY3BwfGggdG8g dGhlIHN5c3RlbSwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3Iu aCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAppbmRleCBmZTA5ZTFiLi45N2I3 OGIxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKKysrIGIv V2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCkBAIC00OSw2ICs0OSw4IEBAIHB1Ymxp YzoKICAgICAvLyBjb250ZW50IHNob3VsZCBiZSBzY3JvbGxlZCBzdWNoIHRoYXQgdGhlIHNlbGVj dGlvbiBnZXRzIGNlcnRlciBhbGlnbmVkLgogICAgIGJvb2wgc2hvdWxkQ2VudGVyQWxpZ25XaGVu U2VsZWN0aW9uSXNSZXZlYWxlZCgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFj QmVoYXZpb3I7IH0KIAorICAgIGJvb2wgc2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZU aHJvdWdob3V0VGhlU2VsZWN0aW9uKCkgY29uc3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdN YWNCZWhhdmlvcjsgfQorCiBwcml2YXRlOgogICAgIEVkaXRpbmdCZWhhdmlvclR5cGUgbV90eXBl OwogfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCBiL1dl YkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAppbmRleCAwZmMwMDY4Li41NTM0ODM4IDEw MDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29y ZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCkBAIC0xNjUsOSArMTY1LDggQEAgc3RhdGljIGJv b2wgZXhlY3V0ZVRvZ2dsZVN0eWxlKEZyYW1lKiBmcmFtZSwgRWRpdG9yQ29tbWFuZFNvdXJjZSBz b3VyY2UsIEVkaXRBY3QKICAgICAvLyBTdHlsZSBpcyBjb25zaWRlcmVkIHByZXNlbnQgd2hlbgog ICAgIC8vIG1hYzogcHJlc2VudCBhdCB0aGUgYmVnaW5uaW5nIG9mIHNlbGVjdGlvbgogICAgIC8v IG90aGVyOiBwcmVzZW50IHRocm91Z2hvdXQgdGhlIHNlbGVjdGlvbgotICAgIFNldHRpbmdzKiBz ZXR0aW5ncyA9IGZyYW1lLT5kb2N1bWVudCgpLT5zZXR0aW5ncygpOwogICAgIGJvb2wgc3R5bGVJ c1ByZXNlbnQ7Ci0gICAgaWYgKHNldHRpbmdzICYmIHNldHRpbmdzLT5lZGl0aW5nQmVoYXZpb3JU eXBlKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgIGlmICghZnJhbWUtPmVkaXRvcigpLT5i ZWhhdmlvcigpLnNob3VsZENvbnNpZGVyU3R5bGVQcmVzZW50T25seUlmVGhyb3VnaG91dFRoZVNl bGVjdGlvbigpKQogICAgICAgICBzdHlsZUlzUHJlc2VudCA9IGZyYW1lLT5lZGl0b3IoKS0+c2Vs ZWN0aW9uU3RhcnRIYXNTdHlsZShzdHlsZS5nZXQoKSk7CiAgICAgZWxzZQogICAgICAgICBzdHls ZUlzUHJlc2VudCA9IGZyYW1lLT5lZGl0b3IoKS0+c2VsZWN0aW9uSGFzU3R5bGUoc3R5bGUuZ2V0 KCkpID09IFRydWVUcmlTdGF0ZTsKQEAgLTIzMiw4ICsyMzEsMTUgQEAgc3RhdGljIGJvb2wgZXhw YW5kU2VsZWN0aW9uVG9HcmFudWxhcml0eShGcmFtZSogZnJhbWUsIFRleHRHcmFudWxhcml0eSBn cmFudWxhcmkKIHN0YXRpYyBUcmlTdGF0ZSBzdGF0ZVN0eWxlKEZyYW1lKiBmcmFtZSwgaW50IHBy b3BlcnR5SUQsIGNvbnN0IGNoYXIqIGRlc2lyZWRWYWx1ZSkKIHsKICAgICBSZWZQdHI8Q1NTTXV0 YWJsZVN0eWxlRGVjbGFyYXRpb24+IHN0eWxlID0gQ1NTTXV0YWJsZVN0eWxlRGVjbGFyYXRpb246 OmNyZWF0ZSgpOwotICAgIHN0eWxlLT5zZXRQcm9wZXJ0eShwcm9wZXJ0eUlELCBkZXNpcmVkVmFs dWUpOwotICAgIHJldHVybiBmcmFtZS0+ZWRpdG9yKCktPnNlbGVjdGlvbkhhc1N0eWxlKHN0eWxl LmdldCgpKTsKKyAgICBzdHlsZS0+c2V0UHJvcGVydHkocHJvcGVydHlJRCwgZGVzaXJlZFZhbHVl KTsgLy8gV2UgbmVlZCB0byBhZGQgdGhpcyBzdHlsZSB0byBwYXNzIGl0IHRvIHNlbGVjdGlvblN0 YXJ0SGFzU3R5bGUgLyBzZWxlY3Rpb25IYXNTdHlsZQorCisgICAgVHJpU3RhdGUgc3R5bGVJc1By ZXNlbnQ7CisgICAgaWYgKCFmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9yKCkuc2hvdWxkQ29uc2lk ZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9uKCkpCisgICAgICAgIHN0 eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25TdGFydEhhc1N0eWxlKHN0 eWxlLmdldCgpKSA/IFRydWVUcmlTdGF0ZSA6IEZhbHNlVHJpU3RhdGU7CisgICAgZWxzZQorICAg ICAgICBzdHlsZUlzUHJlc2VudCA9IGZyYW1lLT5lZGl0b3IoKS0+c2VsZWN0aW9uSGFzU3R5bGUo c3R5bGUuZ2V0KCkpOworCisgICAgcmV0dXJuIHN0eWxlSXNQcmVzZW50OwogfQogCiBzdGF0aWMg U3RyaW5nIHZhbHVlU3R5bGUoRnJhbWUqIGZyYW1lLCBpbnQgcHJvcGVydHlJRCkKLS0gCjEuNy4w LjQKCg== 60186 2010-06-30 20:01:31 -0700 2010-07-08 11:54:24 -0700 patch v3.1 - part II 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 4842 tonikitoo RnJvbSBlZWE0N2U5MWJkNmNjMzU2NzI4MmVlZjk5ZGI4OWZmNWU3MTU2MDliIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogTW9uLCAyOCBKdW4gMjAxMCAwODozMzozMyAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFJl ZmFjdG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNl dHRpbmdzIChwYXJ0IElJKQogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM5ODU0CgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KUGF0Y2ggYnkgQW50b25pbyBHb21l cyA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CgpNYWMgcG9ydCBpcyBjdXJyZW50bHkgdGhlIG9ubHkg cG9ydCByZWx5aW5nIG9uIGEgc3R5bGUgdG8gYmUgcHJlc2VudCBhdCB0aGUgc3RhcnQKb2YgYSBz ZWxlY3Rpb24gdG8gY29uc2lkZXIgdGhlIHN0eWxlIGFzIGFwcGxpZWQgb3Igbm90LiBBbGwgb3Ro ZXIgcG9ydHMKaGF2ZSB0byBoYXZlIHRoZSBzdHlsZSBwcmVzZW50IGluIGFsbCB0ZXh0IG5vZGUg b2YgYSBzZWxlY3Rpb24gZm9yIHN1Y2guCgpQYXRjaCBtYWtlcyBzaXR1YXRpb25zIHRoYXQgZGVw ZW5kIG9uIGNoZWNrcyBsaWtlIHRoaXMgdG8gYmUgY29udHJvbGxlZCBieQp0aGUgRWRpdGluZ0Jl aGF2aW9yIGNsYXNzLgoKUmVmYWN0b3JpbmcsIHNvIG5vIG5ldyB0ZXN0cyBuZWVkZWQuCgoqIGVk aXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6CihXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3Vs ZENvbnNpZGVyU3R5bGVQcmVzZW50T25seUlmVGhyb3VnaG91dFRoZVNlbGVjdGlvbik6CihXZWJD b3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZEV4dGVuZFNlbGVjdGlvbkZyb21FbmRQb2ludEFs d2F5cyk6CiogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKFdlYkNvcmU6OmV4ZWN1dGVUb2dn bGVTdHlsZSk6CihXZWJDb3JlOjpzdGF0ZVN0eWxlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAg ICAgICAgICAgICAgICAgfCAgIDIzICsrKysrKysrKysrKysrKysrKysrKysrCiBXZWJDb3JlL2Vk aXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggfCAgICAyICsrCiBXZWJDb3JlL2VkaXRpbmcvRWRpdG9y Q29tbWFuZC5jcHAgfCAgIDE0ICsrKysrKysrKystLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDM1IGlu c2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VM b2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBmOGY4MTI3Li41ZTBkNmQ5IDEwMDY0NAotLS0g YS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2 IEBACisyMDEwLTA2LTI4ICBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3Ig cGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0dGluZ3Mg KHBhcnQgSUkpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zOTg1NAorCisgICAgICAgIE1hYyBwb3J0IGlzIGN1cnJlbnRseSB0aGUgb25seSBwb3J0IHJl bHlpbmcgb24gYSBzdHlsZSB0byBiZSBwcmVzZW50IGF0IHRoZSBzdGFydAorICAgICAgICBvZiBh IHNlbGVjdGlvbiB0byBjb25zaWRlciB0aGUgc3R5bGUgYXMgYXBwbGllZCBvciBub3QuIEFsbCBv dGhlciBwb3J0cworICAgICAgICBoYXZlIHRvIGhhdmUgdGhlIHN0eWxlIHByZXNlbnQgaW4gYWxs IHRleHQgbm9kZSBvZiB0aGUgc2VsZWN0aW9uIGZvciBzdWNoLgorCisgICAgICAgIFBhdGNoIG1h a2VzIHNpdHVhdGlvbnMgdGhhdCBkZXBlbmQgb24gY2hlY2tzIGxpa2UgdGhpcyB0byBiZSBjb250 cm9sbGVkIGJ5CisgICAgICAgIHRoZSBFZGl0aW5nQmVoYXZpb3IgY2xhc3MuCisKKyAgICAgICAg UmVmYWN0b3JpbmcsIHNvIG5vIG5ldyB0ZXN0cyBuZWVkZWQuCisKKyAgICAgICAgKiBlZGl0aW5n L0VkaXRpbmdCZWhhdmlvci5oOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpz aG91bGRDb25zaWRlclN0eWxlUHJlc2VudE9ubHlJZlRocm91Z2hvdXRUaGVTZWxlY3Rpb24pOgor ICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRFeHRlbmRTZWxlY3Rpb25G cm9tRW5kUG9pbnRBbHdheXMpOgorICAgICAgICAqIGVkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlVG9nZ2xlU3R5bGUpOgorICAgICAgICAoV2ViQ29y ZTo6c3RhdGVTdHlsZSk6CisKIDIwMTAtMDYtMjggIE1PUklUQSBIYWppbWUgIDxtb3JyaXRhQGdv b2dsZS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCBhdHRlbXB0IHRvIGZpeCB3aW5kb3dzIGJ1 aWxkLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oIGIvV2Vi Q29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCmluZGV4IGZlMDllMWIuLjk3Yjc4YjEgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9XZWJDb3Jl L2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKQEAgLTQ5LDYgKzQ5LDggQEAgcHVibGljOgogICAg IC8vIGNvbnRlbnQgc2hvdWxkIGJlIHNjcm9sbGVkIHN1Y2ggdGhhdCB0aGUgc2VsZWN0aW9uIGdl dHMgY2VydGVyIGFsaWduZWQuCiAgICAgYm9vbCBzaG91bGRDZW50ZXJBbGlnbldoZW5TZWxlY3Rp b25Jc1JldmVhbGVkKCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IEVkaXRpbmdNYWNCZWhhdmlv cjsgfQogCisgICAgYm9vbCBzaG91bGRDb25zaWRlclN0eWxlUHJlc2VudE9ubHlJZlRocm91Z2hv dXRUaGVTZWxlY3Rpb24oKSBjb25zdCB7IHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ01hY0JlaGF2 aW9yOyB9CisKIHByaXZhdGU6CiAgICAgRWRpdGluZ0JlaGF2aW9yVHlwZSBtX3R5cGU7CiB9Owpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwIGIvV2ViQ29yZS9l ZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCmluZGV4IDBmYzAwNjguLjU1MzQ4MzggMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAKQEAgLTE2NSw5ICsxNjUsOCBAQCBzdGF0aWMgYm9vbCBleGVj dXRlVG9nZ2xlU3R5bGUoRnJhbWUqIGZyYW1lLCBFZGl0b3JDb21tYW5kU291cmNlIHNvdXJjZSwg RWRpdEFjdAogICAgIC8vIFN0eWxlIGlzIGNvbnNpZGVyZWQgcHJlc2VudCB3aGVuCiAgICAgLy8g bWFjOiBwcmVzZW50IGF0IHRoZSBiZWdpbm5pbmcgb2Ygc2VsZWN0aW9uCiAgICAgLy8gb3RoZXI6 IHByZXNlbnQgdGhyb3VnaG91dCB0aGUgc2VsZWN0aW9uCi0gICAgU2V0dGluZ3MqIHNldHRpbmdz ID0gZnJhbWUtPmRvY3VtZW50KCktPnNldHRpbmdzKCk7CiAgICAgYm9vbCBzdHlsZUlzUHJlc2Vu dDsKLSAgICBpZiAoc2V0dGluZ3MgJiYgc2V0dGluZ3MtPmVkaXRpbmdCZWhhdmlvclR5cGUoKSA9 PSBFZGl0aW5nTWFjQmVoYXZpb3IpCisgICAgaWYgKCFmcmFtZS0+ZWRpdG9yKCktPmJlaGF2aW9y KCkuc2hvdWxkQ29uc2lkZXJTdHlsZVByZXNlbnRPbmx5SWZUaHJvdWdob3V0VGhlU2VsZWN0aW9u KCkpCiAgICAgICAgIHN0eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25T dGFydEhhc1N0eWxlKHN0eWxlLmdldCgpKTsKICAgICBlbHNlCiAgICAgICAgIHN0eWxlSXNQcmVz ZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5nZXQoKSkgPT0g VHJ1ZVRyaVN0YXRlOwpAQCAtMjMyLDggKzIzMSwxNSBAQCBzdGF0aWMgYm9vbCBleHBhbmRTZWxl Y3Rpb25Ub0dyYW51bGFyaXR5KEZyYW1lKiBmcmFtZSwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFy aQogc3RhdGljIFRyaVN0YXRlIHN0YXRlU3R5bGUoRnJhbWUqIGZyYW1lLCBpbnQgcHJvcGVydHlJ RCwgY29uc3QgY2hhciogZGVzaXJlZFZhbHVlKQogewogICAgIFJlZlB0cjxDU1NNdXRhYmxlU3R5 bGVEZWNsYXJhdGlvbj4gc3R5bGUgPSBDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbjo6Y3JlYXRl KCk7Ci0gICAgc3R5bGUtPnNldFByb3BlcnR5KHByb3BlcnR5SUQsIGRlc2lyZWRWYWx1ZSk7Ci0g ICAgcmV0dXJuIGZyYW1lLT5lZGl0b3IoKS0+c2VsZWN0aW9uSGFzU3R5bGUoc3R5bGUuZ2V0KCkp OworICAgIHN0eWxlLT5zZXRQcm9wZXJ0eShwcm9wZXJ0eUlELCBkZXNpcmVkVmFsdWUpOyAvLyBX ZSBuZWVkIHRvIGFkZCB0aGlzIHN0eWxlIHRvIHBhc3MgaXQgdG8gc2VsZWN0aW9uU3RhcnRIYXNT dHlsZSAvIHNlbGVjdGlvbkhhc1N0eWxlCisKKyAgICBUcmlTdGF0ZSBzdHlsZUlzUHJlc2VudDsK KyAgICBpZiAoIWZyYW1lLT5lZGl0b3IoKS0+YmVoYXZpb3IoKS5zaG91bGRDb25zaWRlclN0eWxl UHJlc2VudE9ubHlJZlRocm91Z2hvdXRUaGVTZWxlY3Rpb24oKSkKKyAgICAgICAgc3R5bGVJc1By ZXNlbnQgPSBmcmFtZS0+ZWRpdG9yKCktPnNlbGVjdGlvblN0YXJ0SGFzU3R5bGUoc3R5bGUuZ2V0 KCkpID8gVHJ1ZVRyaVN0YXRlIDogRmFsc2VUcmlTdGF0ZTsKKyAgICBlbHNlCisgICAgICAgIHN0 eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5n ZXQoKSk7CisKKyAgICByZXR1cm4gc3R5bGVJc1ByZXNlbnQ7CiB9CiAKIHN0YXRpYyBTdHJpbmcg dmFsdWVTdHlsZShGcmFtZSogZnJhbWUsIGludCBwcm9wZXJ0eUlEKQotLSAKMS43LjAuNAoK 60921 2010-07-08 11:54:24 -0700 2010-07-08 12:13:14 -0700 (r62815,r=ojan) patch v3.2 - part II 0001-Refactor-platform-dependent-editing-behavior-code-ou.patch text/plain 3954 tonikitoo RnJvbSBlNDU0OWRjZWZkZjQ5NTkwYjY0MmYwMmYwOWY1Y2I4YzdjNzk3MDk5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogVGh1LCA4IEp1bCAyMDEwIDE0OjQxOjU5IC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gUmVm YWN0b3IgcGxhdGZvcm0gZGVwZW5kZW50IGVkaXRpbmcgYmVoYXZpb3IgY29kZSBvdXQgb2YgU2V0 dGluZ3MgKHBhcnQgSUkpCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 Mzk4NTQKClJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpQYXRjaCBieSBBbnRvbmlvIEdvbWVz IDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KCk1hYyBwb3J0IGlzIGN1cnJlbnRseSB0aGUgb25seSBw b3J0IHJlbHlpbmcgb24gYSBzdHlsZSB0byBiZSBwcmVzZW50IG9uIHRoZSBzdGFydApvZiBhIHNl bGVjdGlvbiB0byBjb25zaWRlciB0aGUgc3R5bGUgYXMgYXBwbGllZCBvciBub3QuIEFsbCBvdGhl ciBwb3J0cwpoYXZlIHRvIGhhdmUgdGhlIHN0eWxlIHByZXNlbnQgaW4gYWxsIHRleHQgbm9kZSBv ZiB0aGUgc2VsZWN0aW9uIGZvciBzdWNoLgoKUGF0Y2ggbWFrZXMgc2l0dWF0aW9ucyB0aGF0IGRl cGVuZCBvbiB0aGlzIGNoZWNrIGxpa2UgdGhpcyB0byBiZSBjb250cm9sbGVkIGJ5CnRoZSBFZGl0 aW5nQmVoYXZpb3IgY2xhc3MuCgpSZWZhY3RvcmluZywgc28gbm8gbmV3IHRlc3RzIG5lZWRlZC4K CiogZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDoKKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6 c2hvdWxkVG9nZ2xlU3R5bGVCYXNlZE9uU3RhcnRPZlNlbGVjdGlvbik6CiogZWRpdGluZy9FZGl0 b3JDb21tYW5kLmNwcDoKKFdlYkNvcmU6OmV4ZWN1dGVUb2dnbGVTdHlsZSk6Ci0tLQogV2ViQ29y ZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgIHwgICAyMSArKysrKysrKysrKysrKysrKysrKysK IFdlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCB8ICAgIDQgKysrKwogV2ViQ29yZS9l ZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwIHwgICAgNSArKystLQogMyBmaWxlcyBjaGFuZ2VkLCAy OCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hh bmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDNlNTg5NC4uMDIyZDk2ZSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNCBAQAorMjAxMC0wNi0yOCAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlZmFj dG9yIHBsYXRmb3JtIGRlcGVuZGVudCBlZGl0aW5nIGJlaGF2aW9yIGNvZGUgb3V0IG9mIFNldHRp bmdzIChwYXJ0IElJKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9Mzk4NTQKKworICAgICAgICBNYWMgcG9ydCBpcyBjdXJyZW50bHkgdGhlIG9ubHkgcG9y dCByZWx5aW5nIG9uIGEgc3R5bGUgdG8gYmUgcHJlc2VudCBvbiB0aGUgc3RhcnQKKyAgICAgICAg b2YgYSBzZWxlY3Rpb24gdG8gY29uc2lkZXIgdGhlIHN0eWxlIGFzIGFwcGxpZWQgb3Igbm90LiBB bGwgb3RoZXIgcG9ydHMKKyAgICAgICAgaGF2ZSB0byBoYXZlIHRoZSBzdHlsZSBwcmVzZW50IGlu IGFsbCB0ZXh0IG5vZGUgb2YgdGhlIHNlbGVjdGlvbiBmb3Igc3VjaC4KKworICAgICAgICBQYXRj aCBtYWtlcyBzaXR1YXRpb25zIHRoYXQgZGVwZW5kIG9uIHRoaXMgY2hlY2sgbGlrZSB0aGlzIHRv IGJlIGNvbnRyb2xsZWQgYnkKKyAgICAgICAgdGhlIEVkaXRpbmdCZWhhdmlvciBjbGFzcy4KKwor ICAgICAgICBSZWZhY3RvcmluZywgc28gbm8gbmV3IHRlc3RzIG5lZWRlZC4KKworICAgICAgICAq IGVkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmg6CisgICAgICAgIChXZWJDb3JlOjpFZGl0aW5nQmVo YXZpb3I6OnNob3VsZFRvZ2dsZVN0eWxlQmFzZWRPblN0YXJ0T2ZTZWxlY3Rpb24pOgorICAgICAg ICAqIGVkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpleGVjdXRl VG9nZ2xlU3R5bGUpOgorCiAyMDEwLTA3LTA3IEdyYWNlIEtsb2JhICA8a2xvYmFnQGdtYWlsLmNv bT4gLCBBbnRvbmlvIEdvbWVzICA8dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRp dGluZ0JlaGF2aW9yLmggYi9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKaW5kZXgg ZmUwOWUxYi4uZDQ0MmFkNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhh dmlvci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApAQCAtNDksNiAr NDksMTAgQEAgcHVibGljOgogICAgIC8vIGNvbnRlbnQgc2hvdWxkIGJlIHNjcm9sbGVkIHN1Y2gg dGhhdCB0aGUgc2VsZWN0aW9uIGdldHMgY2VydGVyIGFsaWduZWQuCiAgICAgYm9vbCBzaG91bGRD ZW50ZXJBbGlnbldoZW5TZWxlY3Rpb25Jc1JldmVhbGVkKCkgY29uc3QgeyByZXR1cm4gbV90eXBl ID09IEVkaXRpbmdNYWNCZWhhdmlvcjsgfQogCisgICAgLy8gT24gTWFjLCBzdHlsZSBpcyBjb25z aWRlcmVkIHByZXNlbnQgd2hlbiBwcmVzZW50IGF0IHRoZSBiZWdpbm5pbmcgb2Ygc2VsZWN0aW9u LiBPbiBvdGhlciBwbGF0Zm9ybXMsCisgICAgLy8gc3R5bGUgaGFzIHRvIGJlIHByZXNlbnQgdGhy b3VnaG91dCB0aGUgc2VsZWN0aW9uLgorICAgIGJvb2wgc2hvdWxkVG9nZ2xlU3R5bGVCYXNlZE9u U3RhcnRPZlNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nTWFjQmVo YXZpb3I7IH0KKwogcHJpdmF0ZToKICAgICBFZGl0aW5nQmVoYXZpb3JUeXBlIG1fdHlwZTsKIH07 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKaW5kZXggMGZjMDA2OC4uNDhhN2RkOCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRp dGluZy9FZGl0b3JDb21tYW5kLmNwcApAQCAtMTY1LDkgKzE2NSwxMCBAQCBzdGF0aWMgYm9vbCBl eGVjdXRlVG9nZ2xlU3R5bGUoRnJhbWUqIGZyYW1lLCBFZGl0b3JDb21tYW5kU291cmNlIHNvdXJj ZSwgRWRpdEFjdAogICAgIC8vIFN0eWxlIGlzIGNvbnNpZGVyZWQgcHJlc2VudCB3aGVuCiAgICAg Ly8gbWFjOiBwcmVzZW50IGF0IHRoZSBiZWdpbm5pbmcgb2Ygc2VsZWN0aW9uCiAgICAgLy8gb3Ro ZXI6IHByZXNlbnQgdGhyb3VnaG91dCB0aGUgc2VsZWN0aW9uCi0gICAgU2V0dGluZ3MqIHNldHRp bmdzID0gZnJhbWUtPmRvY3VtZW50KCktPnNldHRpbmdzKCk7CisKKyAgICAvLyBGSVhNRTogTWFr ZSBzdGF0ZVN0eWxlKCkgdG8gdXNlIHRoaXMgZWRpdGluZyBtZXRob2QgdG9vIGZvciB0aGUgY2Fz ZXMgd2hlcmUgaXQncyB1c2VkIGZvciBxdWVyeUNvbW1hbmRTdGF0ZS4KICAgICBib29sIHN0eWxl SXNQcmVzZW50OwotICAgIGlmIChzZXR0aW5ncyAmJiBzZXR0aW5ncy0+ZWRpdGluZ0JlaGF2aW9y VHlwZSgpID09IEVkaXRpbmdNYWNCZWhhdmlvcikKKyAgICBpZiAoIWZyYW1lLT5lZGl0b3IoKS0+ YmVoYXZpb3IoKS5zaG91bGRUb2dnbGVTdHlsZUJhc2VkT25TdGFydE9mU2VsZWN0aW9uKCkpCiAg ICAgICAgIHN0eWxlSXNQcmVzZW50ID0gZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25TdGFydEhh c1N0eWxlKHN0eWxlLmdldCgpKTsKICAgICBlbHNlCiAgICAgICAgIHN0eWxlSXNQcmVzZW50ID0g ZnJhbWUtPmVkaXRvcigpLT5zZWxlY3Rpb25IYXNTdHlsZShzdHlsZS5nZXQoKSkgPT0gVHJ1ZVRy aVN0YXRlOwotLSAKMS43LjAuNAoK