159928 2016-07-19 10:53:07 -0700 [GStreamer] Support a direct GPU-to-GPU copy of video textures to WebGL 2016-09-22 05:46:16 -0700 1 1 1 Unclassified WebKit WebKitGTK Other Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 olivier.blin webkit-unassigned bugs-noreply commit-queue dino eric.carlson jer.noble loic.yhuel magomez mcatanzaro pnormand yoon zan oldest_to_newest 1212428 0 olivier.blin 2016-07-19 10:53:07 -0700 Copy of GStreamer video frames to WebGL textures is not accelerated, since copyVideoTextureToPlatformTexture() is not implemented. Currently, WebGLRenderingContextBase::texImage2D(HTMLVideoElement) goes through a slow software paint() that wraps the video frame into a cairo surface (ImageGStreamer) and downloads it to draw to the image cache context, which gets copied again, and uploaded again to an OpenGL texture. Instead, GPU-to-GPU copy should be implemented in copyVideoTextureToPlatformTexture(), like Apple port are doing with VideoTextureCopierCV. 1212459 1 284029 olivier.blin 2016-07-19 12:21:20 -0700 Created attachment 284029 Patch 1212465 2 olivier.blin 2016-07-19 12:32:24 -0700 (In reply to comment #1) > Created attachment 284029 [details] > Patch Posting for comments. This patch implements copyVideoTextureToPlatformTexture() for the GStreamer media player backend, to do GPU-to-GPU copy. This copies the VideoTextureCopierCV code from Apple backends, removing Apple specifics. If this approach is ok, the patch should be reworked to properly extract VideoTextureCopier, by inlining the few remaining VideoTextureCopierCV specifics in MediaPlayerPrivateAVFoundationObjC. Though, Miguel already has concerns about this, since it does not support the video rotation flags. Miguel suggests to reuse cairo_gl_surface_create_for_texture() instead, like in nativeImageForCurrentTime(), and let cairo do the texture copy and rotating if needed. 1212693 3 pnormand 2016-07-20 01:31:13 -0700 Adding some Apple Media experts as this patch intends to refactor Apple code. 1212699 4 magomez 2016-07-20 01:57:25 -0700 > Though, Miguel already has concerns about this, since it does not support > the video rotation flags. > Miguel suggests to reuse cairo_gl_surface_create_for_texture() instead, like > in nativeImageForCurrentTime(), and let cairo do the texture copy and > rotating if needed. As I explained to you, we need to take into consideration the video orientation flag when we are rendering video frames with accelerated composition enabled. This is because the frames we get from the video are not following the video orientation in the acc composition case, and we apply the appropriate rotation when painting them. This is done in the video element, in the canvas, and needs to be done in webgl as well. Also, on a fast look to the patch I realized that you are not using the appropriate mutex when accessing the video sample. 1212737 5 olivier.blin 2016-07-20 08:13:11 -0700 (In reply to comment #4) > > Though, Miguel already has concerns about this, since it does not support > > the video rotation flags. > > Miguel suggests to reuse cairo_gl_surface_create_for_texture() instead, like > > in nativeImageForCurrentTime(), and let cairo do the texture copy and > > rotating if needed. > > As I explained to you, we need to take into consideration the video > orientation flag when we are rendering video frames with accelerated > composition enabled. This is because the frames we get from the video are > not following the video orientation in the acc composition case, and we > apply the appropriate rotation when painting them. This is done in the video > element, in the canvas, and needs to be done in webgl as well. Yep, I posted my current state of work for reference, I will rework as you advised. > Also, on a fast look to the patch I realized that you are not using the > appropriate mutex when accessing the video sample. Ok, isn't one needed in the GSTREAMER_GL case of paintToTextureMapper() as well? Thanks for your input 1220836 6 286293 olivier.blin 2016-08-17 03:09:16 -0700 Created attachment 286293 Patch new version using cairo, sharing code with nativeImageForCurrentTime() 1220837 7 olivier.blin 2016-08-17 03:10:56 -0700 (In reply to comment #6) > Created attachment 286293 [details] > Patch > > new version using cairo, sharing code with nativeImageForCurrentTime() Not sure if the following calls should be repeated, we can probably just do this once in the caller: context->makeContextCurrent(); cairo_gl_device_set_thread_aware(device, FALSE); 1228033 8 mcatanzaro 2016-09-08 20:43:57 -0700 Miguel, Philippe, can you review it again? 1229625 9 288829 olivier.blin 2016-09-14 10:28:29 -0700 Created attachment 288829 Patch 1229628 10 olivier.blin 2016-09-14 10:30:52 -0700 (In reply to comment #9) > Created attachment 288829 [details] > Patch This is rebased on trunk, with improvements by Loïc Yhuel: - save and restore TEXTURE_MIN/MAG_FILTER after cairo_gl_surface_create_for_texture textures filters, otherwise cairo overwrites GL_LINEAR with GL_NEAREST, and the video gets pixelated - remove useless texture parameters 1231584 11 288829 magomez 2016-09-20 02:58:16 -0700 Comment on attachment 288829 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=288829&action=review Sorry for taking so long, I've been quite busy. The approach is fine, just a couple of suggested improvements. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:683 > if (m_usingFallbackVideoSink) This check should be at the beginning of nativeImageForCurrentTime() and copyVideoTextureToPlatformTexture(). We can save some useless operations if we are not using opengl. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:755 > + GLContext* glContext = GLContext::sharingContext(); You'll need to change this with GLContext* context = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:756 > + glContext->makeContextCurrent(); No need to make the sharing context current here, as context->bindTexture() below will change it again. Cairo will make it current when needed. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:775 > + if (!paintToCairoSurface(outputSurface)) Pass the cairo device and the videoInfo to paintToCairoSurface() > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:793 > + GLContext* context = GLContext::sharingContext(); You'll need to change this with GLContext* context = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:804 > + if (!paintToCairoSurface(rotatedSurface)) Pass the cairo device and the videoInfo to paintToCairoSurface() 1232040 12 289443 olivier.blin 2016-09-21 05:09:38 -0700 Created attachment 289443 Patch This addresses issues listed in comment 11. 1232066 13 289443 magomez 2016-09-21 07:55:22 -0700 Comment on attachment 289443 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=289443&action=review Besides one small comment the rest looks good to me. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:710 > GLContext* context = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > context->makeContextCurrent(); Now that the cairo device is a parameter, these 2 lines are not needed. The appropriate context will be set by cairo as well. 1232100 14 289463 olivier.blin 2016-09-21 10:03:54 -0700 Created attachment 289463 Patch This addresses the last issue listed in comment 13. 1232356 15 289463 cgarcia 2016-09-22 01:04:13 -0700 Comment on attachment 289463 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=289463&action=review > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:700 > +bool MediaPlayerPrivateGStreamerBase::paintToCairoSurface(RefPtr<cairo_surface_t> outputSurface, cairo_device_t* device, GstVideoInfo* videoInfo) I don't think you need to pass the smart pointer to this function, and in that case I would pass a reference instead of a copy, but I think you can simply pass the pointer. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:702 > + // m_sampleMutex should be locked by the caller I would move this comment before the function, saying something like: // This should be called with the sample mutex locked. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:710 > - IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(videoInfo), GST_VIDEO_INFO_HEIGHT(videoInfo)); Both callers do this, maybe you could pass this as a const reference. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:713 > IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; Ditto. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:773 > + GLContext* glContext = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > + cairo_device_t* device = glContext->cairoDevice(); > + > + // Thread-awareness is a huge performance hit on non-Intel drivers. > + cairo_gl_device_set_thread_aware(device, FALSE); > + > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > + IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; > + Don't you need to make the context current in this case? > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:813 > + GstVideoInfo videoInfo; > + WTF::GMutexLocker<GMutex> lock(m_sampleMutex); > + if (!getSampleVideoInfo(m_sample.get(), videoInfo)) > + return nullptr; > + > + GLContext* context = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > + context->makeContextCurrent(); > + cairo_device_t* device = context->cairoDevice(); > + > + // Thread-awareness is a huge performance hit on non-Intel drivers. > + cairo_gl_device_set_thread_aware(device, FALSE); > + > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > + IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; All this is mostly duplicated code, could we move it to a helper function? maybe a function that prepares the context and returns the GLContext as return value, and video info, and sizes as output parameters > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:119 > + bool paintToCairoSurface(RefPtr<cairo_surface_t> outputSurface, cairo_device_t*, GstVideoInfo*); This should be private. 1232362 16 magomez 2016-09-22 01:16:10 -0700 Awesome, I was just about to ping a reviewer to give it a look and you were faster Carlos. Also a reply to one of your comments: > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:773 > > + GLContext* glContext = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > > + cairo_device_t* device = glContext->cairoDevice(); > > + > > + // Thread-awareness is a huge performance hit on non-Intel drivers. > > + cairo_gl_device_set_thread_aware(device, FALSE); > > + > > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > > + IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; > > + > > Don't you need to make the context current in this case? > Making the context current in that case is not needed. Setting thread awareness is just a flag, doesn't need the context to be current, and also the context->bindTexture() call three lines below will make current the weblg context again. 1232384 17 olivier.blin 2016-09-22 02:59:57 -0700 (In reply to comment #15) > Comment on attachment 289463 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=289463&action=review > > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:700 > > +bool MediaPlayerPrivateGStreamerBase::paintToCairoSurface(RefPtr<cairo_surface_t> outputSurface, cairo_device_t* device, GstVideoInfo* videoInfo) > > I don't think you need to pass the smart pointer to this function, and in > that case I would pass a reference instead of a copy, but I think you can > simply pass the pointer. Right, I have also simplified the callers, the WebGL case does not need a smart pointer at all. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:702 > > + // m_sampleMutex should be locked by the caller > > I would move this comment before the function, saying something like: // > This should be called with the sample mutex locked. > > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:710 > > - IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(videoInfo), GST_VIDEO_INFO_HEIGHT(videoInfo)); > > Both callers do this, maybe you could pass this as a const reference. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:713 > > IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; > > Ditto. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:773 > > + GLContext* glContext = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > > + cairo_device_t* device = glContext->cairoDevice(); > > + > > + // Thread-awareness is a huge performance hit on non-Intel drivers. > > + cairo_gl_device_set_thread_aware(device, FALSE); > > + > > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > > + IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; > > + > > Don't you need to make the context current in this case? See Miguel's answer. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:813 > > + GstVideoInfo videoInfo; > > + WTF::GMutexLocker<GMutex> lock(m_sampleMutex); > > + if (!getSampleVideoInfo(m_sample.get(), videoInfo)) > > + return nullptr; > > + > > + GLContext* context = PlatformDisplay::sharedDisplayForCompositing().sharingGLContext(); > > + context->makeContextCurrent(); > > + cairo_device_t* device = context->cairoDevice(); > > + > > + // Thread-awareness is a huge performance hit on non-Intel drivers. > > + cairo_gl_device_set_thread_aware(device, FALSE); > > + > > + IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); > > + IntSize rotatedSize = m_videoSourceOrientation.usesWidthAsHeight() ? size.transposedSize() : size; > > All this is mostly duplicated code, could we move it to a helper function? > maybe a function that prepares the context and returns the GLContext as > return value, and video info, and sizes as output parameters I am not sure it is worth it, it is not much more readable after being extracted, but I will do so in the next patch proposal. Also, the cairo_device needs to be kept around as well. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:119 > > + bool paintToCairoSurface(RefPtr<cairo_surface_t> outputSurface, cairo_device_t*, GstVideoInfo*); > > This should be private. Yes, moved it to together with other protected methods. Thanks for your feedback! 1232385 18 289542 olivier.blin 2016-09-22 03:01:17 -0700 Created attachment 289542 Patch This addresses the last issue listed in comment 13. 1232387 19 289542 cgarcia 2016-09-22 03:28:14 -0700 Comment on attachment 289542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=289542&action=review > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:701 > +GLContext* MediaPlayerPrivateGStreamerBase::prepareContextForCairoPaint(cairo_device_t*& device, GstVideoInfo& videoInfo, IntSize& size, IntSize& rotatedSize) We don't need to return the device, you can get it from the context. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:710 > + cairo_gl_device_set_thread_aware(device, FALSE); You can do cairo_gl_device_set_thread_aware(glContext->cairoDevice(), FALSE); directly. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:773 > + cairo_device_t* device; So, this is not needed. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:778 > + if (!prepareContextForCairoPaint(device, videoInfo, size, rotatedSize)) > + return false; Get the context here and use it below to pass the cairo device to paintToCairoSurface() > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:784 > + // cairo_gl_surface_create_for_texture sets these parameters to GL_NEAREST, so we need to backup them Nit: finish comments with '.' > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:806 > + cairo_device_t* device; Same here. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:813 > + GLContext* context = prepareContextForCairoPaint(device, videoInfo, size, rotatedSize); > + if (!context) > + return nullptr; > + context->makeContextCurrent(); I still think that making the context current in prepareContextForCairoPaint wouldn't hurt even if it's not needed in the other case. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:819 > + cairo_surface_t* rotatedSurface = cairo_gl_surface_create(device, CAIRO_CONTENT_COLOR_ALPHA, rotatedSize.width(), rotatedSize.height()); > + if (!paintToCairoSurface(rotatedSurface, device, videoInfo, size, rotatedSize)) > + return nullptr; > + > + return adoptRef(rotatedSurface); The smart pointer was correct here, now you are leaking the surface if paintToCairoSurface() returns false. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:136 > + bool paintToCairoSurface(cairo_surface_t* outputSurface, cairo_device_t*, GstVideoInfo&, const IntSize&, const IntSize&); outputSurface can be omitted in this case 1232395 20 olivier.blin 2016-09-22 04:29:51 -0700 (In reply to comment #19) > Comment on attachment 289542 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=289542&action=review > > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:701 > > +GLContext* MediaPlayerPrivateGStreamerBase::prepareContextForCairoPaint(cairo_device_t*& device, GstVideoInfo& videoInfo, IntSize& size, IntSize& rotatedSize) > > We don't need to return the device, you can get it from the context. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:710 > > + cairo_gl_device_set_thread_aware(device, FALSE); > > You can do cairo_gl_device_set_thread_aware(glContext->cairoDevice(), > FALSE); directly. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:773 > > + cairo_device_t* device; > > So, this is not needed. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:778 > > + if (!prepareContextForCairoPaint(device, videoInfo, size, rotatedSize)) > > + return false; > > Get the context here and use it below to pass the cairo device to > paintToCairoSurface() Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:784 > > + // cairo_gl_surface_create_for_texture sets these parameters to GL_NEAREST, so we need to backup them > > Nit: finish comments with '.' Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:806 > > + cairo_device_t* device; > > Same here. Ok > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:813 > > + GLContext* context = prepareContextForCairoPaint(device, videoInfo, size, rotatedSize); > > + if (!context) > > + return nullptr; > > + context->makeContextCurrent(); > > I still think that making the context current in prepareContextForCairoPaint > wouldn't hurt even if it's not needed in the other case. Done as well > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:819 > > + cairo_surface_t* rotatedSurface = cairo_gl_surface_create(device, CAIRO_CONTENT_COLOR_ALPHA, rotatedSize.width(), rotatedSize.height()); > > + if (!paintToCairoSurface(rotatedSurface, device, videoInfo, size, rotatedSize)) > > + return nullptr; > > + > > + return adoptRef(rotatedSurface); > > The smart pointer was correct here, now you are leaking the surface if > paintToCairoSurface() returns false. That's right, I will fix for both cases. Thanks for spotting this. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:136 > > + bool paintToCairoSurface(cairo_surface_t* outputSurface, cairo_device_t*, GstVideoInfo&, const IntSize&, const IntSize&); > > outputSurface can be omitted in this case Ok 1232399 21 olivier.blin 2016-09-22 04:33:52 -0700 This change also fixes bug #159621, I'll add the following in ChangeLog: + Doing this also fixes bug #159621: red and blue colors were + swapped in video rendered through WebGL with GSTREAMER_GL enabled. 1232400 22 289547 olivier.blin 2016-09-22 04:35:23 -0700 Created attachment 289547 Patch 1232404 23 289547 cgarcia 2016-09-22 05:13:52 -0700 Comment on attachment 289547 Patch Excellent! 1232409 24 289547 commit-queue 2016-09-22 05:46:10 -0700 Comment on attachment 289547 Patch Clearing flags on attachment: 289547 Committed r206257: <http://trac.webkit.org/changeset/206257> 1232410 25 commit-queue 2016-09-22 05:46:16 -0700 All reviewed patches have been landed. Closing bug. 284029 2016-07-19 12:21:20 -0700 2016-08-17 03:09:06 -0700 Patch bug-159928-20160719212024.patch text/plain 18813 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjAyODUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODczNjI1ZGRjMzY1Yjcw Mzc1NjJkMDdmZDlkNzRmZDE2NzNkNGUwMi4uMjFlZTU4Nzg1MDFlOTAzNGQzNzZiMmUwYzNmNTVm ZTdhNDIyNGUxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDE2LTA3LTE5ICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvIGEKKyAgICAgICAgY2Fp cm8gc3VyZmFjZSAoSW1hZ2VHU3RyZWFtZXIpLCBkb3dubG9hZGluZyBpdCB0byBkcmF3IHRvIHRo ZQorICAgICAgICBpbWFnZSBjYWNoZSBjb250ZXh0LCBjb3B5aW5nIGl0IGFnYWluIGluIHNvZnR3 YXJlLCBhbmQgdXBsb2FkaW5nCisgICAgICAgIGl0IGJhY2sgdG8gYW4gT3BlbkdMIHRleHR1cmUu CisKKyAgICAgICAgVGhpcyBwYXRjaCBpbXBsZW1lbnRzIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRm b3JtVGV4dHVyZSgpIGZvciB0aGUKKyAgICAgICAgR1N0cmVhbWVyIG1lZGlhIHBsYXllciBiYWNr ZW5kLCB0byBkbyBHUFUtdG8tR1BVIGNvcHkuCisKKyAgICAgICAgVGhpcyBjb3BpZXMgdGhlIFZp ZGVvVGV4dHVyZUNvcGllckNWIGNvZGUgZnJvbSBBcHBsZSBiYWNrZW5kcywKKyAgICAgICAgcmVt b3ZpbmcgQXBwbGUgc3BlY2lmaWNzLgorCisgICAgICAgIFRPRE86IHByb3Blcmx5IGV4dHJhY3Qg VmlkZW9UZXh0dXJlQ29waWVyLCBieSBpbmxpbmluZyB0aGUgZmV3CisgICAgICAgIHJlbWFpbmlu ZyBWaWRlb1RleHR1cmVDb3BpZXJDViBzcGVjaWZpY3MgaW4KKyAgICAgICAgTWVkaWFQbGF5ZXJQ cml2YXRlQVZGb3VuZGF0aW9uT2JqQy4KKworICAgICAgICAqIENNYWtlTGlzdHMudHh0OgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1ZpZGVvVGV4dHVyZUNvcGllci5jcHA6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6VmlkZW9UZXh0dXJlQ29waWVyOjpWaWRlb1RleHR1cmVDb3BpZXIp OgorICAgICAgICAoV2ViQ29yZTo6VmlkZW9UZXh0dXJlQ29waWVyOjp+VmlkZW9UZXh0dXJlQ29w aWVyKToKKyAgICAgICAgKFdlYkNvcmU6OmVudW1Ub1N0cmluZ01hcCk6CisgICAgICAgIChXZWJD b3JlOjpWaWRlb1RleHR1cmVDb3BpZXI6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVy ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvVmlkZW9UZXh0dXJlQ29waWVyLmg6IEFk ZGVkLgorICAgICAgICAoV2ViQ29yZTo6VmlkZW9UZXh0dXJlQ29waWVyOjpjb250ZXh0KToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0 cmVhbWVyQmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3Ry ZWFtZXJCYXNlOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgorICAgICAgICAq IHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJC YXNlLmg6CisKIDIwMTYtMDctMDYgIE9saXZpZXIgQmxpbiAgPG9saXZpZXIuYmxpbkBzb2Z0YXRo b21lLmNvbT4KIAogICAgICAgICBFeHBvc2UgY3Jvc3NPcmlnaW4gYXR0cmlidXRlIGFzIGEgc3Rh dGljIHByb3BlcnR5IGluIEhUTUxNZWRpYUVsZW1lbnQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL0NNYWtlTGlzdHMudHh0IGIvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKaW5kZXgg OTVlYjljODg1ZjRmNjZlZjE2NTA2MjE1MTI4N2FhMzU1MjU5YzVmZi4uODMwYmNjM2E4NzBlZDY4 ZGM0OWE0MzdlNzkzODJlY2UzN2FmNDIzNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ01h a2VMaXN0cy50eHQKKysrIGIvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKQEAgLTIyNTEs NiArMjI1MSw3IEBAIHNldChXZWJDb3JlX1NPVVJDRVMKICAgICBwbGF0Zm9ybS9ncmFwaGljcy9T dHJpbmdUcnVuY2F0b3IuY3BwCiAgICAgcGxhdGZvcm0vZ3JhcGhpY3MvU3Vycm9nYXRlUGFpckF3 YXJlVGV4dEl0ZXJhdG9yLmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1RleHRSdW4uY3BwCisg ICAgcGxhdGZvcm0vZ3JhcGhpY3MvVmlkZW9UZXh0dXJlQ29waWVyLmNwcAogICAgIHBsYXRmb3Jt L2dyYXBoaWNzL1dPRkZGaWxlRm9ybWF0LmNwcAogICAgIHBsYXRmb3JtL2dyYXBoaWNzL1dpZHRo SXRlcmF0b3IuY3BwCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1ZpZGVvVGV4dHVyZUNvcGllci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9WaWRlb1RleHR1cmVDb3BpZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM3ZDQzZmVjY2UwM2M3MDQ1 MmI4OTg3MjYwNTBjMTQ5NDQ4MDZmN2IKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9WaWRlb1RleHR1cmVDb3BpZXIuY3BwCkBAIC0wLDAgKzEsMTk1 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqIAorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAq IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJWaWRlb1Rl eHR1cmVDb3BpZXIuaCIKKworI2luY2x1ZGUgIkxvZ2dpbmcuaCIKKyNpbmNsdWRlIDx3dGYvTmV2 ZXJEZXN0cm95ZWQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitWaWRlb1RleHR1cmVDb3Bp ZXI6OlZpZGVvVGV4dHVyZUNvcGllcihHcmFwaGljc0NvbnRleHQzRCYgY29udGV4dCkKKyAgICA6 IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9yZWFkRnJhbWVidWZmZXIoY29udGV4dC5jcmVh dGVGcmFtZWJ1ZmZlcigpKQoreworfQorCitWaWRlb1RleHR1cmVDb3BpZXI6On5WaWRlb1RleHR1 cmVDb3BpZXIoKQoreworICAgIG1fY29udGV4dC0+ZGVsZXRlRnJhbWVidWZmZXIobV9yZWFkRnJh bWVidWZmZXIpOworfQorCisjaWYgIUxPR19ESVNBQkxFRAorCisjZGVmaW5lIFNUUklOR0lGWV9Q QUlSKGUpIGUsICNlCitzdGF0aWMgc3RkOjptYXA8dWludDMyX3QsIGNvbnN0IGNoYXIqPiYgZW51 bVRvU3RyaW5nTWFwKCkKK3sKKyAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8c3RkOjptYXA8dWlu dDMyX3QsIGNvbnN0IGNoYXIqPj4gbWFwOworICAgIGlmIChtYXAuZ2V0KCkuZW1wdHkoKSkgewor ICAgICAgICBzdGQ6Om1hcDx1aW50MzJfdCwgY29uc3QgY2hhcio+IHN0cmluZ01hcDsKKyAgICAg ICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkdCKSk7CisgICAgICAgIG1h cC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JHQkEpKTsKKyAgICAgICAgbWFwLmdl dCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfTFVNSU5BTkNFX0FMUEhBKSk7CisgICAgICAg IG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX0xVTUlOQU5DRSkpOworICAgICAg ICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9BTFBIQSkpOworICAgICAgICBt YXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SOCkpOworICAgICAgICBtYXAuZ2V0 KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SMTZGKSk7CisgICAgICAgIG1hcC5nZXQoKS5l bXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1IzMkYpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxh Y2UoU1RSSU5HSUZZX1BBSVIoR0xfUjhVSSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShT VFJJTkdJRllfUEFJUihHTF9SOEkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5H SUZZX1BBSVIoR0xfUjE2VUkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZ X1BBSVIoR0xfUjE2SSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJ UihHTF9SMzJVSSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihH TF9SMzJJKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JH OCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzE2Rikp OworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzMyRikpOwor ICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzhVSSkpOworICAg ICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzhJKSk7CisgICAgICAg IG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JHMTZVSSkpOworICAgICAgICBt YXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzE2SSkpOworICAgICAgICBtYXAu Z2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9SRzMyVUkpKTsKKyAgICAgICAgbWFwLmdl dCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkczMkkpKTsKKyAgICAgICAgbWFwLmdldCgp LmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkdCOCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1w bGFjZShTVFJJTkdJRllfUEFJUihHTF9TUkdCOCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFj ZShTVFJJTkdJRllfUEFJUihHTF9SR0JBOCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShT VFJJTkdJRllfUEFJUihHTF9TUkdCOF9BTFBIQTgpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxh Y2UoU1RSSU5HSUZZX1BBSVIoR0xfUkdCQTQpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2Uo U1RSSU5HSUZZX1BBSVIoR0xfUkdCMTBfQTIpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2Uo U1RSSU5HSUZZX1BBSVIoR0xfREVQVEhfQ09NUE9ORU5UMTYpKTsKKyAgICAgICAgbWFwLmdldCgp LmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfREVQVEhfQ09NUE9ORU5UMjQpKTsKKyAgICAgICAg bWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfREVQVEhfQ09NUE9ORU5UMzJGKSk7 CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX0RFUFRIMjRfU1RF TkNJTDgpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfREVQ VEgzMkZfU1RFTkNJTDgpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BB SVIoR0xfUkdCKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdM X1JHQkEpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfTFVN SU5BTkNFX0FMUEhBKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlS KEdMX0xVTUlOQU5DRSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJ UihHTF9BTFBIQSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihH TF9SRUQpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkdf SU5URUdFUikpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9E RVBUSF9TVEVOQ0lMKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlS KEdMX1VOU0lHTkVEX0JZVEUpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZ X1BBSVIoR0xfVU5TSUdORURfU0hPUlRfNV82XzUpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxh Y2UoU1RSSU5HSUZZX1BBSVIoR0xfVU5TSUdORURfU0hPUlRfNF80XzRfNCkpOworICAgICAgICBt YXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9VTlNJR05FRF9TSE9SVF81XzVfNV8x KSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX0JZVEUpKTsK KyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfSEFMRl9GTE9BVCkp OworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9GTE9BVCkpOwor ICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9VTlNJR05FRF9TSE9S VCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9TSE9SVCkp OworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9VTlNJR05FRF9J TlQpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfSU5UKSk7 CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1VOU0lHTkVEX0lO VF8yXzEwXzEwXzEwX1JFVikpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllf UEFJUihHTF9VTlNJR05FRF9JTlRfMjRfOCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShT VFJJTkdJRllfUEFJUihHTF9GTE9BVF8zMl9VTlNJR05FRF9JTlRfMjRfOF9SRVYpKTsKKworI2lm IFBMQVRGT1JNKElPUykKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIo R0xfUkVEX0lOVEVHRVIpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BB SVIoR0xfUkdCX0lOVEVHRVIpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZ X1BBSVIoR0xfUkc4X1NOT1JNKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lG WV9QQUlSKEdMX1JHQjU2NSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllf UEFJUihHTF9SR0I4X1NOT1JNKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lG WV9QQUlSKEdMX1IxMUZfRzExRl9CMTBGKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNU UklOR0lGWV9QQUlSKEdMX1JHQjlfRTUpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RS SU5HSUZZX1BBSVIoR0xfUkdCMTZGKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklO R0lGWV9QQUlSKEdMX1JHQjMyRikpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJ RllfUEFJUihHTF9SR0I4VUkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZ X1BBSVIoR0xfUkdCOEkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BB SVIoR0xfUkdCMTZVSSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJ UihHTF9SR0IxNkkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIo R0xfUkdCMzJVSSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihH TF9SR0IzMkkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xf UkdCQThfU05PUk0pKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIo R0xfUkdCQTE2RikpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihH TF9SR0JBMzJGKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdM X1JHQkE4VUkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xf UkdCQThJKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JH QjEwX0EyVUkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xf UkdCQTE2VUkpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xf UkdCQTE2SSkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihHTF9S R0JBMzJJKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JH QkEzMlVJKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX1JH QjVfQTEpKTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkcp KTsKKyAgICAgICAgbWFwLmdldCgpLmVtcGxhY2UoU1RSSU5HSUZZX1BBSVIoR0xfUkdCQV9JTlRF R0VSKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBsYWNlKFNUUklOR0lGWV9QQUlSKEdMX0RFUFRI X0NPTVBPTkVOVCkpOworICAgICAgICBtYXAuZ2V0KCkuZW1wbGFjZShTVFJJTkdJRllfUEFJUihH TF9VTlNJR05FRF9JTlRfMTBGXzExRl8xMUZfUkVWKSk7CisgICAgICAgIG1hcC5nZXQoKS5lbXBs YWNlKFNUUklOR0lGWV9QQUlSKEdMX1VOU0lHTkVEX0lOVF81XzlfOV85X1JFVikpOworI2VuZGlm CisgICAgfQorICAgIHJldHVybiBtYXAuZ2V0KCk7Cit9CisKKyNlbmRpZgorCitib29sIFZpZGVv VGV4dHVyZUNvcGllcjo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKFBsYXRmb3Jt M0RPYmplY3QgdmlkZW9UZXh0dXJlLCBHQzNEZW51bSB2aWRlb1RleHR1cmVUYXJnZXQsIHNpemVf dCB3aWR0aCwgc2l6ZV90IGhlaWdodCwgUGxhdGZvcm0zRE9iamVjdCBvdXRwdXRUZXh0dXJlLCBH QzNEZW51bSBvdXRwdXRUYXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsRm9y bWF0LCBHQzNEZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5cGUsIGJvb2wgcHJlbXVsdGlwbHlBbHBo YSwgYm9vbCBmbGlwWSkKK3sKKyAgICBpZiAoZmxpcFkgfHwgcHJlbXVsdGlwbHlBbHBoYSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgTE9HKE1lZGlhLCAiVmlkZW9UZXh0dXJlQ29waWVy Ojpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoJXApIC0gaW50ZXJuYWxGb3JtYXQ6 ICVzLCBmb3JtYXQ6ICVzLCB0eXBlOiAlcyIsIHRoaXMsIGVudW1Ub1N0cmluZ01hcCgpW2ludGVy bmFsRm9ybWF0XSwgZW51bVRvU3RyaW5nTWFwKClbZm9ybWF0XSwgZW51bVRvU3RyaW5nTWFwKClb dHlwZV0pOworCisgICAgLy8gU2F2ZSB0aGUgb3JpZ2lhbCBib3VuZCB0ZXh0dXJlICYgZnJhbWVi dWZmZXIgbmFtZXMgc28gd2UgY2FuIHJlLWJpbmQgdGhlbSBhZnRlciBjb3B5aW5nIHRoZSB2aWRl byB0ZXh0dXJlLgorICAgIEdDM0RpbnQgYm91bmRUZXh0dXJlID0gMDsKKyAgICBHQzNEaW50IGJv dW5kUmVhZEZyYW1lYnVmZmVyID0gMDsKKyAgICBtX2NvbnRleHQtPmdldEludGVnZXJ2KEdyYXBo aWNzQ29udGV4dDNEOjpURVhUVVJFX0JJTkRJTkdfMkQsICZib3VuZFRleHR1cmUpOworICAgIG1f Y29udGV4dC0+Z2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6OlJFQURfRlJBTUVCVUZGRVJf QklORElORywgJmJvdW5kUmVhZEZyYW1lYnVmZmVyKTsKKworICAgIG1fY29udGV4dC0+YmluZFRl eHR1cmUodmlkZW9UZXh0dXJlVGFyZ2V0LCB2aWRlb1RleHR1cmUpOworICAgIG1fY29udGV4dC0+ dGV4UGFyYW1ldGVyaShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlRFWFRVUkVfTUlOX0ZJTFRFUiwgR3JhcGhpY3NDb250ZXh0M0Q6OkxJTkVBUik7Cisg ICAgbV9jb250ZXh0LT50ZXhQYXJhbWV0ZXJmKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJE LCBHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV9XUkFQX1MsIEdyYXBoaWNzQ29udGV4dDNEOjpD TEFNUF9UT19FREdFKTsKKyAgICBtX2NvbnRleHQtPnRleFBhcmFtZXRlcmYoR3JhcGhpY3NDb250 ZXh0M0Q6OlRFWFRVUkVfMkQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX1dSQVBfVCwgR3Jh cGhpY3NDb250ZXh0M0Q6OkNMQU1QX1RPX0VER0UpOworCisgICAgLy8gTWFrZSB0aGF0IGZyYW1l YnVmZmVyIHRoZSByZWFkIHNvdXJjZSBmcm9tIHdoaWNoIGRyYXdpbmcgY29tbWFuZHMgd2lsbCBy ZWFkIHZveGVscy4KKyAgICBtX2NvbnRleHQtPmJpbmRGcmFtZWJ1ZmZlcihHcmFwaGljc0NvbnRl eHQzRDo6UkVBRF9GUkFNRUJVRkZFUiwgbV9yZWFkRnJhbWVidWZmZXIpOworCisgICAgLy8gQWxs b2NhdGUgdW5pbml0aWFsaXplZCBtZW1vcnkgZm9yIHRoZSBvdXRwdXQgdGV4dHVyZS4KKyAgICBt X2NvbnRleHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0VGV4dHVyZSk7CisgICAg bV9jb250ZXh0LT50ZXhQYXJhbWV0ZXJpKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBH cmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV9NSU5fRklMVEVSLCBHcmFwaGljc0NvbnRleHQzRDo6 TElORUFSKTsKKyAgICBtX2NvbnRleHQtPnRleFBhcmFtZXRlcmYoR3JhcGhpY3NDb250ZXh0M0Q6 OlRFWFRVUkVfMkQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX1dSQVBfUywgR3JhcGhpY3ND b250ZXh0M0Q6OkNMQU1QX1RPX0VER0UpOworICAgIG1fY29udGV4dC0+dGV4UGFyYW1ldGVyZihH cmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVf V1JBUF9ULCBHcmFwaGljc0NvbnRleHQzRDo6Q0xBTVBfVE9fRURHRSk7CisgICAgbV9jb250ZXh0 LT50ZXhJbWFnZTJERGlyZWN0KG91dHB1dFRhcmdldCwgbGV2ZWwsIGludGVybmFsRm9ybWF0LCB3 aWR0aCwgaGVpZ2h0LCAwLCBmb3JtYXQsIHR5cGUsIG51bGxwdHIpOworCisgICAgLy8gQXR0YWNo IHRoZSB2aWRlbyB0ZXh0dXJlIHRvIHRoZSBmcmFtZWJ1ZmZlci4KKyAgICBtX2NvbnRleHQtPmZy YW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNEOjpSRUFEX0ZSQU1FQlVGRkVSLCBH cmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVOVDAsIHZpZGVvVGV4dHVyZVRhcmdldCwg dmlkZW9UZXh0dXJlLCBsZXZlbCk7CisKKyAgICBHQzNEZW51bSBzdGF0dXMgPSBtX2NvbnRleHQt PmNoZWNrRnJhbWVidWZmZXJTdGF0dXMoR3JhcGhpY3NDb250ZXh0M0Q6OlJFQURfRlJBTUVCVUZG RVIpOworICAgIGlmIChzdGF0dXMgIT0gR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSX0NP TVBMRVRFKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAvLyBDb3B5IHRleHR1cmUgZnJv bSB0aGUgcmVhZCBmcmFtZWJ1ZmZlciAoYW5kIHRodXMgdGhlIHZpZGVvIHRleHR1cmUpIHRvIHRo ZSBvdXRwdXQgdGV4dHVyZS4KKyAgICBtX2NvbnRleHQtPmNvcHlUZXhJbWFnZTJEKG91dHB1dFRh cmdldCwgbGV2ZWwsIGludGVybmFsRm9ybWF0LCAwLCAwLCB3aWR0aCwgaGVpZ2h0LCAwKTsKKwor ICAgIC8vIFJlc3RvcmUgdGhlIHByZXZpb3VzIHRleHR1cmUgYW5kIGZyYW1lYnVmZmVyIGJpbmRp bmdzLgorICAgIG1fY29udGV4dC0+YmluZFRleHR1cmUob3V0cHV0VGFyZ2V0LCBib3VuZFRleHR1 cmUpOworICAgIG1fY29udGV4dC0+YmluZEZyYW1lYnVmZmVyKEdyYXBoaWNzQ29udGV4dDNEOjpS RUFEX0ZSQU1FQlVGRkVSLCBib3VuZFJlYWRGcmFtZWJ1ZmZlcik7CisKKyAgICByZXR1cm4gIW1f Y29udGV4dC0+Z2V0RXJyb3IoKTsKK30KKworCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9WaWRlb1RleHR1cmVDb3BpZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL1ZpZGVvVGV4dHVyZUNvcGllci5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNlM2Qw NTY1MjEyZjAxM2M1MmIwYzYyZDU4NzcxYmEwOGM0NzhiMmUKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9WaWRlb1RleHR1cmVDb3BpZXIuaApAQCAt MCwwICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBWaWRlb1RleHR1cmVDb3BpZXJfaAor I2RlZmluZSBWaWRlb1RleHR1cmVDb3BpZXJfaAorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0 M0QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBWaWRlb1RleHR1cmVDb3BpZXIg eworcHVibGljOgorICAgIFZpZGVvVGV4dHVyZUNvcGllcihHcmFwaGljc0NvbnRleHQzRCYpOwor ICAgIH5WaWRlb1RleHR1cmVDb3BpZXIoKTsKKworICAgIGJvb2wgY29weVZpZGVvVGV4dHVyZVRv UGxhdGZvcm1UZXh0dXJlKFBsYXRmb3JtM0RPYmplY3QgdmlkZW9UZXh0dXJlLCBHQzNEZW51bSB2 aWRlb1RleHR1cmVUYXJnZXQsIHNpemVfdCB3aWR0aCwgc2l6ZV90IGhlaWdodCwgUGxhdGZvcm0z RE9iamVjdCBvdXRwdXRUZXh0dXJlLCBHQzNEZW51bSBvdXRwdXRUYXJnZXQsIEdDM0RpbnQgbGV2 ZWwsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBHQzNEZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5 cGUsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlwWSk7CisKKyAgICBHcmFwaGljc0Nv bnRleHQzRCYgY29udGV4dCgpIHsgcmV0dXJuIG1fY29udGV4dC5nZXQoKTsgfQorCitwcml2YXRl OgorICAgIFJlZjxHcmFwaGljc0NvbnRleHQzRD4gbV9jb250ZXh0OworICAgIFBsYXRmb3JtM0RP YmplY3QgbV9yZWFkRnJhbWVidWZmZXI7Cit9OworCit9CisKKyNlbmRpZiAvLyBWaWRlb1RleHR1 cmVDb3BpZXJfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJl YW1lckJhc2UuY3BwCmluZGV4IDA1NmUxNzExOTU5MTUyZjZjZTY2ZTQ0MmNlOTUwMDAxZDkwMTMy MmYuLmRhMmY4NWVjZjdjYjcyOTcyMjFjYTc2MjFiNTE0MWMzZDYzM2QwYTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclBy aXZhdGVHU3RyZWFtZXJCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTY2 OCw2ICs2NjgsMzEgQEAgdm9pZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWlu dFRvVGV4dHVyZU1hcHBlcihUZXh0dXJlTWFwcGVyJiB0ZXh0dXIKICNlbmRpZgogCiAjaWYgVVNF KEdTVFJFQU1FUl9HTCkKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6Y29w eVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0 LCBQbGF0Zm9ybTNET2JqZWN0IG91dHB1dFRleHR1cmUsIEdDM0RlbnVtIG91dHB1dFRhcmdldCwg R0MzRGludCBsZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIEdDM0RlbnVtIGZvcm1hdCwg R0MzRGVudW0gdHlwZSwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworICAg IGlmICghbV92aWRlb1RleHR1cmVDb3BpZXIpCisgICAgICAgIG1fdmlkZW9UZXh0dXJlQ29waWVy ID0gc3RkOjptYWtlX3VuaXF1ZTxWaWRlb1RleHR1cmVDb3BpZXI+KCpjb250ZXh0KTsKKworICAg IEdzdFZpZGVvSW5mbyB2aWRlb0luZm87CisgICAgaWYgKCFnZXRTYW1wbGVWaWRlb0luZm8obV9z YW1wbGUuZ2V0KCksIHZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIEdz dEJ1ZmZlciogYnVmZmVyID0gZ3N0X3NhbXBsZV9nZXRfYnVmZmVyKG1fc2FtcGxlLmdldCgpKTsK KyAgICBHc3RWaWRlb0ZyYW1lIHZpZGVvRnJhbWU7CisgICAgaWYgKCFnc3RfdmlkZW9fZnJhbWVf bWFwKCZ2aWRlb0ZyYW1lLCAmdmlkZW9JbmZvLCBidWZmZXIsIHN0YXRpY19jYXN0PEdzdE1hcEZs YWdzPihHU1RfTUFQX1JFQUQgfCBHU1RfTUFQX0dMKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsK KworICAgIHVuc2lnbmVkIHZpZGVvVGV4dHVyZSA9ICpyZWludGVycHJldF9jYXN0PHVuc2lnbmVk Kj4odmlkZW9GcmFtZS5kYXRhWzBdKTsKKyAgICBHQzNEZW51bSB2aWRlb1RleHR1cmVUYXJnZXQg PSBHTF9URVhUVVJFXzJEOworICAgIHNpemVfdCB3aWR0aCA9IEdTVF9WSURFT19JTkZPX1dJRFRI KCZ2aWRlb0luZm8pOworICAgIHNpemVfdCBoZWlnaHQgPSBHU1RfVklERU9fSU5GT19IRUlHSFQo JnZpZGVvSW5mbyk7CisKKyAgICBib29sIGNvcGllZCA9IG1fdmlkZW9UZXh0dXJlQ29waWVyLT5j b3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUodmlkZW9UZXh0dXJlLCB2aWRlb1RleHR1 cmVUYXJnZXQsIHdpZHRoLCBoZWlnaHQsIG91dHB1dFRleHR1cmUsIG91dHB1dFRhcmdldCwgbGV2 ZWwsIGludGVybmFsRm9ybWF0LCBmb3JtYXQsIHR5cGUsIHByZW11bHRpcGx5QWxwaGEsIGZsaXBZ KTsKKworICAgIGdzdF92aWRlb19mcmFtZV91bm1hcCgmdmlkZW9GcmFtZSk7CisgICAgcmV0dXJu IGNvcGllZDsKK30KKwogTmF0aXZlSW1hZ2VQdHIgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVy QmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpCiB7CiAjaWYgIVVTRShDQUlSTykgfHwg IUVOQUJMRShBQ0NFTEVSQVRFRF8yRF9DQU5WQVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVy QmFzZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaAppbmRleCA3NGRkMzE1ODA2MTkwODUwZGMzZTU2 OWJlOGRjYWFkOTMxNDhlNTIxLi5hN2MzNGQ0NjMyYjg4ZDQ4MGU2NWJmODMwNzBjZDRiZjY1ZWMy OTA4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJC YXNlLmgKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogI2luY2x1 ZGUgPHd0Zi9SdW5Mb29wLmg+CiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyNpbmNsdWRlICJWaWRl b1RleHR1cmVDb3BpZXIuaCIKICNkZWZpbmUgR1NUX1VTRV9VTlNUQUJMRV9BUEkKICNpbmNsdWRl IDxnc3QvZ2wvZ2wuaD4KICN1bmRlZiBHU1RfVVNFX1VOU1RBQkxFX0FQSQpAQCAtMTI5LDYgKzEz MCw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAgICBib29s IGNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBs YXRmb3JtM0RPYmplY3QsIEdDM0RlbnVtLCBHQzNEaW50LCBHQzNEZW51bSwgR0MzRGVudW0sIEdD M0RlbnVtLCBib29sLCBib29sKSBvdmVycmlkZTsKICAgICBOYXRpdmVJbWFnZVB0ciBuYXRpdmVJ bWFnZUZvckN1cnJlbnRUaW1lKCkgb3ZlcnJpZGU7CiAjZW5kaWYKIApAQCAtMTk3LDYgKzE5OSw3 IEBAIHByb3RlY3RlZDoKICNpZiBVU0UoR1NUUkVBTUVSX0dMKQogICAgIEdSZWZQdHI8R3N0R0xD b250ZXh0PiBtX2dsQ29udGV4dDsKICAgICBHUmVmUHRyPEdzdEdMRGlzcGxheT4gbV9nbERpc3Bs YXk7CisgICAgc3RkOjp1bmlxdWVfcHRyPFZpZGVvVGV4dHVyZUNvcGllcj4gbV92aWRlb1RleHR1 cmVDb3BpZXI7CiAjZW5kaWYKIAogI2lmIFVTRShDT09SRElOQVRFRF9HUkFQSElDU19USFJFQURF RCkK 286293 2016-08-17 03:09:16 -0700 2016-09-14 10:28:19 -0700 Patch bug-159928-20160817120727.patch text/plain 7843 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA0NTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTFmYmY1ODkyYWNlZjNi ZjU3NzgxMmI0NWYzMWUxNDM5YTc2MDgwMC4uMzkzYjVjMmE5NzdhMTgwYzE4ZTJlMTAxOTZkMmVj NzU1NjE4NjA3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE2LTA4LTE3ICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAgIGNhaXJv IHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0byB0aGUK KyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBzb2Z0d2Fy ZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0dXJlLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIgYmFja2Vu ZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNvZGUgZnJv bSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fp cm9TdXJmYWNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJl bnRUaW1lKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oOgorCiAyMDE2LTA4LTE2ICBDaHJpcyBEdW1leiAgPGNk dW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgY3R4LmRyYXdJbWFnZSBzaG91bGQgY2xpcCBzb3Vy Y2UgcmVjdCBpZiBpdCBpcyBvdXRzaWRlIHRoZSBzb3VyY2UgaW1hZ2UKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJCYXNlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcAppbmRleCBiMjkyMzll MTE5NGE3YjkzMzhjODEwNDIxYjkxODhlMTgyMWIyZjcxLi41YmE2ZTEyMzQ3YmNmYThjMmVlYTIy NGU5MDdiMTI0ZWNkZTBlOTNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVy UHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCkBAIC02ODIsMjUgKzY4MiwyMSBAQCB2b2lkIE1lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6OnBhaW50VG9UZXh0dXJlTWFwcGVyKFRleHR1cmVN YXBwZXImIHRleHR1cgogI2VuZGlmCiAKICNpZiBVU0UoR1NUUkVBTUVSX0dMKQotTmF0aXZlSW1h Z2VQdHIgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJy ZW50VGltZSgpCitib29sIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6OnBhaW50VG9D YWlyb1N1cmZhY2UoUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0U3VyZmFjZSkKIHsKLSNp ZiAhVVNFKENBSVJPKSB8fCAhRU5BQkxFKEFDQ0VMRVJBVEVEXzJEX0NBTlZBUykKLSAgICByZXR1 cm4gbnVsbHB0cjsKLSNlbmRpZgorICAgIC8vIG1fc2FtcGxlTXV0ZXggc2hvdWxkIGJlIGxvY2tl ZCBieSB0aGUgY2FsbGVyCiAKICAgICBpZiAobV91c2luZ0ZhbGxiYWNrVmlkZW9TaW5rKQotICAg ICAgICByZXR1cm4gbnVsbHB0cjsKLQotICAgIFdURjo6R011dGV4TG9ja2VyPEdNdXRleD4gbG9j ayhtX3NhbXBsZU11dGV4KTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgR3N0VmlkZW9J bmZvIHZpZGVvSW5mbzsKICAgICBpZiAoIWdldFNhbXBsZVZpZGVvSW5mbyhtX3NhbXBsZS5nZXQo KSwgdmlkZW9JbmZvKSkKLSAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgICAgIHJldHVybiBm YWxzZTsKIAogICAgIEdzdEJ1ZmZlciogYnVmZmVyID0gZ3N0X3NhbXBsZV9nZXRfYnVmZmVyKG1f c2FtcGxlLmdldCgpKTsKICAgICBHc3RWaWRlb0ZyYW1lIHZpZGVvRnJhbWU7CiAgICAgaWYgKCFn c3RfdmlkZW9fZnJhbWVfbWFwKCZ2aWRlb0ZyYW1lLCAmdmlkZW9JbmZvLCBidWZmZXIsIHN0YXRp Y19jYXN0PEdzdE1hcEZsYWdzPihHU1RfTUFQX1JFQUQgfCBHU1RfTUFQX0dMKSkpCi0gICAgICAg IHJldHVybiBudWxscHRyOworICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBHTENvbnRleHQq IGNvbnRleHQgPSBHTENvbnRleHQ6OnNoYXJpbmdDb250ZXh0KCk7CiAgICAgY29udGV4dC0+bWFr ZUNvbnRleHRDdXJyZW50KCk7CkBAIC03MTQsOCArNzEwLDcgQEAgTmF0aXZlSW1hZ2VQdHIgTWVk aWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgp CiAgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gc3VyZmFjZSA9IGFkb3B0UmVmKGNhaXJvX2ds X3N1cmZhY2VfY3JlYXRlX2Zvcl90ZXh0dXJlKGRldmljZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9B TFBIQSwgdGV4dHVyZUlELCBzaXplLndpZHRoKCksIHNpemUuaGVpZ2h0KCkpKTsKIAogICAgIElu dFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3JpZW50YXRpb24udXNlc1dpZHRoQXNI ZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNpemU7Ci0gICAgUmVmUHRyPGNhaXJv X3N1cmZhY2VfdD4gcm90YXRlZFN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb19nbF9zdXJmYWNlX2Ny ZWF0ZShkZXZpY2UsIENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIHJvdGF0ZWRTaXplLndpZHRo KCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKSk7Ci0gICAgUmVmUHRyPGNhaXJvX3Q+IGNyID0gYWRv cHRSZWYoY2Fpcm9fY3JlYXRlKHJvdGF0ZWRTdXJmYWNlLmdldCgpKSk7CisgICAgUmVmUHRyPGNh aXJvX3Q+IGNyID0gYWRvcHRSZWYoY2Fpcm9fY3JlYXRlKG91dHB1dFN1cmZhY2UuZ2V0KCkpKTsK IAogICAgIHN3aXRjaCAobV92aWRlb1NvdXJjZU9yaWVudGF0aW9uKSB7CiAgICAgY2FzZSBEZWZh dWx0SW1hZ2VPcmllbnRhdGlvbjoKQEAgLTc0NSw2ICs3NDAsNzEgQEAgTmF0aXZlSW1hZ2VQdHIg TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGlt ZSgpCiAKICAgICBnc3RfdmlkZW9fZnJhbWVfdW5tYXAoJnZpZGVvRnJhbWUpOwogCisgICAgcmV0 dXJuIHRydWU7Cit9CisKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6Y29w eVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0 LCBQbGF0Zm9ybTNET2JqZWN0IG91dHB1dFRleHR1cmUsIEdDM0RlbnVtIG91dHB1dFRhcmdldCwg R0MzRGludCBsZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIEdDM0RlbnVtIGZvcm1hdCwg R0MzRGVudW0gdHlwZSwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworI2lm ICFVU0UoQ0FJUk8pCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCisKKyAgICBpZiAoZmxpcFkg fHwgcHJlbXVsdGlwbHlBbHBoYSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgV1RGOjpH TXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKG1fc2FtcGxlTXV0ZXgpOworCisgICAgR3N0VmlkZW9J bmZvIHZpZGVvSW5mbzsKKyAgICBpZiAoIWdldFNhbXBsZVZpZGVvSW5mbyhtX3NhbXBsZS5nZXQo KSwgdmlkZW9JbmZvKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgR0xDb250ZXh0KiBn bENvbnRleHQgPSBHTENvbnRleHQ6OnNoYXJpbmdDb250ZXh0KCk7CisgICAgZ2xDb250ZXh0LT5t YWtlQ29udGV4dEN1cnJlbnQoKTsKKyAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlID0gZ2xDb250 ZXh0LT5jYWlyb0RldmljZSgpOworCisgICAgLy8gVGhyZWFkLWF3YXJlbmVzcyBpcyBhIGh1Z2Ug cGVyZm9ybWFuY2UgaGl0IG9uIG5vbi1JbnRlbCBkcml2ZXJzLgorICAgIGNhaXJvX2dsX2Rldmlj ZV9zZXRfdGhyZWFkX2F3YXJlKGRldmljZSwgRkFMU0UpOworICAgIC8vIEZJWE1FPworCisgICAg SW50U2l6ZSBzaXplID0gSW50U2l6ZShHU1RfVklERU9fSU5GT19XSURUSCgmdmlkZW9JbmZvKSwg R1NUX1ZJREVPX0lORk9fSEVJR0hUKCZ2aWRlb0luZm8pKTsKKyAgICBJbnRTaXplIHJvdGF0ZWRT aXplID0gbV92aWRlb1NvdXJjZU9yaWVudGF0aW9uLnVzZXNXaWR0aEFzSGVpZ2h0KCkgPyBzaXpl LnRyYW5zcG9zZWRTaXplKCkgOiBzaXplOworCisgICAgLy8gQWxsb2NhdGUgdW5pbml0aWFsaXpl ZCBtZW1vcnkgZm9yIHRoZSBvdXRwdXQgdGV4dHVyZS4KKyAgICBjb250ZXh0LT5iaW5kVGV4dHVy ZShvdXRwdXRUYXJnZXQsIG91dHB1dFRleHR1cmUpOworICAgIGNvbnRleHQtPnRleFBhcmFtZXRl cmkoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhU VVJFX01JTl9GSUxURVIsIEdyYXBoaWNzQ29udGV4dDNEOjpMSU5FQVIpOworICAgIGNvbnRleHQt PnRleFBhcmFtZXRlcmYoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIEdyYXBoaWNzQ29u dGV4dDNEOjpURVhUVVJFX1dSQVBfUywgR3JhcGhpY3NDb250ZXh0M0Q6OkNMQU1QX1RPX0VER0Up OworICAgIGNvbnRleHQtPnRleFBhcmFtZXRlcmYoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVf MkQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX1dSQVBfVCwgR3JhcGhpY3NDb250ZXh0M0Q6 OkNMQU1QX1RPX0VER0UpOworICAgIGNvbnRleHQtPnRleEltYWdlMkREaXJlY3Qob3V0cHV0VGFy Z2V0LCBsZXZlbCwgaW50ZXJuYWxGb3JtYXQsIHJvdGF0ZWRTaXplLndpZHRoKCksIHJvdGF0ZWRT aXplLmhlaWdodCgpLCAwLCBmb3JtYXQsIHR5cGUsIG51bGxwdHIpOworCisgICAgUmVmUHRyPGNh aXJvX3N1cmZhY2VfdD4gb3V0cHV0U3VyZmFjZSA9IGFkb3B0UmVmKGNhaXJvX2dsX3N1cmZhY2Vf Y3JlYXRlX2Zvcl90ZXh0dXJlKGRldmljZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBIQSwgb3V0 cHV0VGV4dHVyZSwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVpZ2h0KCkpKTsK KyAgICByZXR1cm4gcGFpbnRUb0NhaXJvU3VyZmFjZShvdXRwdXRTdXJmYWNlKTsKK30KKworTmF0 aXZlSW1hZ2VQdHIgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VG b3JDdXJyZW50VGltZSgpCit7CisjaWYgIVVTRShDQUlSTykgfHwgIUVOQUJMRShBQ0NFTEVSQVRF RF8yRF9DQU5WQVMpCisgICAgcmV0dXJuIG51bGxwdHI7CisjZW5kaWYKKworICAgIEdzdFZpZGVv SW5mbyB2aWRlb0luZm87CisgICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKG1fc2Ft cGxlTXV0ZXgpOworICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2 aWRlb0luZm8pKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAgIEdMQ29udGV4dCogY29u dGV4dCA9IEdMQ29udGV4dDo6c2hhcmluZ0NvbnRleHQoKTsKKyAgICBjb250ZXh0LT5tYWtlQ29u dGV4dEN1cnJlbnQoKTsKKyAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlID0gY29udGV4dC0+Y2Fp cm9EZXZpY2UoKTsKKworICAgIC8vIFRocmVhZC1hd2FyZW5lc3MgaXMgYSBodWdlIHBlcmZvcm1h bmNlIGhpdCBvbiBub24tSW50ZWwgZHJpdmVycy4KKyAgICBjYWlyb19nbF9kZXZpY2Vfc2V0X3Ro cmVhZF9hd2FyZShkZXZpY2UsIEZBTFNFKTsKKworICAgIEludFNpemUgc2l6ZSA9IEludFNpemUo R1NUX1ZJREVPX0lORk9fV0lEVEgoJnZpZGVvSW5mbyksIEdTVF9WSURFT19JTkZPX0hFSUdIVCgm dmlkZW9JbmZvKSk7CisgICAgSW50U2l6ZSByb3RhdGVkU2l6ZSA9IG1fdmlkZW9Tb3VyY2VPcmll bnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8gc2l6ZS50cmFuc3Bvc2VkU2l6ZSgpIDogc2l6 ZTsKKyAgICBSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90PiByb3RhdGVkU3VyZmFjZSA9IGFkb3B0UmVm KGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlKGRldmljZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBI QSwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVpZ2h0KCkpKTsKKworICAgIGlm ICghcGFpbnRUb0NhaXJvU3VyZmFjZShyb3RhdGVkU3VyZmFjZSkpCisgICAgICAgIHJldHVybiBu dWxscHRyOworCiAgICAgcmV0dXJuIHJvdGF0ZWRTdXJmYWNlOwogfQogI2VuZGlmCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaAppbmRleCBhOWMx MzgzY2MyMDNmODNiMGY4OTk1OTMyNzU1MWIyODVjYjE3NzUwLi44NDIyYTM0Zjk3YTc4YzRmZTU5 YzI4ZjBmOWJlYzA0ZTU1NmE3NGJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlLmgKQEAgLTExOSw2ICsxMTksOCBAQCBwdWJsaWM6CiAjZW5k aWYKIAogI2lmIFVTRShHU1RSRUFNRVJfR0wpCisgICAgYm9vbCBwYWludFRvQ2Fpcm9TdXJmYWNl KFJlZlB0cjxjYWlyb19zdXJmYWNlX3Q+IG91dHB1dFN1cmZhY2UpOworICAgIGJvb2wgY29weVZp ZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiwgUGxhdGZvcm0z RE9iamVjdCwgR0MzRGVudW0sIEdDM0RpbnQsIEdDM0RlbnVtLCBHQzNEZW51bSwgR0MzRGVudW0s IGJvb2wsIGJvb2wpIG92ZXJyaWRlOwogICAgIE5hdGl2ZUltYWdlUHRyIG5hdGl2ZUltYWdlRm9y Q3VycmVudFRpbWUoKSBvdmVycmlkZTsKICNlbmRpZgogCg== 288829 2016-09-14 10:28:29 -0700 2016-09-21 05:09:29 -0700 Patch bug-159928-20160914192552.patch text/plain 8031 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA1OTE0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDczZmI0MWZkZjRmNmEy ZTExYWViN2U5OThjNWI2NWJmODhhNzMyNi4uOTJjMjM0NDMzNzMwYzhiNjEzZmIyMDc5Yzc1Mzdk ZTQ1MjUzOGY4YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE2LTA4LTE3ICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAgIGNhaXJv IHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0byB0aGUK KyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBzb2Z0d2Fy ZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0dXJlLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIgYmFja2Vu ZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNvZGUgZnJv bSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fp cm9TdXJmYWNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJl bnRUaW1lKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oOgorCiAyMDE2LTA5LTE0ICBDaHJpcyBEdW1leiAgPGNk dW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgUmVncmVzc2lvbihyMTUyNzI1KTogZ2VuZXJhdGUt YmluZGluZ3MucGwgLS13cml0ZS1kZXBlbmRlbmNpZXMgZG9lcyBub3Qgd29yawpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVy UHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCmluZGV4IDhh ZDI0NGM0MzAzMThhMTM2YzJlNDRkZWJjN2M4MDBiNGU2MTAxNzEuLmQ1M2JiN2M3NTg3ODI3NTdi MDczYjQ1NmRkNjRjNGZkMGM5MTEzZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTY3NywyMiArNjc3LDIwIEBAIHZvaWQg TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFpbnRUb1RleHR1cmVNYXBwZXIoVGV4 dHVyZU1hcHBlciYgdGV4dHVyCiAjZW5kaWYKIAogI2lmIFVTRShHU1RSRUFNRVJfR0wpCi1OYXRp dmVJbWFnZVB0ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZv ckN1cnJlbnRUaW1lKCkKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFp bnRUb0NhaXJvU3VyZmFjZShSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90PiBvdXRwdXRTdXJmYWNlKQog ewotI2lmIFVTRShDQUlSTykgJiYgRU5BQkxFKEFDQ0VMRVJBVEVEXzJEX0NBTlZBUykKKyAgICAv LyBtX3NhbXBsZU11dGV4IHNob3VsZCBiZSBsb2NrZWQgYnkgdGhlIGNhbGxlcgogICAgIGlmICht X3VzaW5nRmFsbGJhY2tWaWRlb1NpbmspCi0gICAgICAgIHJldHVybiBudWxscHRyOwotCi0gICAg V1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKG1fc2FtcGxlTXV0ZXgpOworICAgICAgICBy ZXR1cm4gZmFsc2U7CiAKICAgICBHc3RWaWRlb0luZm8gdmlkZW9JbmZvOwogICAgIGlmICghZ2V0 U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2aWRlb0luZm8pKQotICAgICAgICByZXR1 cm4gbnVsbHB0cjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgR3N0QnVmZmVyKiBidWZm ZXIgPSBnc3Rfc2FtcGxlX2dldF9idWZmZXIobV9zYW1wbGUuZ2V0KCkpOwogICAgIEdzdFZpZGVv RnJhbWUgdmlkZW9GcmFtZTsKICAgICBpZiAoIWdzdF92aWRlb19mcmFtZV9tYXAoJnZpZGVvRnJh bWUsICZ2aWRlb0luZm8sIGJ1ZmZlciwgc3RhdGljX2Nhc3Q8R3N0TWFwRmxhZ3M+KEdTVF9NQVBf UkVBRCB8IEdTVF9NQVBfR0wpKSkKLSAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgICAgIHJl dHVybiBmYWxzZTsKIAogICAgIEdMQ29udGV4dCogY29udGV4dCA9IFBsYXRmb3JtRGlzcGxheTo6 c2hhcmVkRGlzcGxheUZvckNvbXBvc2l0aW5nKCkuc2hhcmluZ0dMQ29udGV4dCgpOwogICAgIGNv bnRleHQtPm1ha2VDb250ZXh0Q3VycmVudCgpOwpAQCAtNzA2LDggKzcwNCw3IEBAIE5hdGl2ZUlt YWdlUHRyIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6Om5hdGl2ZUltYWdlRm9yQ3Vy cmVudFRpbWUoKQogICAgIFJlZlB0cjxjYWlyb19zdXJmYWNlX3Q+IHN1cmZhY2UgPSBhZG9wdFJl ZihjYWlyb19nbF9zdXJmYWNlX2NyZWF0ZV9mb3JfdGV4dHVyZShkZXZpY2UsIENBSVJPX0NPTlRF TlRfQ09MT1JfQUxQSEEsIHRleHR1cmVJRCwgc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpKSk7 CiAKICAgICBJbnRTaXplIHJvdGF0ZWRTaXplID0gbV92aWRlb1NvdXJjZU9yaWVudGF0aW9uLnVz ZXNXaWR0aEFzSGVpZ2h0KCkgPyBzaXplLnRyYW5zcG9zZWRTaXplKCkgOiBzaXplOwotICAgIFJl ZlB0cjxjYWlyb19zdXJmYWNlX3Q+IHJvdGF0ZWRTdXJmYWNlID0gYWRvcHRSZWYoY2Fpcm9fZ2xf c3VyZmFjZV9jcmVhdGUoZGV2aWNlLCBDQUlST19DT05URU5UX0NPTE9SX0FMUEhBLCByb3RhdGVk U2l6ZS53aWR0aCgpLCByb3RhdGVkU2l6ZS5oZWlnaHQoKSkpOwotICAgIFJlZlB0cjxjYWlyb190 PiBjciA9IGFkb3B0UmVmKGNhaXJvX2NyZWF0ZShyb3RhdGVkU3VyZmFjZS5nZXQoKSkpOworICAg IFJlZlB0cjxjYWlyb190PiBjciA9IGFkb3B0UmVmKGNhaXJvX2NyZWF0ZShvdXRwdXRTdXJmYWNl LmdldCgpKSk7CiAKICAgICBzd2l0Y2ggKG1fdmlkZW9Tb3VyY2VPcmllbnRhdGlvbikgewogICAg IGNhc2UgRGVmYXVsdEltYWdlT3JpZW50YXRpb246CkBAIC03MzcsNiArNzM0LDc2IEBAIE5hdGl2 ZUltYWdlUHRyIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6Om5hdGl2ZUltYWdlRm9y Q3VycmVudFRpbWUoKQogCiAgICAgZ3N0X3ZpZGVvX2ZyYW1lX3VubWFwKCZ2aWRlb0ZyYW1lKTsK IAorICAgIHJldHVybiB0cnVlOworfQorCitib29sIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQz RCogY29udGV4dCwgUGxhdGZvcm0zRE9iamVjdCBvdXRwdXRUZXh0dXJlLCBHQzNEZW51bSBvdXRw dXRUYXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBHQzNEZW51 bSBmb3JtYXQsIEdDM0RlbnVtIHR5cGUsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlw WSkKK3sKKyNpZiAhVVNFKENBSVJPKQorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorCisgICAg aWYgKGZsaXBZIHx8IHByZW11bHRpcGx5QWxwaGEpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgIFdURjo6R011dGV4TG9ja2VyPEdNdXRleD4gbG9jayhtX3NhbXBsZU11dGV4KTsKKworICAg IEdzdFZpZGVvSW5mbyB2aWRlb0luZm87CisgICAgaWYgKCFnZXRTYW1wbGVWaWRlb0luZm8obV9z YW1wbGUuZ2V0KCksIHZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIEdM Q29udGV4dCogZ2xDb250ZXh0ID0gR0xDb250ZXh0OjpzaGFyaW5nQ29udGV4dCgpOworICAgIGds Q29udGV4dC0+bWFrZUNvbnRleHRDdXJyZW50KCk7CisgICAgY2Fpcm9fZGV2aWNlX3QqIGRldmlj ZSA9IGdsQ29udGV4dC0+Y2Fpcm9EZXZpY2UoKTsKKworICAgIC8vIFRocmVhZC1hd2FyZW5lc3Mg aXMgYSBodWdlIHBlcmZvcm1hbmNlIGhpdCBvbiBub24tSW50ZWwgZHJpdmVycy4KKyAgICBjYWly b19nbF9kZXZpY2Vfc2V0X3RocmVhZF9hd2FyZShkZXZpY2UsIEZBTFNFKTsKKworICAgIEludFNp emUgc2l6ZSA9IEludFNpemUoR1NUX1ZJREVPX0lORk9fV0lEVEgoJnZpZGVvSW5mbyksIEdTVF9W SURFT19JTkZPX0hFSUdIVCgmdmlkZW9JbmZvKSk7CisgICAgSW50U2l6ZSByb3RhdGVkU2l6ZSA9 IG1fdmlkZW9Tb3VyY2VPcmllbnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8gc2l6ZS50cmFu c3Bvc2VkU2l6ZSgpIDogc2l6ZTsKKworICAgIC8vIEFsbG9jYXRlIHVuaW5pdGlhbGl6ZWQgbWVt b3J5IGZvciB0aGUgb3V0cHV0IHRleHR1cmUuCisgICAgY29udGV4dC0+YmluZFRleHR1cmUob3V0 cHV0VGFyZ2V0LCBvdXRwdXRUZXh0dXJlKTsKKyAgICBjb250ZXh0LT50ZXhJbWFnZTJERGlyZWN0 KG91dHB1dFRhcmdldCwgbGV2ZWwsIGludGVybmFsRm9ybWF0LCByb3RhdGVkU2l6ZS53aWR0aCgp LCByb3RhdGVkU2l6ZS5oZWlnaHQoKSwgMCwgZm9ybWF0LCB0eXBlLCBudWxscHRyKTsKKworICAg IC8vIGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlX2Zvcl90ZXh0dXJlIHNldHMgdGhlc2UgcGFyYW1l dGVycyB0byBHTF9ORUFSRVNULCBzbyB3ZSBuZWVkIHRvIGJhY2t1cCB0aGVtCisgICAgR0MzRGlu dCBtaW5GaWx0ZXIsIG1hZ0ZpbHRlcjsKKyAgICBjb250ZXh0LT5nZXRUZXhQYXJhbWV0ZXJpdihv dXRwdXRUYXJnZXQsIEdMX1RFWFRVUkVfTUlOX0ZJTFRFUiwgJm1pbkZpbHRlcik7CisgICAgY29u dGV4dC0+Z2V0VGV4UGFyYW1ldGVyaXYob3V0cHV0VGFyZ2V0LCBHTF9URVhUVVJFX01BR19GSUxU RVIsICZtYWdGaWx0ZXIpOworCisgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0U3Vy ZmFjZSA9IGFkb3B0UmVmKGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlX2Zvcl90ZXh0dXJlKGRldmlj ZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBIQSwgb3V0cHV0VGV4dHVyZSwgcm90YXRlZFNpemUu d2lkdGgoKSwgcm90YXRlZFNpemUuaGVpZ2h0KCkpKTsKKyAgICBpZiAoIXBhaW50VG9DYWlyb1N1 cmZhY2Uob3V0cHV0U3VyZmFjZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGNvbnRl eHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0VGV4dHVyZSk7CisgICAgY29udGV4 dC0+dGV4UGFyYW1ldGVyaShvdXRwdXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJF X01JTl9GSUxURVIsIG1pbkZpbHRlcik7CisgICAgY29udGV4dC0+dGV4UGFyYW1ldGVyaShvdXRw dXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX01BR19GSUxURVIsIG1hZ0ZpbHRl cik7CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworTmF0aXZlSW1hZ2VQdHIgTWVkaWFQbGF5ZXJQ cml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpCit7CisjaWYg VVNFKENBSVJPKSAmJiBFTkFCTEUoQUNDRUxFUkFURURfMkRfQ0FOVkFTKQorICAgIEdzdFZpZGVv SW5mbyB2aWRlb0luZm87CisgICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKG1fc2Ft cGxlTXV0ZXgpOworICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2 aWRlb0luZm8pKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAgIEdMQ29udGV4dCogY29u dGV4dCA9IEdMQ29udGV4dDo6c2hhcmluZ0NvbnRleHQoKTsKKyAgICBjb250ZXh0LT5tYWtlQ29u dGV4dEN1cnJlbnQoKTsKKyAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlID0gY29udGV4dC0+Y2Fp cm9EZXZpY2UoKTsKKworICAgIC8vIFRocmVhZC1hd2FyZW5lc3MgaXMgYSBodWdlIHBlcmZvcm1h bmNlIGhpdCBvbiBub24tSW50ZWwgZHJpdmVycy4KKyAgICBjYWlyb19nbF9kZXZpY2Vfc2V0X3Ro cmVhZF9hd2FyZShkZXZpY2UsIEZBTFNFKTsKKworICAgIEludFNpemUgc2l6ZSA9IEludFNpemUo R1NUX1ZJREVPX0lORk9fV0lEVEgoJnZpZGVvSW5mbyksIEdTVF9WSURFT19JTkZPX0hFSUdIVCgm dmlkZW9JbmZvKSk7CisgICAgSW50U2l6ZSByb3RhdGVkU2l6ZSA9IG1fdmlkZW9Tb3VyY2VPcmll bnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8gc2l6ZS50cmFuc3Bvc2VkU2l6ZSgpIDogc2l6 ZTsKKyAgICBSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90PiByb3RhdGVkU3VyZmFjZSA9IGFkb3B0UmVm KGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlKGRldmljZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBI QSwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVpZ2h0KCkpKTsKKworICAgIGlm ICghcGFpbnRUb0NhaXJvU3VyZmFjZShyb3RhdGVkU3VyZmFjZSkpCisgICAgICAgIHJldHVybiBu dWxscHRyOworCiAgICAgcmV0dXJuIHJvdGF0ZWRTdXJmYWNlOwogI2Vsc2UKICAgICByZXR1cm4g bnVsbHB0cjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVy QmFzZS5oCmluZGV4IGY4MGEzOTk3OTMyOTQ0ZGYwMTc3ODY2NGNlYjk2NWRhY2FmYjgyNmQuLmEz YTU5MWI1ZmI3YWFmZTllMjRkYzQ3MDcyNDVhNmQ0ZDMyYjAyMWMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0 cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaApAQCAtMTI1LDYgKzEyNSw4 IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAgICBib29sIHBh aW50VG9DYWlyb1N1cmZhY2UoUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0U3VyZmFjZSk7 CisgICAgYm9vbCBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhpY3NDb250 ZXh0M0QqLCBQbGF0Zm9ybTNET2JqZWN0LCBHQzNEZW51bSwgR0MzRGludCwgR0MzRGVudW0sIEdD M0RlbnVtLCBHQzNEZW51bSwgYm9vbCwgYm9vbCkgb3ZlcnJpZGU7CiAgICAgTmF0aXZlSW1hZ2VQ dHIgbmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpIG92ZXJyaWRlOwogI2VuZGlmCiAK 289443 2016-09-21 05:09:38 -0700 2016-09-21 10:03:44 -0700 Patch bug-159928-20160921140650.patch text/plain 8699 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA2MTQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDQ4NjdiYTU2MWNhOWFi YzgyNGQ4YTE2NWE2YzhlNTk1NTM3ZDRjNC4uNGI1OTg1M2JjOWE4OWY2NWUzYmU0MzlmZDBlY2Rm YWFmZDJmYjI0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE2LTA5LTIxICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAgIGNhaXJv IHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0byB0aGUK KyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBzb2Z0d2Fy ZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0dXJlLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIgYmFja2Vu ZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNvZGUgZnJv bSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fp cm9TdXJmYWNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJl bnRUaW1lKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oOgorCiAyMDE2LTA5LTIwICBQZXIgQXJuZSBWb2xsYW4g IDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBVbnJldmlld2VkIHdhcm5pbmcg Zml4LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJh c2UuY3BwCmluZGV4IDBmNWQxMTQ2MjQ0MGEyZWNmM2Q2ZjY3MzljNWNkYWJhZmEyMjkxNjQuLmFh ZjgyYjQwOGIxZjJlMTA3MTJkYzI3YmU4OGMzYWI1MWZlMmVhZDQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTY5NywzNyAr Njk3LDI0IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFpbnRUb1Rl eHR1cmVNYXBwZXIoVGV4dHVyZU1hcHBlciYgdGV4dHVyCiAjZW5kaWYKIAogI2lmIFVTRShHU1RS RUFNRVJfR0wpCi1OYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNl OjpuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0 cmVhbWVyQmFzZTo6cGFpbnRUb0NhaXJvU3VyZmFjZShSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90PiBv dXRwdXRTdXJmYWNlLCBjYWlyb19kZXZpY2VfdCogZGV2aWNlLCBHc3RWaWRlb0luZm8qIHZpZGVv SW5mbykKIHsKLSNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShBQ0NFTEVSQVRFRF8yRF9DQU5WQVMp Ci0gICAgaWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykKLSAgICAgICAgcmV0dXJuIG51bGxw dHI7Ci0KLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7 Ci0KLSAgICBHc3RWaWRlb0luZm8gdmlkZW9JbmZvOwotICAgIGlmICghZ2V0U2FtcGxlVmlkZW9J bmZvKG1fc2FtcGxlLmdldCgpLCB2aWRlb0luZm8pKQotICAgICAgICByZXR1cm4gbnVsbHB0cjsK KyAgICAvLyBtX3NhbXBsZU11dGV4IHNob3VsZCBiZSBsb2NrZWQgYnkgdGhlIGNhbGxlcgogCiAg ICAgR3N0QnVmZmVyKiBidWZmZXIgPSBnc3Rfc2FtcGxlX2dldF9idWZmZXIobV9zYW1wbGUuZ2V0 KCkpOwogICAgIEdzdFZpZGVvRnJhbWUgdmlkZW9GcmFtZTsKLSAgICBpZiAoIWdzdF92aWRlb19m cmFtZV9tYXAoJnZpZGVvRnJhbWUsICZ2aWRlb0luZm8sIGJ1ZmZlciwgc3RhdGljX2Nhc3Q8R3N0 TWFwRmxhZ3M+KEdTVF9NQVBfUkVBRCB8IEdTVF9NQVBfR0wpKSkKLSAgICAgICAgcmV0dXJuIG51 bGxwdHI7CisgICAgaWYgKCFnc3RfdmlkZW9fZnJhbWVfbWFwKCZ2aWRlb0ZyYW1lLCB2aWRlb0lu Zm8sIGJ1ZmZlciwgc3RhdGljX2Nhc3Q8R3N0TWFwRmxhZ3M+KEdTVF9NQVBfUkVBRCB8IEdTVF9N QVBfR0wpKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgR0xDb250ZXh0KiBjb250ZXh0 ID0gUGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5Rm9yQ29tcG9zaXRpbmcoKS5zaGFyaW5n R0xDb250ZXh0KCk7CiAgICAgY29udGV4dC0+bWFrZUNvbnRleHRDdXJyZW50KCk7Ci0gICAgY2Fp cm9fZGV2aWNlX3QqIGRldmljZSA9IGNvbnRleHQtPmNhaXJvRGV2aWNlKCk7Ci0KLSAgICAvLyBU aHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBwZXJmb3JtYW5jZSBoaXQgb24gbm9uLUludGVsIGRy aXZlcnMuCi0gICAgY2Fpcm9fZ2xfZGV2aWNlX3NldF90aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxT RSk7CiAKICAgICB1bnNpZ25lZCB0ZXh0dXJlSUQgPSAqcmVpbnRlcnByZXRfY2FzdDx1bnNpZ25l ZCo+KHZpZGVvRnJhbWUuZGF0YVswXSk7Ci0gICAgSW50U2l6ZSBzaXplID0gSW50U2l6ZShHU1Rf VklERU9fSU5GT19XSURUSCgmdmlkZW9JbmZvKSwgR1NUX1ZJREVPX0lORk9fSEVJR0hUKCZ2aWRl b0luZm8pKTsKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXplKEdTVF9WSURFT19JTkZPX1dJRFRI KHZpZGVvSW5mbyksIEdTVF9WSURFT19JTkZPX0hFSUdIVCh2aWRlb0luZm8pKTsKICAgICBSZWZQ dHI8Y2Fpcm9fc3VyZmFjZV90PiBzdXJmYWNlID0gYWRvcHRSZWYoY2Fpcm9fZ2xfc3VyZmFjZV9j cmVhdGVfZm9yX3RleHR1cmUoZGV2aWNlLCBDQUlST19DT05URU5UX0NPTE9SX0FMUEhBLCB0ZXh0 dXJlSUQsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSkpOwogCiAgICAgSW50U2l6ZSByb3Rh dGVkU2l6ZSA9IG1fdmlkZW9Tb3VyY2VPcmllbnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8g c2l6ZS50cmFuc3Bvc2VkU2l6ZSgpIDogc2l6ZTsKLSAgICBSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90 PiByb3RhdGVkU3VyZmFjZSA9IGFkb3B0UmVmKGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlKGRldmlj ZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBIQSwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRl ZFNpemUuaGVpZ2h0KCkpKTsKLSAgICBSZWZQdHI8Y2Fpcm9fdD4gY3IgPSBhZG9wdFJlZihjYWly b19jcmVhdGUocm90YXRlZFN1cmZhY2UuZ2V0KCkpKTsKKyAgICBSZWZQdHI8Y2Fpcm9fdD4gY3Ig PSBhZG9wdFJlZihjYWlyb19jcmVhdGUob3V0cHV0U3VyZmFjZS5nZXQoKSkpOwogCiAgICAgc3dp dGNoIChtX3ZpZGVvU291cmNlT3JpZW50YXRpb24pIHsKICAgICBjYXNlIERlZmF1bHRJbWFnZU9y aWVudGF0aW9uOgpAQCAtNzU3LDYgKzc0NCw4MSBAQCBOYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKIAogICAg IGdzdF92aWRlb19mcmFtZV91bm1hcCgmdmlkZW9GcmFtZSk7CiAKKyAgICByZXR1cm4gdHJ1ZTsK K30KKworYm9vbCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpjb3B5VmlkZW9UZXh0 dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFBsYXRmb3Jt M0RPYmplY3Qgb3V0cHV0VGV4dHVyZSwgR0MzRGVudW0gb3V0cHV0VGFyZ2V0LCBHQzNEaW50IGxl dmVsLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0 eXBlLCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpCit7CisjaWYgIVVTRShDQUlS TykKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKKworICAgIGlmIChtX3VzaW5nRmFsbGJhY2tW aWRlb1NpbmspCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChmbGlwWSB8fCBwcmVt dWx0aXBseUFscGhhKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBXVEY6OkdNdXRleExv Y2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7CisKKyAgICBHc3RWaWRlb0luZm8gdmlk ZW9JbmZvOworICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2aWRl b0luZm8pKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBHTENvbnRleHQqIGdsQ29udGV4 dCA9IFBsYXRmb3JtRGlzcGxheTo6c2hhcmVkRGlzcGxheUZvckNvbXBvc2l0aW5nKCkuc2hhcmlu Z0dMQ29udGV4dCgpOworICAgIGNhaXJvX2RldmljZV90KiBkZXZpY2UgPSBnbENvbnRleHQtPmNh aXJvRGV2aWNlKCk7CisKKyAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBwZXJmb3Jt YW5jZSBoaXQgb24gbm9uLUludGVsIGRyaXZlcnMuCisgICAgY2Fpcm9fZ2xfZGV2aWNlX3NldF90 aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxTRSk7CisKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXpl KEdTVF9WSURFT19JTkZPX1dJRFRIKCZ2aWRlb0luZm8pLCBHU1RfVklERU9fSU5GT19IRUlHSFQo JnZpZGVvSW5mbykpOworICAgIEludFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3Jp ZW50YXRpb24udXNlc1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNp emU7CisKKyAgICAvLyBBbGxvY2F0ZSB1bmluaXRpYWxpemVkIG1lbW9yeSBmb3IgdGhlIG91dHB1 dCB0ZXh0dXJlLgorICAgIGNvbnRleHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0 VGV4dHVyZSk7CisgICAgY29udGV4dC0+dGV4SW1hZ2UyRERpcmVjdChvdXRwdXRUYXJnZXQsIGxl dmVsLCBpbnRlcm5hbEZvcm1hdCwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVp Z2h0KCksIDAsIGZvcm1hdCwgdHlwZSwgbnVsbHB0cik7CisKKyAgICAvLyBjYWlyb19nbF9zdXJm YWNlX2NyZWF0ZV9mb3JfdGV4dHVyZSBzZXRzIHRoZXNlIHBhcmFtZXRlcnMgdG8gR0xfTkVBUkVT VCwgc28gd2UgbmVlZCB0byBiYWNrdXAgdGhlbQorICAgIEdDM0RpbnQgbWluRmlsdGVyLCBtYWdG aWx0ZXI7CisgICAgY29udGV4dC0+Z2V0VGV4UGFyYW1ldGVyaXYob3V0cHV0VGFyZ2V0LCBHTF9U RVhUVVJFX01JTl9GSUxURVIsICZtaW5GaWx0ZXIpOworICAgIGNvbnRleHQtPmdldFRleFBhcmFt ZXRlcml2KG91dHB1dFRhcmdldCwgR0xfVEVYVFVSRV9NQUdfRklMVEVSLCAmbWFnRmlsdGVyKTsK KworICAgIFJlZlB0cjxjYWlyb19zdXJmYWNlX3Q+IG91dHB1dFN1cmZhY2UgPSBhZG9wdFJlZihj YWlyb19nbF9zdXJmYWNlX2NyZWF0ZV9mb3JfdGV4dHVyZShkZXZpY2UsIENBSVJPX0NPTlRFTlRf Q09MT1JfQUxQSEEsIG91dHB1dFRleHR1cmUsIHJvdGF0ZWRTaXplLndpZHRoKCksIHJvdGF0ZWRT aXplLmhlaWdodCgpKSk7CisgICAgaWYgKCFwYWludFRvQ2Fpcm9TdXJmYWNlKG91dHB1dFN1cmZh Y2UsIGRldmljZSwgJnZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGNv bnRleHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0VGV4dHVyZSk7CisgICAgY29u dGV4dC0+dGV4UGFyYW1ldGVyaShvdXRwdXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhU VVJFX01JTl9GSUxURVIsIG1pbkZpbHRlcik7CisgICAgY29udGV4dC0+dGV4UGFyYW1ldGVyaShv dXRwdXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX01BR19GSUxURVIsIG1hZ0Zp bHRlcik7CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworTmF0aXZlSW1hZ2VQdHIgTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpCit7Cisj aWYgVVNFKENBSVJPKSAmJiBFTkFCTEUoQUNDRUxFUkFURURfMkRfQ0FOVkFTKQorICAgIGlmICht X3VzaW5nRmFsbGJhY2tWaWRlb1NpbmspCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAg R3N0VmlkZW9JbmZvIHZpZGVvSW5mbzsKKyAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxv Y2sobV9zYW1wbGVNdXRleCk7CisgICAgaWYgKCFnZXRTYW1wbGVWaWRlb0luZm8obV9zYW1wbGUu Z2V0KCksIHZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgR0xDb250 ZXh0KiBjb250ZXh0ID0gUGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5Rm9yQ29tcG9zaXRp bmcoKS5zaGFyaW5nR0xDb250ZXh0KCk7CisgICAgY29udGV4dC0+bWFrZUNvbnRleHRDdXJyZW50 KCk7CisgICAgY2Fpcm9fZGV2aWNlX3QqIGRldmljZSA9IGNvbnRleHQtPmNhaXJvRGV2aWNlKCk7 CisKKyAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBwZXJmb3JtYW5jZSBoaXQgb24g bm9uLUludGVsIGRyaXZlcnMuCisgICAgY2Fpcm9fZ2xfZGV2aWNlX3NldF90aHJlYWRfYXdhcmUo ZGV2aWNlLCBGQUxTRSk7CisKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXplKEdTVF9WSURFT19J TkZPX1dJRFRIKCZ2aWRlb0luZm8pLCBHU1RfVklERU9fSU5GT19IRUlHSFQoJnZpZGVvSW5mbykp OworICAgIEludFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3JpZW50YXRpb24udXNl c1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNpemU7CisgICAgUmVm UHRyPGNhaXJvX3N1cmZhY2VfdD4gcm90YXRlZFN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb19nbF9z dXJmYWNlX2NyZWF0ZShkZXZpY2UsIENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIHJvdGF0ZWRT aXplLndpZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKSk7CisKKyAgICBpZiAoIXBhaW50VG9D YWlyb1N1cmZhY2Uocm90YXRlZFN1cmZhY2UsIGRldmljZSwgJnZpZGVvSW5mbykpCisgICAgICAg IHJldHVybiBudWxscHRyOworCiAgICAgcmV0dXJuIHJvdGF0ZWRTdXJmYWNlOwogI2Vsc2UKICAg ICByZXR1cm4gbnVsbHB0cjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyQmFzZS5oCmluZGV4IGRlNmQyMzEyM2NkOGMwODkxN2JhMjdhNDI2OTQ5ZjQwMDJh ZWVkOGMuLjRhZDc3MzdlYmVkNmFjNzZmN2EyMWNmNWIxZTQxODkyM2RkNTU5MmEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaApAQCAtMTE2 LDYgKzExNiw4IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAg ICBib29sIHBhaW50VG9DYWlyb1N1cmZhY2UoUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0 U3VyZmFjZSwgY2Fpcm9fZGV2aWNlX3QqLCBHc3RWaWRlb0luZm8qKTsKKyAgICBib29sIGNvcHlW aWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBsYXRmb3Jt M0RPYmplY3QsIEdDM0RlbnVtLCBHQzNEaW50LCBHQzNEZW51bSwgR0MzRGVudW0sIEdDM0RlbnVt LCBib29sLCBib29sKSBvdmVycmlkZTsKICAgICBOYXRpdmVJbWFnZVB0ciBuYXRpdmVJbWFnZUZv ckN1cnJlbnRUaW1lKCkgb3ZlcnJpZGU7CiAjZW5kaWYKIAo= 289463 2016-09-21 10:03:54 -0700 2016-09-22 03:01:04 -0700 Patch bug-159928-20160921190105.patch text/plain 8699 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA2MTQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDQ4NjdiYTU2MWNhOWFi YzgyNGQ4YTE2NWE2YzhlNTk1NTM3ZDRjNC4uNGI1OTg1M2JjOWE4OWY2NWUzYmU0MzlmZDBlY2Rm YWFmZDJmYjI0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE2LTA5LTIxICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAgIGNhaXJv IHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0byB0aGUK KyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBzb2Z0d2Fy ZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0dXJlLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIgYmFja2Vu ZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNvZGUgZnJv bSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fp cm9TdXJmYWNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJl bnRUaW1lKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oOgorCiAyMDE2LTA5LTIwICBQZXIgQXJuZSBWb2xsYW4g IDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBVbnJldmlld2VkIHdhcm5pbmcg Zml4LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJh c2UuY3BwCmluZGV4IDBmNWQxMTQ2MjQ0MGEyZWNmM2Q2ZjY3MzljNWNkYWJhZmEyMjkxNjQuLjcy ZDY3MWU2NDJkYmM5NzMwN2ZlZWVlYjA0MDdhMGM5ZGU5YjVlY2QgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTY5NywzNyAr Njk3LDIxIEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFpbnRUb1Rl eHR1cmVNYXBwZXIoVGV4dHVyZU1hcHBlciYgdGV4dHVyCiAjZW5kaWYKIAogI2lmIFVTRShHU1RS RUFNRVJfR0wpCi1OYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNl OjpuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0 cmVhbWVyQmFzZTo6cGFpbnRUb0NhaXJvU3VyZmFjZShSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90PiBv dXRwdXRTdXJmYWNlLCBjYWlyb19kZXZpY2VfdCogZGV2aWNlLCBHc3RWaWRlb0luZm8qIHZpZGVv SW5mbykKIHsKLSNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShBQ0NFTEVSQVRFRF8yRF9DQU5WQVMp Ci0gICAgaWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykKLSAgICAgICAgcmV0dXJuIG51bGxw dHI7Ci0KLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7 Ci0KLSAgICBHc3RWaWRlb0luZm8gdmlkZW9JbmZvOwotICAgIGlmICghZ2V0U2FtcGxlVmlkZW9J bmZvKG1fc2FtcGxlLmdldCgpLCB2aWRlb0luZm8pKQotICAgICAgICByZXR1cm4gbnVsbHB0cjsK KyAgICAvLyBtX3NhbXBsZU11dGV4IHNob3VsZCBiZSBsb2NrZWQgYnkgdGhlIGNhbGxlcgogCiAg ICAgR3N0QnVmZmVyKiBidWZmZXIgPSBnc3Rfc2FtcGxlX2dldF9idWZmZXIobV9zYW1wbGUuZ2V0 KCkpOwogICAgIEdzdFZpZGVvRnJhbWUgdmlkZW9GcmFtZTsKLSAgICBpZiAoIWdzdF92aWRlb19m cmFtZV9tYXAoJnZpZGVvRnJhbWUsICZ2aWRlb0luZm8sIGJ1ZmZlciwgc3RhdGljX2Nhc3Q8R3N0 TWFwRmxhZ3M+KEdTVF9NQVBfUkVBRCB8IEdTVF9NQVBfR0wpKSkKLSAgICAgICAgcmV0dXJuIG51 bGxwdHI7Ci0KLSAgICBHTENvbnRleHQqIGNvbnRleHQgPSBQbGF0Zm9ybURpc3BsYXk6OnNoYXJl ZERpc3BsYXlGb3JDb21wb3NpdGluZygpLnNoYXJpbmdHTENvbnRleHQoKTsKLSAgICBjb250ZXh0 LT5tYWtlQ29udGV4dEN1cnJlbnQoKTsKLSAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlID0gY29u dGV4dC0+Y2Fpcm9EZXZpY2UoKTsKLQotICAgIC8vIFRocmVhZC1hd2FyZW5lc3MgaXMgYSBodWdl IHBlcmZvcm1hbmNlIGhpdCBvbiBub24tSW50ZWwgZHJpdmVycy4KLSAgICBjYWlyb19nbF9kZXZp Y2Vfc2V0X3RocmVhZF9hd2FyZShkZXZpY2UsIEZBTFNFKTsKKyAgICBpZiAoIWdzdF92aWRlb19m cmFtZV9tYXAoJnZpZGVvRnJhbWUsIHZpZGVvSW5mbywgYnVmZmVyLCBzdGF0aWNfY2FzdDxHc3RN YXBGbGFncz4oR1NUX01BUF9SRUFEIHwgR1NUX01BUF9HTCkpKQorICAgICAgICByZXR1cm4gZmFs c2U7CiAKICAgICB1bnNpZ25lZCB0ZXh0dXJlSUQgPSAqcmVpbnRlcnByZXRfY2FzdDx1bnNpZ25l ZCo+KHZpZGVvRnJhbWUuZGF0YVswXSk7Ci0gICAgSW50U2l6ZSBzaXplID0gSW50U2l6ZShHU1Rf VklERU9fSU5GT19XSURUSCgmdmlkZW9JbmZvKSwgR1NUX1ZJREVPX0lORk9fSEVJR0hUKCZ2aWRl b0luZm8pKTsKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXplKEdTVF9WSURFT19JTkZPX1dJRFRI KHZpZGVvSW5mbyksIEdTVF9WSURFT19JTkZPX0hFSUdIVCh2aWRlb0luZm8pKTsKICAgICBSZWZQ dHI8Y2Fpcm9fc3VyZmFjZV90PiBzdXJmYWNlID0gYWRvcHRSZWYoY2Fpcm9fZ2xfc3VyZmFjZV9j cmVhdGVfZm9yX3RleHR1cmUoZGV2aWNlLCBDQUlST19DT05URU5UX0NPTE9SX0FMUEhBLCB0ZXh0 dXJlSUQsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSkpOwogCiAgICAgSW50U2l6ZSByb3Rh dGVkU2l6ZSA9IG1fdmlkZW9Tb3VyY2VPcmllbnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8g c2l6ZS50cmFuc3Bvc2VkU2l6ZSgpIDogc2l6ZTsKLSAgICBSZWZQdHI8Y2Fpcm9fc3VyZmFjZV90 PiByb3RhdGVkU3VyZmFjZSA9IGFkb3B0UmVmKGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlKGRldmlj ZSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBIQSwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRl ZFNpemUuaGVpZ2h0KCkpKTsKLSAgICBSZWZQdHI8Y2Fpcm9fdD4gY3IgPSBhZG9wdFJlZihjYWly b19jcmVhdGUocm90YXRlZFN1cmZhY2UuZ2V0KCkpKTsKKyAgICBSZWZQdHI8Y2Fpcm9fdD4gY3Ig PSBhZG9wdFJlZihjYWlyb19jcmVhdGUob3V0cHV0U3VyZmFjZS5nZXQoKSkpOwogCiAgICAgc3dp dGNoIChtX3ZpZGVvU291cmNlT3JpZW50YXRpb24pIHsKICAgICBjYXNlIERlZmF1bHRJbWFnZU9y aWVudGF0aW9uOgpAQCAtNzU3LDYgKzc0MSw4MSBAQCBOYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKIAogICAg IGdzdF92aWRlb19mcmFtZV91bm1hcCgmdmlkZW9GcmFtZSk7CiAKKyAgICByZXR1cm4gdHJ1ZTsK K30KKworYm9vbCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpjb3B5VmlkZW9UZXh0 dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFBsYXRmb3Jt M0RPYmplY3Qgb3V0cHV0VGV4dHVyZSwgR0MzRGVudW0gb3V0cHV0VGFyZ2V0LCBHQzNEaW50IGxl dmVsLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0 eXBlLCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpCit7CisjaWYgIVVTRShDQUlS TykKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKKworICAgIGlmIChtX3VzaW5nRmFsbGJhY2tW aWRlb1NpbmspCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChmbGlwWSB8fCBwcmVt dWx0aXBseUFscGhhKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBXVEY6OkdNdXRleExv Y2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7CisKKyAgICBHc3RWaWRlb0luZm8gdmlk ZW9JbmZvOworICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2aWRl b0luZm8pKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBHTENvbnRleHQqIGdsQ29udGV4 dCA9IFBsYXRmb3JtRGlzcGxheTo6c2hhcmVkRGlzcGxheUZvckNvbXBvc2l0aW5nKCkuc2hhcmlu Z0dMQ29udGV4dCgpOworICAgIGNhaXJvX2RldmljZV90KiBkZXZpY2UgPSBnbENvbnRleHQtPmNh aXJvRGV2aWNlKCk7CisKKyAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBwZXJmb3Jt YW5jZSBoaXQgb24gbm9uLUludGVsIGRyaXZlcnMuCisgICAgY2Fpcm9fZ2xfZGV2aWNlX3NldF90 aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxTRSk7CisKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXpl KEdTVF9WSURFT19JTkZPX1dJRFRIKCZ2aWRlb0luZm8pLCBHU1RfVklERU9fSU5GT19IRUlHSFQo JnZpZGVvSW5mbykpOworICAgIEludFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3Jp ZW50YXRpb24udXNlc1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNp emU7CisKKyAgICAvLyBBbGxvY2F0ZSB1bmluaXRpYWxpemVkIG1lbW9yeSBmb3IgdGhlIG91dHB1 dCB0ZXh0dXJlLgorICAgIGNvbnRleHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0 VGV4dHVyZSk7CisgICAgY29udGV4dC0+dGV4SW1hZ2UyRERpcmVjdChvdXRwdXRUYXJnZXQsIGxl dmVsLCBpbnRlcm5hbEZvcm1hdCwgcm90YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVp Z2h0KCksIDAsIGZvcm1hdCwgdHlwZSwgbnVsbHB0cik7CisKKyAgICAvLyBjYWlyb19nbF9zdXJm YWNlX2NyZWF0ZV9mb3JfdGV4dHVyZSBzZXRzIHRoZXNlIHBhcmFtZXRlcnMgdG8gR0xfTkVBUkVT VCwgc28gd2UgbmVlZCB0byBiYWNrdXAgdGhlbQorICAgIEdDM0RpbnQgbWluRmlsdGVyLCBtYWdG aWx0ZXI7CisgICAgY29udGV4dC0+Z2V0VGV4UGFyYW1ldGVyaXYob3V0cHV0VGFyZ2V0LCBHTF9U RVhUVVJFX01JTl9GSUxURVIsICZtaW5GaWx0ZXIpOworICAgIGNvbnRleHQtPmdldFRleFBhcmFt ZXRlcml2KG91dHB1dFRhcmdldCwgR0xfVEVYVFVSRV9NQUdfRklMVEVSLCAmbWFnRmlsdGVyKTsK KworICAgIFJlZlB0cjxjYWlyb19zdXJmYWNlX3Q+IG91dHB1dFN1cmZhY2UgPSBhZG9wdFJlZihj YWlyb19nbF9zdXJmYWNlX2NyZWF0ZV9mb3JfdGV4dHVyZShkZXZpY2UsIENBSVJPX0NPTlRFTlRf Q09MT1JfQUxQSEEsIG91dHB1dFRleHR1cmUsIHJvdGF0ZWRTaXplLndpZHRoKCksIHJvdGF0ZWRT aXplLmhlaWdodCgpKSk7CisgICAgaWYgKCFwYWludFRvQ2Fpcm9TdXJmYWNlKG91dHB1dFN1cmZh Y2UsIGRldmljZSwgJnZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGNv bnRleHQtPmJpbmRUZXh0dXJlKG91dHB1dFRhcmdldCwgb3V0cHV0VGV4dHVyZSk7CisgICAgY29u dGV4dC0+dGV4UGFyYW1ldGVyaShvdXRwdXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhU VVJFX01JTl9GSUxURVIsIG1pbkZpbHRlcik7CisgICAgY29udGV4dC0+dGV4UGFyYW1ldGVyaShv dXRwdXRUYXJnZXQsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFX01BR19GSUxURVIsIG1hZ0Zp bHRlcik7CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworTmF0aXZlSW1hZ2VQdHIgTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpCit7Cisj aWYgVVNFKENBSVJPKSAmJiBFTkFCTEUoQUNDRUxFUkFURURfMkRfQ0FOVkFTKQorICAgIGlmICht X3VzaW5nRmFsbGJhY2tWaWRlb1NpbmspCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAg R3N0VmlkZW9JbmZvIHZpZGVvSW5mbzsKKyAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxv Y2sobV9zYW1wbGVNdXRleCk7CisgICAgaWYgKCFnZXRTYW1wbGVWaWRlb0luZm8obV9zYW1wbGUu Z2V0KCksIHZpZGVvSW5mbykpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgR0xDb250 ZXh0KiBjb250ZXh0ID0gUGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5Rm9yQ29tcG9zaXRp bmcoKS5zaGFyaW5nR0xDb250ZXh0KCk7CisgICAgY29udGV4dC0+bWFrZUNvbnRleHRDdXJyZW50 KCk7CisgICAgY2Fpcm9fZGV2aWNlX3QqIGRldmljZSA9IGNvbnRleHQtPmNhaXJvRGV2aWNlKCk7 CisKKyAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBwZXJmb3JtYW5jZSBoaXQgb24g bm9uLUludGVsIGRyaXZlcnMuCisgICAgY2Fpcm9fZ2xfZGV2aWNlX3NldF90aHJlYWRfYXdhcmUo ZGV2aWNlLCBGQUxTRSk7CisKKyAgICBJbnRTaXplIHNpemUgPSBJbnRTaXplKEdTVF9WSURFT19J TkZPX1dJRFRIKCZ2aWRlb0luZm8pLCBHU1RfVklERU9fSU5GT19IRUlHSFQoJnZpZGVvSW5mbykp OworICAgIEludFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3JpZW50YXRpb24udXNl c1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNpemU7CisgICAgUmVm UHRyPGNhaXJvX3N1cmZhY2VfdD4gcm90YXRlZFN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb19nbF9z dXJmYWNlX2NyZWF0ZShkZXZpY2UsIENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIHJvdGF0ZWRT aXplLndpZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKSk7CisKKyAgICBpZiAoIXBhaW50VG9D YWlyb1N1cmZhY2Uocm90YXRlZFN1cmZhY2UsIGRldmljZSwgJnZpZGVvSW5mbykpCisgICAgICAg IHJldHVybiBudWxscHRyOworCiAgICAgcmV0dXJuIHJvdGF0ZWRTdXJmYWNlOwogI2Vsc2UKICAg ICByZXR1cm4gbnVsbHB0cjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyQmFzZS5oCmluZGV4IGRlNmQyMzEyM2NkOGMwODkxN2JhMjdhNDI2OTQ5ZjQwMDJh ZWVkOGMuLjRhZDc3MzdlYmVkNmFjNzZmN2EyMWNmNWIxZTQxODkyM2RkNTU5MmEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaApAQCAtMTE2 LDYgKzExNiw4IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAg ICBib29sIHBhaW50VG9DYWlyb1N1cmZhY2UoUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0 U3VyZmFjZSwgY2Fpcm9fZGV2aWNlX3QqLCBHc3RWaWRlb0luZm8qKTsKKyAgICBib29sIGNvcHlW aWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBsYXRmb3Jt M0RPYmplY3QsIEdDM0RlbnVtLCBHQzNEaW50LCBHQzNEZW51bSwgR0MzRGVudW0sIEdDM0RlbnVt LCBib29sLCBib29sKSBvdmVycmlkZTsKICAgICBOYXRpdmVJbWFnZVB0ciBuYXRpdmVJbWFnZUZv ckN1cnJlbnRUaW1lKCkgb3ZlcnJpZGU7CiAjZW5kaWYKIAo= 289542 2016-09-22 03:01:17 -0700 2016-09-22 04:35:11 -0700 Patch bug-159928-20160922115826.patch text/plain 9130 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA2MTQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDQ4NjdiYTU2MWNhOWFi YzgyNGQ4YTE2NWE2YzhlNTk1NTM3ZDRjNC4uNGI1OTg1M2JjOWE4OWY2NWUzYmU0MzlmZDBlY2Rm YWFmZDJmYjI0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE2LTA5LTIxICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3YXMgbm90 IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnRleElt YWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xvdyBzb2Z0 d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAgIGNhaXJv IHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0byB0aGUK KyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBzb2Z0d2Fy ZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0dXJlLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIgYmFja2Vu ZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNvZGUgZnJv bSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fp cm9TdXJmYWNlKToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2U6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisgICAgICAgIChXZWJD b3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJl bnRUaW1lKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oOgorCiAyMDE2LTA5LTIwICBQZXIgQXJuZSBWb2xsYW4g IDxwdm9sbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBVbnJldmlld2VkIHdhcm5pbmcg Zml4LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJh c2UuY3BwCmluZGV4IDBmNWQxMTQ2MjQ0MGEyZWNmM2Q2ZjY3MzljNWNkYWJhZmEyMjkxNjQuLmFk ZTMwMzBjZDBhZTE0Y2VkMTlkZGM3YWM5N2UxYTI2YjJkNDgzNmMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTY5NywzNyAr Njk3LDM1IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFpbnRUb1Rl eHR1cmVNYXBwZXIoVGV4dHVyZU1hcHBlciYgdGV4dHVyCiAjZW5kaWYKIAogI2lmIFVTRShHU1RS RUFNRVJfR0wpCi1OYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNl OjpuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKKy8vIFRoaXMgc2hvdWxkIGJlIGNhbGxlZCB3 aXRoIHRoZSBzYW1wbGUgbXV0ZXggbG9ja2VkLgorR0xDb250ZXh0KiBNZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJCYXNlOjpwcmVwYXJlQ29udGV4dEZvckNhaXJvUGFpbnQoY2Fpcm9fZGV2aWNl X3QqJiBkZXZpY2UsIEdzdFZpZGVvSW5mbyYgdmlkZW9JbmZvLCBJbnRTaXplJiBzaXplLCBJbnRT aXplJiByb3RhdGVkU2l6ZSkKIHsKLSNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShBQ0NFTEVSQVRF RF8yRF9DQU5WQVMpCi0gICAgaWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykKKyAgICBpZiAo IWdldFNhbXBsZVZpZGVvSW5mbyhtX3NhbXBsZS5nZXQoKSwgdmlkZW9JbmZvKSkKICAgICAgICAg cmV0dXJuIG51bGxwdHI7CiAKLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9z YW1wbGVNdXRleCk7CisgICAgR0xDb250ZXh0KiBnbENvbnRleHQgPSBQbGF0Zm9ybURpc3BsYXk6 OnNoYXJlZERpc3BsYXlGb3JDb21wb3NpdGluZygpLnNoYXJpbmdHTENvbnRleHQoKTsKKyAgICBk ZXZpY2UgPSBnbENvbnRleHQtPmNhaXJvRGV2aWNlKCk7CiAKLSAgICBHc3RWaWRlb0luZm8gdmlk ZW9JbmZvOwotICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1fc2FtcGxlLmdldCgpLCB2aWRl b0luZm8pKQotICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICAvLyBUaHJlYWQtYXdhcmVuZXNz IGlzIGEgaHVnZSBwZXJmb3JtYW5jZSBoaXQgb24gbm9uLUludGVsIGRyaXZlcnMuCisgICAgY2Fp cm9fZ2xfZGV2aWNlX3NldF90aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxTRSk7CiAKKyAgICBzaXpl ID0gSW50U2l6ZShHU1RfVklERU9fSU5GT19XSURUSCgmdmlkZW9JbmZvKSwgR1NUX1ZJREVPX0lO Rk9fSEVJR0hUKCZ2aWRlb0luZm8pKTsKKyAgICByb3RhdGVkU2l6ZSA9IG1fdmlkZW9Tb3VyY2VP cmllbnRhdGlvbi51c2VzV2lkdGhBc0hlaWdodCgpID8gc2l6ZS50cmFuc3Bvc2VkU2l6ZSgpIDog c2l6ZTsKKworICAgIHJldHVybiBnbENvbnRleHQ7Cit9CisKKy8vIFRoaXMgc2hvdWxkIGJlIGNh bGxlZCB3aXRoIHRoZSBzYW1wbGUgbXV0ZXggbG9ja2VkLgorYm9vbCBNZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJCYXNlOjpwYWludFRvQ2Fpcm9TdXJmYWNlKGNhaXJvX3N1cmZhY2VfdCogb3V0 cHV0U3VyZmFjZSwgY2Fpcm9fZGV2aWNlX3QqIGRldmljZSwgR3N0VmlkZW9JbmZvJiB2aWRlb0lu Zm8sIGNvbnN0IEludFNpemUmIHNpemUsIGNvbnN0IEludFNpemUmIHJvdGF0ZWRTaXplKQorewog ICAgIEdzdEJ1ZmZlciogYnVmZmVyID0gZ3N0X3NhbXBsZV9nZXRfYnVmZmVyKG1fc2FtcGxlLmdl dCgpKTsKICAgICBHc3RWaWRlb0ZyYW1lIHZpZGVvRnJhbWU7CiAgICAgaWYgKCFnc3RfdmlkZW9f ZnJhbWVfbWFwKCZ2aWRlb0ZyYW1lLCAmdmlkZW9JbmZvLCBidWZmZXIsIHN0YXRpY19jYXN0PEdz dE1hcEZsYWdzPihHU1RfTUFQX1JFQUQgfCBHU1RfTUFQX0dMKSkpCi0gICAgICAgIHJldHVybiBu dWxscHRyOwotCi0gICAgR0xDb250ZXh0KiBjb250ZXh0ID0gUGxhdGZvcm1EaXNwbGF5OjpzaGFy ZWREaXNwbGF5Rm9yQ29tcG9zaXRpbmcoKS5zaGFyaW5nR0xDb250ZXh0KCk7Ci0gICAgY29udGV4 dC0+bWFrZUNvbnRleHRDdXJyZW50KCk7Ci0gICAgY2Fpcm9fZGV2aWNlX3QqIGRldmljZSA9IGNv bnRleHQtPmNhaXJvRGV2aWNlKCk7Ci0KLSAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVn ZSBwZXJmb3JtYW5jZSBoaXQgb24gbm9uLUludGVsIGRyaXZlcnMuCi0gICAgY2Fpcm9fZ2xfZGV2 aWNlX3NldF90aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxTRSk7CisgICAgICAgIHJldHVybiBmYWxz ZTsKIAogICAgIHVuc2lnbmVkIHRleHR1cmVJRCA9ICpyZWludGVycHJldF9jYXN0PHVuc2lnbmVk Kj4odmlkZW9GcmFtZS5kYXRhWzBdKTsKLSAgICBJbnRTaXplIHNpemUgPSBJbnRTaXplKEdTVF9W SURFT19JTkZPX1dJRFRIKCZ2aWRlb0luZm8pLCBHU1RfVklERU9fSU5GT19IRUlHSFQoJnZpZGVv SW5mbykpOwogICAgIFJlZlB0cjxjYWlyb19zdXJmYWNlX3Q+IHN1cmZhY2UgPSBhZG9wdFJlZihj YWlyb19nbF9zdXJmYWNlX2NyZWF0ZV9mb3JfdGV4dHVyZShkZXZpY2UsIENBSVJPX0NPTlRFTlRf Q09MT1JfQUxQSEEsIHRleHR1cmVJRCwgc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpKSk7Ci0K LSAgICBJbnRTaXplIHJvdGF0ZWRTaXplID0gbV92aWRlb1NvdXJjZU9yaWVudGF0aW9uLnVzZXNX aWR0aEFzSGVpZ2h0KCkgPyBzaXplLnRyYW5zcG9zZWRTaXplKCkgOiBzaXplOwotICAgIFJlZlB0 cjxjYWlyb19zdXJmYWNlX3Q+IHJvdGF0ZWRTdXJmYWNlID0gYWRvcHRSZWYoY2Fpcm9fZ2xfc3Vy ZmFjZV9jcmVhdGUoZGV2aWNlLCBDQUlST19DT05URU5UX0NPTE9SX0FMUEhBLCByb3RhdGVkU2l6 ZS53aWR0aCgpLCByb3RhdGVkU2l6ZS5oZWlnaHQoKSkpOwotICAgIFJlZlB0cjxjYWlyb190PiBj ciA9IGFkb3B0UmVmKGNhaXJvX2NyZWF0ZShyb3RhdGVkU3VyZmFjZS5nZXQoKSkpOworICAgIFJl ZlB0cjxjYWlyb190PiBjciA9IGFkb3B0UmVmKGNhaXJvX2NyZWF0ZShvdXRwdXRTdXJmYWNlKSk7 CiAKICAgICBzd2l0Y2ggKG1fdmlkZW9Tb3VyY2VPcmllbnRhdGlvbikgewogICAgIGNhc2UgRGVm YXVsdEltYWdlT3JpZW50YXRpb246CkBAIC03NTcsNyArNzU1LDY4IEBAIE5hdGl2ZUltYWdlUHRy IE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6Om5hdGl2ZUltYWdlRm9yQ3VycmVudFRp bWUoKQogCiAgICAgZ3N0X3ZpZGVvX2ZyYW1lX3VubWFwKCZ2aWRlb0ZyYW1lKTsKIAotICAgIHJl dHVybiByb3RhdGVkU3VyZmFjZTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworYm9vbCBNZWRpYVBs YXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1 cmUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFBsYXRmb3JtM0RPYmplY3Qgb3V0cHV0VGV4 dHVyZSwgR0MzRGVudW0gb3V0cHV0VGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRl cm5hbEZvcm1hdCwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBib29sIHByZW11bHRp cGx5QWxwaGEsIGJvb2wgZmxpcFkpCit7CisjaWYgIVVTRShDQUlSTykKKyAgICByZXR1cm4gZmFs c2U7CisjZW5kaWYKKworICAgIGlmIChtX3VzaW5nRmFsbGJhY2tWaWRlb1NpbmspCisgICAgICAg IHJldHVybiBmYWxzZTsKKworICAgIGlmIChmbGlwWSB8fCBwcmVtdWx0aXBseUFscGhhKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlOworICAgIEdz dFZpZGVvSW5mbyB2aWRlb0luZm87CisgICAgSW50U2l6ZSBzaXplLCByb3RhdGVkU2l6ZTsKKyAg ICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7CisgICAgaWYg KCFwcmVwYXJlQ29udGV4dEZvckNhaXJvUGFpbnQoZGV2aWNlLCB2aWRlb0luZm8sIHNpemUsIHJv dGF0ZWRTaXplKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgLy8gQWxsb2NhdGUgdW5p bml0aWFsaXplZCBtZW1vcnkgZm9yIHRoZSBvdXRwdXQgdGV4dHVyZS4KKyAgICBjb250ZXh0LT5i aW5kVGV4dHVyZShvdXRwdXRUYXJnZXQsIG91dHB1dFRleHR1cmUpOworICAgIGNvbnRleHQtPnRl eEltYWdlMkREaXJlY3Qob3V0cHV0VGFyZ2V0LCBsZXZlbCwgaW50ZXJuYWxGb3JtYXQsIHJvdGF0 ZWRTaXplLndpZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpLCAwLCBmb3JtYXQsIHR5cGUsIG51 bGxwdHIpOworCisgICAgLy8gY2Fpcm9fZ2xfc3VyZmFjZV9jcmVhdGVfZm9yX3RleHR1cmUgc2V0 cyB0aGVzZSBwYXJhbWV0ZXJzIHRvIEdMX05FQVJFU1QsIHNvIHdlIG5lZWQgdG8gYmFja3VwIHRo ZW0KKyAgICBHQzNEaW50IG1pbkZpbHRlciwgbWFnRmlsdGVyOworICAgIGNvbnRleHQtPmdldFRl eFBhcmFtZXRlcml2KG91dHB1dFRhcmdldCwgR0xfVEVYVFVSRV9NSU5fRklMVEVSLCAmbWluRmls dGVyKTsKKyAgICBjb250ZXh0LT5nZXRUZXhQYXJhbWV0ZXJpdihvdXRwdXRUYXJnZXQsIEdMX1RF WFRVUkVfTUFHX0ZJTFRFUiwgJm1hZ0ZpbHRlcik7CisKKyAgICBjYWlyb19zdXJmYWNlX3QqIG91 dHB1dFN1cmZhY2UgPSBjYWlyb19nbF9zdXJmYWNlX2NyZWF0ZV9mb3JfdGV4dHVyZShkZXZpY2Us IENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIG91dHB1dFRleHR1cmUsIHJvdGF0ZWRTaXplLndp ZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKTsKKyAgICBpZiAoIXBhaW50VG9DYWlyb1N1cmZh Y2Uob3V0cHV0U3VyZmFjZSwgZGV2aWNlLCB2aWRlb0luZm8sIHNpemUsIHJvdGF0ZWRTaXplKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgY29udGV4dC0+YmluZFRleHR1cmUob3V0cHV0 VGFyZ2V0LCBvdXRwdXRUZXh0dXJlKTsKKyAgICBjb250ZXh0LT50ZXhQYXJhbWV0ZXJpKG91dHB1 dFRhcmdldCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfTUlOX0ZJTFRFUiwgbWluRmlsdGVy KTsKKyAgICBjb250ZXh0LT50ZXhQYXJhbWV0ZXJpKG91dHB1dFRhcmdldCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlRFWFRVUkVfTUFHX0ZJTFRFUiwgbWFnRmlsdGVyKTsKKworICAgIHJldHVybiB0cnVl OworfQorCitOYXRpdmVJbWFnZVB0ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpu YXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkKK3sKKyNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShB Q0NFTEVSQVRFRF8yRF9DQU5WQVMpCisgICAgaWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykK KyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBjYWlyb19kZXZpY2VfdCogZGV2aWNlOwor ICAgIEdzdFZpZGVvSW5mbyB2aWRlb0luZm87CisgICAgSW50U2l6ZSBzaXplLCByb3RhdGVkU2l6 ZTsKKyAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7Cisg ICAgR0xDb250ZXh0KiBjb250ZXh0ID0gcHJlcGFyZUNvbnRleHRGb3JDYWlyb1BhaW50KGRldmlj ZSwgdmlkZW9JbmZvLCBzaXplLCByb3RhdGVkU2l6ZSk7CisgICAgaWYgKCFjb250ZXh0KQorICAg ICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICBjb250ZXh0LT5tYWtlQ29udGV4dEN1cnJlbnQoKTsK KworICAgIGNhaXJvX3N1cmZhY2VfdCogcm90YXRlZFN1cmZhY2UgPSBjYWlyb19nbF9zdXJmYWNl X2NyZWF0ZShkZXZpY2UsIENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIHJvdGF0ZWRTaXplLndp ZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKTsKKyAgICBpZiAoIXBhaW50VG9DYWlyb1N1cmZh Y2Uocm90YXRlZFN1cmZhY2UsIGRldmljZSwgdmlkZW9JbmZvLCBzaXplLCByb3RhdGVkU2l6ZSkp CisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgcmV0dXJuIGFkb3B0UmVmKHJvdGF0ZWRT dXJmYWNlKTsKICNlbHNlCiAgICAgcmV0dXJuIG51bGxwdHI7CiAjZW5kaWYKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclBy aXZhdGVHU3RyZWFtZXJCYXNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oCmluZGV4IGRlNmQyMzEy M2NkOGMwODkxN2JhMjdhNDI2OTQ5ZjQwMDJhZWVkOGMuLjJmNTVlMmQ4YTkxMzdjOGE3NTNhNTBk ZmQ2MjdkY2M5MjQ1NzRmODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJp dmF0ZUdTdHJlYW1lckJhc2UuaApAQCAtNDcsNiArNDcsNyBAQCB0eXBlZGVmIHN0cnVjdCBfR3N0 R0xEaXNwbGF5IEdzdEdMRGlzcGxheTsKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQml0 bWFwVGV4dHVyZUdMOworY2xhc3MgR0xDb250ZXh0OwogY2xhc3MgR3JhcGhpY3NDb250ZXh0Owog Y2xhc3MgR3JhcGhpY3NDb250ZXh0M0Q7CiBjbGFzcyBJbnRTaXplOwpAQCAtMTE2LDYgKzExNyw3 IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAgICBib29sIGNv cHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBsYXRm b3JtM0RPYmplY3QsIEdDM0RlbnVtLCBHQzNEaW50LCBHQzNEZW51bSwgR0MzRGVudW0sIEdDM0Rl bnVtLCBib29sLCBib29sKSBvdmVycmlkZTsKICAgICBOYXRpdmVJbWFnZVB0ciBuYXRpdmVJbWFn ZUZvckN1cnJlbnRUaW1lKCkgb3ZlcnJpZGU7CiAjZW5kaWYKIApAQCAtMTMwLDYgKzEzMiw4IEBA IHByb3RlY3RlZDoKICAgICBzdGF0aWMgR3N0Rmxvd1JldHVybiBuZXdQcmVyb2xsQ2FsbGJhY2so R3N0RWxlbWVudCosIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UqKTsKICAgICBHc3RF bGVtZW50KiBjcmVhdGVHTEFwcFNpbmsoKTsKICAgICBHc3RFbGVtZW50KiBjcmVhdGVWaWRlb1Np bmtHTCgpOworICAgIEdMQ29udGV4dCogcHJlcGFyZUNvbnRleHRGb3JDYWlyb1BhaW50KGNhaXJv X2RldmljZV90KiYsIEdzdFZpZGVvSW5mbyYsIEludFNpemUmLCBJbnRTaXplJik7CisgICAgYm9v bCBwYWludFRvQ2Fpcm9TdXJmYWNlKGNhaXJvX3N1cmZhY2VfdCogb3V0cHV0U3VyZmFjZSwgY2Fp cm9fZGV2aWNlX3QqLCBHc3RWaWRlb0luZm8mLCBjb25zdCBJbnRTaXplJiwgY29uc3QgSW50U2l6 ZSYpOwogI2VuZGlmCiAKICAgICB2b2lkIHNldFN0cmVhbVZvbHVtZUVsZW1lbnQoR3N0U3RyZWFt Vm9sdW1lKik7Cg== 289547 2016-09-22 04:35:23 -0700 2016-09-22 05:46:10 -0700 Patch bug-159928-20160922133232.patch text/plain 9269 olivier.blin U3VidmVyc2lvbiBSZXZpc2lvbjogMjA2MTQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDQ4NjdiYTU2MWNhOWFi YzgyNGQ4YTE2NWE2YzhlNTk1NTM3ZDRjNC4uOTgzNzkzZjhkM2U0ZmQ0ZjdiMDhlOGJiMWI0Y2I2 MzRkNThjNDUzMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisyMDE2LTA5LTIyICBPbGl2 aWVyIEJsaW4gIDxvbGl2aWVyLmJsaW5Ac29mdGF0aG9tZS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gU3VwcG9ydCBhIGRpcmVjdCBHUFUtdG8tR1BVIGNvcHkgb2YgdmlkZW8gdGV4dHVyZXMg dG8gV2ViR0wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE1OTkyOAorCisgICAgICAgIFJldmlld2VkIGJ5IENhcmxvcyBHYXJjaWEgQ2FtcG9zLgorCisg ICAgICAgIENvcHkgb2YgR1N0cmVhbWVyIHZpZGVvIGZyYW1lcyB0byBXZWJHTCB0ZXh0dXJlcyB3 YXMgbm90IGFjY2VsZXJhdGVkLgorCisgICAgICAgIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6 OnRleEltYWdlMkQoSFRNTFZpZGVvRWxlbWVudCkgd2VudAorICAgICAgICB0aHJvdWdoIGEgc2xv dyBzb2Z0d2FyZSBwYWludCgpIHdyYXBwaW5nIHRoZSB2aWRlbyBmcmFtZSBpbnRvCisgICAgICAg IGNhaXJvIHN1cmZhY2UgKEltYWdlR1N0cmVhbWVyKSwgZG93bmxvYWRpbmcgaXQgdG8gZHJhdyB0 byB0aGUKKyAgICAgICAgaW1hZ2UgY2FjaGUgY29udGV4dCwgY29weWluZyBpdCBhZ2FpbiBpbiBz b2Z0d2FyZSwgYW5kIHVwbG9hZGluZworICAgICAgICBpdCBiYWNrIHRvIGFuIE9wZW5HTCB0ZXh0 dXJlLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBjb3B5VmlkZW9UZXh0dXJlVG9Q bGF0Zm9ybVRleHR1cmUoKSBmb3IKKyAgICAgICAgdGhlIEdTdHJlYW1lciBtZWRpYSBwbGF5ZXIg YmFja2VuZCwgdG8gZG8gR1BVLXRvLUdQVSBjb3B5LCBieQorICAgICAgICBleHRyYWN0aW5nIGNv ZGUgZnJvbSBuYXRpdmVJbWFnZUZvckN1cnJlbnRUaW1lKCkuCisKKyAgICAgICAgRG9pbmcgdGhp cyBhbHNvIGZpeGVzIGJ1ZyAjMTU5NjIxOiByZWQgYW5kIGJsdWUgY29sb3JzIHdlcmUKKyAgICAg ICAgc3dhcHBlZCBpbiB2aWRlbyByZW5kZXJlZCB0aHJvdWdoIFdlYkdMIHdpdGggR1NUUkVBTUVS X0dMIGVuYWJsZWQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVk aWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNZWRp YVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpwcmVwYXJlQ29udGV4dEZvckNhaXJvUGFpbnQp OgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cGFp bnRUb0NhaXJvU3VyZmFjZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgorICAgICAg ICAoV2ViQ29yZTo6TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VG b3JDdXJyZW50VGltZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01l ZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuaDoKKwogMjAxNi0wOS0yMCAgUGVyIEFybmUg Vm9sbGFuICA8cHZvbGxhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW1dpbl0gVW5yZXZpZXdlZCB3 YXJuaW5nIGZpeC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3Ry ZWFtZXJCYXNlLmNwcAppbmRleCAwZjVkMTE0NjI0NDBhMmVjZjNkNmY2NzM5YzVjZGFiYWZhMjI5 MTY0Li45MWU3ZjhhMjIyNmNjMWRiODYzOTNjMjBlMzY2YjQ5ZmZlOTVhMTMxIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQ cml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCkBAIC02 OTcsMzcgKzY5NywzNSBAQCB2b2lkIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6OnBh aW50VG9UZXh0dXJlTWFwcGVyKFRleHR1cmVNYXBwZXImIHRleHR1cgogI2VuZGlmCiAKICNpZiBV U0UoR1NUUkVBTUVSX0dMKQotTmF0aXZlSW1hZ2VQdHIgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVh bWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50VGltZSgpCisvLyBUaGlzIHNob3VsZCBiZSBj YWxsZWQgd2l0aCB0aGUgc2FtcGxlIG11dGV4IGxvY2tlZC4KK0dMQ29udGV4dCogTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6cHJlcGFyZUNvbnRleHRGb3JDYWlyb1BhaW50KEdzdFZp ZGVvSW5mbyYgdmlkZW9JbmZvLCBJbnRTaXplJiBzaXplLCBJbnRTaXplJiByb3RhdGVkU2l6ZSkK IHsKLSNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShBQ0NFTEVSQVRFRF8yRF9DQU5WQVMpCi0gICAg aWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykKLSAgICAgICAgcmV0dXJuIG51bGxwdHI7Ci0K LSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2sobV9zYW1wbGVNdXRleCk7Ci0KLSAg ICBHc3RWaWRlb0luZm8gdmlkZW9JbmZvOwogICAgIGlmICghZ2V0U2FtcGxlVmlkZW9JbmZvKG1f c2FtcGxlLmdldCgpLCB2aWRlb0luZm8pKQogICAgICAgICByZXR1cm4gbnVsbHB0cjsKIAotICAg IEdzdEJ1ZmZlciogYnVmZmVyID0gZ3N0X3NhbXBsZV9nZXRfYnVmZmVyKG1fc2FtcGxlLmdldCgp KTsKLSAgICBHc3RWaWRlb0ZyYW1lIHZpZGVvRnJhbWU7Ci0gICAgaWYgKCFnc3RfdmlkZW9fZnJh bWVfbWFwKCZ2aWRlb0ZyYW1lLCAmdmlkZW9JbmZvLCBidWZmZXIsIHN0YXRpY19jYXN0PEdzdE1h cEZsYWdzPihHU1RfTUFQX1JFQUQgfCBHU1RfTUFQX0dMKSkpCi0gICAgICAgIHJldHVybiBudWxs cHRyOwotCiAgICAgR0xDb250ZXh0KiBjb250ZXh0ID0gUGxhdGZvcm1EaXNwbGF5OjpzaGFyZWRE aXNwbGF5Rm9yQ29tcG9zaXRpbmcoKS5zaGFyaW5nR0xDb250ZXh0KCk7CiAgICAgY29udGV4dC0+ bWFrZUNvbnRleHRDdXJyZW50KCk7Ci0gICAgY2Fpcm9fZGV2aWNlX3QqIGRldmljZSA9IGNvbnRl eHQtPmNhaXJvRGV2aWNlKCk7CiAKICAgICAvLyBUaHJlYWQtYXdhcmVuZXNzIGlzIGEgaHVnZSBw ZXJmb3JtYW5jZSBoaXQgb24gbm9uLUludGVsIGRyaXZlcnMuCi0gICAgY2Fpcm9fZ2xfZGV2aWNl X3NldF90aHJlYWRfYXdhcmUoZGV2aWNlLCBGQUxTRSk7CisgICAgY2Fpcm9fZ2xfZGV2aWNlX3Nl dF90aHJlYWRfYXdhcmUoY29udGV4dC0+Y2Fpcm9EZXZpY2UoKSwgRkFMU0UpOworCisgICAgc2l6 ZSA9IEludFNpemUoR1NUX1ZJREVPX0lORk9fV0lEVEgoJnZpZGVvSW5mbyksIEdTVF9WSURFT19J TkZPX0hFSUdIVCgmdmlkZW9JbmZvKSk7CisgICAgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNl T3JpZW50YXRpb24udXNlc1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6 IHNpemU7CisKKyAgICByZXR1cm4gY29udGV4dDsKK30KKworLy8gVGhpcyBzaG91bGQgYmUgY2Fs bGVkIHdpdGggdGhlIHNhbXBsZSBtdXRleCBsb2NrZWQuCitib29sIE1lZGlhUGxheWVyUHJpdmF0 ZUdTdHJlYW1lckJhc2U6OnBhaW50VG9DYWlyb1N1cmZhY2UoY2Fpcm9fc3VyZmFjZV90KiBvdXRw dXRTdXJmYWNlLCBjYWlyb19kZXZpY2VfdCogZGV2aWNlLCBHc3RWaWRlb0luZm8mIHZpZGVvSW5m bywgY29uc3QgSW50U2l6ZSYgc2l6ZSwgY29uc3QgSW50U2l6ZSYgcm90YXRlZFNpemUpCit7Cisg ICAgR3N0QnVmZmVyKiBidWZmZXIgPSBnc3Rfc2FtcGxlX2dldF9idWZmZXIobV9zYW1wbGUuZ2V0 KCkpOworICAgIEdzdFZpZGVvRnJhbWUgdmlkZW9GcmFtZTsKKyAgICBpZiAoIWdzdF92aWRlb19m cmFtZV9tYXAoJnZpZGVvRnJhbWUsICZ2aWRlb0luZm8sIGJ1ZmZlciwgc3RhdGljX2Nhc3Q8R3N0 TWFwRmxhZ3M+KEdTVF9NQVBfUkVBRCB8IEdTVF9NQVBfR0wpKSkKKyAgICAgICAgcmV0dXJuIGZh bHNlOwogCiAgICAgdW5zaWduZWQgdGV4dHVyZUlEID0gKnJlaW50ZXJwcmV0X2Nhc3Q8dW5zaWdu ZWQqPih2aWRlb0ZyYW1lLmRhdGFbMF0pOwotICAgIEludFNpemUgc2l6ZSA9IEludFNpemUoR1NU X1ZJREVPX0lORk9fV0lEVEgoJnZpZGVvSW5mbyksIEdTVF9WSURFT19JTkZPX0hFSUdIVCgmdmlk ZW9JbmZvKSk7CiAgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gc3VyZmFjZSA9IGFkb3B0UmVm KGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlX2Zvcl90ZXh0dXJlKGRldmljZSwgQ0FJUk9fQ09OVEVO VF9DT0xPUl9BTFBIQSwgdGV4dHVyZUlELCBzaXplLndpZHRoKCksIHNpemUuaGVpZ2h0KCkpKTsK LQotICAgIEludFNpemUgcm90YXRlZFNpemUgPSBtX3ZpZGVvU291cmNlT3JpZW50YXRpb24udXNl c1dpZHRoQXNIZWlnaHQoKSA/IHNpemUudHJhbnNwb3NlZFNpemUoKSA6IHNpemU7Ci0gICAgUmVm UHRyPGNhaXJvX3N1cmZhY2VfdD4gcm90YXRlZFN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb19nbF9z dXJmYWNlX2NyZWF0ZShkZXZpY2UsIENBSVJPX0NPTlRFTlRfQ09MT1JfQUxQSEEsIHJvdGF0ZWRT aXplLndpZHRoKCksIHJvdGF0ZWRTaXplLmhlaWdodCgpKSk7Ci0gICAgUmVmUHRyPGNhaXJvX3Q+ IGNyID0gYWRvcHRSZWYoY2Fpcm9fY3JlYXRlKHJvdGF0ZWRTdXJmYWNlLmdldCgpKSk7CisgICAg UmVmUHRyPGNhaXJvX3Q+IGNyID0gYWRvcHRSZWYoY2Fpcm9fY3JlYXRlKG91dHB1dFN1cmZhY2Up KTsKIAogICAgIHN3aXRjaCAobV92aWRlb1NvdXJjZU9yaWVudGF0aW9uKSB7CiAgICAgY2FzZSBE ZWZhdWx0SW1hZ2VPcmllbnRhdGlvbjoKQEAgLTc1Nyw2ICs3NTUsNjUgQEAgTmF0aXZlSW1hZ2VQ dHIgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6bmF0aXZlSW1hZ2VGb3JDdXJyZW50 VGltZSgpCiAKICAgICBnc3RfdmlkZW9fZnJhbWVfdW5tYXAoJnZpZGVvRnJhbWUpOwogCisgICAg cmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6 Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250 ZXh0LCBQbGF0Zm9ybTNET2JqZWN0IG91dHB1dFRleHR1cmUsIEdDM0RlbnVtIG91dHB1dFRhcmdl dCwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIEdDM0RlbnVtIGZvcm1h dCwgR0MzRGVudW0gdHlwZSwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQorewor I2lmICFVU0UoQ0FJUk8pCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCisKKyAgICBpZiAobV91 c2luZ0ZhbGxiYWNrVmlkZW9TaW5rKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAo ZmxpcFkgfHwgcHJlbXVsdGlwbHlBbHBoYSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg R3N0VmlkZW9JbmZvIHZpZGVvSW5mbzsKKyAgICBJbnRTaXplIHNpemUsIHJvdGF0ZWRTaXplOwor ICAgIFdURjo6R011dGV4TG9ja2VyPEdNdXRleD4gbG9jayhtX3NhbXBsZU11dGV4KTsKKyAgICBH TENvbnRleHQqIGdsQ29udGV4dCA9IHByZXBhcmVDb250ZXh0Rm9yQ2Fpcm9QYWludCh2aWRlb0lu Zm8sIHNpemUsIHJvdGF0ZWRTaXplKTsKKyAgICBpZiAoIWdsQ29udGV4dCkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgLy8gQWxsb2NhdGUgdW5pbml0aWFsaXplZCBtZW1vcnkgZm9yIHRo ZSBvdXRwdXQgdGV4dHVyZS4KKyAgICBjb250ZXh0LT5iaW5kVGV4dHVyZShvdXRwdXRUYXJnZXQs IG91dHB1dFRleHR1cmUpOworICAgIGNvbnRleHQtPnRleEltYWdlMkREaXJlY3Qob3V0cHV0VGFy Z2V0LCBsZXZlbCwgaW50ZXJuYWxGb3JtYXQsIHJvdGF0ZWRTaXplLndpZHRoKCksIHJvdGF0ZWRT aXplLmhlaWdodCgpLCAwLCBmb3JtYXQsIHR5cGUsIG51bGxwdHIpOworCisgICAgLy8gY2Fpcm9f Z2xfc3VyZmFjZV9jcmVhdGVfZm9yX3RleHR1cmUgc2V0cyB0aGVzZSBwYXJhbWV0ZXJzIHRvIEdM X05FQVJFU1QsIHNvIHdlIG5lZWQgdG8gYmFja3VwIHRoZW0uCisgICAgR0MzRGludCBtaW5GaWx0 ZXIsIG1hZ0ZpbHRlcjsKKyAgICBjb250ZXh0LT5nZXRUZXhQYXJhbWV0ZXJpdihvdXRwdXRUYXJn ZXQsIEdMX1RFWFRVUkVfTUlOX0ZJTFRFUiwgJm1pbkZpbHRlcik7CisgICAgY29udGV4dC0+Z2V0 VGV4UGFyYW1ldGVyaXYob3V0cHV0VGFyZ2V0LCBHTF9URVhUVVJFX01BR19GSUxURVIsICZtYWdG aWx0ZXIpOworCisgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gb3V0cHV0U3VyZmFjZSA9IGFk b3B0UmVmKGNhaXJvX2dsX3N1cmZhY2VfY3JlYXRlX2Zvcl90ZXh0dXJlKGdsQ29udGV4dC0+Y2Fp cm9EZXZpY2UoKSwgQ0FJUk9fQ09OVEVOVF9DT0xPUl9BTFBIQSwgb3V0cHV0VGV4dHVyZSwgcm90 YXRlZFNpemUud2lkdGgoKSwgcm90YXRlZFNpemUuaGVpZ2h0KCkpKTsKKyAgICBpZiAoIXBhaW50 VG9DYWlyb1N1cmZhY2Uob3V0cHV0U3VyZmFjZS5nZXQoKSwgZ2xDb250ZXh0LT5jYWlyb0Rldmlj ZSgpLCB2aWRlb0luZm8sIHNpemUsIHJvdGF0ZWRTaXplKSkKKyAgICAgICAgcmV0dXJuIGZhbHNl OworCisgICAgY29udGV4dC0+YmluZFRleHR1cmUob3V0cHV0VGFyZ2V0LCBvdXRwdXRUZXh0dXJl KTsKKyAgICBjb250ZXh0LT50ZXhQYXJhbWV0ZXJpKG91dHB1dFRhcmdldCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlRFWFRVUkVfTUlOX0ZJTFRFUiwgbWluRmlsdGVyKTsKKyAgICBjb250ZXh0LT50ZXhQ YXJhbWV0ZXJpKG91dHB1dFRhcmdldCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfTUFHX0ZJ TFRFUiwgbWFnRmlsdGVyKTsKKworICAgIHJldHVybiB0cnVlOworfQorCitOYXRpdmVJbWFnZVB0 ciBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpuYXRpdmVJbWFnZUZvckN1cnJlbnRU aW1lKCkKK3sKKyNpZiBVU0UoQ0FJUk8pICYmIEVOQUJMRShBQ0NFTEVSQVRFRF8yRF9DQU5WQVMp CisgICAgaWYgKG1fdXNpbmdGYWxsYmFja1ZpZGVvU2luaykKKyAgICAgICAgcmV0dXJuIG51bGxw dHI7CisKKyAgICBHc3RWaWRlb0luZm8gdmlkZW9JbmZvOworICAgIEludFNpemUgc2l6ZSwgcm90 YXRlZFNpemU7CisgICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKG1fc2FtcGxlTXV0 ZXgpOworICAgIEdMQ29udGV4dCogY29udGV4dCA9IHByZXBhcmVDb250ZXh0Rm9yQ2Fpcm9QYWlu dCh2aWRlb0luZm8sIHNpemUsIHJvdGF0ZWRTaXplKTsKKyAgICBpZiAoIWNvbnRleHQpCisgICAg ICAgIHJldHVybiBudWxscHRyOworCisgICAgUmVmUHRyPGNhaXJvX3N1cmZhY2VfdD4gcm90YXRl ZFN1cmZhY2UgPSBhZG9wdFJlZihjYWlyb19nbF9zdXJmYWNlX2NyZWF0ZShjb250ZXh0LT5jYWly b0RldmljZSgpLCBDQUlST19DT05URU5UX0NPTE9SX0FMUEhBLCByb3RhdGVkU2l6ZS53aWR0aCgp LCByb3RhdGVkU2l6ZS5oZWlnaHQoKSkpOworICAgIGlmICghcGFpbnRUb0NhaXJvU3VyZmFjZShy b3RhdGVkU3VyZmFjZS5nZXQoKSwgY29udGV4dC0+Y2Fpcm9EZXZpY2UoKSwgdmlkZW9JbmZvLCBz aXplLCByb3RhdGVkU2l6ZSkpCisgICAgICAgIHJldHVybiBudWxscHRyOworCiAgICAgcmV0dXJu IHJvdGF0ZWRTdXJmYWNlOwogI2Vsc2UKICAgICByZXR1cm4gbnVsbHB0cjsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclBy aXZhdGVHU3RyZWFtZXJCYXNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5oCmluZGV4IGRlNmQyMzEy M2NkOGMwODkxN2JhMjdhNDI2OTQ5ZjQwMDJhZWVkOGMuLmU0YWM5Yzg0MDc3NjIxOWI2OTExMTc5 MzcwYmE4YzFjZGZhMWFhODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJp dmF0ZUdTdHJlYW1lckJhc2UuaApAQCAtNDcsNiArNDcsNyBAQCB0eXBlZGVmIHN0cnVjdCBfR3N0 R0xEaXNwbGF5IEdzdEdMRGlzcGxheTsKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQml0 bWFwVGV4dHVyZUdMOworY2xhc3MgR0xDb250ZXh0OwogY2xhc3MgR3JhcGhpY3NDb250ZXh0Owog Y2xhc3MgR3JhcGhpY3NDb250ZXh0M0Q7CiBjbGFzcyBJbnRTaXplOwpAQCAtMTE2LDYgKzExNyw3 IEBAIHB1YmxpYzoKICNlbmRpZgogCiAjaWYgVVNFKEdTVFJFQU1FUl9HTCkKKyAgICBib29sIGNv cHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBsYXRm b3JtM0RPYmplY3QsIEdDM0RlbnVtLCBHQzNEaW50LCBHQzNEZW51bSwgR0MzRGVudW0sIEdDM0Rl bnVtLCBib29sLCBib29sKSBvdmVycmlkZTsKICAgICBOYXRpdmVJbWFnZVB0ciBuYXRpdmVJbWFn ZUZvckN1cnJlbnRUaW1lKCkgb3ZlcnJpZGU7CiAjZW5kaWYKIApAQCAtMTMwLDYgKzEzMiw4IEBA IHByb3RlY3RlZDoKICAgICBzdGF0aWMgR3N0Rmxvd1JldHVybiBuZXdQcmVyb2xsQ2FsbGJhY2so R3N0RWxlbWVudCosIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UqKTsKICAgICBHc3RF bGVtZW50KiBjcmVhdGVHTEFwcFNpbmsoKTsKICAgICBHc3RFbGVtZW50KiBjcmVhdGVWaWRlb1Np bmtHTCgpOworICAgIEdMQ29udGV4dCogcHJlcGFyZUNvbnRleHRGb3JDYWlyb1BhaW50KEdzdFZp ZGVvSW5mbyYsIEludFNpemUmLCBJbnRTaXplJik7CisgICAgYm9vbCBwYWludFRvQ2Fpcm9TdXJm YWNlKGNhaXJvX3N1cmZhY2VfdCosIGNhaXJvX2RldmljZV90KiwgR3N0VmlkZW9JbmZvJiwgY29u c3QgSW50U2l6ZSYsIGNvbnN0IEludFNpemUmKTsKICNlbmRpZgogCiAgICAgdm9pZCBzZXRTdHJl YW1Wb2x1bWVFbGVtZW50KEdzdFN0cmVhbVZvbHVtZSopOwo=