155536 2016-03-16 02:14:30 -0700 Wrong use of EGL_DEPTH_SIZE 2016-10-20 01:36:42 -0700 1 1 1 Unclassified WebKit WebCore Misc. WebKit Local Build All All RESOLVED FIXED P2 Major --- 1 erwin webkit-unassigned cgarcia clopez mario mcatanzaro tpopela yoon zan oldest_to_newest 1175323 0 erwin 2016-03-16 02:14:30 -0700 In Source/WebCore/platform/graphics/egl/GLContextEGL.cpp function std::unique_ptr<GLContextEGL> GLContextEGL::createPixmapContext(EGLContext sharingContext) uses; eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depth) to (mistakenly) get the depth buffer size instead of the color depth. That depth (0 because no depth buffer was requested) is later passed to; XCreatePixmap(x11Display, DefaultRootWindow(x11Display), 1, 1, depth) to request a pixmap with the same color depth as the screen. And passing 0 causes that call to fail with a; (WebKitWebProcess:669): Gdk-ERROR **: The program 'WebKitWebProcess' received an X Window System error. This probably reflects a bug in the program. The error was 'BadValue'. (Details: serial 148 error_code 2 request_code 53 (core protocol) minor_code 0) (Note to programmers: normally, X errors are reported asynchronously; that is, you will receive the error a while after causing it. To debug your program, run it with the GDK_SYNCHRONIZE environment variable to change this behavior. You can then get a meaningful backtrace from your debugger if you break on the gdk_x_error() function.) On my hardware setup (Tegra3 Linux) setting depth hard to 32 makes things work, this is ofcourse not a real fix because other setups might not use 32bit screens. 1175399 1 clopez 2016-03-16 11:03:28 -0700 So the issue is that we are requesting an EGL config without specifying the depth in eglChooseConfig, or the issue is that the value of EGL_DEPTH_SIZE is not what we should be passing to XCreatePixmap ? 1175538 2 erwin 2016-03-16 15:50:52 -0700 The intention of the code seems to be to get the number of bits per pixel (used by the screen for color) and to create a pixmap with that same number of bits per pixel. The EGL_DEPTH_SIZE has nothing to do with color, it is the depth buffer size (the number of bits for the Z axis). https://www.khronos.org/registry/egl/sdk/docs/man/html/eglGetConfigAttrib.xhtml A better way to get the color depth of the DefaultRootWindow is maybe to use the XGetWindowAttributes() call and use the XWindowAttributes.depth member. https://tronche.com/gui/x/xlib/window-information/XGetWindowAttributes.html 1175684 3 clopez 2016-03-17 04:17:21 -0700 (In reply to comment #2) > The intention of the code seems to be to get the number of bits per pixel > (used by the screen for color) and to create a pixmap with that same number > of bits per pixel. > > The EGL_DEPTH_SIZE has nothing to do with color, it is the depth buffer size > (the number of bits for the Z axis). > https://www.khronos.org/registry/egl/sdk/docs/man/html/eglGetConfigAttrib. > xhtml > So instead of EGL_DEPTH_SIZE we should request EGL_BUFFER_SIZE ? - EGL_BUFFER_SIZE: Returns the depth of the color buffer. It is the sum of EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, and EGL_ALPHA_SIZE. If you want, feel free to upload a patch here for review. Don't forget to include a Changelog in your patch as explained here: https://webkit.org/contributing-code/ 1175687 4 erwin 2016-03-17 04:36:55 -0700 I can make a patch, but it will take a few days. 1176764 5 mcatanzaro 2016-03-21 10:23:55 -0700 (In reply to comment #4) > I can make a patch, but it will take a few days. Much appreciated, thanks. 1241895 6 cgarcia 2016-10-19 06:03:14 -0700 I've run into this issue too, both EGL_DEPTH_SIZE and EGL_BUFFER_SIZE are indeed confusing. What happens here is that the driver doesn't implement EGL_DEPTH_SIZE and the default value, which is 0, is returned. Then XCreatePixmap fails because 0 is not a valid depth. The thing is that even if EGL_DEPTH_SIZE or EGL_BUFFER_SIZE retuned a valid depth, it still might not be supported by the default screen and XCreatePixmap can fail. What we need to ensure is that the depth we pass is compatible with the X display, not only with the EGL config, to avoid failres when creating the pixmap. So, I think we can use EGL_NATIVE_VISUAL_ID instead, and then ask X for the visual info for that id. If not found then we just return before creating the pixmap. If the visual is found then we can be sure that the depth of the visual will not make the pixmap creation fail. However, with the driver I'm using it doesn't matter how we create the pixmap that eglCreatePixmapSurface always fails, again with X errors that are fatal by default. Since the driver is not free, I assume it doesn't support eglCreatePixmapSurface or it's just buggy, so the only option we have here is trap the x errors and ignore them. It turns out that the x errors are not fatal in this case, because eglCreatePixmapSurface ends up returning a surface, and since these are offscreen contexts, it doesn't really matter if they contains an invalid pixmap, because we never do swap buffer on them, so just ignoring the X errors fixes the crashes and makes everythig work. 1241896 7 292062 cgarcia 2016-10-19 06:23:49 -0700 Created attachment 292062 Patch 1241926 8 292062 mcatanzaro 2016-10-19 09:04:26 -0700 Comment on attachment 292062 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=292062&action=review > Source/WebCore/ChangeLog:10 > + EGL_BUFFER_SIZE retuned a valid depth, it still might not be supported by the default screen and XCreatePixmap retuned -> returned > Source/WebCore/ChangeLog:12 > + EGL config, to avoid failures when creating the pixmap. So, We can use EGL_NATIVE_VISUAL_ID instead, and We -> we > Source/WebCore/ChangeLog:28 > + the depthj to be passed to XCreatePixmap. Also use the XErrorTrapper class to ignore all BadDrawable errors depthj -> depth > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:210 > + // Some drivers fail to create the surface producing BadDrawable X error and the default XError handler normally aborts. > + // However, if the X error is ignored, eglCreatePixmapSurface() ends up returning a surface and we can continue creating > + // the context. Since this is an offscreen context, it doesn't matter if the pixmap used is not valid because we never do > + // swap buffers. So, we use a custom XError handler here that ignores BadDrawable errors and only warns about any other > + // errors without aborting in any case. > + XErrorTrapper trapper(x11Display, XErrorTrapper::Policy::Warn, { BadDrawable }); This seems like a workaround to a broken crap proprietary graphics driver. Are you sure we really want to upstream this workaround? IMO this should be carried downstream in the project for the client that made the mistake of using a proprietary graphics stack. 1241939 9 cgarcia 2016-10-19 09:17:02 -0700 (In reply to comment #8) > Comment on attachment 292062 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=292062&action=review > > > Source/WebCore/ChangeLog:10 > > + EGL_BUFFER_SIZE retuned a valid depth, it still might not be supported by the default screen and XCreatePixmap > > retuned -> returned > > > Source/WebCore/ChangeLog:12 > > + EGL config, to avoid failures when creating the pixmap. So, We can use EGL_NATIVE_VISUAL_ID instead, and > > We -> we > > > Source/WebCore/ChangeLog:28 > > + the depthj to be passed to XCreatePixmap. Also use the XErrorTrapper class to ignore all BadDrawable errors > > depthj -> depth > > > Source/WebCore/platform/graphics/egl/GLContextEGL.cpp:210 > > + // Some drivers fail to create the surface producing BadDrawable X error and the default XError handler normally aborts. > > + // However, if the X error is ignored, eglCreatePixmapSurface() ends up returning a surface and we can continue creating > > + // the context. Since this is an offscreen context, it doesn't matter if the pixmap used is not valid because we never do > > + // swap buffers. So, we use a custom XError handler here that ignores BadDrawable errors and only warns about any other > > + // errors without aborting in any case. > > + XErrorTrapper trapper(x11Display, XErrorTrapper::Policy::Warn, { BadDrawable }); > > This seems like a workaround to a broken crap proprietary graphics driver. > Are you sure we really want to upstream this workaround? IMO this should be > carried downstream in the project for the client that made the mistake of > using a proprietary graphics stack. It's a workaround for a buggy driver, but also a better way to handle X errors in general. You can see other libs using X like GTK+ itself, that are full of blocks trapping X errors. I tried to be conservative here, because I don't want an error trapper like this to hide real bugs, but the plan is to use it every time we detect an X error crashing the web process for no reason and we know it's not a our fault. So, yes I want to upstream this. 1242293 10 cgarcia 2016-10-20 01:36:42 -0700 Committed r207590: <http://trac.webkit.org/changeset/207590> 292062 2016-10-19 06:23:49 -0700 2016-10-19 09:29:34 -0700 Patch wk-egl-create-pixmap-surface-errors.diff text/plain 15656 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBmNWQ4ZjJlLi4zNGI3MzMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDEg QEAKKzIwMTYtMTAtMTkgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFdyb25nIHVzZSBvZiBFR0xfREVQVEhfU0laRQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU1NTM2CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2hhdCBoYXBwZW5zIGhlcmUgaXMgdGhh dCB0aGUgZHJpdmVyIGRvZXNuJ3QgaW1wbGVtZW50IEVHTF9ERVBUSF9TSVpFIGFuZCB0aGUgZGVm YXVsdCB2YWx1ZSwgd2hpY2ggaXMgMCwgaXMKKyAgICAgICAgcmV0dXJuZWQuIFRoZW4gWENyZWF0 ZVBpeG1hcCBmYWlscyBiZWNhdXNlIDAgaXMgbm90IGEgdmFsaWQgZGVwdGguIFRoZSB0aGluZyBp cyB0aGF0IGV2ZW4gaWYgRUdMX0RFUFRIX1NJWkUgb3IKKyAgICAgICAgRUdMX0JVRkZFUl9TSVpF IHJldHVuZWQgYSB2YWxpZCBkZXB0aCwgaXQgc3RpbGwgbWlnaHQgbm90IGJlIHN1cHBvcnRlZCBi eSB0aGUgZGVmYXVsdCBzY3JlZW4gYW5kIFhDcmVhdGVQaXhtYXAKKyAgICAgICAgY2FuIGZhaWwu IFdoYXQgd2UgbmVlZCB0byBlbnN1cmUgaXMgdGhhdCB0aGUgZGVwdGggd2UgcGFzcyBpcyBjb21w YXRpYmxlIHdpdGggdGhlIFggZGlzcGxheSwgbm90IG9ubHkgd2l0aCB0aGUKKyAgICAgICAgRUdM IGNvbmZpZywgdG8gYXZvaWQgZmFpbHVyZXMgd2hlbiBjcmVhdGluZyB0aGUgcGl4bWFwLiBTbywg V2UgY2FuIHVzZSBFR0xfTkFUSVZFX1ZJU1VBTF9JRCBpbnN0ZWFkLCBhbmQKKyAgICAgICAgdGhl biBhc2sgWCBmb3IgdGhlIHZpc3VhbCBpbmZvIGZvciB0aGF0IGlkLiBJZiBpdCBpc24ndCBmb3Vu ZCB0aGVuIHdlIGp1c3QgcmV0dXJuIGJlZm9yZSBjcmVhdGluZyB0aGUgcGl4bWFwLAorICAgICAg ICBidXQgaWYgdGhlIHZpc3VhbCBpcyBmb3VuZCB0aGVuIHdlIGNhbiBiZSBzdXJlIHRoYXQgdGhl IGRlcHRoIG9mIHRoZSB2aXN1YWwgd2lsbCBub3QgbWFrZSB0aGUgcGl4bWFwIGNyZWF0aW9uCisg ICAgICAgIGZhaWwuIEhvd2V2ZXIsIHdpdGggdGhlIGRyaXZlciBJJ20gdXNpbmcgaXQgZG9lc24n dCBtYXR0ZXIgaG93IHdlIGNyZWF0ZSB0aGUgcGl4bWFwIHRoYXQgZWdsQ3JlYXRlUGl4bWFwU3Vy ZmFjZQorICAgICAgICBhbHdheXMgZmFpbHMsIGFnYWluIHdpdGggWCBlcnJvcnMgdGhhdCBhcmUg ZmF0YWwgYnkgZGVmYXVsdC4gU2luY2UgdGhlIGRyaXZlciBpcyBub3QgZnJlZSwgSSBhc3N1bWUg aXQgZG9lc24ndAorICAgICAgICBzdXBwb3J0IGVnbENyZWF0ZVBpeG1hcFN1cmZhY2Ugb3IgaXQn cyBqdXN0IGJ1Z2d5LCBzbyB0aGUgb25seSBvcHRpb24gd2UgaGF2ZSBoZXJlIGlzIHRyYXAgdGhl IHggZXJyb3JzIGFuZAorICAgICAgICBpZ25vcmUgdGhlbS4gSXQgdHVybnMgb3V0IHRoYXQgdGhl IFggZXJyb3JzIGFyZSBub3QgZmF0YWwgaW4gdGhpcyBjYXNlLCBiZWNhdXNlIGVnbENyZWF0ZVBp eG1hcFN1cmZhY2UgZW5kcyB1cAorICAgICAgICByZXR1cm5pbmcgYSBzdXJmYWNlLCBhbmQgc2lu Y2UgdGhlc2UgYXJlIG9mZnNjcmVlbiBjb250ZXh0cywgaXQgZG9lc24ndCByZWFsbHkgbWF0dGVy IGlmIHRoZXkgY29udGFpbiBhbgorICAgICAgICBpbnZhbGlkIHBpeG1hcCwgYmVjYXVzZSB3ZSBu ZXZlciBkbyBzd2FwIGJ1ZmZlciBvbiB0aGVtLCBzbyBqdXN0IGlnbm9yaW5nIHRoZSBYIGVycm9y cyBmaXhlcyB0aGUgY3Jhc2hlcyBhbmQKKyAgICAgICAgbWFrZXMgZXZlcnl0aGlnIHdvcmsuIFRo aXMgcGF0Y2ggYWRkcyBhIGhlbHBlciBjbGFzcyBYRXJyb3JUcmFwcGVyIHRoYXQgYWxsb3dzIHRv IHRyYXAgWEVycm9ycyBhbmQgZGVjaWRlIHdoYXQKKyAgICAgICAgdG8gZG8gd2l0aCB0aGVtIChp Z25vcmUsIHdhcm4gb3IgY3Jhc2gpIG9yIGV2ZW4gbm90IGNvbnNpZGVyIGEgcGFydGljdWxhciBz ZXQgb2YgZXJyb3JzIGFzIGVycm9ycy4KKworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOiBB ZGQgbmV3IGZpbGUgdG8gY29tcGlsYXRpb24uCisgICAgICAgICogUGxhdGZvcm1HVEsuY21ha2U6 IERpdHRvLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2VnbC9HTENvbnRleHRFR0wuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6R0xDb250ZXh0RUdMOjpjcmVhdGVQaXhtYXBDb250ZXh0KTog VXNlIEVHTF9OQVRJVkVfVklTVUFMX0lEIGluc3RlYWQgb2YgRUdMX0RFUFRIX1NJWkUgdG8gZmln dXJlIG91dAorICAgICAgICB0aGUgZGVwdGhqIHRvIGJlIHBhc3NlZCB0byBYQ3JlYXRlUGl4bWFw LiBBbHNvIHVzZSB0aGUgWEVycm9yVHJhcHBlciBjbGFzcyB0byBpZ25vcmUgYWxsIEJhZERyYXdh YmxlIGVycm9ycworICAgICAgICBwcm9kdWNlZCBieSBlZ2xDcmVhdGVQaXhtYXBTdXJmYWNlKCkg YW5kIG9ubHkgc2hvdyBhIHdhcm5pbmcgYWJvdXQgYWxsIG90aGVyIFggZXJyb3JzLgorICAgICAg ICAqIHBsYXRmb3JtL2dyYXBoaWNzL3gxMS9YRXJyb3JUcmFwcGVyLmNwcDogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjp4RXJyb3JUcmFwcGVyc01hcCk6CisgICAgICAgIChXZWJDb3JlOjpYRXJy b3JUcmFwcGVyOjpYRXJyb3JUcmFwcGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlhFcnJvclRyYXBw ZXI6On5YRXJyb3JUcmFwcGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlhFcnJvclRyYXBwZXI6OmVy cm9yQ29kZSk6CisgICAgICAgIChXZWJDb3JlOjpYRXJyb3JUcmFwcGVyOjplcnJvckV2ZW50KToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy94MTEvWEVycm9yVHJhcHBlci5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmU6OlhFcnJvclRyYXBwZXI6OlhFcnJvclRyYXBwZXIpOgorCiAyMDE2 LTEwLTA0ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAg ICAgICBbU09VUF0gUmVtb3ZlIFNTTFBvbGljeUZsYWdzIGZyb20gU291cE5ldHdvcmtTZXNzaW9u CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9X ZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCmluZGV4IDYwODlmMmQuLmYyNGIxMWIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3Jl L1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0xODEsNiArMTgxLDcgQEAgbGlzdChBUFBFTkQgV2ViQ29y ZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3Mvc3VyZmFjZXMvZ2x4L1gxMUhlbHBlci5j cHAKIAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL3gxMS9QbGF0Zm9ybURpc3BsYXlYMTEuY3BwCisg ICAgcGxhdGZvcm0vZ3JhcGhpY3MveDExL1hFcnJvclRyYXBwZXIuY3BwCiAgICAgcGxhdGZvcm0v Z3JhcGhpY3MveDExL1hVbmlxdWVSZXNvdXJjZS5jcHAKIAogICAgIHBsYXRmb3JtL2ltYWdlLWVu Y29kZXJzL0pQRUdJbWFnZUVuY29kZXIuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q bGF0Zm9ybUdUSy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4 IDU2N2JkNzkuLjgxODVjNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RL LmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xNDcsNiAr MTQ3LDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vZ3JhcGhp Y3Mvd2F5bGFuZC9QbGF0Zm9ybURpc3BsYXlXYXlsYW5kLmNwcAogCiAgICAgcGxhdGZvcm0vZ3Jh cGhpY3MveDExL1BsYXRmb3JtRGlzcGxheVgxMS5jcHAKKyAgICBwbGF0Zm9ybS9ncmFwaGljcy94 MTEvWEVycm9yVHJhcHBlci5jcHAKICAgICBwbGF0Zm9ybS9ncmFwaGljcy94MTEvWFVuaXF1ZVJl c291cmNlLmNwcAogCiAgICAgcGxhdGZvcm0vZ3RrL0RyYWdEYXRhR3RrLmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZWdsL0dMQ29udGV4dEVHTC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcApp bmRleCA3OTc5OTY4Li5hZTIwM2I5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9lZ2wvR0xDb250ZXh0RUdMLmNwcApAQCAtMzYsNiArMzYsOCBAQAogCiAj aWYgUExBVEZPUk0oWDExKQogI2luY2x1ZGUgIlBsYXRmb3JtRGlzcGxheVgxMS5oIgorI2luY2x1 ZGUgIlhFcnJvclRyYXBwZXIuaCIKKyNpbmNsdWRlICJYVW5pcXVlUHRyLmgiCiAjaW5jbHVkZSA8 WDExL1hsaWIuaD4KICNlbmRpZgogCkBAIC0xNzUsMTkgKzE3NywzNyBAQCBzdGQ6OnVuaXF1ZV9w dHI8R0xDb250ZXh0RUdMPiBHTENvbnRleHRFR0w6OmNyZWF0ZVBpeG1hcENvbnRleHQoUGxhdGZv cm1EaXNwbGF5JgogICAgIGlmIChjb250ZXh0ID09IEVHTF9OT19DT05URVhUKQogICAgICAgICBy ZXR1cm4gbnVsbHB0cjsKIAotICAgIEVHTGludCBkZXB0aDsKLSAgICBpZiAoIWVnbEdldENvbmZp Z0F0dHJpYihkaXNwbGF5LCBjb25maWcsIEVHTF9ERVBUSF9TSVpFLCAmZGVwdGgpKSB7CisgICAg RUdMaW50IHZpc3VhbElkOworICAgIGlmICghZWdsR2V0Q29uZmlnQXR0cmliKGRpc3BsYXksIGNv bmZpZywgRUdMX05BVElWRV9WSVNVQUxfSUQsICZ2aXN1YWxJZCkpIHsKICAgICAgICAgZWdsRGVz dHJveUNvbnRleHQoZGlzcGxheSwgY29udGV4dCk7CiAgICAgICAgIHJldHVybiBudWxscHRyOwog ICAgIH0KIAogICAgIERpc3BsYXkqIHgxMURpc3BsYXkgPSBkb3duY2FzdDxQbGF0Zm9ybURpc3Bs YXlYMTE+KHBsYXRmb3JtRGlzcGxheSkubmF0aXZlKCk7Ci0gICAgWFVuaXF1ZVBpeG1hcCBwaXht YXAgPSBYQ3JlYXRlUGl4bWFwKHgxMURpc3BsYXksIERlZmF1bHRSb290V2luZG93KHgxMURpc3Bs YXkpLCAxLCAxLCBkZXB0aCk7CisKKyAgICBYVmlzdWFsSW5mbyB2aXN1YWxJbmZvOworICAgIHZp c3VhbEluZm8udmlzdWFsaWQgPSB2aXN1YWxJZDsKKyAgICBpbnQgbnVtVmlzdWFscyA9IDA7Cisg ICAgWFVuaXF1ZVB0cjxYVmlzdWFsSW5mbz4gdmlzdWFsSW5mb0xpc3QoWEdldFZpc3VhbEluZm8o eDExRGlzcGxheSwgVmlzdWFsSURNYXNrLCAmdmlzdWFsSW5mbywgJm51bVZpc3VhbHMpKTsKKyAg ICBpZiAoIXZpc3VhbEluZm9MaXN0IHx8ICFudW1WaXN1YWxzKSB7CisgICAgICAgIGVnbERlc3Ry b3lDb250ZXh0KGRpc3BsYXksIGNvbnRleHQpOworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAg ICB9CisKKyAgICAvLyBXZSBhcmUgdXNpbmcgVmlzdWFsSURNYXNrIHNvIHRoZXJlIG11c3QgYmUg b25seSBvbmUuCisgICAgQVNTRVJUKG51bVZpc3VhbHMgPT0gMSk7CisgICAgWFVuaXF1ZVBpeG1h cCBwaXhtYXAgPSBYQ3JlYXRlUGl4bWFwKHgxMURpc3BsYXksIERlZmF1bHRSb290V2luZG93KHgx MURpc3BsYXkpLCAxLCAxLCB2aXN1YWxJbmZvTGlzdC5nZXQoKVswXS5kZXB0aCk7CiAgICAgaWYg KCFwaXhtYXApIHsKICAgICAgICAgZWdsRGVzdHJveUNvbnRleHQoZGlzcGxheSwgY29udGV4dCk7 CiAgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIH0KIAorICAgIC8vIFNvbWUgZHJpdmVycyBm YWlsIHRvIGNyZWF0ZSB0aGUgc3VyZmFjZSBwcm9kdWNpbmcgQmFkRHJhd2FibGUgWCBlcnJvciBh bmQgdGhlIGRlZmF1bHQgWEVycm9yIGhhbmRsZXIgbm9ybWFsbHkgYWJvcnRzLgorICAgIC8vIEhv d2V2ZXIsIGlmIHRoZSBYIGVycm9yIGlzIGlnbm9yZWQsIGVnbENyZWF0ZVBpeG1hcFN1cmZhY2Uo KSBlbmRzIHVwIHJldHVybmluZyBhIHN1cmZhY2UgYW5kIHdlIGNhbiBjb250aW51ZSBjcmVhdGlu ZworICAgIC8vIHRoZSBjb250ZXh0LiBTaW5jZSB0aGlzIGlzIGFuIG9mZnNjcmVlbiBjb250ZXh0 LCBpdCBkb2Vzbid0IG1hdHRlciBpZiB0aGUgcGl4bWFwIHVzZWQgaXMgbm90IHZhbGlkIGJlY2F1 c2Ugd2UgbmV2ZXIgZG8KKyAgICAvLyBzd2FwIGJ1ZmZlcnMuIFNvLCB3ZSB1c2UgYSBjdXN0b20g WEVycm9yIGhhbmRsZXIgaGVyZSB0aGF0IGlnbm9yZXMgQmFkRHJhd2FibGUgZXJyb3JzIGFuZCBv bmx5IHdhcm5zIGFib3V0IGFueSBvdGhlcgorICAgIC8vIGVycm9ycyB3aXRob3V0IGFib3J0aW5n IGluIGFueSBjYXNlLgorICAgIFhFcnJvclRyYXBwZXIgdHJhcHBlcih4MTFEaXNwbGF5LCBYRXJy b3JUcmFwcGVyOjpQb2xpY3k6Oldhcm4sIHsgQmFkRHJhd2FibGUgfSk7CiAgICAgRUdMU3VyZmFj ZSBzdXJmYWNlID0gZWdsQ3JlYXRlUGl4bWFwU3VyZmFjZShkaXNwbGF5LCBjb25maWcsIHJlaW50 ZXJwcmV0X2Nhc3Q8RUdMTmF0aXZlUGl4bWFwVHlwZT4ocGl4bWFwLmdldCgpKSwgMCk7CiAgICAg aWYgKHN1cmZhY2UgPT0gRUdMX05PX1NVUkZBQ0UpIHsKICAgICAgICAgZWdsRGVzdHJveUNvbnRl eHQoZGlzcGxheSwgY29udGV4dCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy94MTEvWEVycm9yVHJhcHBlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy94MTEvWEVycm9yVHJhcHBlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uNmZkNGQ0OQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL3gxMS9YRXJyb3JUcmFwcGVyLmNwcApAQCAtMCwwICsxLDEwMSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5MCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJV VE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIlhFcnJvclRyYXBwZXIuaCIKKworI2lmIFBMQVRGT1JNKFgxMSkKKyNp bmNsdWRlIDxzeXMvdHlwZXMuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDx3dGYv SGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK3N0YXRpYyBIYXNoTWFwPERpc3BsYXkqLCBWZWN0b3I8WEVycm9yVHJhcHBl cio+PiYgeEVycm9yVHJhcHBlcnNNYXAoKQoreworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxI YXNoTWFwPERpc3BsYXkqLCBWZWN0b3I8WEVycm9yVHJhcHBlcio+Pj4gdHJhcHBlcnNNYXA7Cisg ICAgcmV0dXJuIHRyYXBwZXJzTWFwOworfQorCitYRXJyb3JUcmFwcGVyOjpYRXJyb3JUcmFwcGVy KERpc3BsYXkqIGRpc3BsYXksIFBvbGljeSBwb2xpY3ksIFZlY3Rvcjx1bnNpZ25lZCBjaGFyPiYm IGV4cGVjdGVkRXJyb3JzKQorICAgIDogbV9kaXNwbGF5KGRpc3BsYXkpCisgICAgLCBtX3BvbGlj eShwb2xpY3kpCisgICAgLCBtX2V4cGVjdGVkRXJyb3JzKFdURk1vdmUoZXhwZWN0ZWRFcnJvcnMp KQoreworICAgIHhFcnJvclRyYXBwZXJzTWFwKCkuYWRkKG1fZGlzcGxheSwgVmVjdG9yPFhFcnJv clRyYXBwZXIqPigpKS5pdGVyYXRvci0+dmFsdWUuYXBwZW5kKHRoaXMpOworICAgIG1fcHJldmlv dXNFcnJvckhhbmRsZXIgPSBYU2V0RXJyb3JIYW5kbGVyKFtdKERpc3BsYXkqIGRpc3BsYXksIFhF cnJvckV2ZW50KiBldmVudCkgLT4gaW50IHsKKyAgICAgICAgYXV0byBpdGVyYXRvciA9IHhFcnJv clRyYXBwZXJzTWFwKCkuZmluZChkaXNwbGF5KTsKKyAgICAgICAgaWYgKGl0ZXJhdG9yID09IHhF cnJvclRyYXBwZXJzTWFwKCkuZW5kKCkpCisgICAgICAgICAgICByZXR1cm4gMDsKKworICAgICAg ICBBU1NFUlQoIWl0ZXJhdG9yLT52YWx1ZS5pc0VtcHR5KCkpOworICAgICAgICBpdGVyYXRvci0+ dmFsdWUubGFzdCgpLT5lcnJvckV2ZW50KGV2ZW50KTsKKyAgICAgICAgcmV0dXJuIDA7CisgICAg fSk7Cit9CisKK1hFcnJvclRyYXBwZXI6On5YRXJyb3JUcmFwcGVyKCkKK3sKKyAgICBYU3luYyht X2Rpc3BsYXksIEZhbHNlKTsKKyAgICBhdXRvIGl0ZXJhdG9yID0geEVycm9yVHJhcHBlcnNNYXAo KS5maW5kKG1fZGlzcGxheSk7CisgICAgQVNTRVJUKGl0ZXJhdG9yICE9IHhFcnJvclRyYXBwZXJz TWFwKCkuZW5kKCkpOworICAgIGF1dG8qIHRyYXBwZXIgPSBpdGVyYXRvci0+dmFsdWUudGFrZUxh c3QoKTsKKyAgICBBU1NFUlRfVU5VU0VEKHRyYXBwZXIsIHRyYXBwZXIgPT0gdGhpcyk7CisgICAg aWYgKGl0ZXJhdG9yLT52YWx1ZS5pc0VtcHR5KCkpCisgICAgICAgIHhFcnJvclRyYXBwZXJzTWFw KCkucmVtb3ZlKGl0ZXJhdG9yKTsKKworICAgIFhTZXRFcnJvckhhbmRsZXIobV9wcmV2aW91c0Vy cm9ySGFuZGxlcik7Cit9CisKK3Vuc2lnbmVkIGNoYXIgWEVycm9yVHJhcHBlcjo6ZXJyb3JDb2Rl KCkgY29uc3QKK3sKKyAgICBYU3luYyhtX2Rpc3BsYXksIEZhbHNlKTsKKyAgICByZXR1cm4gbV9l cnJvckNvZGU7Cit9CisKK3ZvaWQgWEVycm9yVHJhcHBlcjo6ZXJyb3JFdmVudChYRXJyb3JFdmVu dCogZXZlbnQpCit7CisgICAgbV9lcnJvckNvZGUgPSBldmVudC0+ZXJyb3JfY29kZTsKKyAgICBp ZiAobV9wb2xpY3kgPT0gUG9saWN5OjpJZ25vcmUpCisgICAgICAgIHJldHVybjsKKworICAgIGlm IChtX2V4cGVjdGVkRXJyb3JzLmNvbnRhaW5zKG1fZXJyb3JDb2RlKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgc3RhdGljIGNvbnN0IGNoYXIgZXJyb3JGb3JtYXRTdHJpbmdbXSA9ICJUaGUgcHJv Z3JhbSB3aXRoIHBpZCAlZCByZWNlaXZlZCBhbiBYIFdpbmRvdyBTeXN0ZW0gZXJyb3IuXG4iCisg ICAgICAgICJUaGUgZXJyb3Igd2FzICclcycuXG4iCisgICAgICAgICIgIChEZXRhaWxzOiBzZXJp YWwgJWxkIGVycm9yX2NvZGUgJWQgcmVxdWVzdF9jb2RlICVkIG1pbm9yX2NvZGUgJWQpXG4iOwor ICAgIGNoYXIgZXJyb3JNZXNzYWdlWzY0XTsKKyAgICBYR2V0RXJyb3JUZXh0KG1fZGlzcGxheSwg bV9lcnJvckNvZGUsIGVycm9yTWVzc2FnZSwgNjMpOworICAgIFdURkxvZ0Fsd2F5cyhlcnJvckZv cm1hdFN0cmluZywgZ2V0cGlkKCksIGVycm9yTWVzc2FnZSwgZXZlbnQtPnNlcmlhbCwgZXZlbnQt PmVycm9yX2NvZGUsIGV2ZW50LT5yZXF1ZXN0X2NvZGUsIGV2ZW50LT5taW5vcl9jb2RlKTsKKwor ICAgIGlmIChtX3BvbGljeSA9PSBQb2xpY3k6OkNyYXNoKQorICAgICAgICBDUkFTSCgpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBQTEFURk9STShYMTEpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy94MTEvWEVycm9yVHJhcHBl ci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MveDExL1hFcnJvclRyYXBwZXIu aApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41ZDUzYjZjCi0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MveDExL1hFcnJvclRyYXBw ZXIuaApAQCAtMCwwICsxLDU0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBT LkwKKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAx LiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjcHJhZ21hIG9uY2UKKworI2lmIFBMQVRGT1JNKFgxMSkKKyNpbmNsdWRlIDxYMTEv WGxpYi5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitjbGFzcyBYRXJyb3JUcmFwcGVyIHsKK3B1YmxpYzoKKyAgICBlbnVtIGNsYXNzIFBvbGljeSB7 IElnbm9yZSwgV2FybiwgQ3Jhc2ggfTsKKyAgICBYRXJyb3JUcmFwcGVyKERpc3BsYXkqLCBQb2xp Y3kgPSBQb2xpY3k6Oklnbm9yZSwgVmVjdG9yPHVuc2lnbmVkIGNoYXI+JiYgZXhwZWN0ZWRFcnJv cnMgPSB7IH0pOworICAgIH5YRXJyb3JUcmFwcGVyKCk7CisKKyAgICB1bnNpZ25lZCBjaGFyIGVy cm9yQ29kZSgpIGNvbnN0OworCitwcml2YXRlOgorICAgIHZvaWQgZXJyb3JFdmVudChYRXJyb3JF dmVudCopOworCisgICAgRGlzcGxheSogbV9kaXNwbGF5IHsgbnVsbHB0ciB9OworICAgIFBvbGlj eSBtX3BvbGljeSB7IFBvbGljeTo6SWdub3JlIH07CisgICAgVmVjdG9yPHVuc2lnbmVkIGNoYXI+ IG1fZXhwZWN0ZWRFcnJvcnM7CisgICAgWEVycm9ySGFuZGxlciBtX3ByZXZpb3VzRXJyb3JIYW5k bGVyIHsgbnVsbHB0ciB9OworICAgIHVuc2lnbmVkIGNoYXIgbV9lcnJvckNvZGUgeyAwIH07Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBQTEFURk9STShYMTEpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFu Z2VMb2cKaW5kZXggNTU2NDI2OS4uMDA1ODc3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBA CisyMDE2LTEwLTE5ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4K KworICAgICAgICBXcm9uZyB1c2Ugb2YgRUdMX0RFUFRIX1NJWkUKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTUzNgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBYRXJyb3JUcmFwcGVyIGNsYXNzIGlu c3RlYWQgb2YgdGhlIGN1c3RvbSBYRXJyb3JIYW5kbGVyLgorCisgICAgICAgICogUGx1Z2luUHJv Y2Vzcy91bml4L1BsdWdpblByb2Nlc3NNYWluVW5peC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBs dWdpblByb2Nlc3NNYWluVW5peCk6CisKIDIwMTYtMTAtMTEgIENhcmxvcyBHYXJjaWEgQ2FtcG9z ICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQuIFVwZGF0ZSBPcHRp b25zR1RLLmNtYWtlIGFuZCBORVdTIGZvciAyLjE0LjEgcmVsZWFzZS4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1BsdWdpblByb2Nlc3MvdW5peC9QbHVnaW5Qcm9jZXNzTWFpblVuaXguY3Bw IGIvU291cmNlL1dlYktpdDIvUGx1Z2luUHJvY2Vzcy91bml4L1BsdWdpblByb2Nlc3NNYWluVW5p eC5jcHAKaW5kZXggOThiMWRiZi4uNzQ1YmI3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv UGx1Z2luUHJvY2Vzcy91bml4L1BsdWdpblByb2Nlc3NNYWluVW5peC5jcHAKKysrIGIvU291cmNl L1dlYktpdDIvUGx1Z2luUHJvY2Vzcy91bml4L1BsdWdpblByb2Nlc3NNYWluVW5peC5jcHAKQEAg LTM2LDcgKzM2LDYgQEAKICNpbmNsdWRlICJQbHVnaW5Qcm9jZXNzLmgiCiAjaW5jbHVkZSA8V2Vi Q29yZS9GaWxlU3lzdGVtLmg+CiAjaW5jbHVkZSA8c3RkbGliLmg+Ci0jaW5jbHVkZSA8d3RmL3Rl eHQvQ1N0cmluZy5oPgogCiAjaWYgUExBVEZPUk0oR1RLKQogI2luY2x1ZGUgPGd0ay9ndGsuaD4K QEAgLTQ0LDI4ICs0MywxNSBAQAogI2luY2x1ZGUgPEVjb3JlX1guaD4KICNlbmRpZgogCi1uYW1l c3BhY2UgV2ViS2l0IHsKLQogI2lmIGRlZmluZWQoWFBfVU5JWCkKKyNpbmNsdWRlIDxXZWJDb3Jl L1BsYXRmb3JtRGlzcGxheVgxMS5oPgorI2luY2x1ZGUgPFdlYkNvcmUvWEVycm9yVHJhcHBlci5o PgorI2VuZGlmCiAKLSNpZiAhTE9HX0RJU0FCTEVECi1zdGF0aWMgY29uc3QgY2hhciB4RXJyb3JT dHJpbmdbXSA9ICJUaGUgcHJvZ3JhbSAnJXMnIHJlY2VpdmVkIGFuIFggV2luZG93IFN5c3RlbSBl cnJvci5cbiIKLSAgICAiVGhpcyBwcm9iYWJseSByZWZsZWN0cyBhIGJ1ZyBpbiBhIGJyb3dzZXIg cGx1Z2luLlxuIgotICAgICJUaGUgZXJyb3Igd2FzICclcycuXG4iCi0gICAgIiAgKERldGFpbHM6 IHNlcmlhbCAlbGQgZXJyb3JfY29kZSAlZCByZXF1ZXN0X2NvZGUgJWQgbWlub3JfY29kZSAlZClc biI7Ci0jZW5kaWYgLy8gIUxPR19ESVNBQkxFRAotCi1zdGF0aWMgQ1N0cmluZyBwcm9ncmFtTmFt ZTsKLQotc3RhdGljIGludCB3ZWJraXRYRXJyb3IoRGlzcGxheSogeGRpc3BsYXksIFhFcnJvckV2 ZW50KiBlcnJvcikKLXsKLSAgICBjaGFyIGVycm9yTWVzc2FnZVs2NF07Ci0gICAgWEdldEVycm9y VGV4dCh4ZGlzcGxheSwgZXJyb3ItPmVycm9yX2NvZGUsIGVycm9yTWVzc2FnZSwgNjMpOwotCi0g ICAgTE9HKFBsdWdpbnMsIHhFcnJvclN0cmluZywgcHJvZ3JhbU5hbWUuZGF0YSgpLCBlcnJvck1l c3NhZ2UsIGVycm9yLT5zZXJpYWwsIGVycm9yLT5lcnJvcl9jb2RlLCBlcnJvci0+cmVxdWVzdF9j b2RlLCBlcnJvci0+bWlub3JfY29kZSk7CituYW1lc3BhY2UgV2ViS2l0IHsKIAotICAgIHJldHVy biAwOwotfQorI2lmIGRlZmluZWQoWFBfVU5JWCkKK3N0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8V2Vi Q29yZTo6WEVycm9yVHJhcHBlcj4geEVycm9yVHJhcHBlcjsKICNlbmRpZiAvLyBYUF9VTklYCiAK IGNsYXNzIFBsdWdpblByb2Nlc3NNYWluIGZpbmFsOiBwdWJsaWMgQ2hpbGRQcm9jZXNzTWFpbkJh c2UgewpAQCAtOTgsOCArODQsMTAgQEAgcHVibGljOgogI2VuZGlmCiAKICNpZiBkZWZpbmVkKFhQ X1VOSVgpCi0gICAgICAgIHByb2dyYW1OYW1lID0gV2ViQ29yZTo6cGF0aEdldEZpbGVOYW1lKGFy Z3ZbMF0pLnV0ZjgoKTsKLSAgICAgICAgWFNldEVycm9ySGFuZGxlcih3ZWJraXRYRXJyb3IpOwor ICAgICAgICBpZiAoV2ViQ29yZTo6UGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5KCkudHlw ZSgpID09IFdlYkNvcmU6OlBsYXRmb3JtRGlzcGxheTo6VHlwZTo6WDExKSB7CisgICAgICAgICAg ICBhdXRvKiBkaXNwbGF5ID0gZG93bmNhc3Q8V2ViQ29yZTo6UGxhdGZvcm1EaXNwbGF5WDExPihX ZWJDb3JlOjpQbGF0Zm9ybURpc3BsYXk6OnNoYXJlZERpc3BsYXkoKSkubmF0aXZlKCk7CisgICAg ICAgICAgICB4RXJyb3JUcmFwcGVyID0gc3RkOjptYWtlX3VuaXF1ZTxXZWJDb3JlOjpYRXJyb3JU cmFwcGVyPihkaXNwbGF5LCBXZWJDb3JlOjpYRXJyb3JUcmFwcGVyOjpQb2xpY3k6Oldhcm4pOwor ICAgICAgICB9CiAjZW5kaWYKIAogICAgICAgICBtX3BhcmFtZXRlcnMuZXh0cmFJbml0aWFsaXph dGlvbkRhdGEuYWRkKCJwbHVnaW4tcGF0aCIsIGFyZ3ZbMl0pOwo=