82889 2012-04-02 05:14:09 -0700 [GTK] Honor GTK+ font settings 2017-03-23 05:10:50 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 mcrha mcatanzaro aperez bugs-noreply cgarcia mcatanzaro mmaxfield mrobinson tpopela oldest_to_newest 593377 0 mcrha 2012-04-02 05:14:09 -0700 GTK follows system font settings on its cairo contexts, but WebKitGtk doesn't follow this settings, which makes pages rendered in Gtk look ugly and inconsistent with the rest of application. If I apply the below change, then I get consistent behaviour, with one exception, if I change font setting while webkitview is already created, then the font change is not noticed in it. Note the system settings has both font Hinting and font Antialiasing, and I use Hinting: Slight, Antialiasing: Rgba. You can see a sample screen shot here [1], where the first part from GtkHTML uses system font setting (on a monospaced font), while the webkit does not. The difference is noticeable. [1] https://bugzilla.gnome.org/show_bug.cgi?id=673108#c1 diff -up webkit-1.8.0/Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp.fonts webkit-1.8.0/Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp --- webkit-1.8.0/Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp.fonts 2012-04-02 13:58:12.393501948 +0200 +++ webkit-1.8.0/Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp 2012-04-02 13:58:15.363537998 +0200 @@ -94,10 +94,10 @@ void setCairoFontOptionsFromFontConfigPa cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); } - if (FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &integerResult) == FcResultMatch) + /*if (FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &integerResult) == FcResultMatch) cairo_font_options_set_hint_style(options, convertFontConfigHintStyle(integerResult)); if (FcPatternGetBool(pattern, FC_HINTING, 0, &booleanResult) == FcResultMatch && !booleanResult) - cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); + cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE);*/ } static cairo_font_options_t* getDefaultFontOptions() diff -up webkit-1.8.0/Source/WebCore/platform/graphics/pango/FontPlatformDataPango.cpp.fonts webkit-1.8.0/Source/WebCore/platform/graphics/pango/FontPlatformDataPango.cpp --- webkit-1.8.0/Source/WebCore/platform/graphics/pango/FontPlatformDataPango.cpp.fonts 2012-04-02 13:59:00.823090496 +0200 +++ webkit-1.8.0/Source/WebCore/platform/graphics/pango/FontPlatformDataPango.cpp 2012-04-02 13:59:38.091543457 +0200 @@ -152,8 +152,8 @@ FontPlatformData::FontPlatformData(cairo // We force antialiasing and disable hinting to provide consistent // typographic qualities for custom fonts on all platforms. - cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); - cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); + /*cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); + cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY);*/ m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); 599305 1 mrobinson 2012-04-10 08:37:19 -0700 WebKitGTK+ should follow your Fontconfig settings over the Xsettings ones. The reason is that XSettings switches are not per-font, while Fontconfig settings are. You simply need to modify your Fontconfig setup to disable hinting. For all of the gory details take a look here: http://neugierig.org/software/chromium/fonts/ Now, if for some reason WebKitGTK+ isn't reading your Fontconfig settings properly and you don't see this issue in Chromium, this is a valid bug. 600153 2 mcrha 2012-04-11 02:26:35 -0700 My idea was that if this is WebKitGTK, then it should follow gtk's font settings, thus also WebKitGTK will follow look & feel of other gtk+ applications. Hinting makes a large difference, noticeable on the first look. 600263 3 mrobinson 2012-04-11 07:52:57 -0700 (In reply to comment #2) > My idea was that if this is WebKitGTK, then it should follow gtk's font settings, thus also WebKitGTK will follow look & feel of other gtk+ applications. Hinting makes a large difference, noticeable on the first look. In the end, the choice to follow the Fontconfig settings or the XSettings settings is somewhat arbitrary. In this case, we've chosen to take the route that gives the user more control. XSettings does not allow you to hint some fonts and not others. Not only that, we try to do the same thing as Chromium here. If you simply update your Fontconfig settings to disable hinting everywhere, I think you'll find fonts are to your liking. You'll also fix all applications that obey Fontconfig over XSettings. 677820 4 mcrha 2012-07-25 02:19:57 -0700 I still believe that in webkitgtk you should follow gtk settings, it's WebKit *GTK*, after all. Nonetheless, I'm not going to fight here. I would like to ask you for one thing, though. Could you tell me where and how I can change font settings in fontconfig, please? The best some kind of UI tool, like the gtk has. I know about gtk, but not about fontconfig, and I expect users will ask for it, as they might not like tiny fonts, which are hard to read, same as I do not like them for monospace fonts. 678903 5 mrobinson 2012-07-25 23:25:25 -0700 (In reply to comment #4) > I still believe that in webkitgtk you should follow gtk settings, it's WebKit *GTK*, after all. Nonetheless, I'm not going to fight here. > > I would like to ask you for one thing, though. Could you tell me where and how I can change font settings in fontconfig, please? The best some kind of UI tool, like the gtk has. I know about gtk, but not about fontconfig, and I expect users will ask for it, as they might not like tiny fonts, which are hard to read, same as I do not like them for monospace fonts. I don't know of a tool to modify fontconfig font settings, but if you look around you should be able to find some examples of how to modify the configuration of all fonts. The size of the font isn't determined by the fontconfig or XSettings configuration. It's up to the client (Epiphany, for instance) to determine the the default font size. One thing to ensure is that, if you are using Epiphany, you should uncheck "Use system font settings" and choose a more appropriate default size. 678988 6 mcrha 2012-07-26 01:08:28 -0700 It's not about font size, like how tall it's supposed to be, it's about hinting and antialiasing. If I turn than on, then the font is weighter, easier to read for me. If you open font settings for gtk/gnome, then you can tweak these options there and see what I mean. Different settings fit for different monitors (CRT/LCD/Laptop/...). I looked around, I only found /etc/fonts/..., but that is quite user unfriendly. My intention for the setting is also to verify that your advice actually works. 678994 7 mrobinson 2012-07-26 01:11:26 -0700 (In reply to comment #6) > It's not about font size, like how tall it's supposed to be, it's about hinting and antialiasing. If I turn than on, then the font is weighter, easier to read for me. If you open font settings for gtk/gnome, then you can tweak these options there and see what I mean. Different settings fit for different monitors (CRT/LCD/Laptop/...). So the font.conf settings are specifying that the fonts are not hinted nor anti-aliased? Typically those are on by default, unless fontconfig disables them for a particular font. Here's a guide to configuring fontconfig via the ~/fonts.conf file: https://wiki.archlinux.org/index.php/Font_Configuration#Fontconfig_configuration 679055 8 mcrha 2012-07-26 01:56:34 -0700 Nice, thanks. I also made this system-wide, when I copied 10-sub-pixel-rgb.conf and 10-autohint.conf from /etc/fonts/conf.avail/ to /etc/fonts/conf.d/ and after I restart Evolution (the application using webkitgtk now), the fonts look readable again. 1246774 9 mcatanzaro 2016-10-31 18:56:16 -0700 After much discussion with Behdad and Martin (who is still not completely convinced I think :) I want to merge cairo font options into the Fontconfig pattern used for rendering using cairo_ft_font_options_substitute(). This is how the API was designed to be used anyway. Fontconfig will still have final say over whether to actually respect the desktop settings or not, so it can still choose to ignore the desktop's settings, but I don't think it makes sense to have desktop-wide font settings and not tell Fontconfig about them, especially when the whole point of WebKitGTK+ is desktop integration. This should also reduce complaints that we're not following desktop settings and that we're drawing fonts differently than Firefox. 1250733 10 mcatanzaro 2016-11-12 15:09:49 -0800 Here's an initial patch. The code changes should all be fine, but it will probably break a huge amount of layout tests. To be able to easily rebase the layout tests, we need accurate test expectations for all currently-failing tests, so it's probably a bad idea to commit this patch in the meantime. 1250734 11 mcatanzaro 2016-11-12 15:11:17 -0800 Note that our font rendering still looks completely different from Firefox, but I am hoping that is bug #164689, knock on wood. 1250735 12 294635 mcatanzaro 2016-11-12 15:13:49 -0800 Created attachment 294635 Patch 1250736 13 294636 mcatanzaro 2016-11-12 15:15:07 -0800 Created attachment 294636 Patch 1250751 14 mcatanzaro 2016-11-12 16:59:34 -0800 (In reply to comment #11) > Note that our font rendering still looks completely different from Firefox, > but I am hoping that is bug #164689, knock on wood. Nope, even with both of these patches, our font rendering looks nothing at all like Firefox. Alas. 1250943 15 294636 cgarcia 2016-11-13 23:32:02 -0800 Comment on attachment 294636 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294636&action=review > Source/WebCore/PlatformEfl.cmake:160 > + platform/graphics/freetype/FreeTypeFontUtilities.cpp This files uses GTK+, it should be added to WebCorePlatformGTK_SOURCES > Source/WebCore/PlatformGTK.cmake:212 > + platform/graphics/freetype/FontCacheFreeType.cpp > platform/graphics/freetype/FontPlatformDataFreeType.cpp > + platform/graphics/freetype/FreeTypeFontUtilities.cpp It's the other way around, FontPlatformDataFreeType.cpp no longer uses GTK+, so all theses should be moved to WebCore_SOURCES, and FreeTypeFontUtilities.cpp should be moved to WebCorePlatformGTK_SOURCES, but you are adding it to both. > Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp:-119 > -static CairoUniquePtr<cairo_font_options_t> getDefaultCairoFontOptions() > -{ > -#if PLATFORM(GTK) > - if (GdkScreen* screen = gdk_screen_get_default()) { > - const cairo_font_options_t* screenOptions = gdk_screen_get_font_options(screen); > - if (screenOptions) > - return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_copy(screenOptions)); > - } > -#endif > - return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_create()); > -} Can we also remove the #include <gdk/gdk.h> now? > Source/WebCore/platform/graphics/freetype/FreeTypeFontUtilities.cpp:27 > +#include "FreeTypeFontUtilities.h" I'm not sure FreeTypeFontUtilities is the best name for this, nor Source/WebCore/platform/graphics/freetype/ the best place. This has nothing to do with freetype actually, it's more a cairo implementation. I would add it to Source/WebCore/platform/graphics/cairo instead, named as CairoFontUtilities or CairoDefaultFontOptions. Or you could add it to CairoUtilities that already has some FreeType stuff (although that would make CairoUtilities a GTK+ file). > Source/WebCore/platform/graphics/freetype/FreeTypeFontUtilities.cpp:29 > +#include <wtf/Platform.h> I'm pretty sure you don't need this, I think all config.h files already include Platform.h > Source/WebCore/platform/graphics/freetype/FreeTypeFontUtilities.cpp:37 > +CairoUniquePtr<cairo_font_options_t> getDefaultCairoFontOptions() We should take advantage of this patch to properly name this, it should be defaultCairoFonrOptions() > Source/WebCore/platform/graphics/freetype/FreeTypeFontUtilities.cpp:43 > + return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_copy(screenOptions)); So, in all the new places where you are now using this, the font options are not modified, they are used to set up a FcPattern. I wonder if we could return the options without copying them, and let the caller decide whether to copy them or not. For the fallback case we could use a static cairo_font_options_t > Source/WebCore/platform/graphics/freetype/FreeTypeFontUtilities.h:29 > +#include "CairoUniquePtr.h" > +#include <cairo.h> CairoUniquePtr.h already includes cairo.h 1253133 16 mcatanzaro 2016-11-19 19:01:27 -0800 (In reply to comment #14) > Nope, even with both of these patches, our font rendering looks nothing at > all like Firefox. Alas. Actually this seems to get us about halfway there. Our character positioning is completely different (arguably worse) but it makes the hinting match. That's good. Will update this patch when I have sufficient time to attend to the layout tests. 1253134 17 mcatanzaro 2016-11-19 19:04:29 -0800 (In reply to comment #3) > In the end, the choice to follow the Fontconfig settings or the XSettings > settings is somewhat arbitrary. In this case, we've chosen to take the route > that gives the user more control. XSettings does not allow you to hint some > fonts and not others. Not only that, we try to do the same thing as Chromium > here. By the way, I am only merging *defaults* from GTK+ settings. Users still have full control of the final hinting on a per-font basis with fontconfig, just the default will be GTK+'s default and not fontconfig's default (which is currently only used by WebKitGTK+ and not anything else). 1284509 18 mcatanzaro 2017-03-07 13:01:22 -0800 So the big change since I originally wrote this patch is that Fontconfig switched from medium to light hinting by default, which now matches GTK+'s default. So this should make no difference to users who have not touched those hidden font settings. But if you have tweaked your settings, you probably want them to work properly... hence we still need this. 1284521 19 mcatanzaro 2017-03-07 13:16:45 -0800 Next patch attempt is mainly for EWS; I'm still building it locally. Big thanks to Carlos Garcia, Carlos Lopez, and Javi Fernandez for doing the hard part to make this possible, which was cleaning up our test expectations. This has to land when the bot is green or almost green, as otherwise it's way too hard to assess impact on layout tests. I tried running tests locally and am at something like 200 failures and 400 timeouts, so it's just not practical now. I'll watch the bots after this lands to see what the impact is. In theory, any breakage should be fixable without altering test expectations by just modifying our test Fontconfig configuration, but I want to assess the impact before making any changes there. 1284522 20 303711 mcatanzaro 2017-03-07 13:18:15 -0800 Created attachment 303711 Patch 1284538 21 303719 mcatanzaro 2017-03-07 13:45:13 -0800 Created attachment 303719 Patch 1284581 22 303730 mcatanzaro 2017-03-07 15:01:59 -0800 Created attachment 303730 Patch 1284583 23 mcatanzaro 2017-03-07 15:05:32 -0800 (In reply to comment #15) > It's the other way around, FontPlatformDataFreeType.cpp no longer uses GTK+, > so all theses should be moved to WebCore_SOURCES, and > FreeTypeFontUtilities.cpp should be moved to WebCorePlatformGTK_SOURCES, but > you are adding it to both. I'm sure I did it because I couldn't get it to link otherwise. This time around, it doesn't seem to work no matter what I try: FAILED: lib/libwebkit2gtk-4.0.so.37.20.0 : && /usr/lib64/ccache/c++ -fPIC -fno-exceptions -fno-strict-aliasing -fno-rtti -std=c++1y -O2 -DNDEBUG -Wl,--no-undefined -L/home/mcatanzaro/Projects/GNOME/install/lib -fuse-ld=gold -Wl,--disable-new-dtags -fuse-ld=gold -Wl,--disable-new-dtags -shared -Wl,-soname,libwebkit2gtk-4.0.so.37 -o lib/libwebkit2gtk-4.0.so.37.20.0 @CMakeFiles/WebKit2.rsp && : lib/libWebCoreGTK.a(lib/../Source/WebCore/CMakeFiles/WebCore.dir/platform/graphics/freetype/FontCacheFreeType.cpp.o):FontCacheFreeType.cpp:function WebCore::FontCache::systemFallbackForCharacters(WebCore::FontDescription const&, WebCore::Font const*, bool, unsigned short const*, unsigned int): error: undefined reference to 'WebCore::getDefaultCairoFontOptions()' lib/libWebCoreGTK.a(lib/../Source/WebCore/CMakeFiles/WebCore.dir/platform/graphics/freetype/FontCacheFreeType.cpp.o):FontCacheFreeType.cpp:function WebCore::FontCache::createFontPlatformData(WebCore::FontDescription const&, WTF::AtomicString const&, WebCore::FontTaggedSettings<int> const*, WebCore::FontVariantSettings const*): error: undefined reference to 'WebCore::getDefaultCairoFontOptions()' lib/libWebCoreGTK.a(lib/../Source/WebCore/CMakeFiles/WebCore.dir/platform/graphics/freetype/FontCacheFreeType.cpp.o):FontCacheFreeType.cpp:function WebCore::FontCache::createFontPlatformData(WebCore::FontDescription const&, WTF::AtomicString const&, WebCore::FontTaggedSettings<int> const*, WebCore::FontVariantSettings const*): error: undefined reference to 'WebCore::getDefaultCairoFontOptions()' lib/libWebCoreGTK.a(lib/../Source/WebCore/CMakeFiles/WebCore.dir/platform/graphics/freetype/FontPlatformDataFreeType.cpp.o):FontPlatformDataFreeType.cpp:function void std::call_once<WebCore::getDefaultFontconfigOptions()::{lambda(_FcPattern*)#1}, _FcPattern*&>(std::once_flag&, WebCore::getDefaultFontconfigOptions()::{lambda(_FcPattern*)#1}&&, _FcPattern*&)::{lambda()#2}::_FUN(): error: undefined reference to 'WebCore::getDefaultCairoFontOptions()' collect2: error: ld returned 1 exit status Linkers! 1284590 24 mcatanzaro 2017-03-07 15:09:31 -0800 (In reply to comment #23) > I'm sure I did it because I couldn't get it to link otherwise. > > This time around, it doesn't seem to work no matter what I try: Ah, it was just a missing namespace 1284592 25 303733 mcatanzaro 2017-03-07 15:11:43 -0800 Created attachment 303733 Patch 1288284 26 303733 mmaxfield 2017-03-15 15:34:13 -0700 Comment on attachment 303733 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=303733&action=review I don't think I can review this. > Source/WebCore/PlatformGTK.cmake:-190 > - platform/graphics/freetype/FontPlatformDataFreeType.cpp Why move it? > Source/WebCore/platform/graphics/cairo/CairoUtilities.h:31 > +#include "CairoUniquePtr.h" Can't you forward-declare the type instead of including it in the header? Header includes make our builds slower. 1288391 27 mcatanzaro 2017-03-15 18:12:43 -0700 (In reply to comment #26) > Comment on attachment 303733 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=303733&action=review > > I don't think I can review this. I wouldn't expect you to... I'll bug Carlos. > > Source/WebCore/PlatformGTK.cmake:-190 > > - platform/graphics/freetype/FontPlatformDataFreeType.cpp > > Why move it? I can't get it to link otherwise. > > Source/WebCore/platform/graphics/cairo/CairoUtilities.h:31 > > +#include "CairoUniquePtr.h" > > Can't you forward-declare the type instead of including it in the header? > Header includes make our builds slower. I doubt it, since it's needed for template expansion? Anyway, if we remove it we have to include cairo.h directly instead, which is way bigger. 1288479 28 303733 cgarcia 2017-03-16 00:21:12 -0700 Comment on attachment 303733 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=303733&action=review >>> Source/WebCore/PlatformGTK.cmake:-190 >>> - platform/graphics/freetype/FontPlatformDataFreeType.cpp >> >> Why move it? > > I can't get it to link otherwise. Before this patch FontPlatformDataFreeType used GTK+ so we had to add it to WebCorePlatformGTK_SOURCES. Norw that it doesn't it should be moved to WebCore_SOURCES that doesn't depend on GTK+. > Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp:54 > +CairoUniquePtr<cairo_font_options_t> getDefaultCairoFontOptions() > +{ > + return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_create()); > +} I know this is the existing name, but this patch is a good moment to improve it. The get sounds like a global static object is returned, even when it returns a unique_ptr. So, maybe we can rename this to defaultCairoFontOptions(). Or wait, I think we can stop returning a copy. Before this patch, we always wanted a copy because FontPlatformData::buildScaledFont was the only user and it changes the options, but now we are using this only to pass it to cairo_ft_font_options_substitute that expects a const cairo_font_options_t*. So, I think this should use NeverDestroyed to create a global default font options, and let the user decide whether to copy it or not. >>> Source/WebCore/platform/graphics/cairo/CairoUtilities.h:31 >>> +#include "CairoUniquePtr.h" >> >> Can't you forward-declare the type instead of including it in the header? Header includes make our builds slower. > > I doubt it, since it's needed for template expansion? Anyway, if we remove it we have to include cairo.h directly instead, which is way bigger. And then we don't need this here because we will return a pointer > Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:41 > + const cairo_font_options_t* screenOptions = gdk_screen_get_font_options(screen); > + if (screenOptions) if (const auto* options = gdk_screen_get_font_options(screen)) return options; > Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:44 > + return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_create()); And here we would use a lazy initialized never destroyed 1288907 29 mcatanzaro 2017-03-16 20:26:15 -0700 (In reply to comment #28) > Before this patch FontPlatformDataFreeType used GTK+ so we had to add it to > WebCorePlatformGTK_SOURCES. Norw that it doesn't it should be moved to > WebCore_SOURCES that doesn't depend on GTK+. I know that's right, but I really don't know how to make that work. See comment #23. I know it's not cool to ask you to debug my problem, but I'm stumped. > > Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp:54 > > +CairoUniquePtr<cairo_font_options_t> getDefaultCairoFontOptions() > > +{ > > + return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_create()); > > +} > > I know this is the existing name, but this patch is a good moment to improve > it. The get sounds like a global static object is returned, even when it > returns a unique_ptr. So, maybe we can rename this to > defaultCairoFontOptions(). Or wait, I think we can stop returning a copy. > Before this patch, we always wanted a copy because > FontPlatformData::buildScaledFont was the only user and it changes the > options, but now we are using this only to pass it to > cairo_ft_font_options_substitute that expects a const cairo_font_options_t*. > So, I think this should use NeverDestroyed to create a global default font > options, and let the user decide whether to copy it or not. OK. > >>> Source/WebCore/platform/graphics/cairo/CairoUtilities.h:31 > >>> +#include "CairoUniquePtr.h" > >> > >> Can't you forward-declare the type instead of including it in the header? Header includes make our builds slower. > > > > I doubt it, since it's needed for template expansion? Anyway, if we remove it we have to include cairo.h directly instead, which is way bigger. > > And then we don't need this here because we will return a pointer OK. > > Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:41 > > + const cairo_font_options_t* screenOptions = gdk_screen_get_font_options(screen); > > + if (screenOptions) > > if (const auto* options = gdk_screen_get_font_options(screen)) > return options; Yes that's nicer, though I think I would omit the const there...? It's not useful. > > Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:44 > > + return CairoUniquePtr<cairo_font_options_t>(cairo_font_options_create()); > > And here we would use a lazy initialized never destroyed OK. 1288959 30 cgarcia 2017-03-17 00:41:53 -0700 (In reply to comment #29) > (In reply to comment #28) > > Before this patch FontPlatformDataFreeType used GTK+ so we had to add it to > > WebCorePlatformGTK_SOURCES. Norw that it doesn't it should be moved to > > WebCore_SOURCES that doesn't depend on GTK+. > > I know that's right, but I really don't know how to make that work. See > comment #23. I know it's not cool to ask you to debug my problem, but I'm > stumped. This patch is doing the right thing now, FontPlatformDataFreeType no longer uses GTK+ so it's moved to the common sources. 1288982 31 mcatanzaro 2017-03-17 05:48:29 -0700 Ummm... OK great, I got it working and forgot! See comment #24, my linker error was due to a missing namespace. :) 1289009 32 304781 mcatanzaro 2017-03-17 08:38:25 -0700 Created attachment 304781 Patch 1289032 33 304781 cgarcia 2017-03-17 09:57:27 -0700 Comment on attachment 304781 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=304781&action=review > Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp:296 > - CairoUniquePtr<cairo_font_options_t> options = getDefaultCairoFontOptions(); > + cairo_font_options_t* options = getDefaultCairoFontOptions(); Default options should never be modified, because then they are no the default ones anymore. Here you have to explicitly copy them. CairoUniquePtr<cairo_font_options_t> options(cairo_font_options_copy(getDefaultCairoFontOptions())); > Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:52 > + static LazyNeverDestroyed<cairo_font_options_t*> options; > + static std::once_flag flag; > + std::call_once(flag, [] { > + if (auto* screen = gdk_screen_get_default()) { > + if (auto* screenOptions = gdk_screen_get_font_options(screen)) { > + options.construct(cairo_font_options_copy(screenOptions)); > + return; > + } > + } > + options.construct(cairo_font_options_create()); > + }); > + return options; This is not what I meant. In the case of the GTK+ default options can change at any time, so we don't want to init once, we can simply return always the result of gdk_screen_get_font_options(screen). Only in case that's nullptr, we want to use our global options like in the non gtk case, but in this case we want to lazy initialize because in most of the cases it won't be used. 1289334 34 304781 mcatanzaro 2017-03-18 16:57:42 -0700 Comment on attachment 304781 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=304781&action=review >> Source/WebCore/platform/graphics/freetype/FontPlatformDataFreeType.cpp:296 >> + cairo_font_options_t* options = getDefaultCairoFontOptions(); > > Default options should never be modified, because then they are no the default ones anymore. Here you have to explicitly copy them. > > CairoUniquePtr<cairo_font_options_t> options(cairo_font_options_copy(getDefaultCairoFontOptions())); Oh no! Good catch.... >> Source/WebCore/platform/graphics/gtk/GdkCairoUtilities.cpp:52 >> + return options; > > This is not what I meant. In the case of the GTK+ default options can change at any time, so we don't want to init once, we can simply return always the result of gdk_screen_get_font_options(screen). Only in case that's nullptr, we want to use our global options like in the non gtk case, but in this case we want to lazy initialize because in most of the cases it won't be used. Ah, right. 1289346 35 304889 mcatanzaro 2017-03-18 17:55:14 -0700 Created attachment 304889 Patch 1290251 36 mcatanzaro 2017-03-22 16:17:56 -0700 OK, let's do a test commit to see how layout tests react. I'm expecting to need to roll this out. 1290253 37 mcatanzaro 2017-03-22 16:19:01 -0700 Committed r214283: <http://trac.webkit.org/changeset/214283> 1290268 38 mcatanzaro 2017-03-22 17:15:32 -0700 Bots are happy. 1290416 39 aperez 2017-03-23 05:10:50 -0700 (In reply to Michael Catanzaro from comment #38) > Bots are happy. /me is happy, too! :-) 294635 2016-11-12 15:13:49 -0800 2016-11-12 15:15:02 -0800 Patch bug-82889-20161112170933.patch text/plain 11552 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4NjU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTllNjM5ZDdjZmZmYWI3 NGQ4ZjE2NmEzMDc1ODE2YmVmNGY4MzYzYy4uNzNhMDU5ZWE0NGMwMjQ0NDk5NjFlYzE1NjEyYzk2 ZjA4NmJjNWM3OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDE2LTExLTEyICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbRnJlZVR5 cGVdIEhvbm9yIGNhaXJvIChlLmcuIEdUSyspIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdp dGggQmVoZGFkIGFuZCBNYXJ0aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5j ZWQgSSB0aGluaworICAgICAgICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25z IGludG8gdGhlIEZvbnRjb25maWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAg ICAgICAgY2Fpcm9fZnRfZm9udF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhl IEFQSSB3YXMgZGVzaWduZWQgdG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcg d2lsbCBzdGlsbCBoYXZlIGZpbmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVj dCB0aGUgZGVza3RvcCBzZXR0aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBj aG9vc2UgdG8gaWdub3JlIHRoZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5r IGl0IG1ha2VzCisgICAgICAgIHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGlu Z3MgYW5kIG5vdCB0ZWxsIEZvbnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisg ICAgICAgIHRoZSB3aG9sZSBwb2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRp b24uIFRoaXMgc2hvdWxkIGFsc28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdy ZSBub3QgZm9sbG93aW5nIGRlc2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBm b250cyBkaWZmZXJlbnRseSB0aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0 Zm9ybUVmbC5jbWFrZToKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAg ICAoV2ViQ29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpG b250Q2FjaGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6 Z2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorCiAyMDE2LTExLTEyICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgU3BlZWQgdXAgc2V0dGluZyBh dHRyaWJ1dGVzIG9mIGlucHV0IGVsZW1lbnRzIG9mIHR5cGUgJ3RleHQnCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt RWZsLmNtYWtlCmluZGV4IDkyNDk3M2RhNTY1YmE5ZWMxY2MxMGEyMGY3YmRlZWZiNGQxNDg4ZTAu LjhjNWE0NGY1NTUyNjg1ZWEyY2VkZTc1OGVlNTMwNmJmMDk1ZjQ0YmMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRm b3JtRWZsLmNtYWtlCkBAIC0xNTcsNiArMTU3LDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VS Q0VTCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3Bw CiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udEN1c3RvbVBsYXRmb3JtRGF0YUZy ZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURh dGFGcmVlVHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlwZUZv bnRVdGlsaXRpZXMuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdl VHJlZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1w bGVGb250RGF0YUZyZWVUeXBlLmNwcAogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0 Zm9ybUdUSy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4IGJh Y2U0NjZkYjZlYmI4NzNkMDFlOWM0MGVmOGZlMDMzMjVmNTZiZDMuLjlkN2I4YWZiZmNmMmQ1YzFh OTI4OGVjMjZhYzQxODg5YjVmZDFkM2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRm b3JtR1RLLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0x MzAsNyArMTMwLDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTFdheWxhbmQuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhp Y3MvZWdsL0dMQ29udGV4dEVHTFgxMS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBl L0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9HbHlwaFBhZ2VUcmVlTm9kZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dy YXBoaWNzL2ZyZWV0eXBlL1NpbXBsZUZvbnREYXRhRnJlZVR5cGUuY3BwCkBAIC0yMDgsNyArMjA3 LDkgQEAgbGlzdChBUFBFTkQgV2ViQ29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRm b3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHAKIAorICAgIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2Zy ZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9GcmVlVHlwZUZvbnRVdGlsaXRpZXMuY3BwCiAKICAgICBwbGF0Zm9ybS9ncmFw aGljcy9ndGsvQ29sb3JHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJv VXRpbGl0aWVzLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDhlMDRiZDE4 NTY0NDAzZGQxZWEwMDJmZTNlMTFlNWJhNWJhNzUxNjEuLmI4ZDI0N2RkMmE0ZThlMzE4YmU4NjAx MWY0MDRkNDQwNzUyMjgzYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTI0 LDYgKzI0LDcgQEAKIAogI2luY2x1ZGUgIkZjVW5pcXVlUHRyLmgiCiAjaW5jbHVkZSAiRm9udC5o IgorI2luY2x1ZGUgIkZyZWVUeXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlJlZlB0ckNh aXJvLmgiCiAjaW5jbHVkZSAiVVRGMTZVQ2hhcjMySXRlcmF0b3IuaCIKICNpbmNsdWRlIDxjYWly by1mdC5oPgpAQCAtNTcsNiArNTgsNyBAQCBzdGF0aWMgUmVmUHRyPEZjUGF0dGVybj4gY3JlYXRl Rm9udENvbmZpZ1BhdHRlcm5Gb3JDaGFyYWN0ZXJzKGNvbnN0IFVDaGFyKiBjaGFyYQogCiAgICAg RmNQYXR0ZXJuQWRkQm9vbChwYXR0ZXJuLmdldCgpLCBGQ19TQ0FMQUJMRSwgRmNUcnVlKTsKICAg ICBGY0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybi5nZXQoKSwgRmNNYXRjaFBhdHRl cm4pOworICAgIGNhaXJvX2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWly b0ZvbnRPcHRpb25zKCkuZ2V0KCksIHBhdHRlcm4uZ2V0KCkpOwogICAgIEZjRGVmYXVsdFN1YnN0 aXR1dGUocGF0dGVybi5nZXQoKSk7CiAgICAgcmV0dXJuIHBhdHRlcm47CiB9CkBAIC0yNjEsNiAr MjYzLDcgQEAgc3RhdGljIFZlY3RvcjxTdHJpbmc+IHN0cm9uZ0FsaWFzZXNGb3JGYW1pbHkoY29u c3QgU3RyaW5nJiBmYW1pbHkpCiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigpOwogCiAg ICAgRmNDb25maWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0 ZXJuKTsKKyAgICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fp cm9Gb250T3B0aW9ucygpLmdldCgpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJz dGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwogCiAgICAgRmNVbmlxdWVQdHI8RmNPYmplY3RTZXQ+IGZh bWlsaWVzT25seShGY09iamVjdFNldEJ1aWxkKEZDX0ZBTUlMWSwgbnVsbHB0cikpOwpAQCAtMzU1 LDYgKzM1OCw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxGb250UGxhdGZvcm1EYXRhPiBGb250Q2FjaGU6 OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEoY29uc3QgRm9udERlCiAgICAgLy8gY29uZmlndXJhdGlv biBzdGVwLCBiZWZvcmUgYW55IG1hdGNoaW5nIG9jY3Vycywgd2UgYWxsb3cgYXJiaXRyYXJ5IGZh bWlseSBzdWJzdGl0dXRpb25zLAogICAgIC8vIHNpbmNlIHRoaXMgaXMgYW4gZXhhY3QgbWF0dGVy IG9mIHJlc3BlY3RpbmcgdGhlIHVzZXIncyBmb250IGNvbmZpZ3VyYXRpb24uCiAgICAgRmNDb25m aWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAg ICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0 aW9ucygpLmdldCgpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBh dHRlcm4uZ2V0KCkpOwogCiAgICAgRmNDaGFyOCogZm9udENvbmZpZ0ZhbWlseU5hbWVBZnRlckNv bmZpZ3VyYXRpb247CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcApp bmRleCA4NGUxYmExMTUwNzlmYjc1NWY4NmZiMWY4NzU1MDIyYmM0YmE5YzQ5Li5hMGU5MTVhYWU5 ZDJjZDYwMTg3ZmMyNmFjNWQyODg1OGYxYmFiMTVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0 Zm9ybURhdGFGcmVlVHlwZS5jcHAKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlICJDYWlyb1V0 aWxpdGllcy5oIgogI2luY2x1ZGUgIkZvbnRDYWNoZS5oIgogI2luY2x1ZGUgIkZvbnREZXNjcmlw dGlvbi5oIgorI2luY2x1ZGUgIkZyZWVUeXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlNo YXJlZEJ1ZmZlci5oIgogI2luY2x1ZGUgPGNhaXJvLWZ0Lmg+CiAjaW5jbHVkZSA8Zm9udGNvbmZp Zy9mY2ZyZWV0eXBlLmg+CkBAIC0xMDYsMTggKzEwNyw2IEBAIHN0YXRpYyB2b2lkIHNldENhaXJv Rm9udE9wdGlvbnNGcm9tRm9udENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRpb25zX3QqIG9w dGlvCiAgICAgICAgIGNhaXJvX2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShvcHRpb25zLCBD QUlST19ISU5UX1NUWUxFX05PTkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9f Zm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsKLSNpZiBQTEFU Rk9STShHVEspCi0gICAgaWYgKEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVlbl9nZXRfZGVm YXVsdCgpKSB7Ci0gICAgICAgIGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBzY3JlZW5PcHRp b25zID0gZ2RrX3NjcmVlbl9nZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAgICAgIGlmIChz Y3JlZW5PcHRpb25zKQotICAgICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2Zv bnRfb3B0aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7Ci0g ICAgfQotI2VuZGlmCi0gICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9u c190PihjYWlyb19mb250X29wdGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMgRmNQYXR0ZXJu KiBnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBzb21lIGdlbmVy aWMgZGVmYXVsdCBzZXR0aW5ncyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250cy4gU3RyYXRl Z3kKQEAgLTEyOSw2ICsxMTgsNyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNv bmZpZ09wdGlvbnMoKQogICAgIHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0dGVybiopIHsK ICAgICAgICAgcGF0dGVybiA9IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBGY0NvbmZpZ1N1 YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAgICAgICBjYWly b19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygp LmdldCgpLCBwYXR0ZXJuKTsKICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuKTsK ICAgICAgICAgRmNQYXR0ZXJuRGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAgICAgIEZjQ29u ZmlnU3Vic3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlwZUZvbnRV dGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUv RnJlZVR5cGVGb250VXRpbGl0aWVzLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43YjlkZmVmYjEwMzNmMzBlOWQz MGExNThhMTU0MDRjYzQ0OWUwMzE3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRnJlZVR5cGVGb250VXRpbGl0aWVzLmNwcApAQCAt MCwwICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBJR0FMSUEg QU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE CisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkg QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGcmVlVHlwZUZvbnRVdGlsaXRpZXMuaCIK KworI2luY2x1ZGUgPHd0Zi9QbGF0Zm9ybS5oPgorCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1 ZGUgPGdkay9nZGsuaD4KKyNlbmRpZgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0NhaXJvVW5p cXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190PiBnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygp Cit7CisjaWYgUExBVEZPUk0oR1RLKQorICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19z Y3JlZW5fZ2V0X2RlZmF1bHQoKSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNf dCogc2NyZWVuT3B0aW9ucyA9IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOwor ICAgICAgICBpZiAoc2NyZWVuT3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1 ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVu T3B0aW9ucykpOworICAgIH0KKyNlbmRpZgorICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWly b19mb250X29wdGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NyZWF0ZSgpKTsKK30KKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRnJlZVR5cGVGb250VXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlwZUZvbnRVdGlsaXRpZXMuaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5kYjU1YWExMmRiNGFkMzcxZjdkNmRhZjU1ZmI2MzcxZmZjMTFhZWRmCi0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRnJl ZVR5cGVGb250VXRpbGl0aWVzLmgKQEAgLTAsMCArMSwzNSBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxNiBJZ2FsaWEgUy5MLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgSUdBTElBIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5E IEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAq IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgIkNhaXJv VW5pcXVlUHRyLmgiCisjaW5jbHVkZSA8Y2Fpcm8uaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9u dE9wdGlvbnMoKTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQo= 294636 2016-11-12 15:15:07 -0800 2017-03-07 13:18:09 -0800 Patch bug-82889-20161112171050.patch text/plain 11534 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4NjU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTllNjM5ZDdjZmZmYWI3 NGQ4ZjE2NmEzMDc1ODE2YmVmNGY4MzYzYy4uYTE2YmIwYmIyZDUyNjAwZGQ1YzM3ZjViMDJjOTcz OTUyYmMzZWNlNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDE2LTExLTEyICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUVmbC5jbWFrZToKKyAg ICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9m cmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpjcmVhdGVG b250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2ViQ29yZTo6c3Ryb25n QWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2FjaGU6OmNyZWF0ZUZv bnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0Zv bnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpnZXREZWZhdWx0 Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVmYXVsdENhaXJvRm9u dE9wdGlvbnMpOiBEZWxldGVkLgorCiAyMDE2LTExLTEyICBDaHJpcyBEdW1leiAgPGNkdW1lekBh cHBsZS5jb20+CiAKICAgICAgICAgU3BlZWQgdXAgc2V0dGluZyBhdHRyaWJ1dGVzIG9mIGlucHV0 IGVsZW1lbnRzIG9mIHR5cGUgJ3RleHQnCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0 Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCmluZGV4IDky NDk3M2RhNTY1YmE5ZWMxY2MxMGEyMGY3YmRlZWZiNGQxNDg4ZTAuLjhjNWE0NGY1NTUyNjg1ZWEy Y2VkZTc1OGVlNTMwNmJmMDk1ZjQ0YmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRm b3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0x NTcsNiArMTU3LDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MvZnJlZXR5cGUvRm9udEN1c3RvbVBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAogICAgIHBs YXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKKyAg ICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlwZUZvbnRVdGlsaXRpZXMuY3BwCiAg ICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJlZU5vZGVGcmVlVHlwZS5j cHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVGb250RGF0YUZyZWVUeXBl LmNwcAogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZSBiL1Nv dXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4IGJhY2U0NjZkYjZlYmI4NzNkMDFl OWM0MGVmOGZlMDMzMjVmNTZiZDMuLjlkN2I4YWZiZmNmMmQ1YzFhOTI4OGVjMjZhYzQxODg5YjVm ZDFkM2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCisrKyBi L1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xMzAsNyArMTMwLDYgQEAgbGlz dChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29u dGV4dEVHTFdheWxhbmQuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVH TFgxMS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVU eXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDdXN0b21QbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9HbHlwaFBh Z2VUcmVlTm9kZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL1Np bXBsZUZvbnREYXRhRnJlZVR5cGUuY3BwCkBAIC0yMDgsNyArMjA3LDkgQEAgbGlzdChBUFBFTkQg V2ViQ29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRm b3JtRGlzcGxheS5jcHAKIAorICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNo ZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlw ZUZvbnRVdGlsaXRpZXMuY3BwCiAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9ndGsvQ29sb3JHdGsu Y3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNwcApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udENh Y2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5 cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDhlMDRiZDE4NTY0NDAzZGQxZWEwMDJmZTNl MTFlNWJhNWJhNzUxNjEuLmI4ZDI0N2RkMmE0ZThlMzE4YmU4NjAxMWY0MDRkNDQwNzUyMjgzYzMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0Zv bnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTI0LDYgKzI0LDcgQEAKIAogI2lu Y2x1ZGUgIkZjVW5pcXVlUHRyLmgiCiAjaW5jbHVkZSAiRm9udC5oIgorI2luY2x1ZGUgIkZyZWVU eXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlJlZlB0ckNhaXJvLmgiCiAjaW5jbHVkZSAi VVRGMTZVQ2hhcjMySXRlcmF0b3IuaCIKICNpbmNsdWRlIDxjYWlyby1mdC5oPgpAQCAtNTcsNiAr NTgsNyBAQCBzdGF0aWMgUmVmUHRyPEZjUGF0dGVybj4gY3JlYXRlRm9udENvbmZpZ1BhdHRlcm5G b3JDaGFyYWN0ZXJzKGNvbnN0IFVDaGFyKiBjaGFyYQogCiAgICAgRmNQYXR0ZXJuQWRkQm9vbChw YXR0ZXJuLmdldCgpLCBGQ19TQ0FMQUJMRSwgRmNUcnVlKTsKICAgICBGY0NvbmZpZ1N1YnN0aXR1 dGUobnVsbHB0ciwgcGF0dGVybi5nZXQoKSwgRmNNYXRjaFBhdHRlcm4pOworICAgIGNhaXJvX2Z0 X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkuZ2V0 KCksIHBhdHRlcm4uZ2V0KCkpOwogICAgIEZjRGVmYXVsdFN1YnN0aXR1dGUocGF0dGVybi5nZXQo KSk7CiAgICAgcmV0dXJuIHBhdHRlcm47CiB9CkBAIC0yNjEsNiArMjYzLDcgQEAgc3RhdGljIFZl Y3RvcjxTdHJpbmc+IHN0cm9uZ0FsaWFzZXNGb3JGYW1pbHkoY29uc3QgU3RyaW5nJiBmYW1pbHkp CiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigpOwogCiAgICAgRmNDb25maWdTdWJzdGl0 dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19m dF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdl dCgpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0 KCkpOwogCiAgICAgRmNVbmlxdWVQdHI8RmNPYmplY3RTZXQ+IGZhbWlsaWVzT25seShGY09iamVj dFNldEJ1aWxkKEZDX0ZBTUlMWSwgbnVsbHB0cikpOwpAQCAtMzU1LDYgKzM1OCw3IEBAIHN0ZDo6 dW5pcXVlX3B0cjxGb250UGxhdGZvcm1EYXRhPiBGb250Q2FjaGU6OmNyZWF0ZUZvbnRQbGF0Zm9y bURhdGEoY29uc3QgRm9udERlCiAgICAgLy8gY29uZmlndXJhdGlvbiBzdGVwLCBiZWZvcmUgYW55 IG1hdGNoaW5nIG9jY3Vycywgd2UgYWxsb3cgYXJiaXRyYXJ5IGZhbWlseSBzdWJzdGl0dXRpb25z LAogICAgIC8vIHNpbmNlIHRoaXMgaXMgYW4gZXhhY3QgbWF0dGVyIG9mIHJlc3BlY3RpbmcgdGhl IHVzZXIncyBmb250IGNvbmZpZ3VyYXRpb24uCiAgICAgRmNDb25maWdTdWJzdGl0dXRlKG51bGxw dHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9mb250X29w dGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgpLCBwYXR0 ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwogCiAg ICAgRmNDaGFyOCogZm9udENvbmZpZ0ZhbWlseU5hbWVBZnRlckNvbmZpZ3VyYXRpb247CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxh dGZvcm1EYXRhRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAppbmRleCA4NGUxYmExMTUwNzlm Yjc1NWY4NmZiMWY4NzU1MDIyYmM0YmE5YzQ5Li5hMGU5MTVhYWU5ZDJjZDYwMTg3ZmMyNmFjNWQy ODg1OGYxYmFiMTVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5j cHAKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlICJDYWlyb1V0aWxpdGllcy5oIgogI2luY2x1 ZGUgIkZvbnRDYWNoZS5oIgogI2luY2x1ZGUgIkZvbnREZXNjcmlwdGlvbi5oIgorI2luY2x1ZGUg IkZyZWVUeXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgogI2lu Y2x1ZGUgPGNhaXJvLWZ0Lmg+CiAjaW5jbHVkZSA8Zm9udGNvbmZpZy9mY2ZyZWV0eXBlLmg+CkBA IC0xMDYsMTggKzEwNyw2IEBAIHN0YXRpYyB2b2lkIHNldENhaXJvRm9udE9wdGlvbnNGcm9tRm9u dENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRpb25zX3QqIG9wdGlvCiAgICAgICAgIGNhaXJv X2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShvcHRpb25zLCBDQUlST19ISU5UX1NUWUxFX05P TkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdl dERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsKLSNpZiBQTEFURk9STShHVEspCi0gICAgaWYg KEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgpKSB7Ci0gICAgICAg IGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBzY3JlZW5PcHRpb25zID0gZ2RrX3NjcmVlbl9n ZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAgICAgIGlmIChzY3JlZW5PcHRpb25zKQotICAg ICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190PihjYWly b19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7Ci0gICAgfQotI2VuZGlmCi0gICAg cmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190PihjYWlyb19mb250X29w dGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNv bmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBzb21lIGdlbmVyaWMgZGVmYXVsdCBzZXR0aW5n cyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250cy4gU3RyYXRlZ3kKQEAgLTEyOSw2ICsxMTgs NyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogICAg IHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0dGVybiopIHsKICAgICAgICAgcGF0dGVybiA9 IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBGY0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwg cGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAgICAgICBjYWlyb19mdF9mb250X29wdGlvbnNf c3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgpLCBwYXR0ZXJuKTsK ICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuKTsKICAgICAgICAgRmNQYXR0ZXJu RGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAgICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShudWxs cHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9GcmVlVHlwZUZvbnRVdGlsaXRpZXMuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRnJlZVR5cGVGb250VXRpbGl0 aWVzLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi43YjlkZmVmYjEwMzNmMzBlOWQzMGExNThhMTU0MDRjYzQ0OWUw MzE3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRnJlZVR5cGVGb250VXRpbGl0aWVzLmNwcApAQCAtMCwwICsxLDQ5IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBJR0FMSUEgQU5EIElUUyBDT05UUklCVVRP UlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF CisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJGcmVlVHlwZUZvbnRVdGlsaXRpZXMuaCIKKworI2luY2x1ZGUgPHd0Zi9Q bGF0Zm9ybS5oPgorCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUgPGdkay9nZGsuaD4KKyNl bmRpZgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0NhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRf b3B0aW9uc190PiBnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpCit7CisjaWYgUExBVEZPUk0o R1RLKQorICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19zY3JlZW5fZ2V0X2RlZmF1bHQo KSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCogc2NyZWVuT3B0aW9ucyA9 IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOworICAgICAgICBpZiAoc2NyZWVu T3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29w dGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVuT3B0aW9ucykpOworICAgIH0K KyNlbmRpZgorICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4o Y2Fpcm9fZm9udF9vcHRpb25zX2NyZWF0ZSgpKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUv RnJlZVR5cGVGb250VXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9GcmVlVHlwZUZvbnRVdGlsaXRpZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kYjU1YWExMmRi NGFkMzcxZjdkNmRhZjU1ZmI2MzcxZmZjMTFhZWRmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRnJlZVR5cGVGb250VXRpbGl0aWVz LmgKQEAgLTAsMCArMSwzNSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5M LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEu ICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg SUdBTElBIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgIkNhaXJvVW5pcXVlUHRyLmgiCisjaW5j bHVkZSA8Y2Fpcm8uaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDYWlyb1VuaXF1ZVB0cjxj YWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKTsKKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQo= 303711 2017-03-07 13:18:15 -0800 2017-03-07 13:45:07 -0800 Patch bug-82889-20170307151814.patch text/plain 9822 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEzNTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWE3MmM2NmQ2ZWQ4NjZl MDdjYTJiZTQ1OTJjNjkxZDVkZWM2NzA4MC4uOGE1ZGI2YjM4MGFhMzYwOGUxNTVmOGE3ZTUwYWQ2 ZDMwODkxZmIzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTA3ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMDcgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hyaXN0ZW5z ZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVudCBFeHRlbnNpb25zXSBSZW5hbWUgIkRv bWFpbiIgdG8gIkNvbmRpdGlvbiIgd2hlcmUgYXBwcm9wcmlhdGUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsu Y21ha2UKaW5kZXggM2NkMGRiOWJlZjI0ZTM2MjFiMDgxN2Y1YjQ2MWMyNGY0NDI4N2ZjNy4uMzdm ZDY3OWQ1Y2NkOWIzOTIyNDdiNDBjOTRjZjIyZDE4MWFiNzMzYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTExMiw2ICsxMTIsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK IAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVl VHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRh RnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJl ZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVG b250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0xODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2Vi Q29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5j cHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAg cGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25HdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXgg MWZkNTFkNzZlNzc0ZjFkODNiOWJlZjQ3MTA3MDdhNGM0NDgzYzU2OC4uZTBmNWJiOGUzN2JkZTRl YWEwMzI2ZmU2N2JhNzRkNDQ4YTdjNmMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtNDcsNiAr NDcsMTMgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAh UExBVEZPUk0oR1RLKQorQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERl ZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKK3sKKyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fp cm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CisjZW5k aWYKKwogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMoY2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3Qq IGRzdENyKQogewogICAgIGNhaXJvX3NldF9hbnRpYWxpYXMoZHN0Q3IsIGNhaXJvX2dldF9hbnRp YWxpYXMoc3JjQ3IpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oCmluZGV4IDQ4NjI5MWQzMTA3Nzg1NmJkZGM3MGVi NGU5YWVjNjEwNTc5NTE5YzYuLmZkOWUxMjg0YTRmMDEzNzQxNzg1OWViODQ0OWQ3ZmI0YjllNDlm NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0Nh aXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vQ2Fpcm9VdGlsaXRpZXMuaApAQCAtMjQsMTQgKzI0LDEzIEBACiAgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog ICovCiAKLSNpZm5kZWYgQ2Fpcm9VdGlsaXRpZXNfaAotI2RlZmluZSBDYWlyb1V0aWxpdGllc19o CisjcHJhZ21hIG9uY2UKIAogI2lmIFVTRShDQUlSTykKIAorI2luY2x1ZGUgIkNhaXJvVW5pcXVl UHRyLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIK LSNpbmNsdWRlIDxjYWlyby5oPgogCiAvLyBUaGlzIGZ1bmN0aW9uIHdhcyBhZGRlZCBwcmV0dHkg bXVjaCBzaW11bHRhbmVvdXMgdG8gd2hlbiAxLjEzIHdhcyBicmFuY2hlZC4KICNkZWZpbmUgSEFW RV9DQUlST19TVVJGQUNFX1NFVF9ERVZJQ0VfU0NBTEUgQ0FJUk9fVkVSU0lPTl9NQUpPUiA+IDEg fHwgKENBSVJPX1ZFUlNJT05fTUFKT1IgPT0gMSAmJiBDQUlST19WRVJTSU9OX01JTk9SID49IDEz KQpAQCAtNzEsNiArNzAsOCBAQCBwcml2YXRlOgogICAgIGNhaXJvX3NjYWxlZF9mb250X3QqIG1f c2NhbGVkRm9udCB7IG51bGxwdHIgfTsKICAgICBGVF9GYWNlIG1fZnRGYWNlIHsgbnVsbHB0ciB9 OwogfTsKKworQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRD YWlyb0ZvbnRPcHRpb25zKCk7CiAjZW5kaWYKIAogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMo Y2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3QqIGRzdENyKTsKQEAgLTk4LDUgKzk5LDMgQEAgUmVmUHRy PGNhaXJvX3JlZ2lvbl90PiB0b0NhaXJvUmVnaW9uKGNvbnN0IFJlZ2lvbiYpOwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJPKQotCi0jZW5kaWYgLy8gQ2Fpcm9V dGlsaXRpZXNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDIxMWNmZmI3MTU0 ZmUwNWZkNmM4MWNiMDkxOWUwZTlhZDM4ZjE2NjguLmI4OWJkZTdmNjMxZmQ2YWJmZjA5Yzg5NTJh M2I4N2QxOWE5OTZjNTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTI0LDYg KzI0LDcgQEAKIAogI2luY2x1ZGUgIkZjVW5pcXVlUHRyLmgiCiAjaW5jbHVkZSAiRm9udC5oIgor I2luY2x1ZGUgIkZyZWVUeXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlJlZlB0ckNhaXJv LmgiCiAjaW5jbHVkZSAiVVRGMTZVQ2hhcjMySXRlcmF0b3IuaCIKICNpbmNsdWRlIDxjYWlyby1m dC5oPgpAQCAtNTcsNiArNTgsNyBAQCBzdGF0aWMgUmVmUHRyPEZjUGF0dGVybj4gY3JlYXRlRm9u dENvbmZpZ1BhdHRlcm5Gb3JDaGFyYWN0ZXJzKGNvbnN0IFVDaGFyKiBjaGFyYQogCiAgICAgRmNQ YXR0ZXJuQWRkQm9vbChwYXR0ZXJuLmdldCgpLCBGQ19TQ0FMQUJMRSwgRmNUcnVlKTsKICAgICBG Y0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybi5nZXQoKSwgRmNNYXRjaFBhdHRlcm4p OworICAgIGNhaXJvX2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWlyb0Zv bnRPcHRpb25zKCkuZ2V0KCksIHBhdHRlcm4uZ2V0KCkpOwogICAgIEZjRGVmYXVsdFN1YnN0aXR1 dGUocGF0dGVybi5nZXQoKSk7CiAgICAgcmV0dXJuIHBhdHRlcm47CiB9CkBAIC0yNjAsNiArMjYy LDcgQEAgc3RhdGljIFZlY3RvcjxTdHJpbmc+IHN0cm9uZ0FsaWFzZXNGb3JGYW1pbHkoY29uc3Qg U3RyaW5nJiBmYW1pbHkpCiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigpOwogCiAgICAg RmNDb25maWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJu KTsKKyAgICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucygpLmdldCgpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0 dXRlKHBhdHRlcm4uZ2V0KCkpOwogCiAgICAgRmNVbmlxdWVQdHI8RmNPYmplY3RTZXQ+IGZhbWls aWVzT25seShGY09iamVjdFNldEJ1aWxkKEZDX0ZBTUlMWSwgbnVsbHB0cikpOwpAQCAtMzU0LDYg KzM1Nyw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxGb250UGxhdGZvcm1EYXRhPiBGb250Q2FjaGU6OmNy ZWF0ZUZvbnRQbGF0Zm9ybURhdGEoY29uc3QgRm9udERlCiAgICAgLy8gY29uZmlndXJhdGlvbiBz dGVwLCBiZWZvcmUgYW55IG1hdGNoaW5nIG9jY3Vycywgd2UgYWxsb3cgYXJiaXRyYXJ5IGZhbWls eSBzdWJzdGl0dXRpb25zLAogICAgIC8vIHNpbmNlIHRoaXMgaXMgYW4gZXhhY3QgbWF0dGVyIG9m IHJlc3BlY3RpbmcgdGhlIHVzZXIncyBmb250IGNvbmZpZ3VyYXRpb24uCiAgICAgRmNDb25maWdT dWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBj YWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9u cygpLmdldCgpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRl cm4uZ2V0KCkpOwogCiAgICAgRmNDaGFyOCogZm9udENvbmZpZ0ZhbWlseU5hbWVBZnRlckNvbmZp Z3VyYXRpb247CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9m cmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAppbmRl eCBiMDViNTRhNTY2Mzk2YmI2ODBlYjdlYmRmODhlNzM1NTFiMjBiZThkLi5mYTczYThkYTM3Mzc5 MGViYjk2MWQ0YmY0MWQ1ZGI3MmNjMjU1ZTFlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlICJDYWlyb1V0aWxp dGllcy5oIgogI2luY2x1ZGUgIkZvbnRDYWNoZS5oIgogI2luY2x1ZGUgIkZvbnREZXNjcmlwdGlv bi5oIgorI2luY2x1ZGUgIkZyZWVUeXBlRm9udFV0aWxpdGllcy5oIgogI2luY2x1ZGUgIlNoYXJl ZEJ1ZmZlci5oIgogI2luY2x1ZGUgPGNhaXJvLWZ0Lmg+CiAjaW5jbHVkZSA8Zm9udGNvbmZpZy9m Y2ZyZWV0eXBlLmg+CkBAIC0zNywxMCArMzgsNiBAQAogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFz Lmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKLSNpZiBQTEFURk9STShHVEsp Ci0jaW5jbHVkZSA8Z2RrL2dkay5oPgotI2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog c3RhdGljIGNhaXJvX3N1YnBpeGVsX29yZGVyX3QgY29udmVydEZvbnRDb25maWdTdWJwaXhlbE9y ZGVyKGludCBmb250Q29uZmlnT3JkZXIpCkBAIC0xMDYsMTggKzEwMyw2IEBAIHN0YXRpYyB2b2lk IHNldENhaXJvRm9udE9wdGlvbnNGcm9tRm9udENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRp b25zX3QqIG9wdGlvCiAgICAgICAgIGNhaXJvX2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShv cHRpb25zLCBDQUlST19ISU5UX1NUWUxFX05PTkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQ dHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsK LSNpZiBQTEFURk9STShHVEspCi0gICAgaWYgKEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVl bl9nZXRfZGVmYXVsdCgpKSB7Ci0gICAgICAgIGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBz Y3JlZW5PcHRpb25zID0gZ2RrX3NjcmVlbl9nZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAg ICAgIGlmIChzY3JlZW5PcHRpb25zKQotICAgICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRy PGNhaXJvX2ZvbnRfb3B0aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRp b25zKSk7Ci0gICAgfQotI2VuZGlmCi0gICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2Zv bnRfb3B0aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMg RmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBz b21lIGdlbmVyaWMgZGVmYXVsdCBzZXR0aW5ncyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250 cy4gU3RyYXRlZ3kKQEAgLTEyOSw2ICsxMTQsNyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZh dWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogICAgIHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0 dGVybiopIHsKICAgICAgICAgcGF0dGVybiA9IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBG Y0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAg ICAgICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250 T3B0aW9ucygpLmdldCgpLCBwYXR0ZXJuKTsKICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShw YXR0ZXJuKTsKICAgICAgICAgRmNQYXR0ZXJuRGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAg ICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9V dGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0Nh aXJvVXRpbGl0aWVzLmNwcAppbmRleCA4NGNmMzlhM2IyNTgzMTkwMTU5NzYwM2E2NmMxNzI0YWQ1 Mzc3YWEwLi5lYjNjZjBhNzEwZWM1NzRlYWExZGIxOGI3YjEyZTdlNmE1MGQzZGE1IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRp ZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWly b1V0aWxpdGllcy5jcHAKQEAgLTM0LDYgKzM0LDE1IEBACiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCitDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENh aXJvRm9udE9wdGlvbnMoKQoreworICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19zY3Jl ZW5fZ2V0X2RlZmF1bHQoKSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCog c2NyZWVuT3B0aW9ucyA9IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOworICAg ICAgICBpZiAoc2NyZWVuT3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0 cjxjYWlyb19mb250X29wdGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVuT3B0 aW9ucykpOworICAgIH0KK30KKwogR2RrUGl4YnVmKiBjYWlyb1N1cmZhY2VUb0dka1BpeGJ1Zihj YWlyb19zdXJmYWNlX3QqIHN1cmZhY2UpCiB7CiAgICAgSW50U2l6ZSBzaXplID0gY2Fpcm9TdXJm YWNlU2l6ZShzdXJmYWNlKTsK 303719 2017-03-07 13:45:13 -0800 2017-03-07 15:01:53 -0800 Patch bug-82889-20170307154512.patch text/plain 9579 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEzNTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWE3MmM2NmQ2ZWQ4NjZl MDdjYTJiZTQ1OTJjNjkxZDVkZWM2NzA4MC4uOGE1ZGI2YjM4MGFhMzYwOGUxNTVmOGE3ZTUwYWQ2 ZDMwODkxZmIzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTA3ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMDcgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hyaXN0ZW5z ZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVudCBFeHRlbnNpb25zXSBSZW5hbWUgIkRv bWFpbiIgdG8gIkNvbmRpdGlvbiIgd2hlcmUgYXBwcm9wcmlhdGUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsu Y21ha2UKaW5kZXggM2NkMGRiOWJlZjI0ZTM2MjFiMDgxN2Y1YjQ2MWMyNGY0NDI4N2ZjNy4uMzdm ZDY3OWQ1Y2NkOWIzOTIyNDdiNDBjOTRjZjIyZDE4MWFiNzMzYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTExMiw2ICsxMTIsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK IAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVl VHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRh RnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJl ZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVG b250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0xODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2Vi Q29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5j cHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAg cGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25HdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXgg MWZkNTFkNzZlNzc0ZjFkODNiOWJlZjQ3MTA3MDdhNGM0NDgzYzU2OC4uZTBmNWJiOGUzN2JkZTRl YWEwMzI2ZmU2N2JhNzRkNDQ4YTdjNmMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtNDcsNiAr NDcsMTMgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAh UExBVEZPUk0oR1RLKQorQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERl ZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKK3sKKyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fp cm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CisjZW5k aWYKKwogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMoY2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3Qq IGRzdENyKQogewogICAgIGNhaXJvX3NldF9hbnRpYWxpYXMoZHN0Q3IsIGNhaXJvX2dldF9hbnRp YWxpYXMoc3JjQ3IpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oCmluZGV4IDQ4NjI5MWQzMTA3Nzg1NmJkZGM3MGVi NGU5YWVjNjEwNTc5NTE5YzYuLmZkOWUxMjg0YTRmMDEzNzQxNzg1OWViODQ0OWQ3ZmI0YjllNDlm NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0Nh aXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vQ2Fpcm9VdGlsaXRpZXMuaApAQCAtMjQsMTQgKzI0LDEzIEBACiAgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog ICovCiAKLSNpZm5kZWYgQ2Fpcm9VdGlsaXRpZXNfaAotI2RlZmluZSBDYWlyb1V0aWxpdGllc19o CisjcHJhZ21hIG9uY2UKIAogI2lmIFVTRShDQUlSTykKIAorI2luY2x1ZGUgIkNhaXJvVW5pcXVl UHRyLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIK LSNpbmNsdWRlIDxjYWlyby5oPgogCiAvLyBUaGlzIGZ1bmN0aW9uIHdhcyBhZGRlZCBwcmV0dHkg bXVjaCBzaW11bHRhbmVvdXMgdG8gd2hlbiAxLjEzIHdhcyBicmFuY2hlZC4KICNkZWZpbmUgSEFW RV9DQUlST19TVVJGQUNFX1NFVF9ERVZJQ0VfU0NBTEUgQ0FJUk9fVkVSU0lPTl9NQUpPUiA+IDEg fHwgKENBSVJPX1ZFUlNJT05fTUFKT1IgPT0gMSAmJiBDQUlST19WRVJTSU9OX01JTk9SID49IDEz KQpAQCAtNzEsNiArNzAsOCBAQCBwcml2YXRlOgogICAgIGNhaXJvX3NjYWxlZF9mb250X3QqIG1f c2NhbGVkRm9udCB7IG51bGxwdHIgfTsKICAgICBGVF9GYWNlIG1fZnRGYWNlIHsgbnVsbHB0ciB9 OwogfTsKKworQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRD YWlyb0ZvbnRPcHRpb25zKCk7CiAjZW5kaWYKIAogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMo Y2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3QqIGRzdENyKTsKQEAgLTk4LDUgKzk5LDMgQEAgUmVmUHRy PGNhaXJvX3JlZ2lvbl90PiB0b0NhaXJvUmVnaW9uKGNvbnN0IFJlZ2lvbiYpOwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJPKQotCi0jZW5kaWYgLy8gQ2Fpcm9V dGlsaXRpZXNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDIxMWNmZmI3MTU0 ZmUwNWZkNmM4MWNiMDkxOWUwZTlhZDM4ZjE2NjguLjhkMDYzN2RjYmJjNmIxNTU1ODdhYjk5OTJm ODc2ZjVmMDUzNWUyY2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTIyLDYg KzIyLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJGb250Q2FjaGUuaCIKIAor I2luY2x1ZGUgIkNhaXJvVXRpbGl0aWVzLmgiCiAjaW5jbHVkZSAiRmNVbmlxdWVQdHIuaCIKICNp bmNsdWRlICJGb250LmgiCiAjaW5jbHVkZSAiUmVmUHRyQ2Fpcm8uaCIKQEAgLTU3LDYgKzU4LDcg QEAgc3RhdGljIFJlZlB0cjxGY1BhdHRlcm4+IGNyZWF0ZUZvbnRDb25maWdQYXR0ZXJuRm9yQ2hh cmFjdGVycyhjb25zdCBVQ2hhciogY2hhcmEKIAogICAgIEZjUGF0dGVybkFkZEJvb2wocGF0dGVy bi5nZXQoKSwgRkNfU0NBTEFCTEUsIEZjVHJ1ZSk7CiAgICAgRmNDb25maWdTdWJzdGl0dXRlKG51 bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9mb250 X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgpLCBw YXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwog ICAgIHJldHVybiBwYXR0ZXJuOwogfQpAQCAtMjYwLDYgKzI2Miw3IEBAIHN0YXRpYyBWZWN0b3I8 U3RyaW5nPiBzdHJvbmdBbGlhc2VzRm9yRmFtaWx5KGNvbnN0IFN0cmluZyYgZmFtaWx5KQogICAg ICAgICByZXR1cm4gVmVjdG9yPFN0cmluZz4oKTsKIAogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShu dWxscHRyLCBwYXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwg cGF0dGVybi5nZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsK IAogICAgIEZjVW5pcXVlUHRyPEZjT2JqZWN0U2V0PiBmYW1pbGllc09ubHkoRmNPYmplY3RTZXRC dWlsZChGQ19GQU1JTFksIG51bGxwdHIpKTsKQEAgLTM1NCw2ICszNTcsNyBAQCBzdGQ6OnVuaXF1 ZV9wdHI8Rm9udFBsYXRmb3JtRGF0YT4gRm9udENhY2hlOjpjcmVhdGVGb250UGxhdGZvcm1EYXRh KGNvbnN0IEZvbnREZQogICAgIC8vIGNvbmZpZ3VyYXRpb24gc3RlcCwgYmVmb3JlIGFueSBtYXRj aGluZyBvY2N1cnMsIHdlIGFsbG93IGFyYml0cmFyeSBmYW1pbHkgc3Vic3RpdHV0aW9ucywKICAg ICAvLyBzaW5jZSB0aGlzIGlzIGFuIGV4YWN0IG1hdHRlciBvZiByZXNwZWN0aW5nIHRoZSB1c2Vy J3MgZm9udCBjb25maWd1cmF0aW9uLgogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShudWxscHRyLCBw YXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9udF9vcHRpb25z X3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwgcGF0dGVybi5n ZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsKIAogICAgIEZj Q2hhcjgqIGZvbnRDb25maWdGYW1pbHlOYW1lQWZ0ZXJDb25maWd1cmF0aW9uOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3Jt RGF0YUZyZWVUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKaW5kZXggYjA1YjU0YTU2NjM5NmJiNjgw ZWI3ZWJkZjg4ZTczNTUxYjIwYmU4ZC4uYWRhYTQwM2UyMDBkMzE3Mzg4ODk5NWE4MzdkNTExZDg0 ZWYwN2U5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJl ZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCkBA IC0zNywxMCArMzcsNiBAQAogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKLSNpZiBQTEFURk9STShHVEspCi0jaW5jbHVkZSA8Z2Rr L2dkay5oPgotI2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIGNhaXJvX3N1 YnBpeGVsX29yZGVyX3QgY29udmVydEZvbnRDb25maWdTdWJwaXhlbE9yZGVyKGludCBmb250Q29u ZmlnT3JkZXIpCkBAIC0xMDYsMTggKzEwMiw2IEBAIHN0YXRpYyB2b2lkIHNldENhaXJvRm9udE9w dGlvbnNGcm9tRm9udENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRpb25zX3QqIG9wdGlvCiAg ICAgICAgIGNhaXJvX2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShvcHRpb25zLCBDQUlST19I SU5UX1NUWUxFX05PTkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9v cHRpb25zX3Q+IGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsKLSNpZiBQTEFURk9STShH VEspCi0gICAgaWYgKEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgp KSB7Ci0gICAgICAgIGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBzY3JlZW5PcHRpb25zID0g Z2RrX3NjcmVlbl9nZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAgICAgIGlmIChzY3JlZW5P cHRpb25zKQotICAgICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0 aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7Ci0gICAgfQot I2VuZGlmCi0gICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190Pihj YWlyb19mb250X29wdGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMgRmNQYXR0ZXJuKiBnZXRE ZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBzb21lIGdlbmVyaWMgZGVm YXVsdCBzZXR0aW5ncyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250cy4gU3RyYXRlZ3kKQEAg LTEyOSw2ICsxMTMsNyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNvbmZpZ09w dGlvbnMoKQogICAgIHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0dGVybiopIHsKICAgICAg ICAgcGF0dGVybiA9IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBGY0NvbmZpZ1N1YnN0aXR1 dGUobnVsbHB0ciwgcGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAgICAgICBjYWlyb19mdF9m b250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgp LCBwYXR0ZXJuKTsKICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuKTsKICAgICAg ICAgRmNQYXR0ZXJuRGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAgICAgIEZjQ29uZmlnU3Vi c3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNw cAppbmRleCA4NGNmMzlhM2IyNTgzMTkwMTU5NzYwM2E2NmMxNzI0YWQ1Mzc3YWEwLi5lYjNjZjBh NzEwZWM1NzRlYWExZGIxOGI3YjEyZTdlNmE1MGQzZGE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAK QEAgLTM0LDYgKzM0LDE1IEBACiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCitDYWlyb1Vu aXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMo KQoreworICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19zY3JlZW5fZ2V0X2RlZmF1bHQo KSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCogc2NyZWVuT3B0aW9ucyA9 IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOworICAgICAgICBpZiAoc2NyZWVu T3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29w dGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVuT3B0aW9ucykpOworICAgIH0K K30KKwogR2RrUGl4YnVmKiBjYWlyb1N1cmZhY2VUb0dka1BpeGJ1ZihjYWlyb19zdXJmYWNlX3Qq IHN1cmZhY2UpCiB7CiAgICAgSW50U2l6ZSBzaXplID0gY2Fpcm9TdXJmYWNlU2l6ZShzdXJmYWNl KTsK 303730 2017-03-07 15:01:59 -0800 2017-03-07 15:11:37 -0800 Patch bug-82889-20170307170158.patch text/plain 9658 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEzNTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWE3MmM2NmQ2ZWQ4NjZl MDdjYTJiZTQ1OTJjNjkxZDVkZWM2NzA4MC4uOGE1ZGI2YjM4MGFhMzYwOGUxNTVmOGE3ZTUwYWQ2 ZDMwODkxZmIzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTA3ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMDcgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hyaXN0ZW5z ZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVudCBFeHRlbnNpb25zXSBSZW5hbWUgIkRv bWFpbiIgdG8gIkNvbmRpdGlvbiIgd2hlcmUgYXBwcm9wcmlhdGUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsu Y21ha2UKaW5kZXggM2NkMGRiOWJlZjI0ZTM2MjFiMDgxN2Y1YjQ2MWMyNGY0NDI4N2ZjNy4uMzdm ZDY3OWQ1Y2NkOWIzOTIyNDdiNDBjOTRjZjIyZDE4MWFiNzMzYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTExMiw2ICsxMTIsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK IAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVl VHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRh RnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJl ZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVG b250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0xODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2Vi Q29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5j cHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAg cGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25HdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXgg MWZkNTFkNzZlNzc0ZjFkODNiOWJlZjQ3MTA3MDdhNGM0NDgzYzU2OC4uZTBmNWJiOGUzN2JkZTRl YWEwMzI2ZmU2N2JhNzRkNDQ4YTdjNmMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtNDcsNiAr NDcsMTMgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAh UExBVEZPUk0oR1RLKQorQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERl ZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKK3sKKyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fp cm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CisjZW5k aWYKKwogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMoY2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3Qq IGRzdENyKQogewogICAgIGNhaXJvX3NldF9hbnRpYWxpYXMoZHN0Q3IsIGNhaXJvX2dldF9hbnRp YWxpYXMoc3JjQ3IpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oCmluZGV4IDQ4NjI5MWQzMTA3Nzg1NmJkZGM3MGVi NGU5YWVjNjEwNTc5NTE5YzYuLmZkOWUxMjg0YTRmMDEzNzQxNzg1OWViODQ0OWQ3ZmI0YjllNDlm NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0Nh aXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vQ2Fpcm9VdGlsaXRpZXMuaApAQCAtMjQsMTQgKzI0LDEzIEBACiAgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog ICovCiAKLSNpZm5kZWYgQ2Fpcm9VdGlsaXRpZXNfaAotI2RlZmluZSBDYWlyb1V0aWxpdGllc19o CisjcHJhZ21hIG9uY2UKIAogI2lmIFVTRShDQUlSTykKIAorI2luY2x1ZGUgIkNhaXJvVW5pcXVl UHRyLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIK LSNpbmNsdWRlIDxjYWlyby5oPgogCiAvLyBUaGlzIGZ1bmN0aW9uIHdhcyBhZGRlZCBwcmV0dHkg bXVjaCBzaW11bHRhbmVvdXMgdG8gd2hlbiAxLjEzIHdhcyBicmFuY2hlZC4KICNkZWZpbmUgSEFW RV9DQUlST19TVVJGQUNFX1NFVF9ERVZJQ0VfU0NBTEUgQ0FJUk9fVkVSU0lPTl9NQUpPUiA+IDEg fHwgKENBSVJPX1ZFUlNJT05fTUFKT1IgPT0gMSAmJiBDQUlST19WRVJTSU9OX01JTk9SID49IDEz KQpAQCAtNzEsNiArNzAsOCBAQCBwcml2YXRlOgogICAgIGNhaXJvX3NjYWxlZF9mb250X3QqIG1f c2NhbGVkRm9udCB7IG51bGxwdHIgfTsKICAgICBGVF9GYWNlIG1fZnRGYWNlIHsgbnVsbHB0ciB9 OwogfTsKKworQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRD YWlyb0ZvbnRPcHRpb25zKCk7CiAjZW5kaWYKIAogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMo Y2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3QqIGRzdENyKTsKQEAgLTk4LDUgKzk5LDMgQEAgUmVmUHRy PGNhaXJvX3JlZ2lvbl90PiB0b0NhaXJvUmVnaW9uKGNvbnN0IFJlZ2lvbiYpOwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJPKQotCi0jZW5kaWYgLy8gQ2Fpcm9V dGlsaXRpZXNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDIxMWNmZmI3MTU0 ZmUwNWZkNmM4MWNiMDkxOWUwZTlhZDM4ZjE2NjguLjhkMDYzN2RjYmJjNmIxNTU1ODdhYjk5OTJm ODc2ZjVmMDUzNWUyY2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTIyLDYg KzIyLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJGb250Q2FjaGUuaCIKIAor I2luY2x1ZGUgIkNhaXJvVXRpbGl0aWVzLmgiCiAjaW5jbHVkZSAiRmNVbmlxdWVQdHIuaCIKICNp bmNsdWRlICJGb250LmgiCiAjaW5jbHVkZSAiUmVmUHRyQ2Fpcm8uaCIKQEAgLTU3LDYgKzU4LDcg QEAgc3RhdGljIFJlZlB0cjxGY1BhdHRlcm4+IGNyZWF0ZUZvbnRDb25maWdQYXR0ZXJuRm9yQ2hh cmFjdGVycyhjb25zdCBVQ2hhciogY2hhcmEKIAogICAgIEZjUGF0dGVybkFkZEJvb2wocGF0dGVy bi5nZXQoKSwgRkNfU0NBTEFCTEUsIEZjVHJ1ZSk7CiAgICAgRmNDb25maWdTdWJzdGl0dXRlKG51 bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9mb250 X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgpLCBw YXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwog ICAgIHJldHVybiBwYXR0ZXJuOwogfQpAQCAtMjYwLDYgKzI2Miw3IEBAIHN0YXRpYyBWZWN0b3I8 U3RyaW5nPiBzdHJvbmdBbGlhc2VzRm9yRmFtaWx5KGNvbnN0IFN0cmluZyYgZmFtaWx5KQogICAg ICAgICByZXR1cm4gVmVjdG9yPFN0cmluZz4oKTsKIAogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShu dWxscHRyLCBwYXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwg cGF0dGVybi5nZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsK IAogICAgIEZjVW5pcXVlUHRyPEZjT2JqZWN0U2V0PiBmYW1pbGllc09ubHkoRmNPYmplY3RTZXRC dWlsZChGQ19GQU1JTFksIG51bGxwdHIpKTsKQEAgLTM1NCw2ICszNTcsNyBAQCBzdGQ6OnVuaXF1 ZV9wdHI8Rm9udFBsYXRmb3JtRGF0YT4gRm9udENhY2hlOjpjcmVhdGVGb250UGxhdGZvcm1EYXRh KGNvbnN0IEZvbnREZQogICAgIC8vIGNvbmZpZ3VyYXRpb24gc3RlcCwgYmVmb3JlIGFueSBtYXRj aGluZyBvY2N1cnMsIHdlIGFsbG93IGFyYml0cmFyeSBmYW1pbHkgc3Vic3RpdHV0aW9ucywKICAg ICAvLyBzaW5jZSB0aGlzIGlzIGFuIGV4YWN0IG1hdHRlciBvZiByZXNwZWN0aW5nIHRoZSB1c2Vy J3MgZm9udCBjb25maWd1cmF0aW9uLgogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShudWxscHRyLCBw YXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9udF9vcHRpb25z X3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwgcGF0dGVybi5n ZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsKIAogICAgIEZj Q2hhcjgqIGZvbnRDb25maWdGYW1pbHlOYW1lQWZ0ZXJDb25maWd1cmF0aW9uOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3Jt RGF0YUZyZWVUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKaW5kZXggYjA1YjU0YTU2NjM5NmJiNjgw ZWI3ZWJkZjg4ZTczNTUxYjIwYmU4ZC4uYWRhYTQwM2UyMDBkMzE3Mzg4ODk5NWE4MzdkNTExZDg0 ZWYwN2U5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJl ZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCkBA IC0zNywxMCArMzcsNiBAQAogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKLSNpZiBQTEFURk9STShHVEspCi0jaW5jbHVkZSA8Z2Rr L2dkay5oPgotI2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIGNhaXJvX3N1 YnBpeGVsX29yZGVyX3QgY29udmVydEZvbnRDb25maWdTdWJwaXhlbE9yZGVyKGludCBmb250Q29u ZmlnT3JkZXIpCkBAIC0xMDYsMTggKzEwMiw2IEBAIHN0YXRpYyB2b2lkIHNldENhaXJvRm9udE9w dGlvbnNGcm9tRm9udENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRpb25zX3QqIG9wdGlvCiAg ICAgICAgIGNhaXJvX2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShvcHRpb25zLCBDQUlST19I SU5UX1NUWUxFX05PTkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9v cHRpb25zX3Q+IGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsKLSNpZiBQTEFURk9STShH VEspCi0gICAgaWYgKEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgp KSB7Ci0gICAgICAgIGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBzY3JlZW5PcHRpb25zID0g Z2RrX3NjcmVlbl9nZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAgICAgIGlmIChzY3JlZW5P cHRpb25zKQotICAgICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0 aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7Ci0gICAgfQot I2VuZGlmCi0gICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190Pihj YWlyb19mb250X29wdGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMgRmNQYXR0ZXJuKiBnZXRE ZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBzb21lIGdlbmVyaWMgZGVm YXVsdCBzZXR0aW5ncyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250cy4gU3RyYXRlZ3kKQEAg LTEyOSw2ICsxMTMsNyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNvbmZpZ09w dGlvbnMoKQogICAgIHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0dGVybiopIHsKICAgICAg ICAgcGF0dGVybiA9IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBGY0NvbmZpZ1N1YnN0aXR1 dGUobnVsbHB0ciwgcGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAgICAgICBjYWlyb19mdF9m b250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgp LCBwYXR0ZXJuKTsKICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuKTsKICAgICAg ICAgRmNQYXR0ZXJuRGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAgICAgIEZjQ29uZmlnU3Vi c3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNw cAppbmRleCA4NGNmMzlhM2IyNTgzMTkwMTU5NzYwM2E2NmMxNzI0YWQ1Mzc3YWEwLi4wOTcyNDhk YzVjYzA0MWUwZjc0OTZjMGI3NWYxNTM3MGNiN2Y3OTcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAK QEAgLTM0LDYgKzM0LDE2IEBACiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCitDYWlyb1Vu aXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMo KQoreworICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19zY3JlZW5fZ2V0X2RlZmF1bHQo KSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCogc2NyZWVuT3B0aW9ucyA9 IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOworICAgICAgICBpZiAoc2NyZWVu T3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29w dGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVuT3B0aW9ucykpOworICAgIH0K KyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2Zv bnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CisKIEdka1BpeGJ1ZiogY2Fpcm9TdXJmYWNlVG9HZGtQ aXhidWYoY2Fpcm9fc3VyZmFjZV90KiBzdXJmYWNlKQogewogICAgIEludFNpemUgc2l6ZSA9IGNh aXJvU3VyZmFjZVNpemUoc3VyZmFjZSk7Cg== 303733 2017-03-07 15:11:43 -0800 2017-03-17 08:38:18 -0700 Patch bug-82889-20170307171142.patch text/plain 10484 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEzNTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWE3MmM2NmQ2ZWQ4NjZl MDdjYTJiZTQ1OTJjNjkxZDVkZWM2NzA4MC4uOGE1ZGI2YjM4MGFhMzYwOGUxNTVmOGE3ZTUwYWQ2 ZDMwODkxZmIzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTA3ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMDcgIEFsZXggQ2hyaXN0ZW5zZW4gIDxhY2hyaXN0ZW5z ZW5Ad2Via2l0Lm9yZz4KIAogICAgICAgICBbQ29udGVudCBFeHRlbnNpb25zXSBSZW5hbWUgIkRv bWFpbiIgdG8gIkNvbmRpdGlvbiIgd2hlcmUgYXBwcm9wcmlhdGUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsu Y21ha2UKaW5kZXggM2NkMGRiOWJlZjI0ZTM2MjFiMDgxN2Y1YjQ2MWMyNGY0NDI4N2ZjNy4uMzdm ZDY3OWQ1Y2NkOWIzOTIyNDdiNDBjOTRjZjIyZDE4MWFiNzMzYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTExMiw2ICsxMTIsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK IAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVl VHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRh RnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJl ZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVG b250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0xODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2Vi Q29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9y bURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5j cHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAg cGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25HdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXgg MWZkNTFkNzZlNzc0ZjFkODNiOWJlZjQ3MTA3MDdhNGM0NDgzYzU2OC4uZTBmNWJiOGUzN2JkZTRl YWEwMzI2ZmU2N2JhNzRkNDQ4YTdjNmMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtNDcsNiAr NDcsMTMgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAh UExBVEZPUk0oR1RLKQorQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERl ZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKK3sKKyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fp cm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CisjZW5k aWYKKwogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMoY2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3Qq IGRzdENyKQogewogICAgIGNhaXJvX3NldF9hbnRpYWxpYXMoZHN0Q3IsIGNhaXJvX2dldF9hbnRp YWxpYXMoc3JjQ3IpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oCmluZGV4IDQ4NjI5MWQzMTA3Nzg1NmJkZGM3MGVi NGU5YWVjNjEwNTc5NTE5YzYuLmZkOWUxMjg0YTRmMDEzNzQxNzg1OWViODQ0OWQ3ZmI0YjllNDlm NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0Nh aXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fp cm8vQ2Fpcm9VdGlsaXRpZXMuaApAQCAtMjQsMTQgKzI0LDEzIEBACiAgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog ICovCiAKLSNpZm5kZWYgQ2Fpcm9VdGlsaXRpZXNfaAotI2RlZmluZSBDYWlyb1V0aWxpdGllc19o CisjcHJhZ21hIG9uY2UKIAogI2lmIFVTRShDQUlSTykKIAorI2luY2x1ZGUgIkNhaXJvVW5pcXVl UHRyLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIK LSNpbmNsdWRlIDxjYWlyby5oPgogCiAvLyBUaGlzIGZ1bmN0aW9uIHdhcyBhZGRlZCBwcmV0dHkg bXVjaCBzaW11bHRhbmVvdXMgdG8gd2hlbiAxLjEzIHdhcyBicmFuY2hlZC4KICNkZWZpbmUgSEFW RV9DQUlST19TVVJGQUNFX1NFVF9ERVZJQ0VfU0NBTEUgQ0FJUk9fVkVSU0lPTl9NQUpPUiA+IDEg fHwgKENBSVJPX1ZFUlNJT05fTUFKT1IgPT0gMSAmJiBDQUlST19WRVJTSU9OX01JTk9SID49IDEz KQpAQCAtNzEsNiArNzAsOCBAQCBwcml2YXRlOgogICAgIGNhaXJvX3NjYWxlZF9mb250X3QqIG1f c2NhbGVkRm9udCB7IG51bGxwdHIgfTsKICAgICBGVF9GYWNlIG1fZnRGYWNlIHsgbnVsbHB0ciB9 OwogfTsKKworQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IGdldERlZmF1bHRD YWlyb0ZvbnRPcHRpb25zKCk7CiAjZW5kaWYKIAogdm9pZCBjb3B5Q29udGV4dFByb3BlcnRpZXMo Y2Fpcm9fdCogc3JjQ3IsIGNhaXJvX3QqIGRzdENyKTsKQEAgLTk4LDUgKzk5LDMgQEAgUmVmUHRy PGNhaXJvX3JlZ2lvbl90PiB0b0NhaXJvUmVnaW9uKGNvbnN0IFJlZ2lvbiYpOwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gVVNFKENBSVJPKQotCi0jZW5kaWYgLy8gQ2Fpcm9V dGlsaXRpZXNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3BwCmluZGV4IDIxMWNmZmI3MTU0 ZmUwNWZkNmM4MWNiMDkxOWUwZTlhZDM4ZjE2NjguLjhkMDYzN2RjYmJjNmIxNTU1ODdhYjk5OTJm ODc2ZjVmMDUzNWUyY2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2ZyZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAKQEAgLTIyLDYg KzIyLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJGb250Q2FjaGUuaCIKIAor I2luY2x1ZGUgIkNhaXJvVXRpbGl0aWVzLmgiCiAjaW5jbHVkZSAiRmNVbmlxdWVQdHIuaCIKICNp bmNsdWRlICJGb250LmgiCiAjaW5jbHVkZSAiUmVmUHRyQ2Fpcm8uaCIKQEAgLTU3LDYgKzU4LDcg QEAgc3RhdGljIFJlZlB0cjxGY1BhdHRlcm4+IGNyZWF0ZUZvbnRDb25maWdQYXR0ZXJuRm9yQ2hh cmFjdGVycyhjb25zdCBVQ2hhciogY2hhcmEKIAogICAgIEZjUGF0dGVybkFkZEJvb2wocGF0dGVy bi5nZXQoKSwgRkNfU0NBTEFCTEUsIEZjVHJ1ZSk7CiAgICAgRmNDb25maWdTdWJzdGl0dXRlKG51 bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9mb250 X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgpLCBw YXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwog ICAgIHJldHVybiBwYXR0ZXJuOwogfQpAQCAtMjYwLDYgKzI2Miw3IEBAIHN0YXRpYyBWZWN0b3I8 U3RyaW5nPiBzdHJvbmdBbGlhc2VzRm9yRmFtaWx5KGNvbnN0IFN0cmluZyYgZmFtaWx5KQogICAg ICAgICByZXR1cm4gVmVjdG9yPFN0cmluZz4oKTsKIAogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShu dWxscHRyLCBwYXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwg cGF0dGVybi5nZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsK IAogICAgIEZjVW5pcXVlUHRyPEZjT2JqZWN0U2V0PiBmYW1pbGllc09ubHkoRmNPYmplY3RTZXRC dWlsZChGQ19GQU1JTFksIG51bGxwdHIpKTsKQEAgLTM1NCw2ICszNTcsNyBAQCBzdGQ6OnVuaXF1 ZV9wdHI8Rm9udFBsYXRmb3JtRGF0YT4gRm9udENhY2hlOjpjcmVhdGVGb250UGxhdGZvcm1EYXRh KGNvbnN0IEZvbnREZQogICAgIC8vIGNvbmZpZ3VyYXRpb24gc3RlcCwgYmVmb3JlIGFueSBtYXRj aGluZyBvY2N1cnMsIHdlIGFsbG93IGFyYml0cmFyeSBmYW1pbHkgc3Vic3RpdHV0aW9ucywKICAg ICAvLyBzaW5jZSB0aGlzIGlzIGFuIGV4YWN0IG1hdHRlciBvZiByZXNwZWN0aW5nIHRoZSB1c2Vy J3MgZm9udCBjb25maWd1cmF0aW9uLgogICAgIEZjQ29uZmlnU3Vic3RpdHV0ZShudWxscHRyLCBw YXR0ZXJuLmdldCgpLCBGY01hdGNoUGF0dGVybik7CisgICAgY2Fpcm9fZnRfZm9udF9vcHRpb25z X3N1YnN0aXR1dGUoZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKS5nZXQoKSwgcGF0dGVybi5n ZXQoKSk7CiAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuLmdldCgpKTsKIAogICAgIEZj Q2hhcjgqIGZvbnRDb25maWdGYW1pbHlOYW1lQWZ0ZXJDb25maWd1cmF0aW9uOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3Jt RGF0YUZyZWVUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKaW5kZXggYjA1YjU0YTU2NjM5NmJiNjgw ZWI3ZWJkZjg4ZTczNTUxYjIwYmU4ZC4uYWRhYTQwM2UyMDBkMzE3Mzg4ODk5NWE4MzdkNTExZDg0 ZWYwN2U5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJl ZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCkBA IC0zNywxMCArMzcsNiBAQAogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKLSNpZiBQTEFURk9STShHVEspCi0jaW5jbHVkZSA8Z2Rr L2dkay5oPgotI2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIGNhaXJvX3N1 YnBpeGVsX29yZGVyX3QgY29udmVydEZvbnRDb25maWdTdWJwaXhlbE9yZGVyKGludCBmb250Q29u ZmlnT3JkZXIpCkBAIC0xMDYsMTggKzEwMiw2IEBAIHN0YXRpYyB2b2lkIHNldENhaXJvRm9udE9w dGlvbnNGcm9tRm9udENvbmZpZ1BhdHRlcm4oY2Fpcm9fZm9udF9vcHRpb25zX3QqIG9wdGlvCiAg ICAgICAgIGNhaXJvX2ZvbnRfb3B0aW9uc19zZXRfaGludF9zdHlsZShvcHRpb25zLCBDQUlST19I SU5UX1NUWUxFX05PTkUpOwogfQogCi1zdGF0aWMgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9v cHRpb25zX3Q+IGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKLXsKLSNpZiBQTEFURk9STShH VEspCi0gICAgaWYgKEdka1NjcmVlbiogc2NyZWVuID0gZ2RrX3NjcmVlbl9nZXRfZGVmYXVsdCgp KSB7Ci0gICAgICAgIGNvbnN0IGNhaXJvX2ZvbnRfb3B0aW9uc190KiBzY3JlZW5PcHRpb25zID0g Z2RrX3NjcmVlbl9nZXRfZm9udF9vcHRpb25zKHNjcmVlbik7Ci0gICAgICAgIGlmIChzY3JlZW5P cHRpb25zKQotICAgICAgICAgICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0 aW9uc190PihjYWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7Ci0gICAgfQot I2VuZGlmCi0gICAgcmV0dXJuIENhaXJvVW5pcXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190Pihj YWlyb19mb250X29wdGlvbnNfY3JlYXRlKCkpOwotfQotCiBzdGF0aWMgRmNQYXR0ZXJuKiBnZXRE ZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMoKQogewogICAgIC8vIEdldCBzb21lIGdlbmVyaWMgZGVm YXVsdCBzZXR0aW5ncyBmcm9tIGZvbnRjb25maWcgZm9yIHdlYiBmb250cy4gU3RyYXRlZ3kKQEAg LTEyOSw2ICsxMTMsNyBAQCBzdGF0aWMgRmNQYXR0ZXJuKiBnZXREZWZhdWx0Rm9udGNvbmZpZ09w dGlvbnMoKQogICAgIHN0ZDo6Y2FsbF9vbmNlKGZsYWcsIFtdKEZjUGF0dGVybiopIHsKICAgICAg ICAgcGF0dGVybiA9IEZjUGF0dGVybkNyZWF0ZSgpOwogICAgICAgICBGY0NvbmZpZ1N1YnN0aXR1 dGUobnVsbHB0ciwgcGF0dGVybiwgRmNNYXRjaFBhdHRlcm4pOworICAgICAgICBjYWlyb19mdF9m b250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLmdldCgp LCBwYXR0ZXJuKTsKICAgICAgICAgRmNEZWZhdWx0U3Vic3RpdHV0ZShwYXR0ZXJuKTsKICAgICAg ICAgRmNQYXR0ZXJuRGVsKHBhdHRlcm4sIEZDX0ZBTUlMWSk7CiAgICAgICAgIEZjQ29uZmlnU3Vi c3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoRm9udCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNw cAppbmRleCA4NGNmMzlhM2IyNTgzMTkwMTU5NzYwM2E2NmMxNzI0YWQ1Mzc3YWEwLi4zNjMyNzY1 NzkxNjE5OTA1ODEyYzE2MWQzZmIxOTc1YmEyNGFiOGUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAK QEAgLTMyLDcgKzMyLDE3IEBACiAjaW5jbHVkZSA8Y2Fpcm8uaD4KICNpbmNsdWRlIDxndGsvZ3Rr Lmg+CiAKLXVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworbmFtZXNwYWNlIFdlYkNvcmUgeworCitD YWlyb1VuaXF1ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9w dGlvbnMoKQoreworICAgIGlmIChHZGtTY3JlZW4qIHNjcmVlbiA9IGdka19zY3JlZW5fZ2V0X2Rl ZmF1bHQoKSkgeworICAgICAgICBjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCogc2NyZWVuT3B0 aW9ucyA9IGdka19zY3JlZW5fZ2V0X2ZvbnRfb3B0aW9ucyhzY3JlZW4pOworICAgICAgICBpZiAo c2NyZWVuT3B0aW9ucykKKyAgICAgICAgICAgIHJldHVybiBDYWlyb1VuaXF1ZVB0cjxjYWlyb19m b250X29wdGlvbnNfdD4oY2Fpcm9fZm9udF9vcHRpb25zX2NvcHkoc2NyZWVuT3B0aW9ucykpOwor ICAgIH0KKyAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+KGNh aXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Cit9CiAKIEdka1BpeGJ1ZiogY2Fpcm9TdXJmYWNl VG9HZGtQaXhidWYoY2Fpcm9fc3VyZmFjZV90KiBzdXJmYWNlKQogewpAQCAtNDAsMyArNTAsNCBA QCBHZGtQaXhidWYqIGNhaXJvU3VyZmFjZVRvR2RrUGl4YnVmKGNhaXJvX3N1cmZhY2VfdCogc3Vy ZmFjZSkKICAgICByZXR1cm4gZ2RrX3BpeGJ1Zl9nZXRfZnJvbV9zdXJmYWNlKHN1cmZhY2UsIDAs IDAsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSk7CiB9CiAKK30KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmgK aW5kZXggODM0N2IxNmVjYjU4MDg5ZDNjOWFhZWUwZDBjMmM3ZTY2MjM2ZGI5ZS4uZTJhZWFhZTIy ZDQzZGM4MTllN2RiMzc2NGE0ZmIyMTM2ZTdhYzc2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmgKQEAgLTIz LDkgKzIzLDEwIEBACiAgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKLSNpZm5kZWYgR2RrQ2Fpcm9VdGls aXRpZXNfaAotI2RlZmluZSBHZGtDYWlyb1V0aWxpdGllc19oCisjcHJhZ21hIG9uY2UKKworbmFt ZXNwYWNlIFdlYkNvcmUgewogCiBHZGtQaXhidWYqIGNhaXJvU3VyZmFjZVRvR2RrUGl4YnVmKGNh aXJvX3N1cmZhY2VfdCopOwogCi0jZW5kaWYgLy8gR2RrQ2Fpcm9VdGlsaXRpZXNfaAorfQo= 304781 2017-03-17 08:38:25 -0700 2017-03-18 17:55:08 -0700 Patch bug-82889-20170317103824.patch text/plain 11489 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjE0MTAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjRlOWViNzNlOTJmY2Yz NzhkOTA1ZDZjYjkyNjk3ODIyNjViNzY2Zi4uMjdhMmJiODgxOGM5MjQ4MjE0NTJkOGRhMmY1ZjI4 N2MzMjkxMjExYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTE3ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMTcgIE1pZ3VlbCBHb21leiAgPG1hZ29tZXpAaWdhbGlh LmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgKHIyMTM4MzMpOiB3cml0ZSBhIGxheW91dCB0ZXN0 IGZvciAxNjkxOTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtl IGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggODIyYmJjMGU3MWI4YjM5 OWZkM2I4OGUwOTJkMGU2ZjUyYjU0MTMxZC4uMTRlMWExNjQ1Yjk1MzRjMjRhMGYwOWVlZWFjNDQ0 NzlhYzE2ZWI1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UK KysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTExMyw2ICsxMTMsNyBA QCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2Zy ZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFw aGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJlZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0 Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVGb250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0x ODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3Jt L2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBs YXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9n dGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25H dGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWly by9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j YWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXggNTgyMDc1NTliNGY2Nzg2MGQ1OTM0OWZjMjZj ZTE1ZGJmMDEyZGJmMS4uMTgyMDYxNjM4ZDIzODg4MDY1NGEzZmM1NzVjYzM1OTNhOTkyMDdkZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9V dGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJv L0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtMzksNiArMzksNyBAQAogI2luY2x1ZGUgIlJlZlB0ckNh aXJvLmgiCiAjaW5jbHVkZSAiUmVnaW9uLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4K KyNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+ CiAKICNpZiBFTkFCTEUoQUNDRUxFUkFURURfMkRfQ0FOVkFTKQpAQCAtNDcsNiArNDgsMTQgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAhUExBVEZPUk0o R1RLKQorY2Fpcm9fZm9udF9vcHRpb25zX3QqIGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkK K3sKKyAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8Y2Fpcm9fZm9udF9vcHRpb25zX3QqPiBvcHRp b25zID0gY2Fpcm9fZm9udF9vcHRpb25zX2NyZWF0ZSgpOworICAgIHJldHVybiBvcHRpb25zOwor fQorI2VuZGlmCisKIHZvaWQgY29weUNvbnRleHRQcm9wZXJ0aWVzKGNhaXJvX3QqIHNyY0NyLCBj YWlyb190KiBkc3RDcikKIHsKICAgICBjYWlyb19zZXRfYW50aWFsaWFzKGRzdENyLCBjYWlyb19n ZXRfYW50aWFsaWFzKHNyY0NyKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaAppbmRleCAxNWY2ZTgxMTU2MTViMGIx ZmExOTk1YmQzY2EyYjAzZWFiMmNiMGFiLi5kYWE5NmZhNjIyNDllOGMyNzhmMWU4MzJiZWNhM2Y5 NDUzMDY4MjI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j YWlyby9DYWlyb1V0aWxpdGllcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmgKQEAgLTI0LDggKzI0LDcgQEAKICAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCiAgKi8KIAotI2lmbmRlZiBDYWlyb1V0aWxpdGllc19oCi0jZGVmaW5lIENhaXJvVXRpbGl0 aWVzX2gKKyNwcmFnbWEgb25jZQogCiAjaWYgVVNFKENBSVJPKQogCkBAIC03MSw2ICs3MCw4IEBA IHByaXZhdGU6CiAgICAgY2Fpcm9fc2NhbGVkX2ZvbnRfdCogbV9zY2FsZWRGb250IHsgbnVsbHB0 ciB9OwogICAgIEZUX0ZhY2UgbV9mdEZhY2UgeyBudWxscHRyIH07CiB9OworCitjYWlyb19mb250 X29wdGlvbnNfdCogZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKTsKICNlbmRpZgogCiB2b2lk IGNvcHlDb250ZXh0UHJvcGVydGllcyhjYWlyb190KiBzcmNDciwgY2Fpcm9fdCogZHN0Q3IpOwpA QCAtOTcsNSArOTgsMyBAQCBSZWZQdHI8Y2Fpcm9fcmVnaW9uX3Q+IHRvQ2Fpcm9SZWdpb24oY29u c3QgUmVnaW9uJik7CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBVU0UoQ0FJ Uk8pCi0KLSNlbmRpZiAvLyBDYWlyb1V0aWxpdGllc19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlw ZS5jcHAKaW5kZXggMjExY2ZmYjcxNTRmZTA1ZmQ2YzgxY2IwOTE5ZTBlOWFkMzhmMTY2OC4uNDZi ZTE2MGMzN2JlNTU5NmUwNGVlNDNhYmQ1ZGY4MjZlMWQ1YTdmMiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hlRnJlZVR5cGUuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRDYWNo ZUZyZWVUeXBlLmNwcApAQCAtMjIsNiArMjIsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2lu Y2x1ZGUgIkZvbnRDYWNoZS5oIgogCisjaW5jbHVkZSAiQ2Fpcm9VdGlsaXRpZXMuaCIKICNpbmNs dWRlICJGY1VuaXF1ZVB0ci5oIgogI2luY2x1ZGUgIkZvbnQuaCIKICNpbmNsdWRlICJSZWZQdHJD YWlyby5oIgpAQCAtNTcsNiArNTgsNyBAQCBzdGF0aWMgUmVmUHRyPEZjUGF0dGVybj4gY3JlYXRl Rm9udENvbmZpZ1BhdHRlcm5Gb3JDaGFyYWN0ZXJzKGNvbnN0IFVDaGFyKiBjaGFyYQogCiAgICAg RmNQYXR0ZXJuQWRkQm9vbChwYXR0ZXJuLmdldCgpLCBGQ19TQ0FMQUJMRSwgRmNUcnVlKTsKICAg ICBGY0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybi5nZXQoKSwgRmNNYXRjaFBhdHRl cm4pOworICAgIGNhaXJvX2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWly b0ZvbnRPcHRpb25zKCksIHBhdHRlcm4uZ2V0KCkpOwogICAgIEZjRGVmYXVsdFN1YnN0aXR1dGUo cGF0dGVybi5nZXQoKSk7CiAgICAgcmV0dXJuIHBhdHRlcm47CiB9CkBAIC0yNjAsNiArMjYyLDcg QEAgc3RhdGljIFZlY3RvcjxTdHJpbmc+IHN0cm9uZ0FsaWFzZXNGb3JGYW1pbHkoY29uc3QgU3Ry aW5nJiBmYW1pbHkpCiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigpOwogCiAgICAgRmND b25maWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsK KyAgICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250 T3B0aW9ucygpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRl cm4uZ2V0KCkpOwogCiAgICAgRmNVbmlxdWVQdHI8RmNPYmplY3RTZXQ+IGZhbWlsaWVzT25seShG Y09iamVjdFNldEJ1aWxkKEZDX0ZBTUlMWSwgbnVsbHB0cikpOwpAQCAtMzU0LDYgKzM1Nyw3IEBA IHN0ZDo6dW5pcXVlX3B0cjxGb250UGxhdGZvcm1EYXRhPiBGb250Q2FjaGU6OmNyZWF0ZUZvbnRQ bGF0Zm9ybURhdGEoY29uc3QgRm9udERlCiAgICAgLy8gY29uZmlndXJhdGlvbiBzdGVwLCBiZWZv cmUgYW55IG1hdGNoaW5nIG9jY3Vycywgd2UgYWxsb3cgYXJiaXRyYXJ5IGZhbWlseSBzdWJzdGl0 dXRpb25zLAogICAgIC8vIHNpbmNlIHRoaXMgaXMgYW4gZXhhY3QgbWF0dGVyIG9mIHJlc3BlY3Rp bmcgdGhlIHVzZXIncyBmb250IGNvbmZpZ3VyYXRpb24uCiAgICAgRmNDb25maWdTdWJzdGl0dXRl KG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9m b250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpLCBwYXR0 ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwogCiAg ICAgRmNDaGFyOCogZm9udENvbmZpZ0ZhbWlseU5hbWVBZnRlckNvbmZpZ3VyYXRpb247CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxh dGZvcm1EYXRhRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZnJlZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAppbmRleCBiMDViNTRhNTY2Mzk2 YmI2ODBlYjdlYmRmODhlNzM1NTFiMjBiZThkLi4yNzg0ZmE4MGNhYjgzMWFmM2Q4MDA0ODNhNmI3 NmM2MjZjMGU4NjdhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5j cHAKQEAgLTM3LDEwICszNyw2IEBACiAjaW5jbHVkZSA8d3RmL01hdGhFeHRyYXMuaD4KICNpbmNs dWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAotI2lmIFBMQVRGT1JNKEdUSykKLSNpbmNsdWRl IDxnZGsvZ2RrLmg+Ci0jZW5kaWYKLQogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBzdGF0aWMgY2Fp cm9fc3VicGl4ZWxfb3JkZXJfdCBjb252ZXJ0Rm9udENvbmZpZ1N1YnBpeGVsT3JkZXIoaW50IGZv bnRDb25maWdPcmRlcikKQEAgLTEwNiwxOCArMTAyLDYgQEAgc3RhdGljIHZvaWQgc2V0Q2Fpcm9G b250T3B0aW9uc0Zyb21Gb250Q29uZmlnUGF0dGVybihjYWlyb19mb250X29wdGlvbnNfdCogb3B0 aW8KICAgICAgICAgY2Fpcm9fZm9udF9vcHRpb25zX3NldF9oaW50X3N0eWxlKG9wdGlvbnMsIENB SVJPX0hJTlRfU1RZTEVfTk9ORSk7CiB9CiAKLXN0YXRpYyBDYWlyb1VuaXF1ZVB0cjxjYWlyb19m b250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKQotewotI2lmIFBMQVRG T1JNKEdUSykKLSAgICBpZiAoR2RrU2NyZWVuKiBzY3JlZW4gPSBnZGtfc2NyZWVuX2dldF9kZWZh dWx0KCkpIHsKLSAgICAgICAgY29uc3QgY2Fpcm9fZm9udF9vcHRpb25zX3QqIHNjcmVlbk9wdGlv bnMgPSBnZGtfc2NyZWVuX2dldF9mb250X29wdGlvbnMoc2NyZWVuKTsKLSAgICAgICAgaWYgKHNj cmVlbk9wdGlvbnMpCi0gICAgICAgICAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9u dF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jb3B5KHNjcmVlbk9wdGlvbnMpKTsKLSAg ICB9Ci0jZW5kaWYKLSAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25z X3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Ci19Ci0KIHN0YXRpYyBGY1BhdHRlcm4q IGdldERlZmF1bHRGb250Y29uZmlnT3B0aW9ucygpCiB7CiAgICAgLy8gR2V0IHNvbWUgZ2VuZXJp YyBkZWZhdWx0IHNldHRpbmdzIGZyb20gZm9udGNvbmZpZyBmb3Igd2ViIGZvbnRzLiBTdHJhdGVn eQpAQCAtMTI5LDYgKzExMyw3IEBAIHN0YXRpYyBGY1BhdHRlcm4qIGdldERlZmF1bHRGb250Y29u ZmlnT3B0aW9ucygpCiAgICAgc3RkOjpjYWxsX29uY2UoZmxhZywgW10oRmNQYXR0ZXJuKikgewog ICAgICAgICBwYXR0ZXJuID0gRmNQYXR0ZXJuQ3JlYXRlKCk7CiAgICAgICAgIEZjQ29uZmlnU3Vi c3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoUGF0dGVybik7CisgICAgICAgIGNhaXJv X2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCks IHBhdHRlcm4pOwogICAgICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4pOwogICAgICAg ICBGY1BhdHRlcm5EZWwocGF0dGVybiwgRkNfRkFNSUxZKTsKICAgICAgICAgRmNDb25maWdTdWJz dGl0dXRlKG51bGxwdHIsIHBhdHRlcm4sIEZjTWF0Y2hGb250KTsKQEAgLTMwOCw5ICsyOTMsOSBA QCBTdHJpbmcgRm9udFBsYXRmb3JtRGF0YTo6ZGVzY3JpcHRpb24oKSBjb25zdAogCiB2b2lkIEZv bnRQbGF0Zm9ybURhdGE6OmJ1aWxkU2NhbGVkRm9udChjYWlyb19mb250X2ZhY2VfdCogZm9udEZh Y2UpCiB7Ci0gICAgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+IG9wdGlvbnMg PSBnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpOworICAgIGNhaXJvX2ZvbnRfb3B0aW9uc190 KiBvcHRpb25zID0gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKTsKICAgICBGY1BhdHRlcm4q IG9wdGlvbnNQYXR0ZXJuID0gbV9wYXR0ZXJuID8gbV9wYXR0ZXJuLmdldCgpIDogZ2V0RGVmYXVs dEZvbnRjb25maWdPcHRpb25zKCk7Ci0gICAgc2V0Q2Fpcm9Gb250T3B0aW9uc0Zyb21Gb250Q29u ZmlnUGF0dGVybihvcHRpb25zLmdldCgpLCBvcHRpb25zUGF0dGVybik7CisgICAgc2V0Q2Fpcm9G b250T3B0aW9uc0Zyb21Gb250Q29uZmlnUGF0dGVybihvcHRpb25zLCBvcHRpb25zUGF0dGVybik7 CiAKICAgICBjYWlyb19tYXRyaXhfdCBjdG07CiAgICAgY2Fpcm9fbWF0cml4X2luaXRfaWRlbnRp dHkoJmN0bSk7CkBAIC0zNDksNyArMzM0LDcgQEAgdm9pZCBGb250UGxhdGZvcm1EYXRhOjpidWls ZFNjYWxlZEZvbnQoY2Fpcm9fZm9udF9mYWNlX3QqIGZvbnRGYWNlKQogICAgICAgICBjYWlyb19t YXRyaXhfdHJhbnNsYXRlKCZmb250TWF0cml4LCAwLjAsIDEuMCk7CiAgICAgfQogCi0gICAgbV9z Y2FsZWRGb250ID0gYWRvcHRSZWYoY2Fpcm9fc2NhbGVkX2ZvbnRfY3JlYXRlKGZvbnRGYWNlLCAm Zm9udE1hdHJpeCwgJmN0bSwgb3B0aW9ucy5nZXQoKSkpOworICAgIG1fc2NhbGVkRm9udCA9IGFk b3B0UmVmKGNhaXJvX3NjYWxlZF9mb250X2NyZWF0ZShmb250RmFjZSwgJmZvbnRNYXRyaXgsICZj dG0sIG9wdGlvbnMpKTsKIH0KIAogYm9vbCBGb250UGxhdGZvcm1EYXRhOjpoYXNDb21wYXRpYmxl Q2hhcm1hcCgpIGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNwcAppbmRleCA4NGNmMzlhM2IyNTgzMTkw MTU5NzYwM2E2NmMxNzI0YWQ1Mzc3YWEwLi5hNGNhZWRmNGY4ODM1YzhkZjMyZWNkZDU3MDkzZmFj OTdlZWY3NzEwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n dGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAKQEAgLTMxLDggKzMxLDI2IEBACiAjaW5j bHVkZSAiSW50U2l6ZS5oIgogI2luY2x1ZGUgPGNhaXJvLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5o PgorI2luY2x1ZGUgPG11dGV4PgorI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogCi11 c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2Fpcm9fZm9u dF9vcHRpb25zX3QqIGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkKK3sKKyAgICBzdGF0aWMg TGF6eU5ldmVyRGVzdHJveWVkPGNhaXJvX2ZvbnRfb3B0aW9uc190Kj4gb3B0aW9uczsKKyAgICBz dGF0aWMgc3RkOjpvbmNlX2ZsYWcgZmxhZzsKKyAgICBzdGQ6OmNhbGxfb25jZShmbGFnLCBbXSB7 CisgICAgICAgIGlmIChhdXRvKiBzY3JlZW4gPSBnZGtfc2NyZWVuX2dldF9kZWZhdWx0KCkpIHsK KyAgICAgICAgICAgIGlmIChhdXRvKiBzY3JlZW5PcHRpb25zID0gZ2RrX3NjcmVlbl9nZXRfZm9u dF9vcHRpb25zKHNjcmVlbikpIHsKKyAgICAgICAgICAgICAgICBvcHRpb25zLmNvbnN0cnVjdChj YWlyb19mb250X29wdGlvbnNfY29weShzY3JlZW5PcHRpb25zKSk7CisgICAgICAgICAgICAgICAg cmV0dXJuOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIG9wdGlvbnMuY29uc3Ry dWN0KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7CisgICAgfSk7CisgICAgcmV0dXJuIG9w dGlvbnM7Cit9CiAKIEdka1BpeGJ1ZiogY2Fpcm9TdXJmYWNlVG9HZGtQaXhidWYoY2Fpcm9fc3Vy ZmFjZV90KiBzdXJmYWNlKQogewpAQCAtNDAsMyArNTgsNCBAQCBHZGtQaXhidWYqIGNhaXJvU3Vy ZmFjZVRvR2RrUGl4YnVmKGNhaXJvX3N1cmZhY2VfdCogc3VyZmFjZSkKICAgICByZXR1cm4gZ2Rr X3BpeGJ1Zl9nZXRfZnJvbV9zdXJmYWNlKHN1cmZhY2UsIDAsIDAsIHNpemUud2lkdGgoKSwgc2l6 ZS5oZWlnaHQoKSk7CiB9CiAKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmgKaW5kZXggODM0N2IxNmVjYjU4MDg5 ZDNjOWFhZWUwZDBjMmM3ZTY2MjM2ZGI5ZS4uZTJhZWFhZTIyZDQzZGM4MTllN2RiMzc2NGE0ZmIy MTM2ZTdhYzc2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3RrL0dka0NhaXJvVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmgKQEAgLTIzLDkgKzIzLDEwIEBACiAgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgogICovCiAKLSNpZm5kZWYgR2RrQ2Fpcm9VdGlsaXRpZXNfaAotI2RlZmluZSBHZGtD YWlyb1V0aWxpdGllc19oCisjcHJhZ21hIG9uY2UKKworbmFtZXNwYWNlIFdlYkNvcmUgewogCiBH ZGtQaXhidWYqIGNhaXJvU3VyZmFjZVRvR2RrUGl4YnVmKGNhaXJvX3N1cmZhY2VfdCopOwogCi0j ZW5kaWYgLy8gR2RrQ2Fpcm9VdGlsaXRpZXNfaAorfQo= 304889 2017-03-18 17:55:14 -0700 2017-03-20 01:41:14 -0700 Patch bug-82889-20170318195513.patch text/plain 10900 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjE0MTAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjRlOWViNzNlOTJmY2Yz NzhkOTA1ZDZjYjkyNjk3ODIyNjViNzY2Zi4uOTNhNGY4MmJiYjc5YWY4MWM1OGY2YTdhYTEwY2Qy ZmZjNWZlMDc5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE3LTAzLTE4ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBI b25vciBHVEsrIGZvbnQgc2V0dGluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTgyODg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWZ0ZXIgbXVjaCBkaXNjdXNzaW9uIHdpdGggQmVoZGFkIGFuZCBNYXJ0 aW4gKHdobyBpcyBzdGlsbCBub3QgY29tcGxldGVseSBjb252aW5jZWQgSSB0aGluaworICAgICAg ICA6KSBJIHdhbnQgdG8gbWVyZ2UgY2Fpcm8gZm9udCBvcHRpb25zIGludG8gdGhlIEZvbnRjb25m aWcgcGF0dGVybiB1c2VkIGZvciByZW5kZXJpbmcgdXNpbmcKKyAgICAgICAgY2Fpcm9fZnRfZm9u dF9vcHRpb25zX3N1YnN0aXR1dGUoKS4gVGhpcyBpcyBob3cgdGhlIEFQSSB3YXMgZGVzaWduZWQg dG8gYmUgdXNlZCBhbnl3YXkuCisgICAgICAgIEZvbnRjb25maWcgd2lsbCBzdGlsbCBoYXZlIGZp bmFsIHNheSBvdmVyIHdoZXRoZXIgdG8gYWN0dWFsbHkgcmVzcGVjdCB0aGUgZGVza3RvcCBzZXR0 aW5ncworICAgICAgICBvciBub3QsIHNvIGl0IGNhbiBzdGlsbCBjaG9vc2UgdG8gaWdub3JlIHRo ZSBkZXNrdG9wJ3Mgc2V0dGluZ3MsIGJ1dCBJIGRvbid0IHRoaW5rIGl0IG1ha2VzCisgICAgICAg IHNlbnNlIHRvIGhhdmUgZGVza3RvcC13aWRlIGZvbnQgc2V0dGluZ3MgYW5kIG5vdCB0ZWxsIEZv bnRjb25maWcgYWJvdXQgdGhlbSwgZXNwZWNpYWxseSB3aGVuCisgICAgICAgIHRoZSB3aG9sZSBw b2ludCBvZiBXZWJLaXRHVEsrIGlzIGRlc2t0b3AgaW50ZWdyYXRpb24uIFRoaXMgc2hvdWxkIGFs c28gcmVkdWNlIGNvbXBsYWludHMKKyAgICAgICAgdGhhdCB3ZSdyZSBub3QgZm9sbG93aW5nIGRl c2t0b3Agc2V0dGluZ3MgYW5kIHRoYXQgd2UncmUgZHJhd2luZyBmb250cyBkaWZmZXJlbnRseSB0 aGFuCisgICAgICAgIEZpcmVmb3guCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucyk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpjcmVhdGVGb250Q29uZmlnUGF0dGVybkZvckNoYXJhY3RlcnMpOgorICAgICAgICAoV2Vi Q29yZTo6c3Ryb25nQWxpYXNlc0ZvckZhbWlseSk6CisgICAgICAgIChXZWJDb3JlOjpGb250Q2Fj aGU6OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpnZXREZWZhdWx0Rm9udGNvbmZpZ09wdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6Z2V0RGVm YXVsdENhaXJvRm9udE9wdGlvbnMpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHA6CisgICAgICAgIChnZXREZWZhdWx0Q2Fpcm9G b250T3B0aW9ucyk6CisKIDIwMTctMDMtMTcgIE1pZ3VlbCBHb21leiAgPG1hZ29tZXpAaWdhbGlh LmNvbT4KIAogICAgICAgICBGb2xsb3ctdXAgKHIyMTM4MzMpOiB3cml0ZSBhIGxheW91dCB0ZXN0 IGZvciAxNjkxOTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtl IGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggODIyYmJjMGU3MWI4YjM5 OWZkM2I4OGUwOTJkMGU2ZjUyYjU0MTMxZC4uMTRlMWExNjQ1Yjk1MzRjMjRhMGYwOWVlZWFjNDQ0 NzlhYzE2ZWI1ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UK KysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTExMyw2ICsxMTMsNyBA QCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2Zy ZWV0eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRDdXN0b21QbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFw aGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MvZnJlZXR5cGUvR2x5cGhQYWdlVHJlZU5vZGVGcmVlVHlwZS5jcHAKICAgICBwbGF0 Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9TaW1wbGVGb250RGF0YUZyZWVUeXBlLmNwcAogCkBAIC0x ODcsOCArMTg4LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZVBsYXRmb3JtR1RLX1NPVVJDRVMKIAog ICAgIHBsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHAKIAotICAgIHBsYXRmb3Jt L2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURhdGFGcmVlVHlwZS5jcHAKLQogICAgIHBs YXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9n dGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0ljb25H dGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWly by9DYWlyb1V0aWxpdGllcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j YWlyby9DYWlyb1V0aWxpdGllcy5jcHAKaW5kZXggNTgyMDc1NTliNGY2Nzg2MGQ1OTM0OWZjMjZj ZTE1ZGJmMDEyZGJmMS4uOGEzZmYzM2QwMDMwY2MxM2M3MjhkNmVmNTY0ZjAzZDFjZGFmMjRhMiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9V dGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJv L0NhaXJvVXRpbGl0aWVzLmNwcApAQCAtMzksNiArMzksNyBAQAogI2luY2x1ZGUgIlJlZlB0ckNh aXJvLmgiCiAjaW5jbHVkZSAiUmVnaW9uLmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4K KyNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+ CiAKICNpZiBFTkFCTEUoQUNDRUxFUkFURURfMkRfQ0FOVkFTKQpAQCAtNDcsNiArNDgsMTQgQEAK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgVVNFKEZSRUVUWVBFKSAmJiAhUExBVEZPUk0o R1RLKQorY29uc3QgY2Fpcm9fZm9udF9vcHRpb25zX3QqIGdldERlZmF1bHRDYWlyb0ZvbnRPcHRp b25zKCkKK3sKKyAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8Y2Fpcm9fZm9udF9vcHRpb25zX3Qq PiBvcHRpb25zID0gY2Fpcm9fZm9udF9vcHRpb25zX2NyZWF0ZSgpOworICAgIHJldHVybiBvcHRp b25zOworfQorI2VuZGlmCisKIHZvaWQgY29weUNvbnRleHRQcm9wZXJ0aWVzKGNhaXJvX3QqIHNy Y0NyLCBjYWlyb190KiBkc3RDcikKIHsKICAgICBjYWlyb19zZXRfYW50aWFsaWFzKGRzdENyLCBj YWlyb19nZXRfYW50aWFsaWFzKHNyY0NyKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vQ2Fpcm9VdGlsaXRpZXMuaAppbmRleCAxNWY2ZTgxMTU2 MTViMGIxZmExOTk1YmQzY2EyYjAzZWFiMmNiMGFiLi45NTI4ZTAyMTAzYzA2Yzg3MTg4YjA4NmVj NTUxMDA1MWE5NDU5MGNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jYWlyby9DYWlyb1V0aWxpdGllcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2NhaXJvL0NhaXJvVXRpbGl0aWVzLmgKQEAgLTI0LDggKzI0LDcgQEAKICAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCiAgKi8KIAotI2lmbmRlZiBDYWlyb1V0aWxpdGllc19oCi0jZGVmaW5lIENhaXJv VXRpbGl0aWVzX2gKKyNwcmFnbWEgb25jZQogCiAjaWYgVVNFKENBSVJPKQogCkBAIC03MSw2ICs3 MCw4IEBAIHByaXZhdGU6CiAgICAgY2Fpcm9fc2NhbGVkX2ZvbnRfdCogbV9zY2FsZWRGb250IHsg bnVsbHB0ciB9OwogICAgIEZUX0ZhY2UgbV9mdEZhY2UgeyBudWxscHRyIH07CiB9OworCitjb25z dCBjYWlyb19mb250X29wdGlvbnNfdCogZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKTsKICNl bmRpZgogCiB2b2lkIGNvcHlDb250ZXh0UHJvcGVydGllcyhjYWlyb190KiBzcmNDciwgY2Fpcm9f dCogZHN0Q3IpOwpAQCAtOTcsNSArOTgsMyBAQCBSZWZQdHI8Y2Fpcm9fcmVnaW9uX3Q+IHRvQ2Fp cm9SZWdpb24oY29uc3QgUmVnaW9uJik7CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRp ZiAvLyBVU0UoQ0FJUk8pCi0KLSNlbmRpZiAvLyBDYWlyb1V0aWxpdGllc19oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250Q2FjaGVGcmVl VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250 Q2FjaGVGcmVlVHlwZS5jcHAKaW5kZXggMjExY2ZmYjcxNTRmZTA1ZmQ2YzgxY2IwOTE5ZTBlOWFk MzhmMTY2OC4uNDZiZTE2MGMzN2JlNTU5NmUwNGVlNDNhYmQ1ZGY4MjZlMWQ1YTdmMiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udENhY2hl RnJlZVR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0 eXBlL0ZvbnRDYWNoZUZyZWVUeXBlLmNwcApAQCAtMjIsNiArMjIsNyBAQAogI2luY2x1ZGUgImNv bmZpZy5oIgogI2luY2x1ZGUgIkZvbnRDYWNoZS5oIgogCisjaW5jbHVkZSAiQ2Fpcm9VdGlsaXRp ZXMuaCIKICNpbmNsdWRlICJGY1VuaXF1ZVB0ci5oIgogI2luY2x1ZGUgIkZvbnQuaCIKICNpbmNs dWRlICJSZWZQdHJDYWlyby5oIgpAQCAtNTcsNiArNTgsNyBAQCBzdGF0aWMgUmVmUHRyPEZjUGF0 dGVybj4gY3JlYXRlRm9udENvbmZpZ1BhdHRlcm5Gb3JDaGFyYWN0ZXJzKGNvbnN0IFVDaGFyKiBj aGFyYQogCiAgICAgRmNQYXR0ZXJuQWRkQm9vbChwYXR0ZXJuLmdldCgpLCBGQ19TQ0FMQUJMRSwg RmNUcnVlKTsKICAgICBGY0NvbmZpZ1N1YnN0aXR1dGUobnVsbHB0ciwgcGF0dGVybi5nZXQoKSwg RmNNYXRjaFBhdHRlcm4pOworICAgIGNhaXJvX2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdl dERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCksIHBhdHRlcm4uZ2V0KCkpOwogICAgIEZjRGVmYXVs dFN1YnN0aXR1dGUocGF0dGVybi5nZXQoKSk7CiAgICAgcmV0dXJuIHBhdHRlcm47CiB9CkBAIC0y NjAsNiArMjYyLDcgQEAgc3RhdGljIFZlY3RvcjxTdHJpbmc+IHN0cm9uZ0FsaWFzZXNGb3JGYW1p bHkoY29uc3QgU3RyaW5nJiBmYW1pbHkpCiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigp OwogCiAgICAgRmNDb25maWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0 Y2hQYXR0ZXJuKTsKKyAgICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZh dWx0Q2Fpcm9Gb250T3B0aW9ucygpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJz dGl0dXRlKHBhdHRlcm4uZ2V0KCkpOwogCiAgICAgRmNVbmlxdWVQdHI8RmNPYmplY3RTZXQ+IGZh bWlsaWVzT25seShGY09iamVjdFNldEJ1aWxkKEZDX0ZBTUlMWSwgbnVsbHB0cikpOwpAQCAtMzU0 LDYgKzM1Nyw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxGb250UGxhdGZvcm1EYXRhPiBGb250Q2FjaGU6 OmNyZWF0ZUZvbnRQbGF0Zm9ybURhdGEoY29uc3QgRm9udERlCiAgICAgLy8gY29uZmlndXJhdGlv biBzdGVwLCBiZWZvcmUgYW55IG1hdGNoaW5nIG9jY3Vycywgd2UgYWxsb3cgYXJiaXRyYXJ5IGZh bWlseSBzdWJzdGl0dXRpb25zLAogICAgIC8vIHNpbmNlIHRoaXMgaXMgYW4gZXhhY3QgbWF0dGVy IG9mIHJlc3BlY3RpbmcgdGhlIHVzZXIncyBmb250IGNvbmZpZ3VyYXRpb24uCiAgICAgRmNDb25m aWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4uZ2V0KCksIEZjTWF0Y2hQYXR0ZXJuKTsKKyAg ICBjYWlyb19mdF9mb250X29wdGlvbnNfc3Vic3RpdHV0ZShnZXREZWZhdWx0Q2Fpcm9Gb250T3B0 aW9ucygpLCBwYXR0ZXJuLmdldCgpKTsKICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRlcm4u Z2V0KCkpOwogCiAgICAgRmNDaGFyOCogZm9udENvbmZpZ0ZhbWlseU5hbWVBZnRlckNvbmZpZ3Vy YXRpb247CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9mcmVl dHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZnJlZXR5cGUvRm9udFBsYXRmb3JtRGF0YUZyZWVUeXBlLmNwcAppbmRleCBi MDViNTRhNTY2Mzk2YmI2ODBlYjdlYmRmODhlNzM1NTFiMjBiZThkLi5mMjhiOTI2ZDczZGE0YzJi NTI3MDhmOGJmMmZlYTI2NTg3OTQ1NDllIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9mcmVldHlwZS9Gb250UGxhdGZvcm1EYXRhRnJlZVR5cGUuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlL0ZvbnRQbGF0Zm9ybURh dGFGcmVlVHlwZS5jcHAKQEAgLTM3LDEwICszNyw2IEBACiAjaW5jbHVkZSA8d3RmL01hdGhFeHRy YXMuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAotI2lmIFBMQVRGT1JNKEdU SykKLSNpbmNsdWRlIDxnZGsvZ2RrLmg+Ci0jZW5kaWYKLQogbmFtZXNwYWNlIFdlYkNvcmUgewog CiBzdGF0aWMgY2Fpcm9fc3VicGl4ZWxfb3JkZXJfdCBjb252ZXJ0Rm9udENvbmZpZ1N1YnBpeGVs T3JkZXIoaW50IGZvbnRDb25maWdPcmRlcikKQEAgLTEwNiwxOCArMTAyLDYgQEAgc3RhdGljIHZv aWQgc2V0Q2Fpcm9Gb250T3B0aW9uc0Zyb21Gb250Q29uZmlnUGF0dGVybihjYWlyb19mb250X29w dGlvbnNfdCogb3B0aW8KICAgICAgICAgY2Fpcm9fZm9udF9vcHRpb25zX3NldF9oaW50X3N0eWxl KG9wdGlvbnMsIENBSVJPX0hJTlRfU1RZTEVfTk9ORSk7CiB9CiAKLXN0YXRpYyBDYWlyb1VuaXF1 ZVB0cjxjYWlyb19mb250X29wdGlvbnNfdD4gZ2V0RGVmYXVsdENhaXJvRm9udE9wdGlvbnMoKQot ewotI2lmIFBMQVRGT1JNKEdUSykKLSAgICBpZiAoR2RrU2NyZWVuKiBzY3JlZW4gPSBnZGtfc2Ny ZWVuX2dldF9kZWZhdWx0KCkpIHsKLSAgICAgICAgY29uc3QgY2Fpcm9fZm9udF9vcHRpb25zX3Qq IHNjcmVlbk9wdGlvbnMgPSBnZGtfc2NyZWVuX2dldF9mb250X29wdGlvbnMoc2NyZWVuKTsKLSAg ICAgICAgaWYgKHNjcmVlbk9wdGlvbnMpCi0gICAgICAgICAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQ dHI8Y2Fpcm9fZm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jb3B5KHNjcmVlbk9w dGlvbnMpKTsKLSAgICB9Ci0jZW5kaWYKLSAgICByZXR1cm4gQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9f Zm9udF9vcHRpb25zX3Q+KGNhaXJvX2ZvbnRfb3B0aW9uc19jcmVhdGUoKSk7Ci19Ci0KIHN0YXRp YyBGY1BhdHRlcm4qIGdldERlZmF1bHRGb250Y29uZmlnT3B0aW9ucygpCiB7CiAgICAgLy8gR2V0 IHNvbWUgZ2VuZXJpYyBkZWZhdWx0IHNldHRpbmdzIGZyb20gZm9udGNvbmZpZyBmb3Igd2ViIGZv bnRzLiBTdHJhdGVneQpAQCAtMTI5LDYgKzExMyw3IEBAIHN0YXRpYyBGY1BhdHRlcm4qIGdldERl ZmF1bHRGb250Y29uZmlnT3B0aW9ucygpCiAgICAgc3RkOjpjYWxsX29uY2UoZmxhZywgW10oRmNQ YXR0ZXJuKikgewogICAgICAgICBwYXR0ZXJuID0gRmNQYXR0ZXJuQ3JlYXRlKCk7CiAgICAgICAg IEZjQ29uZmlnU3Vic3RpdHV0ZShudWxscHRyLCBwYXR0ZXJuLCBGY01hdGNoUGF0dGVybik7Cisg ICAgICAgIGNhaXJvX2Z0X2ZvbnRfb3B0aW9uc19zdWJzdGl0dXRlKGdldERlZmF1bHRDYWlyb0Zv bnRPcHRpb25zKCksIHBhdHRlcm4pOwogICAgICAgICBGY0RlZmF1bHRTdWJzdGl0dXRlKHBhdHRl cm4pOwogICAgICAgICBGY1BhdHRlcm5EZWwocGF0dGVybiwgRkNfRkFNSUxZKTsKICAgICAgICAg RmNDb25maWdTdWJzdGl0dXRlKG51bGxwdHIsIHBhdHRlcm4sIEZjTWF0Y2hGb250KTsKQEAgLTMw OCw3ICsyOTMsNyBAQCBTdHJpbmcgRm9udFBsYXRmb3JtRGF0YTo6ZGVzY3JpcHRpb24oKSBjb25z dAogCiB2b2lkIEZvbnRQbGF0Zm9ybURhdGE6OmJ1aWxkU2NhbGVkRm9udChjYWlyb19mb250X2Zh Y2VfdCogZm9udEZhY2UpCiB7Ci0gICAgQ2Fpcm9VbmlxdWVQdHI8Y2Fpcm9fZm9udF9vcHRpb25z X3Q+IG9wdGlvbnMgPSBnZXREZWZhdWx0Q2Fpcm9Gb250T3B0aW9ucygpOworICAgIENhaXJvVW5p cXVlUHRyPGNhaXJvX2ZvbnRfb3B0aW9uc190PiBvcHRpb25zKGNhaXJvX2ZvbnRfb3B0aW9uc19j b3B5KGdldERlZmF1bHRDYWlyb0ZvbnRPcHRpb25zKCkpKTsKICAgICBGY1BhdHRlcm4qIG9wdGlv bnNQYXR0ZXJuID0gbV9wYXR0ZXJuID8gbV9wYXR0ZXJuLmdldCgpIDogZ2V0RGVmYXVsdEZvbnRj b25maWdPcHRpb25zKCk7CiAgICAgc2V0Q2Fpcm9Gb250T3B0aW9uc0Zyb21Gb250Q29uZmlnUGF0 dGVybihvcHRpb25zLmdldCgpLCBvcHRpb25zUGF0dGVybik7CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRpZXMuY3Bw CmluZGV4IDg0Y2YzOWEzYjI1ODMxOTAxNTk3NjAzYTY2YzE3MjRhZDUzNzdhYTAuLjgxOTQ0MWVm YTY3ZjhmN2Q3ZGYyYmFhOTRlYWQ5MDBiYmMwODAwNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9HZGtDYWlyb1V0aWxpdGllcy5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNwcApA QCAtMzEsOCArMzEsMjUgQEAKICNpbmNsdWRlICJJbnRTaXplLmgiCiAjaW5jbHVkZSA8Y2Fpcm8u aD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8bXV0ZXg+CisjaW5jbHVkZSA8d3Rm L05ldmVyRGVzdHJveWVkLmg+CiAKLXVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworbmFtZXNwYWNl IFdlYkNvcmUgeworCitjb25zdCBjYWlyb19mb250X29wdGlvbnNfdCogZ2V0RGVmYXVsdENhaXJv Rm9udE9wdGlvbnMoKQoreworICAgIGlmIChhdXRvKiBzY3JlZW4gPSBnZGtfc2NyZWVuX2dldF9k ZWZhdWx0KCkpIHsKKyAgICAgICAgaWYgKGF1dG8qIG9wdGlvbnMgPSBnZGtfc2NyZWVuX2dldF9m b250X29wdGlvbnMoc2NyZWVuKSkKKyAgICAgICAgICAgIHJldHVybiBvcHRpb25zOworICAgIH0K KworICAgIHN0YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8Y2Fpcm9fZm9udF9vcHRpb25zX3QqPiBv cHRpb25zOworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBmbGFnOworICAgIHN0ZDo6Y2FsbF9v bmNlKGZsYWcsIFtdIHsKKyAgICAgICAgb3B0aW9ucy5jb25zdHJ1Y3QoY2Fpcm9fZm9udF9vcHRp b25zX2NyZWF0ZSgpKTsKKyAgICB9KTsKKyAgICByZXR1cm4gb3B0aW9uczsKK30KIAogR2RrUGl4 YnVmKiBjYWlyb1N1cmZhY2VUb0dka1BpeGJ1ZihjYWlyb19zdXJmYWNlX3QqIHN1cmZhY2UpCiB7 CkBAIC00MCwzICs1Nyw0IEBAIEdka1BpeGJ1ZiogY2Fpcm9TdXJmYWNlVG9HZGtQaXhidWYoY2Fp cm9fc3VyZmFjZV90KiBzdXJmYWNlKQogICAgIHJldHVybiBnZGtfcGl4YnVmX2dldF9mcm9tX3N1 cmZhY2Uoc3VyZmFjZSwgMCwgMCwgc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpKTsKIH0KIAor fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0Nh aXJvVXRpbGl0aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2Rr Q2Fpcm9VdGlsaXRpZXMuaAppbmRleCA4MzQ3YjE2ZWNiNTgwODlkM2M5YWFlZTBkMGMyYzdlNjYy MzZkYjllLi5lMmFlYWFlMjJkNDNkYzgxOWU3ZGIzNzY0YTRmYjIxMzZlN2FjNzY2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9VdGlsaXRp ZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ndGsvR2RrQ2Fpcm9V dGlsaXRpZXMuaApAQCAtMjMsOSArMjMsMTAgQEAKICAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAotI2lm bmRlZiBHZGtDYWlyb1V0aWxpdGllc19oCi0jZGVmaW5lIEdka0NhaXJvVXRpbGl0aWVzX2gKKyNw cmFnbWEgb25jZQorCituYW1lc3BhY2UgV2ViQ29yZSB7CiAKIEdka1BpeGJ1ZiogY2Fpcm9TdXJm YWNlVG9HZGtQaXhidWYoY2Fpcm9fc3VyZmFjZV90Kik7CiAKLSNlbmRpZiAvLyBHZGtDYWlyb1V0 aWxpdGllc19oCit9Cg==