194817 2019-02-19 07:02:53 -0800 [EGL] Runtime support for RGB565 pixel layout 2024-05-19 07:45:56 -0700 1 1 1 Unclassified WebKit WPE WebKit WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 pnormand pnormand aperez bugs-noreply cgarcia junior magomez mcatanzaro zan oldest_to_newest 1507661 0 pnormand 2019-02-19 07:02:53 -0800 Currently our graphics pipeline always relies on a ARGB8888 (32 bpp) pixel configuration. On some low-end (old) embedded platforms the graphics driver is sometimes optimized for 16 bpp configurations, such as RGB565. So it would be nice if there was a runtime setting that could be used on these platforms. I started a patch... 1507662 1 pnormand 2019-02-19 07:04:46 -0800 http://www.barth-dev.de/online/rgb565-color-picker/ Especially (cheap) screens used with embedded devices do not provide 24 bit color-depth. Moreover, storing and/or transmitting 3 bytes per pixel is consuming quite some memory and creates latency. RGB565 requires only 16 (5+6+5) bits/2 bytes and is commonly used with embedded screens. 1507665 2 362385 pnormand 2019-02-19 07:30:14 -0800 Created attachment 362385 Patch 1507666 3 pnormand 2019-02-19 07:51:12 -0800 I'm not really happy with the added optional arguments, I can change them to use WTF::Optional instead, if deemed better approach :) 1508035 4 362385 cgarcia 2019-02-20 02:18:45 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review Why do we need a setting for this? Can't it be detected somehow? > Source/WebCore/platform/graphics/GLContext.cpp:79 > +std::unique_ptr<GLContext> GLContext::createContextForWindow(GLNativeWindowType windowHandle, PlatformDisplay* platformDisplay, uint32_t eglConfigBitsPerPixel) If this value is set in the platform display, we wouldsn't need to pass it everywhere, we could get it from the display. > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:161 > +#if !PLATFORM(WPE) > + bitsPerPixel = 32; > +#endif Why is this specific to WPE? > Source/WebCore/platform/graphics/egl/GLContextEGL.h:92 > + static std::unique_ptr<GLContextEGL> createSurfacelessContext(PlatformDisplay&, EGLContext sharingContext = nullptr, uint32_t bitsPerPixel = 42); why 42 here? > Source/WebKit/UIProcess/API/C/WKPreferences.cpp:2123 > +#if PLATFORM(WPE) > +void WKPreferencesSetEGLConfigBitsPerPixel(WKPreferencesRef preferencesRef, int bitsPerPixel) > +{ > + toImpl(preferencesRef)->setEglConfigBitsPerPixel(bitsPerPixel); > +} > + > +bool WKPreferencesGetEGLConfigBitsPerPixel(WKPreferencesRef preferencesRef) > +{ > + return toImpl(preferencesRef)->eglConfigBitsPerPixel(); > +} > +#endif Please do not add anew C API unless it's used by WKTR 1508041 5 362385 pnormand 2019-02-20 02:49:18 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review >> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:161 >> +#endif > > Why is this specific to WPE? The whole patch is specific to WPE because I assumed the new setting would be useful for this port only, as it's the preferred port nowadays for embedded devices. >> Source/WebCore/platform/graphics/egl/GLContextEGL.h:92 >> + static std::unique_ptr<GLContextEGL> createSurfacelessContext(PlatformDisplay&, EGLContext sharingContext = nullptr, uint32_t bitsPerPixel = 42); > > why 42 here? Typo :) >> Source/WebKit/UIProcess/API/C/WKPreferences.cpp:2123 >> +#endif > > Please do not add anew C API unless it's used by WKTR Hum ok, but can I still have a web-setting without C API ? 1508043 6 pnormand 2019-02-20 02:52:05 -0800 (In reply to Carlos Garcia Campos from comment #4) > Comment on attachment 362385 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > Why do we need a setting for this? Can't it be detected somehow? > I'll let others chime in on this. For my case (i.MX51 board) it can't be detected because most formats are already advertised as supported (from 16bpp to 32bpp) but only I know that 16bpp should be preferred. AFAIK the EGL config attributes provide no support pixel format "hinting". 1508045 7 362385 pnormand 2019-02-20 03:18:06 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review >>> Source/WebKit/UIProcess/API/C/WKPreferences.cpp:2123 >>> +#endif >> >> Please do not add anew C API unless it's used by WKTR > > Hum ok, but can I still have a web-setting without C API ? The answer is 42^Wyes 1508046 8 cgarcia 2019-02-20 03:25:48 -0800 (In reply to Philippe Normand from comment #7) > Comment on attachment 362385 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > >>> Source/WebKit/UIProcess/API/C/WKPreferences.cpp:2123 > >>> +#endif > >> > >> Please do not add anew C API unless it's used by WKTR > > > > Hum ok, but can I still have a web-setting without C API ? > > The answer is 42^Wyes Yes, I only complained about the C API. But I'm not sure about the glib one either. This is very specific use-case for a particular hw/driver, and it's not something we might want to configure per web view. Maybe an env var would be more appropriate. 1508064 9 pnormand 2019-02-20 06:54:04 -0800 (In reply to Carlos Garcia Campos from comment #8) > (In reply to Philippe Normand from comment #7) > > Comment on attachment 362385 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > > > >>> Source/WebKit/UIProcess/API/C/WKPreferences.cpp:2123 > > >>> +#endif > > >> > > >> Please do not add anew C API unless it's used by WKTR > > > > > > Hum ok, but can I still have a web-setting without C API ? > > > > The answer is 42^Wyes > > Yes, I only complained about the C API. But I'm not sure about the glib one > either. This is very specific use-case for a particular hw/driver, and it's > not something we might want to configure per web view. Maybe an env var > would be more appropriate. Before I update the patch I would like to know which approach should be used... An env var would be easier to support than a web-setting, in the end it's mostly a question about semantics. So... do we use an env-var or a web-setting for this? 1508095 10 aperez 2019-02-20 09:38:13 -0800 (In reply to Philippe Normand from comment #6) > (In reply to Carlos Garcia Campos from comment #4) > > Comment on attachment 362385 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > > > Why do we need a setting for this? Can't it be detected somehow? > > > > I'll let others chime in on this. > For my case (i.MX51 board) it can't be detected because most formats are > already advertised as supported (from 16bpp to 32bpp) but only I know that > 16bpp should be preferred. AFAIK the EGL config attributes provide no > support pixel format "hinting". I have also seen some systems in which the GPU is perfectly capable of rendering in 32bpp modes, but the display attached (typically some kind of TFT LCD) only supports 16bpp. I have been working with one where the framebuffer device (correctly) allows only configuring 16bpp modes but WebKit still needs to be patched to allow choosing an EGLConfig where color components can have less than 8bit. This patch (or similar) would help and avoid needing to apply patches in my case as well. 1508470 11 cgarcia 2019-02-21 01:13:01 -0800 (In reply to Adrian Perez from comment #10) > (In reply to Philippe Normand from comment #6) > > (In reply to Carlos Garcia Campos from comment #4) > > > Comment on attachment 362385 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > > > > > Why do we need a setting for this? Can't it be detected somehow? > > > > > > > I'll let others chime in on this. > > For my case (i.MX51 board) it can't be detected because most formats are > > already advertised as supported (from 16bpp to 32bpp) but only I know that > > 16bpp should be preferred. AFAIK the EGL config attributes provide no > > support pixel format "hinting". > > I have also seen some systems in which the GPU is perfectly capable > of rendering in 32bpp modes, but the display attached (typically some > kind of TFT LCD) only supports 16bpp. I have been working with one > where the framebuffer device (correctly) allows only configuring 16bpp > modes but WebKit still needs to be patched to allow choosing an EGLConfig > where color components can have less than 8bit. This patch (or similar) > would help and avoid needing to apply patches in my case as well. I'm only concerned (not even opposed) to the setting, not the patch itself. 1508472 12 pnormand 2019-02-21 01:27:46 -0800 Yeah I think we all agree the patch makes sense. The dilemma is about env-var vs setting... An env-var would simplify the patch, a lot. But is less discoverable from the user POV, unless we have a place in the docs documenting env-vars? 1508475 13 cgarcia 2019-02-21 01:57:59 -0800 (In reply to Philippe Normand from comment #12) > Yeah I think we all agree the patch makes sense. The dilemma is about > env-var vs setting... > > An env-var would simplify the patch, a lot. But is less discoverable from > the user POV, unless we have a place in the docs documenting env-vars? We don't, but we should. 1508476 14 aperez 2019-02-21 02:07:51 -0800 (In reply to Carlos Garcia Campos from comment #13) > (In reply to Philippe Normand from comment #12) > > Yeah I think we all agree the patch makes sense. The dilemma is about > > env-var vs setting... > > > > An env-var would simplify the patch, a lot. But is less discoverable from > > the user POV, unless we have a place in the docs documenting env-vars? > > We don't, but we should. This is a good point. I have found myself now and then grepping the WebKit sources to find out which env-var we had for this or that (e.g. like the one for pausing the WebProcess to give time to attach the debugger). Not all environment variables need to be in the documentation, for example the ones used for development probably would fit better somewhere in the wiki. 1508484 15 362385 cgarcia 2019-02-21 02:48:38 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:110 > + EGL_SAMPLES, 0, Why do you add EGL_SAMPLES too? > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:118 > + EGLint bufferSize = bitsPerPixel; > + if (bufferSize == 16) { > + attributeList[9] = 0; > + attributeList[11] = 0; > + } I don't understand this. 9 is EGL_STENCIL_SIZE and 11 is EGL_ALPHA_SIZE. Why do we only change them if bitsPerPixel is 16, don't we want to support other depth sizes? like 24 for example? And why do we set the values to 0? 1508488 16 362385 pnormand 2019-02-21 03:02:02 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review >> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:110 >> + EGL_SAMPLES, 0, > > Why do you add EGL_SAMPLES too? Perhaps it can be unset, I just followed the same code as weston's simple-egl. >> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:118 >> + } > > I don't understand this. 9 is EGL_STENCIL_SIZE and 11 is EGL_ALPHA_SIZE. Why do we only change them if bitsPerPixel is 16, don't we want to support other depth sizes? like 24 for example? And why do we set the values to 0? stencil and alpha are disabled here so that we have a chance to reach 16bpp... Disabling alpha means we use an RGB format, like RGB565, which uses 16 bits for storage. For 24bpp, I think additional changes might be needed, I haven't investigated this. 1508489 17 362385 cgarcia 2019-02-21 03:06:51 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review >>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:110 >>> + EGL_SAMPLES, 0, >> >> Why do you add EGL_SAMPLES too? > > Perhaps it can be unset, I just followed the same code as weston's simple-egl. But 0 is the default for both depth size and samples. >>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:118 >>> + } >> >> I don't understand this. 9 is EGL_STENCIL_SIZE and 11 is EGL_ALPHA_SIZE. Why do we only change them if bitsPerPixel is 16, don't we want to support other depth sizes? like 24 for example? And why do we set the values to 0? > > stencil and alpha are disabled here so that we have a chance to reach 16bpp... Disabling alpha means we use an RGB format, like RGB565, which uses 16 bits for storage. > For 24bpp, I think additional changes might be needed, I haven't investigated this. That means we are exposing a setting to set the depth size, but that only works with value 16 and what it does is disabling alpha, instead of changing the depth size in the config. It's very confusing. 1508505 18 362385 pnormand 2019-02-21 07:18:39 -0800 Comment on attachment 362385 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362385&action=review >>>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:110 >>>> + EGL_SAMPLES, 0, >>> >>> Why do you add EGL_SAMPLES too? >> >> Perhaps it can be unset, I just followed the same code as weston's simple-egl. > > But 0 is the default for both depth size and samples. I'll revert this change in the next patch iteration. >>>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:118 >>>> + } >>> >>> I don't understand this. 9 is EGL_STENCIL_SIZE and 11 is EGL_ALPHA_SIZE. Why do we only change them if bitsPerPixel is 16, don't we want to support other depth sizes? like 24 for example? And why do we set the values to 0? >> >> stencil and alpha are disabled here so that we have a chance to reach 16bpp... Disabling alpha means we use an RGB format, like RGB565, which uses 16 bits for storage. >> For 24bpp, I think additional changes might be needed, I haven't investigated this. > > That means we are exposing a setting to set the depth size, but that only works with value 16 and what it does is disabling alpha, instead of changing the depth size in the config. It's very confusing. I think you're confusing pixel formats with depth testing... Anyway I'll let actual experts step in here :) 1508517 19 cgarcia 2019-02-21 08:16:57 -0800 (In reply to Philippe Normand from comment #18) > Comment on attachment 362385 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=362385&action=review > > >>>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:110 > >>>> + EGL_SAMPLES, 0, > >>> > >>> Why do you add EGL_SAMPLES too? > >> > >> Perhaps it can be unset, I just followed the same code as weston's simple-egl. > > > > But 0 is the default for both depth size and samples. > > I'll revert this change in the next patch iteration. > > >>>> Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:118 > >>>> + } > >>> > >>> I don't understand this. 9 is EGL_STENCIL_SIZE and 11 is EGL_ALPHA_SIZE. Why do we only change them if bitsPerPixel is 16, don't we want to support other depth sizes? like 24 for example? And why do we set the values to 0? > >> > >> stencil and alpha are disabled here so that we have a chance to reach 16bpp... Disabling alpha means we use an RGB format, like RGB565, which uses 16 bits for storage. > >> For 24bpp, I think additional changes might be needed, I haven't investigated this. > > > > That means we are exposing a setting to set the depth size, but that only works with value 16 and what it does is disabling alpha, instead of changing the depth size in the config. It's very confusing. > > I think you're confusing pixel formats with depth testing... Anyway I'll let > actual experts step in here :) Yes, probably, this is indeed confusing, it's weird to expose a setting that allows to set any bpp but only works if 0 or 16 is passed. Whatever bpp means, that should be an enum and not a integer, I would say. 1508529 20 magomez 2019-02-21 08:48:22 -0800 Couple of comments related to what you're talking: - EGL_DEPTH_SIZE is not set because we don't use depth testing so we want it to be 0 (default value). Same with EGL_SAMPLES. - EGL_STENCIL_SIZE needs to be 8 cause we need it to do stencil clipping. That's not related to bpp as that's not transferred to the display. - When setting the values of EGL_RED_SIZE, EGL_BLUE_SIZE and EGL_GREEN_SIZE to 1 you are saying that you want the smallest size available for those. But that could be RGB444 if that's supported and not the RGB565 that you're expecting. If you want RGB565 specifically, you should set those values to 5, 6, and 5 respectively. 1508533 21 magomez 2019-02-21 08:57:23 -0800 Maybe instead of receiving the bpp, what we need to receive is a format. For example WPE_EGL_FORMAT and allow RGB565 for starters, and then fallback to RGBA8888 if that's not supported. Later we can add more formats if we want to. 1508659 22 pnormand 2019-02-21 14:04:10 -0800 (In reply to Miguel Gomez from comment #20) > Couple of comments related to what you're talking: > > - EGL_DEPTH_SIZE is not set because we don't use depth testing so we want it > to be 0 (default value). Same with EGL_SAMPLES. > > - EGL_STENCIL_SIZE needs to be 8 cause we need it to do stencil clipping. > That's not related to bpp as that's not transferred to the display. > > - When setting the values of EGL_RED_SIZE, EGL_BLUE_SIZE and EGL_GREEN_SIZE > to 1 you are saying that you want the smallest size available for those. But > that could be RGB444 if that's supported and not the RGB565 that you're > expecting. If you want RGB565 specifically, you should set those values to > 5, 6, and 5 respectively. But RGB444 isn't a 16bpp format, is it? As I understand it, setting RGB channels to 1 constitutes a low-barrier for filtering on EGL_BUFFER_SIZE later on. (In reply to Miguel Gomez from comment #21) > Maybe instead of receiving the bpp, what we need to receive is a format. For > example WPE_EGL_FORMAT and allow RGB565 for starters, and then fallback to > RGBA8888 if that's not supported. Later we can add more formats if we want > to. Yes... that's an option too. Explicit is better than implicit... But I'm not sure there's a use for say, 24bpp formats... As mentioned in previous comments there's quite a few setups where 16bpp is the preferred format. In this patch I basically copied the behaviour of weston's simple-egl client, which has a runtime option for 16bpp formats... 1508909 23 cgarcia 2019-02-21 23:11:03 -0800 (In reply to Philippe Normand from comment #22) > (In reply to Miguel Gomez from comment #20) > > Couple of comments related to what you're talking: > > > > - EGL_DEPTH_SIZE is not set because we don't use depth testing so we want it > > to be 0 (default value). Same with EGL_SAMPLES. > > > > - EGL_STENCIL_SIZE needs to be 8 cause we need it to do stencil clipping. > > That's not related to bpp as that's not transferred to the display. > > > > - When setting the values of EGL_RED_SIZE, EGL_BLUE_SIZE and EGL_GREEN_SIZE > > to 1 you are saying that you want the smallest size available for those. But > > that could be RGB444 if that's supported and not the RGB565 that you're > > expecting. If you want RGB565 specifically, you should set those values to > > 5, 6, and 5 respectively. > > But RGB444 isn't a 16bpp format, is it? > As I understand it, setting RGB channels to 1 constitutes a low-barrier for > filtering on EGL_BUFFER_SIZE later on. > > (In reply to Miguel Gomez from comment #21) > > Maybe instead of receiving the bpp, what we need to receive is a format. For > > example WPE_EGL_FORMAT and allow RGB565 for starters, and then fallback to > > RGBA8888 if that's not supported. Later we can add more formats if we want > > to. > > Yes... that's an option too. Explicit is better than implicit... But I'm not > sure there's a use for say, 24bpp formats... As mentioned in previous > comments there's quite a few setups where 16bpp is the preferred format. > > In this patch I basically copied the behaviour of weston's simple-egl > client, which has a runtime option for 16bpp formats... Could we simplify it then as use-rgba-egl-config (or something similar) in the public API? 1508910 24 cgarcia 2019-02-21 23:14:00 -0800 This is what gtk does in gdkglcontext-wayland.c: use_rgba = (visual == gdk_screen_get_rgba_visual (gdk_display_get_default_screen (display))); if (use_rgba) { attrs[i++] = EGL_ALPHA_SIZE; attrs[i++] = 1; } else { attrs[i++] = EGL_ALPHA_SIZE; attrs[i++] = 0; } So, for the GTK port we could get the web view visual and send use_rgba to the web process without any new public API (I'm not asking to do this as port of this patch, though) 1508932 25 pnormand 2019-02-22 01:01:53 -0800 Disabling alpha is not enough because it might lead to RGB888 being selected. 1508983 26 cgarcia 2019-02-22 06:06:43 -0800 (In reply to Philippe Normand from comment #25) > Disabling alpha is not enough because it might lead to RGB888 being selected. GTK also uses 1 for EGL_RED_SIZE, EGL_BLUE_SIZE and EGL_GREEN_SIZE 1509589 27 pnormand 2019-02-25 04:19:34 -0800 So which approach should I use? Env var or setting? I'd like to get this in WPE 2.24 if possible, so we need to settle on the approach :) 1509595 28 cgarcia 2019-02-25 04:37:04 -0800 (In reply to Philippe Normand from comment #27) > So which approach should I use? Env var or setting? I'd like to get this in > WPE 2.24 if possible, so we need to settle on the approach :) I think it's too late for new API in 2.24, specially when it's not clear enough how the thing should be exposed in the API. 1509596 29 cgarcia 2019-02-25 04:38:15 -0800 (In reply to Carlos Garcia Campos from comment #26) > (In reply to Philippe Normand from comment #25) > > Disabling alpha is not enough because it might lead to RGB888 being selected. > > GTK also uses 1 for EGL_RED_SIZE, EGL_BLUE_SIZE and EGL_GREEN_SIZE And allows to set a different visual per window, so maybe we should also allow to use a different config per web view in the end. 1509600 30 362894 pnormand 2019-02-25 04:57:00 -0800 Created attachment 362894 Patch 1509601 31 362894 pnormand 2019-02-25 04:59:17 -0800 Comment on attachment 362894 Patch Oops, this is incomplete 1509602 32 362895 pnormand 2019-02-25 05:02:09 -0800 Created attachment 362895 Patch 1509992 33 362895 cgarcia 2019-02-26 01:40:29 -0800 Comment on attachment 362895 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362895&action=review > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:114 > + const char* environmentVariable = getenv("WEBKIT_EGL_PIXEL_FORMAT"); > + if (environmentVariable && *environmentVariable) { I don't think we need to check it's not empty, you could simply: if (const char* pixelFormat = getenv("WEBKIT_EGL_PIXEL_FORMAT")) { } > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:120 > + attributeList[3] = 5; > + attributeList[5] = 6; > + attributeList[7] = 5; > + attributeList[9] = 0; This is confusing, please add a comment before every line saying with the value this is for: // EGL_RED_SIZE attributeList[3] = 5; // EGL_GREEN_SIZE attributeList[5] = 6; ..... > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:122 > + g_warning("Value supplied for WEBKIT_EGL_PIXEL_FORMAT should be RGB565 or the environment variable should not be set at all."); Do not use g_warning() in this file that is not glib specific. You can use WTFLogAlways. I would say something like: "Unknown pixel format %s, falling back to RGBA8888". > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:141 > + EGLint count; > + if (!eglGetConfigs(display, nullptr, 0, &count) || !count) > + return false; I don't think we want all display configs, but only the ones matching the attributes. You can use eglChooseConfig() passing nullptr as configs to get the numbers of configs. > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:143 > + EGLConfig* configs = reinterpret_cast<EGLConfig*>(fastCalloc(sizeof(EGLConfig), count)); Use unique_ptr here, this is leaked if eglChooseConfig fails below. > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:146 > EGLint numberConfigsReturned; > - return eglChooseConfig(display, attributeList, config, 1, &numberConfigsReturned) && numberConfigsReturned; > + if (!eglChooseConfig(display, attributeList, configs, count, &numberConfigsReturned) || !numberConfigsReturned) > + return false; I think we can keep using 1 config only for the non rgb565 case, since we don'tm need to iterate configs in such case. We could do something like: if (!eglChooseConfig(display, attributeList, isRGB565 ? configs : config, isRGB565 ? count : 1, &numberConfigsReturned) || !numberConfigsReturned) return false; if (!isRGB565) return true; // Iterate configs to find the one matching. > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:150 > + eglGetConfigAttrib(display, configs[i], EGL_BUFFER_SIZE, &size); Is really buffer size enough? couldn't be other formats with 16 that are not RGB565? I think it would be safer to get EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, and EGL_ALPHA_SIZE, and check they are 5, 6, 5, 0. 1510004 34 362974 pnormand 2019-02-26 04:00:19 -0800 Created attachment 362974 Patch 1510005 35 362975 pnormand 2019-02-26 04:06:57 -0800 Created attachment 362975 Patch 1510006 36 362974 cgarcia 2019-02-26 04:14:34 -0800 Comment on attachment 362974 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=362974&action=review > Source/WebCore/ChangeLog:3 > + [WPE][EGL] Runtime support for RGB565 pixel layout This is not WPE specific anymore > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:150 > + auto configs = std::make_unique<Vector<EGLConfig>>(count); Using Vector is a good idea, but then you don't need to use std::unique_ptr, just keep the vector stack allocated. > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:162 > + return (redSize == 5 && greenSize == 6 && blueSize == 5); Don't we need to check alpha is 0 too? 1510011 37 362978 pnormand 2019-02-26 06:26:30 -0800 Created attachment 362978 Patch 1510023 38 pnormand 2019-02-26 07:13:51 -0800 Committed r242084: <https://trac.webkit.org/changeset/242084> 1510051 39 mcatanzaro 2019-02-26 09:27:28 -0800 (In reply to Philippe Normand from comment #27) > So which approach should I use? Env var or setting? I'd like to get this in > WPE 2.24 if possible, so we need to settle on the approach :) We shouldn't add environment variables that must be set for WebKit to work properly, unless there's also corresponding API. If applications rely on setting the environment variable, they will -- almost guaranteed -- do so in an unsafe manner. But if we provide a corresponding API, then the environment variable becomes OK, since applications will very likely use the API, and the environment variable becomes just a convenience for debugging. If there's really absolutely no way for WebKit to know the right pixel layout to use on its own, then we must add new API. That's better than requiring applications set an environment variable to work. But it would also be sad, because we try hard to avoid exposing low-level details like this in our API. Maybe it should be exposed only for WPE. 1510054 40 pnormand 2019-02-26 09:38:20 -0800 (In reply to Michael Catanzaro from comment #39) > (In reply to Philippe Normand from comment #27) > > So which approach should I use? Env var or setting? I'd like to get this in > > WPE 2.24 if possible, so we need to settle on the approach :) > > We shouldn't add environment variables that must be set for WebKit to work > properly, s/must/may/ You once again exaggerated things. This patch is about optimizing rendering, if the var is not set rendering will still work, although in some platforms, not optimally. > unless there's also corresponding API. If applications rely on > setting the environment variable, they will -- almost guaranteed -- do so in > an unsafe manner. But if we provide a corresponding API, then the > environment variable becomes OK, since applications will very likely use the > API, and the environment variable becomes just a convenience for debugging. > > If there's really absolutely no way for WebKit to know the right pixel > layout to use on its own, then we must add new API. That's better than > requiring applications set an environment variable to work. But it would > also be sad, because we try hard to avoid exposing low-level details like > this in our API. Maybe it should be exposed only for WPE. I agree it doesn't make much sense to have GTK API for this. 1510393 41 cgarcia 2019-02-26 23:49:29 -0800 (In reply to Michael Catanzaro from comment #39) > (In reply to Philippe Normand from comment #27) > > So which approach should I use? Env var or setting? I'd like to get this in > > WPE 2.24 if possible, so we need to settle on the approach :) > > We shouldn't add environment variables that must be set for WebKit to work > properly, unless there's also corresponding API. That's not the case here. > If applications rely on > setting the environment variable, they will -- almost guaranteed -- do so in > an unsafe manner. Sure, you know it. > But if we provide a corresponding API, then the > environment variable becomes OK, since applications will very likely use the > API, and the environment variable becomes just a convenience for debugging. Please, read the other comments in this bug. The plan is to add API for this, but we haven't agreed on how to expose it yet. Phil needs this in 2.24 branch and I don't want to add new API in 2.24 at this point without being sure about the best approach to expose this. So, the env var allows to add the functionality while we decide on the API for 2.26. > If there's really absolutely no way for WebKit to know the right pixel > layout to use on its own, then we must add new API. Again, that's the plan. > That's better than > requiring applications set an environment variable to work. Again, that's not the case. > But it would > also be sad, because we try hard to avoid exposing low-level details like > this in our API. Maybe it should be exposed only for WPE. In gtk we might try to guess the right pixel layout from the GdkWindow visual. 1510430 42 mcatanzaro 2019-02-27 06:45:19 -0800 OK, that seems perfectly fine! Just need to follow-up with new API for 2.26. And document it here: https://trac.webkit.org/wiki/EnvironmentVariables (In reply to Carlos Garcia Campos from comment #41) > > We shouldn't add environment variables that must be set for WebKit to work > > properly, unless there's also corresponding API. > > That's not the case here. It could be restated as: we shouldn't add environment variables that applications will be tempted to set. 2036282 43 junior 2024-05-19 07:45:56 -0700 Created attachment 280450 [details] Patched on https://emp3juice.blog/ https://tubidy.diy/ https://y2mate.diy/ 362385 2019-02-19 07:30:14 -0800 2019-02-25 04:56:56 -0800 Patch bug-194817-20190219153012.patch text/plain 35394 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQxNzYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWJkYzZkM2ZhMGEwNDlk MzA0NjQwOTM2MmVhMDA2ZDhmZWZiN2FiMC4uOGY5YThhZmZjZDBkYjdlNjA2NTJiN2IxMTg5OGUz ZGFlNDRjZjllNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDE5LTAyLTE5ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtFR0xd IFJ1bnRpbWUgc3VwcG9ydCBmb3IgMTYgYnBwIEVHTCBjb25maWd1cmF0aW9ucworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk0ODE3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5IG91ciBncmFw aGljcyBwaXBlbGluZSBhbHdheXMgcmVsaWVzIG9uIGEgQVJHQjg4ODggKDMyCisgICAgICAgIGJw cCkgcGl4ZWwgY29uZmlndXJhdGlvbi4gT24gc29tZSBsb3ctZW5kIChvbGQpIGVtYmVkZGVkIHBs YXRmb3JtcworICAgICAgICB0aGUgZ3JhcGhpY3MgZHJpdmVyIGlzIHNvbWV0aW1lcyBvcHRpbWl6 ZWQgZm9yIDE2IGJwcAorICAgICAgICBjb25maWd1cmF0aW9ucywgc3VjaCBhcyBSR0I1NjUuIE9u IHRob3NlIHBsYXRmb3JtcyB0aGUgYXBwbGljYXRpb24KKyAgICAgICAgY2FuIG5vdyBjb25maWd1 cmUgdGhlIGVnbC1jb25maWctYml0cy1wZXItcGl4ZWwgc2V0dGluZyB2YWx1ZSB0bworICAgICAg ICBhZGp1c3QgdG8gdGhlIGJlc3QgcGl4ZWwgY29uZmlndXJhdGlvbiBzdXBwb3J0ZWQgYnkgdGhl IHNjcmVlbiBhbmQKKyAgICAgICAgZ3JhcGhpY3MgZHJpdmVyLgorCisgICAgICAgICogcGFnZS9T ZXR0aW5ncy55YW1sOiBBZGQgYSBuZXcgZWdsQ29uZmlnQml0c1BlclBpeGVsIHdlYi1zZXR0aW5n LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0dMQ29udGV4dC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpHTENvbnRleHQ6OmNyZWF0ZUNvbnRleHRGb3JXaW5kb3cpOiBPcHRpb25hbAorICAg ICAgICBlZ2xDb25maWdCaXRzUGVyUGl4ZWwgYXJndW1lbnQsIGRlZmF1bHRpbmcgdG8gMzJicHAu CisgICAgICAgIChXZWJDb3JlOjpHTENvbnRleHQ6OmNyZWF0ZVNoYXJpbmdDb250ZXh0KTogRGl0 dG8uCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvR0xDb250ZXh0Lmg6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvUGxhdGZvcm1EaXNwbGF5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlBsYXRmb3JtRGlzcGxheTo6c2hhcmluZ0dMQ29udGV4dCk6IERpdHRvLgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R0xDb250ZXh0 RUdMOjpnZXRFR0xDb25maWcpOiBEaXNhYmxlIGFscGhhIGFuZCBzdGVuY2lsCisgICAgICAgIGZv ciAxNmJwcCBjb25maWd1cmF0aW9ucy4gQWxzbyBwZXJmb3JtIGZpbHRlcmluZyBvZiB0aGUgcHJv YmVkCisgICAgICAgIGNvbmZpZ3VyYXRpb24gdG8gc2VsZWN0IHRoZSBvbmUgaGludGVkIGJ5IHRo ZSBwYXNzZWQgcGl4ZWwKKyAgICAgICAgcmVzb2x1dGlvbiB2YWx1ZS4KKyAgICAgICAgKFdlYkNv cmU6OkdMQ29udGV4dEVHTDo6Y3JlYXRlV2luZG93Q29udGV4dCk6IE9wdGlvbmFsCisgICAgICAg IGVnbENvbmZpZ0JpdHNQZXJQaXhlbCBhcmd1bWVudCwgZGVmYXVsdGluZyB0byAzMmJwcC4KKyAg ICAgICAgKFdlYkNvcmU6OkdMQ29udGV4dEVHTDo6Y3JlYXRlU3VyZmFjZWxlc3NDb250ZXh0KTog RGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpHTENvbnRleHRFR0w6OmNyZWF0ZUNvbnRleHQpOiBE aXR0by4KKyAgICAgICAgKFdlYkNvcmU6OkdMQ29udGV4dEVHTDo6Y3JlYXRlU2hhcmluZ0NvbnRl eHQpOiBEaXR0by4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdM Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTExpYldQRS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpHTENvbnRleHRFR0w6OmNyZWF0ZVdQRUNvbnRleHQpOiBE aXR0by4KKwogMjAxOS0wMi0xNiAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAKICAg ICAgICAgQ29udGludWUgcmVkdWNpbmcgdXNlIG9mIFN0cmluZzo6Zm9ybWF0LCBub3cgZm9jdXNp bmcgb24gaGV4OiAiJXAiLCAiJXgiLCBldGMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQ5YTIxZDlkYTViZjVjOWI3 MmRjOTgyMTgyNzJhYTM4OTg5OWNhMWMuLjcwMjBhMDQ5NTQ1YWM5NTg3YWM0YzBlMTQ2N2Y5MDg1 YTBhZDJlNjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzggQEAKKzIwMTktMDItMTkgIFBoaWxpcHBl IE5vcm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgorCisgICAgICAgIFtXUEVdW0VHTF0gUnVu dGltZSBzdXBwb3J0IGZvciAxNiBicHAgRUdMIGNvbmZpZ3VyYXRpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTQ4MTcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNoYXJlZC9Db29yZGluYXRlZEdy YXBoaWNzL3RocmVhZGVkY29tcG9zaXRvci9UaHJlYWRlZENvbXBvc2l0b3IuY3BwOgorICAgICAg ICAoV2ViS2l0OjpUaHJlYWRlZENvbXBvc2l0b3I6OmNyZWF0ZUdMQ29udGV4dCk6IFVzZSB0aGUg Y2xpZW50J3MKKyAgICAgICAgZWdsLWNvbmZpZy1iaXRzLXBlci1waXhlbCB2YWx1ZSB3aGVuIGNy ZWF0aW5nIHRoZSBHTCBjb250ZXh0LgorICAgICAgICAqIFNoYXJlZC9Db29yZGluYXRlZEdyYXBo aWNzL3RocmVhZGVkY29tcG9zaXRvci9UaHJlYWRlZENvbXBvc2l0b3IuaDoKKyAgICAgICAgKiBT aGFyZWQvV2ViUHJlZmVyZW5jZXMueWFtbDogQWRkIG5ldyBFZ2xDb25maWdCaXRzUGVyUGl4ZWwg V2ViUHJlZmVyZW5jZS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0MvV0tQcmVmZXJlbmNlcy5j cHA6CisgICAgICAgIChXS1ByZWZlcmVuY2VzU2V0RUdMQ29uZmlnQml0c1BlclBpeGVsKToKKyAg ICAgICAgKFdLUHJlZmVyZW5jZXNHZXRFR0xDb25maWdCaXRzUGVyUGl4ZWwpOgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRTZXR0aW5ncy5jcHA6IE5ldyBlZ2wtY29uZmlnLWJp dHMtcGVyLXBpeGVsIFdQRSBXZWJTZXR0aW5nLgorICAgICAgICAod2ViS2l0U2V0dGluZ3NTZXRQ cm9wZXJ0eSk6CisgICAgICAgICh3ZWJLaXRTZXR0aW5nc0dldFByb3BlcnR5KToKKyAgICAgICAg KHdlYmtpdF9zZXR0aW5nc19jbGFzc19pbml0KToKKyAgICAgICAgKHdlYmtpdF9zZXR0aW5nc19n ZXRfZWdsX2NvbmZpZ19iaXRzX3Blcl9waXhlbCk6CisgICAgICAgICh3ZWJraXRfc2V0dGluZ3Nf c2V0X2VnbF9jb25maWdfYml0c19wZXJfcGl4ZWwpOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkv d3BlL1dlYktpdFNldHRpbmdzLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS93cGUvZG9jcy93 cGUtMC4xLXNlY3Rpb25zLnR4dDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRp bmF0ZWRHcmFwaGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdC5jcHA6CisgICAg ICAgIChXZWJLaXQ6OlRocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0OjplZ2xDb25maWdC aXRzUGVyUGl4ZWwpOgorICAgICAgICBDaGFpbiB0byBXZWJQYWdlJ3MgZWxnQ29uZmlnQml0c1Bl clBpeGVsIHZhbHVlIG9yIGZhbGxiYWNrIHRvIDMyCisgICAgICAgIGJwcCBvbiBub24gV1BFIHBs YXRmb3Jtcy4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFwaGlj cy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdC5oOgorICAgICAgICAqIFdlYlByb2Nl c3MvV2ViUGFnZS9XZWJQYWdlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6dXBkYXRl UHJlZmVyZW5jZXMpOiBVcGRhdGUgV2ViUGFnZSdzCisgICAgICAgIGVnbENvbmZpZ0JpdHNQZXJQ aXhlbCB2YWx1ZSB3aGVuIHRoZSBjb3JyZXNwb25kaW5nIHNldHRpbmcgaGFzCisgICAgICAgIGNo YW5nZXMuCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaDoKKyAgICAgICAg KFdlYktpdDo6V2ViUGFnZTo6ZWdsQ29uZmlnQml0c1BlclBpeGVsIGNvbnN0KToKKwogMjAxOS0w Mi0xOSAgQW50b2luZSBRdWludCAgPGdyYW91dHNAYXBwbGUuY29tPgogCiAgICAgICAgIFtpT1Nd ICJ0b3VjaC1hY3Rpb246IG5vbmUiIHNob3VsZCBub3QgcHJldmVudCB0ZXh0IHNlbGVjdGlvbiBv ciB0YXBwaW5nIG9uIGEgbGluawpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZXR0 aW5ncy55YW1sIGIvU291cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy55YW1sCmluZGV4IDU0NTg1 YmViNjY0ZGQxMTk4MDY5MmU5NTE5NWEwYzIwM2ZjMmYxNzMuLjc4ODNmYTdhNjQ2ZmJkZWQyMGQz YTk2NzQ1OTQ1N2M0Mjk2Y2RhY2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0 dGluZ3MueWFtbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLnlhbWwKQEAgLTgw MCw2ICs4MDAsMTAgQEAgZWRpdGFibGVJbWFnZXNFbmFibGVkOgogYWRDbGlja0F0dHJpYnV0aW9u RW5hYmxlZDoKICAgaW5pdGlhbDogZmFsc2UKIAorZWdsQ29uZmlnQml0c1BlclBpeGVsOgorICB0 eXBlOiBpbnQKKyAgaW5pdGlhbDogMzIKKwogIyBEZXByZWNhdGVkCiAKIGljZUNhbmRpZGF0ZUZp bHRlcmluZ0VuYWJsZWQ6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9HTENvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR0xD b250ZXh0LmNwcAppbmRleCBmNmQzMGRiNThlNTJiZDk3YjcwNzc1MjE3MTRhNjAxYTEyNjNmNTEw Li5mNTIzOWIxOWJjYjdiN2Y0MTI2MTA4ODE1YjZiYjc0NDllZjkzMjMwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HTENvbnRleHQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dMQ29udGV4dC5jcHAKQEAgLTc2LDggKzc2LDEy IEBAIHN0YXRpYyBib29sIGluaXRpYWxpemVPcGVuR0xTaGltc0lmTmVlZGVkKCkKICNlbmRpZgog fQogCi1zdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0PiBHTENvbnRleHQ6OmNyZWF0ZUNvbnRleHRG b3JXaW5kb3coR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvd0hhbmRsZSwgUGxhdGZvcm1EaXNwbGF5 KiBwbGF0Zm9ybURpc3BsYXkpCitzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0PiBHTENvbnRleHQ6 OmNyZWF0ZUNvbnRleHRGb3JXaW5kb3coR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvd0hhbmRsZSwg UGxhdGZvcm1EaXNwbGF5KiBwbGF0Zm9ybURpc3BsYXksIHVpbnQzMl90IGVnbENvbmZpZ0JpdHNQ ZXJQaXhlbCkKIHsKKyNpZiAhVVNFKEVHTCkKKyAgICBVTlVTRURfUEFSQU0oZWdsQ29uZmlnQml0 c1BlclBpeGVsKTsKKyNlbmRpZgorCiAgICAgaWYgKCFpbml0aWFsaXplT3BlbkdMU2hpbXNJZk5l ZWRlZCgpKQogICAgICAgICByZXR1cm4gbnVsbHB0cjsKIApAQCAtOTUsNyArOTksNyBAQCBzdGQ6 OnVuaXF1ZV9wdHI8R0xDb250ZXh0PiBHTENvbnRleHQ6OmNyZWF0ZUNvbnRleHRGb3JXaW5kb3co R0xOYXRpdmVXaW5kb3dUeXBlCiAgICAgICAgIHJldHVybiBXVEZNb3ZlKGdseENvbnRleHQpOwog I2VuZGlmCiAjaWYgVVNFKEVHTCkKLSAgICBpZiAoYXV0byBlZ2xDb250ZXh0ID0gR0xDb250ZXh0 RUdMOjpjcmVhdGVDb250ZXh0KHdpbmRvd0hhbmRsZSwgZGlzcGxheSkpCisgICAgaWYgKGF1dG8g ZWdsQ29udGV4dCA9IEdMQ29udGV4dEVHTDo6Y3JlYXRlQ29udGV4dCh3aW5kb3dIYW5kbGUsIGRp c3BsYXksIGVnbENvbmZpZ0JpdHNQZXJQaXhlbCkpCiAgICAgICAgIHJldHVybiBXVEZNb3ZlKGVn bENvbnRleHQpOwogI2VuZGlmCiAgICAgcmV0dXJuIG51bGxwdHI7CkBAIC0xMDksNyArMTEzLDcg QEAgc3RkOjp1bmlxdWVfcHRyPEdMQ29udGV4dD4gR0xDb250ZXh0OjpjcmVhdGVPZmZzY3JlZW5D b250ZXh0KFBsYXRmb3JtRGlzcGxheSogcGwKICAgICByZXR1cm4gY3JlYXRlQ29udGV4dEZvcldp bmRvdygwLCBwbGF0Zm9ybURpc3BsYXkgPyBwbGF0Zm9ybURpc3BsYXkgOiAmUGxhdGZvcm1EaXNw bGF5OjpzaGFyZWREaXNwbGF5KCkpOwogfQogCi1zdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0PiBH TENvbnRleHQ6OmNyZWF0ZVNoYXJpbmdDb250ZXh0KFBsYXRmb3JtRGlzcGxheSYgZGlzcGxheSkK K3N0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHQ+IEdMQ29udGV4dDo6Y3JlYXRlU2hhcmluZ0NvbnRl eHQoUGxhdGZvcm1EaXNwbGF5JiBkaXNwbGF5LCB1aW50MzJfdCBlZ2xDb25maWdCaXRzUGVyUGl4 ZWwpCiB7CiAgICAgaWYgKCFpbml0aWFsaXplT3BlbkdMU2hpbXNJZk5lZWRlZCgpKQogICAgICAg ICByZXR1cm4gbnVsbHB0cjsKQEAgLTEyMiw4ICsxMjYsMTAgQEAgc3RkOjp1bmlxdWVfcHRyPEdM Q29udGV4dD4gR0xDb250ZXh0OjpjcmVhdGVTaGFyaW5nQ29udGV4dChQbGF0Zm9ybURpc3BsYXkm IGRpc3AKICNlbmRpZgogCiAjaWYgVVNFKEVHTCkgfHwgUExBVEZPUk0oV0FZTEFORCkgfHwgUExB VEZPUk0oV1BFKQotICAgIGlmIChhdXRvIGVnbENvbnRleHQgPSBHTENvbnRleHRFR0w6OmNyZWF0 ZVNoYXJpbmdDb250ZXh0KGRpc3BsYXkpKQorICAgIGlmIChhdXRvIGVnbENvbnRleHQgPSBHTENv bnRleHRFR0w6OmNyZWF0ZVNoYXJpbmdDb250ZXh0KGRpc3BsYXksIGVnbENvbmZpZ0JpdHNQZXJQ aXhlbCkpCiAgICAgICAgIHJldHVybiBXVEZNb3ZlKGVnbENvbnRleHQpOworI2Vsc2UKKyAgICBV TlVTRURfUEFSQU0oZWdsQ29uZmlnQml0c1BlclBpeGVsKTsKICNlbmRpZgogCiAgICAgcmV0dXJu IG51bGxwdHI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9H TENvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dMQ29udGV4dC5o CmluZGV4IDg2MTVlYTA2ZDg3NWIyNmRiMTA5ZmJjZDQ2MmY4MDBmZWI5NzI3NTMuLmQxMGQxNDE3 NjIyYTU0MzA0MjI1MTY0ZGE3NTA4YjA1Y2YxYzM2MDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dMQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dMQ29udGV4dC5oCkBAIC00NSw5ICs0NSw5IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIGNsYXNzIEdMQ29udGV4dCB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoR0xD b250ZXh0KTsgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiBwdWJsaWM6Ci0gICAgV0VCQ09SRV9F WFBPUlQgc3RhdGljIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHQ+IGNyZWF0ZUNvbnRleHRGb3JX aW5kb3coR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvd0hhbmRsZSwgUGxhdGZvcm1EaXNwbGF5KiA9 IG51bGxwdHIpOworICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xD b250ZXh0PiBjcmVhdGVDb250ZXh0Rm9yV2luZG93KEdMTmF0aXZlV2luZG93VHlwZSB3aW5kb3dI YW5kbGUsIFBsYXRmb3JtRGlzcGxheSogPSBudWxscHRyLCB1aW50MzJfdCBlZ2xDb25maWdCaXRz UGVyUGl4ZWwgPSAzMik7CiAgICAgc3RhdGljIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHQ+IGNy ZWF0ZU9mZnNjcmVlbkNvbnRleHQoUGxhdGZvcm1EaXNwbGF5KiA9IG51bGxwdHIpOwotICAgIHN0 YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0PiBjcmVhdGVTaGFyaW5nQ29udGV4dChQbGF0 Zm9ybURpc3BsYXkmKTsKKyAgICBzdGF0aWMgc3RkOjp1bmlxdWVfcHRyPEdMQ29udGV4dD4gY3Jl YXRlU2hhcmluZ0NvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgdWludDMyX3QgZWdsQ29uZmlnQml0 c1BlclBpeGVsID0gMzIpOwogICAgIHN0YXRpYyBHTENvbnRleHQqIGN1cnJlbnQoKTsKICAgICBz dGF0aWMgYm9vbCBpc0V4dGVuc2lvblN1cHBvcnRlZChjb25zdCBjaGFyKiBleHRlbnNpb25MaXN0 LCBjb25zdCBjaGFyKiBleHRlbnNpb24pOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9QbGF0Zm9ybURpc3BsYXkuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvUGxhdGZvcm1EaXNwbGF5LmNwcAppbmRleCBkMjNjNjA3OTJlYTk3MDJl Njk5MmFlYzY4NzZlMDkzYzU1ZjJkMzE3Li4yMGMxNmUyODY1ZjIzNTUxYzcyMDI1NWNmOTQwYjc1 NjlkMDA0NDdiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Q bGF0Zm9ybURpc3BsYXkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L1BsYXRmb3JtRGlzcGxheS5jcHAKQEAgLTE1NywxMCArMTU3LDEwIEBAIFBsYXRmb3JtRGlzcGxh eTo6flBsYXRmb3JtRGlzcGxheSgpCiB9CiAKICNpZiBVU0UoRUdMKSB8fCBVU0UoR0xYKQotR0xD b250ZXh0KiBQbGF0Zm9ybURpc3BsYXk6OnNoYXJpbmdHTENvbnRleHQoKQorR0xDb250ZXh0KiBQ bGF0Zm9ybURpc3BsYXk6OnNoYXJpbmdHTENvbnRleHQodWludDMyX3QgZWdsQ29uZmlnQml0c1Bl clBpeGVsKQogewogICAgIGlmICghbV9zaGFyaW5nR0xDb250ZXh0KQotICAgICAgICBtX3NoYXJp bmdHTENvbnRleHQgPSBHTENvbnRleHQ6OmNyZWF0ZVNoYXJpbmdDb250ZXh0KCp0aGlzKTsKKyAg ICAgICAgbV9zaGFyaW5nR0xDb250ZXh0ID0gR0xDb250ZXh0OjpjcmVhdGVTaGFyaW5nQ29udGV4 dCgqdGhpcywgZWdsQ29uZmlnQml0c1BlclBpeGVsKTsKICAgICByZXR1cm4gbV9zaGFyaW5nR0xD b250ZXh0LmdldCgpOwogfQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9QbGF0Zm9ybURpc3BsYXkuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5oCmluZGV4IDRmMjkyOWE2NDg4MDA4YTA5N2RkMWJh ZDVkYTkzYjM0OWRiODJjNzIuLmEwN2JhZDZhYjUxZGUzM2Y4ZjcwOTY1ZjRkOGExODU0NzZmMzhi YTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3Jt RGlzcGxheS5oCkBAIC02Miw3ICs2Miw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFR5cGUgdHlw ZSgpIGNvbnN0ID0gMDsKIAogI2lmIFVTRShFR0wpIHx8IFVTRShHTFgpCi0gICAgV0VCQ09SRV9F WFBPUlQgR0xDb250ZXh0KiBzaGFyaW5nR0xDb250ZXh0KCk7CisgICAgV0VCQ09SRV9FWFBPUlQg R0xDb250ZXh0KiBzaGFyaW5nR0xDb250ZXh0KHVpbnQzMl90IGVnbENvbmZpZ0JpdHNQZXJQaXhl bCA9IDMyKTsKICNlbmRpZgogCiAjaWYgVVNFKEVHTCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5jcHAKaW5kZXggMjRkMDZiYTAy Yjc5ZjRiNzZkNzkyMjc3NGEwZjhjZDVlMzA2YTBhYy4uZWEwZWQ1M2IwZjQ4OTQ3OTBkMmEyYjUy N2E5ZjU3MTZhYzcwNDg2YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZWdsL0dMQ29udGV4dEVHTC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5jcHAKQEAgLTkyLDcgKzkyLDcgQEAgY29uc3QgY2hh ciogR0xDb250ZXh0RUdMOjpsYXN0RXJyb3JTdHJpbmcoKQogICAgIHJldHVybiBlcnJvclN0cmlu ZyhlZ2xHZXRFcnJvcigpKTsKIH0KIAotYm9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZpZyhF R0xEaXNwbGF5IGRpc3BsYXksIEVHTENvbmZpZyogY29uZmlnLCBFR0xTdXJmYWNlVHlwZSBzdXJm YWNlVHlwZSkKK2Jvb2wgR0xDb250ZXh0RUdMOjpnZXRFR0xDb25maWcoRUdMRGlzcGxheSBkaXNw bGF5LCBFR0xDb25maWcqIGNvbmZpZywgRUdMU3VyZmFjZVR5cGUgc3VyZmFjZVR5cGUsIHVpbnQz Ml90IGJpdHNQZXJQaXhlbCkKIHsKICAgICBFR0xpbnQgYXR0cmlidXRlTGlzdFtdID0gewogI2lm IFVTRShPUEVOR0xfRVMpCkBAIC0xMDAsMTUgKzEwMCwyMyBAQCBib29sIEdMQ29udGV4dEVHTDo6 Z2V0RUdMQ29uZmlnKEVHTERpc3BsYXkgZGlzcGxheSwgRUdMQ29uZmlnKiBjb25maWcsIEVHTFN1 cmZhYwogI2Vsc2UKICAgICAgICAgRUdMX1JFTkRFUkFCTEVfVFlQRSwgRUdMX09QRU5HTF9CSVQs CiAjZW5kaWYKLSAgICAgICAgRUdMX1JFRF9TSVpFLCA4LAotICAgICAgICBFR0xfR1JFRU5fU0la RSwgOCwKLSAgICAgICAgRUdMX0JMVUVfU0laRSwgOCwKLSAgICAgICAgRUdMX1NURU5DSUxfU0la RSwgOCwKLSAgICAgICAgRUdMX0FMUEhBX1NJWkUsIDgsCisgICAgICAgIEVHTF9SRURfU0laRSwg MSwKKyAgICAgICAgRUdMX0dSRUVOX1NJWkUsIDEsCisgICAgICAgIEVHTF9CTFVFX1NJWkUsIDEs CisgICAgICAgIEVHTF9BTFBIQV9TSVpFLCAxLAorICAgICAgICBFR0xfU1RFTkNJTF9TSVpFLCAx LAogICAgICAgICBFR0xfU1VSRkFDRV9UWVBFLCBFR0xfTk9ORSwKKyAgICAgICAgRUdMX0RFUFRI X1NJWkUsIDAsCisgICAgICAgIEVHTF9TQU1QTEVTLCAwLAogICAgICAgICBFR0xfTk9ORQogICAg IH07CiAKKyAgICBFR0xpbnQgYnVmZmVyU2l6ZSA9IGJpdHNQZXJQaXhlbDsKKyAgICBpZiAoYnVm ZmVyU2l6ZSA9PSAxNikgeworICAgICAgICBhdHRyaWJ1dGVMaXN0WzldID0gMDsKKyAgICAgICAg YXR0cmlidXRlTGlzdFsxMV0gPSAwOworICAgIH0KKwogICAgIHN3aXRjaCAoc3VyZmFjZVR5cGUp IHsKICAgICBjYXNlIEdMQ29udGV4dEVHTDo6UGJ1ZmZlclN1cmZhY2U6CiAgICAgICAgIGF0dHJp YnV0ZUxpc3RbMTNdID0gRUdMX1BCVUZGRVJfQklUOwpAQCAtMTIyLDE1ICsxMzAsMzYgQEAgYm9v bCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZpZyhFR0xEaXNwbGF5IGRpc3BsYXksIEVHTENvbmZp ZyogY29uZmlnLCBFR0xTdXJmYWMKICAgICAgICAgYnJlYWs7CiAgICAgfQogCisgICAgRUdMaW50 IGNvdW50OworICAgIGlmICghZWdsR2V0Q29uZmlncyhkaXNwbGF5LCBudWxscHRyLCAwLCAmY291 bnQpIHx8ICFjb3VudCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgRUdMQ29uZmlnKiBj b25maWdzID0gcmVpbnRlcnByZXRfY2FzdDxFR0xDb25maWcqPihmYXN0Q2FsbG9jKHNpemVvZihF R0xDb25maWcpLCBjb3VudCkpOwogICAgIEVHTGludCBudW1iZXJDb25maWdzUmV0dXJuZWQ7Ci0g ICAgcmV0dXJuIGVnbENob29zZUNvbmZpZyhkaXNwbGF5LCBhdHRyaWJ1dGVMaXN0LCBjb25maWcs IDEsICZudW1iZXJDb25maWdzUmV0dXJuZWQpICYmIG51bWJlckNvbmZpZ3NSZXR1cm5lZDsKKyAg ICBpZiAoIWVnbENob29zZUNvbmZpZyhkaXNwbGF5LCBhdHRyaWJ1dGVMaXN0LCBjb25maWdzLCBj b3VudCwgJm51bWJlckNvbmZpZ3NSZXR1cm5lZCkgfHwgIW51bWJlckNvbmZpZ3NSZXR1cm5lZCkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgRUdMaW50IHNpemU7CisgICAgZm9yIChFR0xp bnQgaSA9IDA7IGkgPCBudW1iZXJDb25maWdzUmV0dXJuZWQ7IGkrKykgeworICAgICAgICBlZ2xH ZXRDb25maWdBdHRyaWIoZGlzcGxheSwgY29uZmlnc1tpXSwgRUdMX0JVRkZFUl9TSVpFLCAmc2l6 ZSk7CisgICAgICAgIGlmIChidWZmZXJTaXplID09IHNpemUpIHsKKyAgICAgICAgICAgICpjb25m aWcgPSBjb25maWdzW2ldOworICAgICAgICAgICAgZmFzdEZyZWUoY29uZmlncyk7CisgICAgICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgIH0KKyAgICBmYXN0RnJlZShjb25maWdz KTsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+ IEdMQ29udGV4dEVHTDo6Y3JlYXRlV2luZG93Q29udGV4dChHTE5hdGl2ZVdpbmRvd1R5cGUgd2lu ZG93LCBQbGF0Zm9ybURpc3BsYXkmIHBsYXRmb3JtRGlzcGxheSwgRUdMQ29udGV4dCBzaGFyaW5n Q29udGV4dCkKK3N0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3Jl YXRlV2luZG93Q29udGV4dChHTE5hdGl2ZVdpbmRvd1R5cGUgd2luZG93LCBQbGF0Zm9ybURpc3Bs YXkmIHBsYXRmb3JtRGlzcGxheSwgRUdMQ29udGV4dCBzaGFyaW5nQ29udGV4dCwgdWludDMyX3Qg Yml0c1BlclBpeGVsKQogewogICAgIEVHTERpc3BsYXkgZGlzcGxheSA9IHBsYXRmb3JtRGlzcGxh eS5lZ2xEaXNwbGF5KCk7CiAgICAgRUdMQ29uZmlnIGNvbmZpZzsKLSAgICBpZiAoIWdldEVHTENv bmZpZyhkaXNwbGF5LCAmY29uZmlnLCBXaW5kb3dTdXJmYWNlKSkgeworI2lmICFQTEFURk9STShX UEUpCisgICAgYml0c1BlclBpeGVsID0gMzI7CisjZW5kaWYKKyAgICBpZiAoIWdldEVHTENvbmZp ZyhkaXNwbGF5LCAmY29uZmlnLCBXaW5kb3dTdXJmYWNlLCBiaXRzUGVyUGl4ZWwpKSB7CiAgICAg ICAgIFdURkxvZ0Fsd2F5cygiQ2Fubm90IG9idGFpbiBFR0wgd2luZG93IGNvbnRleHQgY29uZmln dXJhdGlvbjogJXNcbiIsIGxhc3RFcnJvclN0cmluZygpKTsKICAgICAgICAgcmV0dXJuIG51bGxw dHI7CiAgICAgfQpAQCAtMTkyLDcgKzIyMSw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRF R0w+IEdMQ29udGV4dEVHTDo6Y3JlYXRlUGJ1ZmZlckNvbnRleHQoUGxhdGZvcm1EaXNwbGF5CiAg ICAgcmV0dXJuIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+KG5ldyBHTENvbnRleHRFR0wo cGxhdGZvcm1EaXNwbGF5LCBjb250ZXh0LCBzdXJmYWNlLCBQYnVmZmVyU3VyZmFjZSkpOwogfQog Ci1zdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVN1cmZh Y2VsZXNzQ29udGV4dChQbGF0Zm9ybURpc3BsYXkmIHBsYXRmb3JtRGlzcGxheSwgRUdMQ29udGV4 dCBzaGFyaW5nQ29udGV4dCkKK3N0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4 dEVHTDo6Y3JlYXRlU3VyZmFjZWxlc3NDb250ZXh0KFBsYXRmb3JtRGlzcGxheSYgcGxhdGZvcm1E aXNwbGF5LCBFR0xDb250ZXh0IHNoYXJpbmdDb250ZXh0LCB1aW50MzJfdCBiaXRzUGVyUGl4ZWwp CiB7CiAgICAgRUdMRGlzcGxheSBkaXNwbGF5ID0gcGxhdGZvcm1EaXNwbGF5LmVnbERpc3BsYXko KTsKICAgICBpZiAoZGlzcGxheSA9PSBFR0xfTk9fRElTUExBWSkgewpAQCAtMjA2LDggKzIzNSwx MSBAQCBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVN1 cmZhY2VsZXNzQ29udGV4dChQbGF0Zm9ybURpcwogICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAg ICB9CiAKKyNpZiAhUExBVEZPUk0oV1BFKQorICAgIGJpdHNQZXJQaXhlbCA9IDMyOworI2VuZGlm CiAgICAgRUdMQ29uZmlnIGNvbmZpZzsKLSAgICBpZiAoIWdldEVHTENvbmZpZyhkaXNwbGF5LCAm Y29uZmlnLCBTdXJmYWNlbGVzcykpIHsKKyAgICBpZiAoIWdldEVHTENvbmZpZyhkaXNwbGF5LCAm Y29uZmlnLCBTdXJmYWNlbGVzcywgYml0c1BlclBpeGVsKSkgewogICAgICAgICBXVEZMb2dBbHdh eXMoIkNhbm5vdCBvYnRhaW4gRUdMIHN1cmZhY2VsZXNzIGNvbmZpZ3VyYXRpb246ICVzXG4iLCBs YXN0RXJyb3JTdHJpbmcoKSk7CiAgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIH0KQEAgLTIy MSw3ICsyNTMsNyBAQCBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6 OmNyZWF0ZVN1cmZhY2VsZXNzQ29udGV4dChQbGF0Zm9ybURpcwogICAgIHJldHVybiBzdGQ6OnVu aXF1ZV9wdHI8R0xDb250ZXh0RUdMPihuZXcgR0xDb250ZXh0RUdMKHBsYXRmb3JtRGlzcGxheSwg Y29udGV4dCwgRUdMX05PX1NVUkZBQ0UsIFN1cmZhY2VsZXNzKSk7CiB9CiAKLXN0ZDo6dW5pcXVl X3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3JlYXRlQ29udGV4dChHTE5hdGl2ZVdp bmRvd1R5cGUgd2luZG93LCBQbGF0Zm9ybURpc3BsYXkmIHBsYXRmb3JtRGlzcGxheSkKK3N0ZDo6 dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3JlYXRlQ29udGV4dChHTE5h dGl2ZVdpbmRvd1R5cGUgd2luZG93LCBQbGF0Zm9ybURpc3BsYXkmIHBsYXRmb3JtRGlzcGxheSwg dWludDMyX3QgYml0c1BlclBpeGVsKQogewogICAgIGlmIChwbGF0Zm9ybURpc3BsYXkuZWdsRGlz cGxheSgpID09IEVHTF9OT19ESVNQTEFZKSB7CiAgICAgICAgIFdURkxvZ0Fsd2F5cygiQ2Fubm90 IGNyZWF0ZSBFR0wgY29udGV4dDogaW52YWxpZCBkaXNwbGF5IChsYXN0IGVycm9yOiAlcylcbiIs IGxhc3RFcnJvclN0cmluZygpKTsKQEAgLTIzNywxMCArMjY5LDEwIEBAIHN0ZDo6dW5pcXVlX3B0 cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3JlYXRlQ29udGV4dChHTE5hdGl2ZVdpbmRv d1R5cGUgd2luCiAgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIH0KIAotICAgIEVHTENvbnRl eHQgZWdsU2hhcmluZ0NvbnRleHQgPSBwbGF0Zm9ybURpc3BsYXkuc2hhcmluZ0dMQ29udGV4dCgp ID8gc3RhdGljX2Nhc3Q8R0xDb250ZXh0RUdMKj4ocGxhdGZvcm1EaXNwbGF5LnNoYXJpbmdHTENv bnRleHQoKSktPm1fY29udGV4dCA6IEVHTF9OT19DT05URVhUOwotICAgIGF1dG8gY29udGV4dCA9 IHdpbmRvdyA/IGNyZWF0ZVdpbmRvd0NvbnRleHQod2luZG93LCBwbGF0Zm9ybURpc3BsYXksIGVn bFNoYXJpbmdDb250ZXh0KSA6IG51bGxwdHI7CisgICAgRUdMQ29udGV4dCBlZ2xTaGFyaW5nQ29u dGV4dCA9IHBsYXRmb3JtRGlzcGxheS5zaGFyaW5nR0xDb250ZXh0KGJpdHNQZXJQaXhlbCkgPyBz dGF0aWNfY2FzdDxHTENvbnRleHRFR0wqPihwbGF0Zm9ybURpc3BsYXkuc2hhcmluZ0dMQ29udGV4 dCgpKS0+bV9jb250ZXh0IDogRUdMX05PX0NPTlRFWFQ7CisgICAgYXV0byBjb250ZXh0ID0gd2lu ZG93ID8gY3JlYXRlV2luZG93Q29udGV4dCh3aW5kb3csIHBsYXRmb3JtRGlzcGxheSwgZWdsU2hh cmluZ0NvbnRleHQsIGJpdHNQZXJQaXhlbCkgOiBudWxscHRyOwogICAgIGlmICghY29udGV4dCkK LSAgICAgICAgY29udGV4dCA9IGNyZWF0ZVN1cmZhY2VsZXNzQ29udGV4dChwbGF0Zm9ybURpc3Bs YXksIGVnbFNoYXJpbmdDb250ZXh0KTsKKyAgICAgICAgY29udGV4dCA9IGNyZWF0ZVN1cmZhY2Vs ZXNzQ29udGV4dChwbGF0Zm9ybURpc3BsYXksIGVnbFNoYXJpbmdDb250ZXh0LCBiaXRzUGVyUGl4 ZWwpOwogICAgIGlmICghY29udGV4dCkgewogI2lmIFBMQVRGT1JNKFgxMSkKICAgICAgICAgaWYg KHBsYXRmb3JtRGlzcGxheS50eXBlKCkgPT0gUGxhdGZvcm1EaXNwbGF5OjpUeXBlOjpYMTEpCkBA IC0yNTIsNyArMjg0LDcgQEAgc3RkOjp1bmlxdWVfcHRyPEdMQ29udGV4dEVHTD4gR0xDb250ZXh0 RUdMOjpjcmVhdGVDb250ZXh0KEdMTmF0aXZlV2luZG93VHlwZSB3aW4KICNlbmRpZgogI2lmIFBM QVRGT1JNKFdQRSkKICAgICAgICAgaWYgKHBsYXRmb3JtRGlzcGxheS50eXBlKCkgPT0gUGxhdGZv cm1EaXNwbGF5OjpUeXBlOjpXUEUpCi0gICAgICAgICAgICBjb250ZXh0ID0gY3JlYXRlV1BFQ29u dGV4dChwbGF0Zm9ybURpc3BsYXksIGVnbFNoYXJpbmdDb250ZXh0KTsKKyAgICAgICAgICAgIGNv bnRleHQgPSBjcmVhdGVXUEVDb250ZXh0KHBsYXRmb3JtRGlzcGxheSwgZWdsU2hhcmluZ0NvbnRl eHQsIGJpdHNQZXJQaXhlbCk7CiAjZW5kaWYKICAgICB9CiAgICAgaWYgKCFjb250ZXh0KQpAQCAt MjYxLDcgKzI5Myw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVH TDo6Y3JlYXRlQ29udGV4dChHTE5hdGl2ZVdpbmRvd1R5cGUgd2luCiAgICAgcmV0dXJuIGNvbnRl eHQ7CiB9CiAKLXN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3Jl YXRlU2hhcmluZ0NvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiBwbGF0Zm9ybURpc3BsYXkpCitzdGQ6 OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVNoYXJpbmdDb250 ZXh0KFBsYXRmb3JtRGlzcGxheSYgcGxhdGZvcm1EaXNwbGF5LCB1aW50MzJfdCBiaXRzUGVyUGl4 ZWwpCiB7CiAgICAgaWYgKHBsYXRmb3JtRGlzcGxheS5lZ2xEaXNwbGF5KCkgPT0gRUdMX05PX0RJ U1BMQVkpIHsKICAgICAgICAgV1RGTG9nQWx3YXlzKCJDYW5ub3QgY3JlYXRlIEVHTCBzaGFyaW5n IGNvbnRleHQ6IGludmFsaWQgZGlzcGxheSAobGFzdCBlcnJvcjogJXMpIiwgbGFzdEVycm9yU3Ry aW5nKCkpOwpAQCAtMjc3LDcgKzMwOSw3IEBAIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+ IEdMQ29udGV4dEVHTDo6Y3JlYXRlU2hhcmluZ0NvbnRleHQoUGxhdGZvcm1EaXNwbGF5CiAgICAg ICAgIHJldHVybiBudWxscHRyOwogICAgIH0KIAotICAgIGF1dG8gY29udGV4dCA9IGNyZWF0ZVN1 cmZhY2VsZXNzQ29udGV4dChwbGF0Zm9ybURpc3BsYXkpOworICAgIGF1dG8gY29udGV4dCA9IGNy ZWF0ZVN1cmZhY2VsZXNzQ29udGV4dChwbGF0Zm9ybURpc3BsYXksIG51bGxwdHIsIGJpdHNQZXJQ aXhlbCk7CiAgICAgaWYgKCFjb250ZXh0KSB7CiAjaWYgUExBVEZPUk0oWDExKQogICAgICAgICBp ZiAocGxhdGZvcm1EaXNwbGF5LnR5cGUoKSA9PSBQbGF0Zm9ybURpc3BsYXk6OlR5cGU6OlgxMSkK QEAgLTI4OSw3ICszMjEsNyBAQCBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRl eHRFR0w6OmNyZWF0ZVNoYXJpbmdDb250ZXh0KFBsYXRmb3JtRGlzcGxheQogI2VuZGlmCiAjaWYg UExBVEZPUk0oV1BFKQogICAgICAgICBpZiAocGxhdGZvcm1EaXNwbGF5LnR5cGUoKSA9PSBQbGF0 Zm9ybURpc3BsYXk6OlR5cGU6OldQRSkKLSAgICAgICAgICAgIGNvbnRleHQgPSBjcmVhdGVXUEVD b250ZXh0KHBsYXRmb3JtRGlzcGxheSk7CisgICAgICAgICAgICBjb250ZXh0ID0gY3JlYXRlV1BF Q29udGV4dChwbGF0Zm9ybURpc3BsYXksIG51bGxwdHIsIGJpdHNQZXJQaXhlbCk7CiAjZW5kaWYK ICAgICB9CiAgICAgaWYgKCFjb250ZXh0KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5oCmluZGV4IGNiZDYzNDFmZTVkNzExZDA4Yzc0 NzRjYWM0YjU2M2RkY2Q5N2NjZmYuLjdlZDRmZWE5ZDllZjcwZDFiMzE5ODQzNDE2NTNlZTkxNDg3 NTMzMzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9H TENvbnRleHRFR0wuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wv R0xDb250ZXh0RUdMLmgKQEAgLTQ2LDggKzQ2LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogY2xh c3MgR0xDb250ZXh0RUdMIGZpbmFsIDogcHVibGljIEdMQ29udGV4dCB7CiAgICAgV1RGX01BS0Vf Tk9OQ09QWUFCTEUoR0xDb250ZXh0RUdMKTsKIHB1YmxpYzoKLSAgICBzdGF0aWMgc3RkOjp1bmlx dWVfcHRyPEdMQ29udGV4dEVHTD4gY3JlYXRlQ29udGV4dChHTE5hdGl2ZVdpbmRvd1R5cGUsIFBs YXRmb3JtRGlzcGxheSYpOwotICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdM PiBjcmVhdGVTaGFyaW5nQ29udGV4dChQbGF0Zm9ybURpc3BsYXkmKTsKKyAgICBzdGF0aWMgc3Rk Ojp1bmlxdWVfcHRyPEdMQ29udGV4dEVHTD4gY3JlYXRlQ29udGV4dChHTE5hdGl2ZVdpbmRvd1R5 cGUsIFBsYXRmb3JtRGlzcGxheSYsIHVpbnQzMl90IGJpdHNQZXJQaXhlbCA9IDMyKTsKKyAgICBz dGF0aWMgc3RkOjp1bmlxdWVfcHRyPEdMQ29udGV4dEVHTD4gY3JlYXRlU2hhcmluZ0NvbnRleHQo UGxhdGZvcm1EaXNwbGF5JiwgdWludDMyX3QgYml0c1BlclBpeGVsID0gMzIpOwogCiAgICAgc3Rh dGljIGNvbnN0IGNoYXIqIGVycm9yU3RyaW5nKGludCBzdGF0dXNDb2RlKTsKICAgICBzdGF0aWMg Y29uc3QgY2hhciogbGFzdEVycm9yU3RyaW5nKCk7CkBAIC04Nyw5ICs4Nyw5IEBAIHByaXZhdGU6 CiAgICAgdm9pZCBkZXN0cm95V1BFVGFyZ2V0KCk7CiAjZW5kaWYKIAotICAgIHN0YXRpYyBzdGQ6 OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBjcmVhdGVXaW5kb3dDb250ZXh0KEdMTmF0aXZlV2lu ZG93VHlwZSwgUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29udGV4dCBzaGFyaW5nQ29udGV4dCA9IG51 bGxwdHIpOworICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBjcmVhdGVX aW5kb3dDb250ZXh0KEdMTmF0aXZlV2luZG93VHlwZSwgUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29u dGV4dCBzaGFyaW5nQ29udGV4dCA9IG51bGxwdHIsIHVpbnQzMl90IGJpdHNQZXJQaXhlbCA9IDMy KTsKICAgICBzdGF0aWMgc3RkOjp1bmlxdWVfcHRyPEdMQ29udGV4dEVHTD4gY3JlYXRlUGJ1ZmZl ckNvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29udGV4dCBzaGFyaW5nQ29udGV4dCA9IG51 bGxwdHIpOwotICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBjcmVhdGVT dXJmYWNlbGVzc0NvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29udGV4dCBzaGFyaW5nQ29u dGV4dCA9IG51bGxwdHIpOworICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdM PiBjcmVhdGVTdXJmYWNlbGVzc0NvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29udGV4dCBz aGFyaW5nQ29udGV4dCA9IG51bGxwdHIsIHVpbnQzMl90IGJpdHNQZXJQaXhlbCA9IDQyKTsKICNp ZiBQTEFURk9STShYMTEpCiAgICAgc3RhdGljIHN0ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+ IGNyZWF0ZVBpeG1hcENvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29udGV4dCBzaGFyaW5n Q29udGV4dCA9IG51bGxwdHIpOwogICAgIHN0YXRpYyBFR0xTdXJmYWNlIGNyZWF0ZVdpbmRvd1N1 cmZhY2VYMTEoRUdMRGlzcGxheSwgRUdMQ29uZmlnLCBHTE5hdGl2ZVdpbmRvd1R5cGUpOwpAQCAt OTksMTEgKzk5LDExIEBAIHByaXZhdGU6CiAgICAgc3RhdGljIEVHTFN1cmZhY2UgY3JlYXRlV2lu ZG93U3VyZmFjZVdheWxhbmQoRUdMRGlzcGxheSwgRUdMQ29uZmlnLCBHTE5hdGl2ZVdpbmRvd1R5 cGUpOwogI2VuZGlmCiAjaWYgVVNFKExJQldQRSkKLSAgICBzdGF0aWMgc3RkOjp1bmlxdWVfcHRy PEdMQ29udGV4dEVHTD4gY3JlYXRlV1BFQ29udGV4dChQbGF0Zm9ybURpc3BsYXkmLCBFR0xDb250 ZXh0IHNoYXJpbmdDb250ZXh0ID0gbnVsbHB0cik7CisgICAgc3RhdGljIHN0ZDo6dW5pcXVlX3B0 cjxHTENvbnRleHRFR0w+IGNyZWF0ZVdQRUNvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiwgRUdMQ29u dGV4dCBzaGFyaW5nQ29udGV4dCA9IG51bGxwdHIsIHVpbnQzMl90IGJpdHNQZXJQaXhlbCA9IDMy KTsKICAgICBzdGF0aWMgRUdMU3VyZmFjZSBjcmVhdGVXaW5kb3dTdXJmYWNlV1BFKEVHTERpc3Bs YXksIEVHTENvbmZpZywgR0xOYXRpdmVXaW5kb3dUeXBlKTsKICNlbmRpZgogCi0gICAgc3RhdGlj IGJvb2wgZ2V0RUdMQ29uZmlnKEVHTERpc3BsYXksIEVHTENvbmZpZyosIEVHTFN1cmZhY2VUeXBl KTsKKyAgICBzdGF0aWMgYm9vbCBnZXRFR0xDb25maWcoRUdMRGlzcGxheSwgRUdMQ29uZmlnKiwg RUdMU3VyZmFjZVR5cGUsIHVpbnQzMl90IGJpdHNQZXJQaXhlbCA9IDMyKTsKIAogICAgIEVHTENv bnRleHQgbV9jb250ZXh0IHsgbnVsbHB0ciB9OwogICAgIEVHTFN1cmZhY2UgbV9zdXJmYWNlIHsg bnVsbHB0ciB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv ZWdsL0dMQ29udGV4dEVHTExpYldQRS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9lZ2wvR0xDb250ZXh0RUdMTGliV1BFLmNwcAppbmRleCBkOTg4MDlmZTdhZDU1OWY5MTQ3 NTk2N2I5Y2I0MDE1ZjM3MzY2NmQyLi5kYjhlM2I1OTJjZTc2YzNmMDljZTVhMTBlNTA5YTRmOGEz NTRiZDZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wv R0xDb250ZXh0RUdMTGliV1BFLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9lZ2wvR0xDb250ZXh0RUdMTGliV1BFLmNwcApAQCAtNTAsMTEgKzUwLDExIEBAIEVHTFN1 cmZhY2UgR0xDb250ZXh0RUdMOjpjcmVhdGVXaW5kb3dTdXJmYWNlV1BFKEVHTERpc3BsYXkgZGlz cGxheSwgRUdMQ29uZmlnIGNvCiAgICAgcmV0dXJuIGVnbENyZWF0ZVdpbmRvd1N1cmZhY2UoZGlz cGxheSwgY29uZmlnLCByZWludGVycHJldF9jYXN0PEVHTE5hdGl2ZVdpbmRvd1R5cGU+KHdpbmRv dyksIG51bGxwdHIpOwogfQogCi1zdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRl eHRFR0w6OmNyZWF0ZVdQRUNvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiBwbGF0Zm9ybURpc3BsYXks IEVHTENvbnRleHQgc2hhcmluZ0NvbnRleHQpCitzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdM PiBHTENvbnRleHRFR0w6OmNyZWF0ZVdQRUNvbnRleHQoUGxhdGZvcm1EaXNwbGF5JiBwbGF0Zm9y bURpc3BsYXksIEVHTENvbnRleHQgc2hhcmluZ0NvbnRleHQsIHVpbnQzMl90IGJpdHNQZXJQaXhl bCkKIHsKICAgICBFR0xEaXNwbGF5IGRpc3BsYXkgPSBwbGF0Zm9ybURpc3BsYXkuZWdsRGlzcGxh eSgpOwogICAgIEVHTENvbmZpZyBjb25maWc7Ci0gICAgaWYgKCFnZXRFR0xDb25maWcoZGlzcGxh eSwgJmNvbmZpZywgV2luZG93U3VyZmFjZSkpIHsKKyAgICBpZiAoIWdldEVHTENvbmZpZyhkaXNw bGF5LCAmY29uZmlnLCBXaW5kb3dTdXJmYWNlLCBiaXRzUGVyUGl4ZWwpKSB7CiAgICAgICAgIFdU RkxvZ0Fsd2F5cygiQ2Fubm90IG9idGFpbiBFR0wgV1BFIGNvbnRleHQgY29uZmlndXJhdGlvbjog JXNcbiIsIGxhc3RFcnJvclN0cmluZygpKTsKICAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAgICAg fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvQ29vcmRpbmF0ZWRHcmFwaGljcy90 aHJlYWRlZGNvbXBvc2l0b3IvVGhyZWFkZWRDb21wb3NpdG9yLmNwcCBiL1NvdXJjZS9XZWJLaXQv U2hhcmVkL0Nvb3JkaW5hdGVkR3JhcGhpY3MvdGhyZWFkZWRjb21wb3NpdG9yL1RocmVhZGVkQ29t cG9zaXRvci5jcHAKaW5kZXggNzUyMmY4NGVhOGY4YTY4MjNiYjkyMWZmYzNmMDVjZmJkODdlYjU4 MS4uYmVjMmY5OGVkYTEyYTlmOGIyYzgzYTcwMjlmZWE3ZjAzYzcwMDZmNCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9TaGFyZWQvQ29vcmRpbmF0ZWRHcmFwaGljcy90aHJlYWRlZGNvbXBvc2l0 b3IvVGhyZWFkZWRDb21wb3NpdG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9Db29y ZGluYXRlZEdyYXBoaWNzL3RocmVhZGVkY29tcG9zaXRvci9UaHJlYWRlZENvbXBvc2l0b3IuY3Bw CkBAIC04Nyw3ICs4Nyw4IEBAIHZvaWQgVGhyZWFkZWRDb21wb3NpdG9yOjpjcmVhdGVHTENvbnRl eHQoKQogCiAgICAgQVNTRVJUKG1fbmF0aXZlU3VyZmFjZUhhbmRsZSk7CiAKLSAgICBtX2NvbnRl eHQgPSBHTENvbnRleHQ6OmNyZWF0ZUNvbnRleHRGb3JXaW5kb3cocmVpbnRlcnByZXRfY2FzdDxH TE5hdGl2ZVdpbmRvd1R5cGU+KG1fbmF0aXZlU3VyZmFjZUhhbmRsZSksICZQbGF0Zm9ybURpc3Bs YXk6OnNoYXJlZERpc3BsYXlGb3JDb21wb3NpdGluZygpKTsKKyAgICB1aW50MzJfdCBlZ2xDb25m aWdCaXRzUGVyUGl4ZWwgPSBtX2NsaWVudC5lZ2xDb25maWdCaXRzUGVyUGl4ZWwoKTsKKyAgICBt X2NvbnRleHQgPSBHTENvbnRleHQ6OmNyZWF0ZUNvbnRleHRGb3JXaW5kb3cocmVpbnRlcnByZXRf Y2FzdDxHTE5hdGl2ZVdpbmRvd1R5cGU+KG1fbmF0aXZlU3VyZmFjZUhhbmRsZSksICZQbGF0Zm9y bURpc3BsYXk6OnNoYXJlZERpc3BsYXlGb3JDb21wb3NpdGluZygpLCBlZ2xDb25maWdCaXRzUGVy UGl4ZWwpOwogICAgIGlmICghbV9jb250ZXh0KQogICAgICAgICByZXR1cm47CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0Nvb3JkaW5hdGVkR3JhcGhpY3MvdGhyZWFkZWRjb21w b3NpdG9yL1RocmVhZGVkQ29tcG9zaXRvci5oIGIvU291cmNlL1dlYktpdC9TaGFyZWQvQ29vcmRp bmF0ZWRHcmFwaGljcy90aHJlYWRlZGNvbXBvc2l0b3IvVGhyZWFkZWRDb21wb3NpdG9yLmgKaW5k ZXggNmQ3MDUzODUwZGFkNTdhMTY0ZjE5ZTkxODZmNGZhMmE2YTg2NmFmZi4uZTU1NDVjNDI0NGUw ZmM5MTAyMTcyZTQ5M2Y0YjE2YTlmNDM2ODYwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9T aGFyZWQvQ29vcmRpbmF0ZWRHcmFwaGljcy90aHJlYWRlZGNvbXBvc2l0b3IvVGhyZWFkZWRDb21w b3NpdG9yLmgKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvQ29vcmRpbmF0ZWRHcmFwaGljcy90 aHJlYWRlZGNvbXBvc2l0b3IvVGhyZWFkZWRDb21wb3NpdG9yLmgKQEAgLTU2LDYgKzU2LDggQEAg cHVibGljOgogICAgICAgICB2aXJ0dWFsIHVpbnQ2NF90IG5hdGl2ZVN1cmZhY2VIYW5kbGVGb3JD b21wb3NpdGluZygpID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZERlc3Ryb3lHTENvbnRl eHQoKSA9IDA7CiAKKyAgICAgICAgdmlydHVhbCB1aW50MzJfdCBlZ2xDb25maWdCaXRzUGVyUGl4 ZWwoKSA9IDA7CisKICAgICAgICAgdmlydHVhbCB2b2lkIHJlc2l6ZShjb25zdCBXZWJDb3JlOjpJ bnRTaXplJikgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbFJlbmRlckZyYW1lKCkgPSAw OwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVuZGVyRnJhbWUoKSA9IDA7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcmVmZXJlbmNlcy55YW1sIGIvU291cmNlL1dlYktp dC9TaGFyZWQvV2ViUHJlZmVyZW5jZXMueWFtbAppbmRleCA3NGExMjJjNWI3N2ZjNWQ0MWEyODg5 MWNhMGE1M2RmNWRlYzlmYWZlLi4wMDAxNDQxYjkxNDg2NDhlOGQ3ZmZmYTQ3NTc1YWMwYzcwOWJj YjljIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcmVmZXJlbmNlcy55YW1s CisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByZWZlcmVuY2VzLnlhbWwKQEAgLTE1NTks NiArMTU1OSwxMyBAQCBNb3VzZW1vdmVFdmVudEhhbmRsaW5nUHJldmVudHNEZWZhdWx0RW5hYmxl ZDoKICAgY2F0ZWdvcnk6IGludGVybmFsCiAgIGNvbmRpdGlvbjogRU5BQkxFKFRPVUNIX0VWRU5U UykKIAorRWdsQ29uZmlnQml0c1BlclBpeGVsOgorICB0eXBlOiB1aW50MzJfdAorICBkZWZhdWx0 VmFsdWU6IDMyCisgIGNvbmRpdGlvbjogUExBVEZPUk0oV1BFKQorCisjIHdlYmNvcmVOYW1lOiBl Z2xDb25maWdCaXRzUGVyUGl4ZWwKKwogIyBEZXByZWNhdGVkCiAKIElDRUNhbmRpZGF0ZUZpbHRl cmluZ0VuYWJsZWQ6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQy9X S1ByZWZlcmVuY2VzLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUHJlZmVy ZW5jZXMuY3BwCmluZGV4IDMwNTEzMzBjMGM2NzMyMzk1YTNlYmU1ZGI4MjAyNzlmYzE1OGYzODEu LmEyNTcxN2VkODE2NzdhMjQyMDJjMzg4YTAzNWRkNTQzNTgyNWZmMDEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUHJlZmVyZW5jZXMuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUHJlZmVyZW5jZXMuY3BwCkBAIC0yMTA5LDMgKzIx MDksMTUgQEAgYm9vbCBXS1ByZWZlcmVuY2VzR2V0Q2FwdHVyZVZpZGVvSW5VSVByb2Nlc3NFbmFi bGVkKFdLUHJlZmVyZW5jZXNSZWYgcHJlZmVyZW5jZXMKIHsKICAgICByZXR1cm4gdG9JbXBsKHBy ZWZlcmVuY2VzUmVmKS0+Y2FwdHVyZVZpZGVvSW5VSVByb2Nlc3NFbmFibGVkKCk7CiB9CisKKyNp ZiBQTEFURk9STShXUEUpCit2b2lkIFdLUHJlZmVyZW5jZXNTZXRFR0xDb25maWdCaXRzUGVyUGl4 ZWwoV0tQcmVmZXJlbmNlc1JlZiBwcmVmZXJlbmNlc1JlZiwgaW50IGJpdHNQZXJQaXhlbCkKK3sK KyAgICB0b0ltcGwocHJlZmVyZW5jZXNSZWYpLT5zZXRFZ2xDb25maWdCaXRzUGVyUGl4ZWwoYml0 c1BlclBpeGVsKTsKK30KKworYm9vbCBXS1ByZWZlcmVuY2VzR2V0RUdMQ29uZmlnQml0c1BlclBp eGVsKFdLUHJlZmVyZW5jZXNSZWYgcHJlZmVyZW5jZXNSZWYpCit7CisgICAgcmV0dXJuIHRvSW1w bChwcmVmZXJlbmNlc1JlZiktPmVnbENvbmZpZ0JpdHNQZXJQaXhlbCgpOworfQorI2VuZGlmCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRTZXR0aW5n cy5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRTZXR0aW5ncy5j cHAKaW5kZXggMDM2NTRkZDA0ODFlYjdmMzU3ZWNhNTM3ZjY5ODEzZWIyODAzMzQ5Yi4uNmFjYWI0 Yzk5YzYwNzAyMGI2NGM0N2E3M2VhYmM3ZjJmODI5MmFhOSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvV2ViS2l0U2V0dGluZ3MuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFNldHRpbmdzLmNwcApAQCAtMTY3LDYgKzE2 Nyw5IEBAIGVudW0gewogICAgIFBST1BfRU5BQkxFX0JBQ0tfRk9SV0FSRF9OQVZJR0FUSU9OX0dF U1RVUkVTLAogI2VuZGlmCiAgICAgUFJPUF9FTkFCTEVfSkFWQVNDUklQVF9NQVJLVVAsCisjaWYg UExBVEZPUk0oV1BFKQorICAgIFBST1BfRUdMX0NPTkZJR19CSVRTX1BFUl9QSVhFTCwKKyNlbmRp ZgogfTsKIAogc3RhdGljIHZvaWQgd2ViS2l0U2V0dGluZ3NEaXNwb3NlKEdPYmplY3QqIG9iamVj dCkKQEAgLTM5Myw2ICszOTYsMTEgQEAgc3RhdGljIHZvaWQgd2ViS2l0U2V0dGluZ3NTZXRQcm9w ZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BJZCwgY29uc3QgR1ZhbHUKICAgICBjYXNl IFBST1BfRU5BQkxFX0pBVkFTQ1JJUFRfTUFSS1VQOgogICAgICAgICB3ZWJraXRfc2V0dGluZ3Nf c2V0X2VuYWJsZV9qYXZhc2NyaXB0X21hcmt1cChzZXR0aW5ncywgZ192YWx1ZV9nZXRfYm9vbGVh bih2YWx1ZSkpOwogICAgICAgICBicmVhazsKKyNpZiBQTEFURk9STShXUEUpCisgICAgY2FzZSBQ Uk9QX0VHTF9DT05GSUdfQklUU19QRVJfUElYRUw6CisgICAgICAgIHdlYmtpdF9zZXR0aW5nc19z ZXRfZWdsX2NvbmZpZ19iaXRzX3Blcl9waXhlbChzZXR0aW5ncywgZ192YWx1ZV9nZXRfaW50KHZh bHVlKSk7CisgICAgICAgIGJyZWFrOworI2VuZGlmCiAgICAgZGVmYXVsdDoKICAgICAgICAgR19P QkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcElkLCBwYXJhbVNwZWMp OwogICAgICAgICBicmVhazsKQEAgLTU3OCw2ICs1ODYsMTEgQEAgc3RhdGljIHZvaWQgd2ViS2l0 U2V0dGluZ3NHZXRQcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BJZCwgR1ZhbHVl KiB2YWwKICAgICBjYXNlIFBST1BfRU5BQkxFX0pBVkFTQ1JJUFRfTUFSS1VQOgogICAgICAgICBn X3ZhbHVlX3NldF9ib29sZWFuKHZhbHVlLCB3ZWJraXRfc2V0dGluZ3NfZ2V0X2VuYWJsZV9qYXZh c2NyaXB0X21hcmt1cChzZXR0aW5ncykpOwogICAgICAgICBicmVhazsKKyNpZiBQTEFURk9STShX UEUpCisgICAgY2FzZSBQUk9QX0VHTF9DT05GSUdfQklUU19QRVJfUElYRUw6CisgICAgICAgIGdf dmFsdWVfc2V0X2ludCh2YWx1ZSwgd2Via2l0X3NldHRpbmdzX2dldF9lZ2xfY29uZmlnX2JpdHNf cGVyX3BpeGVsKHNldHRpbmdzKSk7CisgICAgICAgIGJyZWFrOworI2VuZGlmCiAgICAgZGVmYXVs dDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJv cElkLCBwYXJhbVNwZWMpOwogICAgICAgICBicmVhazsKQEAgLTE0OTMsNiArMTUwNiwyMiBAQCBz dGF0aWMgdm9pZCB3ZWJraXRfc2V0dGluZ3NfY2xhc3NfaW5pdChXZWJLaXRTZXR0aW5nc0NsYXNz KiBrbGFzcykKICAgICAgICAgICAgIF8oIkVuYWJsZSBKYXZhU2NyaXB0IGluIGRvY3VtZW50IG1h cmt1cC4iKSwKICAgICAgICAgICAgIFRSVUUsCiAgICAgICAgICAgICByZWFkV3JpdGVDb25zdHJ1 Y3RQYXJhbUZsYWdzKSk7CisKKyNpZiBQTEFURk9STShXUEUpCisgICAgLyoqCisgICAgICogV2Vi S2l0U2V0dGluZ3M6ZWdsLWNvbmZpZy1iaXRzLXBlci1waXhlbDoKKyAgICAgKgorICAgICAqIENv bmZpZ3VyZSB0aGUgRUdMIGNvbmZpZ3VyYXRpb24gcGl4ZWwgcmVzb2x1dGlvbi4gVGhlIGRlZmF1 bHQgaXMgMzIgYml0cyBwZXIgcGl4ZWwuCisgICAgICoKKyAgICAgKiBTaW5jZTogMi4yNgorICAg ICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVydHkoZ09iamVjdENsYXNzLAor ICAgICAgICBQUk9QX0VHTF9DT05GSUdfQklUU19QRVJfUElYRUwsCisgICAgICAgIGdfcGFyYW1f c3BlY19pbnQoImVnbC1jb25maWctYml0cy1wZXItcGl4ZWwiLAorICAgICAgICAgICAgXygiRUdM IGNvbmZpZ3VyYXRpb24gYml0cyBwZXIgcGl4ZWwiKSwKKyAgICAgICAgICAgIF8oIkVHTCBjb25m aWd1cmF0aW9uIGJpdHMgcGVyIHBpeGVsIiksCisgICAgICAgICAgICAxNiwgMzIsIDMyLCByZWFk V3JpdGVDb25zdHJ1Y3RQYXJhbUZsYWdzKSk7CisjZW5kaWYgLy8gUExBVEZPUk0oV1BFKQogfQog CiBXZWJQcmVmZXJlbmNlcyogd2Via2l0U2V0dGluZ3NHZXRQcmVmZXJlbmNlcyhXZWJLaXRTZXR0 aW5ncyogc2V0dGluZ3MpCkBAIC0zNjc0LDMgKzM3MDMsNDQgQEAgdm9pZCB3ZWJraXRfc2V0dGlu Z3Nfc2V0X2VuYWJsZV9qYXZhc2NyaXB0X21hcmt1cChXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3Ms IGdib28KICAgICBwcml2LT5wcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdE1hcmt1cEVuYWJsZWQo ZW5hYmxlZCk7CiAgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHNldHRpbmdzKSwgImVuYWJs ZS1qYXZhc2NyaXB0LW1hcmt1cCIpOwogfQorCisjaWYgUExBVEZPUk0oV1BFKQorLyoqCisgKiB3 ZWJraXRfc2V0dGluZ3NfZ2V0X2VnbF9jb25maWdfYml0c19wZXJfcGl4ZWw6CisgKiBAc2V0dGlu Z3M6IGEgI1dlYktpdFNldHRpbmdzCisgKgorICogR2V0IHRoZSAjV2ViS2l0U2V0dGluZ3M6ZWds LWNvbmZpZy1iaXRzLXBlci1waXhlbCBwcm9wZXJ0eS4KKyAqCisgKiBSZXR1cm5zOiBBICVnaW50 CisgKgorICogU2luY2U6IDIuMjYKKyAqLworZ2ludCB3ZWJraXRfc2V0dGluZ3NfZ2V0X2VnbF9j b25maWdfYml0c19wZXJfcGl4ZWwoV2ViS2l0U2V0dGluZ3MqIHNldHRpbmdzKQoreworICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19TRVRUSU5HUyhzZXR0aW5ncyksIDMyKTsKKwor ICAgIHJldHVybiBzZXR0aW5ncy0+cHJpdi0+cHJlZmVyZW5jZXMtPmVnbENvbmZpZ0JpdHNQZXJQ aXhlbCgpOworfQorCisvKioKKyAqIHdlYmtpdF9zZXR0aW5nc19zZXRfZWdsX2NvbmZpZ19iaXRz X3Blcl9waXhlbDoKKyAqIEBzZXR0aW5nczogYSAjV2ViS2l0U2V0dGluZ3MKKyAqIEBiaXRzX3Bl cl9waXhlbDogVmFsdWUgdG8gYmUgc2V0CisgKgorICogU2V0IHRoZSAjV2ViS2l0U2V0dGluZ3M6 ZWdsLWNvbmZpZy1iaXRzLXBlci1waXhlbCBwcm9wZXJ0eS4KKyAqCisgKiBTaW5jZTogMi4yNgor ICovCit2b2lkIHdlYmtpdF9zZXR0aW5nc19zZXRfZWdsX2NvbmZpZ19iaXRzX3Blcl9waXhlbChX ZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MsIGdpbnQgYml0c1BlclBpeGVsKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1NFVFRJTkdTKHNldHRpbmdzKSk7CisKKyAgICBXZWJLaXRT ZXR0aW5nc1ByaXZhdGUqIHByaXYgPSBzZXR0aW5ncy0+cHJpdjsKKyAgICBnaW50IGN1cnJlbnRW YWx1ZSA9IHByaXYtPnByZWZlcmVuY2VzLT5lZ2xDb25maWdCaXRzUGVyUGl4ZWwoKTsKKyAgICBp ZiAoY3VycmVudFZhbHVlID09IGJpdHNQZXJQaXhlbCkKKyAgICAgICAgcmV0dXJuOworCisgICAg cHJpdi0+cHJlZmVyZW5jZXMtPnNldEVnbENvbmZpZ0JpdHNQZXJQaXhlbChiaXRzUGVyUGl4ZWwp OworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChzZXR0aW5ncyksICJlZ2wtY29uZmlnLWJp dHMtcGVyLXBpeGVsIik7Cit9CisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvV2ViS2l0U2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS93cGUvV2ViS2l0U2V0dGluZ3MuaAppbmRleCBhNzkyMWFiZmVkMTg3ZmEzYmNiMWM2MDkx OGRjYzRiNjY4NDdhYTdjLi4yN2E2M2M3MWRmYTJmNDQ0NjYxMDQyNjBkNWNmN2U0MzYxYmQzNGRj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1dlYktpdFNldHRp bmdzLmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XZWJLaXRTZXR0aW5n cy5oCkBAIC00NDksNiArNDQ5LDEzIEBAIFdFQktJVF9BUEkgdm9pZAogd2Via2l0X3NldHRpbmdz X3NldF9lbmFibGVfamF2YXNjcmlwdF9tYXJrdXAgICAgICAgICAgICAgICAgICAgKFdlYktpdFNl dHRpbmdzICpzZXR0aW5ncywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICAgICAgZW5hYmxlZCk7CiAKK1dF QktJVF9BUEkgZ2ludAord2Via2l0X3NldHRpbmdzX2dldF9lZ2xfY29uZmlnX2JpdHNfcGVyX3Bp eGVsICAgICAgICAgICAgICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5ncyk7CisKK1dFQktJ VF9BUEkgdm9pZAord2Via2l0X3NldHRpbmdzX3NldF9lZ2xfY29uZmlnX2JpdHNfcGVyX3BpeGVs ICAgICAgICAgICAgICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5ncywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnaW50 ICAgICAgICAgICAgYml0c19wZXJfcGl4ZWwpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYgLyog V2ViS2l0U2V0dGluZ3NfaCAqLwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv QVBJL3dwZS9kb2NzL3dwZS0wLjEtc2VjdGlvbnMudHh0IGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL3dwZS9kb2NzL3dwZS0wLjEtc2VjdGlvbnMudHh0CmluZGV4IGE1ZWNmZTQ2MzdmOGYz OTE3YWYyNjEyN2ZhY2UwMTUxN2YzNzg4MDYuLjZlMGU1YjlmMjBjYmRhYjk0NmE4NGQ3NDljMzRj NTJiMzk3MDllMjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUv ZG9jcy93cGUtMC4xLXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvd3BlL2RvY3Mvd3BlLTAuMS1zZWN0aW9ucy50eHQKQEAgLTQ2OSw2ICs0NjksOCBAQCB3ZWJr aXRfc2V0dGluZ3NfZ2V0X2FsbG93X2ZpbGVfYWNjZXNzX2Zyb21fZmlsZV91cmxzCiB3ZWJraXRf c2V0dGluZ3Nfc2V0X2FsbG93X2ZpbGVfYWNjZXNzX2Zyb21fZmlsZV91cmxzCiB3ZWJraXRfc2V0 dGluZ3NfZ2V0X2FsbG93X3VuaXZlcnNhbF9hY2Nlc3NfZnJvbV9maWxlX3VybHMKIHdlYmtpdF9z ZXR0aW5nc19zZXRfYWxsb3dfdW5pdmVyc2FsX2FjY2Vzc19mcm9tX2ZpbGVfdXJscword2Via2l0 X3NldHRpbmdzX2dldF9lZ2xfY29uZmlnX2JpdHNfcGVyX3BpeGVsCit3ZWJraXRfc2V0dGluZ3Nf c2V0X2VnbF9jb25maWdfYml0c19wZXJfcGl4ZWwKIAogPFNVQlNFQ1RJT04gU3RhbmRhcmQ+CiBX ZWJLaXRTZXR0aW5nc0NsYXNzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9Db29yZGluYXRlZEdyYXBoaWNzL1RocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVI b3N0LmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL0Nvb3JkaW5hdGVkR3Jh cGhpY3MvVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhvc3QuY3BwCmluZGV4IDgyM2I3ZmEy YWM3NTk3YTNhZWFiMjc0NDMxYmMwY2M5YjkyOTA4YzkuLjEzZWNhZTJhMTRjNDU5NTNlYTkzNmVl NjY0ZWQ0Y2QyY2Q2ZmE3NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9X ZWJQYWdlL0Nvb3JkaW5hdGVkR3JhcGhpY3MvVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhv c3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL0Nvb3JkaW5hdGVk R3JhcGhpY3MvVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhvc3QuY3BwCkBAIC0xMzYsNiAr MTM2LDE1IEBAIHZvaWQgVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhvc3Q6OmRpZERlc3Ry b3lHTENvbnRleHQoKQogICAgICAgICBtX3N1cmZhY2UtPmZpbmFsaXplKCk7CiB9CiAKK3VpbnQz Ml90IFRocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0OjplZ2xDb25maWdCaXRzUGVyUGl4 ZWwoKQoreworI2lmIFBMQVRGT1JNKFdQRSkKKyAgICByZXR1cm4gbV93ZWJQYWdlLmVnbENvbmZp Z0JpdHNQZXJQaXhlbCgpOworI2Vsc2UKKyAgICByZXR1cm4gMzI7CisjZW5kaWYKK30KKwogdm9p ZCBUaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdDo6d2lsbFJlbmRlckZyYW1lKCkKIHsK ICAgICBpZiAobV9zdXJmYWNlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNz L1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFwaGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVl SG9zdC5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFw aGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdC5oCmluZGV4IGI3ODQ2ODE2Nzli MjI3YmI4MTIyNzc0NWUxYjc2OGUxYTNiMDYzY2QuLjRmZGMyODUwZmQxMmYwYzAwYWU4MTZhMDY0 MTY2ZmE5M2YzMmMwMGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQ YWdlL0Nvb3JkaW5hdGVkR3JhcGhpY3MvVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhvc3Qu aAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9Db29yZGluYXRlZEdyYXBo aWNzL1RocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0LmgKQEAgLTkxLDYgKzkxLDExIEBA IHByaXZhdGU6CiAgICAgICAgICAgICBtX2xheWVyVHJlZUhvc3QuZGlkRGVzdHJveUdMQ29udGV4 dCgpOwogICAgICAgICB9CiAKKyAgICAgICAgdWludDMyX3QgZWdsQ29uZmlnQml0c1BlclBpeGVs KCkgb3ZlcnJpZGUKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1fbGF5ZXJUcmVlSG9z dC5lZ2xDb25maWdCaXRzUGVyUGl4ZWwoKTsKKyAgICAgICAgfQorCiAgICAgICAgIHZvaWQgcmVz aXplKGNvbnN0IFdlYkNvcmU6OkludFNpemUmIHNpemUpCiAgICAgICAgIHsKICAgICAgICAgICAg IGlmIChtX2xheWVyVHJlZUhvc3QubV9zdXJmYWNlKQpAQCAtMTM1LDYgKzE0MCw3IEBAIHByaXZh dGU6CiAKICAgICB1aW50NjRfdCBuYXRpdmVTdXJmYWNlSGFuZGxlRm9yQ29tcG9zaXRpbmcoKTsK ICAgICB2b2lkIGRpZERlc3Ryb3lHTENvbnRleHQoKTsKKyAgICB1aW50MzJfdCBlZ2xDb25maWdC aXRzUGVyUGl4ZWwoKTsKICAgICB2b2lkIHdpbGxSZW5kZXJGcmFtZSgpOwogICAgIHZvaWQgZGlk UmVuZGVyRnJhbWUoKTsKICAgICB2b2lkIHJlcXVlc3REaXNwbGF5UmVmcmVzaE1vbml0b3JVcGRh dGUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBh Z2UuY3BwIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAKaW5k ZXggMDg1ZDgyYThlNjRkOTdhYjYyMTk5NDgwMDBhYjlmYzdhOWI3OGZiMC4uZTNmMzgzMTQyMTcw NGI5MWY4NTZiZDdkMjI2MjcwYTg3ODdhZTMxZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9X ZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHAKQEAgLTM0NzIsNiArMzQ3MiwxMCBAQCB2b2lkIFdlYlBh Z2U6OnVwZGF0ZVByZWZlcmVuY2VzKGNvbnN0IFdlYlByZWZlcmVuY2VzU3RvcmUmIHN0b3JlKQog CiAgICAgc2V0dGluZ3Muc2V0TGF5b3V0Vmlld3BvcnRIZWlnaHRFeHBhbnNpb25GYWN0b3Ioc3Rv cmUuZ2V0RG91YmxlVmFsdWVGb3JLZXkoV2ViUHJlZmVyZW5jZXNLZXk6OmxheW91dFZpZXdwb3J0 SGVpZ2h0RXhwYW5zaW9uRmFjdG9yS2V5KCkpKTsKIAorI2lmIFBMQVRGT1JNKFdQRSkKKyAgICBt X2VnbENvbmZpZ0JpdHNQZXJQaXhlbCA9IHN0b3JlLmdldFVJbnQzMlZhbHVlRm9yS2V5KFdlYlBy ZWZlcmVuY2VzS2V5OjplZ2xDb25maWdCaXRzUGVyUGl4ZWxLZXkoKSk7CisjZW5kaWYKKwogICAg IGlmIChtX2RyYXdpbmdBcmVhKQogICAgICAgICBtX2RyYXdpbmdBcmVhLT51cGRhdGVQcmVmZXJl bmNlcyhzdG9yZSk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlLmggYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdl LmgKaW5kZXggMWRkMmJmN2Q0YjVhZGY0N2VmYzlhMTZkNjBkNzJiYWYyY2M0OTc3OC4uMDFjZmE0 YTQ4MmZmNGIxN2MzNmYwOGQ4MjJhZWQxNGM0YzliNjYwMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaApAQCAtMTEyNiw2ICsxMTI2LDcgQEAgcHVibGljOgog CiAjaWYgUExBVEZPUk0oV1BFKQogICAgIGludCByZWxlYXNlSG9zdEZpbGVEZXNjcmlwdG9yKCkg eyByZXR1cm4gbV9ob3N0RmlsZURlc2NyaXB0b3IucmVsZWFzZUZpbGVEZXNjcmlwdG9yKCk7IH0K KyAgICB1aW50MzJfdCBlZ2xDb25maWdCaXRzUGVyUGl4ZWwoKSBjb25zdCB7IHJldHVybiBtX2Vn bENvbmZpZ0JpdHNQZXJQaXhlbDsgfQogI2VuZGlmCiAKICAgICB2b2lkIHVwZGF0ZUN1cnJlbnRN b2RpZmllclN0YXRlKE9wdGlvblNldDxXZWJDb3JlOjpQbGF0Zm9ybUV2ZW50OjpNb2RpZmllcj4g bW9kaWZpZXJzKTsKQEAgLTE4MjksNiArMTgzMCw3IEBAIHByaXZhdGU6CiAKICNpZiBQTEFURk9S TShXUEUpCiAgICAgSVBDOjpBdHRhY2htZW50IG1faG9zdEZpbGVEZXNjcmlwdG9yOworICAgIHVp bnQzMl90IG1fZWdsQ29uZmlnQml0c1BlclBpeGVsIHsgMzIgfTsKICNlbmRpZgogCiAgICAgSGFz aE1hcDxTdHJpbmcsIFJlZlB0cjxXZWJVUkxTY2hlbWVIYW5kbGVyUHJveHk+PiBtX3NjaGVtZVRv VVJMU2NoZW1lSGFuZGxlclByb3h5TWFwOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDg0ZmUzZDZmNTQ2YTAwNDc5Y2IxYjQ5MDdjYTFjZjNkN2Mw MTYyNjcuLmZmZGEyYWNiNTdiOGRlZDEzMWIzOTcyYTIyODcwN2ViMTA3Njg1ZGMgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBA QAorMjAxOS0wMi0xOSAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxpYS5jb20+CisK KyAgICAgICAgW1dQRV1bRUdMXSBSdW50aW1lIHN1cHBvcnQgZm9yIDE2IGJwcCBFR0wgY29uZmln dXJhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE5NDgxNworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogTWluaUJyb3dzZXIvd3BlL21haW4uY3BwOgorICAgICAgICAobWFpbik6IEFkZCBXUEVfRUdM X0JQUCBlbnZpcm9ubWVudCB2YXJpYWJsZSBzdXBwb3J0IHNvIHRoYXQgdGhlCisgICAgICAgIGVn bC1jb25maWctYml0cy1wZXItcGl4ZWwgc2V0dGluZyBjYW4gYmUgZWFzaWx5IHRlc3RlZC4KKwog MjAxOS0wMi0xOSAgUGFibG8gU2FhdmVkcmEgIDxwc2FhdmVkcmFAaWdhbGlhLmNvbT4KIAogICAg ICAgICBweXRlc3QgaXMgbm90IGNvcnJlY3RseSBhdXRvLWluc3RhbGxlZApkaWZmIC0tZ2l0IGEv VG9vbHMvTWluaUJyb3dzZXIvd3BlL21haW4uY3BwIGIvVG9vbHMvTWluaUJyb3dzZXIvd3BlL21h aW4uY3BwCmluZGV4IDEzMWEwZjM4NzA5MGIzNDc3NTI0MDhmOWVhNDE2ZGJhMTgwYWZmYWEuLjNk YjhiZWU3NTJmZDQyYWY5NmI2OWQ5MzdjNzdlN2M3ZDZhYzAxZDYgMTAwNjQ0Ci0tLSBhL1Rvb2xz L01pbmlCcm93c2VyL3dwZS9tYWluLmNwcAorKysgYi9Ub29scy9NaW5pQnJvd3Nlci93cGUvbWFp bi5jcHAKQEAgLTE4MywxMiArMTgzLDE2IEBAIGludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2 W10pCiAgICAgY29uc3QgY2hhciogc2luZ2xlcHJvY2VzcyA9IGdfZ2V0ZW52KCJNSU5JQlJPV1NF Ul9TSU5HTEVQUk9DRVNTIik7CiAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9wcm9jZXNzX21v ZGVsKHdlYkNvbnRleHQsIChzaW5nbGVwcm9jZXNzICYmICpzaW5nbGVwcm9jZXNzKSA/CiAgICAg ICAgIFdFQktJVF9QUk9DRVNTX01PREVMX1NIQVJFRF9TRUNPTkRBUllfUFJPQ0VTUyA6IFdFQktJ VF9QUk9DRVNTX01PREVMX01VTFRJUExFX1NFQ09OREFSWV9QUk9DRVNTRVMpOworICAgIGludCBl Z2xDb25maWdCaXRzUGVyUGl4ZWwgPSAzMjsKKyAgICBpZiAoY29uc3QgY2hhciogZWdsQ29uZmln Qml0c1BlclBpeGVsRW52aXJvbm1lbnRWYXJpYWJsZSA9IGdfZ2V0ZW52KCJXUEVfRUdMX0JQUCIp KQorICAgICAgICBlZ2xDb25maWdCaXRzUGVyUGl4ZWwgPSBzdGF0aWNfY2FzdDxpbnQ+KGdfYXNj aWlfc3RydG9sbChlZ2xDb25maWdCaXRzUGVyUGl4ZWxFbnZpcm9ubWVudFZhcmlhYmxlLCBOVUxM LCAwKSk7CiAKICAgICBhdXRvKiBzZXR0aW5ncyA9IHdlYmtpdF9zZXR0aW5nc19uZXdfd2l0aF9z ZXR0aW5ncygKICAgICAgICAgImVuYWJsZS1kZXZlbG9wZXItZXh0cmFzIiwgVFJVRSwKICAgICAg ICAgImVuYWJsZS13ZWJnbCIsIFRSVUUsCiAgICAgICAgICJlbmFibGUtbWVkaWEtc3RyZWFtIiwg VFJVRSwKICAgICAgICAgImVuYWJsZS1lbmNyeXB0ZWQtbWVkaWEiLCBUUlVFLAorICAgICAgICAi ZWdsLWNvbmZpZy1iaXRzLXBlci1waXhlbCIsIGVnbENvbmZpZ0JpdHNQZXJQaXhlbCwKICAgICAg ICAgbnVsbHB0cik7CiAKICAgICBhdXRvKiBiYWNrZW5kUHRyID0gYmFja2VuZC5nZXQoKTsK 362894 2019-02-25 04:57:00 -0800 2019-02-25 04:59:17 -0800 Patch bug-194817-20190225125659.patch text/plain 2679 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyMDM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTc1MWVjYWQwNzJiNzI3 YzQxZDFmMmY4ZTU0YjQ1NDE4NGRkYzg3OS4uNjg5OGJlOTVjOTY2YzNjMmFkNjA5OGFlODJhMGRh OGI1OGQwMDNjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTAyLTI1ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtFR0xd IFJ1bnRpbWUgc3VwcG9ydCBmb3IgMTYgYnBwIEVHTCBjb25maWd1cmF0aW9ucworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk0ODE3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5IG91ciBncmFw aGljcyBwaXBlbGluZSBhbHdheXMgcmVsaWVzIG9uIGEgQVJHQjg4ODggKDMyCisgICAgICAgIGJw cCkgcGl4ZWwgY29uZmlndXJhdGlvbi4gT24gc29tZSBsb3ctZW5kIChvbGQpIGVtYmVkZGVkIHBs YXRmb3JtcworICAgICAgICB0aGUgZ3JhcGhpY3MgZHJpdmVyIGlzIHNvbWV0aW1lcyBvcHRpbWl6 ZWQgZm9yIDE2IGJwcAorICAgICAgICBjb25maWd1cmF0aW9ucywgc3VjaCBhcyBSR0I1NjUuIE9u IHRob3NlIHBsYXRmb3JtcyB0aGUgYXBwbGljYXRpb24KKyAgICAgICAgY2FuIG5vdyBzZXQgdGhl IFdFQktJVF9FR0xfUElYRUxfRk9STUFUIGVudmlyb25tZW50IHZhcmlhYmxlIHRvCisgICAgICAg ICJSR0I1NjUiIHRvIGFkanVzdCB0byB0aGUgYmVzdCBwaXhlbCBjb25maWd1cmF0aW9uIHN1cHBv cnRlZCBieQorICAgICAgICB0aGUgc2NyZWVuIGFuZCBncmFwaGljcyBkcml2ZXIuCisKKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkdMQ29udGV4dEVHTDo6Z2V0RUdMQ29uZmlnKToKKwogMjAxOS0wMi0yNSAgQ2hhcmxp ZSBUdXJuZXIgIDxjdHVybmVyQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0VNRV1bR1N0cmVhbWVy XSBSZXBsYWNlIGNhcHMgZmllbGQgbG9vcCB3aXRoIGdzdF9zdHJ1Y3R1cmVfcmVtb3ZlX2ZpZWxk cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29u dGV4dEVHTC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250 ZXh0RUdMLmNwcAppbmRleCAyNGQwNmJhMDJiNzlmNGI3NmQ3OTIyNzc0YTBmOGNkNWUzMDZhMGFj Li4yNGIwYjg5ZTk5YWI1MTNhZjllYTA1ZGI2NmM3NTMwMzIyOTg4NzQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcApA QCAtMTAwLDE1ICsxMDAsMjggQEAgYm9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZpZyhFR0xE aXNwbGF5IGRpc3BsYXksIEVHTENvbmZpZyogY29uZmlnLCBFR0xTdXJmYWMKICNlbHNlCiAgICAg ICAgIEVHTF9SRU5ERVJBQkxFX1RZUEUsIEVHTF9PUEVOR0xfQklULAogI2VuZGlmCi0gICAgICAg IEVHTF9SRURfU0laRSwgOCwKLSAgICAgICAgRUdMX0dSRUVOX1NJWkUsIDgsCi0gICAgICAgIEVH TF9CTFVFX1NJWkUsIDgsCisgICAgICAgIEVHTF9SRURfU0laRSwgMSwKKyAgICAgICAgRUdMX0dS RUVOX1NJWkUsIDEsCisgICAgICAgIEVHTF9CTFVFX1NJWkUsIDEsCisgICAgICAgIEVHTF9BTFBI QV9TSVpFLCAxLAogICAgICAgICBFR0xfU1RFTkNJTF9TSVpFLCA4LAotICAgICAgICBFR0xfQUxQ SEFfU0laRSwgOCwKICAgICAgICAgRUdMX1NVUkZBQ0VfVFlQRSwgRUdMX05PTkUsCiAgICAgICAg IEVHTF9OT05FCiAgICAgfTsKIAorICAgIEVHTGludCBidWZmZXJTaXplID0gMzI7CisgICAgY29u c3QgY2hhciogZW52aXJvbm1lbnRWYXJpYWJsZSA9IGdldGVudigiV0VCS0lUX0VHTF9QSVhFTF9G T1JNQVQiKTsKKyAgICBpZiAoZW52aXJvbm1lbnRWYXJpYWJsZSAmJiAqZW52aXJvbm1lbnRWYXJp YWJsZSkgeworICAgICAgICBpZiAoIXN0cmNtcChlbnZpcm9ubWVudFZhcmlhYmxlLCAiUkdCNTY1 IikpIHsKKyAgICAgICAgICAgIGJ1ZmZlclNpemUgPSAxNjsKKyAgICAgICAgICAgIGF0dHJpYnV0 ZUxpc3RbM10gPSA1OworICAgICAgICAgICAgYXR0cmlidXRlTGlzdFs1XSA9IDY7CisgICAgICAg ICAgICBhdHRyaWJ1dGVMaXN0WzddID0gNTsKKyAgICAgICAgICAgIGF0dHJpYnV0ZUxpc3RbOV0g PSAwOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGdfd2FybmluZygiVmFsdWUgc3VwcGxp ZWQgZm9yIFdFQktJVF9FR0xfUElYRUxfRk9STUFUIHNob3VsZCBiZSBSR0I1NjUgb3IgdGhlIGVu dmlyb25tZW50IHZhcmlhYmxlIHNob3VsZCBub3QgYmUgc2V0IGF0IGFsbC4iKTsKKyAgICB9CisK ICAgICBzd2l0Y2ggKHN1cmZhY2VUeXBlKSB7CiAgICAgY2FzZSBHTENvbnRleHRFR0w6OlBidWZm ZXJTdXJmYWNlOgogICAgICAgICBhdHRyaWJ1dGVMaXN0WzEzXSA9IEVHTF9QQlVGRkVSX0JJVDsK 362895 2019-02-25 05:02:09 -0800 2019-02-26 04:00:15 -0800 Patch bug-194817-20190225130208.patch text/plain 3913 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyMDM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTc1MWVjYWQwNzJiNzI3 YzQxZDFmMmY4ZTU0YjQ1NDE4NGRkYzg3OS4uNjg5OGJlOTVjOTY2YzNjMmFkNjA5OGFlODJhMGRh OGI1OGQwMDNjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTAyLTI1ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtFR0xd IFJ1bnRpbWUgc3VwcG9ydCBmb3IgMTYgYnBwIEVHTCBjb25maWd1cmF0aW9ucworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk0ODE3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5IG91ciBncmFw aGljcyBwaXBlbGluZSBhbHdheXMgcmVsaWVzIG9uIGEgQVJHQjg4ODggKDMyCisgICAgICAgIGJw cCkgcGl4ZWwgY29uZmlndXJhdGlvbi4gT24gc29tZSBsb3ctZW5kIChvbGQpIGVtYmVkZGVkIHBs YXRmb3JtcworICAgICAgICB0aGUgZ3JhcGhpY3MgZHJpdmVyIGlzIHNvbWV0aW1lcyBvcHRpbWl6 ZWQgZm9yIDE2IGJwcAorICAgICAgICBjb25maWd1cmF0aW9ucywgc3VjaCBhcyBSR0I1NjUuIE9u IHRob3NlIHBsYXRmb3JtcyB0aGUgYXBwbGljYXRpb24KKyAgICAgICAgY2FuIG5vdyBzZXQgdGhl IFdFQktJVF9FR0xfUElYRUxfRk9STUFUIGVudmlyb25tZW50IHZhcmlhYmxlIHRvCisgICAgICAg ICJSR0I1NjUiIHRvIGFkanVzdCB0byB0aGUgYmVzdCBwaXhlbCBjb25maWd1cmF0aW9uIHN1cHBv cnRlZCBieQorICAgICAgICB0aGUgc2NyZWVuIGFuZCBncmFwaGljcyBkcml2ZXIuCisKKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkdMQ29udGV4dEVHTDo6Z2V0RUdMQ29uZmlnKToKKwogMjAxOS0wMi0yNSAgQ2hhcmxp ZSBUdXJuZXIgIDxjdHVybmVyQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0VNRV1bR1N0cmVhbWVy XSBSZXBsYWNlIGNhcHMgZmllbGQgbG9vcCB3aXRoIGdzdF9zdHJ1Y3R1cmVfcmVtb3ZlX2ZpZWxk cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29u dGV4dEVHTC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250 ZXh0RUdMLmNwcAppbmRleCAyNGQwNmJhMDJiNzlmNGI3NmQ3OTIyNzc0YTBmOGNkNWUzMDZhMGFj Li5hZGEzOGQwMGZkYTViNGExMTYyMTVhN2FhZjc5NWNmYzA2MWI4MTU1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcApA QCAtMTAwLDE5ICsxMDAsMzMgQEAgYm9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZpZyhFR0xE aXNwbGF5IGRpc3BsYXksIEVHTENvbmZpZyogY29uZmlnLCBFR0xTdXJmYWMKICNlbHNlCiAgICAg ICAgIEVHTF9SRU5ERVJBQkxFX1RZUEUsIEVHTF9PUEVOR0xfQklULAogI2VuZGlmCi0gICAgICAg IEVHTF9SRURfU0laRSwgOCwKLSAgICAgICAgRUdMX0dSRUVOX1NJWkUsIDgsCi0gICAgICAgIEVH TF9CTFVFX1NJWkUsIDgsCisgICAgICAgIEVHTF9SRURfU0laRSwgMSwKKyAgICAgICAgRUdMX0dS RUVOX1NJWkUsIDEsCisgICAgICAgIEVHTF9CTFVFX1NJWkUsIDEsCisgICAgICAgIEVHTF9BTFBI QV9TSVpFLCAxLAogICAgICAgICBFR0xfU1RFTkNJTF9TSVpFLCA4LAotICAgICAgICBFR0xfQUxQ SEFfU0laRSwgOCwKICAgICAgICAgRUdMX1NVUkZBQ0VfVFlQRSwgRUdMX05PTkUsCiAgICAgICAg IEVHTF9OT05FCiAgICAgfTsKIAorICAgIEVHTGludCBidWZmZXJTaXplID0gMzI7CisgICAgY29u c3QgY2hhciogZW52aXJvbm1lbnRWYXJpYWJsZSA9IGdldGVudigiV0VCS0lUX0VHTF9QSVhFTF9G T1JNQVQiKTsKKyAgICBpZiAoZW52aXJvbm1lbnRWYXJpYWJsZSAmJiAqZW52aXJvbm1lbnRWYXJp YWJsZSkgeworICAgICAgICBpZiAoIXN0cmNtcChlbnZpcm9ubWVudFZhcmlhYmxlLCAiUkdCNTY1 IikpIHsKKyAgICAgICAgICAgIGJ1ZmZlclNpemUgPSAxNjsKKyAgICAgICAgICAgIGF0dHJpYnV0 ZUxpc3RbM10gPSA1OworICAgICAgICAgICAgYXR0cmlidXRlTGlzdFs1XSA9IDY7CisgICAgICAg ICAgICBhdHRyaWJ1dGVMaXN0WzddID0gNTsKKyAgICAgICAgICAgIGF0dHJpYnV0ZUxpc3RbOV0g PSAwOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGdfd2FybmluZygiVmFsdWUgc3VwcGxp ZWQgZm9yIFdFQktJVF9FR0xfUElYRUxfRk9STUFUIHNob3VsZCBiZSBSR0I1NjUgb3IgdGhlIGVu dmlyb25tZW50IHZhcmlhYmxlIHNob3VsZCBub3QgYmUgc2V0IGF0IGFsbC4iKTsKKyAgICB9CisK ICAgICBzd2l0Y2ggKHN1cmZhY2VUeXBlKSB7CiAgICAgY2FzZSBHTENvbnRleHRFR0w6OlBidWZm ZXJTdXJmYWNlOgogICAgICAgICBhdHRyaWJ1dGVMaXN0WzEzXSA9IEVHTF9QQlVGRkVSX0JJVDsK ICAgICAgICAgYnJlYWs7CisKICAgICBjYXNlIEdMQ29udGV4dEVHTDo6UGl4bWFwU3VyZmFjZToK ICAgICAgICAgYXR0cmlidXRlTGlzdFsxM10gPSBFR0xfUElYTUFQX0JJVDsKICAgICAgICAgYnJl YWs7CkBAIC0xMjIsOCArMTM2LDI2IEBAIGJvb2wgR0xDb250ZXh0RUdMOjpnZXRFR0xDb25maWco RUdMRGlzcGxheSBkaXNwbGF5LCBFR0xDb25maWcqIGNvbmZpZywgRUdMU3VyZmFjCiAgICAgICAg IGJyZWFrOwogICAgIH0KIAorICAgIEVHTGludCBjb3VudDsKKyAgICBpZiAoIWVnbEdldENvbmZp Z3MoZGlzcGxheSwgbnVsbHB0ciwgMCwgJmNvdW50KSB8fCAhY291bnQpCisgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgIEVHTENvbmZpZyogY29uZmlncyA9IHJlaW50ZXJwcmV0X2Nhc3Q8RUdM Q29uZmlnKj4oZmFzdENhbGxvYyhzaXplb2YoRUdMQ29uZmlnKSwgY291bnQpKTsKICAgICBFR0xp bnQgbnVtYmVyQ29uZmlnc1JldHVybmVkOwotICAgIHJldHVybiBlZ2xDaG9vc2VDb25maWcoZGlz cGxheSwgYXR0cmlidXRlTGlzdCwgY29uZmlnLCAxLCAmbnVtYmVyQ29uZmlnc1JldHVybmVkKSAm JiBudW1iZXJDb25maWdzUmV0dXJuZWQ7CisgICAgaWYgKCFlZ2xDaG9vc2VDb25maWcoZGlzcGxh eSwgYXR0cmlidXRlTGlzdCwgY29uZmlncywgY291bnQsICZudW1iZXJDb25maWdzUmV0dXJuZWQp IHx8ICFudW1iZXJDb25maWdzUmV0dXJuZWQpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAg IEVHTGludCBzaXplOworICAgIGZvciAoRUdMaW50IGkgPSAwOyBpIDwgbnVtYmVyQ29uZmlnc1Jl dHVybmVkOyBpKyspIHsKKyAgICAgICAgZWdsR2V0Q29uZmlnQXR0cmliKGRpc3BsYXksIGNvbmZp Z3NbaV0sIEVHTF9CVUZGRVJfU0laRSwgJnNpemUpOworICAgICAgICBpZiAoYnVmZmVyU2l6ZSA9 PSBzaXplKSB7CisgICAgICAgICAgICAqY29uZmlnID0gY29uZmlnc1tpXTsKKyAgICAgICAgICAg IGZhc3RGcmVlKGNvbmZpZ3MpOworICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0K KyAgICB9CisgICAgZmFzdEZyZWUoY29uZmlncyk7CisgICAgcmV0dXJuIGZhbHNlOwogfQogCiBz dGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVdpbmRvd0Nv bnRleHQoR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvdywgUGxhdGZvcm1EaXNwbGF5JiBwbGF0Zm9y bURpc3BsYXksIEVHTENvbnRleHQgc2hhcmluZ0NvbnRleHQpCg== 362974 2019-02-26 04:00:19 -0800 2019-02-26 04:16:31 -0800 Patch bug-194817-20190226120018.patch text/plain 4368 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyMDgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTVkZjkyMTAyY2JmMjE0 NWQ5MWQyOGY4OTQwZDY2ZDhhYjA1ZGQxMS4uNmZkODZkODRmZmE4ZjU0YTI0NzRiYzE4ZDkwMDg1 YWE5YmMwZmNjNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTAyLTI1ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtFR0xd IFJ1bnRpbWUgc3VwcG9ydCBmb3IgUkdCNTY1IHBpeGVsIGxheW91dAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk0ODE3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5IG91ciBncmFwaGljcyBw aXBlbGluZSBhbHdheXMgcmVsaWVzIG9uIGEgQVJHQjg4ODggKDMyCisgICAgICAgIGJwcCkgcGl4 ZWwgY29uZmlndXJhdGlvbi4gT24gc29tZSBsb3ctZW5kIChvbGQpIGVtYmVkZGVkIHBsYXRmb3Jt cworICAgICAgICB0aGUgZ3JhcGhpY3MgZHJpdmVyIGlzIHNvbWV0aW1lcyBvcHRpbWl6ZWQgZm9y IDE2IGJwcAorICAgICAgICBjb25maWd1cmF0aW9ucywgc3VjaCBhcyBSR0I1NjUuIE9uIHRob3Nl IHBsYXRmb3JtcyB0aGUgYXBwbGljYXRpb24KKyAgICAgICAgY2FuIG5vdyBzZXQgdGhlIFdFQktJ VF9FR0xfUElYRUxfTEFZT1VUIGVudmlyb25tZW50IHZhcmlhYmxlIHRvCisgICAgICAgICJSR0I1 NjUiIHRvIGFkanVzdCB0byB0aGUgYmVzdCBwaXhlbCBjb25maWd1cmF0aW9uIHN1cHBvcnRlZCBi eQorICAgICAgICB0aGUgc2NyZWVuIGFuZCBncmFwaGljcyBkcml2ZXIuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkdMQ29udGV4dEVHTDo6Z2V0RUdMQ29uZmlnKToKKwogMjAxOS0wMi0yNSAgWW9uZ2p1biBaaGFu ZyAgPHlvbmdqdW5femhhbmdAYXBwbGUuY29tPgogCiAgICAgICAgIHNjYWxhYmxlTmF0aXZlV2Vi cGFnZVBhcmFtZXRlcnMoKSBpcyBub3QgcHJlc2VydmVkIG9uIG5ldyBwYWdlIG5hdmlnYXRpb24u CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250 ZXh0RUdMLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRl eHRFR0wuY3BwCmluZGV4IDI0ZDA2YmEwMmI3OWY0Yjc2ZDc5MjI3NzRhMGY4Y2Q1ZTMwNmEwYWMu Ljk5MmYwMjFhYzllZTIwZmFkNjJjNDY2YTllNjZhZjcxMjQzMTdiMzcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwCkBA IC01Myw2ICs1Myw4IEBACiAjaW5jbHVkZSA8Y2Fpcm8tZ2wuaD4KICNlbmRpZgogCisjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBVU0UoT1BFTkdM X0VTKQpAQCAtMTAwLDE5ICsxMDIsMzcgQEAgYm9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZp ZyhFR0xEaXNwbGF5IGRpc3BsYXksIEVHTENvbmZpZyogY29uZmlnLCBFR0xTdXJmYWMKICNlbHNl CiAgICAgICAgIEVHTF9SRU5ERVJBQkxFX1RZUEUsIEVHTF9PUEVOR0xfQklULAogI2VuZGlmCi0g ICAgICAgIEVHTF9SRURfU0laRSwgOCwKLSAgICAgICAgRUdMX0dSRUVOX1NJWkUsIDgsCi0gICAg ICAgIEVHTF9CTFVFX1NJWkUsIDgsCisgICAgICAgIEVHTF9SRURfU0laRSwgMSwKKyAgICAgICAg RUdMX0dSRUVOX1NJWkUsIDEsCisgICAgICAgIEVHTF9CTFVFX1NJWkUsIDEsCisgICAgICAgIEVH TF9BTFBIQV9TSVpFLCAxLAogICAgICAgICBFR0xfU1RFTkNJTF9TSVpFLCA4LAotICAgICAgICBF R0xfQUxQSEFfU0laRSwgOCwKICAgICAgICAgRUdMX1NVUkZBQ0VfVFlQRSwgRUdMX05PTkUsCiAg ICAgICAgIEVHTF9OT05FCiAgICAgfTsKIAorICAgIGJvb2wgaXNSR0I1NjUgPSBmYWxzZTsKKyAg ICBpZiAoY29uc3QgY2hhciogZW52aXJvbm1lbnRWYXJpYWJsZSA9IGdldGVudigiV0VCS0lUX0VH TF9QSVhFTF9MQVlPVVQiKSkgeworICAgICAgICBpZiAoIXN0cmNtcChlbnZpcm9ubWVudFZhcmlh YmxlLCAiUkdCNTY1IikpIHsKKyAgICAgICAgICAgIC8vIGJ1ZmZlclNpemUgPSAxNjsKKyAgICAg ICAgICAgIGlzUkdCNTY1ID0gdHJ1ZTsKKyAgICAgICAgICAgIC8vIEVHTF9SRURfU0laRQorICAg ICAgICAgICAgYXR0cmlidXRlTGlzdFszXSA9IDU7CisgICAgICAgICAgICAvLyBFR0xfR1JFRU5f U0laRQorICAgICAgICAgICAgYXR0cmlidXRlTGlzdFs1XSA9IDY7CisgICAgICAgICAgICAvLyBF R0xfQkxVRV9TSVpFCisgICAgICAgICAgICBhdHRyaWJ1dGVMaXN0WzddID0gNTsKKyAgICAgICAg ICAgIC8vIEVHTF9BTFBIQV9TSVpFCisgICAgICAgICAgICBhdHRyaWJ1dGVMaXN0WzldID0gMDsK KyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBXVEZMb2dBbHdheXMoIlVua25vd24gcGl4ZWwg bGF5b3V0ICVzLCBmYWxsaW5nIGJhY2sgdG8gUkdCQTg4ODgiLCBlbnZpcm9ubWVudFZhcmlhYmxl KTsKKyAgICB9CisKICAgICBzd2l0Y2ggKHN1cmZhY2VUeXBlKSB7CiAgICAgY2FzZSBHTENvbnRl eHRFR0w6OlBidWZmZXJTdXJmYWNlOgogICAgICAgICBhdHRyaWJ1dGVMaXN0WzEzXSA9IEVHTF9Q QlVGRkVSX0JJVDsKICAgICAgICAgYnJlYWs7CisKICAgICBjYXNlIEdMQ29udGV4dEVHTDo6UGl4 bWFwU3VyZmFjZToKICAgICAgICAgYXR0cmlidXRlTGlzdFsxM10gPSBFR0xfUElYTUFQX0JJVDsK ICAgICAgICAgYnJlYWs7CkBAIC0xMjIsOCArMTQyLDMxIEBAIGJvb2wgR0xDb250ZXh0RUdMOjpn ZXRFR0xDb25maWcoRUdMRGlzcGxheSBkaXNwbGF5LCBFR0xDb25maWcqIGNvbmZpZywgRUdMU3Vy ZmFjCiAgICAgICAgIGJyZWFrOwogICAgIH0KIAorICAgIEVHTGludCBjb3VudDsKKyAgICBpZiAo IWVnbENob29zZUNvbmZpZyhkaXNwbGF5LCBhdHRyaWJ1dGVMaXN0LCBudWxscHRyLCAwLCAmY291 bnQpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICBFR0xpbnQgbnVtYmVyQ29uZmlnc1Jl dHVybmVkOwotICAgIHJldHVybiBlZ2xDaG9vc2VDb25maWcoZGlzcGxheSwgYXR0cmlidXRlTGlz dCwgY29uZmlnLCAxLCAmbnVtYmVyQ29uZmlnc1JldHVybmVkKSAmJiBudW1iZXJDb25maWdzUmV0 dXJuZWQ7CisgICAgYXV0byBjb25maWdzID0gc3RkOjptYWtlX3VuaXF1ZTxWZWN0b3I8RUdMQ29u ZmlnPj4oY291bnQpOworICAgIGlmICghZWdsQ2hvb3NlQ29uZmlnKGRpc3BsYXksIGF0dHJpYnV0 ZUxpc3QsIGlzUkdCNTY1ID8gcmVpbnRlcnByZXRfY2FzdDxFR0xDb25maWcqPihjb25maWdzLT5k YXRhKCkpIDogY29uZmlnLCBpc1JHQjU2NSA/IGNvdW50IDogMSwgJm51bWJlckNvbmZpZ3NSZXR1 cm5lZCkgfHwgIW51bWJlckNvbmZpZ3NSZXR1cm5lZCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor CisgICAgaWYgKCFpc1JHQjU2NSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBhdXRvIGlu ZGV4ID0gY29uZmlncy0+ZmluZE1hdGNoaW5nKFsmXShFR0xDb25maWcgdmFsdWUpIHsKKyAgICAg ICAgRUdMaW50IHJlZFNpemUsIGdyZWVuU2l6ZSwgYmx1ZVNpemU7CisgICAgICAgIGVnbEdldENv bmZpZ0F0dHJpYihkaXNwbGF5LCB2YWx1ZSwgRUdMX1JFRF9TSVpFLCAmcmVkU2l6ZSk7CisgICAg ICAgIGVnbEdldENvbmZpZ0F0dHJpYihkaXNwbGF5LCB2YWx1ZSwgRUdMX0dSRUVOX1NJWkUsICZn cmVlblNpemUpOworICAgICAgICBlZ2xHZXRDb25maWdBdHRyaWIoZGlzcGxheSwgdmFsdWUsIEVH TF9CTFVFX1NJWkUsICZibHVlU2l6ZSk7CisgICAgICAgIHJldHVybiAocmVkU2l6ZSA9PSA1ICYm IGdyZWVuU2l6ZSA9PSA2ICYmIGJsdWVTaXplID09IDUpOworICAgIH0pOworCisgICAgaWYgKGlu ZGV4ICE9IG5vdEZvdW5kKSB7CisgICAgICAgICpjb25maWcgPSBjb25maWdzLT5hdChpbmRleCk7 CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIHN0 ZDo6dW5pcXVlX3B0cjxHTENvbnRleHRFR0w+IEdMQ29udGV4dEVHTDo6Y3JlYXRlV2luZG93Q29u dGV4dChHTE5hdGl2ZVdpbmRvd1R5cGUgd2luZG93LCBQbGF0Zm9ybURpc3BsYXkmIHBsYXRmb3Jt RGlzcGxheSwgRUdMQ29udGV4dCBzaGFyaW5nQ29udGV4dCkK 362975 2019-02-26 04:06:57 -0800 2019-02-26 06:26:25 -0800 Patch bug-194817-20190226120655.patch text/plain 4315 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyMDgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTVkZjkyMTAyY2JmMjE0 NWQ5MWQyOGY4OTQwZDY2ZDhhYjA1ZGQxMS4uNmZkODZkODRmZmE4ZjU0YTI0NzRiYzE4ZDkwMDg1 YWE5YmMwZmNjNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTAyLTI1ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtFR0xd IFJ1bnRpbWUgc3VwcG9ydCBmb3IgUkdCNTY1IHBpeGVsIGxheW91dAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk0ODE3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5IG91ciBncmFwaGljcyBw aXBlbGluZSBhbHdheXMgcmVsaWVzIG9uIGEgQVJHQjg4ODggKDMyCisgICAgICAgIGJwcCkgcGl4 ZWwgY29uZmlndXJhdGlvbi4gT24gc29tZSBsb3ctZW5kIChvbGQpIGVtYmVkZGVkIHBsYXRmb3Jt cworICAgICAgICB0aGUgZ3JhcGhpY3MgZHJpdmVyIGlzIHNvbWV0aW1lcyBvcHRpbWl6ZWQgZm9y IDE2IGJwcAorICAgICAgICBjb25maWd1cmF0aW9ucywgc3VjaCBhcyBSR0I1NjUuIE9uIHRob3Nl IHBsYXRmb3JtcyB0aGUgYXBwbGljYXRpb24KKyAgICAgICAgY2FuIG5vdyBzZXQgdGhlIFdFQktJ VF9FR0xfUElYRUxfTEFZT1VUIGVudmlyb25tZW50IHZhcmlhYmxlIHRvCisgICAgICAgICJSR0I1 NjUiIHRvIGFkanVzdCB0byB0aGUgYmVzdCBwaXhlbCBjb25maWd1cmF0aW9uIHN1cHBvcnRlZCBi eQorICAgICAgICB0aGUgc2NyZWVuIGFuZCBncmFwaGljcyBkcml2ZXIuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkdMQ29udGV4dEVHTDo6Z2V0RUdMQ29uZmlnKToKKwogMjAxOS0wMi0yNSAgWW9uZ2p1biBaaGFu ZyAgPHlvbmdqdW5femhhbmdAYXBwbGUuY29tPgogCiAgICAgICAgIHNjYWxhYmxlTmF0aXZlV2Vi cGFnZVBhcmFtZXRlcnMoKSBpcyBub3QgcHJlc2VydmVkIG9uIG5ldyBwYWdlIG5hdmlnYXRpb24u CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250 ZXh0RUdMLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRl eHRFR0wuY3BwCmluZGV4IDI0ZDA2YmEwMmI3OWY0Yjc2ZDc5MjI3NzRhMGY4Y2Q1ZTMwNmEwYWMu LjFjM2E3YzJlNzk3ZmQ4YWEzMWYxYzBjYjRkNTc0ODhjMjdiYjFkNTUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3BwCkBA IC01Myw2ICs1Myw4IEBACiAjaW5jbHVkZSA8Y2Fpcm8tZ2wuaD4KICNlbmRpZgogCisjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBVU0UoT1BFTkdM X0VTKQpAQCAtMTAwLDE1ICsxMDIsMzEgQEAgYm9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZp ZyhFR0xEaXNwbGF5IGRpc3BsYXksIEVHTENvbmZpZyogY29uZmlnLCBFR0xTdXJmYWMKICNlbHNl CiAgICAgICAgIEVHTF9SRU5ERVJBQkxFX1RZUEUsIEVHTF9PUEVOR0xfQklULAogI2VuZGlmCi0g ICAgICAgIEVHTF9SRURfU0laRSwgOCwKLSAgICAgICAgRUdMX0dSRUVOX1NJWkUsIDgsCi0gICAg ICAgIEVHTF9CTFVFX1NJWkUsIDgsCisgICAgICAgIEVHTF9SRURfU0laRSwgMSwKKyAgICAgICAg RUdMX0dSRUVOX1NJWkUsIDEsCisgICAgICAgIEVHTF9CTFVFX1NJWkUsIDEsCisgICAgICAgIEVH TF9BTFBIQV9TSVpFLCAxLAogICAgICAgICBFR0xfU1RFTkNJTF9TSVpFLCA4LAotICAgICAgICBF R0xfQUxQSEFfU0laRSwgOCwKICAgICAgICAgRUdMX1NVUkZBQ0VfVFlQRSwgRUdMX05PTkUsCiAg ICAgICAgIEVHTF9OT05FCiAgICAgfTsKIAorICAgIGJvb2wgaXNSR0I1NjUgPSBmYWxzZTsKKyAg ICBpZiAoY29uc3QgY2hhciogZW52aXJvbm1lbnRWYXJpYWJsZSA9IGdldGVudigiV0VCS0lUX0VH TF9QSVhFTF9MQVlPVVQiKSkgeworICAgICAgICBpZiAoIXN0cmNtcChlbnZpcm9ubWVudFZhcmlh YmxlLCAiUkdCNTY1IikpIHsKKyAgICAgICAgICAgIGlzUkdCNTY1ID0gdHJ1ZTsKKyAgICAgICAg ICAgIC8vIEVHTF9SRURfU0laRQorICAgICAgICAgICAgYXR0cmlidXRlTGlzdFszXSA9IDU7Cisg ICAgICAgICAgICAvLyBFR0xfR1JFRU5fU0laRQorICAgICAgICAgICAgYXR0cmlidXRlTGlzdFs1 XSA9IDY7CisgICAgICAgICAgICAvLyBFR0xfQkxVRV9TSVpFCisgICAgICAgICAgICBhdHRyaWJ1 dGVMaXN0WzddID0gNTsKKyAgICAgICAgICAgIC8vIEVHTF9BTFBIQV9TSVpFCisgICAgICAgICAg ICBhdHRyaWJ1dGVMaXN0WzldID0gMDsKKyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBXVEZM b2dBbHdheXMoIlVua25vd24gcGl4ZWwgbGF5b3V0ICVzLCBmYWxsaW5nIGJhY2sgdG8gUkdCQTg4 ODgiLCBlbnZpcm9ubWVudFZhcmlhYmxlKTsKKyAgICB9CisKICAgICBzd2l0Y2ggKHN1cmZhY2VU eXBlKSB7CiAgICAgY2FzZSBHTENvbnRleHRFR0w6OlBidWZmZXJTdXJmYWNlOgogICAgICAgICBh dHRyaWJ1dGVMaXN0WzEzXSA9IEVHTF9QQlVGRkVSX0JJVDsKQEAgLTEyMiw4ICsxNDAsMzIgQEAg Ym9vbCBHTENvbnRleHRFR0w6OmdldEVHTENvbmZpZyhFR0xEaXNwbGF5IGRpc3BsYXksIEVHTENv bmZpZyogY29uZmlnLCBFR0xTdXJmYWMKICAgICAgICAgYnJlYWs7CiAgICAgfQogCisgICAgRUdM aW50IGNvdW50OworICAgIGlmICghZWdsQ2hvb3NlQ29uZmlnKGRpc3BsYXksIGF0dHJpYnV0ZUxp c3QsIG51bGxwdHIsIDAsICZjb3VudCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIEVH TGludCBudW1iZXJDb25maWdzUmV0dXJuZWQ7Ci0gICAgcmV0dXJuIGVnbENob29zZUNvbmZpZyhk aXNwbGF5LCBhdHRyaWJ1dGVMaXN0LCBjb25maWcsIDEsICZudW1iZXJDb25maWdzUmV0dXJuZWQp ICYmIG51bWJlckNvbmZpZ3NSZXR1cm5lZDsKKyAgICBhdXRvIGNvbmZpZ3MgPSBzdGQ6Om1ha2Vf dW5pcXVlPFZlY3RvcjxFR0xDb25maWc+Pihjb3VudCk7CisgICAgaWYgKCFlZ2xDaG9vc2VDb25m aWcoZGlzcGxheSwgYXR0cmlidXRlTGlzdCwgaXNSR0I1NjUgPyByZWludGVycHJldF9jYXN0PEVH TENvbmZpZyo+KGNvbmZpZ3MtPmRhdGEoKSkgOiBjb25maWcsIGlzUkdCNTY1ID8gY291bnQgOiAx LCAmbnVtYmVyQ29uZmlnc1JldHVybmVkKSB8fCAhbnVtYmVyQ29uZmlnc1JldHVybmVkKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIWlzUkdCNTY1KQorICAgICAgICByZXR1cm4g dHJ1ZTsKKworICAgIGF1dG8gaW5kZXggPSBjb25maWdzLT5maW5kTWF0Y2hpbmcoWyZdKEVHTENv bmZpZyB2YWx1ZSkgeworICAgICAgICBFR0xpbnQgcmVkU2l6ZSwgZ3JlZW5TaXplLCBibHVlU2l6 ZSwgYWxwaGFTaXplOworICAgICAgICBlZ2xHZXRDb25maWdBdHRyaWIoZGlzcGxheSwgdmFsdWUs IEVHTF9SRURfU0laRSwgJnJlZFNpemUpOworICAgICAgICBlZ2xHZXRDb25maWdBdHRyaWIoZGlz cGxheSwgdmFsdWUsIEVHTF9HUkVFTl9TSVpFLCAmZ3JlZW5TaXplKTsKKyAgICAgICAgZWdsR2V0 Q29uZmlnQXR0cmliKGRpc3BsYXksIHZhbHVlLCBFR0xfQkxVRV9TSVpFLCAmYmx1ZVNpemUpOwor ICAgICAgICBlZ2xHZXRDb25maWdBdHRyaWIoZGlzcGxheSwgdmFsdWUsIEVHTF9BTFBIQV9TSVpF LCAmYWxwaGFTaXplKTsKKyAgICAgICAgcmV0dXJuIChyZWRTaXplID09IDUgJiYgZ3JlZW5TaXpl ID09IDYgJiYgYmx1ZVNpemUgPT0gNSAmJiAhYWxwaGFTaXplKTsKKyAgICB9KTsKKworICAgIGlm IChpbmRleCAhPSBub3RGb3VuZCkgeworICAgICAgICAqY29uZmlnID0gY29uZmlncy0+YXQoaW5k ZXgpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJuIGZhbHNlOwogfQog CiBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVdpbmRv d0NvbnRleHQoR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvdywgUGxhdGZvcm1EaXNwbGF5JiBwbGF0 Zm9ybURpc3BsYXksIEVHTENvbnRleHQgc2hhcmluZ0NvbnRleHQpCg== 362978 2019-02-26 06:26:30 -0800 2019-02-26 07:03:07 -0800 Patch bug-194817-20190226142629.patch text/plain 4279 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyMDgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTVkZjkyMTAyY2JmMjE0 NWQ5MWQyOGY4OTQwZDY2ZDhhYjA1ZGQxMS4uMzUzNzdlYTAzNDEyNDU0ZGRlODE0OTZkZmI3MTYw ZjAwZTdmNDY0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTAyLTI1ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbRUdMXSBSdW50 aW1lIHN1cHBvcnQgZm9yIFJHQjU2NSBwaXhlbCBsYXlvdXQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5NDgxNworCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEN1cnJlbnRseSBvdXIgZ3JhcGhpY3MgcGlwZWxp bmUgYWx3YXlzIHJlbGllcyBvbiBhIEFSR0I4ODg4ICgzMgorICAgICAgICBicHApIHBpeGVsIGNv bmZpZ3VyYXRpb24uIE9uIHNvbWUgbG93LWVuZCAob2xkKSBlbWJlZGRlZCBwbGF0Zm9ybXMKKyAg ICAgICAgdGhlIGdyYXBoaWNzIGRyaXZlciBpcyBzb21ldGltZXMgb3B0aW1pemVkIGZvciAxNiBi cHAKKyAgICAgICAgY29uZmlndXJhdGlvbnMsIHN1Y2ggYXMgUkdCNTY1LiBPbiB0aG9zZSBwbGF0 Zm9ybXMgdGhlIGFwcGxpY2F0aW9uCisgICAgICAgIGNhbiBub3cgc2V0IHRoZSBXRUJLSVRfRUdM X1BJWEVMX0xBWU9VVCBlbnZpcm9ubWVudCB2YXJpYWJsZSB0bworICAgICAgICAiUkdCNTY1IiB0 byBhZGp1c3QgdG8gdGhlIGJlc3QgcGl4ZWwgY29uZmlndXJhdGlvbiBzdXBwb3J0ZWQgYnkKKyAg ICAgICAgdGhlIHNjcmVlbiBhbmQgZ3JhcGhpY3MgZHJpdmVyLgorCisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHTENv bnRleHRFR0w6OmdldEVHTENvbmZpZyk6CisKIDIwMTktMDItMjUgIFlvbmdqdW4gWmhhbmcgIDx5 b25nanVuX3poYW5nQGFwcGxlLmNvbT4KIAogICAgICAgICBzY2FsYWJsZU5hdGl2ZVdlYnBhZ2VQ YXJhbWV0ZXJzKCkgaXMgbm90IHByZXNlcnZlZCBvbiBuZXcgcGFnZSBuYXZpZ2F0aW9uLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVH TC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdM LmNwcAppbmRleCAyNGQwNmJhMDJiNzlmNGI3NmQ3OTIyNzc0YTBmOGNkNWUzMDZhMGFjLi5lMDli MmQ1ZjFkMWEzZDY4Y2FjYTdhMjcxODhmYTY5MWI5MzFkZTJkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcApAQCAtNTMs NiArNTMsOCBAQAogI2luY2x1ZGUgPGNhaXJvLWdsLmg+CiAjZW5kaWYKIAorI2luY2x1ZGUgPHd0 Zi9WZWN0b3IuaD4KKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAjaWYgVVNFKE9QRU5HTF9FUykK QEAgLTEwMCwxNSArMTAyLDMxIEBAIGJvb2wgR0xDb250ZXh0RUdMOjpnZXRFR0xDb25maWcoRUdM RGlzcGxheSBkaXNwbGF5LCBFR0xDb25maWcqIGNvbmZpZywgRUdMU3VyZmFjCiAjZWxzZQogICAg ICAgICBFR0xfUkVOREVSQUJMRV9UWVBFLCBFR0xfT1BFTkdMX0JJVCwKICNlbmRpZgotICAgICAg ICBFR0xfUkVEX1NJWkUsIDgsCi0gICAgICAgIEVHTF9HUkVFTl9TSVpFLCA4LAotICAgICAgICBF R0xfQkxVRV9TSVpFLCA4LAorICAgICAgICBFR0xfUkVEX1NJWkUsIDEsCisgICAgICAgIEVHTF9H UkVFTl9TSVpFLCAxLAorICAgICAgICBFR0xfQkxVRV9TSVpFLCAxLAorICAgICAgICBFR0xfQUxQ SEFfU0laRSwgMSwKICAgICAgICAgRUdMX1NURU5DSUxfU0laRSwgOCwKLSAgICAgICAgRUdMX0FM UEhBX1NJWkUsIDgsCiAgICAgICAgIEVHTF9TVVJGQUNFX1RZUEUsIEVHTF9OT05FLAogICAgICAg ICBFR0xfTk9ORQogICAgIH07CiAKKyAgICBib29sIGlzUkdCNTY1ID0gZmFsc2U7CisgICAgaWYg KGNvbnN0IGNoYXIqIGVudmlyb25tZW50VmFyaWFibGUgPSBnZXRlbnYoIldFQktJVF9FR0xfUElY RUxfTEFZT1VUIikpIHsKKyAgICAgICAgaWYgKCFzdHJjbXAoZW52aXJvbm1lbnRWYXJpYWJsZSwg IlJHQjU2NSIpKSB7CisgICAgICAgICAgICBpc1JHQjU2NSA9IHRydWU7CisgICAgICAgICAgICAv LyBFR0xfUkVEX1NJWkUKKyAgICAgICAgICAgIGF0dHJpYnV0ZUxpc3RbM10gPSA1OworICAgICAg ICAgICAgLy8gRUdMX0dSRUVOX1NJWkUKKyAgICAgICAgICAgIGF0dHJpYnV0ZUxpc3RbNV0gPSA2 OworICAgICAgICAgICAgLy8gRUdMX0JMVUVfU0laRQorICAgICAgICAgICAgYXR0cmlidXRlTGlz dFs3XSA9IDU7CisgICAgICAgICAgICAvLyBFR0xfQUxQSEFfU0laRQorICAgICAgICAgICAgYXR0 cmlidXRlTGlzdFs5XSA9IDA7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgV1RGTG9nQWx3 YXlzKCJVbmtub3duIHBpeGVsIGxheW91dCAlcywgZmFsbGluZyBiYWNrIHRvIFJHQkE4ODg4Iiwg ZW52aXJvbm1lbnRWYXJpYWJsZSk7CisgICAgfQorCiAgICAgc3dpdGNoIChzdXJmYWNlVHlwZSkg ewogICAgIGNhc2UgR0xDb250ZXh0RUdMOjpQYnVmZmVyU3VyZmFjZToKICAgICAgICAgYXR0cmli dXRlTGlzdFsxM10gPSBFR0xfUEJVRkZFUl9CSVQ7CkBAIC0xMjIsOCArMTQwLDMyIEBAIGJvb2wg R0xDb250ZXh0RUdMOjpnZXRFR0xDb25maWcoRUdMRGlzcGxheSBkaXNwbGF5LCBFR0xDb25maWcq IGNvbmZpZywgRUdMU3VyZmFjCiAgICAgICAgIGJyZWFrOwogICAgIH0KIAorICAgIEVHTGludCBj b3VudDsKKyAgICBpZiAoIWVnbENob29zZUNvbmZpZyhkaXNwbGF5LCBhdHRyaWJ1dGVMaXN0LCBu dWxscHRyLCAwLCAmY291bnQpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICBFR0xpbnQg bnVtYmVyQ29uZmlnc1JldHVybmVkOwotICAgIHJldHVybiBlZ2xDaG9vc2VDb25maWcoZGlzcGxh eSwgYXR0cmlidXRlTGlzdCwgY29uZmlnLCAxLCAmbnVtYmVyQ29uZmlnc1JldHVybmVkKSAmJiBu dW1iZXJDb25maWdzUmV0dXJuZWQ7CisgICAgVmVjdG9yPEVHTENvbmZpZz4gY29uZmlncyhjb3Vu dCk7CisgICAgaWYgKCFlZ2xDaG9vc2VDb25maWcoZGlzcGxheSwgYXR0cmlidXRlTGlzdCwgaXNS R0I1NjUgPyByZWludGVycHJldF9jYXN0PEVHTENvbmZpZyo+KGNvbmZpZ3MuZGF0YSgpKSA6IGNv bmZpZywgaXNSR0I1NjUgPyBjb3VudCA6IDEsICZudW1iZXJDb25maWdzUmV0dXJuZWQpIHx8ICFu dW1iZXJDb25maWdzUmV0dXJuZWQpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICgh aXNSR0I1NjUpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgYXV0byBpbmRleCA9IGNvbmZp Z3MuZmluZE1hdGNoaW5nKFsmXShFR0xDb25maWcgdmFsdWUpIHsKKyAgICAgICAgRUdMaW50IHJl ZFNpemUsIGdyZWVuU2l6ZSwgYmx1ZVNpemUsIGFscGhhU2l6ZTsKKyAgICAgICAgZWdsR2V0Q29u ZmlnQXR0cmliKGRpc3BsYXksIHZhbHVlLCBFR0xfUkVEX1NJWkUsICZyZWRTaXplKTsKKyAgICAg ICAgZWdsR2V0Q29uZmlnQXR0cmliKGRpc3BsYXksIHZhbHVlLCBFR0xfR1JFRU5fU0laRSwgJmdy ZWVuU2l6ZSk7CisgICAgICAgIGVnbEdldENvbmZpZ0F0dHJpYihkaXNwbGF5LCB2YWx1ZSwgRUdM X0JMVUVfU0laRSwgJmJsdWVTaXplKTsKKyAgICAgICAgZWdsR2V0Q29uZmlnQXR0cmliKGRpc3Bs YXksIHZhbHVlLCBFR0xfQUxQSEFfU0laRSwgJmFscGhhU2l6ZSk7CisgICAgICAgIHJldHVybiAo cmVkU2l6ZSA9PSA1ICYmIGdyZWVuU2l6ZSA9PSA2ICYmIGJsdWVTaXplID09IDUgJiYgIWFscGhh U2l6ZSk7CisgICAgfSk7CisKKyAgICBpZiAoaW5kZXggIT0gbm90Rm91bmQpIHsKKyAgICAgICAg KmNvbmZpZyA9IGNvbmZpZ3NbaW5kZXhdOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9Cisg ICAgcmV0dXJuIGZhbHNlOwogfQogCiBzdGQ6OnVuaXF1ZV9wdHI8R0xDb250ZXh0RUdMPiBHTENv bnRleHRFR0w6OmNyZWF0ZVdpbmRvd0NvbnRleHQoR0xOYXRpdmVXaW5kb3dUeXBlIHdpbmRvdywg UGxhdGZvcm1EaXNwbGF5JiBwbGF0Zm9ybURpc3BsYXksIEVHTENvbnRleHQgc2hhcmluZ0NvbnRl eHQpCg==