70023 2011-10-13 07:02:14 -0700 [Qt] X11 plugins need to be reworked for Qt5 2011-11-30 16:14:38 -0800 1 1 1 Unclassified WebKit Plug-ins 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED Qt, QtTriaged P2 Normal --- 1 kbalazs kbalazs hausmann ossy webkit.review.bot zoltan oldest_to_newest 483164 0 kbalazs 2011-10-13 07:02:14 -0700 The current plugin code - both WK1 and WK2 - does not build with Qt5 because we don't have QPixmap::fromX11Pixmap anymore. On the bots it is hided by #69931. To fix this we should rethink how plugins should work with QPA. Until that we should explicitly forbid plugins with Qt5 (and not depend on the existence of the qmake bug). 483174 1 110841 kbalazs 2011-10-13 07:17:02 -0700 Created attachment 110841 Patch 485865 2 110841 hausmann 2011-10-18 00:05:04 -0700 Comment on attachment 110841 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110841&action=review > Source/WebCore/features.pri:91 > + unix:!qt5|win32-*:!embedded:!wince*: { Hrm, what is the precedence here? It is one big complex condition that is hard to understand :) It looks like the ":" serves as logical and operator, which means after your change plugins will only be enabled if "unix" _AND_ (!qt5 _or win32). How can the configuration be unix _AND_ win32? Previously it was win32 _OR_ unix. 485913 3 kbalazs 2011-10-18 01:42:59 -0700 (In reply to comment #2) > (From update of attachment 110841 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110841&action=review > > > Source/WebCore/features.pri:91 > > + unix:!qt5|win32-*:!embedded:!wince*: { > > Hrm, what is the precedence here? > > It is one big complex condition that is hard to understand :) > > It looks like the ":" serves as logical and operator, which means after your change > plugins will only be enabled if "unix" _AND_ (!qt5 _or win32). How can the configuration > be unix _AND_ win32? > > Previously it was win32 _OR_ unix. I believe : is stronger than | as in normal logic :), so it is (unix and !qt5) or (win32 and ...), but I can add parentheses to make it clear. 485919 4 kbalazs 2011-10-18 01:58:31 -0700 > I believe : is stronger than | as in normal logic :), so it is (unix and !qt5) or (win32 and ...), but I can add parentheses to make it clear. No I can't, qmake doesn't understand it :( , however I tried with an example and the condition is true on Linux with qt4 qmake and false with qt5 so it seems like my theory about precedence is correct. 492464 5 112867 kbalazs 2011-10-28 08:17:12 -0700 Created attachment 112867 Patch 492465 6 kbalazs 2011-10-28 08:21:33 -0700 Skip plugin tests through the skipped list for Qt5, and not remove the unexplained failures from the list (maybe those will fail in the future as well). Otherwise the same patch. 493216 7 112867 hausmann 2011-10-31 02:08:06 -0700 Comment on attachment 112867 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=112867&action=review > Source/WebKit2/config.h:161 > -#elif (PLATFORM(QT) || (PLATFORM(GTK))) && (OS(UNIX) && !OS(MAC_OS_X)) > +#elif PLATFORM(GTK) && (OS(UNIX) && !OS(MAC_OS_X)) > #define PLUGIN_ARCHITECTURE_X11 1 Hm, won't this end up disabling plugins for the Qt 4.x/X11 based build in trunk? 493231 8 hausmann 2011-10-31 03:22:54 -0700 I think we need at least two steps in this, to at least get windowless plugins on X11: 1) Figure out whether we're on X11 or not. Either at run-time or build time. 2) Replace the QPixmap code in NetscapePluginX11.cpp with plain X11 code to retrieve the image and then wrap it in a QImage. In the long run I wonder if we can add X11 pixmap support to the texture mapper (i.e. layers consisting of an X11 pixmap) on the WebProcess and UIProcess side (using TextureFromPixmap for rendering). That should make the rendering of windowless plugins on X11 really efficient. 493233 9 kbalazs 2011-10-31 03:48:51 -0700 (In reply to comment #7) > (From update of attachment 112867 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=112867&action=review > > > Source/WebKit2/config.h:161 > > -#elif (PLATFORM(QT) || (PLATFORM(GTK))) && (OS(UNIX) && !OS(MAC_OS_X)) > > +#elif PLATFORM(GTK) && (OS(UNIX) && !OS(MAC_OS_X)) > > #define PLUGIN_ARCHITECTURE_X11 1 > > Hm, won't this end up disabling plugins for the Qt 4.x/X11 based build in trunk? Qt 4.x + WebKit2 is not supported. http://trac.webkit.org/browser/trunk/Source/WebKit.pro?#L12 :) 493236 10 kbalazs 2011-10-31 03:56:24 -0700 (In reply to comment #8) > I think we need at least two steps in this, to at least get windowless plugins on X11: > > 1) Figure out whether we're on X11 or not. Either at run-time or build time. > 2) Replace the QPixmap code in NetscapePluginX11.cpp with plain X11 code to retrieve the image and then wrap it in a QImage. Sounds like a plan. I stalled with this because I don't know how to get the X connection with Qt5 (the Display* which is needed to call xlib functions). QX11Info is not functional anymore. It's there but it does not have an implementation -> link error :( 493267 11 hausmann 2011-10-31 06:08:09 -0700 (In reply to comment #10) > (In reply to comment #8) > > I think we need at least two steps in this, to at least get windowless plugins on X11: > > > > 1) Figure out whether we're on X11 or not. Either at run-time or build time. > > 2) Replace the QPixmap code in NetscapePluginX11.cpp with plain X11 code to retrieve the image and then wrap it in a QImage. > > Sounds like a plan. I stalled with this because I don't know how to get the X connection with Qt5 (the Display* which is needed to call xlib functions). QX11Info is not functional anymore. It's there but it does not have an implementation -> link error :( You'll probably have to open a new display connection yourself. Qt is not using xlib but xcb. Flash most probably expects that the application uses Xlib, so that's probably what we'll have to do in WebKit. 495236 12 hausmann 2011-11-03 00:28:37 -0700 Actually a solution for run-time detection is to use the QPlatformNativeInterface, which for X11 for example can retrieve the display (when xcb is using xlib). We still need a way to reliably detect the presence of xlib, so that we can at least build the x11 code and later detect and enable it at run-time. Right now what would work is contains(QT_CONFIG, xcb-xlib) Then we know at least that Qt is built at least with the xcb plugin with xlib support enabled. There may be another plugin enabled at run-time, but at least there's a remote possibility that the xcb-xlib one will show up at some point :) 495323 13 112867 kbalazs 2011-11-03 03:40:46 -0700 Comment on attachment 112867 Patch Landed in http://trac.webkit.org/changeset/99163 497488 14 113932 kbalazs 2011-11-07 14:51:45 -0800 Created attachment 113932 wk2 plugins Rework our basic WK2 plugin support 497491 15 webkit.review.bot 2011-11-07 14:54:55 -0800 Attachment 113932 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'ChangeLog', u'LayoutTests/ChangeLog', u'La..." exit_code: 1 Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:50: Missing spaces around = [whitespace/operators] [4] Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:52: Declaration has space between type name and * in ushort *p [whitespace/declaration] [3] Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:53: Declaration has space between type name and * in ushort *end [whitespace/declaration] [3] Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:59: Declaration has space between type name and * in uint *p [whitespace/declaration] [3] Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:60: Declaration has space between type name and * in uint *end [whitespace/declaration] [3] Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:72: Declaration has space between type name and * in QRgb *p [whitespace/declaration] [3] Total errors found: 6 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 497495 16 kbalazs 2011-11-07 14:59:13 -0800 (In reply to comment #14) > Created an attachment (id=113932) [details] > wk2 plugins > > Rework our basic WK2 plugin support It's still don't do anything for plugin process or windowed plugins. Just rework what we had before. Maybe we also need a runtime check to know what platform plugin we have (xcb, wayland, whatever), I'm not sure. If that's the case then we need to wait for that API to appear in Qt5. Tested with flash. There was no observable problem with the frame rate. 497499 17 kbalazs 2011-11-07 15:00:52 -0800 The style issues are associated with the Qt code. I took it from Qt so I wouldn't like to change it. 497822 18 113932 hausmann 2011-11-08 00:55:22 -0800 Comment on attachment 113932 wk2 plugins View in context: https://bugs.webkit.org/attachment.cgi?id=113932&action=review This is a good start, but it needs some work. I've added comments. Please also do fix the coding style in the function that you took from Qt. > Source/WebKit2/ChangeLog:45 > + affect if PLUGIN_ARCHITECTURE_UNSOPPORTED is not defined. Typo. > Source/WebKit2/WebProcess/Plugins/Netscape/qt/QtPluginHelper.cpp:27 > +/* > + * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). > + * All rights reserved. > + * > + * GNU Lesser General Public License Usage > + * This file may be used under the terms of the GNU Lesser General Public > + * License version 2.1 as published by the Free Software Foundation and > + * appearing in the file LICENSE.LGPL included in the packaging of this > + * file. Please review the following information to ensure the GNU Lesser > + * General Public License version 2.1 requirements will be met: > + * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. > + * > + * In addition, as a special exception, Nokia gives you certain additional > + * rights. These rights are described in the Nokia Qt LGPL Exception > + * version 1.1, included in the file LGPL_EXCEPTION.txt in this package. > + * > + * GNU General Public License Usage > + * Alternatively, this file may be used under the terms of the GNU General > + * Public License version 3.0 as published by the Free Software Foundation > + * and appearing in the file LICENSE.GPL included in the packaging of this > + * file. Please review the following information to ensure the GNU General > + * Public License version 3.0 requirements will be met: > + * http://www.gnu.org/copyleft/gpl.html. > + * > + * Note: The function qimageFromXImage has been taken from the Qt Toolkit. > + * > + */ I think the part of the license text that grants the special exception is not transferrable and should be removed. Similarly we do not intend to take GPL licensed code into WebKit. As a result this file is licensed solely under the LGPL. > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:102 > static inline Display* x11Display() > { > #if PLATFORM(QT) > - return QX11Info::display(); > + static bool opened = false; > + if (!opened) { > + NetscapePlugin::s_fakeDisplayForPlugins = XOpenDisplay(0); > + opened = true; > + } > + return NetscapePlugin::s_fakeDisplayForPlugins; > #elif PLATFORM(GTK) > return GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); > #else I'd prefer this code to turn into a proper public class method of NetscapePlugin. The "fakeDisplayForPlugins" variable can become "static Display* dedicatedPluginDisplay;", local to the function. > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:168 > + if (!display) > + return false; This should be an ASSERT, not a return false. > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:174 > +#if PLATFORM(QT) > + if (depth != 16 && depth != 24 && depth != 32) > + return false; > +#endif I don't think that this should be a run-time check with "return false". I'd rather like to see this as an ASSERT. It is fatal. > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:187 > - ASSERT(visualInfo); > + if (!visualInfo) > + return false; Why did you replace the ASSERT with a return? I think an ASSERT is the right thing to use here, the lack of a visual should be fatal to us. > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:284 > + XImage* xImage = XGetImage(x11Display(), m_drawable, exposedRect.x(), exposedRect.y(), > + exposedRect.width(), exposedRect.height(), ULONG_MAX, ZPixmap); I believe this will leak for each paint. You have to destroy the XImage with XDestroyImage. > Source/WebKit2/config.h:160 > -#elif PLATFORM(GTK) && (OS(UNIX) && !OS(MAC_OS_X)) > +#elif (PLATFORM(QT) || PLATFORM(GTK)) && (OS(UNIX) && !OS(MAC_OS_X)) This doesn't look right when considering that Qt can be compiled for say Linux without xcb support. In that case we should _not_ set PLUGIN_ARCHITECTURE_X11. I think perhaps this whole block of #ifdefs should be changed to allow us to define the plugin architecture from within the .pro files instead of at compile time. So you could for example surround the whole thing by #ifndef PLUGIN_ARCHITECTURE_SET and set it accordingly, along with PLUGIN_ARCHITECTURE_X11 if plugins_X11 is set. > Tools/qmake/mkspecs/features/features.prf:100 > - unix:!haveQt(5)|win32-*:!embedded:!wince*: { > - DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > + !haveQt(5): { > + unix|win32-*:!embedded:!wince*: { > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > + } else { > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > + } > } else { > DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > } Hang on, don't we want to re-enable NPAPI on Qt 5, too? > Tools/qmake/mkspecs/features/features.prf:104 > +!no_webkit2:!contains(DEFINES, PLUGIN_ARCHITECTURE_UNSOPPORTED): { Typo: UNSOPPORTED -> UNSUPPORTED > Tools/qmake/mkspecs/features/features.prf:108 > + DEFINES += PLUGIN_ARCHITECTURE_UNSOPPORTED Typo > LayoutTests/platform/qt-wk1/Skipped:5 > + > +# [Qt] Plugins need to be reworked for Qt5 > +# https://bugs.webkit.org/show_bug.cgi?id=70023 > +plugins This doesn't look right. Don't we want to continue to test plugins with wk1 and Qt 4.x? AFAICS in qt.py, qt-wk1/Skipped is used for builds that are _not_ webkit2, regardless of the Qt version. We should only skip these plugin when running WebKit1 tests with a build of WebKit against Qt 5. 497876 19 kbalazs 2011-11-08 02:36:26 -0800 > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:168 > > + if (!display) > > + return false; > > This should be an ASSERT, not a return false. > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:174 > > +#if PLATFORM(QT) > > + if (depth != 16 && depth != 24 && depth != 32) > > + return false; > > +#endif > > I don't think that this should be a run-time check with "return false". I'd rather like to see this as an ASSERT. It is fatal. > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:187 > > - ASSERT(visualInfo); > > + if (!visualInfo) > > + return false; > > Why did you replace the ASSERT with a return? I think an ASSERT is the right thing to use here, the lack of a visual > should be fatal to us. These conditions are fatal but only for running the plugin. If we return false here then the plugin will be abandoned and we won't be in trouble later. I changed the assert to if because we cannot really control these conditions (the display, the depth, and the visual). Do you still think these should be asserts? > > Source/WebKit2/config.h:160 > > -#elif PLATFORM(GTK) && (OS(UNIX) && !OS(MAC_OS_X)) > > +#elif (PLATFORM(QT) || PLATFORM(GTK)) && (OS(UNIX) && !OS(MAC_OS_X)) > > This doesn't look right when considering that Qt can be compiled for say Linux without xcb support. In that case > we should _not_ set PLUGIN_ARCHITECTURE_X11. > > I think perhaps this whole block of #ifdefs should be changed to allow us to define the plugin architecture > from within the .pro files instead of at compile time. > > So you could for example surround the whole thing by #ifndef PLUGIN_ARCHITECTURE_SET and set it accordingly, along > with PLUGIN_ARCHITECTURE_X11 if plugins_X11 is set. Currently it is surrounded with PLUGIN_ARCHITECTURE_UNSUPPORTED and I used that to prevent turning it on for non xcb-xlib platforms. However you are right in that it would be clearer to set this up solely in the .pro files. > > Tools/qmake/mkspecs/features/features.prf:100 > > - unix:!haveQt(5)|win32-*:!embedded:!wince*: { > > - DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > > + !haveQt(5): { > > + unix|win32-*:!embedded:!wince*: { > > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > > + } else { > > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > > + } > > } else { > > DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > > } > > Hang on, don't we want to re-enable NPAPI on Qt 5, too? Ok, it's not really clear. So, ENABLE_NETSCAPE_PLUGIN_API controls it for WK1, PLUGIN_ARCHITECTURE_??? controls it for WK2. Maybe we should introduce a common config condition for these two, do you think so? Otherwise, do you mean we should fix plugins+Qt5 for WK1 as well? Is the old API supposed to be released with Qt5? Anyhow, it need additional work to fix it for WK1. The WK1 path also has a wider support (windowless/windowed, transparency) so I guess it would not be trivial. I would go with only WK2 in this first step. > > LayoutTests/platform/qt-wk1/Skipped:5 > > + > > +# [Qt] Plugins need to be reworked for Qt5 > > +# https://bugs.webkit.org/show_bug.cgi?id=70023 > > +plugins > > This doesn't look right. Don't we want to continue to test plugins with wk1 and Qt 4.x? > > AFAICS in qt.py, qt-wk1/Skipped is used for builds that are _not_ webkit2, regardless of the Qt version. > > We should only skip these plugin when running WebKit1 tests with a build of WebKit against Qt 5. Sure, it was a silly. 497880 20 hausmann 2011-11-08 02:40:41 -0800 (In reply to comment #19) > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:168 > > > + if (!display) > > > + return false; > > > > This should be an ASSERT, not a return false. > > > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:174 > > > +#if PLATFORM(QT) > > > + if (depth != 16 && depth != 24 && depth != 32) > > > + return false; > > > +#endif > > > > I don't think that this should be a run-time check with "return false". I'd rather like to see this as an ASSERT. It is fatal. > > > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:187 > > > - ASSERT(visualInfo); > > > + if (!visualInfo) > > > + return false; > > > > Why did you replace the ASSERT with a return? I think an ASSERT is the right thing to use here, the lack of a visual > > should be fatal to us. > > These conditions are fatal but only for running the plugin. If we return false here then the plugin will be abandoned and we won't be in trouble later. I changed the assert to if because we cannot really control these conditions (the display, the depth, and the visual). Do you still think these should be asserts? Well, but if the conditions fail, then it's not because of anything specific to the plugin, it means something is seriously busted on the host side, preventing us from loading any plugin. That's why I think this justifies an ASSERT. > > > Tools/qmake/mkspecs/features/features.prf:100 > > > - unix:!haveQt(5)|win32-*:!embedded:!wince*: { > > > - DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > > > + !haveQt(5): { > > > + unix|win32-*:!embedded:!wince*: { > > > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=1 > > > + } else { > > > + DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > > > + } > > > } else { > > > DEFINES += ENABLE_NETSCAPE_PLUGIN_API=0 > > > } > > > > Hang on, don't we want to re-enable NPAPI on Qt 5, too? > > Ok, it's not really clear. So, ENABLE_NETSCAPE_PLUGIN_API controls it for WK1, PLUGIN_ARCHITECTURE_??? controls it for WK2. Maybe we should introduce a common config condition for these two, do you think so? Otherwise, do you mean we should fix plugins+Qt5 for WK1 as well? Is the old API supposed to be released with Qt5? Anyhow, it need additional work to fix it for WK1. The WK1 path also has a wider support (windowless/windowed, transparency) so I guess it would not be trivial. I would go with only WK2 in this first step. Ok, I see. Yes, unfortunately we need to support WK1 with Qt 5, and that includes plugin support :(. That can however easily be a separate "project". Oh, that reminds me: Then we can continue to use the plugin directory code from WebCore/plugins, no? 498040 21 kbalazs 2011-11-08 07:33:08 -0800 > Oh, that reminds me: Then we can continue to use the plugin directory code from WebCore/plugins, no? It is not working. With ENABLE_NETSCAPE_PLUGIN_API=0 - which is necessary as WK1 path does not build with Qt5 - we don't build it. I think copying a few simple line is worth to remove the dependency :) Another issue: I won't be able to enable tests because there is no way to enable them for Qt5-WK2 and Qt4-WK1 but not for Qt5-WK1. 498043 22 114061 kbalazs 2011-11-08 07:34:51 -0800 Created attachment 114061 wk2 plugins v2 498062 23 114061 webkit-ews 2011-11-08 07:57:19 -0800 Comment on attachment 114061 wk2 plugins v2 Attachment 114061 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/10369114 498081 24 114074 kbalazs 2011-11-08 08:15:58 -0800 Created attachment 114074 wk2 plugins v2 fixed 499199 25 114074 hausmann 2011-11-09 11:36:00 -0800 Comment on attachment 114074 wk2 plugins v2 fixed View in context: https://bugs.webkit.org/attachment.cgi?id=114074&action=review Good! This is much better. We're close now. I think one more iteration is needed. Comments below. > Source/WebCore/ChangeLog:21 > + * plugins/qt/QtX11ImageConversion.cpp: Added. > + (WebCore::qimageFromXImage): > + * plugins/qt/QtX11ImageConversion.h: Added. On second thought, isn't it a bit strange to add a file into WebCore that is used only by WebKit2? What about for example WebKit2/Shared/Plugins/qt? > Source/WebCore/plugins/qt/QtX11ImageConversion.cpp:12 > +/* > + * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). > + * All rights reserved. > + * > + * GNU Lesser General Public License Usage > + * This file may be used under the terms of the GNU Lesser General Public > + * License version 2.1 as published by the Free Software Foundation and > + * appearing in the file LICENSE.LGPL included in the packaging of this > + * file. Please review the following information to ensure the GNU Lesser > + * General Public License version 2.1 requirements will be met: > + * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. > + * Ok, after taking another look at this, please use the following license text that we use for code contributions from Nokia: ---- /* * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this program; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. * */ ---- > Source/WebCore/plugins/qt/QtX11ImageConversion.cpp:38 > + ushort * p = reinterpret_cast<ushort*>(image.scanLine(i)); The coding style check missed out the placement of the * :) > Source/WebCore/plugins/qt/QtX11ImageConversion.h:13 > +/* > + * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). > + * All rights reserved. > + * > + * GNU Lesser General Public License Usage > + * This file may be used under the terms of the GNU Lesser General Public > + * License version 2.1 as published by the Free Software Foundation and > + * appearing in the file LICENSE.LGPL included in the packaging of this > + * file. Please review the following information to ensure the GNU Lesser > + * General Public License version 2.1 requirements will be met: > + * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. > + * > + */ (Same here btw regarding the license text) > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:269 > - if (m_pluginDisplay != x11Display()) > + if (m_pluginDisplay != pluginDisplay()) This line makes it clear that we are having a naming problem: If the plugin display is not the plugin display? Huh? The file has NetscapePlugin::pluginDisplay() getPluginDisplay() and m_pluginDisplay I suggest to rename the class method to x11HostDisplay(), so that the code becomes if (m_pluginDisplay != x11HostDisplay()) > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:280 > + QImage image = qimageFromXImage(xImage); > + > QPainter* painter = context->platformContext(); > - painter->drawPixmap(QPoint(exposedRect.x(), exposedRect.y()), qtDrawable, exposedRect); > + painter->drawImage(QPoint(exposedRect.x(), exposedRect.y()), image, exposedRect); > + > + image = QImage(); Instead of clearing the QImage manually, I suggest the use of a temporary and write: painter->drawImage(QPoint(...), qImageFromXImage(xImage), exposedRect()) > Tools/qmake/mkspecs/features/features.prf:105 > + contains(QT_CONFIG, xcb-xlib) { Note: In the future we can replace this "check" about the availability of X11 by using the new module config test feature of the Qt 5 build system. Not necessary for this patch though :) 499764 26 kbalazs 2011-11-10 03:13:43 -0800 (In reply to comment #25) > (From update of attachment 114074 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=114074&action=review > > Good! This is much better. We're close now. I think one more iteration is needed. Comments below. > > > Source/WebCore/ChangeLog:21 > > + * plugins/qt/QtX11ImageConversion.cpp: Added. > > + (WebCore::qimageFromXImage): > > + * plugins/qt/QtX11ImageConversion.h: Added. > > On second thought, isn't it a bit strange to add a file into WebCore that is used only by WebKit2? I added it here to be able to reuse for WK1 in the future - as it is suggested in the changelog ;) Do you think it's reasonable? > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:269 > > - if (m_pluginDisplay != x11Display()) > > + if (m_pluginDisplay != pluginDisplay()) > > This line makes it clear that we are having a naming problem: If the plugin display is not the plugin display? Huh? > The file has > > NetscapePlugin::pluginDisplay() > getPluginDisplay() > and > m_pluginDisplay > > I suggest to rename the class method to x11HostDisplay(), so that the code becomes > > if (m_pluginDisplay != x11HostDisplay()) Actually I plan to remove the getPluginDisplay function and the m_pluginDisplay member. It is only used to determine whether we should call XSync. Actually the results of the whole thing is calling it for Qt and not for GTK so it's better to get rid of that. I planned to do this in another patch but then let's do it here. However x11HostDisplay is a more clear name, I will do the renaming. > > > Tools/qmake/mkspecs/features/features.prf:105 > > + contains(QT_CONFIG, xcb-xlib) { > > Note: In the future we can replace this "check" about the availability of X11 by using the new module config test feature of the Qt 5 build system. Not necessary for this patch though :) I'm going to take a look to this fancy feature. :) 499800 27 kbalazs 2011-11-10 04:43:38 -0800 > > > Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:269 > > > - if (m_pluginDisplay != x11Display()) > > > + if (m_pluginDisplay != pluginDisplay()) > > > > This line makes it clear that we are having a naming problem: If the plugin display is not the plugin display? Huh? > > The file has > > > > NetscapePlugin::pluginDisplay() > > getPluginDisplay() > > and > > m_pluginDisplay > > > > I suggest to rename the class method to x11HostDisplay(), so that the code becomes > > > > if (m_pluginDisplay != x11HostDisplay()) > > Actually I plan to remove the getPluginDisplay function and the m_pluginDisplay member. It is only used to determine whether we should call XSync. Actually the results of the whole thing is calling it for Qt and not for GTK so it's better to get rid of that. I planned to do this in another patch but then let's do it here. However x11HostDisplay is a more clear name, I will do the renaming. Ok, I have just realized that this won't work because we need the display used by the plugin to sync with, i.e. XSysnc(m_pluginDisplay, false). So I'm going to do it as you suggested. 499878 28 114494 kbalazs 2011-11-10 07:11:26 -0800 Created attachment 114494 wk2 plugins v3 499880 29 kbalazs 2011-11-10 07:12:44 -0800 (In reply to comment #28) > Created an attachment (id=114494) [details] > wk2 plugins v3 Incorporated review comments with the exception of - still put the new files to WebCore - postpone the build time x11 test to a next step 499905 30 114494 hausmann 2011-11-10 07:50:24 -0800 Comment on attachment 114494 wk2 plugins v3 View in context: https://bugs.webkit.org/attachment.cgi?id=114494&action=review Nice! r=me > Source/WebCore/ChangeLog:25 > + it for the WK1 plugin support in the future. Alright, I had overlooked that point :) 499998 31 114494 kbalazs 2011-11-10 09:32:41 -0800 Comment on attachment 114494 wk2 plugins v3 Clearing flags on attachment: 114494 Committed r99872: <http://trac.webkit.org/changeset/99872> 500000 32 kbalazs 2011-11-10 09:32:52 -0800 All reviewed patches have been landed. Closing bug. 512210 33 kbalazs 2011-11-30 16:14:38 -0800 Reopen because wk1+qt5 is still need to be reworked (as well as wk2 + pluginprocess but that's another story). Also the skiplist refers to this bug. 110841 2011-10-13 07:17:02 -0700 2011-10-28 08:17:06 -0700 Patch bug-70023-20111013161700.patch text/plain 5582 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTczNjQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0MDFlMGYxZWU2N2M0MTI5MDE3Y2I0 MjY1NGVhZGRkOTY0MWI4NjljLi42ODk0MzhkY2FiNzc2NjMzOTUzN2VjZWJlZWVlYWIxNWNiZmI2 MjUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMTAtMTMgIEJhbGF6cyBLZWxlbWVuICA8 a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdpbnMgbmVlZCB0byBi ZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIERpc2FibGUgcGx1Z2luIHRlc3RzLgorICAgICAgICAqIHBsYXRmb3JtL3F0LXdr Mi9Ta2lwcGVkOgorCiAyMDExLTEwLTEzICBTZXJnaW8gVmlsbGFyIFNlbmluICA8c3ZpbGxhckBp Z2FsaWEuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJlYmFzZWxpbmVkIEdUSyBTVkcgdGVz dCByZXN1bHQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC13azIvU2tpcHBl ZCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMi9Ta2lwcGVkCmluZGV4IDQ5YTZlYjI2YTBh ZWY4NjhmMzgwNWU5OTRmN2QyYzNiZjljYjk5YjguLjc1YWViZTA0YjM5MmQ3M2Q5NjRhMjVkYTVk OGJjY2Y2MmQ4NGE5ZTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMi9T a2lwcGVkCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMi9Ta2lwcGVkCkBAIC0yNyw2 ICsyNywxMSBAQAogIyBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgogIwogCisjIFtRdF0gUGx1Z2lucyBuZWVkIHRvIGJlIHJl d29ya2VkIGZvciBRdDUKKyMgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTcwMDIzCisjIEZJWE1FOiB0aGlzIHNob3VsZCBiZSBtb3ZlZCB0byB0aGUgcXQ1IHNraXBwZWQg bGlzdCBvbmNlIHdlIHN0YXJ0IHVzaW5nIHRoYXQKK3BsdWdpbnMKKwogIyBTdXBwb3J0IGxheW91 dFRlc3RDb250cm9sbGVyLmxheWVyVHJlZUFzVGV4dCBpbiBXZWJLaXRUZXN0UnVubmVyCiAjIDxo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIxNDU+CiBjb21wb3NpdGlu Zy9sYXllci1jcmVhdGlvbi9zY3JvbGwtcGFydGlhbC11cGRhdGUuaHRtbApAQCAtMTYxLDE1ICsx NjYsNiBAQCBzdmcvY3VzdG9tL3VzZS1ldmVudHMtY3Jhc2guc3ZnCiBzdmcvdGV4dC9zZWxlY3Rp b24tdHJpcGxlY2xpY2suc3ZnCiBzdmcvem9vbS9wYWdlL3pvb20tY29vcmRzLXZpZXdhdHRyLTAx LWIuc3ZnCiAKLSMgW1dLMl0gW1F0XSBTdXBwb3J0IGRyYWcgaW4gbW91c2UgZXZlbnRzIGZvciBX ZWJLaXQyIEV2ZW50U2VuZGVyCi0jIDxodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9Njk5NDY+Ci1lZGl0aW5nL3Bhc3RlYm9hcmQvZHJhZy1kcm9wLWlmcmFtZS1yZWZyZXNo LWNyYXNoLmh0bWwKLWVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1hY3Jvc3MtcmVhZG9ubHktaW5w dXQtMS5odG1sCi1lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3QtYWNyb3NzLXJlYWRvbmx5LWlucHV0 LTIuaHRtbAotZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0LWFjcm9zcy1yZWFkb25seS1pbnB1dC0z Lmh0bWwKLWVkaXRpbmcvc2VsZWN0aW9uL3NlbGVjdC1hY3Jvc3MtcmVhZG9ubHktaW5wdXQtNC5o dG1sCi1lZGl0aW5nL3NlbGVjdGlvbi9zZWxlY3QtYWNyb3NzLXJlYWRvbmx5LWlucHV0LTUuaHRt bAotCiAjIFdlYktpdDIgbmVlZHMgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJl bmNlCiAjIDxodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIxOTc+CiAj IEdldCBhY2NlbGVyYXRlZCBjb21wb3NpdGluZyB3b3JraW5nIHdpdGggd2Via2l0MgpAQCAtMjU3 LDEyICsyNTMsNiBAQCBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nsb3NlLXdpbmRvdy5odG1s CiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1hdXRob3JpemF0aW9uLmh0 bWwKIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2luLW5vLWF1dGhvcml6YXRp b24uaHRtbAogCi0jIFVuZXhwbGFpbmVkIHBsdWdpbiBmYWlsdXJlcwotcGx1Z2lucy9lbWJlZC1w cmVmZXJzLXBsdWdpbnMtZm9yLWltYWdlcy5odG1sCi1wbHVnaW5zL25wcC1zZXQtd2luZG93LWNh bGxlZC1kdXJpbmctZGVzdHJ1Y3Rpb24uaHRtbAotcGx1Z2lucy9yZWxvYWRwbHVnaW5zLWFuZC1w YWdlcy5odG1sCi1wbHVnaW5zL21vdXNlLWNsaWNrLWlmcmFtZS10by1wbHVnaW4uaHRtbAotCiAj IFVuZXhwbGFpbmVkIGZhaWx1cmVzCiBmYXN0L2RvbS9mcmFtZS1sb2FkaW5nLXZpYS1kb2N1bWVu dC13cml0ZS5odG1sCiBmYXN0L3RhYmxlL2dpYW50Q2VsbHNwYWNpbmcuaHRtbApAQCAtNzY5LDYg Kzc1OSwxMSBAQCBodHRwL3Rlc3RzL3NlY3VyaXR5L2NvbnRlbnRTZWN1cml0eVBvbGljeS9ldmFs LWJsb2NrZWQuaHRtbAogaHR0cC90ZXN0cy91cmkvY3NzLWhyZWYucGhwCiAKICMgdW5za2lwcGVk IGJ5IHI4ODE1MiwgYnV0IGZhaWwgb24gUXQtV0syIHBsYXRmb3JtCitlZGl0aW5nL3NlbGVjdGlv bi9zZWxlY3QtYWNyb3NzLXJlYWRvbmx5LWlucHV0LTEuaHRtbAorZWRpdGluZy9zZWxlY3Rpb24v c2VsZWN0LWFjcm9zcy1yZWFkb25seS1pbnB1dC0yLmh0bWwKK2VkaXRpbmcvc2VsZWN0aW9uL3Nl bGVjdC1hY3Jvc3MtcmVhZG9ubHktaW5wdXQtMy5odG1sCitlZGl0aW5nL3NlbGVjdGlvbi9zZWxl Y3QtYWNyb3NzLXJlYWRvbmx5LWlucHV0LTQuaHRtbAorZWRpdGluZy9zZWxlY3Rpb24vc2VsZWN0 LWFjcm9zcy1yZWFkb25seS1pbnB1dC01Lmh0bWwKIHN2Zy9XM0MtU1ZHLTEuMS1TRS9maWx0ZXJz LWZlbGVtLTAxLWIuc3ZnCiBzdmcvVzNDLVNWRy0xLjEtU0UvcGFpbnRpbmctbWFya2VyLTA3LWYu c3ZnCiBzdmcvVzNDLVNWRy0xLjEtU0Uvc3RydWN0LXVzZS0xNC1mLnN2ZwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4 IDFjZjg4YjdjMDdjYmI0MTlhZWQ1OGE0NmQ3ZTJlOThjZGMzYmU3MzQuLmZhMmE3OGExNGI4YWM5 YTdhYWNiM2ZlYmFlNjNkMzBjYTY0ZjM3NzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAor MjAxMS0xMC0xMyAgQmFsYXpzIEtlbGVtZW4gIDxrYmFsYXpzQHdlYmtpdC5vcmc+CisKKyAgICAg ICAgW1F0XSBYMTEgcGx1Z2lucyBuZWVkIHRvIGJlIHJld29ya2VkIGZvciBRdDUKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcwMDIzCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRGlzYWJsZSBYMTEgcGx1Z2lu cyB3aXRoIFF0NS4KKyAgICAgICAgKiBmZWF0dXJlcy5wcmk6CisKIDIwMTEtMTAtMTMgIE1pa2hh aWwgTmFnYW5vdiAgPG1uYWdhbm92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVj dG9yOiBbQ2hyb21pdW1dIEFkZCBhbiBhYmlsaXR5IHRvIGxvb2sgdXAgYW5kIGV4cGxvcmUgYW4g b2JqZWN0IGZyb20gYSBoZWFwIHByb2ZpbGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9m ZWF0dXJlcy5wcmkgYi9Tb3VyY2UvV2ViQ29yZS9mZWF0dXJlcy5wcmkKaW5kZXggMDJkN2ViNTJj YTRhNjFiOWE3MGQwZDkzMTVmYmNkOWIxZTQxNTNkYy4uYjVmMWY5YTU3NWQ1MDMwNTkzYTI2ZTVl NDkxMGVjZWZkMmFmMWZhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZmVhdHVyZXMucHJp CisrKyBiL1NvdXJjZS9XZWJDb3JlL2ZlYXR1cmVzLnByaQpAQCAtODgsNyArODgsNyBAQCBpc0Vt cHR5KEhBVkVfUVJBV0ZPTlQpIHsKIAogIyBOZXNjYXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkp CiAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05FVFNDQVBFX1BMVUdJTl9BUEk9LikgewotICAg IHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNlKjogeworICAgIHVuaXg6IXF0NXx3aW4zMi0q OiFlbWJlZGRlZDohd2luY2UqOiB7CiAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBF X1BMVUdJTl9BUEk9MQogICAgIH0gZWxzZSB7CiAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05F VFNDQVBFX1BMVUdJTl9BUEk9MApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9n IGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IGI3YjZhZDE2YzRmNDBlNWE0NzAzMjY1 YmZhMjQyZjFmYmI3OGRlYzYuLjNlODk4OGI3NmEzMDM0Y2UzZGU1Yjc5ZGU5ZWQwMWZjZjkwNmE5 YWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMS0xMC0xMyAgQmFsYXpzIEtlbGVt ZW4gIDxrYmFsYXpzQHdlYmtpdC5vcmc+CisKKyAgICAgICAgW1F0XSBYMTEgcGx1Z2lucyBuZWVk IHRvIGJlIHJld29ya2VkIGZvciBRdDUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTcwMDIzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgRGlzYWJsZSBYMTEgcGx1Z2lucy4KKyAgICAgICAgKiBjb25maWcuaDoK KwogMjAxMS0xMC0xMyAgU2ltb24gSGF1c21hbm4gIDxzaW1vbi5oYXVzbWFubkBub2tpYS5jb20+ CiAKICAgICAgICAgW1F0XVtXSzJdIEZpeCBidWlsZCBhZnRlciBRU0dJdGVtIEFQSSBjaGFuZ2Vz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9jb25maWcuaCBiL1NvdXJjZS9XZWJLaXQyL2Nv bmZpZy5oCmluZGV4IDIwOWE4OTc3NDUyOTRhN2I1NDNmZDViZTU2ZTE2NjIzNDU4ZmEyN2IuLmI5 ZGU3NmM4MmI2NTdjMjU0ZmYyMmViMGFkZTE0YmYwZTRlOTgzNzkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL2NvbmZpZy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL2NvbmZpZy5oCkBAIC0xNTcs NyArMTU3LDcgQEAgc3RhdGljIGNvbnN0IHR5cGUmIG5hbWUoKSBcCiAjZGVmaW5lIFBMVUdJTl9B UkNISVRFQ1RVUkVfTUFDIDEKICNlbGlmIFBMQVRGT1JNKFdJTikKICNkZWZpbmUgUExVR0lOX0FS Q0hJVEVDVFVSRV9XSU4gMQotI2VsaWYgKFBMQVRGT1JNKFFUKSB8fCAoUExBVEZPUk0oR1RLKSkp ICYmIChPUyhVTklYKSAmJiAhT1MoTUFDX09TX1gpKQorI2VsaWYgUExBVEZPUk0oR1RLKSAmJiBP UyhVTklYKSAmJiAhT1MoTUFDX09TX1gpCiAjZGVmaW5lIFBMVUdJTl9BUkNISVRFQ1RVUkVfWDEx IDEKICNlbHNlCiAjZGVmaW5lIFBMVUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQT1JURUQgMQo= 112867 2011-10-28 08:17:12 -0700 2011-11-07 14:51:38 -0800 Patch bug-70023-20111028171710.patch text/plain 3598 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTg3MjgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAzNGM0ODQ0MDExNWZiNTFk MWNhZDM1YmQwODYyY2ExYTQxMzFlMTZhLi5kZjBhNzEwM2RkYTA2YTJkNmYzOTQyMGQ5ZDNiN2Vi NWM2NmM2NjNkIDEwMDc1NQotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMTAtMjggIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIERpc2FibGUgWDExIHBsdWdpbnMgd2l0aCBRdDUuCisgICAg ICAgICogZmVhdHVyZXMucHJpOgorCiAyMDExLTEwLTI4ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRt YW5AZ29vZ2xlLmNvbT4KIAogICAgICAgICBSZXNldCBsaW5lIG51bWJlcnMgZm9yIHNjcmlwdHMg Z2VuZXJhdGVkIHdpdGggZG9jdW1lbnQud3JpdGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNjM2ZTBjNGRkNTMx MzViNjU3Zjk5OTJjMWQ2ZWRjMjM3NzM5NDk4Mi4uOWY4ZTAxMDA4MGY1NDdjY2NiYWZmYzFhYjJj ODIwZDI3ZTgzNWY0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDExLTEwLTI4ICBC YWxhenMgS2VsZW1lbiAgPGtiYWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBw bHVnaW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNhYmxlIFgxMSBwbHVnaW5zLgorICAgICAgICAq IGNvbmZpZy5oOgorCiAyMDExLTEwLTI4ICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdlYmtp dC5vcmc+CiAKICAgICAgICAgW1F0XSBBZGFwdCB0byBRU0cqIHRvIFFRdWljayogQVBJIGNoYW5n ZSBpbiBxdGRlY2xhcmF0aXZlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9mZWF0dXJlcy5w cmkgYi9Tb3VyY2UvV2ViQ29yZS9mZWF0dXJlcy5wcmkKaW5kZXggYzg5M2U1ZmQ5ZTUyYmZlYTcz OGEwNjVhNjA3YmEyZTJjN2Y3MTI2My4uOWZkNjc1OWM0MzJlZTRhOWI0YTYzNDQwZGU2N2UyZWNl NWM0N2U2OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZmVhdHVyZXMucHJpCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2ZlYXR1cmVzLnByaQpAQCAtODcsNyArODcsNyBAQCBpc0VtcHR5KEhBVkVf UVJBV0ZPTlQpIHsKIAogIyBOZXNjYXBlIHBsdWdpbnMgc3VwcG9ydCAoTlBBUEkpCiAhY29udGFp bnMoREVGSU5FUywgRU5BQkxFX05FVFNDQVBFX1BMVUdJTl9BUEk9LikgewotICAgIHVuaXh8d2lu MzItKjohZW1iZWRkZWQ6IXdpbmNlKjogeworICAgIHVuaXg6IXF0NXx3aW4zMi0qOiFlbWJlZGRl ZDohd2luY2UqOiB7CiAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBFX1BMVUdJTl9B UEk9MQogICAgIH0gZWxzZSB7CiAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBFX1BM VUdJTl9BUEk9MApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvY29uZmlnLmggYi9Tb3VyY2Uv V2ViS2l0Mi9jb25maWcuaAppbmRleCAyMDlhODk3NzQ1Mjk0YTdiNTQzZmQ1YmU1NmUxNjYyMzQ1 OGZhMjdiLi5lYjNiZGFhM2Q3ZDE3ZDIyN2IwZDAxNDUyMWZhM2NlYmM2MWRmY2VmIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9jb25maWcuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9jb25maWcu aApAQCAtMTU3LDcgKzE1Nyw3IEBAIHN0YXRpYyBjb25zdCB0eXBlJiBuYW1lKCkgXAogI2RlZmlu ZSBQTFVHSU5fQVJDSElURUNUVVJFX01BQyAxCiAjZWxpZiBQTEFURk9STShXSU4pCiAjZGVmaW5l IFBMVUdJTl9BUkNISVRFQ1RVUkVfV0lOIDEKLSNlbGlmIChQTEFURk9STShRVCkgfHwgKFBMQVRG T1JNKEdUSykpKSAmJiAoT1MoVU5JWCkgJiYgIU9TKE1BQ19PU19YKSkKKyNlbGlmIFBMQVRGT1JN KEdUSykgJiYgKE9TKFVOSVgpICYmICFPUyhNQUNfT1NfWCkpCiAjZGVmaW5lIFBMVUdJTl9BUkNI SVRFQ1RVUkVfWDExIDEKICNlbHNlCiAjZGVmaW5lIFBMVUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQ T1JURUQgMQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCmluZGV4IDFiYzI4NzZiMzQxZDJiMzM3N2IwNzQ4Y2M0OTVlMGNkMzNlYTUwYzcu LjQ1YjVhY2IxOWNmMWU0MmViNGMyNDBjNDdkODM2ZTI2ODExZGUwMzAgMTAwNzU1Ci0tLSBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxMyBAQAorMjAxMS0xMC0yOCAgQmFsYXpzIEtlbGVtZW4gIDxrYmFsYXpzQHdlYmtpdC5vcmc+ CisKKyAgICAgICAgW1F0XSBYMTEgcGx1Z2lucyBuZWVkIHRvIGJlIHJld29ya2VkIGZvciBRdDUK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcwMDIzCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRGlzYWJsZSBw bHVnaW4gdGVzdHMgd2l0aCBRdDUuCisgICAgICAgICogcGxhdGZvcm0vcXQtNS4wL1NraXBwZWQ6 CisKIDIwMTEtMTAtMjggIFZzZXZvbG9kIFZsYXNvdiAgPHZzZXZpa0BjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgVW5yZXZpZXdlZCwgc2tpcGVkIGZhaWxpbmcgdGVzdCBpbnNwZWN0b3IvZGVidWdn ZXIvc2VsZWN0ZWQtY2FsbC1mcmFtZS1hZnRlci1mb3JtYXR0aW5nLXNvdXJjZS5odG1sLgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtNS4wL1NraXBwZWQgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9xdC01LjAvU2tpcHBlZAppbmRleCAyZmZkYjY0MmY4YWVlMDViMmVmOWYwODBl ODE2OGY2ZWIxMGE3ZTRjLi5lYTA1MTI5MmVlYzBhZjk1Njk0YmM1Yzc0OTMyNzA5NjQ0MWRmOTBl IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC01LjAvU2tpcHBlZAorKysgYi9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC01LjAvU2tpcHBlZApAQCAtMSwzICsxLDcgQEAKKyMgW1F0 XSBQbHVnaW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorIyBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKK3BsdWdpbnMKKwogIyBGYWlsaW5nIHRlc3Rz IGFmdGVyIHJlZmFjdG9yZWQgUXQ1CiBhbmltYXRpb25zLzNkL2NoYW5nZS10cmFuc2Zvcm0taW4t ZW5kLWV2ZW50Lmh0bWwKIGFuaW1hdGlvbnMvM2Qvc3RhdGUtYXQtZW5kLWV2ZW50LXRyYW5zZm9y bS5odG1sCg== 113932 2011-11-07 14:51:45 -0800 2011-11-08 07:34:43 -0800 wk2 plugins bug-70023-20111107235143.patch text/plain 25423 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTk0MDAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2ZDEyMTUyMGUzNWUyODdi ZDBhNTdiYmNmNjA5ZDA0M2EwYWM1ZTVjLi5jYzkxZjBlZTk5YWFlZDliMGM1YTBhNjBjMDA0ODNk N2RhMTUxN2NiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMTEtMDcgIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIgYmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4g YSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVkIGEgYnJpZGdlIGJldHdlZW4gUXQgYW5k IFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50 IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBpbWFn ZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAgZnJvbSBpdC4KKworICAgICAgICAqIGJy aWRnZS9ucHJ1bnRpbWVfaW50ZXJuYWwuaDogQWRkZWQgeWV0IGFub3RoZXIgdW5kZWYKKyAgICAg ICAgdG8gZml4IGJ1aWxkIHdpdGggUXQ1ICsgWDExIGhlYWRlcnMuCisKIDIwMTEtMTEtMDYgIE5v ZWwgR29yZG9uICA8bm9lbC5nb3Jkb25AZ21haWwuY29tPgogCiAgICAgICAgIEZpeCBzb21lIHN0 eWxlIGlzc3VlcyBpbiBJbWFnZUJ1ZmZlci5oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYmQ5N2QxZWYyOTdkZDAx MmJlMWM4YzU4YzRlNzEyMzcxNWRmZTM2Ny4uNTUwYTYwYzRiY2EyY2JiZDhiNmU2MGY2NjRjYThj NWZmYzdjMTdjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ5IEBACisyMDExLTExLTA3ICBCYWxh enMgS2VsZW1lbiAgPGtiYWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBwbHVn aW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBSZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBwb3J0IGlu IGEgd2F5IHRoYXQgZG9lcworICAgICAgICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVuIFF0IGFu ZCBYMTEuIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250 ZW50IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBp bWFnZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UgZnJvbSBpdC4KKworICAgICAgICAqIFRhcmdldC5w cmk6CisgICAgICAgICogVUlQcm9jZXNzL1BsdWdpbnMvdW5peC9QbHVnaW5JbmZvU3RvcmVVbml4 LmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2luSW5mb1N0b3JlOjpwbHVnaW5zRGlyZWN0b3Jp ZXMpOgorICAgICAgICBLaWxsIHRoZSBsYXN0IGRlcGVuZGVuY3kgZnJvbSB0aGUgV2ViS2l0MSBw bHVnaW4gc3lzdGVtLgorICAgICAgICBUaGlzIGlzIG5lY2Vzc2FyeSBiZWNhdXNlIHdlIGRvbid0 IGJ1aWxkIHRoZSBXZWJLaXQxIHBsdWdpbgorICAgICAgICBjb2RlLiBUaGUgZnVuY3Rpb24gaXMg ZXF1aXZhbGVudCB3aXRoIHRoZSBYUF9VTklYIHBhcnQgb2YKKyAgICAgICAgUGx1Z2luRGF0YWJh c2U6OmRlZmF1bHRQbHVnaW5EaXJlY3Rvcmllcy4KKworICAgICAgICAqIFdlYlByb2Nlc3MvUGx1 Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHA6CisgICAgICAgIChXZWJLaXQ6 Ok5QTl9HZXRWYWx1ZSk6CisgICAgICAgICogV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05l dHNjYXBlUGx1Z2luLmg6CisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUv cXQvUXRQbHVnaW5IZWxwZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6cWltYWdlRnJv bVhJbWFnZSk6CisgICAgICAgIEFkZGVkIGEgaGVscGVyIGZ1bmN0aW9uIHRvIGNyZWF0ZSBhIFFJ bWFnZSBmcm9tIGFuIFhJbWFnZS4KKyAgICAgICAgUHV0IGl0IGluIGEgbmV3IGZpbGUgdG8gYXZv aWQgY29weXJpZ2h0IGlzc3VlcyBhcyB0aGlzIGNvZGUKKyAgICAgICAgaGFzIGJlZW4gdGFrZW4g ZGlyZWN0bHkgZnJvbSBRdC4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUv cXQvUXRQbHVnaW5IZWxwZXIuaDogQWRkZWQuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdp bnMvTmV0c2NhcGUveDExL05ldHNjYXBlUGx1Z2luWDExLmNwcDoKKyAgICAgICAgUmV3b3JrIHBs dWdpbiBpbml0aWFsaXphdGlvbiBhbmQgZHJhd2luZyBtb2RlbC4KKyAgICAgICAgKFdlYktpdDo6 Z2V0UGx1Z2luRGlzcGxheSk6CisgICAgICAgIChXZWJLaXQ6OngxMURpc3BsYXkpOgorICAgICAg ICAoV2ViS2l0Ojp4MTFTY3JlZW4pOgorICAgICAgICAoV2ViS2l0OjpkaXNwbGF5RGVwdGgpOgor ICAgICAgICAoV2ViS2l0Ojpyb290V2luZG93SUQpOgorICAgICAgICAoV2ViS2l0OjpOZXRzY2Fw ZVBsdWdpbjo6cGxhdGZvcm1Qb3N0SW5pdGlhbGl6ZSk6CisgICAgICAgIE1pc3NlZCBzb21lIGNo ZWNrIGFib3V0IHRoZSBleHBlY3RlZCBjb25kaXRpb25zLgorICAgICAgICBBZGRpbmcgdGhvc2Ug Zm9yIHNhZmV0aW5lc3MuCisgICAgICAgIChXZWJLaXQ6Ok5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9y bVBhaW50KToKKworICAgICAgICAqIGNvbmZpZy5oOiBFbmFibGUgcGx1Z2lucyBmb3IgUXQuIE5v dGUgdGhhdCBpdCBvbmx5IHRha2VzCisgICAgICAgIGFmZmVjdCBpZiBQTFVHSU5fQVJDSElURUNU VVJFX1VOU09QUE9SVEVEIGlzIG5vdCBkZWZpbmVkLgorCiAyMDExLTExLTAzICBBbmRlcnMgQ2Fy bHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIE5ldHNjYXBlUGx1Z2lu Ojpjb252ZXJ0RnJvbVJvb3RWaWV3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9icmlkZ2Uv bnBydW50aW1lX2ludGVybmFsLmggYi9Tb3VyY2UvV2ViQ29yZS9icmlkZ2UvbnBydW50aW1lX2lu dGVybmFsLmgKaW5kZXggMmQ3ZGMwNjI2MTdmMTg1YWIxYzE2MzkwNjQwYTEwYjE4N2E0MDQ3OS4u NjIzYzQ3NTliY2MwZjliODEwZDU0MDU5YjY2NWFlMTFhMWViYmI0MCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvYnJpZGdlL25wcnVudGltZV9pbnRlcm5hbC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2JyaWRnZS9ucHJ1bnRpbWVfaW50ZXJuYWwuaApAQCAtNTEsNCArNTEsNSBAQAogICAgICN1 bmRlZiBUcnVlCiAgICAgI3VuZGVmIEZhbHNlCiAgICAgI3VuZGVmIFN1Y2Nlc3MKKyAgICAjdW5k ZWYgRXhwb3NlCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkg Yi9Tb3VyY2UvV2ViS2l0Mi9UYXJnZXQucHJpCmluZGV4IDJlZGI4ZjRmNmJhOWQ2NTc0YTAwNTkz MzZjYWJkNTc3OTZhNzg1MjUuLmYyMmFjNWYwNzk3N2E4MzRlODcyYmY4Y2JkNTJjOTBkODFjMWI5 ZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dl YktpdDIvVGFyZ2V0LnByaQpAQCAtMzA4LDYgKzMwOCw3IEBAIEhFQURFUlMgKz0gXAogICAgIFdl YlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHAgXAogICAg IFdlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZVBsdWdpbi5oIFwKICAgICBXZWJQ cm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW5TdHJlYW0uaCBcCisgICAgV2Vi UHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL3F0L1F0UGx1Z2luSGVscGVyLmggXAogICAgIFdlYlBy b2Nlc3MvUGx1Z2lucy9QbHVnaW4uaCBcCiAgICAgV2ViUHJvY2Vzcy9QbHVnaW5zL1BsdWdpbkNv bnRyb2xsZXIuaCBcCiAgICAgV2ViUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblZpZXcuaCBcCkBAIC01 NjcsNiArNTY4LDcgQEAgU09VUkNFUyArPSBcCiAgICAgV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNj YXBlL05ldHNjYXBlUGx1Z2luU3RyZWFtLmNwcCBcCiAgICAgV2ViUHJvY2Vzcy9QbHVnaW5zL05l dHNjYXBlL3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAgXAogICAgIFdlYlByb2Nlc3MvUGx1Z2lu cy9OZXRzY2FwZS9xdC9QbHVnaW5Qcm94eVF0LmNwcCBcCisgICAgV2ViUHJvY2Vzcy9QbHVnaW5z L05ldHNjYXBlL3F0L1F0UGx1Z2luSGVscGVyLmNwcCBcCiAgICAgV2ViUHJvY2Vzcy9QbHVnaW5z L1BsdWdpbi5jcHAgXAogICAgIFdlYlByb2Nlc3MvUGx1Z2lucy9QbHVnaW5WaWV3LmNwcCBcCiAg ICAgV2ViUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblByb3h5LmNwcCBcCkBAIC02MTgsMTMgKzYyMCwx MyBAQCBTT1VSQ0VTICs9IFwKICAgICAkJFdFQktJVDJfR0VORVJBVEVEX1NPVVJDRVMgXAogICAg ICQkV0VCS0lUMV9TT1VSQ0VTX1NIQVJFRF9XSVRIX1dFQktJVDIKIAotY29udGFpbnMoREVGSU5F UywgRU5BQkxFX05FVFNDQVBFX1BMVUdJTl9BUEk9MCkgewotICAgIERFRklORVMgKz0gUExVR0lO X0FSQ0hJVEVDVFVSRV9VTlNVUFBPUlRFRAotfQotCiBjb250YWlucyhERUZJTkVTLCBFTkFCTEVf VE9VQ0hfRVZFTlRTPTEpIHsKICAgICBIRUFERVJTICs9IFwKICAgICAgICAgU2hhcmVkL05hdGl2 ZVdlYlRvdWNoRXZlbnQuaAogICAgIFNPVVJDRVMgKz0gXAogICAgICAgICBTaGFyZWQvcXQvTmF0 aXZlV2ViVG91Y2hFdmVudFF0LmNwcAogfQorCitwbHVnaW5zX3gxMSB7CisgICAgREVGSU5FUyAr PSBYUF9VTklYCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lu cy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L1BsdWdpbnMvdW5peC9QbHVnaW5JbmZvU3RvcmVVbml4LmNwcAppbmRleCA4NWRjOGQ4MTI1Nzg5 MjE4YzQ5MmI2MzU3ODFiYzY5MGQ3MmMyNjQwLi5jYWVjZjc5NDI0ZTJlYzZlZmJlMjBiNzAzOTAy NjE0NzZmMzA3NDcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lu cy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9QbHVnaW5zL3VuaXgvUGx1Z2luSW5mb1N0b3JlVW5peC5jcHAKQEAgLTMwLDYgKzMwLDcg QEAKIAogI2luY2x1ZGUgIk5ldHNjYXBlUGx1Z2luTW9kdWxlLmgiCiAjaW5jbHVkZSAiUGx1Z2lu RGF0YWJhc2UuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KIAogdXNpbmcgbmFt ZXNwYWNlIFdlYkNvcmU7CiAKQEAgLTM3LDcgKzM4LDQxIEBAIG5hbWVzcGFjZSBXZWJLaXQgewog CiBWZWN0b3I8U3RyaW5nPiBQbHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNEaXJlY3RvcmllcygpCiB7 Ci0gICAgcmV0dXJuIFBsdWdpbkRhdGFiYXNlOjpkZWZhdWx0UGx1Z2luRGlyZWN0b3JpZXMoKTsK KyAgICBWZWN0b3I8U3RyaW5nPiByZXN1bHQ7CisKKyAgICByZXN1bHQuYXBwZW5kKGhvbWVEaXJl Y3RvcnlQYXRoKCkgKyAiLy5tb3ppbGxhL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKGhv bWVEaXJlY3RvcnlQYXRoKCkgKyAiLy5uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFw cGVuZCgiL3Vzci9saWIvYnJvd3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vz ci9sb2NhbC9saWIvbW96aWxsYS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9s aWIvZmlyZWZveC9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9icm93 c2VyLXBsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9icm93c2VyLXBsdWdp bnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9tb3ppbGxhL3BsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xvY2FsL25ldHNjYXBlL3BsdWdpbnMiKTsKKyAgICByZXN1 bHQuYXBwZW5kKCIvb3B0L21vemlsbGEvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9v cHQvbW96aWxsYS9saWIvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2Nh cGUvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2NhcGUvY29tbXVuaWNh dG9yL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9uZXRzY2FwZS9wbHVn aW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvbmV0c2NhcGUvcGx1Z2lucy1saWJj NSIpOworICAgIHJlc3VsdC5hcHBlbmQoIi91c3IvbGliL25ldHNjYXBlL3BsdWdpbnMtbGliYzYi KTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYjY0L25ldHNjYXBlL3BsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYjY0L21vemlsbGEvcGx1Z2lucyIpOworICAgIHJlc3Vs dC5hcHBlbmQoIi91c3IvbGliL25zYnJvd3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVu ZCgiL3Vzci9saWI2NC9uc2Jyb3dzZXIvcGx1Z2lucyIpOworCisgICAgU3RyaW5nIG1vemlsbGFI b21lKGdldGVudigiTU9aSUxMQV9IT01FIikpOworICAgIGlmICghbW96aWxsYUhvbWUuaXNFbXB0 eSgpKQorICAgICAgICByZXN1bHQuYXBwZW5kKG1vemlsbGFIb21lICsgIi9wbHVnaW5zIik7CisK KyAgICBTdHJpbmcgbW96aWxsYVBhdGhzKGdldGVudigiTU9aX1BMVUdJTl9QQVRIIikpOworICAg IGlmICghbW96aWxsYVBhdGhzLmlzRW1wdHkoKSkgeworICAgICAgICBWZWN0b3I8U3RyaW5nPiBw YXRoczsKKyAgICAgICAgbW96aWxsYVBhdGhzLnNwbGl0KFVDaGFyKCc6JyksIC8qIGFsbG93RW1w dHlFbnRyaWVzICovIGZhbHNlLCBwYXRocyk7CisgICAgICAgIHJlc3VsdC5hcHBlbmQocGF0aHMp OworICAgIH0KKworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIFZlY3RvcjxTdHJpbmc+IFBsdWdp bkluZm9TdG9yZTo6cGx1Z2luUGF0aHNJbkRpcmVjdG9yeShjb25zdCBTdHJpbmcmIGRpcmVjdG9y eSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2Fw ZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1Bs dWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVCcm93c2VyRnVuY3MuY3BwCmluZGV4IDFlYzQzMzEzYWZk MmQyODk2M2Y0ZTNmNjQ2ZjdkMDg2MWUwZTZlZDcuLmViOTJhMGRhM2YyODk2YzA2YmFmMzNkNjBm OWZmM2I3ZTBjMjE1YWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1 Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHAKKysrIGIvU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlQnJvd3NlckZ1bmNzLmNwcApA QCAtMzYsMTMgKzM2LDkgQEAKICNpbmNsdWRlIDxXZWJDb3JlL1NoYXJlZEJ1ZmZlci5oPgogI2lu Y2x1ZGUgPHV0aWxpdHk+CiAKLSNpZiBQTFVHSU5fQVJDSElURUNUVVJFKFgxMSkKLSNpZiBQTEFU Rk9STShRVCkKLSNpbmNsdWRlIDxRWDExSW5mbz4KLSNlbGlmIFBMQVRGT1JNKEdUSykKKyNpZiBQ TFVHSU5fQVJDSElURUNUVVJFKFgxMSkgJiYgUExBVEZPUk0oR1RLKQogI2luY2x1ZGUgPGdkay9n ZGt4Lmg+CiAjZW5kaWYKLSNlbmRpZgogCiB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIHVzaW5n IG5hbWVzcGFjZSBzdGQ7CkBAIC01MjgsNyArNTI0LDcgQEAgc3RhdGljIE5QRXJyb3IgTlBOX0dl dFZhbHVlKE5QUCBucHAsIE5QTlZhcmlhYmxlIHZhcmlhYmxlLCB2b2lkICp2YWx1ZSkKICAgICAg ICAgICAgaWYgKCFucHApCiAgICAgICAgICAgICAgICByZXR1cm4gTlBFUlJfR0VORVJJQ19FUlJP UjsKICNpZiBQTEFURk9STShRVCkKLSAgICAgICAgICAgKnJlaW50ZXJwcmV0X2Nhc3Q8RGlzcGxh eSoqPih2YWx1ZSkgPSBRWDExSW5mbzo6ZGlzcGxheSgpOworICAgICAgICAgICAqcmVpbnRlcnBy ZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVlKSA9IE5ldHNjYXBlUGx1Z2luOjpzX2Zha2VEaXNwbGF5 Rm9yUGx1Z2luczsKICAgICAgICAgICAgYnJlYWs7CiAjZWxpZiBQTEFURk9STShHVEspCiAgICAg ICAgICAgICpyZWludGVycHJldF9jYXN0PERpc3BsYXkqKj4odmFsdWUpID0gR0RLX0RJU1BMQVlf WERJU1BMQVkoZ2RrX2Rpc3BsYXlfZ2V0X2RlZmF1bHQoKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4uaCBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZVBsdWdpbi5o CmluZGV4IGVjMDVjMTUxMWEyMDQ2N2Q1ZTczN2E3YzE1Y2U3OTcwMzkyOGVlNDguLmRhOTljODlm MTI4Njg3MzhiODI4ZTRkN2Y1ZTVmNTM4ZDI1MmI4ZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZVBsdWdpbi5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZVBsdWdpbi5o CkBAIC0zMzcsNiArMzM3LDExIEBAIHByaXZhdGU6CiAjZWxpZiBQTFVHSU5fQVJDSElURUNUVVJF KFgxMSkKICAgICBQaXhtYXAgbV9kcmF3YWJsZTsKICAgICBEaXNwbGF5KiBtX3BsdWdpbkRpc3Bs YXk7CisjaWYgUExBVEZPUk0oUVQpCisgICAgLy8gTmVlZCB0byBnZXQgaXQgaW4gdGhlIE5QTl9H ZXRWYWx1ZSBicm93c2VyIGNhbGxiYWNrLgorcHVibGljOgorICAgIHN0YXRpYyBEaXNwbGF5KiBz X2Zha2VEaXNwbGF5Rm9yUGx1Z2luczsKKyNlbmRpZgogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvcXQvUXRQbHVnaW5I ZWxwZXIuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL3F0 L1F0UGx1Z2luSGVscGVyLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45MmE0MDA3NjAyMGM0YTEwYjk2NDJmYTdh YmFjY2MzMjYxNTFhOTE3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9QbHVnaW5zL05ldHNjYXBlL3F0L1F0UGx1Z2luSGVscGVyLmNwcApAQCAtMCwwICsxLDg1 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBp dHMgc3Vic2lkaWFyeSgtaWVzKS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIFVzYWdlCisgKiBUaGlzIGZpbGUgbWF5IGJl IHVzZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIHZlcnNpb24gMi4xIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uIGFuZAorICogYXBwZWFyaW5nIGluIHRoZSBmaWxlIExJQ0VOU0UuTEdQTCBpbmNs dWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRoaXMKKyAqIGZpbGUuIFBsZWFzZSByZXZpZXcgdGhl IGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBlbnN1cmUgdGhlIEdOVSBMZXNzZXIKKyAqIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyLjEgcmVxdWlyZW1lbnRzIHdpbGwgYmUgbWV0Ogor ICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL29sZC1saWNlbnNlcy9sZ3BsLTIuMS5odG1s LgorICoKKyAqIEluIGFkZGl0aW9uLCBhcyBhIHNwZWNpYWwgZXhjZXB0aW9uLCBOb2tpYSBnaXZl cyB5b3UgY2VydGFpbiBhZGRpdGlvbmFsCisgKiByaWdodHMuIFRoZXNlIHJpZ2h0cyBhcmUgZGVz Y3JpYmVkIGluIHRoZSBOb2tpYSBRdCBMR1BMIEV4Y2VwdGlvbgorICogdmVyc2lvbiAxLjEsIGlu Y2x1ZGVkIGluIHRoZSBmaWxlIExHUExfRVhDRVBUSU9OLnR4dCBpbiB0aGlzIHBhY2thZ2UuCisg KgorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgVXNhZ2UKKyAqIEFsdGVybmF0aXZlbHks IHRoaXMgZmlsZSBtYXkgYmUgdXNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFs CisgKiBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDMuMCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbgorICogYW5kIGFwcGVhcmluZyBpbiB0aGUgZmlsZSBMSUNFTlNF LkdQTCBpbmNsdWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRoaXMKKyAqIGZpbGUuIFBsZWFzZSBy ZXZpZXcgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBlbnN1cmUgdGhlIEdOVSBHZW5lcmFs CisgKiBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDMuMCByZXF1aXJlbWVudHMgd2lsbCBiZSBtZXQ6 CisgKiBodHRwOi8vd3d3LmdudS5vcmcvY29weWxlZnQvZ3BsLmh0bWwuCisgKgorICogTm90ZTog VGhlIGZ1bmN0aW9uIHFpbWFnZUZyb21YSW1hZ2UgaGFzIGJlZW4gdGFrZW4gZnJvbSB0aGUgUXQg VG9vbGtpdC4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lmIFBMVUdJTl9BUkNI SVRFQ1RVUkUoWDExKQorCisjaW5jbHVkZSAiUXRQbHVnaW5IZWxwZXIuaCIKKworbmFtZXNwYWNl IFdlYktpdCB7CisKK1FJbWFnZSBxaW1hZ2VGcm9tWEltYWdlKFhJbWFnZSAqeGkpCit7CisgICAg UUltYWdlOjpGb3JtYXQgZm9ybWF0ID0gUUltYWdlOjpGb3JtYXRfQVJHQjMyX1ByZW11bHRpcGxp ZWQ7CisgICAgaWYgKHhpLT5kZXB0aCA9PSAyNCkKKyAgICAgICAgZm9ybWF0ID0gUUltYWdlOjpG b3JtYXRfUkdCMzI7CisgICAgZWxzZSBpZiAoeGktPmRlcHRoID09IDE2KQorICAgICAgICBmb3Jt YXQgPSBRSW1hZ2U6OkZvcm1hdF9SR0IxNjsKKworICAgIFFJbWFnZSBpbWFnZSA9IFFJbWFnZSgo dWNoYXIgKil4aS0+ZGF0YSwgeGktPndpZHRoLCB4aS0+aGVpZ2h0LCB4aS0+Ynl0ZXNfcGVyX2xp bmUsIGZvcm1hdCkuY29weSgpOworCisgICAgLy8gd2UgbWF5IGhhdmUgdG8gc3dhcCB0aGUgYnl0 ZSBvcmRlcgorICAgIGlmICgoUVN5c0luZm86OkJ5dGVPcmRlciA9PSBRU3lzSW5mbzo6TGl0dGxl RW5kaWFuICYmIHhpLT5ieXRlX29yZGVyID09IE1TQkZpcnN0KQorICAgICAgICB8fCAoUVN5c0lu Zm86OkJ5dGVPcmRlciA9PSBRU3lzSW5mbzo6QmlnRW5kaWFuICYmIHhpLT5ieXRlX29yZGVyID09 IExTQkZpcnN0KSkKKyAgICB7CisgICAgICAgIGZvciAoaW50IGk9MDsgaSA8IGltYWdlLmhlaWdo dCgpOyBpKyspIHsKKyAgICAgICAgICAgIGlmICh4aS0+ZGVwdGggPT0gMTYpIHsKKyAgICAgICAg ICAgICAgICB1c2hvcnQgKnAgPSAodXNob3J0KilpbWFnZS5zY2FuTGluZShpKTsKKyAgICAgICAg ICAgICAgICB1c2hvcnQgKmVuZCA9IHAgKyBpbWFnZS53aWR0aCgpOworICAgICAgICAgICAgICAg IHdoaWxlIChwIDwgZW5kKSB7CisgICAgICAgICAgICAgICAgICAgICpwID0gKCgqcCA8PCA4KSAm IDB4ZmYwMCkgfCAoKCpwID4+IDgpICYgMHgwMGZmKTsKKyAgICAgICAgICAgICAgICAgICAgcCsr OworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAg ICAgdWludCAqcCA9ICh1aW50KilpbWFnZS5zY2FuTGluZShpKTsKKyAgICAgICAgICAgICAgICB1 aW50ICplbmQgPSBwICsgaW1hZ2Uud2lkdGgoKTsKKyAgICAgICAgICAgICAgICB3aGlsZSAocCA8 IGVuZCkgeworICAgICAgICAgICAgICAgICAgICAqcCA9ICgoKnAgPDwgMjQpICYgMHhmZjAwMDAw MCkgfCAoKCpwIDw8IDgpICYgMHgwMGZmMDAwMCkKKyAgICAgICAgICAgICAgICAgICAgICAgICB8 ICgoKnAgPj4gOCkgJiAweDAwMDBmZjAwKSB8ICgoKnAgPj4gMjQpICYgMHgwMDAwMDBmZik7Cisg ICAgICAgICAgICAgICAgICAgIHArKzsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICB9CisKKyAgICAvLyBmaXgtdXAgYWxwaGEgY2hhbm5lbAorICAgIGlm IChmb3JtYXQgPT0gUUltYWdlOjpGb3JtYXRfUkdCMzIpIHsKKyAgICAgICAgUVJnYiAqcCA9IChR UmdiICopaW1hZ2UuYml0cygpOworICAgICAgICBmb3IgKGludCB5ID0gMDsgeSA8IHhpLT5oZWln aHQ7ICsreSkgeworICAgICAgICAgICAgZm9yIChpbnQgeCA9IDA7IHggPCB4aS0+d2lkdGg7ICsr eCkKKyAgICAgICAgICAgICAgICBwW3hdIHw9IDB4ZmYwMDAwMDA7CisgICAgICAgICAgICBwICs9 IHhpLT5ieXRlc19wZXJfbGluZSAvIDQ7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4g aW1hZ2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gUExVR0lOX0FS Q0hJVEVDVFVSRShYMTEpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1Bs dWdpbnMvTmV0c2NhcGUvcXQvUXRQbHVnaW5IZWxwZXIuaCBiL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9xdC9RdFBsdWdpbkhlbHBlci5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdh NzdkZDFkNjZlYjRjZjFkNDM5MzBlMTdlNGUxMjQwM2QyNjEwNDcKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvcXQvUXRQbHVnaW5I ZWxwZXIuaApAQCAtMCwwICsxLDQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIE5va2lh IENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKS4KKyAqIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIFVzYWdl CisgKiBUaGlzIGZpbGUgbWF5IGJlIHVzZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIHZlcnNpb24gMi4xIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uIGFuZAorICogYXBwZWFyaW5nIGluIHRoZSBm aWxlIExJQ0VOU0UuTEdQTCBpbmNsdWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRoaXMKKyAqIGZp bGUuIFBsZWFzZSByZXZpZXcgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBlbnN1cmUgdGhl IEdOVSBMZXNzZXIKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyLjEgcmVxdWly ZW1lbnRzIHdpbGwgYmUgbWV0OgorICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL29sZC1s aWNlbnNlcy9sZ3BsLTIuMS5odG1sLgorICoKKyAqIEluIGFkZGl0aW9uLCBhcyBhIHNwZWNpYWwg ZXhjZXB0aW9uLCBOb2tpYSBnaXZlcyB5b3UgY2VydGFpbiBhZGRpdGlvbmFsCisgKiByaWdodHMu IFRoZXNlIHJpZ2h0cyBhcmUgZGVzY3JpYmVkIGluIHRoZSBOb2tpYSBRdCBMR1BMIEV4Y2VwdGlv bgorICogdmVyc2lvbiAxLjEsIGluY2x1ZGVkIGluIHRoZSBmaWxlIExHUExfRVhDRVBUSU9OLnR4 dCBpbiB0aGlzIHBhY2thZ2UuCisgKgorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgVXNh Z2UKKyAqIEFsdGVybmF0aXZlbHksIHRoaXMgZmlsZSBtYXkgYmUgdXNlZCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBHZW5lcmFsCisgKiBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDMuMCBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICogYW5kIGFwcGVhcmlu ZyBpbiB0aGUgZmlsZSBMSUNFTlNFLkdQTCBpbmNsdWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRo aXMKKyAqIGZpbGUuIFBsZWFzZSByZXZpZXcgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBl bnN1cmUgdGhlIEdOVSBHZW5lcmFsCisgKiBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDMuMCByZXF1 aXJlbWVudHMgd2lsbCBiZSBtZXQ6CisgKiBodHRwOi8vd3d3LmdudS5vcmcvY29weWxlZnQvZ3Bs Lmh0bWwuCisgKgorICovCisKKyNpZm5kZWYgUXRQbHVnaW5IZWxwZXJfaAorI2RlZmluZSBRdFBs dWdpbkhlbHBlcl9oCisKKyNpZiBQTFVHSU5fQVJDSElURUNUVVJFKFgxMSkKKworI2luY2x1ZGUg PFFJbWFnZT4KKyNpbmNsdWRlIDxXZWJDb3JlL25wcnVudGltZV9pbnRlcm5hbC5oPgorCituYW1l c3BhY2UgV2ViS2l0IHsKKworUUltYWdlIHFpbWFnZUZyb21YSW1hZ2UoWEltYWdlKik7CisKK30K KworI2VuZGlmIC8vIFBMVUdJTl9BUkNISVRFQ1RVUkUoWDExKQorCisjZW5kaWYKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2Nh cGVQbHVnaW5YMTEuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNj YXBlL3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKaW5kZXggZWVlOGE0MTE3OTQ3MjFlYTAwMDhj NTk0ZWJjNjJiYzQ2MDAwN2Q1Ny4uNDU2OWIxM2VlMzFmMmJlMDdiOGQ5ODQ4MTdiMjFlZTg3Y2Y3 OWU2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNj YXBlL3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9QbHVnaW5zL05ldHNjYXBlL3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKQEAgLTM0LDEw ICszNCw3IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9Ob3RJbXBsZW1lbnRlZC5oPgogCiAjaWYgUExB VEZPUk0oUVQpCi0jaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgotI2luY2x1ZGUgPFFEZXNrdG9wV2lk Z2V0PgotI2luY2x1ZGUgPFFQaXhtYXA+Ci0jaW5jbHVkZSA8UVgxMUluZm8+CisjaW5jbHVkZSAi UGx1Z2lucy9OZXRzY2FwZS9xdC9RdFBsdWdpbkhlbHBlci5oIgogI2VsaWYgUExBVEZPUk0oR1RL KQogI2luY2x1ZGUgIlBsYXRmb3JtQ29udGV4dENhaXJvLmgiCiAjaW5jbHVkZSAiUmVmUHRyQ2Fp cm8uaCIKQEAgLTUwLDcgKzQ3LDExIEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCiBuYW1l c3BhY2UgV2ViS2l0IHsKIAotc3RhdGljIERpc3BsYXkgKmdldFBsdWdpbkRpc3BsYXkoKQorI2lm IFBMQVRGT1JNKFFUKQorRGlzcGxheSogTmV0c2NhcGVQbHVnaW46OnNfZmFrZURpc3BsYXlGb3JQ bHVnaW5zID0gMDsKKyNlbmRpZgorCitzdGF0aWMgRGlzcGxheSogZ2V0UGx1Z2luRGlzcGxheSgp CiB7CiAjaWYgUExBVEZPUk0oUVQpCiAgICAgLy8gQXQgdGhlIG1vbWVudCwgd2Ugb25seSBzdXBw b3J0IGdkayBiYXNlZCBwbHVnaW5zIChsaWtlIEZsYXNoKSB0aGF0IHVzZSBhIGRpZmZlcmVudCBY IGNvbm5lY3Rpb24uCkBAIC05MCw3ICs5MSwxMiBAQCBzdGF0aWMgRGlzcGxheSAqZ2V0UGx1Z2lu RGlzcGxheSgpCiBzdGF0aWMgaW5saW5lIERpc3BsYXkqIHgxMURpc3BsYXkoKQogewogI2lmIFBM QVRGT1JNKFFUKQotICAgIHJldHVybiBRWDExSW5mbzo6ZGlzcGxheSgpOworICAgIHN0YXRpYyBi b29sIG9wZW5lZCA9IGZhbHNlOworICAgIGlmICghb3BlbmVkKSB7CisgICAgICAgIE5ldHNjYXBl UGx1Z2luOjpzX2Zha2VEaXNwbGF5Rm9yUGx1Z2lucyA9IFhPcGVuRGlzcGxheSgwKTsKKyAgICAg ICAgb3BlbmVkID0gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJuIE5ldHNjYXBlUGx1Z2luOjpzX2Zh a2VEaXNwbGF5Rm9yUGx1Z2luczsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAgICByZXR1cm4gR0RL X0RJU1BMQVlfWERJU1BMQVkoZ2RrX2Rpc3BsYXlfZ2V0X2RlZmF1bHQoKSk7CiAjZWxzZQpAQCAt OTgsMzQgKzEwNCwzNCBAQCBzdGF0aWMgaW5saW5lIERpc3BsYXkqIHgxMURpc3BsYXkoKQogI2Vu ZGlmCiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IGRpc3BsYXlEZXB0aCgpCitzdGF0aWMgaW5saW5l IGludCB4MTFTY3JlZW4oKQogewogI2lmIFBMQVRGT1JNKFFUKQotICAgIHJldHVybiBRQXBwbGlj YXRpb246OmRlc2t0b3AoKS0+eDExSW5mbygpLmRlcHRoKCk7CisgICAgcmV0dXJuIFhEZWZhdWx0 U2NyZWVuKHgxMURpc3BsYXkoKSk7CiAjZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0dXJuIGdk a192aXN1YWxfZ2V0X2RlcHRoKGdka19zY3JlZW5fZ2V0X3N5c3RlbV92aXN1YWwoZ2RrX3NjcmVl bl9nZXRfZGVmYXVsdCgpKSk7CisgICAgcmV0dXJuIGdka19zY3JlZW5fZ2V0X251bWJlcihnZGtf c2NyZWVuX2dldF9kZWZhdWx0KCkpOwogI2Vsc2UKICAgICByZXR1cm4gMDsKICNlbmRpZgogfQog Ci1zdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgcm9vdFdpbmRvd0lEKCkKK3N0YXRpYyBpbmxp bmUgaW50IGRpc3BsYXlEZXB0aCgpCiB7CiAjaWYgUExBVEZPUk0oUVQpCi0gICAgcmV0dXJuIFFY MTFJbmZvOjphcHBSb290V2luZG93KCk7CisgICAgcmV0dXJuIFhEZWZhdWx0RGVwdGgoeDExRGlz cGxheSgpLCB4MTFTY3JlZW4oKSk7CiAjZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0dXJuIEdE S19ST09UX1dJTkRPVygpOworICAgIHJldHVybiBnZGtfdmlzdWFsX2dldF9kZXB0aChnZGtfc2Ny ZWVuX2dldF9zeXN0ZW1fdmlzdWFsKGdka19zY3JlZW5fZ2V0X2RlZmF1bHQoKSkpOwogI2Vsc2UK ICAgICByZXR1cm4gMDsKICNlbmRpZgogfQogCi1zdGF0aWMgaW5saW5lIGludCB4MTFTY3JlZW4o KQorc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHJvb3RXaW5kb3dJRCgpCiB7CiAjaWYgUExB VEZPUk0oUVQpCi0gICAgcmV0dXJuIFFYMTFJbmZvOjphcHBTY3JlZW4oKTsKKyAgICByZXR1cm4g WERlZmF1bHRSb290V2luZG93KHgxMURpc3BsYXkoKSk7CiAjZWxpZiBQTEFURk9STShHVEspCi0g ICAgcmV0dXJuIGdka19zY3JlZW5fZ2V0X251bWJlcihnZGtfc2NyZWVuX2dldF9kZWZhdWx0KCkp OworICAgIHJldHVybiBHREtfUk9PVF9XSU5ET1coKTsKICNlbHNlCiAgICAgcmV0dXJuIDA7CiAj ZW5kaWYKQEAgLTE1OCw3ICsxNjQsMTUgQEAgYm9vbCBOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1Q b3N0SW5pdGlhbGl6ZSgpCiAgICAgTlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdCogY2FsbGJhY2tT dHJ1Y3QgPSBuZXcgTlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdDsKICAgICBjYWxsYmFja1N0cnVj dC0+dHlwZSA9IDA7CiAgICAgRGlzcGxheSogZGlzcGxheSA9IHgxMURpc3BsYXkoKTsKKyAgICBp ZiAoIWRpc3BsYXkpCisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBpbnQgZGVwdGggPSBkaXNw bGF5RGVwdGgoKTsKKworI2lmIFBMQVRGT1JNKFFUKQorICAgIGlmIChkZXB0aCAhPSAxNiAmJiBk ZXB0aCAhPSAyNCAmJiBkZXB0aCAhPSAzMikKKyAgICAgICAgcmV0dXJuIGZhbHNlOworI2VuZGlm CisKICAgICBjYWxsYmFja1N0cnVjdC0+ZGlzcGxheSA9IGRpc3BsYXk7CiAgICAgY2FsbGJhY2tT dHJ1Y3QtPmRlcHRoID0gZGVwdGg7CiAKQEAgLTE2OSw3ICsxODMsOCBAQCBib29sIE5ldHNjYXBl UGx1Z2luOjpwbGF0Zm9ybVBvc3RJbml0aWFsaXplKCkKICAgICBpbnQgbnVtTWF0Y2hpbmc7CiAg ICAgWFZpc3VhbEluZm8qIHZpc3VhbEluZm8gPSBYR2V0VmlzdWFsSW5mbyhkaXNwbGF5LCBWaXN1 YWxTY3JlZW5NYXNrIHwgVmlzdWFsRGVwdGhNYXNrIHwgVmlzdWFsQ2xhc3NNYXNrLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnZpc3VhbFRlbXBsYXRlLCAm bnVtTWF0Y2hpbmcpOwotICAgIEFTU0VSVCh2aXN1YWxJbmZvKTsKKyAgICBpZiAoIXZpc3VhbElu Zm8pCisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBWaXN1YWwqIHZpc3VhbCA9IHZpc3VhbElu Zm9bMF0udmlzdWFsOwogICAgIEFTU0VSVCh2aXN1YWwpOwogICAgIFhGcmVlKHZpc3VhbEluZm8p OwpAQCAtMjQzLDEyICsyNTgsNiBAQCB2b2lkIE5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9ybVBhaW50 KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgZGlydAogICAgIGlmIChj b250ZXh0LT5wYWludGluZ0Rpc2FibGVkKCkgfHwgIW1fZHJhd2FibGUpCiAgICAgICAgIHJldHVy bjsKIAotI2lmIFBMQVRGT1JNKFFUKQotI2VsaWYgIVBMQVRGT1JNKEdUSykKLSAgICBub3RJbXBs ZW1lbnRlZCgpOwotICAgIHJldHVybjsKLSNlbmRpZgotCiAgICAgWEV2ZW50IHhldmVudDsKICAg ICBtZW1zZXQoJnhldmVudCwgMCwgc2l6ZW9mKFhFdmVudCkpOwogICAgIFhHcmFwaGljc0V4cG9z ZUV2ZW50JiBleHBvc2VFdmVudCA9IHhldmVudC54Z3JhcGhpY3NleHBvc2U7CkBAIC0yNzEsMTAg KzI4MCwxMiBAQCB2b2lkIE5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9ybVBhaW50KEdyYXBoaWNzQ29u dGV4dCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgZGlydAogICAgICAgICBYU3luYyhtX3BsdWdp bkRpc3BsYXksIGZhbHNlKTsKIAogI2lmIFBMQVRGT1JNKFFUKQotICAgIFFQaXhtYXAgcXREcmF3 YWJsZSA9IFFQaXhtYXA6OmZyb21YMTFQaXhtYXAobV9kcmF3YWJsZSwgUVBpeG1hcDo6RXhwbGlj aXRseVNoYXJlZCk7Ci0gICAgQVNTRVJUKHF0RHJhd2FibGUuZGVwdGgoKSA9PSBzdGF0aWNfY2Fz dDxOUFNldFdpbmRvd0NhbGxiYWNrU3RydWN0Kj4obV9ucFdpbmRvdy53c19pbmZvKS0+ZGVwdGgp OworICAgIFhJbWFnZSogeEltYWdlID0gWEdldEltYWdlKHgxMURpc3BsYXkoKSwgbV9kcmF3YWJs ZSwgZXhwb3NlZFJlY3QueCgpLCBleHBvc2VkUmVjdC55KCksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZXhwb3NlZFJlY3Qud2lkdGgoKSwgZXhwb3NlZFJlY3QuaGVpZ2h0KCksIFVM T05HX01BWCwgWlBpeG1hcCk7CisgICAgUUltYWdlIGltYWdlID0gcWltYWdlRnJvbVhJbWFnZSh4 SW1hZ2UpOworCiAgICAgUVBhaW50ZXIqIHBhaW50ZXIgPSBjb250ZXh0LT5wbGF0Zm9ybUNvbnRl eHQoKTsKLSAgICBwYWludGVyLT5kcmF3UGl4bWFwKFFQb2ludChleHBvc2VkUmVjdC54KCksIGV4 cG9zZWRSZWN0LnkoKSksIHF0RHJhd2FibGUsIGV4cG9zZWRSZWN0KTsKKyAgICBwYWludGVyLT5k cmF3SW1hZ2UoUVBvaW50KGV4cG9zZWRSZWN0LngoKSwgZXhwb3NlZFJlY3QueSgpKSwgaW1hZ2Us IGV4cG9zZWRSZWN0KTsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAgICBSZWZQdHI8Y2Fpcm9fc3Vy ZmFjZV90PiBkcmF3YWJsZVN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb194bGliX3N1cmZhY2VfY3Jl YXRlKG1fcGx1Z2luRGlzcGxheSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fZHJhd2FibGUs CkBAIC0yOTIsNiArMzAzLDggQEAgdm9pZCBOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1QYWludChH cmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIGRpcnQKICAgICBjYWlyb19w YWludChjcik7CiAKICAgICBjYWlyb19yZXN0b3JlKGNyKTsKKyNlbHNlCisgICAgbm90SW1wbGVt ZW50ZWQoKTsKICNlbmRpZgogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9jb25maWcu aCBiL1NvdXJjZS9XZWJLaXQyL2NvbmZpZy5oCmluZGV4IGViM2JkYWEzZDdkMTdkMjI3YjBkMDE0 NTIxZmEzY2ViYzYxZGZjZWYuLjVlZTkzNDQ0ZjM0NmNiYTFkNWJjMjc0M2I5M2I1ODc5ZjcxMWJl ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL2NvbmZpZy5oCisrKyBiL1NvdXJjZS9XZWJL aXQyL2NvbmZpZy5oCkBAIC0xNTcsNyArMTU3LDcgQEAgc3RhdGljIGNvbnN0IHR5cGUmIG5hbWUo KSBcCiAjZGVmaW5lIFBMVUdJTl9BUkNISVRFQ1RVUkVfTUFDIDEKICNlbGlmIFBMQVRGT1JNKFdJ TikKICNkZWZpbmUgUExVR0lOX0FSQ0hJVEVDVFVSRV9XSU4gMQotI2VsaWYgUExBVEZPUk0oR1RL KSAmJiAoT1MoVU5JWCkgJiYgIU9TKE1BQ19PU19YKSkKKyNlbGlmIChQTEFURk9STShRVCkgfHwg UExBVEZPUk0oR1RLKSkgJiYgKE9TKFVOSVgpICYmICFPUyhNQUNfT1NfWCkpCiAjZGVmaW5lIFBM VUdJTl9BUkNISVRFQ1RVUkVfWDExIDEKICNlbHNlCiAjZGVmaW5lIFBMVUdJTl9BUkNISVRFQ1RV UkVfVU5TVVBQT1JURUQgMQpkaWZmIC0tZ2l0IGEvU291cmNlL2FwaS5wcmkgYi9Tb3VyY2UvYXBp LnByaQppbmRleCA4YzYwMDU5YjUxNWVhOTJmMmUyNTFhZGM5ZDQ4ZDAyZmNlNTU3ZjFlLi41YjM2 ZmFlZjY3ZjRhNzYyYjIwOGZkNzc5MDMwODI3MDgxNzNjYmExIDEwMDY0NAotLS0gYS9Tb3VyY2Uv YXBpLnByaQorKysgYi9Tb3VyY2UvYXBpLnByaQpAQCAtMjQxLDMgKzI0MSw3IEBAIG1hYyB7CiAg ICAgUU1BS0VfTEZMQUdTX1NPTkFNRSA9ICIkJHtRTUFLRV9MRkxBR1NfU09OQU1FfSQke0RFU1RE SVJ9JCR7UU1BS0VfRElSX1NFUH0iCiB9CiAKK3BsdWdpbnNfeDExIHsKKyAgICBDT05GSUcgKj0g bGlua19wa2djb25maWcKKyAgICBQS0dDT05GSUcgKz0geDExCit9CmRpZmYgLS1naXQgYS9Ub29s cy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNGY2YTEwYWQ0MmUxYTQ1ZWE3Nzc1 YWY0ZjhmNDBlY2NjMzc0MzI4Mi4uNmM3OGRhMzVlYjU3YTc0MWRjMDIyNGQ3M2EyOGY5NDg2ZGY1 NDAzNCAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDIwIEBACisyMDExLTExLTA3ICBCYWxhenMgS2VsZW1lbiAgPGtiYWxhenNAd2Vi a2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBwbHVnaW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQg Zm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBS ZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBwb3J0IGluIGEgd2F5IHRoYXQgZG9lcworICAgICAg ICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVuIFF0IGFuZCBYLiBUaGUgc29sdXRpb24gaXMKKyAg ICAgICAgYmFzZWQgb24gZ2V0dGluZyB0aGUgY29udGVudCBkcmF3ZWQgYnkgdGhlIHBsdWdpbgor ICAgICAgICBmcm9tIHRoZSBzZXJ2ZXIgYXMgYW4gaW1hZ2UgYW5kIGNyZWF0aW5nIGEgUUltYWdl CisgICAgICAgIGZyb20gaXQuCisKKyAgICAgICAgKiBxbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2Zl YXR1cmVzLnByZjogQ29uZmlnIHBsdWdpbiBzdXBwb3J0CisgICAgICAgIGluIGEgd2hpdGUgbGlz dCBtYW5uZXI6IG9ubHkgYWxsb3cgKG5vdCBkaXNhbGxvdykgaXQgd2l0aCB0aGUKKyAgICAgICAg eGNiLXhsaWIgYmFja2VuZC4KKwogMjAxMS0xMS0wNiAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8b3Nz eUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtRdF0gVW5yZXZpZXdlZCB0cml2aWFsIGZpeCBhZnRl ciBidWlsZCBzeXN0ZW0gcmVmYWN0b3JpbmcuCmRpZmYgLS1naXQgYS9Ub29scy9xbWFrZS9ta3Nw ZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnByZiBiL1Rvb2xzL3FtYWtlL21rc3BlY3MvZmVhdHVyZXMv ZmVhdHVyZXMucHJmCmluZGV4IDlhM2QwZmFmYWYyMmI3NGYyOTAxYzJlYWJmMGEwOWZiZTgxMmRi MWEuLjUxODNhN2VlODkxODdjOWE4NzdlNmUxMDU1NzU4MjIzYzkyNGQwODMgMTAwNjQ0Ci0tLSBh L1Rvb2xzL3FtYWtlL21rc3BlY3MvZmVhdHVyZXMvZmVhdHVyZXMucHJmCisrKyBiL1Rvb2xzL3Ft YWtlL21rc3BlY3MvZmVhdHVyZXMvZmVhdHVyZXMucHJmCkBAIC04OSwxMyArODksMjYgQEAgaXNF bXB0eShIQVZFX1FSQVdGT05UKSB7CiAKICMgTmVzY2FwZSBwbHVnaW5zIHN1cHBvcnQgKE5QQVBJ KQogIWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5fQVBJPS4pIHsKLSAg ICB1bml4OiFoYXZlUXQoNSl8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNlKjogewotICAgICAgICBE RUZJTkVTICs9IEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5fQVBJPTEKKyAgICAhaGF2ZVF0KDUpOiB7 CisgICAgICAgIHVuaXh8d2luMzItKjohZW1iZWRkZWQ6IXdpbmNlKjogeworICAgICAgICAgICAg REVGSU5FUyArPSBFTkFCTEVfTkVUU0NBUEVfUExVR0lOX0FQST0xCisgICAgICAgIH0gZWxzZSB7 CisgICAgICAgICAgICBERUZJTkVTICs9IEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5fQVBJPTAKKyAg ICAgICAgfQogICAgIH0gZWxzZSB7CiAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBF X1BMVUdJTl9BUEk9MAogICAgIH0KIH0KIAorIyBOZXRzY2FwZSBwbHVnaW5zIHN1cHBvcnQgZm9y IFdlYktpdDIKKyFub193ZWJraXQyOiFjb250YWlucyhERUZJTkVTLCBQTFVHSU5fQVJDSElURUNU VVJFX1VOU09QUE9SVEVEKTogeworICAgIGNvbnRhaW5zKFFUX0NPTkZJRywgeGNiLXhsaWIpIHsK KyAgICAgICAgQ09ORklHICs9IHBsdWdpbnNfeDExCisgICAgfSBlbHNlIHsKKyAgICAgICAgREVG SU5FUyArPSBQTFVHSU5fQVJDSElURUNUVVJFX1VOU09QUE9SVEVECisgICAgfQorfQorCiAjIFdl YkdMIHN1cHBvcnQKIGNvbnRhaW5zKFFUX0NPTkZJRywgb3BlbmdsKTohd2luMzItKiB7CiAgICAg IWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9XRUJHTD0uKTogREVGSU5FUyArPSBFTkFCTEVfV0VC R0w9MQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IDYzNjE5NTU3ODEwMzE4Y2MxODc4YWU4YmQ2MjYzOTU1N2I4YzVjMTQuLmNj ZTgxYTcwM2U4MzY2NmJkNmM1YmE2N2Q3N2Y2YTE1ZWQ2NTViN2IgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy MSBAQAorMjAxMS0xMS0wNyAgQmFsYXpzIEtlbGVtZW4gIDxrYmFsYXpzQHdlYmtpdC5vcmc+CisK KyAgICAgICAgW1F0XSBYMTEgcGx1Z2lucyBuZWVkIHRvIGJlIHJld29ya2VkIGZvciBRdDUKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcwMDIzCisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmV3b3JrIG91ciBi YXNpYyBwbHVnaW4gc3VwcG9ydCBpbiBhIHdheSB0aGF0IGRvZXMKKyAgICAgICAgbm90IG5lZWQg YSBicmlkZ2UgYmV0d2VlbiBRdCBhbmQgWC4gVGhlIHNvbHV0aW9uIGlzCisgICAgICAgIGJhc2Vk IG9uIGdldHRpbmcgdGhlIGNvbnRlbnQgZHJhd2VkIGJ5IHRoZSBwbHVnaW4KKyAgICAgICAgZnJv bSB0aGUgc2VydmVyIGFzIGFuIGltYWdlIGFuZCBjcmVhdGluZyBhIFFJbWFnZQorICAgICAgICBm cm9tIGl0LgorCisgICAgICAgIEVuYWJsZSBwbHVnaW4gdGVzdHMgZm9yIFF0LVdlYktpdDIuCisK KyAgICAgICAgKiBwbGF0Zm9ybS9xdC01LjAvU2tpcHBlZDoKKyAgICAgICAgKiBwbGF0Zm9ybS9x dC13azEvU2tpcHBlZDoKKwogMjAxMS0xMS0wNyAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5k QGlnYWxpYS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgdW5raXAgYSB3b3JraW5nIHRlc3Qg YW5kIHJlY2xhc3NpZnkgdGhlIHdoZWVsZXZlbnQgbWlzc2luZyBEUlQgZmVhdHVyZXMuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC01LjAvU2tpcHBlZCBiL0xheW91dFRlc3Rz L3BsYXRmb3JtL3F0LTUuMC9Ta2lwcGVkCmluZGV4IGQwZGE3NDViZWMyM2ZjMDc1MmVjMDNkMzA1 Y2UxM2ViZmQ4ZTZlMTEuLmRjZTJhYWFjZjZmNTViMTYzNDQ0NjQ0MGExYmI4MGQ1YzFlYWJmNzkg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LTUuMC9Ta2lwcGVkCisrKyBiL0xh eW91dFRlc3RzL3BsYXRmb3JtL3F0LTUuMC9Ta2lwcGVkCkBAIC0xLDcgKzEsMyBAQAotIyBbUXRd IFBsdWdpbnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1Ci0jIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMwotcGx1Z2lucwotCiAjIEZhaWxpbmcgdGVzdHMg YWZ0ZXIgcmVmYWN0b3JlZCBRdDUKIGFuaW1hdGlvbnMvM2QvY2hhbmdlLXRyYW5zZm9ybS1pbi1l bmQtZXZlbnQuaHRtbAogYW5pbWF0aW9ucy8zZC9zdGF0ZS1hdC1lbmQtZXZlbnQtdHJhbnNmb3Jt Lmh0bWwKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMS9Ta2lwcGVkIGIv TGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2sxL1NraXBwZWQKaW5kZXggMmZhNDk3NWM1YjE4YmY2 YWI0MDZlODgwZTljYTljZGFmZDA0ZTVkZS4uMTc5YmVkMGZlOTQwNDNhNTY4M2U3NGI5Njc5NWI5 ZDU2YzAzYzViYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2sxL1NraXBw ZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2sxL1NraXBwZWQKQEAgLTEgKzEsNSBA QAogIyBUZXN0cyBmYWlsaW5nIG9uIFdLMSBvbmx5ICh3b3JraW5nIG9uIFdLMikKKworIyBbUXRd IFBsdWdpbnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisjIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworcGx1Z2lucwpkaWZmIC0tZ2l0IGEvQ2hhbmdl TG9nIGIvQ2hhbmdlTG9nCmluZGV4IDM1MDRkMTM2ZTE1MGNhZmViMzJlOTY1NzY4OWU0ZmU2YWI5 ZjFjMmUuLjM1NWVhMGUwZGUxODhkYzUwNDI5ZGQ5YTI5N2Q4MTdhMmJmMzI2MzAgMTAwNjQ0Ci0t LSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMS0xMS0w NyAgQmFsYXpzIEtlbGVtZW4gIDxrYmFsYXpzQHdlYmtpdC5vcmc+CisKKyAgICAgICAgW1F0XSBY MTEgcGx1Z2lucyBuZWVkIHRvIGJlIHJld29ya2VkIGZvciBRdDUKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcwMDIzCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmV3b3JrIG91ciBiYXNpYyBwbHVnaW4gc3Vw cG9ydCBpbiBhIHdheSB0aGF0IGRvZXMKKyAgICAgICAgbm90IG5lZWQgYSBicmlkZ2UgYmV0d2Vl biBRdCBhbmQgWC4gVGhlIHNvbHV0aW9uIGlzCisgICAgICAgIGJhc2VkIG9uIGdldHRpbmcgdGhl IGNvbnRlbnQgZHJhd2VkIGJ5IHRoZSBwbHVnaW4KKyAgICAgICAgZnJvbSB0aGUgc2VydmVyIGFz IGFuIGltYWdlIGFuZCBjcmVhdGluZyBhIFFJbWFnZQorICAgICAgICBmcm9tIGl0LgorCisgICAg ICAgICogU291cmNlL2FwaS5wcmk6IExpbmsgdG8geGxpYiBpZiBYMTEgcGx1Z2lucyBhcmUKKyAg ICAgICAgZW5hYmxlZC4KKwogMjAxMS0xMS0wNCAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5k QGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10gRGlzYWJsZSBWSURFT19UUkFDSyBmb3Igbm93 Cg== 114061 2011-11-08 07:34:51 -0800 2011-11-08 08:15:51 -0800 wk2 plugins v2 bug-70023-20111108163449.patch text/plain 22393 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTk1NTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyOWViNmRkNmRlYjA5Nzgz NmU2NTFkNjllYTE2YmY1MWEyOWI1MGQ0Li4xOTE5NjY1ODAyNGEzYjhhNWM4NmQ2MjNjM2I1YjNk MzZiYjA1MDZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTEtMTEtMDggIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIgYmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4g YSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVkIGEgYnJpZGdlIGJldHdlZW4gUXQgYW5k IFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50 IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBpbWFn ZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAgZnJvbSBpdC4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIEV4aXN0aW5nIHBsdWdpbiB0ZXN0IGFyZSBzdWZmaWNpZW50LgorCisgICAgICAg ICogVGFyZ2V0LnByaToKKyAgICAgICAgKiBicmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmg6IEFk ZGVkIHlldCBhbm90aGVyIHVuZGVmCisgICAgICAgIHRvIGZpeCBidWlsZCB3aXRoIFF0NSArIFgx MSBoZWFkZXJzLgorICAgICAgICAqIHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OnFpbWFnZUZyb21YSW1hZ2UpOgorICAgICAgICAq IHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaDogQWRkZWQuCisgICAgICAgIEFkZGVk IGEgaGVscGVyIGZ1bmN0aW9uIHRvIGNyZWF0ZSBhIFFJbWFnZSBmcm9tIGFuIFhJbWFnZS4KKyAg ICAgICAgUHV0IGl0IGluIGEgbmV3IGZpbGUgdG8gYXZvaWQgY29weXJpZ2h0IGlzc3VlcyBhcyB0 aGlzIGNvZGUKKyAgICAgICAgaGFzIGJlZW4gdGFrZW4gZGlyZWN0bHkgZnJvbSBRdC4gQWRkaW5n IHRoaXMgdG8gV2ViQ29yZSB0bworICAgICAgICBiZSBhYmxlIHRvIHJldXNlIGZvciB0aGUgV0sx IHBsdWdpbiBzdXBwb3J0IGluIHRoZSBmdXR1cmUuCisKIDIwMTEtMTEtMDggIEFuZHJleSBLb3N5 YWtvdiAgPGNhc2VxQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBkbyBu b3Qgc2hvdyBvYmplY3QgcG9wb3ZlciB3aGVuIHNlbGVjdGlvbiBpcyBhY3RpdmUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpp bmRleCA1YjRiYzdmM2ExNDI5MmFmM2JiYjQ2NGU5N2EzN2Y1YWZjMzViNzIxLi4zMzZlODYwNjc5 NTFlOTE3OTE5ZmFhOGE5MGQ1OTYxNDA3YTdhNzc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQg QEAKKzIwMTEtMTEtMDggIEJhbGF6cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisg ICAgICAgIFtRdF0gWDExIHBsdWdpbnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGFyZ2V0LnByaToK KyAgICAgICAgKiBVSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3Bw OgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNEaXJlY3Rvcmllcyk6 CisgICAgICAgIEtpbGwgdGhlIGxhc3QgZGVwZW5kZW5jeSBmcm9tIHRoZSBXZWJLaXQxIHBsdWdp biBzeXN0ZW0uCisgICAgICAgIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2UgY3VycmVudGx5IHdl IGRvbid0IGJ1aWxkIHRoZSBXZWJLaXQxCisgICAgICAgIHBsdWdpbiBjb2RlLiBUaGUgZnVuY3Rp b24gaXMgZXF1aXZhbGVudCB3aXRoIHRoZSBYUF9VTklYIHBhcnQgb2YKKyAgICAgICAgUGx1Z2lu RGF0YWJhc2U6OmRlZmF1bHRQbHVnaW5EaXJlY3Rvcmllcy4KKyAgICAgICAgCisgICAgICAgICog V2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlQnJvd3NlckZ1bmNzLmNwcDoKKyAg ICAgICAgKFdlYktpdDo6TlBOX0dldFZhbHVlKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdp bnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4uaDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdp bnMvTmV0c2NhcGUveDExL05ldHNjYXBlUGx1Z2luWDExLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 Z2V0UGx1Z2luRGlzcGxheSk6CisgICAgICAgIChXZWJLaXQ6OngxMVNjcmVlbik6CisgICAgICAg IChXZWJLaXQ6OmRpc3BsYXlEZXB0aCk6CisgICAgICAgIChXZWJLaXQ6OnJvb3RXaW5kb3dJRCk6 CisgICAgICAgIChXZWJLaXQ6Ok5ldHNjYXBlUGx1Z2luOjpwbHVnaW5EaXNwbGF5KToKKyAgICAg ICAgKFdlYktpdDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUpOgorICAg ICAgICAoV2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1EZXN0cm95KToKKyAgICAgICAg KFdlYktpdDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtR2VvbWV0cnlEaWRDaGFuZ2UpOgorICAg ICAgICAoV2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1QYWludCk6CisgICAgICAgIChX ZWJLaXQ6OmluaXRpYWxpemVYRXZlbnQpOgorICAgICAgICBSZXdvcmsgcGx1Z2luIGluaXRpYWxp emF0aW9uIGFuZCBkcmF3aW5nIG1vZGVsLgorCiAyMDExLTExLTA4ICBLZW5uZXRoIFJvaGRlIENo cmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBbUXRdIEltcHJvdmUg dGhlIGFuaW1hdGlvbiB0aW1lIGNvbnN0YW50CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9U YXJnZXQucHJpIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCAwMzZmOWU5Yjk1MDVj YmVjNjRiYzJjZmU5NTg0MWRmZjRmM2VkYzI0Li41NjdmOTQxM2Q3NTUzMGZjOWM5ZTY3NWRjNTc2 YWRiM2RhM2M3N2FlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisrKyBi L1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKQEAgLTI4NjIsNiArMjg2MiwxMSBAQCBjb250YWlu cyhERUZJTkVTLCBFTkFCTEVfTkVUU0NBUEVfUExVR0lOX0FQST0xKSB7CiAgICAgICAgIHBsdWdp bnMvUGx1Z2luVmlld05vbmUuY3BwCiB9CiAKK3BsdWdpbl9iYWNrZW5kX3hsaWIgeworICAgIFNP VVJDRVMgKz0gcGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lvbi5jcHAKKyAgICBIRUFERVJT ICs9IHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaAorfQorCiBjb250YWlucyhERUZJ TkVTLCBFTkFCTEVfU1FMX0RBVEFCQVNFPTEpIHsKICAgICBTT1VSQ0VTICs9IFwKICAgICAgICAg c3RvcmFnZS9DaGFuZ2VWZXJzaW9uV3JhcHBlci5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYnJpZGdlL25wcnVudGltZV9pbnRlcm5hbC5oIGIvU291cmNlL1dlYkNvcmUvYnJpZGdl L25wcnVudGltZV9pbnRlcm5hbC5oCmluZGV4IDJkN2RjMDYyNjE3ZjE4NWFiMWMxNjM5MDY0MGEx MGIxODdhNDA0NzkuLjYyM2M0NzU5YmNjMGY5YjgxMGQ1NDA1OWI2NjVhZTExYTFlYmJiNDAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JyaWRnZS9ucHJ1bnRpbWVfaW50ZXJuYWwuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9icmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmgKQEAgLTUxLDQgKzUx LDUgQEAKICAgICAjdW5kZWYgVHJ1ZQogICAgICN1bmRlZiBGYWxzZQogICAgICN1bmRlZiBTdWNj ZXNzCisgICAgI3VuZGVmIEV4cG9zZQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJzaW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs dWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM1NGZiYjQwNDQ2 ZDAyMzNhM2I1ZmMxZDBlZTk1OWQ0NzgwYzUzMmUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJzaW9uLmNwcApAQCAtMCwwICsxLDY5 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBp dHMgc3Vic2lkaWFyeSgtaWVzKS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIFVzYWdlCisgKiBUaGlzIGZpbGUgbWF5IGJl IHVzZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIHZlcnNpb24gMi4xIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uIGFuZAorICogYXBwZWFyaW5nIGluIHRoZSBmaWxlIExJQ0VOU0UuTEdQTCBpbmNs dWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRoaXMKKyAqIGZpbGUuIFBsZWFzZSByZXZpZXcgdGhl IGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBlbnN1cmUgdGhlIEdOVSBMZXNzZXIKKyAqIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyLjEgcmVxdWlyZW1lbnRzIHdpbGwgYmUgbWV0Ogor ICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL29sZC1saWNlbnNlcy9sZ3BsLTIuMS5odG1s LgorICoKKyAqIE5vdGU6IFRoZSBmdW5jdGlvbiBxaW1hZ2VGcm9tWEltYWdlIGhhcyBiZWVuIHRh a2VuIGZyb20gUXQuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJR dFgxMUltYWdlQ29udmVyc2lvbi5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1FJbWFnZSBx aW1hZ2VGcm9tWEltYWdlKFhJbWFnZSogeGkpCit7CisgICAgUUltYWdlOjpGb3JtYXQgZm9ybWF0 ID0gUUltYWdlOjpGb3JtYXRfQVJHQjMyX1ByZW11bHRpcGxpZWQ7CisgICAgaWYgKHhpLT5kZXB0 aCA9PSAyNCkKKyAgICAgICAgZm9ybWF0ID0gUUltYWdlOjpGb3JtYXRfUkdCMzI7CisgICAgZWxz ZSBpZiAoeGktPmRlcHRoID09IDE2KQorICAgICAgICBmb3JtYXQgPSBRSW1hZ2U6OkZvcm1hdF9S R0IxNjsKKworICAgIFFJbWFnZSBpbWFnZSA9IFFJbWFnZShyZWludGVycHJldF9jYXN0PHVjaGFy Kj4oeGktPmRhdGEpLCB4aS0+d2lkdGgsIHhpLT5oZWlnaHQsIHhpLT5ieXRlc19wZXJfbGluZSwg Zm9ybWF0KS5jb3B5KCk7CisKKyAgICAvLyB3ZSBtYXkgaGF2ZSB0byBzd2FwIHRoZSBieXRlIG9y ZGVyCisgICAgaWYgKChRU3lzSW5mbzo6Qnl0ZU9yZGVyID09IFFTeXNJbmZvOjpMaXR0bGVFbmRp YW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTVNCRmlyc3QpCisgICAgICAgIHx8IChRU3lzSW5mbzo6 Qnl0ZU9yZGVyID09IFFTeXNJbmZvOjpCaWdFbmRpYW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTFNC Rmlyc3QpKSB7CisKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBpbWFnZS5oZWlnaHQoKTsg aSsrKSB7CisgICAgICAgICAgICBpZiAoeGktPmRlcHRoID09IDE2KSB7CisgICAgICAgICAgICAg ICAgdXNob3J0ICogcCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dXNob3J0Kj4oaW1hZ2Uuc2NhbkxpbmUo aSkpOworICAgICAgICAgICAgICAgIHVzaG9ydCogZW5kID0gcCArIGltYWdlLndpZHRoKCk7Cisg ICAgICAgICAgICAgICAgd2hpbGUgKHAgPCBlbmQpIHsKKyAgICAgICAgICAgICAgICAgICAgKnAg PSAoKCpwIDw8IDgpICYgMHhmZjAwKSB8ICgoKnAgPj4gOCkgJiAweDAwZmYpOworICAgICAgICAg ICAgICAgICAgICBwKys7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgICAgICB1aW50KiBwID0gcmVpbnRlcnByZXRfY2FzdDx1aW50Kj4oaW1hZ2Uu c2NhbkxpbmUoaSkpOworICAgICAgICAgICAgICAgIHVpbnQqIGVuZCA9IHAgKyBpbWFnZS53aWR0 aCgpOworICAgICAgICAgICAgICAgIHdoaWxlIChwIDwgZW5kKSB7CisgICAgICAgICAgICAgICAg ICAgICpwID0gKCgqcCA8PCAyNCkgJiAweGZmMDAwMDAwKSB8ICgoKnAgPDwgOCkgJiAweDAwZmYw MDAwKQorICAgICAgICAgICAgICAgICAgICAgICAgIHwgKCgqcCA+PiA4KSAmIDB4MDAwMGZmMDAp IHwgKCgqcCA+PiAyNCkgJiAweDAwMDAwMGZmKTsKKyAgICAgICAgICAgICAgICAgICAgcCsrOwor ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKworICAg IC8vIGZpeC11cCBhbHBoYSBjaGFubmVsCisgICAgaWYgKGZvcm1hdCA9PSBRSW1hZ2U6OkZvcm1h dF9SR0IzMikgeworICAgICAgICBRUmdiKiBwID0gcmVpbnRlcnByZXRfY2FzdDxRUmdiKj4oaW1h Z2UuYml0cygpKTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCB4aS0+aGVpZ2h0OyArK3kp IHsKKyAgICAgICAgICAgIGZvciAoaW50IHggPSAwOyB4IDwgeGktPndpZHRoOyArK3gpCisgICAg ICAgICAgICAgICAgcFt4XSB8PSAweGZmMDAwMDAwOworICAgICAgICAgICAgcCArPSB4aS0+Ynl0 ZXNfcGVyX2xpbmUgLyA0OworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIGltYWdlOwor fQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs dWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaCBiL1NvdXJjZS9XZWJDb3JlL3BsdWdpbnMv cXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZGNiYTRiMzM1YmEyODQ3N2Y2 ZGIyYmM1NWY0NzE2N2Q0Mjk1Mzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lvbi5oCkBAIC0wLDAgKzEsMjcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRp YXJ5KC1pZXMpLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBHTlUgTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgVXNhZ2UKKyAqIFRoaXMgZmlsZSBtYXkgYmUgdXNlZCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug dmVyc2lvbiAyLjEgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24g YW5kCisgKiBhcHBlYXJpbmcgaW4gdGhlIGZpbGUgTElDRU5TRS5MR1BMIGluY2x1ZGVkIGluIHRo ZSBwYWNrYWdpbmcgb2YgdGhpcworICogZmlsZS4gUGxlYXNlIHJldmlldyB0aGUgZm9sbG93aW5n IGluZm9ybWF0aW9uIHRvIGVuc3VyZSB0aGUgR05VIExlc3NlcgorICogR2VuZXJhbCBQdWJsaWMg TGljZW5zZSB2ZXJzaW9uIDIuMSByZXF1aXJlbWVudHMgd2lsbCBiZSBtZXQ6CisgKiBodHRwOi8v d3d3LmdudS5vcmcvbGljZW5zZXMvb2xkLWxpY2Vuc2VzL2xncGwtMi4xLmh0bWwuCisgKgorICov CisKKyNpZm5kZWYgUXRYMTFJbWFnZUNvbnZlcnNpb25faAorI2RlZmluZSBRdFgxMUltYWdlQ29u dmVyc2lvbl9oCisKKyNpbmNsdWRlIDxRSW1hZ2U+CisjaW5jbHVkZSA8WDExL1hsaWIuaD4KKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitRSW1hZ2UgcWltYWdlRnJvbVhJbWFnZShYSW1hZ2UqKTsK KworfQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkgYi9T b3VyY2UvV2ViS2l0Mi9UYXJnZXQucHJpCmluZGV4IDMzYjhhNGQ3NTZhZWJjOGEyYjM5NWNjNjZh ZGIwODI2YWIzMjViNmYuLjM1ODc2MjliODJiNzY2OGY1NmUyMGEwOGJlOGJmZmQ1MTc4MGYxZDYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dlYktp dDIvVGFyZ2V0LnByaQpAQCAtNjExLDEzICs2MTEsMTMgQEAgU09VUkNFUyArPSBcCiAgICAgJCRX RUJLSVQyX0dFTkVSQVRFRF9TT1VSQ0VTIFwKICAgICAkJFdFQktJVDFfU09VUkNFU19TSEFSRURf V0lUSF9XRUJLSVQyCiAKLWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5f QVBJPTApIHsKLSAgICBERUZJTkVTICs9IFBMVUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQT1JURUQK LX0KLQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKSB7CiAgICAgSEVB REVSUyArPSBcCiAgICAgICAgIFNoYXJlZC9OYXRpdmVXZWJUb3VjaEV2ZW50LmgKICAgICBTT1VS Q0VTICs9IFwKICAgICAgICAgU2hhcmVkL3F0L05hdGl2ZVdlYlRvdWNoRXZlbnRRdC5jcHAKIH0K KworcGx1Z2luX2JhY2tlbmRfeGxpYiB7CisgICAgREVGSU5FUyArPSBYUF9VTklYCit9CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9T dG9yZVVuaXguY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvdW5peC9QbHVn aW5JbmZvU3RvcmVVbml4LmNwcAppbmRleCA4NWRjOGQ4MTI1Nzg5MjE4YzQ5MmI2MzU3ODFiYzY5 MGQ3MmMyNjQwLi5jYWVjZjc5NDI0ZTJlYzZlZmJlMjBiNzAzOTAyNjE0NzZmMzA3NDcyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9T dG9yZVVuaXguY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QbHVnaW5zL3VuaXgv UGx1Z2luSW5mb1N0b3JlVW5peC5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIk5l dHNjYXBlUGx1Z2luTW9kdWxlLmgiCiAjaW5jbHVkZSAiUGx1Z2luRGF0YWJhc2UuaCIKKyNpbmNs dWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAK QEAgLTM3LDcgKzM4LDQxIEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiBWZWN0b3I8U3RyaW5nPiBQ bHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNEaXJlY3RvcmllcygpCiB7Ci0gICAgcmV0dXJuIFBsdWdp bkRhdGFiYXNlOjpkZWZhdWx0UGx1Z2luRGlyZWN0b3JpZXMoKTsKKyAgICBWZWN0b3I8U3RyaW5n PiByZXN1bHQ7CisKKyAgICByZXN1bHQuYXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkgKyAiLy5t b3ppbGxhL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkg KyAiLy5uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvYnJv d3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9sb2NhbC9saWIvbW96aWxs YS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvZmlyZWZveC9wbHVnaW5z Iik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9icm93c2VyLXBsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9icm93c2VyLXBsdWdpbnMiKTsKKyAgICByZXN1bHQu YXBwZW5kKCIvdXNyL2xpYi9tb3ppbGxhL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIv dXNyL2xvY2FsL25ldHNjYXBlL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvb3B0L21v emlsbGEvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbW96aWxsYS9saWIvcGx1 Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2NhcGUvcGx1Z2lucyIpOworICAg IHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2NhcGUvY29tbXVuaWNhdG9yL3BsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0 LmFwcGVuZCgiL3Vzci9saWIvbmV0c2NhcGUvcGx1Z2lucy1saWJjNSIpOworICAgIHJlc3VsdC5h cHBlbmQoIi91c3IvbGliL25ldHNjYXBlL3BsdWdpbnMtbGliYzYiKTsKKyAgICByZXN1bHQuYXBw ZW5kKCIvdXNyL2xpYjY0L25ldHNjYXBlL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIv dXNyL2xpYjY0L21vemlsbGEvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi91c3IvbGli L25zYnJvd3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9uc2Jy b3dzZXIvcGx1Z2lucyIpOworCisgICAgU3RyaW5nIG1vemlsbGFIb21lKGdldGVudigiTU9aSUxM QV9IT01FIikpOworICAgIGlmICghbW96aWxsYUhvbWUuaXNFbXB0eSgpKQorICAgICAgICByZXN1 bHQuYXBwZW5kKG1vemlsbGFIb21lICsgIi9wbHVnaW5zIik7CisKKyAgICBTdHJpbmcgbW96aWxs YVBhdGhzKGdldGVudigiTU9aX1BMVUdJTl9QQVRIIikpOworICAgIGlmICghbW96aWxsYVBhdGhz LmlzRW1wdHkoKSkgeworICAgICAgICBWZWN0b3I8U3RyaW5nPiBwYXRoczsKKyAgICAgICAgbW96 aWxsYVBhdGhzLnNwbGl0KFVDaGFyKCc6JyksIC8qIGFsbG93RW1wdHlFbnRyaWVzICovIGZhbHNl LCBwYXRocyk7CisgICAgICAgIHJlc3VsdC5hcHBlbmQocGF0aHMpOworICAgIH0KKworICAgIHJl dHVybiByZXN1bHQ7CiB9CiAKIFZlY3RvcjxTdHJpbmc+IFBsdWdpbkluZm9TdG9yZTo6cGx1Z2lu UGF0aHNJbkRpcmVjdG9yeShjb25zdCBTdHJpbmcmIGRpcmVjdG9yeSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJG dW5jcy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0 c2NhcGVCcm93c2VyRnVuY3MuY3BwCmluZGV4IDFlYzQzMzEzYWZkMmQyODk2M2Y0ZTNmNjQ2Zjdk MDg2MWUwZTZlZDcuLmUwMjBlYzkxMjhlZDk1YTk1ZjQwMGZhOTBkZmQwMzcyOGZmYTdhNjAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRz Y2FwZUJyb3dzZXJGdW5jcy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVn aW5zL05ldHNjYXBlL05ldHNjYXBlQnJvd3NlckZ1bmNzLmNwcApAQCAtMzYsMTQgKzM2LDYgQEAK ICNpbmNsdWRlIDxXZWJDb3JlL1NoYXJlZEJ1ZmZlci5oPgogI2luY2x1ZGUgPHV0aWxpdHk+CiAK LSNpZiBQTFVHSU5fQVJDSElURUNUVVJFKFgxMSkKLSNpZiBQTEFURk9STShRVCkKLSNpbmNsdWRl IDxRWDExSW5mbz4KLSNlbGlmIFBMQVRGT1JNKEdUSykKLSNpbmNsdWRlIDxnZGsvZ2RreC5oPgot I2VuZGlmCi0jZW5kaWYKLQogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiB1c2luZyBuYW1lc3Bh Y2Ugc3RkOwogCkBAIC01MjcsMTUgKzUxOSw4IEBAIHN0YXRpYyBOUEVycm9yIE5QTl9HZXRWYWx1 ZShOUFAgbnBwLCBOUE5WYXJpYWJsZSB2YXJpYWJsZSwgdm9pZCAqdmFsdWUpCiAgICAgICAgY2Fz ZSBOUE5WeERpc3BsYXk6IHsKICAgICAgICAgICAgaWYgKCFucHApCiAgICAgICAgICAgICAgICBy ZXR1cm4gTlBFUlJfR0VORVJJQ19FUlJPUjsKLSNpZiBQTEFURk9STShRVCkKLSAgICAgICAgICAg KnJlaW50ZXJwcmV0X2Nhc3Q8RGlzcGxheSoqPih2YWx1ZSkgPSBRWDExSW5mbzo6ZGlzcGxheSgp OworICAgICAgICAgICAqcmVpbnRlcnByZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVlKSA9IE5ldHNj YXBlUGx1Z2luOjpwbHVnaW5EaXNwbGF5KCk7CiAgICAgICAgICAgIGJyZWFrOwotI2VsaWYgUExB VEZPUk0oR1RLKQotICAgICAgICAgICAqcmVpbnRlcnByZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVl KSA9IEdES19ESVNQTEFZX1hESVNQTEFZKGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOwotICAg ICAgICAgICBicmVhazsKLSNlbHNlCi0gICAgICAgICAgIGdvdG8gZGVmYXVsdDsKLSNlbmRpZgog ICAgICAgIH0KICAgICAgICBjYXNlIE5QTlZTdXBwb3J0c1hFbWJlZEJvb2w6CiAgICAgICAgICAg ICpzdGF0aWNfY2FzdDxOUEJvb2wqPih2YWx1ZSkgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlUGx1Z2luLmggYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4u aAppbmRleCA4YjYzNmJlMDAyMjM0OGRlNzY4NzJlY2RhMDVmNWQ1N2JjNTQzYmZjLi4xOWE2Zjdk ODU3OTQ3YWIyMDhiZjQ3Nzk3ZDM0ZjQxODBlODM4ZTU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4uaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4u aApAQCAtMzQxLDYgKzM0MSw5IEBAIHByaXZhdGU6CiAjZWxpZiBQTFVHSU5fQVJDSElURUNUVVJF KFgxMSkKICAgICBQaXhtYXAgbV9kcmF3YWJsZTsKICAgICBEaXNwbGF5KiBtX3BsdWdpbkRpc3Bs YXk7CisKK3B1YmxpYzogLy8gTmVlZCB0byBjYWxsIGl0IGluIHRoZSBOUE5fR2V0VmFsdWUgYnJv d3NlciBjYWxsYmFjay4KKyAgICBzdGF0aWMgRGlzcGxheSogcGx1Z2luRGlzcGxheSgpOwogI2Vu ZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMv TmV0c2NhcGUveDExL05ldHNjYXBlUGx1Z2luWDExLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVnaW5YMTEuY3BwCmluZGV4IGZj OTRmNjNiMWMxYWMyMzQ2MWU0ZGVkYzU2NjBkNzUyODlkMjdhYWIuLmQ2NzNiMjRmYTNhZDcwOWYx ZTI3MzMxNGQzNTM3YWFmYzMxOThiYTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVnaW5YMTEuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVn aW5YMTEuY3BwCkBAIC0zNCwxMCArMzQsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvTm90SW1wbGVt ZW50ZWQuaD4KIAogI2lmIFBMQVRGT1JNKFFUKQotI2luY2x1ZGUgPFFBcHBsaWNhdGlvbj4KLSNp bmNsdWRlIDxRRGVza3RvcFdpZGdldD4KLSNpbmNsdWRlIDxRUGl4bWFwPgotI2luY2x1ZGUgPFFY MTFJbmZvPgorI2luY2x1ZGUgPFdlYkNvcmUvUXRYMTFJbWFnZUNvbnZlcnNpb24uaD4KICNlbGlm IFBMQVRGT1JNKEdUSykKICNpbmNsdWRlICJQbGF0Zm9ybUNvbnRleHRDYWlyby5oIgogI2luY2x1 ZGUgIlJlZlB0ckNhaXJvLmgiCkBAIC01MCw3ICs0Nyw3IEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAotc3RhdGljIERpc3BsYXkgKmdldFBsdWdpbkRp c3BsYXkoKQorc3RhdGljIERpc3BsYXkqIGdldFBsdWdpbkRpc3BsYXkoKQogewogI2lmIFBMQVRG T1JNKFFUKQogICAgIC8vIEF0IHRoZSBtb21lbnQsIHdlIG9ubHkgc3VwcG9ydCBnZGsgYmFzZWQg cGx1Z2lucyAobGlrZSBGbGFzaCkgdGhhdCB1c2UgYSBkaWZmZXJlbnQgWCBjb25uZWN0aW9uLgpA QCAtODcsMTIgKzg0LDEyIEBAIHN0YXRpYyBEaXNwbGF5ICpnZXRQbHVnaW5EaXNwbGF5KCkKICNl bmRpZgogfQogCi1zdGF0aWMgaW5saW5lIERpc3BsYXkqIHgxMURpc3BsYXkoKQorc3RhdGljIGlu bGluZSBpbnQgeDExU2NyZWVuKCkKIHsKICNpZiBQTEFURk9STShRVCkKLSAgICByZXR1cm4gUVgx MUluZm86OmRpc3BsYXkoKTsKKyAgICByZXR1cm4gWERlZmF1bHRTY3JlZW4oTmV0c2NhcGVQbHVn aW46OnBsdWdpbkRpc3BsYXkoKSk7CiAjZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0dXJuIEdE S19ESVNQTEFZX1hESVNQTEFZKGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworICAgIHJldHVy biBnZGtfc2NyZWVuX2dldF9udW1iZXIoZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgpKTsKICNlbHNl CiAgICAgcmV0dXJuIDA7CiAjZW5kaWYKQEAgLTEwMSw3ICs5OCw3IEBAIHN0YXRpYyBpbmxpbmUg RGlzcGxheSogeDExRGlzcGxheSgpCiBzdGF0aWMgaW5saW5lIGludCBkaXNwbGF5RGVwdGgoKQog ewogI2lmIFBMQVRGT1JNKFFUKQotICAgIHJldHVybiBRQXBwbGljYXRpb246OmRlc2t0b3AoKS0+ eDExSW5mbygpLmRlcHRoKCk7CisgICAgcmV0dXJuIFhEZWZhdWx0RGVwdGgoTmV0c2NhcGVQbHVn aW46OnBsdWdpbkRpc3BsYXkoKSwgeDExU2NyZWVuKCkpOwogI2VsaWYgUExBVEZPUk0oR1RLKQog ICAgIHJldHVybiBnZGtfdmlzdWFsX2dldF9kZXB0aChnZGtfc2NyZWVuX2dldF9zeXN0ZW1fdmlz dWFsKGdka19zY3JlZW5fZ2V0X2RlZmF1bHQoKSkpOwogI2Vsc2UKQEAgLTExMiw3ICsxMDksNyBA QCBzdGF0aWMgaW5saW5lIGludCBkaXNwbGF5RGVwdGgoKQogc3RhdGljIGlubGluZSB1bnNpZ25l ZCBsb25nIHJvb3RXaW5kb3dJRCgpCiB7CiAjaWYgUExBVEZPUk0oUVQpCi0gICAgcmV0dXJuIFFY MTFJbmZvOjphcHBSb290V2luZG93KCk7CisgICAgcmV0dXJuIFhEZWZhdWx0Um9vdFdpbmRvdyhO ZXRzY2FwZVBsdWdpbjo6cGx1Z2luRGlzcGxheSgpKTsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAg ICByZXR1cm4gR0RLX1JPT1RfV0lORE9XKCk7CiAjZWxzZQpAQCAtMTIwLDE3ICsxMTcsNiBAQCBz dGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgcm9vdFdpbmRvd0lEKCkKICNlbmRpZgogfQogCi1z dGF0aWMgaW5saW5lIGludCB4MTFTY3JlZW4oKQotewotI2lmIFBMQVRGT1JNKFFUKQotICAgIHJl dHVybiBRWDExSW5mbzo6YXBwU2NyZWVuKCk7Ci0jZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0 dXJuIGdka19zY3JlZW5fZ2V0X251bWJlcihnZGtfc2NyZWVuX2dldF9kZWZhdWx0KCkpOwotI2Vs c2UKLSAgICByZXR1cm4gMDsKLSNlbmRpZgotfQotCiAjaWYgUExBVEZPUk0oR1RLKQogc3RhdGlj IGJvb2wgbW9kdWxlTWl4ZXNHdGtTeW1ib2xzKE1vZHVsZSogbW9kdWxlKQogewpAQCAtMTQyLDYg KzEyOCwyMiBAQCBzdGF0aWMgYm9vbCBtb2R1bGVNaXhlc0d0a1N5bWJvbHMoTW9kdWxlKiBtb2R1 bGUpCiB9CiAjZW5kaWYKIAorRGlzcGxheSogTmV0c2NhcGVQbHVnaW46OnBsdWdpbkRpc3BsYXko KQoreworI2lmIFBMQVRGT1JNKFFUKQorICAgIHN0YXRpYyBEaXNwbGF5KiBkZWRpY2F0ZWRQbHVn aW5EaXNwbGF5ID0gMDsKKyAgICBpZiAoIWRlZGljYXRlZFBsdWdpbkRpc3BsYXkpCisgICAgICAg IGRlZGljYXRlZFBsdWdpbkRpc3BsYXkgPSBYT3BlbkRpc3BsYXkoMCk7CisKKyAgICBBU1NFUlQo ZGVkaWNhdGVkUGx1Z2luRGlzcGxheSk7CisgICAgcmV0dXJuIGRlZGljYXRlZFBsdWdpbkRpc3Bs YXk7CisjZWxpZiBQTEFURk9STShHVEspCisgICAgcmV0dXJuIEdES19ESVNQTEFZX1hESVNQTEFZ KGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworI2Vsc2UKKyAgICByZXR1cm4gMDsKKyNlbmRp ZgorfQorCiBib29sIE5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9ybVBvc3RJbml0aWFsaXplKCkKIHsK ICNpZiBQTEFURk9STShHVEspCkBAIC0xNTcsOCArMTU5LDExIEBAIGJvb2wgTmV0c2NhcGVQbHVn aW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUoKQogCiAgICAgTlBTZXRXaW5kb3dDYWxsYmFja1N0 cnVjdCogY2FsbGJhY2tTdHJ1Y3QgPSBuZXcgTlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdDsKICAg ICBjYWxsYmFja1N0cnVjdC0+dHlwZSA9IDA7Ci0gICAgRGlzcGxheSogZGlzcGxheSA9IHgxMURp c3BsYXkoKTsKKyAgICBEaXNwbGF5KiBkaXNwbGF5ID0gcGx1Z2luRGlzcGxheSgpOwogICAgIGlu dCBkZXB0aCA9IGRpc3BsYXlEZXB0aCgpOworI2lmIFBMQVRGT1JNKFFUKQorICAgIEFTU0VSVChk ZXB0aCA9PSAxNiB8fCBkZXB0aCA9PSAyNCB8fCBkZXB0aCA9PSAzMik7CisjZW5kaWYKICAgICBj YWxsYmFja1N0cnVjdC0+ZGlzcGxheSA9IGRpc3BsYXk7CiAgICAgY2FsbGJhY2tTdHJ1Y3QtPmRl cHRoID0gZGVwdGg7CiAKQEAgLTE5MSw3ICsxOTYsNyBAQCB2b2lkIE5ldHNjYXBlUGx1Z2luOjpw bGF0Zm9ybURlc3Ryb3koKQogICAgIGRlbGV0ZSBzdGF0aWNfY2FzdDxOUFNldFdpbmRvd0NhbGxi YWNrU3RydWN0Kj4obV9ucFdpbmRvdy53c19pbmZvKTsKIAogICAgIGlmIChtX2RyYXdhYmxlKSB7 Ci0gICAgICAgIFhGcmVlUGl4bWFwKHgxMURpc3BsYXkoKSwgbV9kcmF3YWJsZSk7CisgICAgICAg IFhGcmVlUGl4bWFwKHBsdWdpbkRpc3BsYXkoKSwgbV9kcmF3YWJsZSk7CiAgICAgICAgIG1fZHJh d2FibGUgPSAwOwogICAgIH0KIH0KQEAgLTIwOSw3ICsyMTQsNyBAQCB2b2lkIE5ldHNjYXBlUGx1 Z2luOjpwbGF0Zm9ybUdlb21ldHJ5RGlkQ2hhbmdlKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0K IAotICAgIERpc3BsYXkqIGRpc3BsYXkgPSB4MTFEaXNwbGF5KCk7CisgICAgRGlzcGxheSogZGlz cGxheSA9IHBsdWdpbkRpc3BsYXkoKTsKICAgICBpZiAobV9kcmF3YWJsZSkKICAgICAgICAgWEZy ZWVQaXhtYXAoZGlzcGxheSwgbV9kcmF3YWJsZSk7CiAKQEAgLTI0MywxNyArMjQ4LDExIEBAIHZv aWQgTmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0 LCBjb25zdCBJbnRSZWN0JiBkaXJ0CiAgICAgaWYgKGNvbnRleHQtPnBhaW50aW5nRGlzYWJsZWQo KSB8fCAhbV9kcmF3YWJsZSkKICAgICAgICAgcmV0dXJuOwogCi0jaWYgUExBVEZPUk0oUVQpCi0j ZWxpZiAhUExBVEZPUk0oR1RLKQotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuOwot I2VuZGlmCi0KICAgICBYRXZlbnQgeGV2ZW50OwogICAgIG1lbXNldCgmeGV2ZW50LCAwLCBzaXpl b2YoWEV2ZW50KSk7CiAgICAgWEdyYXBoaWNzRXhwb3NlRXZlbnQmIGV4cG9zZUV2ZW50ID0geGV2 ZW50LnhncmFwaGljc2V4cG9zZTsKICAgICBleHBvc2VFdmVudC50eXBlID0gR3JhcGhpY3NFeHBv c2U7Ci0gICAgZXhwb3NlRXZlbnQuZGlzcGxheSA9IHgxMURpc3BsYXkoKTsKKyAgICBleHBvc2VF dmVudC5kaXNwbGF5ID0gcGx1Z2luRGlzcGxheSgpOwogICAgIGV4cG9zZUV2ZW50LmRyYXdhYmxl ID0gbV9kcmF3YWJsZTsKIAogICAgIEludFJlY3QgZXhwb3NlZFJlY3QoZGlydHlSZWN0KTsKQEAg LTI2NywxNCArMjY2LDE5IEBAIHZvaWQgTmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3Jh cGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiBkaXJ0CiAKICAgICBOUFBfSGFu ZGxlRXZlbnQoJnhldmVudCk7CiAKLSAgICBpZiAobV9wbHVnaW5EaXNwbGF5ICE9IHgxMURpc3Bs YXkoKSkKKyAgICBpZiAobV9wbHVnaW5EaXNwbGF5ICE9IHBsdWdpbkRpc3BsYXkoKSkKICAgICAg ICAgWFN5bmMobV9wbHVnaW5EaXNwbGF5LCBmYWxzZSk7CiAKICNpZiBQTEFURk9STShRVCkKLSAg ICBRUGl4bWFwIHF0RHJhd2FibGUgPSBRUGl4bWFwOjpmcm9tWDExUGl4bWFwKG1fZHJhd2FibGUs IFFQaXhtYXA6OkV4cGxpY2l0bHlTaGFyZWQpOwotICAgIEFTU0VSVChxdERyYXdhYmxlLmRlcHRo KCkgPT0gc3RhdGljX2Nhc3Q8TlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdCo+KG1fbnBXaW5kb3cu d3NfaW5mbyktPmRlcHRoKTsKKyAgICBYSW1hZ2UqIHhJbWFnZSA9IFhHZXRJbWFnZShOZXRzY2Fw ZVBsdWdpbjo6cGx1Z2luRGlzcGxheSgpLCBtX2RyYXdhYmxlLCBleHBvc2VkUmVjdC54KCksIGV4 cG9zZWRSZWN0LnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBvc2VkUmVj dC53aWR0aCgpLCBleHBvc2VkUmVjdC5oZWlnaHQoKSwgVUxPTkdfTUFYLCBaUGl4bWFwKTsKKyAg ICBRSW1hZ2UgaW1hZ2UgPSBxaW1hZ2VGcm9tWEltYWdlKHhJbWFnZSk7CisKICAgICBRUGFpbnRl ciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOwotICAgIHBhaW50ZXItPmRy YXdQaXhtYXAoUVBvaW50KGV4cG9zZWRSZWN0LngoKSwgZXhwb3NlZFJlY3QueSgpKSwgcXREcmF3 YWJsZSwgZXhwb3NlZFJlY3QpOworICAgIHBhaW50ZXItPmRyYXdJbWFnZShRUG9pbnQoZXhwb3Nl ZFJlY3QueCgpLCBleHBvc2VkUmVjdC55KCkpLCBpbWFnZSwgZXhwb3NlZFJlY3QpOworCisgICAg aW1hZ2UgPSBRSW1hZ2UoKTsKKyAgICBYRGVzdHJveUltYWdlKHhJbWFnZSk7CiAjZWxpZiBQTEFU Rk9STShHVEspCiAgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gZHJhd2FibGVTdXJmYWNlID0g YWRvcHRSZWYoY2Fpcm9feGxpYl9zdXJmYWNlX2NyZWF0ZShtX3BsdWdpbkRpc3BsYXksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBtX2RyYXdhYmxlLApAQCAtMjkyLDYgKzI5Niw4IEBAIHZvaWQg TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBj b25zdCBJbnRSZWN0JiBkaXJ0CiAgICAgY2Fpcm9fcGFpbnQoY3IpOwogCiAgICAgY2Fpcm9fcmVz dG9yZShjcik7CisjZWxzZQorICAgIG5vdEltcGxlbWVudGVkKCk7CiAjZW5kaWYKIH0KIApAQCAt MzAwLDcgKzMwNiw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpbml0aWFsaXplWEV2ZW50KFhFdmVu dCYgZXZlbnQpCiAgICAgbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKFhFdmVudCkpOwogICAgIGV2 ZW50Lnhhbnkuc2VyaWFsID0gMDsKICAgICBldmVudC54YW55LnNlbmRfZXZlbnQgPSBmYWxzZTsK LSAgICBldmVudC54YW55LmRpc3BsYXkgPSB4MTFEaXNwbGF5KCk7CisgICAgZXZlbnQueGFueS5k aXNwbGF5ID0gTmV0c2NhcGVQbHVnaW46OnBsdWdpbkRpc3BsYXkoKTsKICAgICBldmVudC54YW55 LndpbmRvdyA9IDA7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9hcGkucHJpIGIvU291cmNlL2Fw aS5wcmkKaW5kZXggYjJlZGRiNDNiODJkOWIxM2QyMGRhYjZhMWYxYjljNzM3NTlmNjcwZi4uNjA5 ZmNkZmQyZTZiNTRhMTBkZjU5ODA3ODdmMGZhNWRiOGRkYTE4YyAxMDA2NDQKLS0tIGEvU291cmNl L2FwaS5wcmkKKysrIGIvU291cmNlL2FwaS5wcmkKQEAgLTIyMiwzICsyMjIsNyBAQCBtYWMgewog ICAgIFFNQUtFX0xGTEFHU19TT05BTUUgPSAiJCR7UU1BS0VfTEZMQUdTX1NPTkFNRX0kJHtERVNU RElSfSQke1FNQUtFX0RJUl9TRVB9IgogfQogCitwbHVnaW5fYmFja2VuZF94bGliIHsKKyAgICBD T05GSUcgKj0gbGlua19wa2djb25maWcKKyAgICBQS0dDT05GSUcgKz0geDExCit9CmRpZmYgLS1n aXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZWM3MmNkZjEwN2Rl OGNiMzc0M2MxM2E4YzBmYTdlOGMxNzcxYWVmMi4uZGE5ODZjODcxMzNkNjM0NTFlMzMwYTY5MTU5 YTVlMjViZDUyZTkxYiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0No YW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDExLTExLTA4ICBCYWxhenMgS2VsZW1lbiAgPGti YWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBwbHVnaW5zIG5lZWQgdG8gYmUg cmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBSZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBwb3J0IGluIGEgd2F5IHRoYXQgZG9l cworICAgICAgICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVuIFF0IGFuZCBYLiBUaGUgc29sdXRp b24gaXMKKyAgICAgICAgYmFzZWQgb24gZ2V0dGluZyB0aGUgY29udGVudCBkcmF3ZWQgYnkgdGhl IHBsdWdpbgorICAgICAgICBmcm9tIHRoZSBzZXJ2ZXIgYXMgYW4gaW1hZ2UgYW5kIGNyZWF0aW5n IGEgUUltYWdlCisgICAgICAgIGZyb20gaXQuCisKKyAgICAgICAgKiBxbWFrZS9ta3NwZWNzL2Zl YXR1cmVzL2ZlYXR1cmVzLnByZjogRW5hYmxlIFgxMQorICAgICAgICBwbHVnaW5zIGlmIFF0IGlz IGJ1aWx0IHdpdGggdGhlIHhjYi14bGliIGJhY2tlbmQuCisKIDIwMTEtMTEtMDggIFRvciBBcm5l IFZlc3Riw7ggIDx0b3IuYXJuZS52ZXN0Ym9Abm9raWEuY29tPgogCiAgICAgICAgIFtRdF0gUHJl dmVudCBkdXBsaWNhdGVkIHNvdXJjZXMgaW4gU09VUkNFUy9PQkpFQ1RJVkVfU09VUkNFUwpkaWZm IC0tZ2l0IGEvVG9vbHMvcW1ha2UvbWtzcGVjcy9mZWF0dXJlcy9mZWF0dXJlcy5wcmYgYi9Ub29s cy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnByZgppbmRleCA5YTNkMGZhZmFmMjJi NzRmMjkwMWMyZWFiZjBhMDlmYmU4MTJkYjFhLi5mOTYzNzg3Y2FjY2M0YWQ1ODcyOTk1NTk5NTQ1 NGJjYzIwMjBlZTA1IDEwMDY0NAotLS0gYS9Ub29scy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2Zl YXR1cmVzLnByZgorKysgYi9Ub29scy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnBy ZgpAQCAtODksMTMgKzg5LDI4IEBAIGlzRW1wdHkoSEFWRV9RUkFXRk9OVCkgewogCiAjIE5lc2Nh cGUgcGx1Z2lucyBzdXBwb3J0IChOUEFQSSkKICFjb250YWlucyhERUZJTkVTLCBFTkFCTEVfTkVU U0NBUEVfUExVR0lOX0FQST0uKSB7Ci0gICAgdW5peDohaGF2ZVF0KDUpfHdpbjMyLSo6IWVtYmVk ZGVkOiF3aW5jZSo6IHsKLSAgICAgICAgREVGSU5FUyArPSBFTkFCTEVfTkVUU0NBUEVfUExVR0lO X0FQST0xCisgICAgIWhhdmVRdCg1KTogeworICAgICAgICB1bml4fHdpbjMyLSo6IWVtYmVkZGVk OiF3aW5jZSo6IHsKKyAgICAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBFX1BMVUdJ Tl9BUEk9MSBcCisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBERUZJTkVTICs9IEVOQUJM RV9ORVRTQ0FQRV9QTFVHSU5fQVBJPTAKKyAgICAgICAgfQogICAgIH0gZWxzZSB7CiAgICAgICAg IERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBFX1BMVUdJTl9BUEk9MAogICAgIH0KIH0KIAorIyBO ZXRzY2FwZSBwbHVnaW5zIHN1cHBvcnQgZm9yIFdlYktpdDIKKyFub193ZWJraXQyOiFjb250YWlu cyhERUZJTkVTLCBQTFVHSU5fQVJDSElURUNUVVJFX1VOU1VQUE9SVEVEKTogeworICAgIGNvbnRh aW5zKFFUX0NPTkZJRywgeGNiLXhsaWIpIHsKKyAgICAgICAgQ09ORklHICs9IHBsdWdpbl9iYWNr ZW5kX3hsaWIKKyAgICAgICAgREVGSU5FUyArPSBQTFVHSU5fQVJDSElURUNUVVJFX1gxMT0xIFwK KyAgICAgICAgICAgICAgICAgICBQTFVHSU5fQVJDSElURUNUVVJFX1VOU1VQUE9SVEVEPTAKKyAg ICB9IGVsc2UgeworICAgICAgICBERUZJTkVTICs9IFBMVUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQ T1JURUQ9MQorICAgIH0KK30KKwogIyBXZWJHTCBzdXBwb3J0CiBjb250YWlucyhRVF9DT05GSUcs IG9wZW5nbCk6IXdpbjMyLSogewogICAgICFjb250YWlucyhERUZJTkVTLCBFTkFCTEVfV0VCR0w9 Lik6IERFRklORVMgKz0gRU5BQkxFX1dFQkdMPTEKZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0No YW5nZUxvZwppbmRleCA0Y2JlNmRkYjY0YzlhMzUwN2FhNmRlNWE4NTE5OGNhMzViOTJjNzFiLi43 Njg2NjIwYmFlYWY2YzI5YTgzNjE3ZGJiMjlhOTQ1NWVjZGVjYzZiIDEwMDY0NAotLS0gYS9DaGFu Z2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMTEtMDggIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIgYmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4g YSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVkIGEgYnJpZGdlIGJldHdlZW4gUXQgYW5k IFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50 IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBpbWFn ZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAgZnJvbSBpdC4KKworICAgICAgICAqIFNv dXJjZS9hcGkucHJpOiBMaW5rIHRvIHhsaWIgaWYgbmVjZXNzYXJ5LgorCiAyMDExLTExLTA4ICBZ dXFpYW5nIFhpYW4gIDx5dXFpYW5nLnhpYW5AaW50ZWwuY29tPgogCiAgICAgICAgIEVuYWJsZSBE RkcgSklUIGJ5IGRlZmF1bHQgb24gWDg2IExpbnV4IGFuZCBNYWMgcGxhdGZvcm1zCg== 114074 2011-11-08 08:15:58 -0800 2011-11-10 07:11:18 -0800 wk2 plugins v2 fixed bug-70023-20111108171556.patch text/plain 22391 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTk1NTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyOWViNmRkNmRlYjA5Nzgz NmU2NTFkNjllYTE2YmY1MWEyOWI1MGQ0Li4xOTE5NjY1ODAyNGEzYjhhNWM4NmQ2MjNjM2I1YjNk MzZiYjA1MDZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTEtMTEtMDggIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIgYmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4g YSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVkIGEgYnJpZGdlIGJldHdlZW4gUXQgYW5k IFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50 IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBpbWFn ZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAgZnJvbSBpdC4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIEV4aXN0aW5nIHBsdWdpbiB0ZXN0IGFyZSBzdWZmaWNpZW50LgorCisgICAgICAg ICogVGFyZ2V0LnByaToKKyAgICAgICAgKiBicmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmg6IEFk ZGVkIHlldCBhbm90aGVyIHVuZGVmCisgICAgICAgIHRvIGZpeCBidWlsZCB3aXRoIFF0NSArIFgx MSBoZWFkZXJzLgorICAgICAgICAqIHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OnFpbWFnZUZyb21YSW1hZ2UpOgorICAgICAgICAq IHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaDogQWRkZWQuCisgICAgICAgIEFkZGVk IGEgaGVscGVyIGZ1bmN0aW9uIHRvIGNyZWF0ZSBhIFFJbWFnZSBmcm9tIGFuIFhJbWFnZS4KKyAg ICAgICAgUHV0IGl0IGluIGEgbmV3IGZpbGUgdG8gYXZvaWQgY29weXJpZ2h0IGlzc3VlcyBhcyB0 aGlzIGNvZGUKKyAgICAgICAgaGFzIGJlZW4gdGFrZW4gZGlyZWN0bHkgZnJvbSBRdC4gQWRkaW5n IHRoaXMgdG8gV2ViQ29yZSB0bworICAgICAgICBiZSBhYmxlIHRvIHJldXNlIGZvciB0aGUgV0sx IHBsdWdpbiBzdXBwb3J0IGluIHRoZSBmdXR1cmUuCisKIDIwMTEtMTEtMDggIEFuZHJleSBLb3N5 YWtvdiAgPGNhc2VxQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBkbyBu b3Qgc2hvdyBvYmplY3QgcG9wb3ZlciB3aGVuIHNlbGVjdGlvbiBpcyBhY3RpdmUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpp bmRleCA1YjRiYzdmM2ExNDI5MmFmM2JiYjQ2NGU5N2EzN2Y1YWZjMzViNzIxLi4zMzZlODYwNjc5 NTFlOTE3OTE5ZmFhOGE5MGQ1OTYxNDA3YTdhNzc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQg QEAKKzIwMTEtMTEtMDggIEJhbGF6cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisg ICAgICAgIFtRdF0gWDExIHBsdWdpbnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGFyZ2V0LnByaToK KyAgICAgICAgKiBVSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3Bw OgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNEaXJlY3Rvcmllcyk6 CisgICAgICAgIEtpbGwgdGhlIGxhc3QgZGVwZW5kZW5jeSBmcm9tIHRoZSBXZWJLaXQxIHBsdWdp biBzeXN0ZW0uCisgICAgICAgIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2UgY3VycmVudGx5IHdl IGRvbid0IGJ1aWxkIHRoZSBXZWJLaXQxCisgICAgICAgIHBsdWdpbiBjb2RlLiBUaGUgZnVuY3Rp b24gaXMgZXF1aXZhbGVudCB3aXRoIHRoZSBYUF9VTklYIHBhcnQgb2YKKyAgICAgICAgUGx1Z2lu RGF0YWJhc2U6OmRlZmF1bHRQbHVnaW5EaXJlY3Rvcmllcy4KKyAgICAgICAgCisgICAgICAgICog V2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlQnJvd3NlckZ1bmNzLmNwcDoKKyAg ICAgICAgKFdlYktpdDo6TlBOX0dldFZhbHVlKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdp bnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4uaDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1BsdWdp bnMvTmV0c2NhcGUveDExL05ldHNjYXBlUGx1Z2luWDExLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 Z2V0UGx1Z2luRGlzcGxheSk6CisgICAgICAgIChXZWJLaXQ6OngxMVNjcmVlbik6CisgICAgICAg IChXZWJLaXQ6OmRpc3BsYXlEZXB0aCk6CisgICAgICAgIChXZWJLaXQ6OnJvb3RXaW5kb3dJRCk6 CisgICAgICAgIChXZWJLaXQ6Ok5ldHNjYXBlUGx1Z2luOjpwbHVnaW5EaXNwbGF5KToKKyAgICAg ICAgKFdlYktpdDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUpOgorICAg ICAgICAoV2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1EZXN0cm95KToKKyAgICAgICAg KFdlYktpdDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtR2VvbWV0cnlEaWRDaGFuZ2UpOgorICAg ICAgICAoV2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1QYWludCk6CisgICAgICAgIChX ZWJLaXQ6OmluaXRpYWxpemVYRXZlbnQpOgorICAgICAgICBSZXdvcmsgcGx1Z2luIGluaXRpYWxp emF0aW9uIGFuZCBkcmF3aW5nIG1vZGVsLgorCiAyMDExLTExLTA4ICBLZW5uZXRoIFJvaGRlIENo cmlzdGlhbnNlbiAgPGtlbm5ldGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBbUXRdIEltcHJvdmUg dGhlIGFuaW1hdGlvbiB0aW1lIGNvbnN0YW50CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9U YXJnZXQucHJpIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCAwMzZmOWU5Yjk1MDVj YmVjNjRiYzJjZmU5NTg0MWRmZjRmM2VkYzI0Li41NjdmOTQxM2Q3NTUzMGZjOWM5ZTY3NWRjNTc2 YWRiM2RhM2M3N2FlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisrKyBi L1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKQEAgLTI4NjIsNiArMjg2MiwxMSBAQCBjb250YWlu cyhERUZJTkVTLCBFTkFCTEVfTkVUU0NBUEVfUExVR0lOX0FQST0xKSB7CiAgICAgICAgIHBsdWdp bnMvUGx1Z2luVmlld05vbmUuY3BwCiB9CiAKK3BsdWdpbl9iYWNrZW5kX3hsaWIgeworICAgIFNP VVJDRVMgKz0gcGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lvbi5jcHAKKyAgICBIRUFERVJT ICs9IHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaAorfQorCiBjb250YWlucyhERUZJ TkVTLCBFTkFCTEVfU1FMX0RBVEFCQVNFPTEpIHsKICAgICBTT1VSQ0VTICs9IFwKICAgICAgICAg c3RvcmFnZS9DaGFuZ2VWZXJzaW9uV3JhcHBlci5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYnJpZGdlL25wcnVudGltZV9pbnRlcm5hbC5oIGIvU291cmNlL1dlYkNvcmUvYnJpZGdl L25wcnVudGltZV9pbnRlcm5hbC5oCmluZGV4IDJkN2RjMDYyNjE3ZjE4NWFiMWMxNjM5MDY0MGEx MGIxODdhNDA0NzkuLjYyM2M0NzU5YmNjMGY5YjgxMGQ1NDA1OWI2NjVhZTExYTFlYmJiNDAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JyaWRnZS9ucHJ1bnRpbWVfaW50ZXJuYWwuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9icmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmgKQEAgLTUxLDQgKzUx LDUgQEAKICAgICAjdW5kZWYgVHJ1ZQogICAgICN1bmRlZiBGYWxzZQogICAgICN1bmRlZiBTdWNj ZXNzCisgICAgI3VuZGVmIEV4cG9zZQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJzaW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs dWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM1NGZiYjQwNDQ2 ZDAyMzNhM2I1ZmMxZDBlZTk1OWQ0NzgwYzUzMmUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJzaW9uLmNwcApAQCAtMCwwICsxLDY5 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBp dHMgc3Vic2lkaWFyeSgtaWVzKS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIFVzYWdlCisgKiBUaGlzIGZpbGUgbWF5IGJl IHVzZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIHZlcnNpb24gMi4xIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uIGFuZAorICogYXBwZWFyaW5nIGluIHRoZSBmaWxlIExJQ0VOU0UuTEdQTCBpbmNs dWRlZCBpbiB0aGUgcGFja2FnaW5nIG9mIHRoaXMKKyAqIGZpbGUuIFBsZWFzZSByZXZpZXcgdGhl IGZvbGxvd2luZyBpbmZvcm1hdGlvbiB0byBlbnN1cmUgdGhlIEdOVSBMZXNzZXIKKyAqIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyLjEgcmVxdWlyZW1lbnRzIHdpbGwgYmUgbWV0Ogor ICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL29sZC1saWNlbnNlcy9sZ3BsLTIuMS5odG1s LgorICoKKyAqIE5vdGU6IFRoZSBmdW5jdGlvbiBxaW1hZ2VGcm9tWEltYWdlIGhhcyBiZWVuIHRh a2VuIGZyb20gUXQuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJR dFgxMUltYWdlQ29udmVyc2lvbi5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1FJbWFnZSBx aW1hZ2VGcm9tWEltYWdlKFhJbWFnZSogeGkpCit7CisgICAgUUltYWdlOjpGb3JtYXQgZm9ybWF0 ID0gUUltYWdlOjpGb3JtYXRfQVJHQjMyX1ByZW11bHRpcGxpZWQ7CisgICAgaWYgKHhpLT5kZXB0 aCA9PSAyNCkKKyAgICAgICAgZm9ybWF0ID0gUUltYWdlOjpGb3JtYXRfUkdCMzI7CisgICAgZWxz ZSBpZiAoeGktPmRlcHRoID09IDE2KQorICAgICAgICBmb3JtYXQgPSBRSW1hZ2U6OkZvcm1hdF9S R0IxNjsKKworICAgIFFJbWFnZSBpbWFnZSA9IFFJbWFnZShyZWludGVycHJldF9jYXN0PHVjaGFy Kj4oeGktPmRhdGEpLCB4aS0+d2lkdGgsIHhpLT5oZWlnaHQsIHhpLT5ieXRlc19wZXJfbGluZSwg Zm9ybWF0KS5jb3B5KCk7CisKKyAgICAvLyB3ZSBtYXkgaGF2ZSB0byBzd2FwIHRoZSBieXRlIG9y ZGVyCisgICAgaWYgKChRU3lzSW5mbzo6Qnl0ZU9yZGVyID09IFFTeXNJbmZvOjpMaXR0bGVFbmRp YW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTVNCRmlyc3QpCisgICAgICAgIHx8IChRU3lzSW5mbzo6 Qnl0ZU9yZGVyID09IFFTeXNJbmZvOjpCaWdFbmRpYW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTFNC Rmlyc3QpKSB7CisKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBpbWFnZS5oZWlnaHQoKTsg aSsrKSB7CisgICAgICAgICAgICBpZiAoeGktPmRlcHRoID09IDE2KSB7CisgICAgICAgICAgICAg ICAgdXNob3J0ICogcCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dXNob3J0Kj4oaW1hZ2Uuc2NhbkxpbmUo aSkpOworICAgICAgICAgICAgICAgIHVzaG9ydCogZW5kID0gcCArIGltYWdlLndpZHRoKCk7Cisg ICAgICAgICAgICAgICAgd2hpbGUgKHAgPCBlbmQpIHsKKyAgICAgICAgICAgICAgICAgICAgKnAg PSAoKCpwIDw8IDgpICYgMHhmZjAwKSB8ICgoKnAgPj4gOCkgJiAweDAwZmYpOworICAgICAgICAg ICAgICAgICAgICBwKys7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgICAgICB1aW50KiBwID0gcmVpbnRlcnByZXRfY2FzdDx1aW50Kj4oaW1hZ2Uu c2NhbkxpbmUoaSkpOworICAgICAgICAgICAgICAgIHVpbnQqIGVuZCA9IHAgKyBpbWFnZS53aWR0 aCgpOworICAgICAgICAgICAgICAgIHdoaWxlIChwIDwgZW5kKSB7CisgICAgICAgICAgICAgICAg ICAgICpwID0gKCgqcCA8PCAyNCkgJiAweGZmMDAwMDAwKSB8ICgoKnAgPDwgOCkgJiAweDAwZmYw MDAwKQorICAgICAgICAgICAgICAgICAgICAgICAgIHwgKCgqcCA+PiA4KSAmIDB4MDAwMGZmMDAp IHwgKCgqcCA+PiAyNCkgJiAweDAwMDAwMGZmKTsKKyAgICAgICAgICAgICAgICAgICAgcCsrOwor ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKworICAg IC8vIGZpeC11cCBhbHBoYSBjaGFubmVsCisgICAgaWYgKGZvcm1hdCA9PSBRSW1hZ2U6OkZvcm1h dF9SR0IzMikgeworICAgICAgICBRUmdiKiBwID0gcmVpbnRlcnByZXRfY2FzdDxRUmdiKj4oaW1h Z2UuYml0cygpKTsKKyAgICAgICAgZm9yIChpbnQgeSA9IDA7IHkgPCB4aS0+aGVpZ2h0OyArK3kp IHsKKyAgICAgICAgICAgIGZvciAoaW50IHggPSAwOyB4IDwgeGktPndpZHRoOyArK3gpCisgICAg ICAgICAgICAgICAgcFt4XSB8PSAweGZmMDAwMDAwOworICAgICAgICAgICAgcCArPSB4aS0+Ynl0 ZXNfcGVyX2xpbmUgLyA0OworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIGltYWdlOwor fQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs dWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaCBiL1NvdXJjZS9XZWJDb3JlL3BsdWdpbnMv cXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZGNiYTRiMzM1YmEyODQ3N2Y2 ZGIyYmM1NWY0NzE2N2Q0Mjk1Mzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lvbi5oCkBAIC0wLDAgKzEsMjcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRp YXJ5KC1pZXMpLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBHTlUgTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgVXNhZ2UKKyAqIFRoaXMgZmlsZSBtYXkgYmUgdXNlZCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug dmVyc2lvbiAyLjEgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24g YW5kCisgKiBhcHBlYXJpbmcgaW4gdGhlIGZpbGUgTElDRU5TRS5MR1BMIGluY2x1ZGVkIGluIHRo ZSBwYWNrYWdpbmcgb2YgdGhpcworICogZmlsZS4gUGxlYXNlIHJldmlldyB0aGUgZm9sbG93aW5n IGluZm9ybWF0aW9uIHRvIGVuc3VyZSB0aGUgR05VIExlc3NlcgorICogR2VuZXJhbCBQdWJsaWMg TGljZW5zZSB2ZXJzaW9uIDIuMSByZXF1aXJlbWVudHMgd2lsbCBiZSBtZXQ6CisgKiBodHRwOi8v d3d3LmdudS5vcmcvbGljZW5zZXMvb2xkLWxpY2Vuc2VzL2xncGwtMi4xLmh0bWwuCisgKgorICov CisKKyNpZm5kZWYgUXRYMTFJbWFnZUNvbnZlcnNpb25faAorI2RlZmluZSBRdFgxMUltYWdlQ29u dmVyc2lvbl9oCisKKyNpbmNsdWRlIDxRSW1hZ2U+CisjaW5jbHVkZSA8WDExL1hsaWIuaD4KKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitRSW1hZ2UgcWltYWdlRnJvbVhJbWFnZShYSW1hZ2UqKTsK KworfQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkgYi9T b3VyY2UvV2ViS2l0Mi9UYXJnZXQucHJpCmluZGV4IDMzYjhhNGQ3NTZhZWJjOGEyYjM5NWNjNjZh ZGIwODI2YWIzMjViNmYuLjM1ODc2MjliODJiNzY2OGY1NmUyMGEwOGJlOGJmZmQ1MTc4MGYxZDYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dlYktp dDIvVGFyZ2V0LnByaQpAQCAtNjExLDEzICs2MTEsMTMgQEAgU09VUkNFUyArPSBcCiAgICAgJCRX RUJLSVQyX0dFTkVSQVRFRF9TT1VSQ0VTIFwKICAgICAkJFdFQktJVDFfU09VUkNFU19TSEFSRURf V0lUSF9XRUJLSVQyCiAKLWNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5f QVBJPTApIHsKLSAgICBERUZJTkVTICs9IFBMVUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQT1JURUQK LX0KLQogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKSB7CiAgICAgSEVB REVSUyArPSBcCiAgICAgICAgIFNoYXJlZC9OYXRpdmVXZWJUb3VjaEV2ZW50LmgKICAgICBTT1VS Q0VTICs9IFwKICAgICAgICAgU2hhcmVkL3F0L05hdGl2ZVdlYlRvdWNoRXZlbnRRdC5jcHAKIH0K KworcGx1Z2luX2JhY2tlbmRfeGxpYiB7CisgICAgREVGSU5FUyArPSBYUF9VTklYCit9CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9T dG9yZVVuaXguY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvdW5peC9QbHVn aW5JbmZvU3RvcmVVbml4LmNwcAppbmRleCA4NWRjOGQ4MTI1Nzg5MjE4YzQ5MmI2MzU3ODFiYzY5 MGQ3MmMyNjQwLi5jYWVjZjc5NDI0ZTJlYzZlZmJlMjBiNzAzOTAyNjE0NzZmMzA3NDcyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9T dG9yZVVuaXguY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QbHVnaW5zL3VuaXgv UGx1Z2luSW5mb1N0b3JlVW5peC5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIk5l dHNjYXBlUGx1Z2luTW9kdWxlLmgiCiAjaW5jbHVkZSAiUGx1Z2luRGF0YWJhc2UuaCIKKyNpbmNs dWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAK QEAgLTM3LDcgKzM4LDQxIEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiBWZWN0b3I8U3RyaW5nPiBQ bHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNEaXJlY3RvcmllcygpCiB7Ci0gICAgcmV0dXJuIFBsdWdp bkRhdGFiYXNlOjpkZWZhdWx0UGx1Z2luRGlyZWN0b3JpZXMoKTsKKyAgICBWZWN0b3I8U3RyaW5n PiByZXN1bHQ7CisKKyAgICByZXN1bHQuYXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkgKyAiLy5t b3ppbGxhL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkg KyAiLy5uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvYnJv d3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9sb2NhbC9saWIvbW96aWxs YS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvZmlyZWZveC9wbHVnaW5z Iik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9icm93c2VyLXBsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9icm93c2VyLXBsdWdpbnMiKTsKKyAgICByZXN1bHQu YXBwZW5kKCIvdXNyL2xpYi9tb3ppbGxhL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIv dXNyL2xvY2FsL25ldHNjYXBlL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvb3B0L21v emlsbGEvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbW96aWxsYS9saWIvcGx1 Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2NhcGUvcGx1Z2lucyIpOworICAg IHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0c2NhcGUvY29tbXVuaWNhdG9yL3BsdWdpbnMiKTsKKyAg ICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0 LmFwcGVuZCgiL3Vzci9saWIvbmV0c2NhcGUvcGx1Z2lucy1saWJjNSIpOworICAgIHJlc3VsdC5h cHBlbmQoIi91c3IvbGliL25ldHNjYXBlL3BsdWdpbnMtbGliYzYiKTsKKyAgICByZXN1bHQuYXBw ZW5kKCIvdXNyL2xpYjY0L25ldHNjYXBlL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIv dXNyL2xpYjY0L21vemlsbGEvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi91c3IvbGli L25zYnJvd3Nlci9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9uc2Jy b3dzZXIvcGx1Z2lucyIpOworCisgICAgU3RyaW5nIG1vemlsbGFIb21lKGdldGVudigiTU9aSUxM QV9IT01FIikpOworICAgIGlmICghbW96aWxsYUhvbWUuaXNFbXB0eSgpKQorICAgICAgICByZXN1 bHQuYXBwZW5kKG1vemlsbGFIb21lICsgIi9wbHVnaW5zIik7CisKKyAgICBTdHJpbmcgbW96aWxs YVBhdGhzKGdldGVudigiTU9aX1BMVUdJTl9QQVRIIikpOworICAgIGlmICghbW96aWxsYVBhdGhz LmlzRW1wdHkoKSkgeworICAgICAgICBWZWN0b3I8U3RyaW5nPiBwYXRoczsKKyAgICAgICAgbW96 aWxsYVBhdGhzLnNwbGl0KFVDaGFyKCc6JyksIC8qIGFsbG93RW1wdHlFbnRyaWVzICovIGZhbHNl LCBwYXRocyk7CisgICAgICAgIHJlc3VsdC5hcHBlbmQocGF0aHMpOworICAgIH0KKworICAgIHJl dHVybiByZXN1bHQ7CiB9CiAKIFZlY3RvcjxTdHJpbmc+IFBsdWdpbkluZm9TdG9yZTo6cGx1Z2lu UGF0aHNJbkRpcmVjdG9yeShjb25zdCBTdHJpbmcmIGRpcmVjdG9yeSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJG dW5jcy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0 c2NhcGVCcm93c2VyRnVuY3MuY3BwCmluZGV4IDFlYzQzMzEzYWZkMmQyODk2M2Y0ZTNmNjQ2Zjdk MDg2MWUwZTZlZDcuLmUwMjBlYzkxMjhlZDk1YTk1ZjQwMGZhOTBkZmQwMzcyOGZmYTdhNjAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRz Y2FwZUJyb3dzZXJGdW5jcy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVn aW5zL05ldHNjYXBlL05ldHNjYXBlQnJvd3NlckZ1bmNzLmNwcApAQCAtMzYsMTQgKzM2LDYgQEAK ICNpbmNsdWRlIDxXZWJDb3JlL1NoYXJlZEJ1ZmZlci5oPgogI2luY2x1ZGUgPHV0aWxpdHk+CiAK LSNpZiBQTFVHSU5fQVJDSElURUNUVVJFKFgxMSkKLSNpZiBQTEFURk9STShRVCkKLSNpbmNsdWRl IDxRWDExSW5mbz4KLSNlbGlmIFBMQVRGT1JNKEdUSykKLSNpbmNsdWRlIDxnZGsvZ2RreC5oPgot I2VuZGlmCi0jZW5kaWYKLQogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiB1c2luZyBuYW1lc3Bh Y2Ugc3RkOwogCkBAIC01MjcsMTUgKzUxOSw4IEBAIHN0YXRpYyBOUEVycm9yIE5QTl9HZXRWYWx1 ZShOUFAgbnBwLCBOUE5WYXJpYWJsZSB2YXJpYWJsZSwgdm9pZCAqdmFsdWUpCiAgICAgICAgY2Fz ZSBOUE5WeERpc3BsYXk6IHsKICAgICAgICAgICAgaWYgKCFucHApCiAgICAgICAgICAgICAgICBy ZXR1cm4gTlBFUlJfR0VORVJJQ19FUlJPUjsKLSNpZiBQTEFURk9STShRVCkKLSAgICAgICAgICAg KnJlaW50ZXJwcmV0X2Nhc3Q8RGlzcGxheSoqPih2YWx1ZSkgPSBRWDExSW5mbzo6ZGlzcGxheSgp OworICAgICAgICAgICAqcmVpbnRlcnByZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVlKSA9IE5ldHNj YXBlUGx1Z2luOjpwbHVnaW5EaXNwbGF5KCk7CiAgICAgICAgICAgIGJyZWFrOwotI2VsaWYgUExB VEZPUk0oR1RLKQotICAgICAgICAgICAqcmVpbnRlcnByZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVl KSA9IEdES19ESVNQTEFZX1hESVNQTEFZKGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOwotICAg ICAgICAgICBicmVhazsKLSNlbHNlCi0gICAgICAgICAgIGdvdG8gZGVmYXVsdDsKLSNlbmRpZgog ICAgICAgIH0KICAgICAgICBjYXNlIE5QTlZTdXBwb3J0c1hFbWJlZEJvb2w6CiAgICAgICAgICAg ICpzdGF0aWNfY2FzdDxOUEJvb2wqPih2YWx1ZSkgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlUGx1Z2luLmggYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4u aAppbmRleCA4YjYzNmJlMDAyMjM0OGRlNzY4NzJlY2RhMDVmNWQ1N2JjNTQzYmZjLi4xOWE2Zjdk ODU3OTQ3YWIyMDhiZjQ3Nzk3ZDM0ZjQxODBlODM4ZTU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4uaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVQbHVnaW4u aApAQCAtMzQxLDYgKzM0MSw5IEBAIHByaXZhdGU6CiAjZWxpZiBQTFVHSU5fQVJDSElURUNUVVJF KFgxMSkKICAgICBQaXhtYXAgbV9kcmF3YWJsZTsKICAgICBEaXNwbGF5KiBtX3BsdWdpbkRpc3Bs YXk7CisKK3B1YmxpYzogLy8gTmVlZCB0byBjYWxsIGl0IGluIHRoZSBOUE5fR2V0VmFsdWUgYnJv d3NlciBjYWxsYmFjay4KKyAgICBzdGF0aWMgRGlzcGxheSogcGx1Z2luRGlzcGxheSgpOwogI2Vu ZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1BsdWdpbnMv TmV0c2NhcGUveDExL05ldHNjYXBlUGx1Z2luWDExLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVnaW5YMTEuY3BwCmluZGV4IGZj OTRmNjNiMWMxYWMyMzQ2MWU0ZGVkYzU2NjBkNzUyODlkMjdhYWIuLmQ2NzNiMjRmYTNhZDcwOWYx ZTI3MzMxNGQzNTM3YWFmYzMxOThiYTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVnaW5YMTEuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQbHVn aW5YMTEuY3BwCkBAIC0zNCwxMCArMzQsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvTm90SW1wbGVt ZW50ZWQuaD4KIAogI2lmIFBMQVRGT1JNKFFUKQotI2luY2x1ZGUgPFFBcHBsaWNhdGlvbj4KLSNp bmNsdWRlIDxRRGVza3RvcFdpZGdldD4KLSNpbmNsdWRlIDxRUGl4bWFwPgotI2luY2x1ZGUgPFFY MTFJbmZvPgorI2luY2x1ZGUgPFdlYkNvcmUvUXRYMTFJbWFnZUNvbnZlcnNpb24uaD4KICNlbGlm IFBMQVRGT1JNKEdUSykKICNpbmNsdWRlICJQbGF0Zm9ybUNvbnRleHRDYWlyby5oIgogI2luY2x1 ZGUgIlJlZlB0ckNhaXJvLmgiCkBAIC01MCw3ICs0Nyw3IEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAotc3RhdGljIERpc3BsYXkgKmdldFBsdWdpbkRp c3BsYXkoKQorc3RhdGljIERpc3BsYXkqIGdldFBsdWdpbkRpc3BsYXkoKQogewogI2lmIFBMQVRG T1JNKFFUKQogICAgIC8vIEF0IHRoZSBtb21lbnQsIHdlIG9ubHkgc3VwcG9ydCBnZGsgYmFzZWQg cGx1Z2lucyAobGlrZSBGbGFzaCkgdGhhdCB1c2UgYSBkaWZmZXJlbnQgWCBjb25uZWN0aW9uLgpA QCAtODcsMTIgKzg0LDEyIEBAIHN0YXRpYyBEaXNwbGF5ICpnZXRQbHVnaW5EaXNwbGF5KCkKICNl bmRpZgogfQogCi1zdGF0aWMgaW5saW5lIERpc3BsYXkqIHgxMURpc3BsYXkoKQorc3RhdGljIGlu bGluZSBpbnQgeDExU2NyZWVuKCkKIHsKICNpZiBQTEFURk9STShRVCkKLSAgICByZXR1cm4gUVgx MUluZm86OmRpc3BsYXkoKTsKKyAgICByZXR1cm4gWERlZmF1bHRTY3JlZW4oTmV0c2NhcGVQbHVn aW46OnBsdWdpbkRpc3BsYXkoKSk7CiAjZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0dXJuIEdE S19ESVNQTEFZX1hESVNQTEFZKGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworICAgIHJldHVy biBnZGtfc2NyZWVuX2dldF9udW1iZXIoZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgpKTsKICNlbHNl CiAgICAgcmV0dXJuIDA7CiAjZW5kaWYKQEAgLTEwMSw3ICs5OCw3IEBAIHN0YXRpYyBpbmxpbmUg RGlzcGxheSogeDExRGlzcGxheSgpCiBzdGF0aWMgaW5saW5lIGludCBkaXNwbGF5RGVwdGgoKQog ewogI2lmIFBMQVRGT1JNKFFUKQotICAgIHJldHVybiBRQXBwbGljYXRpb246OmRlc2t0b3AoKS0+ eDExSW5mbygpLmRlcHRoKCk7CisgICAgcmV0dXJuIFhEZWZhdWx0RGVwdGgoTmV0c2NhcGVQbHVn aW46OnBsdWdpbkRpc3BsYXkoKSwgeDExU2NyZWVuKCkpOwogI2VsaWYgUExBVEZPUk0oR1RLKQog ICAgIHJldHVybiBnZGtfdmlzdWFsX2dldF9kZXB0aChnZGtfc2NyZWVuX2dldF9zeXN0ZW1fdmlz dWFsKGdka19zY3JlZW5fZ2V0X2RlZmF1bHQoKSkpOwogI2Vsc2UKQEAgLTExMiw3ICsxMDksNyBA QCBzdGF0aWMgaW5saW5lIGludCBkaXNwbGF5RGVwdGgoKQogc3RhdGljIGlubGluZSB1bnNpZ25l ZCBsb25nIHJvb3RXaW5kb3dJRCgpCiB7CiAjaWYgUExBVEZPUk0oUVQpCi0gICAgcmV0dXJuIFFY MTFJbmZvOjphcHBSb290V2luZG93KCk7CisgICAgcmV0dXJuIFhEZWZhdWx0Um9vdFdpbmRvdyhO ZXRzY2FwZVBsdWdpbjo6cGx1Z2luRGlzcGxheSgpKTsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAg ICByZXR1cm4gR0RLX1JPT1RfV0lORE9XKCk7CiAjZWxzZQpAQCAtMTIwLDE3ICsxMTcsNiBAQCBz dGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgcm9vdFdpbmRvd0lEKCkKICNlbmRpZgogfQogCi1z dGF0aWMgaW5saW5lIGludCB4MTFTY3JlZW4oKQotewotI2lmIFBMQVRGT1JNKFFUKQotICAgIHJl dHVybiBRWDExSW5mbzo6YXBwU2NyZWVuKCk7Ci0jZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0 dXJuIGdka19zY3JlZW5fZ2V0X251bWJlcihnZGtfc2NyZWVuX2dldF9kZWZhdWx0KCkpOwotI2Vs c2UKLSAgICByZXR1cm4gMDsKLSNlbmRpZgotfQotCiAjaWYgUExBVEZPUk0oR1RLKQogc3RhdGlj IGJvb2wgbW9kdWxlTWl4ZXNHdGtTeW1ib2xzKE1vZHVsZSogbW9kdWxlKQogewpAQCAtMTQyLDYg KzEyOCwyMiBAQCBzdGF0aWMgYm9vbCBtb2R1bGVNaXhlc0d0a1N5bWJvbHMoTW9kdWxlKiBtb2R1 bGUpCiB9CiAjZW5kaWYKIAorRGlzcGxheSogTmV0c2NhcGVQbHVnaW46OnBsdWdpbkRpc3BsYXko KQoreworI2lmIFBMQVRGT1JNKFFUKQorICAgIHN0YXRpYyBEaXNwbGF5KiBkZWRpY2F0ZWRQbHVn aW5EaXNwbGF5ID0gMDsKKyAgICBpZiAoIWRlZGljYXRlZFBsdWdpbkRpc3BsYXkpCisgICAgICAg IGRlZGljYXRlZFBsdWdpbkRpc3BsYXkgPSBYT3BlbkRpc3BsYXkoMCk7CisKKyAgICBBU1NFUlQo ZGVkaWNhdGVkUGx1Z2luRGlzcGxheSk7CisgICAgcmV0dXJuIGRlZGljYXRlZFBsdWdpbkRpc3Bs YXk7CisjZWxpZiBQTEFURk9STShHVEspCisgICAgcmV0dXJuIEdES19ESVNQTEFZX1hESVNQTEFZ KGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworI2Vsc2UKKyAgICByZXR1cm4gMDsKKyNlbmRp ZgorfQorCiBib29sIE5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9ybVBvc3RJbml0aWFsaXplKCkKIHsK ICNpZiBQTEFURk9STShHVEspCkBAIC0xNTcsOCArMTU5LDExIEBAIGJvb2wgTmV0c2NhcGVQbHVn aW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUoKQogCiAgICAgTlBTZXRXaW5kb3dDYWxsYmFja1N0 cnVjdCogY2FsbGJhY2tTdHJ1Y3QgPSBuZXcgTlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdDsKICAg ICBjYWxsYmFja1N0cnVjdC0+dHlwZSA9IDA7Ci0gICAgRGlzcGxheSogZGlzcGxheSA9IHgxMURp c3BsYXkoKTsKKyAgICBEaXNwbGF5KiBkaXNwbGF5ID0gcGx1Z2luRGlzcGxheSgpOwogICAgIGlu dCBkZXB0aCA9IGRpc3BsYXlEZXB0aCgpOworI2lmIFBMQVRGT1JNKFFUKQorICAgIEFTU0VSVChk ZXB0aCA9PSAxNiB8fCBkZXB0aCA9PSAyNCB8fCBkZXB0aCA9PSAzMik7CisjZW5kaWYKICAgICBj YWxsYmFja1N0cnVjdC0+ZGlzcGxheSA9IGRpc3BsYXk7CiAgICAgY2FsbGJhY2tTdHJ1Y3QtPmRl cHRoID0gZGVwdGg7CiAKQEAgLTE5MSw3ICsxOTYsNyBAQCB2b2lkIE5ldHNjYXBlUGx1Z2luOjpw bGF0Zm9ybURlc3Ryb3koKQogICAgIGRlbGV0ZSBzdGF0aWNfY2FzdDxOUFNldFdpbmRvd0NhbGxi YWNrU3RydWN0Kj4obV9ucFdpbmRvdy53c19pbmZvKTsKIAogICAgIGlmIChtX2RyYXdhYmxlKSB7 Ci0gICAgICAgIFhGcmVlUGl4bWFwKHgxMURpc3BsYXkoKSwgbV9kcmF3YWJsZSk7CisgICAgICAg IFhGcmVlUGl4bWFwKHBsdWdpbkRpc3BsYXkoKSwgbV9kcmF3YWJsZSk7CiAgICAgICAgIG1fZHJh d2FibGUgPSAwOwogICAgIH0KIH0KQEAgLTIwOSw3ICsyMTQsNyBAQCB2b2lkIE5ldHNjYXBlUGx1 Z2luOjpwbGF0Zm9ybUdlb21ldHJ5RGlkQ2hhbmdlKCkKICAgICAgICAgcmV0dXJuOwogICAgIH0K IAotICAgIERpc3BsYXkqIGRpc3BsYXkgPSB4MTFEaXNwbGF5KCk7CisgICAgRGlzcGxheSogZGlz cGxheSA9IHBsdWdpbkRpc3BsYXkoKTsKICAgICBpZiAobV9kcmF3YWJsZSkKICAgICAgICAgWEZy ZWVQaXhtYXAoZGlzcGxheSwgbV9kcmF3YWJsZSk7CiAKQEAgLTI0MywxNyArMjQ4LDExIEBAIHZv aWQgTmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0 LCBjb25zdCBJbnRSZWN0JiBkaXJ0CiAgICAgaWYgKGNvbnRleHQtPnBhaW50aW5nRGlzYWJsZWQo KSB8fCAhbV9kcmF3YWJsZSkKICAgICAgICAgcmV0dXJuOwogCi0jaWYgUExBVEZPUk0oUVQpCi0j ZWxpZiAhUExBVEZPUk0oR1RLKQotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuOwot I2VuZGlmCi0KICAgICBYRXZlbnQgeGV2ZW50OwogICAgIG1lbXNldCgmeGV2ZW50LCAwLCBzaXpl b2YoWEV2ZW50KSk7CiAgICAgWEdyYXBoaWNzRXhwb3NlRXZlbnQmIGV4cG9zZUV2ZW50ID0geGV2 ZW50LnhncmFwaGljc2V4cG9zZTsKICAgICBleHBvc2VFdmVudC50eXBlID0gR3JhcGhpY3NFeHBv c2U7Ci0gICAgZXhwb3NlRXZlbnQuZGlzcGxheSA9IHgxMURpc3BsYXkoKTsKKyAgICBleHBvc2VF dmVudC5kaXNwbGF5ID0gcGx1Z2luRGlzcGxheSgpOwogICAgIGV4cG9zZUV2ZW50LmRyYXdhYmxl ID0gbV9kcmF3YWJsZTsKIAogICAgIEludFJlY3QgZXhwb3NlZFJlY3QoZGlydHlSZWN0KTsKQEAg LTI2NywxNCArMjY2LDE5IEBAIHZvaWQgTmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3Jh cGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiBkaXJ0CiAKICAgICBOUFBfSGFu ZGxlRXZlbnQoJnhldmVudCk7CiAKLSAgICBpZiAobV9wbHVnaW5EaXNwbGF5ICE9IHgxMURpc3Bs YXkoKSkKKyAgICBpZiAobV9wbHVnaW5EaXNwbGF5ICE9IHBsdWdpbkRpc3BsYXkoKSkKICAgICAg ICAgWFN5bmMobV9wbHVnaW5EaXNwbGF5LCBmYWxzZSk7CiAKICNpZiBQTEFURk9STShRVCkKLSAg ICBRUGl4bWFwIHF0RHJhd2FibGUgPSBRUGl4bWFwOjpmcm9tWDExUGl4bWFwKG1fZHJhd2FibGUs IFFQaXhtYXA6OkV4cGxpY2l0bHlTaGFyZWQpOwotICAgIEFTU0VSVChxdERyYXdhYmxlLmRlcHRo KCkgPT0gc3RhdGljX2Nhc3Q8TlBTZXRXaW5kb3dDYWxsYmFja1N0cnVjdCo+KG1fbnBXaW5kb3cu d3NfaW5mbyktPmRlcHRoKTsKKyAgICBYSW1hZ2UqIHhJbWFnZSA9IFhHZXRJbWFnZShOZXRzY2Fw ZVBsdWdpbjo6cGx1Z2luRGlzcGxheSgpLCBtX2RyYXdhYmxlLCBleHBvc2VkUmVjdC54KCksIGV4 cG9zZWRSZWN0LnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBvc2VkUmVj dC53aWR0aCgpLCBleHBvc2VkUmVjdC5oZWlnaHQoKSwgVUxPTkdfTUFYLCBaUGl4bWFwKTsKKyAg ICBRSW1hZ2UgaW1hZ2UgPSBxaW1hZ2VGcm9tWEltYWdlKHhJbWFnZSk7CisKICAgICBRUGFpbnRl ciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29udGV4dCgpOwotICAgIHBhaW50ZXItPmRy YXdQaXhtYXAoUVBvaW50KGV4cG9zZWRSZWN0LngoKSwgZXhwb3NlZFJlY3QueSgpKSwgcXREcmF3 YWJsZSwgZXhwb3NlZFJlY3QpOworICAgIHBhaW50ZXItPmRyYXdJbWFnZShRUG9pbnQoZXhwb3Nl ZFJlY3QueCgpLCBleHBvc2VkUmVjdC55KCkpLCBpbWFnZSwgZXhwb3NlZFJlY3QpOworCisgICAg aW1hZ2UgPSBRSW1hZ2UoKTsKKyAgICBYRGVzdHJveUltYWdlKHhJbWFnZSk7CiAjZWxpZiBQTEFU Rk9STShHVEspCiAgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gZHJhd2FibGVTdXJmYWNlID0g YWRvcHRSZWYoY2Fpcm9feGxpYl9zdXJmYWNlX2NyZWF0ZShtX3BsdWdpbkRpc3BsYXksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBtX2RyYXdhYmxlLApAQCAtMjkyLDYgKzI5Niw4IEBAIHZvaWQg TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBj b25zdCBJbnRSZWN0JiBkaXJ0CiAgICAgY2Fpcm9fcGFpbnQoY3IpOwogCiAgICAgY2Fpcm9fcmVz dG9yZShjcik7CisjZWxzZQorICAgIG5vdEltcGxlbWVudGVkKCk7CiAjZW5kaWYKIH0KIApAQCAt MzAwLDcgKzMwNiw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpbml0aWFsaXplWEV2ZW50KFhFdmVu dCYgZXZlbnQpCiAgICAgbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKFhFdmVudCkpOwogICAgIGV2 ZW50Lnhhbnkuc2VyaWFsID0gMDsKICAgICBldmVudC54YW55LnNlbmRfZXZlbnQgPSBmYWxzZTsK LSAgICBldmVudC54YW55LmRpc3BsYXkgPSB4MTFEaXNwbGF5KCk7CisgICAgZXZlbnQueGFueS5k aXNwbGF5ID0gTmV0c2NhcGVQbHVnaW46OnBsdWdpbkRpc3BsYXkoKTsKICAgICBldmVudC54YW55 LndpbmRvdyA9IDA7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9hcGkucHJpIGIvU291cmNlL2Fw aS5wcmkKaW5kZXggYjJlZGRiNDNiODJkOWIxM2QyMGRhYjZhMWYxYjljNzM3NTlmNjcwZi4uNjA5 ZmNkZmQyZTZiNTRhMTBkZjU5ODA3ODdmMGZhNWRiOGRkYTE4YyAxMDA2NDQKLS0tIGEvU291cmNl L2FwaS5wcmkKKysrIGIvU291cmNlL2FwaS5wcmkKQEAgLTIyMiwzICsyMjIsNyBAQCBtYWMgewog ICAgIFFNQUtFX0xGTEFHU19TT05BTUUgPSAiJCR7UU1BS0VfTEZMQUdTX1NPTkFNRX0kJHtERVNU RElSfSQke1FNQUtFX0RJUl9TRVB9IgogfQogCitwbHVnaW5fYmFja2VuZF94bGliIHsKKyAgICBD T05GSUcgKj0gbGlua19wa2djb25maWcKKyAgICBQS0dDT05GSUcgKz0geDExCit9CmRpZmYgLS1n aXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZWM3MmNkZjEwN2Rl OGNiMzc0M2MxM2E4YzBmYTdlOGMxNzcxYWVmMi4uZGE5ODZjODcxMzNkNjM0NTFlMzMwYTY5MTU5 YTVlMjViZDUyZTkxYiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0No YW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDExLTExLTA4ICBCYWxhenMgS2VsZW1lbiAgPGti YWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBwbHVnaW5zIG5lZWQgdG8gYmUg cmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBSZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBwb3J0IGluIGEgd2F5IHRoYXQgZG9l cworICAgICAgICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVuIFF0IGFuZCBYLiBUaGUgc29sdXRp b24gaXMKKyAgICAgICAgYmFzZWQgb24gZ2V0dGluZyB0aGUgY29udGVudCBkcmF3ZWQgYnkgdGhl IHBsdWdpbgorICAgICAgICBmcm9tIHRoZSBzZXJ2ZXIgYXMgYW4gaW1hZ2UgYW5kIGNyZWF0aW5n IGEgUUltYWdlCisgICAgICAgIGZyb20gaXQuCisKKyAgICAgICAgKiBxbWFrZS9ta3NwZWNzL2Zl YXR1cmVzL2ZlYXR1cmVzLnByZjogRW5hYmxlIFgxMQorICAgICAgICBwbHVnaW5zIGlmIFF0IGlz IGJ1aWx0IHdpdGggdGhlIHhjYi14bGliIGJhY2tlbmQuCisKIDIwMTEtMTEtMDggIFRvciBBcm5l IFZlc3Riw7ggIDx0b3IuYXJuZS52ZXN0Ym9Abm9raWEuY29tPgogCiAgICAgICAgIFtRdF0gUHJl dmVudCBkdXBsaWNhdGVkIHNvdXJjZXMgaW4gU09VUkNFUy9PQkpFQ1RJVkVfU09VUkNFUwpkaWZm IC0tZ2l0IGEvVG9vbHMvcW1ha2UvbWtzcGVjcy9mZWF0dXJlcy9mZWF0dXJlcy5wcmYgYi9Ub29s cy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnByZgppbmRleCA5YTNkMGZhZmFmMjJi NzRmMjkwMWMyZWFiZjBhMDlmYmU4MTJkYjFhLi41ZDQ4YzQzYjYzZTU2ODY5OGJhYzkxODM0NmNj YjZkMzgwOGFjMTFmIDEwMDY0NAotLS0gYS9Ub29scy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2Zl YXR1cmVzLnByZgorKysgYi9Ub29scy9xbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnBy ZgpAQCAtODksMTMgKzg5LDI4IEBAIGlzRW1wdHkoSEFWRV9RUkFXRk9OVCkgewogCiAjIE5lc2Nh cGUgcGx1Z2lucyBzdXBwb3J0IChOUEFQSSkKICFjb250YWlucyhERUZJTkVTLCBFTkFCTEVfTkVU U0NBUEVfUExVR0lOX0FQST0uKSB7Ci0gICAgdW5peDohaGF2ZVF0KDUpfHdpbjMyLSo6IWVtYmVk ZGVkOiF3aW5jZSo6IHsKLSAgICAgICAgREVGSU5FUyArPSBFTkFCTEVfTkVUU0NBUEVfUExVR0lO X0FQST0xCisgICAgIWhhdmVRdCg1KTogeworICAgICAgICB1bml4fHdpbjMyLSo6IWVtYmVkZGVk OiF3aW5jZSo6IHsKKyAgICAgICAgICAgIERFRklORVMgKz0gRU5BQkxFX05FVFNDQVBFX1BMVUdJ Tl9BUEk9MQorICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgREVGSU5FUyArPSBFTkFCTEVf TkVUU0NBUEVfUExVR0lOX0FQST0wCisgICAgICAgIH0KICAgICB9IGVsc2UgewogICAgICAgICBE RUZJTkVTICs9IEVOQUJMRV9ORVRTQ0FQRV9QTFVHSU5fQVBJPTAKICAgICB9CiB9CiAKKyMgTmV0 c2NhcGUgcGx1Z2lucyBzdXBwb3J0IGZvciBXZWJLaXQyCishbm9fd2Via2l0MjohY29udGFpbnMo REVGSU5FUywgUExVR0lOX0FSQ0hJVEVDVFVSRV9VTlNVUFBPUlRFRCk6IHsKKyAgICBjb250YWlu cyhRVF9DT05GSUcsIHhjYi14bGliKSB7CisgICAgICAgIENPTkZJRyArPSBwbHVnaW5fYmFja2Vu ZF94bGliCisgICAgICAgIERFRklORVMgKz0gUExVR0lOX0FSQ0hJVEVDVFVSRV9YMTE9MSBcCisg ICAgICAgICAgICAgICAgICAgUExVR0lOX0FSQ0hJVEVDVFVSRV9VTlNVUFBPUlRFRD0wCisgICAg fSBlbHNlIHsKKyAgICAgICAgREVGSU5FUyArPSBQTFVHSU5fQVJDSElURUNUVVJFX1VOU1VQUE9S VEVEPTEKKyAgICB9Cit9CisKICMgV2ViR0wgc3VwcG9ydAogY29udGFpbnMoUVRfQ09ORklHLCBv cGVuZ2wpOiF3aW4zMi0qIHsKICAgICAhY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQkdMPS4p OiBERUZJTkVTICs9IEVOQUJMRV9XRUJHTD0xCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFu Z2VMb2cKaW5kZXggNGNiZTZkZGI2NGM5YTM1MDdhYTZkZTVhODUxOThjYTM1YjkyYzcxYi4uNzY4 NjYyMGJhZWFmNmMyOWE4MzYxN2RiYjI5YTk0NTVlY2RlY2M2YiAxMDA2NDQKLS0tIGEvQ2hhbmdl TG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDExLTExLTA4ICBCYWxhenMg S2VsZW1lbiAgPGtiYWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgxMSBwbHVnaW5z IG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBSZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBwb3J0IGluIGEg d2F5IHRoYXQgZG9lcworICAgICAgICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVuIFF0IGFuZCBY LiBUaGUgc29sdXRpb24gaXMKKyAgICAgICAgYmFzZWQgb24gZ2V0dGluZyB0aGUgY29udGVudCBk cmF3ZWQgYnkgdGhlIHBsdWdpbgorICAgICAgICBmcm9tIHRoZSBzZXJ2ZXIgYXMgYW4gaW1hZ2Ug YW5kIGNyZWF0aW5nIGEgUUltYWdlCisgICAgICAgIGZyb20gaXQuCisKKyAgICAgICAgKiBTb3Vy Y2UvYXBpLnByaTogTGluayB0byB4bGliIGlmIG5lY2Vzc2FyeS4KKwogMjAxMS0xMS0wOCAgWXVx aWFuZyBYaWFuICA8eXVxaWFuZy54aWFuQGludGVsLmNvbT4KIAogICAgICAgICBFbmFibGUgREZH IEpJVCBieSBkZWZhdWx0IG9uIFg4NiBMaW51eCBhbmQgTWFjIHBsYXRmb3Jtcwo= 114494 2011-11-10 07:11:26 -0800 2011-11-10 09:32:41 -0800 wk2 plugins v3 bug-70023-20111110161124.patch text/plain 22448 kbalazs U3VidmVyc2lvbiBSZXZpc2lvbjogOTk4NDgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBkMzQ2NThjNzg3MDZjYjM2 YzdmNDc0NWVjNzI0MDFhNmVhMTkwYjU3Li4xMGI1YzQyNWFhOTJlMGEyYjZiODJhOWU1MjFkNGIy NDUxZDk4ODljIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTEtMTEtMDggIEJhbGF6 cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gWDExIHBsdWdp bnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIgYmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4g YSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVkIGEgYnJpZGdlIGJldHdlZW4gUXQgYW5k IFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNlZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50 IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZyb20gdGhlIHNlcnZlciBhcyBhbiBpbWFn ZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAgZnJvbSBpdC4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIEV4aXN0aW5nIHBsdWdpbiB0ZXN0IGFyZSBzdWZmaWNpZW50LgorCisgICAgICAg ICogVGFyZ2V0LnByaToKKyAgICAgICAgKiBicmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmg6IEFk ZGVkIHlldCBhbm90aGVyIHVuZGVmCisgICAgICAgIHRvIGZpeCBidWlsZCB3aXRoIFF0NSArIFgx MSBoZWFkZXJzLgorICAgICAgICAqIHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OnFpbWFnZUZyb21YSW1hZ2UpOgorICAgICAgICAq IHBsdWdpbnMvcXQvUXRYMTFJbWFnZUNvbnZlcnNpb24uaDogQWRkZWQuCisgICAgICAgIEFkZGVk IGEgaGVscGVyIGZ1bmN0aW9uIHRvIGNyZWF0ZSBhIFFJbWFnZSBmcm9tIGFuIFhJbWFnZS4KKyAg ICAgICAgUHV0IGl0IGluIGEgbmV3IGZpbGUgaW50byBXZWJDb3JlIHRvIGF2b2lkIGNvcHlyaWdo dCBpc3N1ZXMgLSBhcworICAgICAgICB0aGUgY29kZSBoYXMgYmVlbiB0YWtlbiBkaXJlY3RseSBm cm9tIFF0IC0gYW5kIHRvIGJlIGFibGUgdG8gcmVzdXNlCisgICAgICAgIGl0IGZvciB0aGUgV0sx IHBsdWdpbiBzdXBwb3J0IGluIHRoZSBmdXR1cmUuCisKIDIwMTEtMTEtMTAgIEFsZXhhbmRlciBQ YXZsb3YgIDxhcGF2bG92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBb U3VnZ2VzdEJveF0gRG8gbm90IGRpc3BsYXkgc3VnZ2VzdCBib3ggaWYgZWRpdGluZyBpbiB0aGUg bWlkZGxlIG9mIHByb21wdCB1bmxlc3MgYSBzdG9wIGNoYXJhY3RlciBmb2xsb3dzCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cK aW5kZXggZWQ4ZTY5MmExODNlYTEzYmZlNzI2MmU2Yjk3NTU4MTRlOWFiNDY5NC4uY2EwNDJhNWM3 NmU2ZjU0YjYwZjJmZmIxYTBmY2U1NzRjMWVjNzUzYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0 IEBACisyMDExLTExLTA4ICBCYWxhenMgS2VsZW1lbiAgPGtiYWxhenNAd2Via2l0Lm9yZz4KKwor ICAgICAgICBbUXRdIFgxMSBwbHVnaW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRhcmdldC5wcmk6 CisgICAgICAgICogVUlQcm9jZXNzL1BsdWdpbnMvdW5peC9QbHVnaW5JbmZvU3RvcmVVbml4LmNw cDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2luSW5mb1N0b3JlOjpwbHVnaW5zRGlyZWN0b3JpZXMp OgorICAgICAgICBLaWxsIHRoZSBsYXN0IGRlcGVuZGVuY3kgZnJvbSB0aGUgV2ViS2l0MSBwbHVn aW4gc3lzdGVtLgorICAgICAgICBUaGlzIGlzIG5lY2Vzc2FyeSBiZWNhdXNlIGN1cnJlbnRseSB3 ZSBkb24ndCBidWlsZCB0aGUgV2ViS2l0MQorICAgICAgICBwbHVnaW4gY29kZS4gVGhlIGZ1bmN0 aW9uIGlzIGVxdWl2YWxlbnQgd2l0aCB0aGUgWFBfVU5JWCBwYXJ0IG9mCisgICAgICAgIFBsdWdp bkRhdGFiYXNlOjpkZWZhdWx0UGx1Z2luRGlyZWN0b3JpZXMuCisKKyAgICAgICAgKiBXZWJQcm9j ZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVCcm93c2VyRnVuY3MuY3BwOgorICAgICAgICAo V2ViS2l0OjpOUE5fR2V0VmFsdWUpOgorICAgICAgICAqIFdlYlByb2Nlc3MvUGx1Z2lucy9OZXRz Y2FwZS9OZXRzY2FwZVBsdWdpbi5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvUGx1Z2lucy9OZXRz Y2FwZS94MTEvTmV0c2NhcGVQbHVnaW5YMTEuY3BwOgorICAgICAgICAoV2ViS2l0OjpnZXRQbHVn aW5EaXNwbGF5KToKKyAgICAgICAgKFdlYktpdDo6eDExU2NyZWVuKToKKyAgICAgICAgKFdlYktp dDo6ZGlzcGxheURlcHRoKToKKyAgICAgICAgKFdlYktpdDo6cm9vdFdpbmRvd0lEKToKKyAgICAg ICAgKFdlYktpdDo6TmV0c2NhcGVQbHVnaW46OngxMUhvc3REaXNwbGF5KToKKyAgICAgICAgKFdl YktpdDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUpOgorICAgICAgICAo V2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1EZXN0cm95KToKKyAgICAgICAgKFdlYktp dDo6TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtR2VvbWV0cnlEaWRDaGFuZ2UpOgorICAgICAgICAo V2ViS2l0OjpOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1QYWludCk6CisgICAgICAgIChXZWJLaXQ6 OmluaXRpYWxpemVYRXZlbnQpOgorICAgICAgICBSZXdvcmsgcGx1Z2luIGluaXRpYWxpemF0aW9u IGFuZCBkcmF3aW5nIG1vZGVsLgorCiAyMDExLTExLTEwICBTaW1vbiBIYXVzbWFubiAgPHNpbW9u LmhhdXNtYW5uQG5va2lhLmNvbT4KIAogICAgICAgICBbUXRdIENsZWFuIHVwIGJ1aWxkIHN5c3Rl bQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaSBiL1NvdXJjZS9XZWJDb3Jl L1RhcmdldC5wcmkKaW5kZXggMWYwZjEzZGQxYzNiYzU1MWM3OTE2OWE2MDQwYTZiMDQyZWUzYzlh Ni4uY2ZiNDFlOTY2ZTdjMzdiNTc4YTQ1NmM4MTFjMWJjZmE3ZGQ1YzU4MiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJp CkBAIC0yODY0LDYgKzI4NjQsMTEgQEAgY29udGFpbnMoREVGSU5FUywgRU5BQkxFX05FVFNDQVBF X1BMVUdJTl9BUEk9MSkgewogICAgICAgICBwbHVnaW5zL1BsdWdpblZpZXdOb25lLmNwcAogfQog CitwbHVnaW5fYmFja2VuZF94bGliIHsKKyAgICBTT1VSQ0VTICs9IHBsdWdpbnMvcXQvUXRYMTFJ bWFnZUNvbnZlcnNpb24uY3BwCisgICAgSEVBREVSUyArPSBwbHVnaW5zL3F0L1F0WDExSW1hZ2VD b252ZXJzaW9uLmgKK30KKwogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1NRTF9EQVRBQkFTRT0x KSB7CiAgICAgU09VUkNFUyArPSBcCiAgICAgICAgIHN0b3JhZ2UvQ2hhbmdlVmVyc2lvbldyYXBw ZXIuY3BwIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JyaWRnZS9ucHJ1bnRpbWVfaW50 ZXJuYWwuaCBiL1NvdXJjZS9XZWJDb3JlL2JyaWRnZS9ucHJ1bnRpbWVfaW50ZXJuYWwuaAppbmRl eCAyZDdkYzA2MjYxN2YxODVhYjFjMTYzOTA2NDBhMTBiMTg3YTQwNDc5Li42MjNjNDc1OWJjYzBm OWI4MTBkNTQwNTliNjY1YWUxMWExZWJiYjQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9i cmlkZ2UvbnBydW50aW1lX2ludGVybmFsLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYnJpZGdlL25w cnVudGltZV9pbnRlcm5hbC5oCkBAIC01MSw0ICs1MSw1IEBACiAgICAgI3VuZGVmIFRydWUKICAg ICAjdW5kZWYgRmFsc2UKICAgICAjdW5kZWYgU3VjY2VzcworICAgICN1bmRlZiBFeHBvc2UKICNl bmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGx1Z2lucy9xdC9RdFgxMUltYWdlQ29u dmVyc2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJz aW9uLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4wYTc2ZmUyMzk4NTE0YTNmMmNmYjY4NGI1NDcxYjQ3Y2JmYzk4 MWUzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGx1Z2lucy9xdC9RdFgxMUlt YWdlQ29udmVyc2lvbi5jcHAKQEAgLTAsMCArMSw3MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMSBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBw cm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJRdFgxMUltYWdlQ29udmVyc2lvbi5oIgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK1FJbWFnZSBxaW1hZ2VGcm9tWEltYWdlKFhJbWFnZSogeGkp Cit7CisgICAgUUltYWdlOjpGb3JtYXQgZm9ybWF0ID0gUUltYWdlOjpGb3JtYXRfQVJHQjMyX1By ZW11bHRpcGxpZWQ7CisgICAgaWYgKHhpLT5kZXB0aCA9PSAyNCkKKyAgICAgICAgZm9ybWF0ID0g UUltYWdlOjpGb3JtYXRfUkdCMzI7CisgICAgZWxzZSBpZiAoeGktPmRlcHRoID09IDE2KQorICAg ICAgICBmb3JtYXQgPSBRSW1hZ2U6OkZvcm1hdF9SR0IxNjsKKworICAgIFFJbWFnZSBpbWFnZSA9 IFFJbWFnZShyZWludGVycHJldF9jYXN0PHVjaGFyKj4oeGktPmRhdGEpLCB4aS0+d2lkdGgsIHhp LT5oZWlnaHQsIHhpLT5ieXRlc19wZXJfbGluZSwgZm9ybWF0KS5jb3B5KCk7CisKKyAgICAvLyB3 ZSBtYXkgaGF2ZSB0byBzd2FwIHRoZSBieXRlIG9yZGVyCisgICAgaWYgKChRU3lzSW5mbzo6Qnl0 ZU9yZGVyID09IFFTeXNJbmZvOjpMaXR0bGVFbmRpYW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTVNC Rmlyc3QpCisgICAgICAgIHx8IChRU3lzSW5mbzo6Qnl0ZU9yZGVyID09IFFTeXNJbmZvOjpCaWdF bmRpYW4gJiYgeGktPmJ5dGVfb3JkZXIgPT0gTFNCRmlyc3QpKSB7CisKKyAgICAgICAgZm9yIChp bnQgaSA9IDA7IGkgPCBpbWFnZS5oZWlnaHQoKTsgaSsrKSB7CisgICAgICAgICAgICBpZiAoeGkt PmRlcHRoID09IDE2KSB7CisgICAgICAgICAgICAgICAgdXNob3J0KiBwID0gcmVpbnRlcnByZXRf Y2FzdDx1c2hvcnQqPihpbWFnZS5zY2FuTGluZShpKSk7CisgICAgICAgICAgICAgICAgdXNob3J0 KiBlbmQgPSBwICsgaW1hZ2Uud2lkdGgoKTsKKyAgICAgICAgICAgICAgICB3aGlsZSAocCA8IGVu ZCkgeworICAgICAgICAgICAgICAgICAgICAqcCA9ICgoKnAgPDwgOCkgJiAweGZmMDApIHwgKCgq cCA+PiA4KSAmIDB4MDBmZik7CisgICAgICAgICAgICAgICAgICAgIHArKzsKKyAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIHVpbnQqIHAgPSBy ZWludGVycHJldF9jYXN0PHVpbnQqPihpbWFnZS5zY2FuTGluZShpKSk7CisgICAgICAgICAgICAg ICAgdWludCogZW5kID0gcCArIGltYWdlLndpZHRoKCk7CisgICAgICAgICAgICAgICAgd2hpbGUg KHAgPCBlbmQpIHsKKyAgICAgICAgICAgICAgICAgICAgKnAgPSAoKCpwIDw8IDI0KSAmIDB4ZmYw MDAwMDApIHwgKCgqcCA8PCA4KSAmIDB4MDBmZjAwMDApCisgICAgICAgICAgICAgICAgICAgICAg ICAgfCAoKCpwID4+IDgpICYgMHgwMDAwZmYwMCkgfCAoKCpwID4+IDI0KSAmIDB4MDAwMDAwZmYp OworICAgICAgICAgICAgICAgICAgICBwKys7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgLy8gZml4LXVwIGFscGhhIGNoYW5uZWwKKyAg ICBpZiAoZm9ybWF0ID09IFFJbWFnZTo6Rm9ybWF0X1JHQjMyKSB7CisgICAgICAgIFFSZ2IqIHAg PSByZWludGVycHJldF9jYXN0PFFSZ2IqPihpbWFnZS5iaXRzKCkpOworICAgICAgICBmb3IgKGlu dCB5ID0gMDsgeSA8IHhpLT5oZWlnaHQ7ICsreSkgeworICAgICAgICAgICAgZm9yIChpbnQgeCA9 IDA7IHggPCB4aS0+d2lkdGg7ICsreCkKKyAgICAgICAgICAgICAgICBwW3hdIHw9IDB4ZmYwMDAw MDA7CisgICAgICAgICAgICBwICs9IHhpLT5ieXRlc19wZXJfbGluZSAvIDQ7CisgICAgICAgIH0K KyAgICB9CisKKyAgICByZXR1cm4gaW1hZ2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lv bi5oIGIvU291cmNlL1dlYkNvcmUvcGx1Z2lucy9xdC9RdFgxMUltYWdlQ29udmVyc2lvbi5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjFhOTk5YTRjYTU0MjY5NGNhNmUwMmVkZmMwYTFiY2Y0Mzg1MGNjYTYKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbHVnaW5zL3F0L1F0WDExSW1hZ2VDb252ZXJz aW9uLmgKQEAgLTAsMCArMSwzMyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBOb2tpYSBD b3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv bjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgor ICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUg dGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgorICovCisKKyNpZm5kZWYgUXRYMTFJ bWFnZUNvbnZlcnNpb25faAorI2RlZmluZSBRdFgxMUltYWdlQ29udmVyc2lvbl9oCisKKyNpbmNs dWRlIDxRSW1hZ2U+CisjaW5jbHVkZSA8WDExL1hsaWIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitRSW1hZ2UgcWltYWdlRnJvbVhJbWFnZShYSW1hZ2UqKTsKKworfQorCisjZW5kaWYKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1RhcmdldC5wcmkgYi9Tb3VyY2UvV2ViS2l0Mi9UYXJn ZXQucHJpCmluZGV4IDlhN2NjNDFmYTdkMTM5ZWMwMWJiOTg2Nzc3OWMxMTllOGMyYzJlNmUuLjAx MDZiMWUyMTMwNTZmNjgyODI2MDM2M2RlMDEyMjQxNmE3Mzc4YWYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dlYktpdDIvVGFyZ2V0LnByaQpAQCAt NzQ0LDEwICs3NDQsNiBAQCBTT1VSQ0VTICs9IFwKICAgICBXZWJQcm9jZXNzL3F0L1dlYlByb2Nl c3NRdC5jcHAgXAogICAgICQkV0VCS0lUMl9HRU5FUkFURURfU09VUkNFUwogCi1jb250YWlucyhE RUZJTkVTLCBFTkFCTEVfTkVUU0NBUEVfUExVR0lOX0FQST0wKSB7Ci0gICAgREVGSU5FUyArPSBQ TFVHSU5fQVJDSElURUNUVVJFX1VOU1VQUE9SVEVECi19Ci0KIGNvbnRhaW5zKERFRklORVMsIEVO QUJMRV9UT1VDSF9FVkVOVFM9MSkgewogICAgIEhFQURFUlMgKz0gXAogICAgICAgICBTaGFyZWQv TmF0aXZlV2ViVG91Y2hFdmVudC5oCkBAIC03NTYsMyArNzUyLDcgQEAgY29udGFpbnMoREVGSU5F UywgRU5BQkxFX1RPVUNIX0VWRU5UUz0xKSB7CiB9CiAKIGNvbnRhaW5zKERFRklORVMsIEVOQUJM RV9HRU9MT0NBVElPTj0xKTogUVQgKz0gbG9jYXRpb24KKworcGx1Z2luX2JhY2tlbmRfeGxpYiB7 CisgICAgREVGSU5FUyArPSBYUF9VTklYCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3BwIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvdW5peC9QbHVnaW5JbmZvU3RvcmVVbml4LmNwcAppbmRl eCA4NWRjOGQ4MTI1Nzg5MjE4YzQ5MmI2MzU3ODFiYzY5MGQ3MmMyNjQwLi5jYWVjZjc5NDI0ZTJl YzZlZmJlMjBiNzAzOTAyNjE0NzZmMzA3NDcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvUGx1Z2lucy91bml4L1BsdWdpbkluZm9TdG9yZVVuaXguY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9QbHVnaW5zL3VuaXgvUGx1Z2luSW5mb1N0b3JlVW5peC5jcHAK QEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIk5ldHNjYXBlUGx1Z2luTW9kdWxlLmgiCiAj aW5jbHVkZSAiUGx1Z2luRGF0YWJhc2UuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0u aD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKQEAgLTM3LDcgKzM4LDQxIEBAIG5hbWVz cGFjZSBXZWJLaXQgewogCiBWZWN0b3I8U3RyaW5nPiBQbHVnaW5JbmZvU3RvcmU6OnBsdWdpbnNE aXJlY3RvcmllcygpCiB7Ci0gICAgcmV0dXJuIFBsdWdpbkRhdGFiYXNlOjpkZWZhdWx0UGx1Z2lu RGlyZWN0b3JpZXMoKTsKKyAgICBWZWN0b3I8U3RyaW5nPiByZXN1bHQ7CisKKyAgICByZXN1bHQu YXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkgKyAiLy5tb3ppbGxhL3BsdWdpbnMiKTsKKyAgICBy ZXN1bHQuYXBwZW5kKGhvbWVEaXJlY3RvcnlQYXRoKCkgKyAiLy5uZXRzY2FwZS9wbHVnaW5zIik7 CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvYnJvd3Nlci9wbHVnaW5zIik7CisgICAgcmVz dWx0LmFwcGVuZCgiL3Vzci9sb2NhbC9saWIvbW96aWxsYS9wbHVnaW5zIik7CisgICAgcmVzdWx0 LmFwcGVuZCgiL3Vzci9saWIvZmlyZWZveC9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgi L3Vzci9saWI2NC9icm93c2VyLXBsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xp Yi9icm93c2VyLXBsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYi9tb3ppbGxh L3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xvY2FsL25ldHNjYXBlL3BsdWdp bnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvb3B0L21vemlsbGEvcGx1Z2lucyIpOworICAgIHJl c3VsdC5hcHBlbmQoIi9vcHQvbW96aWxsYS9saWIvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBl bmQoIi9vcHQvbmV0c2NhcGUvcGx1Z2lucyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi9vcHQvbmV0 c2NhcGUvY29tbXVuaWNhdG9yL3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xp Yi9uZXRzY2FwZS9wbHVnaW5zIik7CisgICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWIvbmV0c2Nh cGUvcGx1Z2lucy1saWJjNSIpOworICAgIHJlc3VsdC5hcHBlbmQoIi91c3IvbGliL25ldHNjYXBl L3BsdWdpbnMtbGliYzYiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYjY0L25ldHNjYXBl L3BsdWdpbnMiKTsKKyAgICByZXN1bHQuYXBwZW5kKCIvdXNyL2xpYjY0L21vemlsbGEvcGx1Z2lu cyIpOworICAgIHJlc3VsdC5hcHBlbmQoIi91c3IvbGliL25zYnJvd3Nlci9wbHVnaW5zIik7Cisg ICAgcmVzdWx0LmFwcGVuZCgiL3Vzci9saWI2NC9uc2Jyb3dzZXIvcGx1Z2lucyIpOworCisgICAg U3RyaW5nIG1vemlsbGFIb21lKGdldGVudigiTU9aSUxMQV9IT01FIikpOworICAgIGlmICghbW96 aWxsYUhvbWUuaXNFbXB0eSgpKQorICAgICAgICByZXN1bHQuYXBwZW5kKG1vemlsbGFIb21lICsg Ii9wbHVnaW5zIik7CisKKyAgICBTdHJpbmcgbW96aWxsYVBhdGhzKGdldGVudigiTU9aX1BMVUdJ Tl9QQVRIIikpOworICAgIGlmICghbW96aWxsYVBhdGhzLmlzRW1wdHkoKSkgeworICAgICAgICBW ZWN0b3I8U3RyaW5nPiBwYXRoczsKKyAgICAgICAgbW96aWxsYVBhdGhzLnNwbGl0KFVDaGFyKCc6 JyksIC8qIGFsbG93RW1wdHlFbnRyaWVzICovIGZhbHNlLCBwYXRocyk7CisgICAgICAgIHJlc3Vs dC5hcHBlbmQocGF0aHMpOworICAgIH0KKworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIFZlY3Rv cjxTdHJpbmc+IFBsdWdpbkluZm9TdG9yZTo6cGx1Z2luUGF0aHNJbkRpcmVjdG9yeShjb25zdCBT dHJpbmcmIGRpcmVjdG9yeSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv UGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL1BsdWdpbnMvTmV0c2NhcGUvTmV0c2NhcGVCcm93c2VyRnVuY3MuY3BwCmlu ZGV4IDFlYzQzMzEzYWZkMmQyODk2M2Y0ZTNmNjQ2ZjdkMDg2MWUwZTZlZDcuLmE4YTgwNmUwMTlh ZTQ2Y2ZjMGE1OTBhZGY1MTI3MTZlZGM0MzVmMWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS9OZXRzY2FwZUJyb3dzZXJGdW5jcy5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlQnJv d3NlckZ1bmNzLmNwcApAQCAtMzYsMTQgKzM2LDYgQEAKICNpbmNsdWRlIDxXZWJDb3JlL1NoYXJl ZEJ1ZmZlci5oPgogI2luY2x1ZGUgPHV0aWxpdHk+CiAKLSNpZiBQTFVHSU5fQVJDSElURUNUVVJF KFgxMSkKLSNpZiBQTEFURk9STShRVCkKLSNpbmNsdWRlIDxRWDExSW5mbz4KLSNlbGlmIFBMQVRG T1JNKEdUSykKLSNpbmNsdWRlIDxnZGsvZ2RreC5oPgotI2VuZGlmCi0jZW5kaWYKLQogdXNpbmcg bmFtZXNwYWNlIFdlYkNvcmU7CiB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCkBAIC01MjcsMTUgKzUx OSw4IEBAIHN0YXRpYyBOUEVycm9yIE5QTl9HZXRWYWx1ZShOUFAgbnBwLCBOUE5WYXJpYWJsZSB2 YXJpYWJsZSwgdm9pZCAqdmFsdWUpCiAgICAgICAgY2FzZSBOUE5WeERpc3BsYXk6IHsKICAgICAg ICAgICAgaWYgKCFucHApCiAgICAgICAgICAgICAgICByZXR1cm4gTlBFUlJfR0VORVJJQ19FUlJP UjsKLSNpZiBQTEFURk9STShRVCkKLSAgICAgICAgICAgKnJlaW50ZXJwcmV0X2Nhc3Q8RGlzcGxh eSoqPih2YWx1ZSkgPSBRWDExSW5mbzo6ZGlzcGxheSgpOworICAgICAgICAgICAqcmVpbnRlcnBy ZXRfY2FzdDxEaXNwbGF5Kio+KHZhbHVlKSA9IE5ldHNjYXBlUGx1Z2luOjp4MTFIb3N0RGlzcGxh eSgpOwogICAgICAgICAgICBicmVhazsKLSNlbGlmIFBMQVRGT1JNKEdUSykKLSAgICAgICAgICAg KnJlaW50ZXJwcmV0X2Nhc3Q8RGlzcGxheSoqPih2YWx1ZSkgPSBHREtfRElTUExBWV9YRElTUExB WShnZGtfZGlzcGxheV9nZXRfZGVmYXVsdCgpKTsKLSAgICAgICAgICAgYnJlYWs7Ci0jZWxzZQot ICAgICAgICAgICBnb3RvIGRlZmF1bHQ7Ci0jZW5kaWYKICAgICAgICB9CiAgICAgICAgY2FzZSBO UE5WU3VwcG9ydHNYRW1iZWRCb29sOgogICAgICAgICAgICAqc3RhdGljX2Nhc3Q8TlBCb29sKj4o dmFsdWUpID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1 Z2lucy9OZXRzY2FwZS9OZXRzY2FwZVBsdWdpbi5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlUGx1Z2luLmgKaW5kZXggOGI2MzZiZTAwMjIzNDhk ZTc2ODcyZWNkYTA1ZjVkNTdiYzU0M2JmYy4uODQ1NDE4MjBjODYwNGM5ZTU4YWYxYzcxZjhkNzli YThkOWU4Mjg3YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5z L05ldHNjYXBlL05ldHNjYXBlUGx1Z2luLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9QbHVnaW5zL05ldHNjYXBlL05ldHNjYXBlUGx1Z2luLmgKQEAgLTM0MSw2ICszNDEsOSBAQCBw cml2YXRlOgogI2VsaWYgUExVR0lOX0FSQ0hJVEVDVFVSRShYMTEpCiAgICAgUGl4bWFwIG1fZHJh d2FibGU7CiAgICAgRGlzcGxheSogbV9wbHVnaW5EaXNwbGF5OworCitwdWJsaWM6IC8vIE5lZWQg dG8gY2FsbCBpdCBpbiB0aGUgTlBOX0dldFZhbHVlIGJyb3dzZXIgY2FsbGJhY2suCisgICAgc3Rh dGljIERpc3BsYXkqIHgxMUhvc3REaXNwbGF5KCk7CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS94MTEvTmV0c2NhcGVQ bHVnaW5YMTEuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBl L3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKaW5kZXggZmM5NGY2M2IxYzFhYzIzNDYxZTRkZWRj NTY2MGQ3NTI4OWQyN2FhYi4uYWUzNGVhY2U5NTI0YjlkMTI3ZTFhNGJjMzIxZTQ3MTYxZjQyNGJi MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBl L3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9QbHVnaW5zL05ldHNjYXBlL3gxMS9OZXRzY2FwZVBsdWdpblgxMS5jcHAKQEAgLTM0LDEwICsz NCw3IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9Ob3RJbXBsZW1lbnRlZC5oPgogCiAjaWYgUExBVEZP Uk0oUVQpCi0jaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgotI2luY2x1ZGUgPFFEZXNrdG9wV2lkZ2V0 PgotI2luY2x1ZGUgPFFQaXhtYXA+Ci0jaW5jbHVkZSA8UVgxMUluZm8+CisjaW5jbHVkZSA8V2Vi Q29yZS9RdFgxMUltYWdlQ29udmVyc2lvbi5oPgogI2VsaWYgUExBVEZPUk0oR1RLKQogI2luY2x1 ZGUgIlBsYXRmb3JtQ29udGV4dENhaXJvLmgiCiAjaW5jbHVkZSAiUmVmUHRyQ2Fpcm8uaCIKQEAg LTUwLDcgKzQ3LDcgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBXZWJL aXQgewogCi1zdGF0aWMgRGlzcGxheSAqZ2V0UGx1Z2luRGlzcGxheSgpCitzdGF0aWMgRGlzcGxh eSogZ2V0UGx1Z2luRGlzcGxheSgpCiB7CiAjaWYgUExBVEZPUk0oUVQpCiAgICAgLy8gQXQgdGhl IG1vbWVudCwgd2Ugb25seSBzdXBwb3J0IGdkayBiYXNlZCBwbHVnaW5zIChsaWtlIEZsYXNoKSB0 aGF0IHVzZSBhIGRpZmZlcmVudCBYIGNvbm5lY3Rpb24uCkBAIC04NywxMiArODQsMTIgQEAgc3Rh dGljIERpc3BsYXkgKmdldFBsdWdpbkRpc3BsYXkoKQogI2VuZGlmCiB9CiAKLXN0YXRpYyBpbmxp bmUgRGlzcGxheSogeDExRGlzcGxheSgpCitzdGF0aWMgaW5saW5lIGludCB4MTFTY3JlZW4oKQog ewogI2lmIFBMQVRGT1JNKFFUKQotICAgIHJldHVybiBRWDExSW5mbzo6ZGlzcGxheSgpOworICAg IHJldHVybiBYRGVmYXVsdFNjcmVlbihOZXRzY2FwZVBsdWdpbjo6eDExSG9zdERpc3BsYXkoKSk7 CiAjZWxpZiBQTEFURk9STShHVEspCi0gICAgcmV0dXJuIEdES19ESVNQTEFZX1hESVNQTEFZKGdk a19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworICAgIHJldHVybiBnZGtfc2NyZWVuX2dldF9udW1i ZXIoZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgpKTsKICNlbHNlCiAgICAgcmV0dXJuIDA7CiAjZW5k aWYKQEAgLTEwMSw3ICs5OCw3IEBAIHN0YXRpYyBpbmxpbmUgRGlzcGxheSogeDExRGlzcGxheSgp CiBzdGF0aWMgaW5saW5lIGludCBkaXNwbGF5RGVwdGgoKQogewogI2lmIFBMQVRGT1JNKFFUKQot ICAgIHJldHVybiBRQXBwbGljYXRpb246OmRlc2t0b3AoKS0+eDExSW5mbygpLmRlcHRoKCk7Cisg ICAgcmV0dXJuIFhEZWZhdWx0RGVwdGgoTmV0c2NhcGVQbHVnaW46OngxMUhvc3REaXNwbGF5KCks IHgxMVNjcmVlbigpKTsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAgICByZXR1cm4gZ2RrX3Zpc3Vh bF9nZXRfZGVwdGgoZ2RrX3NjcmVlbl9nZXRfc3lzdGVtX3Zpc3VhbChnZGtfc2NyZWVuX2dldF9k ZWZhdWx0KCkpKTsKICNlbHNlCkBAIC0xMTIsNyArMTA5LDcgQEAgc3RhdGljIGlubGluZSBpbnQg ZGlzcGxheURlcHRoKCkKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyByb290V2luZG93SUQo KQogewogI2lmIFBMQVRGT1JNKFFUKQotICAgIHJldHVybiBRWDExSW5mbzo6YXBwUm9vdFdpbmRv dygpOworICAgIHJldHVybiBYRGVmYXVsdFJvb3RXaW5kb3coTmV0c2NhcGVQbHVnaW46OngxMUhv c3REaXNwbGF5KCkpOwogI2VsaWYgUExBVEZPUk0oR1RLKQogICAgIHJldHVybiBHREtfUk9PVF9X SU5ET1coKTsKICNlbHNlCkBAIC0xMjAsMTcgKzExNyw2IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWdu ZWQgbG9uZyByb290V2luZG93SUQoKQogI2VuZGlmCiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IHgx MVNjcmVlbigpCi17Ci0jaWYgUExBVEZPUk0oUVQpCi0gICAgcmV0dXJuIFFYMTFJbmZvOjphcHBT Y3JlZW4oKTsKLSNlbGlmIFBMQVRGT1JNKEdUSykKLSAgICByZXR1cm4gZ2RrX3NjcmVlbl9nZXRf bnVtYmVyKGdka19zY3JlZW5fZ2V0X2RlZmF1bHQoKSk7Ci0jZWxzZQotICAgIHJldHVybiAwOwot I2VuZGlmCi19Ci0KICNpZiBQTEFURk9STShHVEspCiBzdGF0aWMgYm9vbCBtb2R1bGVNaXhlc0d0 a1N5bWJvbHMoTW9kdWxlKiBtb2R1bGUpCiB7CkBAIC0xNDIsNiArMTI4LDIyIEBAIHN0YXRpYyBi b29sIG1vZHVsZU1peGVzR3RrU3ltYm9scyhNb2R1bGUqIG1vZHVsZSkKIH0KICNlbmRpZgogCitE aXNwbGF5KiBOZXRzY2FwZVBsdWdpbjo6eDExSG9zdERpc3BsYXkoKQoreworI2lmIFBMQVRGT1JN KFFUKQorICAgIHN0YXRpYyBEaXNwbGF5KiBkZWRpY2F0ZWREaXNwbGF5ID0gMDsKKyAgICBpZiAo IWRlZGljYXRlZERpc3BsYXkpCisgICAgICAgIGRlZGljYXRlZERpc3BsYXkgPSBYT3BlbkRpc3Bs YXkoMCk7CisKKyAgICBBU1NFUlQoZGVkaWNhdGVkRGlzcGxheSk7CisgICAgcmV0dXJuIGRlZGlj YXRlZERpc3BsYXk7CisjZWxpZiBQTEFURk9STShHVEspCisgICAgcmV0dXJuIEdES19ESVNQTEFZ X1hESVNQTEFZKGdka19kaXNwbGF5X2dldF9kZWZhdWx0KCkpOworI2Vsc2UKKyAgICByZXR1cm4g MDsKKyNlbmRpZgorfQorCiBib29sIE5ldHNjYXBlUGx1Z2luOjpwbGF0Zm9ybVBvc3RJbml0aWFs aXplKCkKIHsKICNpZiBQTEFURk9STShHVEspCkBAIC0xNTcsOCArMTU5LDExIEBAIGJvb2wgTmV0 c2NhcGVQbHVnaW46OnBsYXRmb3JtUG9zdEluaXRpYWxpemUoKQogCiAgICAgTlBTZXRXaW5kb3dD YWxsYmFja1N0cnVjdCogY2FsbGJhY2tTdHJ1Y3QgPSBuZXcgTlBTZXRXaW5kb3dDYWxsYmFja1N0 cnVjdDsKICAgICBjYWxsYmFja1N0cnVjdC0+dHlwZSA9IDA7Ci0gICAgRGlzcGxheSogZGlzcGxh eSA9IHgxMURpc3BsYXkoKTsKKyAgICBEaXNwbGF5KiBkaXNwbGF5ID0geDExSG9zdERpc3BsYXko KTsKICAgICBpbnQgZGVwdGggPSBkaXNwbGF5RGVwdGgoKTsKKyNpZiBQTEFURk9STShRVCkKKyAg ICBBU1NFUlQoZGVwdGggPT0gMTYgfHwgZGVwdGggPT0gMjQgfHwgZGVwdGggPT0gMzIpOworI2Vu ZGlmCiAgICAgY2FsbGJhY2tTdHJ1Y3QtPmRpc3BsYXkgPSBkaXNwbGF5OwogICAgIGNhbGxiYWNr U3RydWN0LT5kZXB0aCA9IGRlcHRoOwogCkBAIC0xOTEsNyArMTk2LDcgQEAgdm9pZCBOZXRzY2Fw ZVBsdWdpbjo6cGxhdGZvcm1EZXN0cm95KCkKICAgICBkZWxldGUgc3RhdGljX2Nhc3Q8TlBTZXRX aW5kb3dDYWxsYmFja1N0cnVjdCo+KG1fbnBXaW5kb3cud3NfaW5mbyk7CiAKICAgICBpZiAobV9k cmF3YWJsZSkgewotICAgICAgICBYRnJlZVBpeG1hcCh4MTFEaXNwbGF5KCksIG1fZHJhd2FibGUp OworICAgICAgICBYRnJlZVBpeG1hcCh4MTFIb3N0RGlzcGxheSgpLCBtX2RyYXdhYmxlKTsKICAg ICAgICAgbV9kcmF3YWJsZSA9IDA7CiAgICAgfQogfQpAQCAtMjA5LDcgKzIxNCw3IEBAIHZvaWQg TmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtR2VvbWV0cnlEaWRDaGFuZ2UoKQogICAgICAgICByZXR1 cm47CiAgICAgfQogCi0gICAgRGlzcGxheSogZGlzcGxheSA9IHgxMURpc3BsYXkoKTsKKyAgICBE aXNwbGF5KiBkaXNwbGF5ID0geDExSG9zdERpc3BsYXkoKTsKICAgICBpZiAobV9kcmF3YWJsZSkK ICAgICAgICAgWEZyZWVQaXhtYXAoZGlzcGxheSwgbV9kcmF3YWJsZSk7CiAKQEAgLTI0MywxNyAr MjQ4LDExIEBAIHZvaWQgTmV0c2NhcGVQbHVnaW46OnBsYXRmb3JtUGFpbnQoR3JhcGhpY3NDb250 ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiBkaXJ0CiAgICAgaWYgKGNvbnRleHQtPnBhaW50 aW5nRGlzYWJsZWQoKSB8fCAhbV9kcmF3YWJsZSkKICAgICAgICAgcmV0dXJuOwogCi0jaWYgUExB VEZPUk0oUVQpCi0jZWxpZiAhUExBVEZPUk0oR1RLKQotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0g ICAgcmV0dXJuOwotI2VuZGlmCi0KICAgICBYRXZlbnQgeGV2ZW50OwogICAgIG1lbXNldCgmeGV2 ZW50LCAwLCBzaXplb2YoWEV2ZW50KSk7CiAgICAgWEdyYXBoaWNzRXhwb3NlRXZlbnQmIGV4cG9z ZUV2ZW50ID0geGV2ZW50LnhncmFwaGljc2V4cG9zZTsKICAgICBleHBvc2VFdmVudC50eXBlID0g R3JhcGhpY3NFeHBvc2U7Ci0gICAgZXhwb3NlRXZlbnQuZGlzcGxheSA9IHgxMURpc3BsYXkoKTsK KyAgICBleHBvc2VFdmVudC5kaXNwbGF5ID0geDExSG9zdERpc3BsYXkoKTsKICAgICBleHBvc2VF dmVudC5kcmF3YWJsZSA9IG1fZHJhd2FibGU7CiAKICAgICBJbnRSZWN0IGV4cG9zZWRSZWN0KGRp cnR5UmVjdCk7CkBAIC0yNjcsMTQgKzI2NiwxNiBAQCB2b2lkIE5ldHNjYXBlUGx1Z2luOjpwbGF0 Zm9ybVBhaW50KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgZGlydAog CiAgICAgTlBQX0hhbmRsZUV2ZW50KCZ4ZXZlbnQpOwogCi0gICAgaWYgKG1fcGx1Z2luRGlzcGxh eSAhPSB4MTFEaXNwbGF5KCkpCisgICAgaWYgKG1fcGx1Z2luRGlzcGxheSAhPSB4MTFIb3N0RGlz cGxheSgpKQogICAgICAgICBYU3luYyhtX3BsdWdpbkRpc3BsYXksIGZhbHNlKTsKIAogI2lmIFBM QVRGT1JNKFFUKQotICAgIFFQaXhtYXAgcXREcmF3YWJsZSA9IFFQaXhtYXA6OmZyb21YMTFQaXht YXAobV9kcmF3YWJsZSwgUVBpeG1hcDo6RXhwbGljaXRseVNoYXJlZCk7Ci0gICAgQVNTRVJUKHF0 RHJhd2FibGUuZGVwdGgoKSA9PSBzdGF0aWNfY2FzdDxOUFNldFdpbmRvd0NhbGxiYWNrU3RydWN0 Kj4obV9ucFdpbmRvdy53c19pbmZvKS0+ZGVwdGgpOworICAgIFhJbWFnZSogeEltYWdlID0gWEdl dEltYWdlKE5ldHNjYXBlUGx1Z2luOjp4MTFIb3N0RGlzcGxheSgpLCBtX2RyYXdhYmxlLCBleHBv c2VkUmVjdC54KCksIGV4cG9zZWRSZWN0LnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBleHBvc2VkUmVjdC53aWR0aCgpLCBleHBvc2VkUmVjdC5oZWlnaHQoKSwgVUxPTkdfTUFY LCBaUGl4bWFwKTsKICAgICBRUGFpbnRlciogcGFpbnRlciA9IGNvbnRleHQtPnBsYXRmb3JtQ29u dGV4dCgpOwotICAgIHBhaW50ZXItPmRyYXdQaXhtYXAoUVBvaW50KGV4cG9zZWRSZWN0LngoKSwg ZXhwb3NlZFJlY3QueSgpKSwgcXREcmF3YWJsZSwgZXhwb3NlZFJlY3QpOworICAgIHBhaW50ZXIt PmRyYXdJbWFnZShRUG9pbnQoZXhwb3NlZFJlY3QueCgpLCBleHBvc2VkUmVjdC55KCkpLCBxaW1h Z2VGcm9tWEltYWdlKHhJbWFnZSksIGV4cG9zZWRSZWN0KTsKKworICAgIFhEZXN0cm95SW1hZ2Uo eEltYWdlKTsKICNlbGlmIFBMQVRGT1JNKEdUSykKICAgICBSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90 PiBkcmF3YWJsZVN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb194bGliX3N1cmZhY2VfY3JlYXRlKG1f cGx1Z2luRGlzcGxheSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fZHJhd2FibGUsCkBAIC0y OTIsNiArMjkzLDggQEAgdm9pZCBOZXRzY2FwZVBsdWdpbjo6cGxhdGZvcm1QYWludChHcmFwaGlj c0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIGRpcnQKICAgICBjYWlyb19wYWludChj cik7CiAKICAgICBjYWlyb19yZXN0b3JlKGNyKTsKKyNlbHNlCisgICAgbm90SW1wbGVtZW50ZWQo KTsKICNlbmRpZgogfQogCkBAIC0zMDAsNyArMzAzLDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGlu aXRpYWxpemVYRXZlbnQoWEV2ZW50JiBldmVudCkKICAgICBtZW1zZXQoJmV2ZW50LCAwLCBzaXpl b2YoWEV2ZW50KSk7CiAgICAgZXZlbnQueGFueS5zZXJpYWwgPSAwOwogICAgIGV2ZW50Lnhhbnku c2VuZF9ldmVudCA9IGZhbHNlOwotICAgIGV2ZW50LnhhbnkuZGlzcGxheSA9IHgxMURpc3BsYXko KTsKKyAgICBldmVudC54YW55LmRpc3BsYXkgPSBOZXRzY2FwZVBsdWdpbjo6eDExSG9zdERpc3Bs YXkoKTsKICAgICBldmVudC54YW55LndpbmRvdyA9IDA7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9hcGkucHJpIGIvU291cmNlL2FwaS5wcmkKaW5kZXggZjhiZTI4NzljN2QwZTZhZDBlNmVlNjJl OGUwM2MzNDczYzkxM2VmNy4uZWFiMzMzN2Q0NGJmMDcyYmM5YTliMTkxYTQxYTA4N2Q1NmI0MWJk MyAxMDA2NDQKLS0tIGEvU291cmNlL2FwaS5wcmkKKysrIGIvU291cmNlL2FwaS5wcmkKQEAgLTIy MiwzICsyMjIsNyBAQCBtYWMgewogICAgIFFNQUtFX0xGTEFHU19TT05BTUUgPSAiJCR7UU1BS0Vf TEZMQUdTX1NPTkFNRX0kJHtERVNURElSfSQke1FNQUtFX0RJUl9TRVB9IgogfQogCitwbHVnaW5f YmFja2VuZF94bGliIHsKKyAgICBDT05GSUcgKj0gbGlua19wa2djb25maWcKKyAgICBQS0dDT05G SUcgKz0geDExCit9CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VM b2cKaW5kZXggOTY0NDY1NmEyMTc4M2M0ZDNiYjBhZjRhZjJiYzFmOWI4ZTgwNDRlMy4uMGM2OTVh NzRmMGQ3NjBiZWY5YzdlZTAxOWNkYWI2YmExOGVkY2ZkMyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hh bmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDExLTExLTA4 ICBCYWxhenMgS2VsZW1lbiAgPGtiYWxhenNAd2Via2l0Lm9yZz4KKworICAgICAgICBbUXRdIFgx MSBwbHVnaW5zIG5lZWQgdG8gYmUgcmV3b3JrZWQgZm9yIFF0NQorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzAwMjMKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZXdvcmsgb3VyIGJhc2ljIHBsdWdpbiBzdXBw b3J0IGluIGEgd2F5IHRoYXQgZG9lcworICAgICAgICBub3QgbmVlZCBhIGJyaWRnZSBiZXR3ZWVu IFF0IGFuZCBYLiBUaGUgc29sdXRpb24gaXMKKyAgICAgICAgYmFzZWQgb24gZ2V0dGluZyB0aGUg Y29udGVudCBkcmF3ZWQgYnkgdGhlIHBsdWdpbgorICAgICAgICBmcm9tIHRoZSBzZXJ2ZXIgYXMg YW4gaW1hZ2UgYW5kIGNyZWF0aW5nIGEgUUltYWdlCisgICAgICAgIGZyb20gaXQuCisKKyAgICAg ICAgKiBxbWFrZS9ta3NwZWNzL2ZlYXR1cmVzL2ZlYXR1cmVzLnByZjogRW5hYmxlIFgxMQorICAg ICAgICBwbHVnaW5zIGlmIFF0IGlzIGJ1aWx0IHdpdGggdGhlIHhjYi14bGliIGJhY2tlbmQuCisK IDIwMTEtMTEtMTAgIEFsZXhpcyBNZW5hcmQgIDxhbGV4aXMubWVuYXJkQG9wZW5ib3NzYS5vcmc+ CiAKICAgICAgICAgW1F0XSBNZXJnZSBRVG91Y2hXZWJWaWV3IGFuZCBRRGVza3RvcFdlYlZpZXcg aW50byBvbmUgY2xhc3MKZGlmZiAtLWdpdCBhL1Rvb2xzL3FtYWtlL21rc3BlY3MvZmVhdHVyZXMv ZmVhdHVyZXMucHJmIGIvVG9vbHMvcW1ha2UvbWtzcGVjcy9mZWF0dXJlcy9mZWF0dXJlcy5wcmYK aW5kZXggMzgyYWZmYmEzZTIwMDMyNjU1NTBkZDc2MTM2ZDExYTg3YmQxZjkyMC4uZDRiYmM4NWI3 OGMwYmJkNTg3ZjMwMzI0YTQ1MDVkYTc4M2EzM2Q3ZCAxMDA2NDQKLS0tIGEvVG9vbHMvcW1ha2Uv bWtzcGVjcy9mZWF0dXJlcy9mZWF0dXJlcy5wcmYKKysrIGIvVG9vbHMvcW1ha2UvbWtzcGVjcy9m ZWF0dXJlcy9mZWF0dXJlcy5wcmYKQEAgLTk2LDYgKzk2LDE3IEBAIGlzRW1wdHkoSEFWRV9RUkFX Rk9OVCkgewogICAgIH0KIH0KIAorIyBOZXRzY2FwZSBwbHVnaW5zIHN1cHBvcnQgZm9yIFdlYktp dDIKKyFub193ZWJraXQyOiFjb250YWlucyhERUZJTkVTLCBQTFVHSU5fQVJDSElURUNUVVJFX1VO U1VQUE9SVEVEKTogeworICAgIGNvbnRhaW5zKFFUX0NPTkZJRywgeGNiLXhsaWIpIHsKKyAgICAg ICAgQ09ORklHICs9IHBsdWdpbl9iYWNrZW5kX3hsaWIKKyAgICAgICAgREVGSU5FUyArPSBQTFVH SU5fQVJDSElURUNUVVJFX1gxMT0xIFwKKyAgICAgICAgICAgICAgICAgICBQTFVHSU5fQVJDSElU RUNUVVJFX1VOU1VQUE9SVEVEPTAKKyAgICB9IGVsc2UgeworICAgICAgICBERUZJTkVTICs9IFBM VUdJTl9BUkNISVRFQ1RVUkVfVU5TVVBQT1JURUQ9MQorICAgIH0KK30KKwogIyBXZWJHTCBzdXBw b3J0CiBjb250YWlucyhRVF9DT05GSUcsIG9wZW5nbCk6IXdpbjMyLSogewogICAgICFjb250YWlu cyhERUZJTkVTLCBFTkFCTEVfV0VCR0w9Lik6IERFRklORVMgKz0gRU5BQkxFX1dFQkdMPTEKZGlm ZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCAxZTQ5ZmVlNDA0OGMyNTZjZWYw MDYyN2IyNDc0ZTg4OGFhM2Y0OWViLi44ODEyNjhkNDUwZjIyMzcwNTkwNzMxZDRjZGIzNzEyMjk4 ZjczZDU3IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTggQEAKKzIwMTEtMTEtMDggIEJhbGF6cyBLZWxlbWVuICA8a2JhbGF6c0B3ZWJraXQub3JnPgor CisgICAgICAgIFtRdF0gWDExIHBsdWdpbnMgbmVlZCB0byBiZSByZXdvcmtlZCBmb3IgUXQ1Cisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MDAyMworCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJld29yayBvdXIg YmFzaWMgcGx1Z2luIHN1cHBvcnQgaW4gYSB3YXkgdGhhdCBkb2VzCisgICAgICAgIG5vdCBuZWVk IGEgYnJpZGdlIGJldHdlZW4gUXQgYW5kIFguIFRoZSBzb2x1dGlvbiBpcworICAgICAgICBiYXNl ZCBvbiBnZXR0aW5nIHRoZSBjb250ZW50IGRyYXdlZCBieSB0aGUgcGx1Z2luCisgICAgICAgIGZy b20gdGhlIHNlcnZlciBhcyBhbiBpbWFnZSBhbmQgY3JlYXRpbmcgYSBRSW1hZ2UKKyAgICAgICAg ZnJvbSBpdC4KKworICAgICAgICAqIFNvdXJjZS9hcGkucHJpOiBMaW5rIHRvIHhsaWIgaWYgbmVj ZXNzYXJ5LgorCiAyMDExLTExLTEwICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5uQG5v a2lhLmNvbT4KIAogICAgICAgICBbUXRdIENsZWFuIHVwIGJ1aWxkIHN5c3RlbQo=