111126 2013-02-28 16:03:46 -0800 Enable GPU-GPU texture copy in texImage2D() for HTMLVideoElement if hardware accelerated video decode is in use 2013-04-02 16:26:10 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 113493 0 jun.a.jiang webkit-unassigned abarth bajones buildbot danakj dglazkov dino eric.carlson esprehn+autocc feature-media-reviews fishd gman jamesr jer.noble kalyan.kondapally kbr kondapallykalyan levin+threading ojan.autocc rniwa scherkus tkent+wkapi vjaquez vrk webkit.review.bot zmo oldest_to_newest 844584 0 jun.a.jiang 2013-02-28 16:03:46 -0800 Hardware accelerated video decode is supported in most platforms like Windows, Mac OSX, ChromeOS, etc, to improve Video playback performance. There is a possibility to do a GPU-GPU texture copy instead of CPU readback and upload in texImage2D() for HTMLVideoElement in WebGL when hardware accelerated video decode is in use. 844613 1 190838 jun.a.jiang 2013-02-28 16:39:30 -0800 Created attachment 190838 Patch 844657 2 190838 buildbot 2013-02-28 17:35:22 -0800 Comment on attachment 190838 Patch Attachment 190838 did not pass mac-wk2-ews (mac-wk2): Output: http://webkit-commit-queue.appspot.com/results/16772714 844693 3 190838 buildbot 2013-02-28 18:14:41 -0800 Comment on attachment 190838 Patch Attachment 190838 did not pass mac-ews (mac): Output: http://webkit-commit-queue.appspot.com/results/16672799 844798 4 190881 jun.a.jiang 2013-02-28 21:44:03 -0800 Created attachment 190881 Patch 845154 5 jun.a.jiang 2013-03-01 07:28:39 -0800 Fix the unused parameter error for Mac builds. At the very beginning, let chromium the first to support the GPU-GPU texture copy in texImage2D() for HTMLVideoElement in WebGL . And there is another small patch(webkit/media/webvideoframe_impl.h/.cc) in chromium project to work with this patch together to get GPU-GPU texture copy working. 845193 6 190881 eric.carlson 2013-03-01 08:18:15 -0800 Comment on attachment 190881 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=190881&action=review > Source/WebCore/ChangeLog:8 > + In texImage2D() for HTMLVideoElement in WebGL, it is possible to do a GPU-GPU texture copy instead of CPU readback and upload when hardware accelerated video decode is in use. Each platform needs to implement the interface isVideoFrameOfFormatNativeTexture() and copyVideoFrameInTexture() to make it truely work. Nit: please wrap this very long line. > Source/WebCore/ChangeLog:14 > + (WebCore): These useless entries can be removed. > Source/WebCore/ChangeLog:15 > + (WebCore::HTMLVideoElement::copyVideoFrameInTexture): I think it is helpful to have per-method comments describing what changed. > Source/WebCore/html/HTMLVideoElement.cpp:245 > + player()->setVisible(true); > + return player()->isVideoFrameOfFormatNativeTexture(); It seems strange that the visibility may change as a side effect of asking this question. 845323 7 190881 eric.carlson 2013-03-01 11:07:23 -0800 Comment on attachment 190881 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=190881&action=review > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4116 > + if (!video || !video->videoWidth() || !video->videoHeight()) { > + synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "no video"); > + return; > + } Is this change required by this patch or is it just an opportunistic fix? > Source/WebCore/platform/graphics/MediaPlayer.h:334 > + bool isVideoFrameOfFormatNativeTexture(); > + bool copyVideoFrameInTexture(GraphicsContext3D&, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); Why does copyVideoFrameInTexture() take a format parameter but isVideoFrameOfFormatNativeTexture() does not? 845618 8 190881 kbr 2013-03-01 16:41:52 -0800 Comment on attachment 190881 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=190881&action=review Thanks for your work on this. It's a good start, but looks like it needs more iteration. > Source/WebCore/ChangeLog:10 > + Already covered by current tests. How much testing did you do? Are you sure that the accelerated video decode path has been exercised? >> Source/WebCore/html/HTMLVideoElement.cpp:245 >> + return player()->isVideoFrameOfFormatNativeTexture(); > > It seems strange that the visibility may change as a side effect of asking this question. I agree. That seems not only strange but incorrect. What if the video tag is deliberately made invisible by the application so that it renders only within the WebGL scene, and not on the rest of the page? > Source/WebCore/html/HTMLVideoElement.h:68 > + bool copyVideoFrameInTexture(GraphicsContext3D&, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); Please document the side-effects of this method. For example, does it redefine the texture, or expect it to already be the correct size? How is the internalFormat parameter used? (I realize that some of these semantics are defined by the basically undocumented GL_CHROMIUM_copy_texture extension, but please make it clear what the requirements are for other ports implementing this.) Consider doing this documentation in MediaPlayer.h and adding a comment pointing there from here. It would be ideal if you could use enums here instead of bools so that the call sites are more descriptive, but I realize that that might be more trouble than it's worth since you have to pass these values all the way down to the platform layer. Using a reference instead of a pointer for the GraphicsContext3D is confusing and doesn't match the rest of the code. Finally, I'd like to suggest "isVideoFrameOfNativeTextureFormat" and "copyVideoFrameToTexture" as easier-to-read names for these methods. > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3882 > + && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) { These checks are confusing. Can you write them in a more concise way? What about adding a method to WebGLTexture to indicate whether it's been defined yet? >> Source/WebCore/platform/graphics/MediaPlayer.h:334 >> + bool copyVideoFrameInTexture(GraphicsContext3D&, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); > > Why does copyVideoFrameInTexture() take a format parameter but isVideoFrameOfFormatNativeTexture() does not? When you add documentation for the semantics of HTMLVideoElement's method, please add a comment here pointing to it -- or better, put the documentation here and point HTMLVideoElement to it. > Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:804 > + context.pixelStorei(Extensions3D::UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, false); Changing the pixel store parameters of WebGL's OpenGL context during video upload is sloppy. I'm not sure this is even needed. Since GL_CHROMIUM_copy_texture obeys these pixel store parameters, and they've already been set in the passed GraphicsContext3D, I think these can just be unused parameters in this port. Please make sure that changing these parameters (at least the flipY parameter) is tested with the accelerated video decode path. 846470 9 190881 jun.a.jiang 2013-03-04 07:29:50 -0800 Comment on attachment 190881 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=190881&action=review >> Source/WebCore/ChangeLog:8 >> + In texImage2D() for HTMLVideoElement in WebGL, it is possible to do a GPU-GPU texture copy instead of CPU readback and upload when hardware accelerated video decode is in use. Each platform needs to implement the interface isVideoFrameOfFormatNativeTexture() and copyVideoFrameInTexture() to make it truely work. > > Nit: please wrap this very long line. Thanks, I will wrap the line. >> Source/WebCore/ChangeLog:10 >> + Already covered by current tests. > > How much testing did you do? Are you sure that the accelerated video decode path has been exercised? I had tested Chromium on Linux, Win7 and Mac. As mentioned earlier, to make chromium work as expected, another patch at chromium https://codereview.chromium.org/12385073/ is needed. 1)there is no hardware accelerated video decode support for chromium on Linux. 2)for Mac, hardware accelerated video decode is disabled in mac_video_decode_accelerator.mm. MacVideoDecodeAccelerator::Initialize() always return false if (true). After removing the "return false", the pipeline is ready but will meet GPU decode error. 3)it works very well on win7. Using a small test example on my laptop to upload video to a cube (win7, Qua core 2.5GHz, Intel Graphics HD 3000, Video source(720p H264 video, 24 FPS) ), the latest Google chrome consumes 50% CPU, 76% GPU and gets a ~33 FPS for WebGL while latest chromium with my patch and H264 enabled in GYP_DEFINES consumes 26% CPU, %90 GPU and enjoys ~55 FPS for WebGL. GPU-GPU texture copy have much performance gain over CPU readback and upload. >> Source/WebCore/ChangeLog:15 >> + (WebCore::HTMLVideoElement::copyVideoFrameInTexture): > > I think it is helpful to have per-method comments describing what changed. Yes, I should do that. Basically, 1). isVideoFrameOfFormatNativeTexture() is used to query if the format of underlying VideoFrame is NativeTexture. If it is of format NativeTexture, then hardware accelerated video decode is in use. If it is of other format, such as YV12, YV16, etc, it is decoded using SW and GPU is not in use for decoding. 2). copyVideoFrameInTexture() is to do the GPU-GPU texture copy, which will return true only if GL_CHROMIUM_copy_texture extension is supported and other conditions are met. >>> Source/WebCore/html/HTMLVideoElement.cpp:245 >>> + return player()->isVideoFrameOfFormatNativeTexture(); >> >> It seems strange that the visibility may change as a side effect of asking this question. > > I agree. That seems not only strange but incorrect. What if the video tag is deliberately made invisible by the application so that it renders only within the WebGL scene, and not on the rest of the page? Yes, setVisible(true) is not needed here. I was affected by the original SW path using paintCurrentFrameInContext() by mistake. I had created a new bug for it at https://bugs.webkit.org/show_bug.cgi?id=111302 >> Source/WebCore/html/HTMLVideoElement.h:68 >> + bool copyVideoFrameInTexture(GraphicsContext3D&, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); > > Please document the side-effects of this method. For example, does it redefine the texture, or expect it to already be the correct size? How is the internalFormat parameter used? (I realize that some of these semantics are defined by the basically undocumented GL_CHROMIUM_copy_texture extension, but please make it clear what the requirements are for other ports implementing this.) Consider doing this documentation in MediaPlayer.h and adding a comment pointing there from here. > > It would be ideal if you could use enums here instead of bools so that the call sites are more descriptive, but I realize that that might be more trouble than it's worth since you have to pass these values all the way down to the platform layer. > > Using a reference instead of a pointer for the GraphicsContext3D is confusing and doesn't match the rest of the code. > > Finally, I'd like to suggest "isVideoFrameOfNativeTextureFormat" and "copyVideoFrameToTexture" as easier-to-read names for these methods. Thanks for your suggestions. The patch will be refined accordingly. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3882 >> + && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) { > > These checks are confusing. Can you write them in a more concise way? What about adding a method to WebGLTexture to indicate whether it's been defined yet? will be refined. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4116 >> + } > > Is this change required by this patch or is it just an opportunistic fix? The code is just moved from videoFrameToImage() to check the condition in a upper level. You can notice that these check was removed in videoFrameToImage(). >>> Source/WebCore/platform/graphics/MediaPlayer.h:334 >>> + bool copyVideoFrameInTexture(GraphicsContext3D&, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); >> >> Why does copyVideoFrameInTexture() take a format parameter but isVideoFrameOfFormatNativeTexture() does not? > > When you add documentation for the semantics of HTMLVideoElement's method, please add a comment here pointing to it -- or better, put the documentation here and point HTMLVideoElement to it. will be refined. >> Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:804 >> + context.pixelStorei(Extensions3D::UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, false); > > Changing the pixel store parameters of WebGL's OpenGL context during video upload is sloppy. I'm not sure this is even needed. Since GL_CHROMIUM_copy_texture obeys these pixel store parameters, and they've already been set in the passed GraphicsContext3D, I think these can just be unused parameters in this port. Please make sure that changing these parameters (at least the flipY parameter) is tested with the accelerated video decode path. My idea is that, The parameters UNPACK_FLIP_Y_CHROMIUM and UNPACK_PREMULTIPLY_ALPHA_CHROMIUM are cached in GraphicsContext3D but may not be in sync with that in GPU comand buffer. So set the two parameters down every time is needed. Since the underlying GraphicsContext in GPU may be shared, it is better to reset them back to default. I have re-tested flipY parameters. When setting UNPACK_FLIP_Y_WEBGL to true, the video is shown as normal. When setting it to false, the video is shown flipped. It seems I need to change "context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, flipY);" to "context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, !flipY);" 846503 10 danakj 2013-03-04 07:59:36 -0800 Is it possible to achieve this without using WebVideoFrame in webkit (ie move logic over to the chromium side of the boundary)? I'm meaning to make WebVideoFrame a completely empty base class, used only for shuffling data from chromium to chromium (and eventually removing it from WebKit entirely). Currently the only user of the WebVideoFrame is some android code which I was meaning to get around to fixing. But this moves in the opposite direction. 846914 11 kbr 2013-03-04 15:27:20 -0800 (In reply to comment #9) > My idea is that, The parameters UNPACK_FLIP_Y_CHROMIUM and UNPACK_PREMULTIPLY_ALPHA_CHROMIUM are cached in GraphicsContext3D but may not be in sync with that in GPU comand buffer. So set the two parameters down every time is needed. Since the underlying GraphicsContext in GPU may be shared, it is better to reset them back to default. OK, I see. I was confusing these parameters with the WebGL-specific ones (UNPACK_FLIP_Y_WEBGL, etc.) which are handled entirely by WebGLRenderingContext. > I have re-tested flipY parameters. When setting UNPACK_FLIP_Y_WEBGL to true, the video is shown as normal. When setting it to false, the video is shown flipped. It seems I need to change "context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, flipY);" to "context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, !flipY);" Yes, I can imagine there would be an issue like that. Please document very clearly any workaround like this which is needed. 847055 12 kbr 2013-03-04 17:06:18 -0800 (In reply to comment #10) > Is it possible to achieve this without using WebVideoFrame in webkit (ie move logic over to the chromium side of the boundary)? I'm meaning to make WebVideoFrame a completely empty base class, used only for shuffling data from chromium to chromium (and eventually removing it from WebKit entirely). Currently the only user of the WebVideoFrame is some android code which I was meaning to get around to fixing. But this moves in the opposite direction. Would the preferred way to do this be to add a new method to WebMediaPlayer which does the work? 847064 13 jamesr 2013-03-04 17:13:13 -0800 (In reply to comment #12) > (In reply to comment #10) > > Is it possible to achieve this without using WebVideoFrame in webkit (ie move logic over to the chromium side of the boundary)? I'm meaning to make WebVideoFrame a completely empty base class, used only for shuffling data from chromium to chromium (and eventually removing it from WebKit entirely). Currently the only user of the WebVideoFrame is some android code which I was meaning to get around to fixing. But this moves in the opposite direction. > > Would the preferred way to do this be to add a new method to WebMediaPlayer which does the work? Yeah, I think that'd be a better direction. 847068 14 kbr 2013-03-04 17:17:40 -0800 (In reply to comment #13) > (In reply to comment #12) > > (In reply to comment #10) > > > Is it possible to achieve this without using WebVideoFrame in webkit (ie move logic over to the chromium side of the boundary)? I'm meaning to make WebVideoFrame a completely empty base class, used only for shuffling data from chromium to chromium (and eventually removing it from WebKit entirely). Currently the only user of the WebVideoFrame is some android code which I was meaning to get around to fixing. But this moves in the opposite direction. > > > > Would the preferred way to do this be to add a new method to WebMediaPlayer which does the work? > > Yeah, I think that'd be a better direction. OK. Jun, could you recast your patch in that direction? I guess it actually isn't necessary in that case to fetch the WebVideoFrame, which would make it better from Dana's standpoint. 847083 15 jun.a.jiang 2013-03-04 17:34:42 -0800 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > (In reply to comment #10) > > > > Is it possible to achieve this without using WebVideoFrame in webkit (ie move logic over to the chromium side of the boundary)? I'm meaning to make WebVideoFrame a completely empty base class, used only for shuffling data from chromium to chromium (and eventually removing it from WebKit entirely). Currently the only user of the WebVideoFrame is some android code which I was meaning to get around to fixing. But this moves in the opposite direction. > > > > > > Would the preferred way to do this be to add a new method to WebMediaPlayer which does the work? > > > > Yeah, I think that'd be a better direction. > > OK. Jun, could you recast your patch in that direction? I guess it actually isn't necessary in that case to fetch the WebVideoFrame, which would make it better from Dana's standpoint. Yes, I agree with all of you and it is the right direction. Adding new APIs in WebMediaPlayer and letting chromium side to determine the implementations are much more flexible and suitable for later change. 847127 16 jamesr 2013-03-04 17:57:26 -0800 For the record, I'd like to move *all* of the compositor <-> media engine interactions to the chromium side. My ideal world would have something like: namespace WebKit { class WebMediaPlayer { public: ... WebLayer* createCompositingLayer() = 0; }; and the implementation in chromium would construct a cc::VideoLayer, wrap it in a WebLayer, and return that back to WebKit so WebCore can insert it into the compositing tree in the correct place. Then, from that point on, all interactions would be between cc::VideoLayer and the media:: pipeline stuff, using media::VideoFrame as the video frame data structure. This would mean no WebVideoLayer, no WebVideoFrame, no WebVideoFrameProvider, no adapters for any of these, etc. I just haven't had time to sit down and think through this fully (especially the startup/shutdown synchronization). So yes, adding this new functionality on the chromium side will definitely be more future proof. 847131 17 scherkus 2013-03-04 17:59:44 -0800 (In reply to comment #16) > For the record, I'd like to move *all* of the compositor <-> media engine interactions to the chromium side. My ideal world would have something like: > > namespace WebKit { > > class WebMediaPlayer { > public: > ... > WebLayer* createCompositingLayer() = 0; > }; > > and the implementation in chromium would construct a cc::VideoLayer, wrap it in a WebLayer, and return that back to WebKit so WebCore can insert it into the compositing tree in the correct place. Then, from that point on, all interactions would be between cc::VideoLayer and the media:: pipeline stuff, using media::VideoFrame as the video frame data structure. This would mean no WebVideoLayer, no WebVideoFrame, no WebVideoFrameProvider, no adapters for any of these, etc. I just haven't had time to sit down and think through this fully (especially the startup/shutdown synchronization). > > So yes, adding this new functionality on the chromium side will definitely be more future proof. jamesr: +100000 (I'd be happy to help think things through -- I have some scatterbrained ideas as well) 848785 18 191738 jun.a.jiang 2013-03-06 06:07:37 -0800 Created attachment 191738 Patch 848796 19 webkit.review.bot 2013-03-06 06:17:22 -0800 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 848813 20 jun.a.jiang 2013-03-06 06:45:52 -0800 Updated the patch to fix the Visible side effect, remove use of WebVideoFrame and add more comments. The relevant patch at chromium part is at https://codereview.chromium.org/12412007/ for review. The flipY value is respected and not reversed to make the GPU path get the same result as the original SW path. It should be the Application to set right FlipY value to get the expected result. The test cases to evaluate the WebGL performance can be found at https://github.com/Jun-Jiang/WebGL_examples. And the build out binaries for comparison can be found at https://github.com/Jun-Jiang/Chrome_binaries. 849424 21 191738 kbr 2013-03-06 16:17:56 -0800 Comment on attachment 191738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=191738&action=review Thanks for your continued work on this. The structure looks better but there are still some issues to be fixed. Also, let's make sure the Chromium API is in its desired form before landing this. > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3922 > + if (GraphicsContext3D::TEXTURE_2D == target && texture && (texture->getType(target, level) == type || !texture->isValid(target, level)) Since this is texImage2D, it reallocates and redefines the texture at the given level. Why then is there a requirement that the texture is either not yet valid at that level, or that its existing type at that level is equal to the specified one here? > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3924 > + if (video->videoDecodeAcceleratedByGpu() && video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) { If "level" isn't an argument to copyVideoTextureToPlatformTexture then this can't be doing the right thing in all cases. Either level needs to be restricted to 0 or something else needs to be changed here. > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4194 > + return; The duplication of these validation checks is unfortunate. Can they be refactored? > Source/WebCore/platform/graphics/MediaPlayer.h:342 > + // The destination texture may need to be resized to the dimensions of the source texture or wrapped to the required internalFormat. This description still isn't clear. Does this method resize/reallocate the destination texture (if necessary) or not? If it does, then why is there no "type" argument? (In the WebGLRenderingContext, this is stored along with the internalformat to validate subsequent calls to TexSubImage2D)? Why is there no "level" argument to this method? Is it implicitly 0? > Source/WebCore/platform/graphics/MediaPlayer.h:345 > + // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt. Requiring this Chromium-specific extension is not a reasonable requirement. Ports can implement this method any way they want to or can. You could point to this extension as having the desired semantics, but not require the extension to be available. > Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:789 > + // flipY==true means to reverse the Video position while flipY==false means to keep the intrinsic position. Does the flipY parameter behave the same for GPU-accelerated video and non-GPU-accelerated video? Also, "orientation" would be better than "position" here. 850088 22 191738 jun.a.jiang 2013-03-07 07:53:47 -0800 Comment on attachment 191738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=191738&action=review >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3922 >> + if (GraphicsContext3D::TEXTURE_2D == target && texture && (texture->getType(target, level) == type || !texture->isValid(target, level)) > > Since this is texImage2D, it reallocates and redefines the texture at the given level. Why then is there a requirement that the texture is either not yet valid at that level, or that its existing type at that level is equal to the specified one here? The current limitation here is that at the bottom level(shaders) GPU-GPU textures copy, it requires the type be UNSIGNED_BYTE. While in GPU command buffer implementation, DoCopyTexture() is implemented like this: 1): if the destination texture is defined already, but the internalFormat, width or height is not met as required, the destination texture will be re-defined. The internalFormat, width and height will be re-defined to the expected value. But the type would not be changed during the re-define process. 2): if the destination texture is not defined, the destination texture will be defined. The internalFormat, width, height and type will be defined to the same as the source textures. To sum up, the texture is either not defined(since the type of source texture from Video is assumed to be UNSIGNED_BYTE) or defined but with the type equals UNSIGNED_BYTE. The code is should be changed form ...(texture->getType(target, level) == type || !texture->isValid(target, level))... && type == UNSIGNED_BYTE to ...((texture->getType(target, level) == UNSIGNED_BYTE) || !texture->isValid(target, level))... and it will be better to understand. The condition "type == UNSIGNED_BYTE" is put last in my code and may be easily ignored. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3924 >> + if (video->videoDecodeAcceleratedByGpu() && video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) { > > If "level" isn't an argument to copyVideoTextureToPlatformTexture then this can't be doing the right thing in all cases. Either level needs to be restricted to 0 or something else needs to be changed here. Yes, there is a mistake here. Although the level of destination texture is assumed to at 0 here, it can't be hard-coded with no check. Moreover, it may be worthy to check if level > 0 works though all of current tests done set level to 0. Will update it to add a level parameter here even the level is restricted to 0 only. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4194 >> + return; > > The duplication of these validation checks is unfortunate. Can they be refactored? Do you mean validateTexFuncFormatAndType() and validateSettableTexFormat() have duplicate checks? >> Source/WebCore/platform/graphics/MediaPlayer.h:342 >> + // The destination texture may need to be resized to the dimensions of the source texture or wrapped to the required internalFormat. > > This description still isn't clear. Does this method resize/reallocate the destination texture (if necessary) or not? If it does, then why is there no "type" argument? (In the WebGLRenderingContext, this is stored along with the internalformat to validate subsequent calls to TexSubImage2D)? Why is there no "level" argument to this method? Is it implicitly 0? The type is assumed to be UNSIGNED_BYTE(defined texture) or 0(undefined texture) here. And in GPU command buffer in chromium port, it will be unified to UNSIGNED_BYTE. For level, it is assumed to be 0 here. However, since it is a file shared between different ports and the limitation may be relaxed one day, these two places need to be changed to add arguments. >> Source/WebCore/platform/graphics/MediaPlayer.h:345 >> + // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt. > > Requiring this Chromium-specific extension is not a reasonable requirement. Ports can implement this method any way they want to or can. You could point to this extension as having the desired semantics, but not require the extension to be available. Yes, will refine the comments. >> Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:789 >> + // flipY==true means to reverse the Video position while flipY==false means to keep the intrinsic position. > > Does the flipY parameter behave the same for GPU-accelerated video and non-GPU-accelerated video? Also, "orientation" would be better than "position" here. Yes. It behaves the same for GPU-accelerated video and non-GPU-accelerated video. Will change "position" to "orientation". 850091 23 jun.a.jiang 2013-03-07 07:54:59 -0800 View in context: https://bugs.webkit.org/attachment.cgi?id=191738&action=review >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3922 >> + if (GraphicsContext3D::TEXTURE_2D == target && texture && (texture->getType(target, level) == type || !texture->isValid(target, level)) > > Since this is texImage2D, it reallocates and redefines the texture at the given level. Why then is there a requirement that the texture is either not yet valid at that level, or that its existing type at that level is equal to the specified one here? The current limitation here is that at the bottom level(shaders) GPU-GPU textures copy, it requires the type be UNSIGNED_BYTE. While in GPU command buffer implementation, DoCopyTexture() is implemented like this: 1): if the destination texture is defined already, but the internalFormat, width or height is not met as required, the destination texture will be re-defined. The internalFormat, width and height will be re-defined to the expected value. But the type would not be changed during the re-define process. 2): if the destination texture is not defined, the destination texture will be defined. The internalFormat, width, height and type will be defined to the same as the source textures. To sum up, the texture is either not defined(since the type of source texture from Video is assumed to be UNSIGNED_BYTE) or defined but with the type equals UNSIGNED_BYTE. The code is should be changed form ...(texture->getType(target, level) == type || !texture->isValid(target, level))... && type == UNSIGNED_BYTE to ...((texture->getType(target, level) == UNSIGNED_BYTE) || !texture->isValid(target, level))... and it will be better to understand. The condition "type == UNSIGNED_BYTE" is put last in my code and may be easily ignored. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:3924 >> + if (video->videoDecodeAcceleratedByGpu() && video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) { > > If "level" isn't an argument to copyVideoTextureToPlatformTexture then this can't be doing the right thing in all cases. Either level needs to be restricted to 0 or something else needs to be changed here. Yes, there is a mistake here. Although the level of destination texture is assumed to at 0 here, it can't be hard-coded with no check. Moreover, it may be worthy to check if level > 0 works though all of current tests done set level to 0. Will update it to add a level parameter here even the level is restricted to 0 only. >> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4194 >> + return; > > The duplication of these validation checks is unfortunate. Can they be refactored? Do you mean validateTexFuncFormatAndType() and validateSettableTexFormat() have duplicate checks? >> Source/WebCore/platform/graphics/MediaPlayer.h:342 >> + // The destination texture may need to be resized to the dimensions of the source texture or wrapped to the required internalFormat. > > This description still isn't clear. Does this method resize/reallocate the destination texture (if necessary) or not? If it does, then why is there no "type" argument? (In the WebGLRenderingContext, this is stored along with the internalformat to validate subsequent calls to TexSubImage2D)? Why is there no "level" argument to this method? Is it implicitly 0? The type is assumed to be UNSIGNED_BYTE(defined texture) or 0(undefined texture) here. And in GPU command buffer in chromium port, it will be unified to UNSIGNED_BYTE. For level, it is assumed to be 0 here. However, since it is a file shared between different ports and the limitation may be relaxed one day, these two places need to be changed to add arguments. >> Source/WebCore/platform/graphics/MediaPlayer.h:345 >> + // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt. > > Requiring this Chromium-specific extension is not a reasonable requirement. Ports can implement this method any way they want to or can. You could point to this extension as having the desired semantics, but not require the extension to be available. Yes, will refine the comments. >> Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:789 >> + // flipY==true means to reverse the Video position while flipY==false means to keep the intrinsic position. > > Does the flipY parameter behave the same for GPU-accelerated video and non-GPU-accelerated video? Also, "orientation" would be better than "position" here. Yes. It behaves the same for GPU-accelerated video and non-GPU-accelerated video. Will change "position" to "orientation". 850299 24 191738 kbr 2013-03-07 11:08:37 -0800 Comment on attachment 191738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=191738&action=review >>> Source/WebCore/html/canvas/WebGLRenderingContext.cpp:4194 >>> + return; >> >> The duplication of these validation checks is unfortunate. Can they be refactored? > > Do you mean validateTexFuncFormatAndType() and validateSettableTexFormat() have duplicate checks? No, I mean that the checks were removed from videoFrameToImage and duplicated into texImage2D and texSubImage2D. 851894 25 192373 jun.a.jiang 2013-03-10 06:42:37 -0700 Created attachment 192373 Patch 851895 26 jun.a.jiang 2013-03-10 07:00:19 -0700 Reduced the two required APIs to one and make the code in WebCore more general. All the details are hide in platform layer. The corresponding patch for chromium project is at https://codereview.chromium.org/12412007/. 853011 27 192373 kbr 2013-03-11 19:36:34 -0700 Comment on attachment 192373 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192373&action=review Thanks for your continued work on this. It looks good overall, and the Chromium API change looks fine, but there's a new layering violation that requires one more change. > Source/WebCore/platform/graphics/MediaPlayer.h:350 > + bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, WebGLTexture*, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY); Code under platform/graphics is not supposed to reference WebCore types outside of platform/graphics like WebGLTexture*. While there are other violations of this rule in this class and in the WebGL implementation, it isn't good to add more. Please change the WebGLTexture* argument to Platform3DObject (defined in GraphicsTypes3D.h). > Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp:781 > + return false; Since according to the layering rules the WebGLTexture object won't be available here, please move these checks back up to WebGLRenderingContext.cpp and have them apply to all ports -- they aren't unreasonable restrictions. Also, please document the current restrictions in MediaPlayer.h. 853510 28 192745 jun.a.jiang 2013-03-12 08:53:13 -0700 Created attachment 192745 Patch 853523 29 jun.a.jiang 2013-03-12 09:03:28 -0700 Thanks for Kenneth's suggestions. Updated the patch to remove use of WebGLTexture inside of platform/graphics and move the restriction check to upper level. 853679 30 192745 kbr 2013-03-12 11:53:46 -0700 Comment on attachment 192745 Patch Very nice. Thank you for your hard work on this patch. r=me 853980 31 192745 webkit.review.bot 2013-03-12 18:49:51 -0700 Comment on attachment 192745 Patch Clearing flags on attachment: 192745 Committed r145669: <http://trac.webkit.org/changeset/145669> 853981 32 webkit.review.bot 2013-03-12 18:49:57 -0700 All reviewed patches have been landed. Closing bug. 190838 2013-02-28 16:39:30 -0800 2013-02-28 21:43:49 -0800 Patch bug-111126-20130301083732.patch text/plain 14762 jun.a.jiang U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ0MzkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTU3ZGIxM2M5OTU4ZGVk NDg4YjMxNWMyNTZjOGEyNGE1YmE4NWE4Ni4uYTU3ZmExNjZmNWMwZmI4YjQ1MTVmZTMwY2NlNGJi ZTk5ZGYwOGRlZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEzLTAyLTI4ICBKdW4g SmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJk d2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiB0ZXhJbWFnZTJEKCkgZm9yIEhUTUxW aWRlb0VsZW1lbnQgaW4gV2ViR0wsIGl0IGlzIHBvc3NpYmxlIHRvIGRvIGEgR1BVLUdQVSB0ZXh0 dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2sgYW5kIHVwbG9hZCB3aGVuIGhhcmR3YXJl IGFjY2VsZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBpbiB1c2UuIEVhY2ggcGxhdGZvcm0gbmVlZHMg dG8gaW1wbGVtZW50IHRoZSBpbnRlcmZhY2UgaXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0 dXJlKCkgYW5kIGNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKCkgdG8gbWFrZSBpdCB0cnVlbHkgd29y ay4KKworICAgICAgICBBbHJlYWR5IGNvdmVyZWQgYnkgY3VycmVudCB0ZXN0cy4KKworICAgICAg ICAqIGh0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVmlk ZW9FbGVtZW50Ojppc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUpOgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVmlkZW9FbGVtZW50Ojpjb3B5VmlkZW9G cmFtZUluVGV4dHVyZSk6CisgICAgICAgICogaHRtbC9IVE1MVmlkZW9FbGVtZW50Lmg6CisgICAg ICAgIChIVE1MVmlkZW9FbGVtZW50KToKKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFJlbmRl cmluZ0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpX ZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZpZGVvRnJhbWVUb0ltYWdlKToKKyAgICAgICAgKFdlYkNv cmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4SW1hZ2UyRCk6CisgICAgICAgIChXZWJDb3Jl OjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleFN1YkltYWdlMkQpOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxh eWVyOjppc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUpOgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXllcjo6Y29weVZpZGVvRnJhbWVJblRleHR1 cmUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmg6CisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKE1lZGlhUGxheWVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9NZWRpYVBsYXllclByaXZhdGUuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxh eWVyUHJpdmF0ZUludGVyZmFjZTo6aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0dXJlKToK KyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUludGVyZmFjZTo6Y29weVZpZGVv RnJhbWVJblRleHR1cmUpOgorCiAyMDEzLTAyLTI4ICAgVmluZWV0IENoYXVkaGFyeSAgPHJnZjc0 OEBtb3Rvcm9sYS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZC4gQmluZGluZ3MgdGVzdCByZXN1 bHRzIHVwZGF0ZSBhZnRlciByMTQ0Mzc2LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA0 NmU3Y2VhZGU5OTYxNmQyYjdiOTg3OTBmODhhYWM5ODc4MTM2ZmVkLi5jMmZiNTM1NjVlYmNlYzlm YmI2ZDg3Yzg0N2Q3ZGFmM2Q5N2ZiNzU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAt MSwzICsxLDE3IEBACisyMDEzLTAyLTI4ICBKdW4gSmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5j b20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUgdGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQo KSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJkd2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNv ZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIHNyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0 OjpXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4 dHVyZSk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRpYVBsYXll ckNsaWVudEltcGw6OmNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKToKKyAgICAgICAgKiBzcmMvV2Vi TWVkaWFQbGF5ZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJNZWRpYVBsYXllckNsaWVudElt cGwpOgorCiAyMDEzLTAyLTI4ICBWYXJ1biBKYWluICA8dmFydW5qYWluQGNocm9taXVtLm9yZz4K IAogICAgICAgICBBZGQgbmV3IHdlYmtpdCBBUEkgdG8gaW52b2tlIGEgY29udGV4dCBtZW51Lgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAKaW5kZXggY2ZlOTU3MTNmZjlk ZjhkNzM1NzViODAyZWU1ODFmMDhkZTY3ODQxZC4uMjFiNzAwMjgwYzE4YzUyOTVmOWQ2MWI5ZGFj Y2NkMTMyYWZjN2RlMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9F bGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuY3Bw CkBAIC0yMzcsNiArMjM3LDIyIEBAIHZvaWQgSFRNTFZpZGVvRWxlbWVudDo6cGFpbnRDdXJyZW50 RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zCiAgICAgcGxheWVy LT5wYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChjb250ZXh0LCBkZXN0UmVjdCk7CiB9CiAKK2Jv b2wgSFRNTFZpZGVvRWxlbWVudDo6aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0dXJlKCkK K3sKKyAgICBpZiAoIXBsYXllcigpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgcGxheWVy KCktPnNldFZpc2libGUodHJ1ZSk7CisgICAgcmV0dXJuIHBsYXllcigpLT5pc1ZpZGVvRnJhbWVP ZkZvcm1hdE5hdGl2ZVRleHR1cmUoKTsKK30KKworYm9vbCBIVE1MVmlkZW9FbGVtZW50Ojpjb3B5 VmlkZW9GcmFtZUluVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCYgY29udGV4dCwgUGxhdGZvcm0z RE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBs eUFscGhhLCBib29sIGZsaXBZKQoreworICAgIGlmICghcGxheWVyKCkpCisgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICBwbGF5ZXIoKS0+c2V0VmlzaWJsZSh0cnVlKTsKKyAgICByZXR1cm4gcGxh eWVyKCktPmNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKGNvbnRleHQsIHRleHR1cmUsIGludGVybmFs Rm9ybWF0LCBwcmVtdWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIGJvb2wgSFRNTFZpZGVvRWxl bWVudDo6aGFzQXZhaWxhYmxlVmlkZW9GcmFtZSgpIGNvbnN0CiB7CiAgICAgaWYgKCFwbGF5ZXIo KSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5oIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKaW5kZXggY2Y0ZmVhY2ZjYjcx YjIyZTM2OTEzYThkOTc4NGNhZWY0MTg1NDlhYi4uMDczNjZmYmJlNDhhMDQwZDgxMTBhYTc2ZTgy MDA0ODAyYjFmYzE0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9F bGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKQEAg LTYzLDYgKzYzLDEwIEBAIHB1YmxpYzoKICAgICAvLyBVc2VkIGJ5IGNhbnZhcyB0byBnYWluIHJh dyBwaXhlbCBhY2Nlc3MKICAgICB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBo aWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsKIAorICAgIC8vIFVzZWQgYnkgV2ViR0wgdG8g ZG8gR1BVLUdQVSB0ZXh0dXJlIGNvcHkgaWYgcG9zc2libGUuCisgICAgYm9vbCBpc1ZpZGVvRnJh bWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUoKTsKKyAgICBib29sIGNvcHlWaWRlb0ZyYW1lSW5UZXh0 dXJlKEdyYXBoaWNzQ29udGV4dDNEJiwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51 bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsKKwog ICAgIGJvb2wgc2hvdWxkRGlzcGxheVBvc3RlckltYWdlKCkgY29uc3QgeyByZXR1cm4gZGlzcGxh eU1vZGUoKSA9PSBQb3N0ZXIgfHwgZGlzcGxheU1vZGUoKSA9PSBQb3N0ZXJXYWl0aW5nRm9yVmlk ZW87IH0KIAogcHJpdmF0ZToKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFz L1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9X ZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCmluZGV4IGRlYjY0YjEwMjQxYTE0ZTg3ZjdlZTJiNDNh MTMwYTZmNjBhMTFkNTUuLjdhOTY4NTNiOWQzMWExNGNlNzY2NmRhYWUzZTY1ZDMyYjY1NWM0YWYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29u dGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdD b250ZXh0LmNwcApAQCAtMzg0NiwxMCArMzg0Niw2IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250 ZXh0Ojp0ZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0K ICNpZiBFTkFCTEUoVklERU8pCiBQYXNzUmVmUHRyPEltYWdlPiBXZWJHTFJlbmRlcmluZ0NvbnRl eHQ6OnZpZGVvRnJhbWVUb0ltYWdlKEhUTUxWaWRlb0VsZW1lbnQqIHZpZGVvLCBCYWNraW5nU3Rv cmVDb3B5IGJhY2tpbmdTdG9yZUNvcHksIEV4Y2VwdGlvbkNvZGUmIGVjKQogewotICAgIGlmICgh dmlkZW8gfHwgIXZpZGVvLT52aWRlb1dpZHRoKCkgfHwgIXZpZGVvLT52aWRlb0hlaWdodCgpKSB7 Ci0gICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZB TFVFLCAidGV4SW1hZ2UyRCIsICJubyB2aWRlbyIpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9 CiAgICAgSW50U2l6ZSBzaXplKHZpZGVvLT52aWRlb1dpZHRoKCksIHZpZGVvLT52aWRlb0hlaWdo dCgpKTsKICAgICBJbWFnZUJ1ZmZlciogYnVmID0gbV92aWRlb0NhY2hlLmltYWdlQnVmZmVyKHNp emUpOwogICAgIGlmICghYnVmKSB7CkBAIC0zODcyLDYgKzM4NjgsMjUgQEAgdm9pZCBXZWJHTFJl bmRlcmluZ0NvbnRleHQ6OnRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVs LCBHQzNEZW51bQogICAgIGVjID0gMDsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAg ICByZXR1cm47CisgICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVvV2lkdGgoKSB8fCAhdmlk ZW8tPnZpZGVvSGVpZ2h0KCkpIHsKKyAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3ND b250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJ0ZXhJbWFnZTJEIiwgIm5vIHZpZGVvIik7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyBJZiBoYXJkd2FyZS1hY2NlbGVyYXRlZCB2aWRl byBkZWNvZGUgaXMgaW4gdXNlLCBjb3B5IGZyb20gdGhlIFZpZGVvIGVsZW1lbnQgZGlyZWN0bHkg dG8gdGhlIHRleHR1cmUKKyAgICAvLyB2aWEgR1BVIGlmIHBvc3NpYmxlLCB3aXRob3V0IGEgcmVh ZC1iYWNrIHRvIHN5c3RlbSBtZW1vcnkuCisgICAgLy8gRklYTUU6IHJlc3RyaWN0aW9uIG9mIChS R0IgfHwgUkdCQSkvVU5TSUdORURfQllURSBzaG91bGQgYmUgbGlmdGVkIGluIHRoZSBmdXR1cmUu CisgICAgV2ViR0xUZXh0dXJlKiB0ZXh0dXJlID0gdmFsaWRhdGVUZXh0dXJlQmluZGluZygidGV4 SW1hZ2UyRCIsIHRhcmdldCwgdHJ1ZSk7CisgICAgY29uc3QgR0MzRGVudW0gd2ViR0xUZXh0dXJl RGVmYXVsdFR5cGUgPSAwOworICAgIGlmIChHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCA9 PSB0YXJnZXQgJiYgdGV4dHVyZSAmJiAodGV4dHVyZS0+Z2V0VHlwZSh0YXJnZXQsIGxldmVsKSA9 PSB0eXBlIHx8IHRleHR1cmUtPmdldFR5cGUodGFyZ2V0LCBsZXZlbCkgPT0gd2ViR0xUZXh0dXJl RGVmYXVsdFR5cGUpCisgICAgICAgICYmIChmb3JtYXQgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlJH QiB8fCBmb3JtYXQgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEpICYmIHR5cGUgPT0gR3JhcGhp Y3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUpIHsKKyAgICAgICAgaWYgKHZpZGVvLT5pc1ZpZGVv RnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUoKSAmJiB2aWRlby0+Y29weVZpZGVvRnJhbWVJblRl eHR1cmUoKm1fY29udGV4dC5nZXQoKSwgdGV4dHVyZS0+b2JqZWN0KCksIGludGVybmFsZm9ybWF0 LCBtX3VucGFja1ByZW11bHRpcGx5QWxwaGEsIG1fdW5wYWNrRmxpcFkpKSB7CisgICAgICAgICAg ICB0ZXh0dXJlLT5zZXRMZXZlbEluZm8odGFyZ2V0LCBsZXZlbCwgaW50ZXJuYWxmb3JtYXQsIHZp ZGVvLT52aWRlb1dpZHRoKCksIHZpZGVvLT52aWRlb0hlaWdodCgpLCB0eXBlKTsKKyAgICAgICAg ICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIH0KKyAgICB9CisKICAgICBSZWZQdHI8SW1hZ2U+IGltYWdlID0gdmlkZW9GcmFt ZVRvSW1hZ2UodmlkZW8sIEltYWdlQnVmZmVyOjpmYXN0Q29weUltYWdlTW9kZSgpLCBlYyk7CiAg ICAgaWYgKCFpbWFnZSkKICAgICAgICAgcmV0dXJuOwpAQCAtNDA5NSw2ICs0MTEwLDEwIEBAIHZv aWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0ZXhTdWJJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwg R0MzRGludCBsZXZlbCwgR0MzRGluCiAgICAgZWMgPSAwOwogICAgIGlmIChpc0NvbnRleHRMb3N0 KCkpCiAgICAgICAgIHJldHVybjsKKyAgICBpZiAoIXZpZGVvIHx8ICF2aWRlby0+dmlkZW9XaWR0 aCgpIHx8ICF2aWRlby0+dmlkZW9IZWlnaHQoKSkgeworICAgICAgICBzeW50aGVzaXplR0xFcnJv cihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgInRleFN1YkltYWdlMkQiLCAibm8g dmlkZW8iKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KICAgICBSZWZQdHI8SW1hZ2U+IGltYWdl ID0gdmlkZW9GcmFtZVRvSW1hZ2UodmlkZW8sIEltYWdlQnVmZmVyOjpmYXN0Q29weUltYWdlTW9k ZSgpLCBlYyk7CiAgICAgaWYgKCFpbWFnZSkKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuY3BwCmluZGV4IGYwYjE4MmQy NDAzNGIyOTdmYmQ3Nzk4MjViNDU0ZmFlMjU1MjI1YTMuLjU2OGE4YzkzOWJiMzBjYmI5MTBlOTE5 Y2NiODhkNzZiMTQwOGRmMTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL01lZGlhUGxheWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9NZWRpYVBsYXllci5jcHAKQEAgLTcyNyw2ICs3MjcsMTYgQEAgdm9pZCBNZWRpYVBsYXll cjo6cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0KiBwLCBjb25zdCBJ bnRSZWN0JgogICAgIG1fcHJpdmF0ZS0+cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQocCwgcik7 CiB9CiAKK2Jvb2wgTWVkaWFQbGF5ZXI6OmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4dHVy ZSgpCit7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVU ZXh0dXJlKCk7Cit9CisKK2Jvb2wgTWVkaWFQbGF5ZXI6OmNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJl KEdyYXBoaWNzQ29udGV4dDNEJiBjb250ZXh0LCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUsIEdD M0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkp Cit7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+Y29weVZpZGVvRnJhbWVJblRleHR1cmUoY29udGV4 dCwgdGV4dHVyZSwgaW50ZXJuYWxGb3JtYXQsIHByZW11bHRpcGx5QWxwaGEsIGZsaXBZKTsKK30K KwogTWVkaWFQbGF5ZXI6OlN1cHBvcnRzVHlwZSBNZWRpYVBsYXllcjo6c3VwcG9ydHNUeXBlKGNv bnN0IENvbnRlbnRUeXBlJiBjb250ZW50VHlwZSwgY29uc3QgU3RyaW5nJiBrZXlTeXN0ZW0sIGNv bnN0IEtVUkwmIHVybCwgY29uc3QgTWVkaWFQbGF5ZXJTdXBwb3J0c1R5cGVDbGllbnQqIGNsaWVu dCkKIHsKICAgICBTdHJpbmcgdHlwZSA9IGNvbnRlbnRUeXBlLnR5cGUoKS5sb3dlcigpOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmgKaW5kZXggOWU1 NmNiODE1N2Q2NmJhYzhkNDRiNzIwMDJhYmViODJkMTUwYjg4Ni4uNzUwODg4NzJhMzQzYjVjZGU1 MTJkZjQ4MDIxNzdlZjU3ODY5NDNiNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9NZWRpYVBsYXllci5oCkBAIC0yNyw3ICsyNyw3IEBACiAjZGVmaW5lIE1lZGlhUGxh eWVyX2gKIAogI2lmIEVOQUJMRShWSURFTykKLQorI2luY2x1ZGUgIkdyYXBoaWNzVHlwZXMzRC5o IgogI2lmIEVOQUJMRShQTFVHSU5fUFJPWFlfRk9SX1ZJREVPKQogI2luY2x1ZGUgIk1lZGlhUGxh eWVyUHJveHkuaCIKICNlbmRpZgpAQCAtMTAxLDYgKzEwMSw3IEBAIGNsYXNzIENhY2hlZFJlc291 cmNlTG9hZGVyOwogY2xhc3MgQ29udGVudFR5cGU7CiBjbGFzcyBGcmFtZVZpZXc7CiBjbGFzcyBH cmFwaGljc0NvbnRleHQ7CitjbGFzcyBHcmFwaGljc0NvbnRleHQzRDsKIGNsYXNzIEludFJlY3Q7 CiBjbGFzcyBJbnRTaXplOwogY2xhc3MgTWVkaWFQbGF5ZXI7CkBAIC0zMjksNiArMzMwLDkgQEAg cHVibGljOgogICAgIHZvaWQgcGFpbnQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYp OwogICAgIHZvaWQgcGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0Kiwg Y29uc3QgSW50UmVjdCYpOwogCisgICAgYm9vbCBpc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRl eHR1cmUoKTsKKyAgICBib29sIGNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKEdyYXBoaWNzQ29udGV4 dDNEJiwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwg Ym9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsKKwogICAgIGVudW0gTmV0d29ya1N0 YXRlIHsgRW1wdHksIElkbGUsIExvYWRpbmcsIExvYWRlZCwgRm9ybWF0RXJyb3IsIE5ldHdvcmtF cnJvciwgRGVjb2RlRXJyb3IgfTsKICAgICBOZXR3b3JrU3RhdGUgbmV0d29ya1N0YXRlKCk7CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVy UHJpdmF0ZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXJQ cml2YXRlLmgKaW5kZXggMWYzZjNlMTBhODdjOTM5NTc1YjNiYzc3NzM4YmMxMjg4MGQxYTU0NC4u ZmFlNTNhNjhjMzY3MTU0NDRmYjY0NTdiZjNiYmRmMDE4MzAzZDE4ZCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXJQcml2YXRlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXJQcml2YXRlLmgKQEAg LTEwNiw2ICsxMDYsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHBhaW50KEdyYXBoaWNz Q29udGV4dCosIGNvbnN0IEludFJlY3QmKSA9IDA7CiAKICAgICB2aXJ0dWFsIHZvaWQgcGFpbnRD dXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0KiBjLCBjb25zdCBJbnRSZWN0JiBy KSB7IHBhaW50KGMsIHIpOyB9CisgICAgdmlydHVhbCBib29sIGlzVmlkZW9GcmFtZU9mRm9ybWF0 TmF0aXZlVGV4dHVyZSgpIHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGNvcHlW aWRlb0ZyYW1lSW5UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEJiBjb250ZXh0LCBQbGF0Zm9ybTNE T2JqZWN0IHRleHR1cmUsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5 QWxwaGEsIGJvb2wgZmxpcFkpIHsgcmV0dXJuIGZhbHNlOyB9CiAKICAgICB2aXJ0dWFsIHZvaWQg c2V0UHJlbG9hZChNZWRpYVBsYXllcjo6UHJlbG9hZCkgeyB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCmluZGV4 IGVlOWRjYjVhODI5YjU2NDRkY2UzMjAxNjk0YTUyM2FkODY5NmZmYjEuLjI4YTg1ZTljODhhZDkz ODIwM2M4MTUwOGM1OGQ5M2M4M2Y5MDBjZTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcApAQCAtMTAsNiArMTAs NyBAQAogI2luY2x1ZGUgIkF1ZGlvQnVzLmgiCiAjaW5jbHVkZSAiQXVkaW9Tb3VyY2VQcm92aWRl ci5oIgogI2luY2x1ZGUgIkF1ZGlvU291cmNlUHJvdmlkZXJDbGllbnQuaCIKKyNpbmNsdWRlICJF eHRlbnNpb25zM0RDaHJvbWl1bS5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiR3Jh cGhpY3NDb250ZXh0LmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NMYXllckNocm9taXVtLmgiCkBAIC03 NjMsNiArNzY0LDUyIEBAIHZvaWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpwYWludEN1cnJl bnRGcmFtZUluQ29udGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRlCiAgICAgfQogfQogCitib29s IFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0 dXJlKCkKK3sKKyAgICBib29sIHJldCA9IGZhbHNlOworICAgIFdlYlZpZGVvRnJhbWUqIHZpZGVv RnJhbWUgPSAwOworICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3dlYk1lZGlhUGxheWVyTXV0ZXgp OworICAgIGlmIChtX3dlYk1lZGlhUGxheWVyKSB7CisgICAgICAgIHZpZGVvRnJhbWUgPSBtX3dl Yk1lZGlhUGxheWVyLT5nZXRDdXJyZW50RnJhbWUoKTsKKyAgICAgICAgaWYgKHZpZGVvRnJhbWUp IHsKKyAgICAgICAgICAgIHJldCA9IHZpZGVvRnJhbWUtPmZvcm1hdCgpID09IFdlYlZpZGVvRnJh bWU6OkZvcm1hdE5hdGl2ZVRleHR1cmUgJiYgdmlkZW9GcmFtZS0+dGV4dHVyZVRhcmdldCgpID09 IFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJEOworICAgICAgICAgICAgbV93 ZWJNZWRpYVBsYXllci0+cHV0Q3VycmVudEZyYW1lKHZpZGVvRnJhbWUpOworICAgICAgICB9Cisg ICAgfQorICAgIHJldHVybiByZXQ7Cit9CisKK2Jvb2wgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBs Ojpjb3B5VmlkZW9GcmFtZUluVGV4dHVyZShXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRCYgY29u dGV4dCwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwg Ym9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworICAgIFdlYlZpZGVvRnJhbWUq IHZpZGVvRnJhbWUgPSAwOworICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3dlYk1lZGlhUGxheWVy TXV0ZXgpOworICAgIGlmIChtX3dlYk1lZGlhUGxheWVyKQorICAgICAgICB2aWRlb0ZyYW1lID0g bV93ZWJNZWRpYVBsYXllci0+Z2V0Q3VycmVudEZyYW1lKCk7CisKKyAgICBpZiAodmlkZW9GcmFt ZSkgeworICAgICAgICBpZiAodmlkZW9GcmFtZS0+Zm9ybWF0KCkgIT0gV2ViVmlkZW9GcmFtZTo6 Rm9ybWF0TmF0aXZlVGV4dHVyZSB8fCB2aWRlb0ZyYW1lLT50ZXh0dXJlVGFyZ2V0KCkgIT0gV2Vi Q29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQpIHsKKyAgICAgICAgICAgIG1fd2Vi TWVkaWFQbGF5ZXItPnB1dEN1cnJlbnRGcmFtZSh2aWRlb0ZyYW1lKTsKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICAgICAgfQorICAgICAgICBQbGF0Zm9ybTNET2JqZWN0IHNvdXJjZVRl eHR1cmUgPSB2aWRlb0ZyYW1lLT50ZXh0dXJlSWQoKTsKKyAgICAgICAgRXh0ZW5zaW9uczNEKiBl eHRlbnNpb25zID0gY29udGV4dC5nZXRFeHRlbnNpb25zKCk7CisgICAgICAgIGlmICghZXh0ZW5z aW9ucy0+c3VwcG9ydHMoIkdMX0NIUk9NSVVNX2NvcHlfdGV4dHVyZSIpIHx8ICFleHRlbnNpb25z LT5zdXBwb3J0cygiR0xfQ0hST01JVU1fZmxpcHkiKSB8fCAhY29udGV4dC5tYWtlQ29udGV4dEN1 cnJlbnQoKSkgeworICAgICAgICAgICAgbV93ZWJNZWRpYVBsYXllci0+cHV0Q3VycmVudEZyYW1l KHZpZGVvRnJhbWUpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAg ICAgIGNvbnRleHQucGl4ZWxTdG9yZWkoRXh0ZW5zaW9uczNEOjpVTlBBQ0tfUFJFTVVMVElQTFlf QUxQSEFfQ0hST01JVU0sIHByZW11bHRpcGx5QWxwaGEpOworICAgICAgICBjb250ZXh0LnBpeGVs U3RvcmVpKEV4dGVuc2lvbnMzRDo6VU5QQUNLX0ZMSVBfWV9DSFJPTUlVTSwgZmxpcFkpOworICAg ICAgICBleHRlbnNpb25zLT5jb3B5VGV4dHVyZUNIUk9NSVVNKEdyYXBoaWNzQ29udGV4dDNEOjpU RVhUVVJFXzJELCBzb3VyY2VUZXh0dXJlLCB0ZXh0dXJlLCAwLCBpbnRlcm5hbEZvcm1hdCk7Cisg ICAgICAgIGNvbnRleHQucGl4ZWxTdG9yZWkoRXh0ZW5zaW9uczNEOjpVTlBBQ0tfRkxJUF9ZX0NI Uk9NSVVNLCBmYWxzZSk7CisgICAgICAgIGNvbnRleHQucGl4ZWxTdG9yZWkoRXh0ZW5zaW9uczNE OjpVTlBBQ0tfUFJFTVVMVElQTFlfQUxQSEFfQ0hST01JVU0sIGZhbHNlKTsKKyAgICAgICAgY29u dGV4dC5mbHVzaCgpOworICAgICAgICBtX3dlYk1lZGlhUGxheWVyLT5wdXRDdXJyZW50RnJhbWUo dmlkZW9GcmFtZSk7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAgIHJldHVybiBm YWxzZTsKK30KKwogdm9pZCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OnNldFByZWxvYWQoTWVk aWFQbGF5ZXI6OlByZWxvYWQgcHJlbG9hZCkKIHsKICAgICBtX3ByZWxvYWQgPSBwcmVsb2FkOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGll bnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVu dEltcGwuaAppbmRleCA5OWQyZThiZGJlODQ1NDgwYjc1ZDEzYWZlZTljNTNlZGQ5NGUwZjc2Li43 YmVkYTkzNDU4OWZhNGJmY2VlMDFhZWQ4ZGU4ZmZlNDNiYmYxZjZlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaApAQCAt MTMyLDYgKzEzMiw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0U2l6ZShjb25zdCBX ZWJDb3JlOjpJbnRTaXplJik7CiAgICAgdmlydHVhbCB2b2lkIHBhaW50KFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dCosIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKTsKICAgICB2aXJ0dWFsIHZvaWQg cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0KiwgY29u c3QgV2ViQ29yZTo6SW50UmVjdCYpOworICAgIHZpcnR1YWwgYm9vbCBpc1ZpZGVvRnJhbWVPZkZv cm1hdE5hdGl2ZVRleHR1cmUoKTsKKyAgICB2aXJ0dWFsIGJvb2wgY29weVZpZGVvRnJhbWVJblRl eHR1cmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0QmLCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1 cmUsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wg ZmxpcFkpOwogICAgIHZpcnR1YWwgdm9pZCBzZXRQcmVsb2FkKFdlYkNvcmU6Ok1lZGlhUGxheWVy OjpQcmVsb2FkKTsKICAgICB2aXJ0dWFsIGJvb2wgaGFzU2luZ2xlU2VjdXJpdHlPcmlnaW4oKSBj b25zdDsKICAgICB2aXJ0dWFsIGJvb2wgZGlkUGFzc0NPUlNBY2Nlc3NDaGVjaygpIGNvbnN0Owo= 190881 2013-02-28 21:44:03 -0800 2013-03-06 06:07:20 -0800 Patch bug-111126-20130301134204.patch text/plain 14691 jun.a.jiang U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ0NDEzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2U5OWMxZTk0ZWU2Yzcx NGRhNzdhOTM5Y2FiZWQ1Zjc5NGZmZjBiMy4uY2VlYzVhZWUyMzdkYWM0ODgwMzFmNTg1MTk0NWZh ZmM2MDE4NDk4ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEzLTAyLTI4ICBKdW4g SmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJk d2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiB0ZXhJbWFnZTJEKCkgZm9yIEhUTUxW aWRlb0VsZW1lbnQgaW4gV2ViR0wsIGl0IGlzIHBvc3NpYmxlIHRvIGRvIGEgR1BVLUdQVSB0ZXh0 dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2sgYW5kIHVwbG9hZCB3aGVuIGhhcmR3YXJl IGFjY2VsZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBpbiB1c2UuIEVhY2ggcGxhdGZvcm0gbmVlZHMg dG8gaW1wbGVtZW50IHRoZSBpbnRlcmZhY2UgaXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0 dXJlKCkgYW5kIGNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKCkgdG8gbWFrZSBpdCB0cnVlbHkgd29y ay4KKworICAgICAgICBBbHJlYWR5IGNvdmVyZWQgYnkgY3VycmVudCB0ZXN0cy4KKworICAgICAg ICAqIGh0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVmlk ZW9FbGVtZW50Ojppc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUpOgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVmlkZW9FbGVtZW50Ojpjb3B5VmlkZW9G cmFtZUluVGV4dHVyZSk6CisgICAgICAgICogaHRtbC9IVE1MVmlkZW9FbGVtZW50Lmg6CisgICAg ICAgIChIVE1MVmlkZW9FbGVtZW50KToKKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFJlbmRl cmluZ0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpX ZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZpZGVvRnJhbWVUb0ltYWdlKToKKyAgICAgICAgKFdlYkNv cmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4SW1hZ2UyRCk6CisgICAgICAgIChXZWJDb3Jl OjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleFN1YkltYWdlMkQpOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxh eWVyOjppc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUpOgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXllcjo6Y29weVZpZGVvRnJhbWVJblRleHR1 cmUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmg6CisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKE1lZGlhUGxheWVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9NZWRpYVBsYXllclByaXZhdGUuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxh eWVyUHJpdmF0ZUludGVyZmFjZTo6aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0dXJlKToK KyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUludGVyZmFjZTo6Y29weVZpZGVv RnJhbWVJblRleHR1cmUpOgorCiAyMDEzLTAyLTI4ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZp ZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTQ0 MzcwLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA5MTc3MGNlNmY1MTZlMWNmNDI5MTM4 NGNiMzYzNGVlMmI1NTA2MTc5Li5mZTYyNTJhOTc2MzZkMjA4MWFmOWJjZWRkMDRkZDhlMGQ4ODgx NzVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEzLTAy LTI4ICBKdW4gSmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxl IEdQVS1HUFUgdGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVu dCBpZiBoYXJkd2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHNyYy9XZWJNZWRpYVBs YXllckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRpYVBsYXllckNsaWVu dEltcGw6OmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4dHVyZSk6CisgICAgICAgIChXZWJL aXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNvcHlWaWRl b0ZyYW1lSW5UZXh0dXJlKToKKyAgICAgICAgKiBzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBs Lmg6CisgICAgICAgIChXZWJNZWRpYVBsYXllckNsaWVudEltcGwpOgorCiAyMDEzLTAyLTI4ICBB bmt1ciBUYWx5ICA8YXRhbHlAZ29vZ2xlLmNvbT4KIAogICAgICAgICBXZWJLaXQgQVBJIGZvciBl bmFibGluZyBET00gbG9nZ2luZyBmb3IgY2VydGFpbiB3b3JsZHMKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxWaWRlb0VsZW1lbnQuY3BwCmluZGV4IGNmZTk1NzEzZmY5ZGY4ZDczNTc1YjgwMmVlNTgx ZjA4ZGU2Nzg0MWQuLjIxYjcwMDI4MGMxOGM1Mjk1ZjlkNjFiOWRhY2NjZDEzMmFmYzdkZTAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcApAQCAtMjM3LDYgKzIzNywy MiBAQCB2b2lkIEhUTUxWaWRlb0VsZW1lbnQ6OnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdy YXBoaWNzQ29udGV4dCogY29udGV4dCwgY29ucwogICAgIHBsYXllci0+cGFpbnRDdXJyZW50RnJh bWVJbkNvbnRleHQoY29udGV4dCwgZGVzdFJlY3QpOwogfQogCitib29sIEhUTUxWaWRlb0VsZW1l bnQ6OmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4dHVyZSgpCit7CisgICAgaWYgKCFwbGF5 ZXIoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHBsYXllcigpLT5zZXRWaXNpYmxlKHRy dWUpOworICAgIHJldHVybiBwbGF5ZXIoKS0+aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0 dXJlKCk7Cit9CisKK2Jvb2wgSFRNTFZpZGVvRWxlbWVudDo6Y29weVZpZGVvRnJhbWVJblRleHR1 cmUoR3JhcGhpY3NDb250ZXh0M0QmIGNvbnRleHQsIFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwg R0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlw WSkKK3sKKyAgICBpZiAoIXBsYXllcigpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgcGxh eWVyKCktPnNldFZpc2libGUodHJ1ZSk7CisgICAgcmV0dXJuIHBsYXllcigpLT5jb3B5VmlkZW9G cmFtZUluVGV4dHVyZShjb250ZXh0LCB0ZXh0dXJlLCBpbnRlcm5hbEZvcm1hdCwgcHJlbXVsdGlw bHlBbHBoYSwgZmxpcFkpOworfQorCiBib29sIEhUTUxWaWRlb0VsZW1lbnQ6Omhhc0F2YWlsYWJs ZVZpZGVvRnJhbWUoKSBjb25zdAogewogICAgIGlmICghcGxheWVyKCkpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTFZpZGVvRWxlbWVudC5oCmluZGV4IGNmNGZlYWNmY2I3MWIyMmUzNjkxM2E4ZDk3ODRj YWVmNDE4NTQ5YWIuLjA3MzY2ZmJiZTQ4YTA0MGQ4MTEwYWE3NmU4MjAwNDgwMmIxZmMxNDQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5oCkBAIC02Myw2ICs2MywxMCBAQCBw dWJsaWM6CiAgICAgLy8gVXNlZCBieSBjYW52YXMgdG8gZ2FpbiByYXcgcGl4ZWwgYWNjZXNzCiAg ICAgdm9pZCBwYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChHcmFwaGljc0NvbnRleHQqLCBjb25z dCBJbnRSZWN0Jik7CiAKKyAgICAvLyBVc2VkIGJ5IFdlYkdMIHRvIGRvIEdQVS1HUFUgdGV4dHVy ZSBjb3B5IGlmIHBvc3NpYmxlLgorICAgIGJvb2wgaXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVU ZXh0dXJlKCk7CisgICAgYm9vbCBjb3B5VmlkZW9GcmFtZUluVGV4dHVyZShHcmFwaGljc0NvbnRl eHQzRCYsIFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQs IGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlwWSk7CisKICAgICBib29sIHNob3VsZERp c3BsYXlQb3N0ZXJJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVy IHx8IGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVyV2FpdGluZ0ZvclZpZGVvOyB9CiAKIHByaXZhdGU6 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0Nv bnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250 ZXh0LmNwcAppbmRleCBkZWI2NGIxMDI0MWExNGU4N2Y3ZWUyYjQzYTEzMGE2ZjYwYTExZDU1Li43 YTk2ODUzYjlkMzFhMTRjZTc2NjZkYWFlM2U2NWQzMmI2NTVjNGFmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAKQEAgLTM4 NDYsMTAgKzM4NDYsNiBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4SW1hZ2UyRChH QzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtCiAjaWYgRU5BQkxFKFZJREVP KQogUGFzc1JlZlB0cjxJbWFnZT4gV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2aWRlb0ZyYW1lVG9J bWFnZShIVE1MVmlkZW9FbGVtZW50KiB2aWRlbywgQmFja2luZ1N0b3JlQ29weSBiYWNraW5nU3Rv cmVDb3B5LCBFeGNlcHRpb25Db2RlJiBlYykKIHsKLSAgICBpZiAoIXZpZGVvIHx8ICF2aWRlby0+ dmlkZW9XaWR0aCgpIHx8ICF2aWRlby0+dmlkZW9IZWlnaHQoKSkgewotICAgICAgICBzeW50aGVz aXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgInRleEltYWdlMkQi LCAibm8gdmlkZW8iKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQogICAgIEludFNpemUgc2l6 ZSh2aWRlby0+dmlkZW9XaWR0aCgpLCB2aWRlby0+dmlkZW9IZWlnaHQoKSk7CiAgICAgSW1hZ2VC dWZmZXIqIGJ1ZiA9IG1fdmlkZW9DYWNoZS5pbWFnZUJ1ZmZlcihzaXplKTsKICAgICBpZiAoIWJ1 ZikgewpAQCAtMzg3Miw2ICszODY4LDI1IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0 ZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0KICAgICBl YyA9IDA7CiAgICAgaWYgKGlzQ29udGV4dExvc3QoKSkKICAgICAgICAgcmV0dXJuOworICAgIGlm ICghdmlkZW8gfHwgIXZpZGVvLT52aWRlb1dpZHRoKCkgfHwgIXZpZGVvLT52aWRlb0hlaWdodCgp KSB7CisgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElE X1ZBTFVFLCAidGV4SW1hZ2UyRCIsICJubyB2aWRlbyIpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgLy8gSWYgaGFyZHdhcmUtYWNjZWxlcmF0ZWQgdmlkZW8gZGVjb2RlIGlzIGluIHVz ZSwgY29weSBmcm9tIHRoZSBWaWRlbyBlbGVtZW50IGRpcmVjdGx5IHRvIHRoZSB0ZXh0dXJlCisg ICAgLy8gdmlhIEdQVSBpZiBwb3NzaWJsZSwgd2l0aG91dCBhIHJlYWQtYmFjayB0byBzeXN0ZW0g bWVtb3J5LgorICAgIC8vIEZJWE1FOiByZXN0cmljdGlvbiBvZiAoUkdCIHx8IFJHQkEpL1VOU0lH TkVEX0JZVEUgc2hvdWxkIGJlIGxpZnRlZCBpbiB0aGUgZnV0dXJlLgorICAgIFdlYkdMVGV4dHVy ZSogdGV4dHVyZSA9IHZhbGlkYXRlVGV4dHVyZUJpbmRpbmcoInRleEltYWdlMkQiLCB0YXJnZXQs IHRydWUpOworICAgIGNvbnN0IEdDM0RlbnVtIHdlYkdMVGV4dHVyZURlZmF1bHRUeXBlID0gMDsK KyAgICBpZiAoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQgPT0gdGFyZ2V0ICYmIHRleHR1 cmUgJiYgKHRleHR1cmUtPmdldFR5cGUodGFyZ2V0LCBsZXZlbCkgPT0gdHlwZSB8fCB0ZXh0dXJl LT5nZXRUeXBlKHRhcmdldCwgbGV2ZWwpID09IHdlYkdMVGV4dHVyZURlZmF1bHRUeXBlKQorICAg ICAgICAmJiAoZm9ybWF0ID09IEdyYXBoaWNzQ29udGV4dDNEOjpSR0IgfHwgZm9ybWF0ID09IEdy YXBoaWNzQ29udGV4dDNEOjpSR0JBKSAmJiB0eXBlID09IEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJ R05FRF9CWVRFKSB7CisgICAgICAgIGlmICh2aWRlby0+aXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRp dmVUZXh0dXJlKCkgJiYgdmlkZW8tPmNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKCptX2NvbnRleHQu Z2V0KCksIHRleHR1cmUtPm9iamVjdCgpLCBpbnRlcm5hbGZvcm1hdCwgbV91bnBhY2tQcmVtdWx0 aXBseUFscGhhLCBtX3VucGFja0ZsaXBZKSkgeworICAgICAgICAgICAgdGV4dHVyZS0+c2V0TGV2 ZWxJbmZvKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0LCB2aWRlby0+dmlkZW9XaWR0aCgp LCB2aWRlby0+dmlkZW9IZWlnaHQoKSwgdHlwZSk7CisgICAgICAgICAgICBjbGVhbnVwQWZ0ZXJH cmFwaGljc0NhbGwoZmFsc2UpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAg fQorCiAgICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9IHZpZGVvRnJhbWVUb0ltYWdlKHZpZGVvLCBJ bWFnZUJ1ZmZlcjo6ZmFzdENvcHlJbWFnZU1vZGUoKSwgZWMpOwogICAgIGlmICghaW1hZ2UpCiAg ICAgICAgIHJldHVybjsKQEAgLTQwOTUsNiArNDExMCwxMCBAQCB2b2lkIFdlYkdMUmVuZGVyaW5n Q29udGV4dDo6dGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdD M0RpbgogICAgIGVjID0gMDsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAgICByZXR1 cm47CisgICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVvV2lkdGgoKSB8fCAhdmlkZW8tPnZp ZGVvSGVpZ2h0KCkpIHsKKyAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0 M0Q6OklOVkFMSURfVkFMVUUsICJ0ZXhTdWJJbWFnZTJEIiwgIm5vIHZpZGVvIik7CisgICAgICAg IHJldHVybjsKKyAgICB9CiAgICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9IHZpZGVvRnJhbWVUb0lt YWdlKHZpZGVvLCBJbWFnZUJ1ZmZlcjo6ZmFzdENvcHlJbWFnZU1vZGUoKSwgZWMpOwogICAgIGlm ICghaW1hZ2UpCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcAppbmRleCBmMGIxODJkMjQwMzRiMjk3ZmJkNzc5ODI1 YjQ1NGZhZTI1NTIyNWEzLi41NjhhOGM5MzliYjMwY2JiOTEwZTkxOWNjYjg4ZDc2YjE0MDhkZjEy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXll ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIu Y3BwCkBAIC03MjcsNiArNzI3LDE2IEBAIHZvaWQgTWVkaWFQbGF5ZXI6OnBhaW50Q3VycmVudEZy YW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4dCogcCwgY29uc3QgSW50UmVjdCYKICAgICBtX3By aXZhdGUtPnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KHAsIHIpOwogfQogCitib29sIE1lZGlh UGxheWVyOjppc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUoKQoreworICAgIHJldHVy biBtX3ByaXZhdGUtPmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4dHVyZSgpOworfQorCiti b29sIE1lZGlhUGxheWVyOjpjb3B5VmlkZW9GcmFtZUluVGV4dHVyZShHcmFwaGljc0NvbnRleHQz RCYgY29udGV4dCwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBpbnRlcm5hbEZv cm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworICAgIHJldHVybiBt X3ByaXZhdGUtPmNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKGNvbnRleHQsIHRleHR1cmUsIGludGVy bmFsRm9ybWF0LCBwcmVtdWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIE1lZGlhUGxheWVyOjpT dXBwb3J0c1R5cGUgTWVkaWFQbGF5ZXI6OnN1cHBvcnRzVHlwZShjb25zdCBDb250ZW50VHlwZSYg Y29udGVudFR5cGUsIGNvbnN0IFN0cmluZyYga2V5U3lzdGVtLCBjb25zdCBLVVJMJiB1cmwsIGNv bnN0IE1lZGlhUGxheWVyU3VwcG9ydHNUeXBlQ2xpZW50KiBjbGllbnQpCiB7CiAgICAgU3RyaW5n IHR5cGUgPSBjb250ZW50VHlwZS50eXBlKCkubG93ZXIoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oCmluZGV4IDllNTZjYjgxNTdkNjZiYWM4ZDQ0 YjcyMDAyYWJlYjgyZDE1MGI4ODYuLjc1MDg4ODcyYTM0M2I1Y2RlNTEyZGY0ODAyMTc3ZWY1Nzg2 OTQzYjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlh UGxheWVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5 ZXIuaApAQCAtMjcsNyArMjcsNyBAQAogI2RlZmluZSBNZWRpYVBsYXllcl9oCiAKICNpZiBFTkFC TEUoVklERU8pCi0KKyNpbmNsdWRlICJHcmFwaGljc1R5cGVzM0QuaCIKICNpZiBFTkFCTEUoUExV R0lOX1BST1hZX0ZPUl9WSURFTykKICNpbmNsdWRlICJNZWRpYVBsYXllclByb3h5LmgiCiAjZW5k aWYKQEAgLTEwMSw2ICsxMDEsNyBAQCBjbGFzcyBDYWNoZWRSZXNvdXJjZUxvYWRlcjsKIGNsYXNz IENvbnRlbnRUeXBlOwogY2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgR3JhcGhpY3NDb250ZXh0Owor Y2xhc3MgR3JhcGhpY3NDb250ZXh0M0Q7CiBjbGFzcyBJbnRSZWN0OwogY2xhc3MgSW50U2l6ZTsK IGNsYXNzIE1lZGlhUGxheWVyOwpAQCAtMzI5LDYgKzMzMCw5IEBAIHB1YmxpYzoKICAgICB2b2lk IHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsKICAgICB2b2lkIHBhaW50 Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKTsK IAorICAgIGJvb2wgaXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0dXJlKCk7CisgICAgYm9v bCBjb3B5VmlkZW9GcmFtZUluVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCYsIFBsYXRmb3JtM0RP YmplY3QgdGV4dHVyZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlB bHBoYSwgYm9vbCBmbGlwWSk7CisKICAgICBlbnVtIE5ldHdvcmtTdGF0ZSB7IEVtcHR5LCBJZGxl LCBMb2FkaW5nLCBMb2FkZWQsIEZvcm1hdEVycm9yLCBOZXR3b3JrRXJyb3IsIERlY29kZUVycm9y IH07CiAgICAgTmV0d29ya1N0YXRlIG5ldHdvcmtTdGF0ZSgpOwogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllclByaXZhdGUuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCmluZGV4IDFm M2YzZTEwYTg3YzkzOTU3NWIzYmM3NzczOGJjMTI4ODBkMWE1NDQuLjU1YmQ1ZjdhNjdmMjRiMmVi MGQ5MjI1YmY4ODAzOTAwZmYyM2YyNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCkBAIC0xMDYsNiArMTA2LDggQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJ bnRSZWN0JikgPSAwOwogCiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250 ZXh0KEdyYXBoaWNzQ29udGV4dCogYywgY29uc3QgSW50UmVjdCYgcikgeyBwYWludChjLCByKTsg fQorICAgIHZpcnR1YWwgYm9vbCBpc1ZpZGVvRnJhbWVPZkZvcm1hdE5hdGl2ZVRleHR1cmUoKSB7 IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgYm9vbCBjb3B5VmlkZW9GcmFtZUluVGV4dHVy ZShHcmFwaGljc0NvbnRleHQzRCYsIFBsYXRmb3JtM0RPYmplY3QsIEdDM0RlbnVtLCBib29sLCBi b29sKSB7IHJldHVybiBmYWxzZTsgfQogCiAgICAgdmlydHVhbCB2b2lkIHNldFByZWxvYWQoTWVk aWFQbGF5ZXI6OlByZWxvYWQpIHsgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcAppbmRleCBlZTlkY2I1YTgyOWI1 NjQ0ZGNlMzIwMTY5NGE1MjNhZDg2OTZmZmIxLi4yOGE4NWU5Yzg4YWQ5MzgyMDNjODE1MDhjNThk OTNjODNmOTAwY2U5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJN ZWRpYVBsYXllckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKQEAgLTEwLDYgKzEwLDcgQEAKICNpbmNsdWRl ICJBdWRpb0J1cy5oIgogI2luY2x1ZGUgIkF1ZGlvU291cmNlUHJvdmlkZXIuaCIKICNpbmNsdWRl ICJBdWRpb1NvdXJjZVByb3ZpZGVyQ2xpZW50LmgiCisjaW5jbHVkZSAiRXh0ZW5zaW9uczNEQ2hy b21pdW0uaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5o IgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXJDaHJvbWl1bS5oIgpAQCAtNzYzLDYgKzc2NCw1MiBA QCB2b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRl eHQoR3JhcGhpY3NDb250ZXh0KiBjb250ZQogICAgIH0KIH0KIAorYm9vbCBXZWJNZWRpYVBsYXll ckNsaWVudEltcGw6OmlzVmlkZW9GcmFtZU9mRm9ybWF0TmF0aXZlVGV4dHVyZSgpCit7CisgICAg Ym9vbCByZXQgPSBmYWxzZTsKKyAgICBXZWJWaWRlb0ZyYW1lKiB2aWRlb0ZyYW1lID0gMDsKKyAg ICBNdXRleExvY2tlciBsb2NrZXIobV93ZWJNZWRpYVBsYXllck11dGV4KTsKKyAgICBpZiAobV93 ZWJNZWRpYVBsYXllcikgeworICAgICAgICB2aWRlb0ZyYW1lID0gbV93ZWJNZWRpYVBsYXllci0+ Z2V0Q3VycmVudEZyYW1lKCk7CisgICAgICAgIGlmICh2aWRlb0ZyYW1lKSB7CisgICAgICAgICAg ICByZXQgPSB2aWRlb0ZyYW1lLT5mb3JtYXQoKSA9PSBXZWJWaWRlb0ZyYW1lOjpGb3JtYXROYXRp dmVUZXh0dXJlICYmIHZpZGVvRnJhbWUtPnRleHR1cmVUYXJnZXQoKSA9PSBXZWJDb3JlOjpHcmFw aGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRDsKKyAgICAgICAgICAgIG1fd2ViTWVkaWFQbGF5ZXIt PnB1dEN1cnJlbnRGcmFtZSh2aWRlb0ZyYW1lKTsKKyAgICAgICAgfQorICAgIH0KKyAgICByZXR1 cm4gcmV0OworfQorCitib29sIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6Y29weVZpZGVvRnJh bWVJblRleHR1cmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0QmIGNvbnRleHQsIFBsYXRmb3Jt M0RPYmplY3QgdGV4dHVyZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlw bHlBbHBoYSwgYm9vbCBmbGlwWSkKK3sKKyAgICBXZWJWaWRlb0ZyYW1lKiB2aWRlb0ZyYW1lID0g MDsKKyAgICBNdXRleExvY2tlciBsb2NrZXIobV93ZWJNZWRpYVBsYXllck11dGV4KTsKKyAgICBp ZiAobV93ZWJNZWRpYVBsYXllcikKKyAgICAgICAgdmlkZW9GcmFtZSA9IG1fd2ViTWVkaWFQbGF5 ZXItPmdldEN1cnJlbnRGcmFtZSgpOworCisgICAgaWYgKHZpZGVvRnJhbWUpIHsKKyAgICAgICAg aWYgKHZpZGVvRnJhbWUtPmZvcm1hdCgpICE9IFdlYlZpZGVvRnJhbWU6OkZvcm1hdE5hdGl2ZVRl eHR1cmUgfHwgdmlkZW9GcmFtZS0+dGV4dHVyZVRhcmdldCgpICE9IFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDNEOjpURVhUVVJFXzJEKSB7CisgICAgICAgICAgICBtX3dlYk1lZGlhUGxheWVyLT5w dXRDdXJyZW50RnJhbWUodmlkZW9GcmFtZSk7CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7Cisg ICAgICAgIH0KKyAgICAgICAgUGxhdGZvcm0zRE9iamVjdCBzb3VyY2VUZXh0dXJlID0gdmlkZW9G cmFtZS0+dGV4dHVyZUlkKCk7CisgICAgICAgIEV4dGVuc2lvbnMzRCogZXh0ZW5zaW9ucyA9IGNv bnRleHQuZ2V0RXh0ZW5zaW9ucygpOworICAgICAgICBpZiAoIWV4dGVuc2lvbnMtPnN1cHBvcnRz KCJHTF9DSFJPTUlVTV9jb3B5X3RleHR1cmUiKSB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdM X0NIUk9NSVVNX2ZsaXB5IikgfHwgIWNvbnRleHQubWFrZUNvbnRleHRDdXJyZW50KCkpIHsKKyAg ICAgICAgICAgIG1fd2ViTWVkaWFQbGF5ZXItPnB1dEN1cnJlbnRGcmFtZSh2aWRlb0ZyYW1lKTsK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorICAgICAgICBjb250ZXh0LnBp eGVsU3RvcmVpKEV4dGVuc2lvbnMzRDo6VU5QQUNLX1BSRU1VTFRJUExZX0FMUEhBX0NIUk9NSVVN LCBwcmVtdWx0aXBseUFscGhhKTsKKyAgICAgICAgY29udGV4dC5waXhlbFN0b3JlaShFeHRlbnNp b25zM0Q6OlVOUEFDS19GTElQX1lfQ0hST01JVU0sIGZsaXBZKTsKKyAgICAgICAgZXh0ZW5zaW9u cy0+Y29weVRleHR1cmVDSFJPTUlVTShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgc291 cmNlVGV4dHVyZSwgdGV4dHVyZSwgMCwgaW50ZXJuYWxGb3JtYXQpOworICAgICAgICBjb250ZXh0 LnBpeGVsU3RvcmVpKEV4dGVuc2lvbnMzRDo6VU5QQUNLX0ZMSVBfWV9DSFJPTUlVTSwgZmFsc2Up OworICAgICAgICBjb250ZXh0LnBpeGVsU3RvcmVpKEV4dGVuc2lvbnMzRDo6VU5QQUNLX1BSRU1V TFRJUExZX0FMUEhBX0NIUk9NSVVNLCBmYWxzZSk7CisgICAgICAgIGNvbnRleHQuZmx1c2goKTsK KyAgICAgICAgbV93ZWJNZWRpYVBsYXllci0+cHV0Q3VycmVudEZyYW1lKHZpZGVvRnJhbWUpOwor ICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIHZv aWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpzZXRQcmVsb2FkKE1lZGlhUGxheWVyOjpQcmVs b2FkIHByZWxvYWQpCiB7CiAgICAgbV9wcmVsb2FkID0gcHJlbG9hZDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKaW5kZXgg OTlkMmU4YmRiZTg0NTQ4MGI3NWQxM2FmZWU5YzUzZWRkOTRlMGY3Ni4uN2JlZGE5MzQ1ODlmYTRi ZmNlZTAxYWVkOGRlOGZmZTQzYmJmMWY2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKQEAgLTEzMiw2ICsxMzIsOCBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNldFNpemUoY29uc3QgV2ViQ29yZTo6SW50U2l6 ZSYpOwogICAgIHZpcnR1YWwgdm9pZCBwYWludChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQqLCBj b25zdCBXZWJDb3JlOjpJbnRSZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q3VycmVudEZy YW1lSW5Db250ZXh0KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dCosIGNvbnN0IFdlYkNvcmU6Oklu dFJlY3QmKTsKKyAgICB2aXJ0dWFsIGJvb2wgaXNWaWRlb0ZyYW1lT2ZGb3JtYXROYXRpdmVUZXh0 dXJlKCk7CisgICAgdmlydHVhbCBib29sIGNvcHlWaWRlb0ZyYW1lSW5UZXh0dXJlKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDNEJiwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBp bnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsKICAgICB2 aXJ0dWFsIHZvaWQgc2V0UHJlbG9hZChXZWJDb3JlOjpNZWRpYVBsYXllcjo6UHJlbG9hZCk7CiAg ICAgdmlydHVhbCBib29sIGhhc1NpbmdsZVNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CiAgICAgdmly dHVhbCBib29sIGRpZFBhc3NDT1JTQWNjZXNzQ2hlY2soKSBjb25zdDsK 191738 2013-03-06 06:07:37 -0800 2013-03-10 06:42:11 -0700 Patch bug-111126-20130306220537.patch text/plain 19769 jun.a.jiang U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ0OTEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmEyNjcyOWIyNDQ1NGM1 Y2IwOWEyZGM1NTJmNWNmZjljYmRjMzFhYS4uN2FmMTVjNjI5ZDU0ZTZlNjUwZDNlYWNhYzlmZWIx MGUwMzEyY2I3OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDEzLTAzLTA2ICBKdW4g SmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJk d2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiB0ZXhJbWFnZTJEKCkgZm9yIEhUTUxW aWRlb0VsZW1lbnQgaW4gV2ViR0wsIGl0IGlzIHBvc3NpYmxlIHRvIGRvIGEgR1BVLUdQVSB0ZXh0 dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2sgCisgICAgICAgIGFuZCB1cGxvYWQgd2hl biBoYXJkd2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlLiBFYWNoIHBsYXRm b3JtIHBvcnQgbmVlZHMgdG8gaW1wbGVtZW50IHRoZSB0d28gZnVuY3Rpb25zIAorICAgICAgICAt dmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KCkgYW5kIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRm b3JtVGV4dHVyZSgpIGRlZmluZWQgaW4gTWVkaWFQbGF5ZXIuaCB0byBtYWtlIGl0IHdvcmsuCisK KyAgICAgICAgQWxyZWFkeSBjb3ZlcmVkIGJ5IGN1cnJlbnQgdGVzdHMuCisKKyAgICAgICAgKiBo dG1sL0hUTUxWaWRlb0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFZpZGVvRWxl bWVudDo6dmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxWaWRlb0VsZW1lbnQ6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6ICAKKyAg ICAgICAgKiBodG1sL0hUTUxWaWRlb0VsZW1lbnQuaDoKKyAgICAgICAgKEhUTUxWaWRlb0VsZW1l bnQpOgorICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHA6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4 dDo6dmlkZW9GcmFtZVRvSW1hZ2UpOiBtb3ZlIHNvbWUgc2VjdXJpdHkgY2hlY2tzIHRvIHVwcGVy IGxldmVsLgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0ZXhJbWFn ZTJEKTogYWRkIHRoZSBHUFUtR1BVIHRleHR1cmVzIGNvcHkgcGF0aCBmb3IgSFRNTFZpZGVvRWxl bWVudC4KKyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4U3ViSW1h Z2UyRCk6CisgICAgICAgICogaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OldlYkdMVGV4dHVyZTo6aXNWYWxpZCk6IGNoZWNrIGlmIHRoZSB0ZXh0dXJlIHdh cyBkZWZpbmVkIGJlZm9yZS4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGh0bWwvY2Fu dmFzL1dlYkdMVGV4dHVyZS5oOgorICAgICAgICAoV2ViR0xUZXh0dXJlKToKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNZWRp YVBsYXllcjo6dmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KTogYWRkZWQgdG8gcXVlcnkgaWYg R1BVLWFjY2VsZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBpbiB1c2UuCisgICAgICAgIChXZWJDb3Jl KToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0 Zm9ybVRleHR1cmUpOiBhZGRlZCB0byBkbyB0aGUgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5IGlmIEdQ VS1hY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlLgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL01lZGlhUGxheWVyLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKE1l ZGlhUGxheWVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllclByaXZh dGUuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUludGVyZmFjZTo6dmlk ZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVy UHJpdmF0ZUludGVyZmFjZTo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKToKKwog MjAxMy0wMy0wNiAgSnVsaWVuIENoYWZmcmFpeCAgPGpjaGFmZnJhaXhAd2Via2l0Lm9yZz4KIAog ICAgICAgICBSZW1vdmUgdGhlIChkZWFkKSBjb2RlIGZvciBoYW5kbGluZyBzaG9ydGhhbmRzIGlu IFN0eWxlUmVzb2x2ZXIgLyBTdHlsZUJ1aWxkZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5k ZXggZDg4ZTA0MzA5MTM1NDU1MDQyMjIzNjI5MmU3NmU5MWU0YmYxOGI0Yi4uNzE1ODE2YWMyMzM0 MmQ2MmM3ZDA5MzAyMzNmNjg0ZjFlOWQxOTg3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cK QEAgLTEsMyArMSwyMiBAQAorMjAxMy0wMy0wNiAgSnVuIEppYW5nICA8anVuLmEuamlhbmdAaW50 ZWwuY29tPgorCisgICAgICAgIEVuYWJsZSBHUFUtR1BVIHRleHR1cmUgY29weSBpbiB0ZXhJbWFn ZTJEKCkgZm9yIEhUTUxWaWRlb0VsZW1lbnQgaWYgaGFyZHdhcmUgYWNjZWxlcmF0ZWQgdmlkZW8g ZGVjb2RlIGlzIGluIHVzZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTExMTI2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBwdWJsaWMvV2ViTWVkaWFQbGF5ZXIuaDoKKyAgICAgICAgKFdlYktpdCk6Cisg ICAgICAgIChXZWJLaXQ6OldlYk1lZGlhUGxheWVyOjp2aWRlb0RlY29kZUFjY2VsZXJhdGVkQnlH cHUpOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRpYVBsYXllcjo6Y29weVZpZGVvVGV4dHVyZVRv UGxhdGZvcm1UZXh0dXJlKToKKyAgICAgICAgKFdlYk1lZGlhUGxheWVyKToKKyAgICAgICAgKiBz cmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTWVk aWFQbGF5ZXJDbGllbnRJbXBsOjp2aWRlb0RlY29kZUFjY2VsZXJhdGVkQnlHcHUpOgorICAgICAg ICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpj b3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgorICAgICAgICAqIHNyYy9XZWJNZWRp YVBsYXllckNsaWVudEltcGwuaDoKKyAgICAgICAgKFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbCk6 CisKIDIwMTMtMDMtMDUgIEFsZXhhbmRyZSBFbGlhcyAgPGFlbGlhc0BjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgW2Nocm9taXVtXSBTY3JvbGwgZGVsdGFzIHNob3VsZCBiZSBmbG9hdHMKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuY3BwCmluZGV4IGNmZTk1NzEzZmY5ZGY4ZDcz NTc1YjgwMmVlNTgxZjA4ZGU2Nzg0MWQuLmUwNTkyMmMzNzU4YTIyMzI2YWEyMzdmYzExOGE3YWMw ZTUwMmE2OTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcApAQCAt MjM3LDYgKzIzNywyMCBAQCB2b2lkIEhUTUxWaWRlb0VsZW1lbnQ6OnBhaW50Q3VycmVudEZyYW1l SW5Db250ZXh0KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29ucwogICAgIHBsYXllci0+cGFp bnRDdXJyZW50RnJhbWVJbkNvbnRleHQoY29udGV4dCwgZGVzdFJlY3QpOwogfQogCitib29sIEhU TUxWaWRlb0VsZW1lbnQ6OnZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgpCit7CisgICAgaWYg KCFwbGF5ZXIoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBwbGF5ZXIoKS0+ dmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KCk7Cit9CisKK2Jvb2wgSFRNTFZpZGVvRWxlbWVu dDo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiBj b250ZXh0LCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0 LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpCit7CisgICAgaWYgKCFwbGF5ZXIo KSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBwbGF5ZXIoKS0+Y29weVZpZGVv VGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKGNvbnRleHQsIHRleHR1cmUsIGludGVybmFsRm9ybWF0 LCBwcmVtdWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIGJvb2wgSFRNTFZpZGVvRWxlbWVudDo6 aGFzQXZhaWxhYmxlVmlkZW9GcmFtZSgpIGNvbnN0CiB7CiAgICAgaWYgKCFwbGF5ZXIoKSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5oIGIvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKaW5kZXggY2Y0ZmVhY2ZjYjcxYjIyZTM2 OTEzYThkOTc4NGNhZWY0MTg1NDlhYi4uNGQwM2QwMmZlMmIyOTMxOTVmYzE0NTZlNjc5MzVjMTVk YTk5YjczZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKQEAgLTYzLDYg KzYzLDEyIEBAIHB1YmxpYzoKICAgICAvLyBVc2VkIGJ5IGNhbnZhcyB0byBnYWluIHJhdyBwaXhl bCBhY2Nlc3MKICAgICB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29u dGV4dCosIGNvbnN0IEludFJlY3QmKTsKIAorICAgIC8vIFVzZWQgYnkgV2ViR0wgdG8gcXVlcnkg aWYgR1BVLWFjY2VsZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBpbiB1c2UgYW5kIGRvIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGlmIHBvc3NpYmxlLgorICAgIC8vIFNlZSBtb3JlIGRldGFpbHMgYXQgTWVk aWFQbGF5ZXI6OnZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgpIGFuZCBNZWRpYVBsYXllcjo6 Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKCkgaW4KKyAgICAvLyBTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oLgorICAgIGJvb2wgdmlkZW9EZWNv ZGVBY2NlbGVyYXRlZEJ5R3B1KCk7CisgICAgYm9vbCBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0QqLCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUsIEdD M0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkp OworCiAgICAgYm9vbCBzaG91bGREaXNwbGF5UG9zdGVySW1hZ2UoKSBjb25zdCB7IHJldHVybiBk aXNwbGF5TW9kZSgpID09IFBvc3RlciB8fCBkaXNwbGF5TW9kZSgpID09IFBvc3RlcldhaXRpbmdG b3JWaWRlbzsgfQogCiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9j YW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2Fu dmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAKaW5kZXggNWJlZjcwZDJjNjVjMzg1ZWFlN2Rk Mjc2OWE2YWIyNjA2NTIzNGViNS4uMThlNzRjNDM4MjdkNjFjZGFiMWMxMjk0NjhhNDMwYTg1MmYw ODg5MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJp bmdDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRl cmluZ0NvbnRleHQuY3BwCkBAIC0zODgyLDIyICszODgyLDE0IEBAIHZvaWQgV2ViR0xSZW5kZXJp bmdDb250ZXh0Ojp0ZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0Mz RGVudW0KIH0KIAogI2lmIEVOQUJMRShWSURFTykKLVBhc3NSZWZQdHI8SW1hZ2U+IFdlYkdMUmVu ZGVyaW5nQ29udGV4dDo6dmlkZW9GcmFtZVRvSW1hZ2UoSFRNTFZpZGVvRWxlbWVudCogdmlkZW8s IEJhY2tpbmdTdG9yZUNvcHkgYmFja2luZ1N0b3JlQ29weSwgRXhjZXB0aW9uQ29kZSYgZWMpCitQ YXNzUmVmUHRyPEltYWdlPiBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZpZGVvRnJhbWVUb0ltYWdl KEhUTUxWaWRlb0VsZW1lbnQqIHZpZGVvLCBCYWNraW5nU3RvcmVDb3B5IGJhY2tpbmdTdG9yZUNv cHksIEV4Y2VwdGlvbkNvZGUmKQogewotICAgIGlmICghdmlkZW8gfHwgIXZpZGVvLT52aWRlb1dp ZHRoKCkgfHwgIXZpZGVvLT52aWRlb0hlaWdodCgpKSB7Ci0gICAgICAgIHN5bnRoZXNpemVHTEVy cm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAidGV4SW1hZ2UyRCIsICJubyB2 aWRlbyIpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9CiAgICAgSW50U2l6ZSBzaXplKHZpZGVv LT52aWRlb1dpZHRoKCksIHZpZGVvLT52aWRlb0hlaWdodCgpKTsKICAgICBJbWFnZUJ1ZmZlciog YnVmID0gbV92aWRlb0NhY2hlLmltYWdlQnVmZmVyKHNpemUpOwogICAgIGlmICghYnVmKSB7CiAg ICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpPVVRfT0ZfTUVNT1JZ LCAidGV4SW1hZ2UyRCIsICJvdXQgb2YgbWVtb3J5Iik7CiAgICAgICAgIHJldHVybiAwOwogICAg IH0KLSAgICBpZiAod291bGRUYWludE9yaWdpbih2aWRlbykpIHsKLSAgICAgICAgZWMgPSBTRUNV UklUWV9FUlI7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KICAgICBJbnRSZWN0IGRlc3RSZWN0 KDAsIDAsIHNpemUud2lkdGgoKSwgc2l6ZS5oZWlnaHQoKSk7CiAgICAgLy8gRklYTUU6IFR1cm4g dGhpcyBpbnRvIGEgR1BVLUdQVSB0ZXh0dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2su CiAgICAgdmlkZW8tPnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KGJ1Zi0+Y29udGV4dCgpLCBk ZXN0UmVjdCk7CkBAIC0zOTEwLDYgKzM5MDIsMzIgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRl eHQ6OnRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bQog ICAgIGVjID0gMDsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAgICByZXR1cm47Cisg ICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVvV2lkdGgoKSB8fCAhdmlkZW8tPnZpZGVvSGVp Z2h0KCkpIHsKKyAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklO VkFMSURfVkFMVUUsICJ0ZXhJbWFnZTJEIiwgIm5vIHZpZGVvIik7CisgICAgICAgIHJldHVybjsK KyAgICB9CisgICAgaWYgKHdvdWxkVGFpbnRPcmlnaW4odmlkZW8pKSB7CisgICAgICAgIGVjID0g U0VDVVJJVFlfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlmICghdmFsaWRhdGVU ZXhGdW5jRm9ybWF0QW5kVHlwZSgidGV4SW1hZ2UyRCIsIGZvcm1hdCwgdHlwZSwgbGV2ZWwpKQor ICAgICAgICByZXR1cm47CisgICAgaWYgKCF2YWxpZGF0ZVNldHRhYmxlVGV4Rm9ybWF0KCJ0ZXhJ bWFnZTJEIiwgZm9ybWF0KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gSWYgR1BVLWFjY2Vs ZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBpbiB1c2UsIGNvcHkgdGhlIFZpZGVvIHRleHR1cmUgdG8g dGhlIHBsYXRmb3JtIHRleHR1cmUgZGlyZWN0bHkKKyAgICAvLyBhdCBHUFUgc2lkZSBpZiBwb3Nz aWJsZSwgd2l0aG91dCBhIHJlYWQtYmFjayB0byBzeXN0ZW0gbWVtb3J5LgorICAgIC8vIEZJWE1F OiByZXN0cmljdGlvbiBvZiAoUkdCIHx8IFJHQkEpL1VOU0lHTkVEX0JZVEUgc2hvdWxkIGJlIGxp ZnRlZCBpbiB0aGUgZnV0dXJlLgorICAgIFdlYkdMVGV4dHVyZSogdGV4dHVyZSA9IHZhbGlkYXRl VGV4dHVyZUJpbmRpbmcoInRleEltYWdlMkQiLCB0YXJnZXQsIHRydWUpOworICAgIGlmIChHcmFw aGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCA9PSB0YXJnZXQgJiYgdGV4dHVyZSAmJiAodGV4dHVy ZS0+Z2V0VHlwZSh0YXJnZXQsIGxldmVsKSA9PSB0eXBlIHx8ICF0ZXh0dXJlLT5pc1ZhbGlkKHRh cmdldCwgbGV2ZWwpKQorICAgICAgICAmJiAoZm9ybWF0ID09IEdyYXBoaWNzQ29udGV4dDNEOjpS R0IgfHwgZm9ybWF0ID09IEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBKSAmJiB0eXBlID09IEdyYXBo aWNzQ29udGV4dDNEOjpVTlNJR05FRF9CWVRFKSB7CisgICAgICAgIGlmICh2aWRlby0+dmlkZW9E ZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KCkgJiYgdmlkZW8tPmNvcHlWaWRlb1RleHR1cmVUb1BsYXRm b3JtVGV4dHVyZShtX2NvbnRleHQuZ2V0KCksIHRleHR1cmUtPm9iamVjdCgpLCBpbnRlcm5hbGZv cm1hdCwgbV91bnBhY2tQcmVtdWx0aXBseUFscGhhLCBtX3VucGFja0ZsaXBZKSkgeworICAgICAg ICAgICAgdGV4dHVyZS0+c2V0TGV2ZWxJbmZvKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0 LCB2aWRlby0+dmlkZW9XaWR0aCgpLCB2aWRlby0+dmlkZW9IZWlnaHQoKSwgdHlwZSk7CisgICAg ICAgICAgICBjbGVhbnVwQWZ0ZXJHcmFwaGljc0NhbGwoZmFsc2UpOworICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICB9CisgICAgfQorCiAgICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9IHZpZGVv RnJhbWVUb0ltYWdlKHZpZGVvLCBJbWFnZUJ1ZmZlcjo6ZmFzdENvcHlJbWFnZU1vZGUoKSwgZWMp OwogICAgIGlmICghaW1hZ2UpCiAgICAgICAgIHJldHVybjsKQEAgLTQxNjEsNiArNDE3OSwyMCBA QCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJn ZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbgogICAgIGVjID0gMDsKICAgICBpZiAoaXNDb250ZXh0 TG9zdCgpKQogICAgICAgICByZXR1cm47CisgICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVv V2lkdGgoKSB8fCAhdmlkZW8tPnZpZGVvSGVpZ2h0KCkpIHsKKyAgICAgICAgc3ludGhlc2l6ZUdM RXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJ0ZXhTdWJJbWFnZTJEIiwg Im5vIHZpZGVvIik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAod291bGRUYWlu dE9yaWdpbih2aWRlbykpIHsKKyAgICAgICAgZWMgPSBTRUNVUklUWV9FUlI7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisgICAgaWYgKCF2YWxpZGF0ZVRleEZ1bmNGb3JtYXRBbmRUeXBlKCJ0ZXhT dWJJbWFnZTJEIiwgZm9ybWF0LCB0eXBlLCBsZXZlbCkpCisgICAgICAgIHJldHVybjsKKyAgICBp ZiAoIXZhbGlkYXRlU2V0dGFibGVUZXhGb3JtYXQoInRleFN1YkltYWdlMkQiLCBmb3JtYXQpKQor ICAgICAgICByZXR1cm47CisKICAgICBSZWZQdHI8SW1hZ2U+IGltYWdlID0gdmlkZW9GcmFtZVRv SW1hZ2UodmlkZW8sIEltYWdlQnVmZmVyOjpmYXN0Q29weUltYWdlTW9kZSgpLCBlYyk7CiAgICAg aWYgKCFpbWFnZSkKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFz L1dlYkdMVGV4dHVyZS5jcHAKaW5kZXggOWFkNThiNGJjMTY0NzBlYTA0ZjY0ODk4MGI3Njk1MTI2 YTNiZDJiNi4uNjM0ZDA3NDAxODJjNWU2ZjQ0ZmI3NzE5MDgwZjc3MGVlM2IzNzcxYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuY3BwCkBAIC0yMDcsNiArMjA3 LDE0IEBAIEdDM0RzaXplaSBXZWJHTFRleHR1cmU6OmdldEhlaWdodChHQzNEZW51bSB0YXJnZXQs IEdDM0RpbnQgbGV2ZWwpIGNvbnN0CiAgICAgcmV0dXJuIGluZm8tPmhlaWdodDsKIH0KIAorYm9v bCBXZWJHTFRleHR1cmU6OmlzVmFsaWQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBj b25zdAoreworICAgIGNvbnN0IExldmVsSW5mbyogaW5mbyA9IGdldExldmVsSW5mbyh0YXJnZXQs IGxldmVsKTsKKyAgICBpZiAoIWluZm8pCisgICAgICAgIHJldHVybiAwOworICAgIHJldHVybiBp bmZvLT52YWxpZDsKK30KKwogYm9vbCBXZWJHTFRleHR1cmU6OmlzTlBPVChHQzNEc2l6ZWkgd2lk dGgsIEdDM0RzaXplaSBoZWlnaHQpCiB7CiAgICAgQVNTRVJUKHdpZHRoID49IDAgJiYgaGVpZ2h0 ID49IDApOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0 dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuaAppbmRleCBk MWRiOTUxZmZjMjBkMTk3ODcxOTk1MDM1MDUyMTMxOGQxZjYwYzc3Li5hNGMxNTA3Y2YwZmM0MTFk NzRkNDI0YjhjNTFmMzNhNDkxMGI1OGUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L2NhbnZhcy9XZWJHTFRleHR1cmUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9X ZWJHTFRleHR1cmUuaApAQCAtNTgsNiArNTgsNyBAQCBwdWJsaWM6CiAgICAgR0MzRGVudW0gZ2V0 VHlwZShHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwpIGNvbnN0OwogICAgIEdDM0RzaXpl aSBnZXRXaWR0aChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwpIGNvbnN0OwogICAgIEdD M0RzaXplaSBnZXRIZWlnaHQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsK KyAgICBib29sIGlzVmFsaWQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsK IAogICAgIC8vIFdoZXRoZXIgd2lkdGgvaGVpZ2h0IGlzIE5vdFBvd2VyT2ZUd28uCiAgICAgc3Rh dGljIGJvb2wgaXNOUE9UKEdDM0RzaXplaSwgR0MzRHNpemVpKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcAppbmRleCBmMGIxODJkMjQwMzRi Mjk3ZmJkNzc5ODI1YjQ1NGZhZTI1NTIyNWEzLi5lZTcwMDFhNWU5NzQ4ZDg2ODZkZWM5MTAxNTMy OTEyYjE0YmQwMzY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9NZWRpYVBsYXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv TWVkaWFQbGF5ZXIuY3BwCkBAIC03MjcsNiArNzI3LDE2IEBAIHZvaWQgTWVkaWFQbGF5ZXI6OnBh aW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4dCogcCwgY29uc3QgSW50UmVj dCYKICAgICBtX3ByaXZhdGUtPnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KHAsIHIpOwogfQog Citib29sIE1lZGlhUGxheWVyOjp2aWRlb0RlY29kZUFjY2VsZXJhdGVkQnlHcHUoKQoreworICAg IHJldHVybiBtX3ByaXZhdGUtPnZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgpOworfQorCiti b29sIE1lZGlhUGxheWVyOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhp Y3NDb250ZXh0M0QqIGNvbnRleHQsIFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwgR0MzRGVudW0g aW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlwWSkKK3sKKyAg ICByZXR1cm4gbV9wcml2YXRlLT5jb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoY29u dGV4dCwgdGV4dHVyZSwgaW50ZXJuYWxGb3JtYXQsIHByZW11bHRpcGx5QWxwaGEsIGZsaXBZKTsK K30KKwogTWVkaWFQbGF5ZXI6OlN1cHBvcnRzVHlwZSBNZWRpYVBsYXllcjo6c3VwcG9ydHNUeXBl KGNvbnN0IENvbnRlbnRUeXBlJiBjb250ZW50VHlwZSwgY29uc3QgU3RyaW5nJiBrZXlTeXN0ZW0s IGNvbnN0IEtVUkwmIHVybCwgY29uc3QgTWVkaWFQbGF5ZXJTdXBwb3J0c1R5cGVDbGllbnQqIGNs aWVudCkKIHsKICAgICBTdHJpbmcgdHlwZSA9IGNvbnRlbnRUeXBlLnR5cGUoKS5sb3dlcigpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIu aCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmgKaW5kZXgg OWU1NmNiODE1N2Q2NmJhYzhkNDRiNzIwMDJhYmViODJkMTUwYjg4Ni4uZTI4NjUyZDY2MzZkMzY3 ZWYwYzUxMWVhMzRlZjI0ZjEzZWRhMjM5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9NZWRpYVBsYXllci5oCkBAIC0yNyw3ICsyNyw3IEBACiAjZGVmaW5lIE1lZGlh UGxheWVyX2gKIAogI2lmIEVOQUJMRShWSURFTykKLQorI2luY2x1ZGUgIkdyYXBoaWNzVHlwZXMz RC5oIgogI2lmIEVOQUJMRShQTFVHSU5fUFJPWFlfRk9SX1ZJREVPKQogI2luY2x1ZGUgIk1lZGlh UGxheWVyUHJveHkuaCIKICNlbmRpZgpAQCAtMTAxLDYgKzEwMSw3IEBAIGNsYXNzIENhY2hlZFJl c291cmNlTG9hZGVyOwogY2xhc3MgQ29udGVudFR5cGU7CiBjbGFzcyBGcmFtZVZpZXc7CiBjbGFz cyBHcmFwaGljc0NvbnRleHQ7CitjbGFzcyBHcmFwaGljc0NvbnRleHQzRDsKIGNsYXNzIEludFJl Y3Q7CiBjbGFzcyBJbnRTaXplOwogY2xhc3MgTWVkaWFQbGF5ZXI7CkBAIC0zMjksNiArMzMwLDIy IEBAIHB1YmxpYzoKICAgICB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJl Y3QmKTsKICAgICB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4 dCosIGNvbnN0IEludFJlY3QmKTsKIAorICAgIC8vIHZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdw dSgpIGlzIHVzZWQgdG8gcXVlcnkgaWYgR1BVLWFjY2VsZXJhdGVkIHZpZGVvIGRlY29kZSBpcyBp biB1c2UgYW5kIHJldHVybnMgdHJ1ZSBpZiBpdCBpcy4KKyAgICBib29sIHZpZGVvRGVjb2RlQWNj ZWxlcmF0ZWRCeUdwdSgpOworCisgICAgLy8gY29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0 dXJlKCkgaXMgdXNlZCB0byBkbyB0aGUgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5IHdpdGhvdXQgYSBy ZWFkYmFjayB0byBzeXN0ZW0gbWVtb3J5LgorICAgIC8vIFRoZSBmaXJzdCB0aHJlZSBwYXJhbWV0 ZXJzIGRlbm90ZSB0aGUgY29ycmVzcG9uZGluZyBHcmFwaGljc0NvbnRleHQsIGRlc3RpbmF0aW9u IHRleHR1cmUgYW5kIHRoZSByZXF1aXJlZCBpbnRlcm5hbEZvcm1hdCBmb3IgZGVzdGluYXRpb24g dGV4dHVyZS4KKyAgICAvLyBUaGUgbGFzdCB0d28gcGFyYW1ldGVycyBwcmVtdWx0aXBseUFscGhh IGFuZCBmbGlwWSBkZW5vdGUgd2hldGhlciBhZGR0aW9uYWwgcHJlbXVsdGlwbHlBbHBoYSBhbmQg ZmxpcCBvcGVyYXRpb24gYXJlIHJlcXVpcmVkIGR1cmluZyB0aGUgY29weS4KKyAgICAvLyBJdCBy ZXR1cm5zIHRydWUgb24gc3VjY2VzcyBhbmQgZmFsc2Ugb24gZmFpbHVyZS4KKworICAgIC8vIElu IHRoZSBHUFUtR1BVIHRleHR1cmVzIGNvcHksIHRoZSBzb3VyY2UgdGV4dHVyZSBzaG91bGQgaGF2 ZSB0aGUgdmFsaWQgdGFyZ2V0LCBpbnRlcm5hbEZvcm1hdCBhbmQgc2l6ZSwgZXRjLgorICAgIC8v IFRoZSBkZXN0aW5hdGlvbiB0ZXh0dXJlIG1heSBuZWVkIHRvIGJlIHJlc2l6ZWQgdG8gdGhlIGRp bWVuc2lvbnMgb2YgdGhlIHNvdXJjZSB0ZXh0dXJlIG9yIHdyYXBwZWQgdG8gdGhlIHJlcXVpcmVk IGludGVybmFsRm9ybWF0LgorCisgICAgLy8gVGhpcyBmdW5jdGlvbiByZXF1aXJlcyB0aGUgcGxh dGZvcm0gR3JhcGhpY3MgcG9ydCB0byBzdXBwb3J0IEdMX0NIUk9NSVVNX2NvcHlfdGV4dHVyZSBl eHRlbnNpb24gd2hpY2ggaXMgZG9jdW1lbnRlZCBhdAorICAgIC8vIGh0dHA6Ly9zcmMuY2hyb21p dW0ub3JnL3ZpZXd2Yy9jaHJvbWUvdHJ1bmsvc3JjL2dwdS9HTEVTMi9leHRlbnNpb25zL0NIUk9N SVVNL0NIUk9NSVVNX2NvcHlfdGV4dHVyZS50eHQuCisgICAgLy8gSW4gQ2hyb21pdW0sIGl0IGlz IGltcGxlbWVudGVkIGF0IGh0dHA6Ly9zcmMuY2hyb21pdW0ub3JnL3ZpZXd2Yy9jaHJvbWUvdHJ1 bmsvc3JjL2dwdS9jb21tYW5kX2J1ZmZlci9zZXJ2aWNlL2dsZXMyX2NtZF9jb3B5X3RleHR1cmVf Y2hyb21pdW0uY2MgdmlhIHNoYWRlcnMuCisgICAgYm9vbCBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0 Zm9ybVRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0QqLCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUs IEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxp cFkpOworCiAgICAgZW51bSBOZXR3b3JrU3RhdGUgeyBFbXB0eSwgSWRsZSwgTG9hZGluZywgTG9h ZGVkLCBGb3JtYXRFcnJvciwgTmV0d29ya0Vycm9yLCBEZWNvZGVFcnJvciB9OwogICAgIE5ldHdv cmtTdGF0ZSBuZXR3b3JrU3RhdGUoKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXJQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllclByaXZhdGUuaAppbmRleCAxZjNmM2UxMGE4N2M5Mzk1 NzViM2JjNzc3MzhiYzEyODgwZDFhNTQ0Li43NzExOWIwNTI2MmIzYTk2MDBjMjZlNzljMjU0ZmI5 YmRhMjEwN2VjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9N ZWRpYVBsYXllclByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9NZWRpYVBsYXllclByaXZhdGUuaApAQCAtMTA2LDYgKzEwNiw4IEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIHZvaWQgcGFpbnQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVjdCYpID0gMDsK IAogICAgIHZpcnR1YWwgdm9pZCBwYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChHcmFwaGljc0Nv bnRleHQqIGMsIGNvbnN0IEludFJlY3QmIHIpIHsgcGFpbnQoYywgcik7IH0KKyAgICB2aXJ0dWFs IGJvb2wgdmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1KCkgeyByZXR1cm4gZmFsc2U7IH0KKyAg ICB2aXJ0dWFsIGJvb2wgY29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNz Q29udGV4dDNEKiwgUGxhdGZvcm0zRE9iamVjdCwgR0MzRGVudW0sIGJvb2wsIGJvb2wpIHsgcmV0 dXJuIGZhbHNlOyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0UHJlbG9hZChNZWRpYVBsYXllcjo6 UHJlbG9hZCkgeyB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYk1lZGlhUGxheWVyLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRp YVBsYXllci5oCmluZGV4IGY5YTdmYWZmOGJjZWExYmMwMzYzYTg1OTJmYTlhNDgxNzA3OTJmZTUu LmVhYmU0ZmYzNDllYjA3ZGU3MzQ4ZDdkMGQ5ZDVlMmI3YTk0NmJlMjMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyLmgKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXIuaApAQCAtNDcsNiArNDcsNyBA QCBjbGFzcyBXZWJTdHJpbmc7CiBjbGFzcyBXZWJVUkw7CiBzdHJ1Y3QgV2ViUmVjdDsKIHN0cnVj dCBXZWJTaXplOworY2xhc3MgV2ViR3JhcGhpY3NDb250ZXh0M0Q7CiAKIGNsYXNzIFdlYk1lZGlh UGxheWVyIHsKIHB1YmxpYzoKQEAgLTE4MCw2ICsxODEsOSBAQCBwdWJsaWM6CiAgICAgLy8gbWV0 aG9kIHNob3VsZCBubyBsb25nZXIgYmUgcmVmZXJlbmNlZCBhZnRlciB0aGUgY2FsbCBpcyBtYWRl LgogICAgIHZpcnR1YWwgdm9pZCBwdXRDdXJyZW50RnJhbWUoV2ViVmlkZW9GcmFtZSopIHsgfQog CisgICAgdmlydHVhbCBib29sIHZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgpIHsgcmV0dXJu IGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4 dHVyZShXZWJHcmFwaGljc0NvbnRleHQzRCosIHVuc2lnbmVkLCB1bnNpZ25lZCkgeyByZXR1cm4g ZmFsc2U7IH0KKwogICAgIHZpcnR1YWwgdm9pZCBzZXRTdHJlYW1UZXh0dXJlQ2xpZW50KFdlYlN0 cmVhbVRleHR1cmVDbGllbnQqKSB7IH0KIAogICAgIHZpcnR1YWwgV2ViQXVkaW9Tb3VyY2VQcm92 aWRlciogYXVkaW9Tb3VyY2VQcm92aWRlcigpIHsgcmV0dXJuIDA7IH0KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCmlu ZGV4IGMzZGJiYzMzNDNiNWIzNGE2NmY4ZTdhOWM3N2I4NmNiYWJjOTM3OGQuLmRjNmQxZWVkM2Zm ZWM4ZTJiYzUwNjc4NDkzOWQ0ZWRkNGM5MjQ2YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcApAQCAtMTIsNiAr MTIsNyBAQAogI2luY2x1ZGUgIkF1ZGlvU291cmNlUHJvdmlkZXJDbGllbnQuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgorI2luY2x1ZGUgIkdyYXBo aWNzQ29udGV4dDNEUHJpdmF0ZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXJDaHJvbWl1bS5o IgogI2luY2x1ZGUgIkhUTUxNZWRpYUVsZW1lbnQuaCIKICNpbmNsdWRlICJJbnRTaXplLmgiCkBA IC03NjMsNiArNzY0LDM4IEBAIHZvaWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpwYWludEN1 cnJlbnRGcmFtZUluQ29udGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRlCiAgICAgfQogfQogCiti b29sIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6dmlkZW9EZWNvZGVBY2NlbGVyYXRlZEJ5R3B1 KCkKK3sKKyAgICBpZiAobV93ZWJNZWRpYVBsYXllcikKKyAgICAgICAgcmV0dXJuIG1fd2ViTWVk aWFQbGF5ZXItPnZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgpOworICAgIHJldHVybiBmYWxz ZTsKK30KKworYm9vbCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNvcHlWaWRlb1RleHR1cmVU b1BsYXRmb3JtVGV4dHVyZShXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgUGxh dGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVt dWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworICAgIGlmICghY29udGV4dCB8fCAhbV93ZWJN ZWRpYVBsYXllcikKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIEV4dGVuc2lvbnMzRCogZXh0 ZW5zaW9ucyA9IGNvbnRleHQtPmdldEV4dGVuc2lvbnMoKTsKKyAgICBpZiAoIWV4dGVuc2lvbnMg fHwgIWV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9DSFJPTUlVTV9jb3B5X3RleHR1cmUiKSB8fCAh ZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0NIUk9NSVVNX2ZsaXB5IikgfHwgIWNvbnRleHQtPm1h a2VDb250ZXh0Q3VycmVudCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgV2ViR3JhcGhp Y3NDb250ZXh0M0QqIHdlYkdyYXBoaWNzQ29udGV4dDNEID0gR3JhcGhpY3NDb250ZXh0M0RQcml2 YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoY29udGV4dCk7CisgICAgaWYgKCF3ZWJH cmFwaGljc0NvbnRleHQzRCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgYm9vbCByZXQg PSBmYWxzZTsKKyAgICAvLyBUaGUgdmlkZW8gaXMgc3RvcmVkIGluIGEgdW5tdWx0aXBsaWVkIGZv cm1hdCwgc28gcHJlbXVsdGlwbHkgaWYgbmVjZXNzYXJ5LgorICAgIGNvbnRleHQtPnBpeGVsU3Rv cmVpKEV4dGVuc2lvbnMzRDo6VU5QQUNLX1BSRU1VTFRJUExZX0FMUEhBX0NIUk9NSVVNLCBwcmVt dWx0aXBseUFscGhhKTsKKyAgICAvLyBBcHBsaWNhdGlvbiBpdHNlbGYgbmVlZHMgdG8gdGFrZSBj YXJlIG9mIHNldHRpbmcgdGhlIHJpZ2h0IGZsaXBZIHZhbHVlIGRvd24gdG8gZ2V0IHRoZSBleHBl Y3RlZCByZXN1bHQuCisgICAgLy8gZmxpcFk9PXRydWUgbWVhbnMgdG8gcmV2ZXJzZSB0aGUgVmlk ZW8gcG9zaXRpb24gd2hpbGUgZmxpcFk9PWZhbHNlIG1lYW5zIHRvIGtlZXAgdGhlIGludHJpbnNp YyBwb3NpdGlvbi4KKyAgICBjb250ZXh0LT5waXhlbFN0b3JlaShFeHRlbnNpb25zM0Q6OlVOUEFD S19GTElQX1lfQ0hST01JVU0sIGZsaXBZKTsKKyAgICByZXQgPSBtX3dlYk1lZGlhUGxheWVyLT5j b3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUod2ViR3JhcGhpY3NDb250ZXh0M0QsIHRl eHR1cmUsIGludGVybmFsRm9ybWF0KTsKKyAgICBjb250ZXh0LT5waXhlbFN0b3JlaShFeHRlbnNp b25zM0Q6OlVOUEFDS19GTElQX1lfQ0hST01JVU0sIGZhbHNlKTsKKyAgICBjb250ZXh0LT5waXhl bFN0b3JlaShFeHRlbnNpb25zM0Q6OlVOUEFDS19QUkVNVUxUSVBMWV9BTFBIQV9DSFJPTUlVTSwg ZmFsc2UpOworICAgIGNvbnRleHQtPmZsdXNoKCk7CisKKyAgICByZXR1cm4gcmV0OworfQorCiB2 b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6c2V0UHJlbG9hZChNZWRpYVBsYXllcjo6UHJl bG9hZCBwcmVsb2FkKQogewogICAgIG1fcHJlbG9hZCA9IHByZWxvYWQ7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaCBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCmluZGV4 IDk5ZDJlOGJkYmU4NDU0ODBiNzVkMTNhZmVlOWM1M2VkZDk0ZTBmNzYuLmYwYmVkZmNiMmU3ZDMz ZDc3ZWNkN2MwMTBlYjI1NjI5NmVhM2RmZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCkBAIC0xMzIsNiArMTMyLDgg QEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRTaXplKGNvbnN0IFdlYkNvcmU6OkludFNp emUmKTsKICAgICB2aXJ0dWFsIHZvaWQgcGFpbnQoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Kiwg Y29uc3QgV2ViQ29yZTo6SW50UmVjdCYpOwogICAgIHZpcnR1YWwgdm9pZCBwYWludEN1cnJlbnRG cmFtZUluQ29udGV4dChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQqLCBjb25zdCBXZWJDb3JlOjpJ bnRSZWN0Jik7CisgICAgdmlydHVhbCBib29sIHZpZGVvRGVjb2RlQWNjZWxlcmF0ZWRCeUdwdSgp OworICAgIHZpcnR1YWwgYm9vbCBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoV2Vi Q29yZTo6R3JhcGhpY3NDb250ZXh0M0QqLCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUsIEdDM0Rl bnVtIGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpOwog ICAgIHZpcnR1YWwgdm9pZCBzZXRQcmVsb2FkKFdlYkNvcmU6Ok1lZGlhUGxheWVyOjpQcmVsb2Fk KTsKICAgICB2aXJ0dWFsIGJvb2wgaGFzU2luZ2xlU2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKICAg ICB2aXJ0dWFsIGJvb2wgZGlkUGFzc0NPUlNBY2Nlc3NDaGVjaygpIGNvbnN0Owo= 192373 2013-03-10 06:42:37 -0700 2013-03-12 08:52:50 -0700 Patch bug-111126-20130310213836.patch text/plain 19083 jun.a.jiang U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1MzIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmY2ZWQ0NWIxZjIyNGJk NzkzYmEyYWI1MGYxNDE2NzEwZGQzZTFkMy4uYWE4ZTkyMzk3ODc5OGUzNjY1NGQ5NTc3NTQxMzJl ZjIzM2U0YjhkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEzLTAzLTEwICBKdW4g SmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJk d2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiB0ZXhJbWFnZTJEKCkgZm9yIEhUTUxW aWRlb0VsZW1lbnQgaW4gV2ViR0wsIGl0IGlzIHBvc3NpYmxlIHRvIGRvIGEgR1BVLUdQVSB0ZXh0 dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2sgCisgICAgICAgIGFuZCB1cGxvYWQgd2hl biB2aWRlb0ZyYW1lIGlzIGluIHRoZSBmb3JtIG9mIHRleHR1cmVzLiBFYWNoIHBsYXRmb3JtIHBv cnQgbmVlZHMgdG8gaW1wbGVtZW50IHRoZSBpbnRlcmZhY2UgCisgICAgICAgIGNvcHlWaWRlb1Rl eHR1cmVUb1BsYXRmb3JtVGV4dHVyZSgpIGRlZmluZWQgaW4gTWVkaWFQbGF5ZXIuaCB0byBtYWtl IGl0IHdvcmsuCisKKyAgICAgICAgQWxyZWFkeSBjb3ZlcmVkIGJ5IGN1cnJlbnQgdGVzdHMuCisK KyAgICAgICAgKiBodG1sL0hUTUxWaWRlb0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTFZpZGVvRWxlbWVudDo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKToKKyAg ICAgICAgKiBodG1sL0hUTUxWaWRlb0VsZW1lbnQuaDoKKyAgICAgICAgKEhUTUxWaWRlb0VsZW1l bnQpOgorICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZpZGVvRnJhbWVUb0ltYWdl KTogTW92ZSBzb21lIHNlY3VyaXR5IGNoZWNrIHRvIHVwcGVyIGxldmVsLgorICAgICAgICAoV2Vi Q29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0ZXhJbWFnZTJEKTogQWRkIHRoZSBmYXN0IEdQ VS1HUFUgdGV4dHVyZXMgY29weSBwYXRoIGZvciBIVE1MVmlkZW9FbGVtZW50IGFuZCBzb21lIHNl Y3VyaXR5IGNoZWNrLgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0 ZXhTdWJJbWFnZTJEKTogQWRkIHNvbWUgc2VjdXJpdHkgY2hlY2suIAorICAgICAgICAqIGh0bWwv Y2FudmFzL1dlYkdMVGV4dHVyZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXZWJHTFRleHR1cmU6 OmlzVmFsaWQpOiBBZGRlZCB0byBjaGVjayBpZiB0aGUgdGV4dHVyZSBpcyBkZWZpbmVkIGF0IHRo ZSBnaXZlbiBsZXZlbC4KKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuaDoKKyAg ICAgICAgKFdlYkdMVGV4dHVyZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQ bGF5ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQbGF5ZXI6OmNvcHlWaWRlb1RleHR1 cmVUb1BsYXRmb3JtVGV4dHVyZSk6IEFkZGVkIHRvIGRvIHRoZSBHUFUtR1BVIHRleHR1cmVzIGNv cHkuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaDoKKyAgICAgICAg KE1lZGlhUGxheWVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllclBy aXZhdGUuaDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUludGVyZmFjZTo6 Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKToKKwogMjAxMy0wMy0wOSAgRXJpYyBD YXJsc29uICA8ZXJpYy5jYXJsc29uQGFwcGxlLmNvbT4KIAogICAgICAgICBFbmFibGUgcGxhdGZv cm0gY29kZSB0byBpbXBsZW1lbnQgdGV4dCB0cmFjayBtZW51CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCmluZGV4IGEyMDI3YTc4MjQzNTJkZTk3MjUyYWU2OWExZTZhN2I3NThjYzE5ZDYuLjhkZjEy OTAzNmU3NzMwZGFiZjJmMmIzZTJhZWI5YzFlNmZmZjIxNmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTMtMDMtMTAgIEp1biBKaWFuZyAgPGp1bi5hLmpp YW5nQGludGVsLmNvbT4KKworICAgICAgICBFbmFibGUgR1BVLUdQVSB0ZXh0dXJlIGNvcHkgaW4g dGV4SW1hZ2UyRCgpIGZvciBIVE1MVmlkZW9FbGVtZW50IGlmIGhhcmR3YXJlIGFjY2VsZXJhdGVk IHZpZGVvIGRlY29kZSBpcyBpbiB1c2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTExMTEyNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogcHVibGljL1dlYk1lZGlhUGxheWVyLmg6CisgICAgICAgIChXZWJL aXQpOgorICAgICAgICAoV2ViTWVkaWFQbGF5ZXIpOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRp YVBsYXllcjo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKToKKyAgICAgICAgKiBz cmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTWVk aWFQbGF5ZXJDbGllbnRJbXBsOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgor ICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKiBzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBs Lmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYk1lZGlhUGxheWVyQ2xpZW50SW1w bCk6CisKIDIwMTMtMDMtMDkgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFtjaHJvbWl1bV0gUmVtb3ZlIGRlcHJlY2F0ZWQgZmxpbmdTdGFy dC5zb3VyY2VEZXZpY2UgZnJvbSBXZWJHZXN0dXJlRXZlbnQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxWaWRlb0VsZW1lbnQuY3BwCmluZGV4IGNmZTk1NzEzZmY5ZGY4ZDczNTc1YjgwMmVlNTgxZjA4 ZGU2Nzg0MWQuLmU1ZTc5ZDBkYzcwYzVlNmFlNzM5YzViYjM2MDY2MmJlMGVkZjA3ZDggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcApAQCAtMjM3LDYgKzIzNywxMyBA QCB2b2lkIEhUTUxWaWRlb0VsZW1lbnQ6OnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBo aWNzQ29udGV4dCogY29udGV4dCwgY29ucwogICAgIHBsYXllci0+cGFpbnRDdXJyZW50RnJhbWVJ bkNvbnRleHQoY29udGV4dCwgZGVzdFJlY3QpOwogfQogCitib29sIEhUTUxWaWRlb0VsZW1lbnQ6 OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCogY29u dGV4dCwgV2ViR0xUZXh0dXJlKiB0ZXh0dXJlLCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSB0eXBl LCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZs aXBZKQoreworICAgIGlmICghcGxheWVyKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBy ZXR1cm4gcGxheWVyKCktPmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShjb250ZXh0 LCB0ZXh0dXJlLCBsZXZlbCwgdHlwZSwgaW50ZXJuYWxGb3JtYXQsIHByZW11bHRpcGx5QWxwaGEs IGZsaXBZKTsKK30KKwogYm9vbCBIVE1MVmlkZW9FbGVtZW50OjpoYXNBdmFpbGFibGVWaWRlb0Zy YW1lKCkgY29uc3QKIHsKICAgICBpZiAoIXBsYXllcigpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxW aWRlb0VsZW1lbnQuaAppbmRleCBjZjRmZWFjZmNiNzFiMjJlMzY5MTNhOGQ5Nzg0Y2FlZjQxODU0 OWFiLi4xZjUxN2RhMzZlMzZhNmMzN2IzMWE3NDRlYTc5YjllOTNiNmViNWM3IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuaApAQCAtNjMsNiArNjMsMTAgQEAgcHVibGljOgog ICAgIC8vIFVzZWQgYnkgY2FudmFzIHRvIGdhaW4gcmF3IHBpeGVsIGFjY2VzcwogICAgIHZvaWQg cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0KiwgY29uc3QgSW50UmVj dCYpOwogCisgICAgLy8gVXNlZCBieSBXZWJHTCB0byBkbyBHUFUtR1BVIHRleHR1cmVzIGNvcHkg aWYgcG9zc2libGUuCisgICAgLy8gU2VlIG1vcmUgZGV0YWlscyBhdCBNZWRpYVBsYXllcjo6Y29w eVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKCkgZGVmaW5lZCBpbiBTb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oLgorICAgIGJvb2wgY29weVZpZGVvVGV4 dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiwgV2ViR0xUZXh0dXJlKiwg R0MzRGludCBsZXZlbCwgR0MzRGVudW0gdHlwZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJv b2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlwWSk7CisKICAgICBib29sIHNob3VsZERpc3Bs YXlQb3N0ZXJJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVyIHx8 IGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVyV2FpdGluZ0ZvclZpZGVvOyB9CiAKIHByaXZhdGU6CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRl eHQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0 LmNwcAppbmRleCA0OTk2OTU4YmIzMzRlYmU1NTJjMGRhZjJiYWExNmU1NWVlODlmMmU5Li4wNDMz YmU3OWRjMzJmMzIwYmJkMmJlM2ViMTdkNDJlZDQ3NTM3YjBjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAKQEAgLTM4ODcs MjIgKzM4ODcsMTQgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleEltYWdlMkQoR0Mz RGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bQogfQogCiAjaWYgRU5BQkxFKFZJ REVPKQotUGFzc1JlZlB0cjxJbWFnZT4gV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2aWRlb0ZyYW1l VG9JbWFnZShIVE1MVmlkZW9FbGVtZW50KiB2aWRlbywgQmFja2luZ1N0b3JlQ29weSBiYWNraW5n U3RvcmVDb3B5LCBFeGNlcHRpb25Db2RlJiBlYykKK1Bhc3NSZWZQdHI8SW1hZ2U+IFdlYkdMUmVu ZGVyaW5nQ29udGV4dDo6dmlkZW9GcmFtZVRvSW1hZ2UoSFRNTFZpZGVvRWxlbWVudCogdmlkZW8s IEJhY2tpbmdTdG9yZUNvcHkgYmFja2luZ1N0b3JlQ29weSwgRXhjZXB0aW9uQ29kZSYpCiB7Ci0g ICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVvV2lkdGgoKSB8fCAhdmlkZW8tPnZpZGVvSGVp Z2h0KCkpIHsKLSAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklO VkFMSURfVkFMVUUsICJ0ZXhJbWFnZTJEIiwgIm5vIHZpZGVvIik7Ci0gICAgICAgIHJldHVybiAw OwotICAgIH0KICAgICBJbnRTaXplIHNpemUodmlkZW8tPnZpZGVvV2lkdGgoKSwgdmlkZW8tPnZp ZGVvSGVpZ2h0KCkpOwogICAgIEltYWdlQnVmZmVyKiBidWYgPSBtX3ZpZGVvQ2FjaGUuaW1hZ2VC dWZmZXIoc2l6ZSk7CiAgICAgaWYgKCFidWYpIHsKICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3Io R3JhcGhpY3NDb250ZXh0M0Q6Ok9VVF9PRl9NRU1PUlksICJ0ZXhJbWFnZTJEIiwgIm91dCBvZiBt ZW1vcnkiKTsKICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQotICAgIGlmICh3b3VsZFRhaW50T3Jp Z2luKHZpZGVvKSkgewotICAgICAgICBlYyA9IFNFQ1VSSVRZX0VSUjsKLSAgICAgICAgcmV0dXJu IDA7Ci0gICAgfQogICAgIEludFJlY3QgZGVzdFJlY3QoMCwgMCwgc2l6ZS53aWR0aCgpLCBzaXpl LmhlaWdodCgpKTsKICAgICAvLyBGSVhNRTogVHVybiB0aGlzIGludG8gYSBHUFUtR1BVIHRleHR1 cmUgY29weSBpbnN0ZWFkIG9mIENQVSByZWFkYmFjay4KICAgICB2aWRlby0+cGFpbnRDdXJyZW50 RnJhbWVJbkNvbnRleHQoYnVmLT5jb250ZXh0KCksIGRlc3RSZWN0KTsKQEAgLTM5MTUsNiArMzkw NywzMSBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4SW1hZ2UyRChHQzNEZW51bSB0 YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtCiAgICAgZWMgPSAwOwogICAgIGlmIChpc0Nv bnRleHRMb3N0KCkpCiAgICAgICAgIHJldHVybjsKKyAgICBpZiAoIXZpZGVvIHx8ICF2aWRlby0+ dmlkZW9XaWR0aCgpIHx8ICF2aWRlby0+dmlkZW9IZWlnaHQoKSkgeworICAgICAgICBzeW50aGVz aXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgInRleEltYWdlMkQi LCAibm8gdmlkZW8iKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBpZiAod291bGRUYWlu dE9yaWdpbih2aWRlbykpIHsKKyAgICAgICAgZWMgPSBTRUNVUklUWV9FUlI7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisgICAgaWYgKCF2YWxpZGF0ZVRleEZ1bmNGb3JtYXRBbmRUeXBlKCJ0ZXhJ bWFnZTJEIiwgZm9ybWF0LCB0eXBlLCBsZXZlbCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAo IXZhbGlkYXRlU2V0dGFibGVUZXhGb3JtYXQoInRleEltYWdlMkQiLCBmb3JtYXQpKQorICAgICAg ICByZXR1cm47CisKKyAgICAvLyBHbyB0aHJvdWdoIHRoZSBmYXN0IHBhdGggZG9pbmcgYSBHUFUt R1BVIHRleHR1cmVzIGNvcHkgd2l0aG91dCBhIHJlYWRiYWNrIHRvIHN5c3RlbSBtZW1vcnkgaWYg cG9zc2libGUuCisgICAgLy8gT3RoZXJ3aXNlLCBpdCB3aWxsIGZhbGwgYmFjayB0byB0aGUgbm9y bWFsIFNXIHBhdGguCisgICAgV2ViR0xUZXh0dXJlKiB0ZXh0dXJlID0gdmFsaWRhdGVUZXh0dXJl QmluZGluZygidGV4SW1hZ2UyRCIsIHRhcmdldCwgdHJ1ZSk7CisgICAgaWYgKEdyYXBoaWNzQ29u dGV4dDNEOjpURVhUVVJFXzJEID09IHRhcmdldCAmJiB0ZXh0dXJlKSB7CisgICAgICAgIGlmICh2 aWRlby0+Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKG1fY29udGV4dC5nZXQoKSwg dGV4dHVyZSwgbGV2ZWwsIHR5cGUsIGludGVybmFsZm9ybWF0LCBtX3VucGFja1ByZW11bHRpcGx5 QWxwaGEsIG1fdW5wYWNrRmxpcFkpKSB7CisgICAgICAgICAgICB0ZXh0dXJlLT5zZXRMZXZlbElu Zm8odGFyZ2V0LCBsZXZlbCwgaW50ZXJuYWxmb3JtYXQsIHZpZGVvLT52aWRlb1dpZHRoKCksIHZp ZGVvLT52aWRlb0hlaWdodCgpLCB0eXBlKTsKKyAgICAgICAgICAgIGNsZWFudXBBZnRlckdyYXBo aWNzQ2FsbChmYWxzZSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisK KyAgICAvLyBOb3JtYWwgcHVyZSBTVyBwYXRoLgogICAgIFJlZlB0cjxJbWFnZT4gaW1hZ2UgPSB2 aWRlb0ZyYW1lVG9JbWFnZSh2aWRlbywgSW1hZ2VCdWZmZXI6OmZhc3RDb3B5SW1hZ2VNb2RlKCks IGVjKTsKICAgICBpZiAoIWltYWdlKQogICAgICAgICByZXR1cm47CkBAIC00MTY2LDYgKzQxODMs MjAgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleFN1YkltYWdlMkQoR0MzRGVudW0g dGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW4KICAgICBlYyA9IDA7CiAgICAgaWYgKGlzQ29u dGV4dExvc3QoKSkKICAgICAgICAgcmV0dXJuOworICAgIGlmICghdmlkZW8gfHwgIXZpZGVvLT52 aWRlb1dpZHRoKCkgfHwgIXZpZGVvLT52aWRlb0hlaWdodCgpKSB7CisgICAgICAgIHN5bnRoZXNp emVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAidGV4U3ViSW1hZ2Uy RCIsICJubyB2aWRlbyIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKHdvdWxk VGFpbnRPcmlnaW4odmlkZW8pKSB7CisgICAgICAgIGVjID0gU0VDVVJJVFlfRVJSOworICAgICAg ICByZXR1cm47CisgICAgfQorICAgIGlmICghdmFsaWRhdGVUZXhGdW5jRm9ybWF0QW5kVHlwZSgi dGV4U3ViSW1hZ2UyRCIsIGZvcm1hdCwgdHlwZSwgbGV2ZWwpKQorICAgICAgICByZXR1cm47Cisg ICAgaWYgKCF2YWxpZGF0ZVNldHRhYmxlVGV4Rm9ybWF0KCJ0ZXhTdWJJbWFnZTJEIiwgZm9ybWF0 KSkKKyAgICAgICAgcmV0dXJuOworCiAgICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9IHZpZGVvRnJh bWVUb0ltYWdlKHZpZGVvLCBJbWFnZUJ1ZmZlcjo6ZmFzdENvcHlJbWFnZU1vZGUoKSwgZWMpOwog ICAgIGlmICghaW1hZ2UpCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvY2FudmFzL1dlYkdMVGV4dHVyZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2Nh bnZhcy9XZWJHTFRleHR1cmUuY3BwCmluZGV4IDlhZDU4YjRiYzE2NDcwZWEwNGY2NDg5ODBiNzY5 NTEyNmEzYmQyYjYuLjYzNGQwNzQwMTgyYzVlNmY0NGZiNzcxOTA4MGY3NzBlZTNiMzc3MWMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMVGV4dHVyZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmNwcApAQCAtMjA3LDYg KzIwNywxNCBAQCBHQzNEc2l6ZWkgV2ViR0xUZXh0dXJlOjpnZXRIZWlnaHQoR0MzRGVudW0gdGFy Z2V0LCBHQzNEaW50IGxldmVsKSBjb25zdAogICAgIHJldHVybiBpbmZvLT5oZWlnaHQ7CiB9CiAK K2Jvb2wgV2ViR0xUZXh0dXJlOjppc1ZhbGlkKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZl bCkgY29uc3QKK3sKKyAgICBjb25zdCBMZXZlbEluZm8qIGluZm8gPSBnZXRMZXZlbEluZm8odGFy Z2V0LCBsZXZlbCk7CisgICAgaWYgKCFpbmZvKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZXR1 cm4gaW5mby0+dmFsaWQ7Cit9CisKIGJvb2wgV2ViR0xUZXh0dXJlOjppc05QT1QoR0MzRHNpemVp IHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KQogewogICAgIEFTU0VSVCh3aWR0aCA+PSAwICYmIGhl aWdodCA+PSAwKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdM VGV4dHVyZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmgKaW5k ZXggZDFkYjk1MWZmYzIwZDE5Nzg3MTk5NTAzNTA1MjEzMThkMWY2MGM3Ny4uYTRjMTUwN2NmMGZj NDExZDc0ZDQyNGI4YzUxZjMzYTQ5MTBiNThlMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv aHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52 YXMvV2ViR0xUZXh0dXJlLmgKQEAgLTU4LDYgKzU4LDcgQEAgcHVibGljOgogICAgIEdDM0RlbnVt IGdldFR5cGUoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsKICAgICBHQzNE c2l6ZWkgZ2V0V2lkdGgoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsKICAg ICBHQzNEc2l6ZWkgZ2V0SGVpZ2h0KEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCkgY29u c3Q7CisgICAgYm9vbCBpc1ZhbGlkKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCkgY29u c3Q7CiAKICAgICAvLyBXaGV0aGVyIHdpZHRoL2hlaWdodCBpcyBOb3RQb3dlck9mVHdvLgogICAg IHN0YXRpYyBib29sIGlzTlBPVChHQzNEc2l6ZWksIEdDM0RzaXplaSk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5jcHAKaW5kZXggNjliNGQ3YjNl N2Y3OGMxYzI1MTQ4YmMxY2ExYTg3N2U0ZGE4NDRmZi4uYTI4M2FiMzczYTk5OWY3YTE1YzA1YzQ0 M2MyOTMzZWJhMzZjMTU0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvTWVkaWFQbGF5ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL01lZGlhUGxheWVyLmNwcApAQCAtNzI3LDYgKzcyNywxMSBAQCB2b2lkIE1lZGlhUGxheWVy OjpwYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChHcmFwaGljc0NvbnRleHQqIHAsIGNvbnN0IElu dFJlY3QmCiAgICAgbV9wcml2YXRlLT5wYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChwLCByKTsK IH0KIAorYm9vbCBNZWRpYVBsYXllcjo6Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJl KEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LCBXZWJHTFRleHR1cmUqIHRleHR1cmUsIEdDM0Rp bnQgbGV2ZWwsIEdDM0RlbnVtIHR5cGUsIEdDM0RlbnVtIGludGVybmFsRm9ybWF0LCBib29sIHBy ZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpCit7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+Y29w eVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKGNvbnRleHQsIHRleHR1cmUsIGxldmVsLCB0 eXBlLCBpbnRlcm5hbEZvcm1hdCwgcHJlbXVsdGlwbHlBbHBoYSwgZmxpcFkpOworfQorCiBNZWRp YVBsYXllcjo6U3VwcG9ydHNUeXBlIE1lZGlhUGxheWVyOjpzdXBwb3J0c1R5cGUoY29uc3QgQ29u dGVudFR5cGUmIGNvbnRlbnRUeXBlLCBjb25zdCBTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgS1VS TCYgdXJsLCBjb25zdCBNZWRpYVBsYXllclN1cHBvcnRzVHlwZUNsaWVudCogY2xpZW50KQogewog ICAgIFN0cmluZyB0eXBlID0gY29udGVudFR5cGUudHlwZSgpLmxvd2VyKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaAppbmRleCA0YmE0ZjI3YjZm NjU3MjU3MGZhNjBiZWM2MzM1YzAyNDJmYTQyOTNjLi5jNWEwOTk2MmZmYTdlMDA2ZTEyYzQwYzhl ZjgzNzFhYjZmZWM3ZmJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9NZWRpYVBsYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L01lZGlhUGxheWVyLmgKQEAgLTI3LDcgKzI3LDcgQEAKICNkZWZpbmUgTWVkaWFQbGF5ZXJfaAog CiAjaWYgRU5BQkxFKFZJREVPKQotCisjaW5jbHVkZSAiR3JhcGhpY3NUeXBlczNELmgiCiAjaWYg RU5BQkxFKFBMVUdJTl9QUk9YWV9GT1JfVklERU8pCiAjaW5jbHVkZSAiTWVkaWFQbGF5ZXJQcm94 eS5oIgogI2VuZGlmCkBAIC02OSw2ICs2OSw3IEBAIGNsYXNzIE1lZGlhUGxheWVyUHJpdmF0ZUlu dGVyZmFjZTsKIGNsYXNzIE1lZGlhU291cmNlOwogI2VuZGlmCiBjbGFzcyBUZXh0VHJhY2tSZXBy ZXNlbnRhdGlvbjsKK2NsYXNzIFdlYkdMVGV4dHVyZTsKIAogLy8gU3RydWN0dXJlIHRoYXQgd2ls bCBob2xkIGV2ZXJ5IG5hdGl2ZQogLy8gdHlwZXMgc3VwcG9ydGVkIGJ5IHRoZSBjdXJyZW50IG1l ZGlhIHBsYXllci4KQEAgLTEwNSw2ICsxMDYsNyBAQCBjbGFzcyBDYWNoZWRSZXNvdXJjZUxvYWRl cjsKIGNsYXNzIENvbnRlbnRUeXBlOwogY2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgR3JhcGhpY3ND b250ZXh0OworY2xhc3MgR3JhcGhpY3NDb250ZXh0M0Q7CiBjbGFzcyBJbnRSZWN0OwogY2xhc3Mg SW50U2l6ZTsKIGNsYXNzIE1lZGlhUGxheWVyOwpAQCAtMzMzLDYgKzMzNSwyMCBAQCBwdWJsaWM6 CiAgICAgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0Jik7CiAgICAg dm9pZCBwYWludEN1cnJlbnRGcmFtZUluQ29udGV4dChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJ bnRSZWN0Jik7CiAKKyAgICAvLyBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoKSBp cyB1c2VkIHRvIGRvIHRoZSBHUFUtR1BVIHRleHR1cmVzIGNvcHkgd2l0aG91dCBhIHJlYWRiYWNr IHRvIHN5c3RlbSBtZW1vcnkuCisgICAgLy8gVGhlIGZpcnN0IGZpdmUgcGFyYW1ldGVycyBkZW5v dGUgdGhlIGNvcnJlc3BvbmRpbmcgR3JhcGhpY3NDb250ZXh0LCBkZXN0aW5hdGlvbiB0ZXh0dXJl LCByZXF1ZXN0ZWQgbGV2ZWwsIHJlcXVlc3RlZCB0eXBlIGFuZCB0aGUgcmVxdWlyZWQgaW50ZXJu YWxGb3JtYXQgZm9yIGRlc3RpbmF0aW9uIHRleHR1cmUuCisgICAgLy8gVGhlIGxhc3QgdHdvIHBh cmFtZXRlcnMgcHJlbXVsdGlwbHlBbHBoYSBhbmQgZmxpcFkgZGVub3RlIHdoZXRoZXIgYWRkdGlv bmFsIHByZW11bHRpcGx5QWxwaGEgYW5kIGZsaXAgb3BlcmF0aW9uIGFyZSByZXF1aXJlZCBkdXJp bmcgdGhlIGNvcHkuCisgICAgLy8gSXQgcmV0dXJucyB0cnVlIG9uIHN1Y2Nlc3MgYW5kIGZhbHNl IG9uIGZhaWx1cmUuCisKKyAgICAvLyBJbiB0aGUgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5LCB0aGUg c291cmNlIHRleHR1cmUoVmlkZW8gdGV4dHVyZSkgc2hvdWxkIGhhdmUgdmFsaWQgdGFyZ2V0LCBp bnRlcm5hbEZvcm1hdCBhbmQgc2l6ZSwgZXRjLgorICAgIC8vIFRoZSBkZXN0aW5hdGlvbiB0ZXh0 dXJlIG1heSBuZWVkIHRvIGJlIHJlc2l6ZWQgdG8gdG8gdGhlIGRpbWVuc2lvbnMgb2YgdGhlIHNv dXJjZSB0ZXh0dXJlIG9yIHdyYXBwZWQgdG8gdGhlIHJlcXVpcmVkIGludGVybmFsRm9ybWF0Lgor CisgICAgLy8gRWFjaCBwbGF0Zm9ybSBwb3J0IGNhbiBoYXZlIGl0cyBvd24gaW1wbGVtZW50YXRp b24gb24gdGhpcyBmdW5jdGlvbi4gVGhlIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gZm9yIGl0IGlz IGEgc2luZ2xlICJyZXR1cm4gZmFsc2UiIGluIE1lZGlhUGxheWVyUHJpdmF0ZS5oLgorICAgIC8v IEluIGNocm9taXVtLCB0aGUgaW1wbGVtZW50YXRpb24gaXMgYmFzZWQgb24gR0xfQ0hST01JVU1f Y29weV90ZXh0dXJlIGV4dGVuc2lvbiB3aGljaCBpcyBkb2N1bWVudGVkIGF0CisgICAgLy8gaHR0 cDovL3NyYy5jaHJvbWl1bS5vcmcvdmlld3ZjL2Nocm9tZS90cnVuay9zcmMvZ3B1L0dMRVMyL2V4 dGVuc2lvbnMvQ0hST01JVU0vQ0hST01JVU1fY29weV90ZXh0dXJlLnR4dCBhbmQgaW1wbGVtZW50 ZWQgYXQKKyAgICAvLyBodHRwOi8vc3JjLmNocm9taXVtLm9yZy92aWV3dmMvY2hyb21lL3RydW5r L3NyYy9ncHUvY29tbWFuZF9idWZmZXIvc2VydmljZS9nbGVzMl9jbWRfY29weV90ZXh0dXJlX2No cm9taXVtLmNjIHZpYSBzaGFkZXJzLgorICAgIGJvb2wgY29weVZpZGVvVGV4dHVyZVRvUGxhdGZv cm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiwgV2ViR0xUZXh0dXJlKiwgR0MzRGludCBsZXZl bCwgR0MzRGVudW0gdHlwZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlw bHlBbHBoYSwgYm9vbCBmbGlwWSk7CisKICAgICBlbnVtIE5ldHdvcmtTdGF0ZSB7IEVtcHR5LCBJ ZGxlLCBMb2FkaW5nLCBMb2FkZWQsIEZvcm1hdEVycm9yLCBOZXR3b3JrRXJyb3IsIERlY29kZUVy cm9yIH07CiAgICAgTmV0d29ya1N0YXRlIG5ldHdvcmtTdGF0ZSgpOwogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllclByaXZhdGUuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCmluZGV4 IDcxMGRhYTdiOTNhNjM1NTllNDI4NTEyNWU3NjA1ZTNmODlhNWU1NTguLjE2OTM4ZDE4M2E2MzU3 ODljMzM3ZjdmNjliZjVlMTVjNDA0M2E4MjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oCkBAIC0xMDcsNiArMTA3LDcg QEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBwYWludChHcmFwaGljc0NvbnRleHQqLCBjb25z dCBJbnRSZWN0JikgPSAwOwogCiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5D b250ZXh0KEdyYXBoaWNzQ29udGV4dCogYywgY29uc3QgSW50UmVjdCYgcikgeyBwYWludChjLCBy KTsgfQorICAgIHZpcnR1YWwgYm9vbCBjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUo R3JhcGhpY3NDb250ZXh0M0QqLCBXZWJHTFRleHR1cmUqLCBHQzNEaW50LCBHQzNEZW51bSwgR0Mz RGVudW0sIGJvb2wsIGJvb2wpIHsgcmV0dXJuIGZhbHNlOyB9CiAKICAgICB2aXJ0dWFsIHZvaWQg c2V0UHJlbG9hZChNZWRpYVBsYXllcjo6UHJlbG9hZCkgeyB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyLmggYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllci5oCmluZGV4IGY4OGI3MTQ5M2Q5ODU3Yzkw YzYwOWE0YTRkYjhhYmMzYWMzYzk5MDIuLjZjNDEwMTk5NTk2ZWMyNWM3NGE0MGEwOGI4ZDhjMjVj MWU3ZDg3MzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1l ZGlhUGxheWVyLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQ bGF5ZXIuaApAQCAtNDcsNiArNDcsNyBAQCBjbGFzcyBXZWJTdHJpbmc7CiBjbGFzcyBXZWJVUkw7 CiBzdHJ1Y3QgV2ViUmVjdDsKIHN0cnVjdCBXZWJTaXplOworY2xhc3MgV2ViR3JhcGhpY3NDb250 ZXh0M0Q7CiAKIGNsYXNzIFdlYk1lZGlhUGxheWVyIHsKIHB1YmxpYzoKQEAgLTE4MCw2ICsxODEs OSBAQCBwdWJsaWM6CiAgICAgLy8gbWV0aG9kIHNob3VsZCBubyBsb25nZXIgYmUgcmVmZXJlbmNl ZCBhZnRlciB0aGUgY2FsbCBpcyBtYWRlLgogICAgIHZpcnR1YWwgdm9pZCBwdXRDdXJyZW50RnJh bWUoV2ViVmlkZW9GcmFtZSopIHsgfQogCisgICAgLy8gRG8gYSBHUFUtR1BVIHRleHR1cmVzIGNv cHkgaWYgcG9zc2libGUuCisgICAgdmlydHVhbCBib29sIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRm b3JtVGV4dHVyZShXZWJHcmFwaGljc0NvbnRleHQzRCosIHVuc2lnbmVkIHRleHR1cmUsIHVuc2ln bmVkIGxldmVsLCB1bnNpZ25lZCBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhh LCBib29sIGZsaXBZKSB7IHJldHVybiBmYWxzZTsgfQorCiAgICAgdmlydHVhbCB2b2lkIHNldFN0 cmVhbVRleHR1cmVDbGllbnQoV2ViU3RyZWFtVGV4dHVyZUNsaWVudCopIHsgfQogCiAgICAgdmly dHVhbCBXZWJBdWRpb1NvdXJjZVByb3ZpZGVyKiBhdWRpb1NvdXJjZVByb3ZpZGVyKCkgeyByZXR1 cm4gMDsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQ bGF5ZXJDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlh UGxheWVyQ2xpZW50SW1wbC5jcHAKaW5kZXggZTIwZmRhMzA4NmY2MmZhM2ZmYjg5YjBiZDNlMzg5 MDFmYmVlMGYzMi4uYmE2YTI3ZmI1NTIwMGFmOTIxYTFhMGFjNmMxYjkwNDBjZGQ3MjYzNSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJ bXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNs aWVudEltcGwuY3BwCkBAIC0xMiw2ICsxMiw3IEBACiAjaW5jbHVkZSAiQXVkaW9Tb3VyY2VQcm92 aWRlckNsaWVudC5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NDb250 ZXh0LmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmgiCiAjaW5jbHVkZSAi R3JhcGhpY3NMYXllckNocm9taXVtLmgiCiAjaW5jbHVkZSAiSFRNTE1lZGlhRWxlbWVudC5oIgog I2luY2x1ZGUgIkludFNpemUuaCIKQEAgLTI2LDYgKzI3LDcgQEAKICNpbmNsdWRlICJXZWJEb2N1 bWVudC5oIgogI2luY2x1ZGUgIldlYkZyYW1lQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJ bXBsLmgiCisjaW5jbHVkZSAiV2ViR0xUZXh0dXJlLmgiCiAjaW5jbHVkZSAiV2ViSGVscGVyUGx1 Z2luSW1wbC5oIgogI2luY2x1ZGUgIldlYk1lZGlhUGxheWVyLmgiCiAjaW5jbHVkZSAiV2ViTWVk aWFTb3VyY2VDbGllbnQuaCIKQEAgLTc2NSw2ICs3NjcsMjYgQEAgdm9pZCBXZWJNZWRpYVBsYXll ckNsaWVudEltcGw6OnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4dCog Y29udGUKICAgICB9CiB9CiAKK2Jvb2wgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpjb3B5Vmlk ZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0QqIGNv bnRleHQsIFdlYkNvcmU6OldlYkdMVGV4dHVyZSogdGV4dHVyZSwgR0MzRGludCBsZXZlbCwgR0Mz RGVudW0gdHlwZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlBbHBo YSwgYm9vbCBmbGlwWSkKK3sKKyAgICBpZiAoIWNvbnRleHQgfHwgIW1fd2ViTWVkaWFQbGF5ZXIp CisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIC8vIEZJWE1FOiBUaGUgY3VycmVudCByZXN0 cmljdGlvbnMgcmVxdWlyZXMgdGhhdCBmb3JtYXQgc2hvdWQgYmUgUkdCIG9yIFJHQkEsCisgICAg Ly8gdHlwZSBzaG91bGQgYmUgVU5TSUdORURfQllURSBhbmQgbGV2ZWwgc2hvdWxkIGJlIDAuIEl0 IG1heSBiZSBsaWZ0ZWQgaW4gdGhlIGZ1dHVyZS4KKyAgICBpZiAoKGludGVybmFsRm9ybWF0ICE9 IFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpSR0IgJiYgaW50ZXJuYWxGb3JtYXQgIT0gV2Vi Q29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEpCisgICAgICAgIHx8IHR5cGUgIT0gV2ViQ29y ZTo6R3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUKKyAgICAgICAgfHwgKHRleHR1cmUt PmdldFR5cGUoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIGxldmVsKSAhPSBHcmFwaGlj c0NvbnRleHQzRDo6VU5TSUdORURfQllURSAmJiB0ZXh0dXJlLT5pc1ZhbGlkKEdyYXBoaWNzQ29u dGV4dDNEOjpURVhUVVJFXzJELCBsZXZlbCkpCisgICAgICAgIHx8IGxldmVsKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBFeHRlbnNpb25zM0QqIGV4dGVuc2lvbnMgPSBjb250ZXh0LT5n ZXRFeHRlbnNpb25zKCk7CisgICAgaWYgKCFleHRlbnNpb25zIHx8ICFleHRlbnNpb25zLT5zdXBw b3J0cygiR0xfQ0hST01JVU1fY29weV90ZXh0dXJlIikgfHwgIWV4dGVuc2lvbnMtPnN1cHBvcnRz KCJHTF9DSFJPTUlVTV9mbGlweSIpIHx8ICFjb250ZXh0LT5tYWtlQ29udGV4dEN1cnJlbnQoKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIFdlYkdyYXBoaWNzQ29udGV4dDNEKiB3ZWJHcmFw aGljc0NvbnRleHQzRCA9IEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0cmFjdFdlYkdyYXBo aWNzQ29udGV4dDNEKGNvbnRleHQpOworICAgIHJldHVybiBtX3dlYk1lZGlhUGxheWVyLT5jb3B5 VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUod2ViR3JhcGhpY3NDb250ZXh0M0QsIHRleHR1 cmUtPm9iamVjdCgpLCBsZXZlbCwgaW50ZXJuYWxGb3JtYXQsIHByZW11bHRpcGx5QWxwaGEsIGZs aXBZKTsKK30KKwogdm9pZCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OnNldFByZWxvYWQoTWVk aWFQbGF5ZXI6OlByZWxvYWQgcHJlbG9hZCkKIHsKICAgICBtX3ByZWxvYWQgPSBwcmVsb2FkOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGll bnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVu dEltcGwuaAppbmRleCA5OWQyZThiZGJlODQ1NDgwYjc1ZDEzYWZlZTljNTNlZGQ5NGUwZjc2Li5h YTg5MzQxZGRlNmNiODc3MjZlMjIwMzZmZjQ0NjNlNWYyZjQ2ZTE0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaApAQCAt NDIsNyArNDIsMTAgQEAKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Bh c3NPd25QdHIuaD4KIAotbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBBdWRpb1NvdXJjZVByb3Zp ZGVyQ2xpZW50OyB9CituYW1lc3BhY2UgV2ViQ29yZSB7CitjbGFzcyBBdWRpb1NvdXJjZVByb3Zp ZGVyQ2xpZW50OworY2xhc3MgV2ViR0xUZXh0dXJlOworfQogCiBuYW1lc3BhY2UgV2ViS2l0IHsK IApAQCAtMTMyLDYgKzEzNSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0U2l6ZShj b25zdCBXZWJDb3JlOjpJbnRTaXplJik7CiAgICAgdmlydHVhbCB2b2lkIHBhaW50KFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dCosIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKTsKICAgICB2aXJ0dWFs IHZvaWQgcGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0 KiwgY29uc3QgV2ViQ29yZTo6SW50UmVjdCYpOworICAgIHZpcnR1YWwgYm9vbCBjb3B5VmlkZW9U ZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0QqLCBXZWJD b3JlOjpXZWJHTFRleHR1cmUqLCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSB0eXBlLCBHQzNEZW51 bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsKICAg ICB2aXJ0dWFsIHZvaWQgc2V0UHJlbG9hZChXZWJDb3JlOjpNZWRpYVBsYXllcjo6UHJlbG9hZCk7 CiAgICAgdmlydHVhbCBib29sIGhhc1NpbmdsZVNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CiAgICAg dmlydHVhbCBib29sIGRpZFBhc3NDT1JTQWNjZXNzQ2hlY2soKSBjb25zdDsK 192745 2013-03-12 08:53:13 -0700 2013-03-12 18:49:51 -0700 Patch bug-111126-20130312234910.patch text/plain 18429 jun.a.jiang U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1NTM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjdiOWIxZDU4NDczNjY1 NGE0N2EzYWU5MjA3ODFiY2EzMjJlZGQyNy4uYWE1Y2M2Mzk3NGFlYjBkOGRhZDE1YmYxMmFlZjhk ZDY3Y2U1NjRiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEzLTAzLTEyICBKdW4g SmlhbmcgIDxqdW4uYS5qaWFuZ0BpbnRlbC5jb20+CisKKyAgICAgICAgRW5hYmxlIEdQVS1HUFUg dGV4dHVyZSBjb3B5IGluIHRleEltYWdlMkQoKSBmb3IgSFRNTFZpZGVvRWxlbWVudCBpZiBoYXJk d2FyZSBhY2NlbGVyYXRlZCB2aWRlbyBkZWNvZGUgaXMgaW4gdXNlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTExMjYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiB0ZXhJbWFnZTJEKCkgZm9yIEhUTUxW aWRlb0VsZW1lbnQgaW4gV2ViR0wsIGl0IGlzIHBvc3NpYmxlIHRvIGRvIGEgR1BVLUdQVSB0ZXh0 dXJlIGNvcHkgaW5zdGVhZCBvZiBDUFUgcmVhZGJhY2sKKyAgICAgICAgYW5kIHVwbG9hZCB3aGVu IHZpZGVvRnJhbWUgaXMgaW4gdGhlIGZvcm0gb2YgdGV4dHVyZXMuIEVhY2ggcGxhdGZvcm0gcG9y dCBuZWVkcyB0byBpbXBsZW1lbnQgdGhlIGludGVyZmFjZQorICAgICAgICBjb3B5VmlkZW9UZXh0 dXJlVG9QbGF0Zm9ybVRleHR1cmUoKSBkZWZpbmVkIGluIE1lZGlhUGxheWVyLmggdG8gbWFrZSBp dCB3b3JrLgorIAorICAgICAgICBBbHJlYWR5IGNvdmVyZWQgYnkgY3VycmVudCB0ZXN0cy4KKwor ICAgICAgICAqIGh0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpI VE1MVmlkZW9FbGVtZW50Ojpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgorICAg ICAgICAqIGh0bWwvSFRNTFZpZGVvRWxlbWVudC5oOgorICAgICAgICAoSFRNTFZpZGVvRWxlbWVu dCk6CisgICAgICAgICogaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6dmlkZW9GcmFtZVRvSW1hZ2Up OiBNb3ZlIHNvbWUgc2VjdXJpdHkgY2hlY2sgdG8gdXBwZXIgbGV2ZWwuCisgICAgICAgIChXZWJD b3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleEltYWdlMkQpOiBBZGQgdGhlIGZhc3QgR1BV LUdQVSB0ZXh0dXJlcyBjb3B5IHBhdGggZm9yIEhUTUxWaWRlb0VsZW1lbnQgYW5kIHNvbWUgc2Vj dXJpdHkgY2hlY2suCisgICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRl eFN1YkltYWdlMkQpOiBBZGQgc29tZSBzZWN1cml0eSBjaGVjay4KKyAgICAgICAgKiBodG1sL2Nh bnZhcy9XZWJHTFRleHR1cmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xUZXh0dXJlOjpp c1ZhbGlkKTogQWRkZWQgdG8gY2hlY2sgaWYgdGhlIHRleHR1cmUgaXMgZGVmaW5lZCBhdCB0aGUg Z2l2ZW4gbGV2ZWwuCisgICAgICAgICogaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmg6CisgICAg ICAgIChXZWJHTFRleHR1cmUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxh eWVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyOjpjb3B5VmlkZW9UZXh0dXJl VG9QbGF0Zm9ybVRleHR1cmUpOiBBZGRlZCB0byBkbyB0aGUgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5 LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmg6CisgICAgICAgIChN ZWRpYVBsYXllcik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXJQcml2 YXRlLmg6CisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVJbnRlcmZhY2U6OmNv cHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6CisKIDIwMTMtMDMtMTIgIFZzZXZvbG9k IFZsYXNvdiAgPHZzZXZpa0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3Rvcjog UmVzb3VyY2VTY3JpcHRGaWxlIGRpdmVyZ2VkIHN0YXRlIHNob3VsZCBiZSBjb3JyZWN0bHkgcmVz ZXQgYWZ0ZXIgZGVidWdnZXIgcmVzZXQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDJm ODJiNjhhMWY2NDdlYTQ0ZGE1OWQwNDcwMzExY2M3MDgzY2U2NDEuLjMyOTdjY2I3YzEzYTM5NDZj MmRkM2U0NGNlYzYzNWMzMTg0MmQ2YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTcgQEAKKzIwMTMtMDMtMTIgIEp1biBKaWFuZyAgPGp1bi5hLmppYW5nQGludGVsLmNv bT4KKworICAgICAgICBFbmFibGUgR1BVLUdQVSB0ZXh0dXJlIGNvcHkgaW4gdGV4SW1hZ2UyRCgp IGZvciBIVE1MVmlkZW9FbGVtZW50IGlmIGhhcmR3YXJlIGFjY2VsZXJhdGVkIHZpZGVvIGRlY29k ZSBpcyBpbiB1c2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTExMTEyNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogcHVibGljL1dlYk1lZGlhUGxheWVyLmg6CisgICAgICAgIChXZWJLaXQ6OldlYk1lZGlh UGxheWVyOjpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUpOgorICAgICAgICAqIHNy Yy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRp YVBsYXllckNsaWVudEltcGw6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSk6IGRv IGEgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5IGlmIHBvc3NpYmxlLgorICAgICAgICAqIHNyYy9XZWJN ZWRpYVBsYXllckNsaWVudEltcGwuaDoKKyAgICAgICAgKFdlYk1lZGlhUGxheWVyQ2xpZW50SW1w bCk6CisKIDIwMTMtMDMtMTEgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwu Y29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIxNDU0NjIuCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQuY3BwIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcAppbmRleCBjZmU5NTcxM2ZmOWRmOGQ3MzU3 NWI4MDJlZTU4MWYwOGRlNjc4NDFkLi5hMzc3YjU2OWVkNzgwZTRmNDk5M2Y1ZGM2NjE1Y2MyNTg0 MTBjOTAzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxWaWRlb0VsZW1lbnQu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5jcHAKQEAgLTIz Nyw2ICsyMzcsMTMgQEAgdm9pZCBIVE1MVmlkZW9FbGVtZW50OjpwYWludEN1cnJlbnRGcmFtZUlu Q29udGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnMKICAgICBwbGF5ZXItPnBhaW50 Q3VycmVudEZyYW1lSW5Db250ZXh0KGNvbnRleHQsIGRlc3RSZWN0KTsKIH0KIAorYm9vbCBIVE1M VmlkZW9FbGVtZW50Ojpjb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhpY3ND b250ZXh0M0QqIGNvbnRleHQsIFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwgR0MzRGludCBsZXZl bCwgR0MzRGVudW0gdHlwZSwgR0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlw bHlBbHBoYSwgYm9vbCBmbGlwWSkKK3sKKyAgICBpZiAoIXBsYXllcigpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgcmV0dXJuIHBsYXllcigpLT5jb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9y bVRleHR1cmUoY29udGV4dCwgdGV4dHVyZSwgbGV2ZWwsIHR5cGUsIGludGVybmFsRm9ybWF0LCBw cmVtdWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIGJvb2wgSFRNTFZpZGVvRWxlbWVudDo6aGFz QXZhaWxhYmxlVmlkZW9GcmFtZSgpIGNvbnN0CiB7CiAgICAgaWYgKCFwbGF5ZXIoKSkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFZpZGVvRWxlbWVudC5oIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKaW5kZXggY2Y0ZmVhY2ZjYjcxYjIyZTM2OTEz YThkOTc4NGNhZWY0MTg1NDlhYi4uMGMzZmQ2OGJjYmYzNDI0ZWFiYjM3NDNmNGNiNmE3MTlhY2Rk ODEyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVmlkZW9FbGVtZW50LmgKQEAgLTYzLDYgKzYz LDEwIEBAIHB1YmxpYzoKICAgICAvLyBVc2VkIGJ5IGNhbnZhcyB0byBnYWluIHJhdyBwaXhlbCBh Y2Nlc3MKICAgICB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0KEdyYXBoaWNzQ29udGV4 dCosIGNvbnN0IEludFJlY3QmKTsKIAorICAgIC8vIFVzZWQgYnkgV2ViR0wgdG8gZG8gR1BVLUdQ VSB0ZXh0dXJlcyBjb3B5IGlmIHBvc3NpYmxlLgorICAgIC8vIFNlZSBtb3JlIGRldGFpbHMgYXQg TWVkaWFQbGF5ZXI6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSgpIGRlZmluZWQg aW4gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaC4KKyAgICBi b29sIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCos IFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0gdHlwZSwg R0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlw WSk7CisKICAgICBib29sIHNob3VsZERpc3BsYXlQb3N0ZXJJbWFnZSgpIGNvbnN0IHsgcmV0dXJu IGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVyIHx8IGRpc3BsYXlNb2RlKCkgPT0gUG9zdGVyV2FpdGlu Z0ZvclZpZGVvOyB9CiAKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1s L2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9j YW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAppbmRleCA1MjUyODU2ZjA4ODcyNGU3ODc0 NmY1Y2E3MjEyY2Q4ZTliZDIxNDBmLi44MjBjZjEzMGE3ZWJkNzkwNmYxZDU4MzgyNjU3OWQzOGNh NDRiYWRjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRl cmluZ0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVu ZGVyaW5nQ29udGV4dC5jcHAKQEAgLTM4OTEsMjIgKzM4OTEsMTQgQEAgdm9pZCBXZWJHTFJlbmRl cmluZ0NvbnRleHQ6OnRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBH QzNEZW51bQogfQogCiAjaWYgRU5BQkxFKFZJREVPKQotUGFzc1JlZlB0cjxJbWFnZT4gV2ViR0xS ZW5kZXJpbmdDb250ZXh0Ojp2aWRlb0ZyYW1lVG9JbWFnZShIVE1MVmlkZW9FbGVtZW50KiB2aWRl bywgQmFja2luZ1N0b3JlQ29weSBiYWNraW5nU3RvcmVDb3B5LCBFeGNlcHRpb25Db2RlJiBlYykK K1Bhc3NSZWZQdHI8SW1hZ2U+IFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dmlkZW9GcmFtZVRvSW1h Z2UoSFRNTFZpZGVvRWxlbWVudCogdmlkZW8sIEJhY2tpbmdTdG9yZUNvcHkgYmFja2luZ1N0b3Jl Q29weSwgRXhjZXB0aW9uQ29kZSYpCiB7Ci0gICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVv V2lkdGgoKSB8fCAhdmlkZW8tPnZpZGVvSGVpZ2h0KCkpIHsKLSAgICAgICAgc3ludGhlc2l6ZUdM RXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJ0ZXhJbWFnZTJEIiwgIm5v IHZpZGVvIik7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KICAgICBJbnRTaXplIHNpemUodmlk ZW8tPnZpZGVvV2lkdGgoKSwgdmlkZW8tPnZpZGVvSGVpZ2h0KCkpOwogICAgIEltYWdlQnVmZmVy KiBidWYgPSBtX3ZpZGVvQ2FjaGUuaW1hZ2VCdWZmZXIoc2l6ZSk7CiAgICAgaWYgKCFidWYpIHsK ICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6Ok9VVF9PRl9NRU1P UlksICJ0ZXhJbWFnZTJEIiwgIm91dCBvZiBtZW1vcnkiKTsKICAgICAgICAgcmV0dXJuIDA7CiAg ICAgfQotICAgIGlmICh3b3VsZFRhaW50T3JpZ2luKHZpZGVvKSkgewotICAgICAgICBlYyA9IFNF Q1VSSVRZX0VSUjsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQogICAgIEludFJlY3QgZGVzdFJl Y3QoMCwgMCwgc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpKTsKICAgICAvLyBGSVhNRTogVHVy biB0aGlzIGludG8gYSBHUFUtR1BVIHRleHR1cmUgY29weSBpbnN0ZWFkIG9mIENQVSByZWFkYmFj ay4KICAgICB2aWRlby0+cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoYnVmLT5jb250ZXh0KCks IGRlc3RSZWN0KTsKQEAgLTM5MTksNiArMzkxMSwzNyBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6dGV4SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVt CiAgICAgZWMgPSAwOwogICAgIGlmIChpc0NvbnRleHRMb3N0KCkpCiAgICAgICAgIHJldHVybjsK KyAgICBpZiAoIXZpZGVvIHx8ICF2aWRlby0+dmlkZW9XaWR0aCgpIHx8ICF2aWRlby0+dmlkZW9I ZWlnaHQoKSkgeworICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6 SU5WQUxJRF9WQUxVRSwgInRleEltYWdlMkQiLCAibm8gdmlkZW8iKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKyAgICBpZiAod291bGRUYWludE9yaWdpbih2aWRlbykpIHsKKyAgICAgICAgZWMg PSBTRUNVUklUWV9FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKCF2YWxpZGF0 ZVRleEZ1bmNGb3JtYXRBbmRUeXBlKCJ0ZXhJbWFnZTJEIiwgZm9ybWF0LCB0eXBlLCBsZXZlbCkp CisgICAgICAgIHJldHVybjsKKyAgICBpZiAoIXZhbGlkYXRlU2V0dGFibGVUZXhGb3JtYXQoInRl eEltYWdlMkQiLCBmb3JtYXQpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBHbyB0aHJvdWdo IHRoZSBmYXN0IHBhdGggZG9pbmcgYSBHUFUtR1BVIHRleHR1cmVzIGNvcHkgd2l0aG91dCBhIHJl YWRiYWNrIHRvIHN5c3RlbSBtZW1vcnkgaWYgcG9zc2libGUuCisgICAgLy8gT3RoZXJ3aXNlLCBp dCB3aWxsIGZhbGwgYmFjayB0byB0aGUgbm9ybWFsIFNXIHBhdGguCisgICAgLy8gRklYTUU6IFRo ZSBjdXJyZW50IHJlc3RyaWN0aW9ucyByZXF1aXJlIHRoYXQgZm9ybWF0IHNob3VkIGJlIFJHQiBv ciBSR0JBLAorICAgIC8vIHR5cGUgc2hvdWxkIGJlIFVOU0lHTkVEX0JZVEUgYW5kIGxldmVsIHNo b3VsZCBiZSAwLiBJdCBtYXkgYmUgbGlmdGVkIGluIHRoZSBmdXR1cmUuCisgICAgV2ViR0xUZXh0 dXJlKiB0ZXh0dXJlID0gdmFsaWRhdGVUZXh0dXJlQmluZGluZygidGV4SW1hZ2UyRCIsIHRhcmdl dCwgdHJ1ZSk7CisgICAgaWYgKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJEID09IHRhcmdl dCAmJiB0ZXh0dXJlCisgICAgICAgICYmIChmb3JtYXQgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlJH QiB8fCBmb3JtYXQgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlJHQkEpCisgICAgICAgICYmIHR5cGUg PT0gR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUKKyAgICAgICAgJiYgKHRleHR1cmUt PmdldFR5cGUodGFyZ2V0LCBsZXZlbCkgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZ VEUgfHwgIXRleHR1cmUtPmlzVmFsaWQodGFyZ2V0LCBsZXZlbCkpCisgICAgICAgICYmICFsZXZl bCkgeworICAgICAgICBpZiAodmlkZW8tPmNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVy ZShtX2NvbnRleHQuZ2V0KCksIHRleHR1cmUtPm9iamVjdCgpLCBsZXZlbCwgdHlwZSwgaW50ZXJu YWxmb3JtYXQsIG1fdW5wYWNrUHJlbXVsdGlwbHlBbHBoYSwgbV91bnBhY2tGbGlwWSkpIHsKKyAg ICAgICAgICAgIHRleHR1cmUtPnNldExldmVsSW5mbyh0YXJnZXQsIGxldmVsLCBpbnRlcm5hbGZv cm1hdCwgdmlkZW8tPnZpZGVvV2lkdGgoKSwgdmlkZW8tPnZpZGVvSGVpZ2h0KCksIHR5cGUpOwor ICAgICAgICAgICAgY2xlYW51cEFmdGVyR3JhcGhpY3NDYWxsKGZhbHNlKTsKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKworICAgIC8vIE5vcm1hbCBwdXJlIFNXIHBhdGgu CiAgICAgUmVmUHRyPEltYWdlPiBpbWFnZSA9IHZpZGVvRnJhbWVUb0ltYWdlKHZpZGVvLCBJbWFn ZUJ1ZmZlcjo6ZmFzdENvcHlJbWFnZU1vZGUoKSwgZWMpOwogICAgIGlmICghaW1hZ2UpCiAgICAg ICAgIHJldHVybjsKQEAgLTQxNzAsNiArNDE5MywyMCBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6dGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0Rp bgogICAgIGVjID0gMDsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAgICByZXR1cm47 CisgICAgaWYgKCF2aWRlbyB8fCAhdmlkZW8tPnZpZGVvV2lkdGgoKSB8fCAhdmlkZW8tPnZpZGVv SGVpZ2h0KCkpIHsKKyAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6 OklOVkFMSURfVkFMVUUsICJ0ZXhTdWJJbWFnZTJEIiwgIm5vIHZpZGVvIik7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKKyAgICBpZiAod291bGRUYWludE9yaWdpbih2aWRlbykpIHsKKyAgICAg ICAgZWMgPSBTRUNVUklUWV9FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKCF2 YWxpZGF0ZVRleEZ1bmNGb3JtYXRBbmRUeXBlKCJ0ZXhTdWJJbWFnZTJEIiwgZm9ybWF0LCB0eXBl LCBsZXZlbCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAoIXZhbGlkYXRlU2V0dGFibGVUZXhG b3JtYXQoInRleFN1YkltYWdlMkQiLCBmb3JtYXQpKQorICAgICAgICByZXR1cm47CisKICAgICBS ZWZQdHI8SW1hZ2U+IGltYWdlID0gdmlkZW9GcmFtZVRvSW1hZ2UodmlkZW8sIEltYWdlQnVmZmVy OjpmYXN0Q29weUltYWdlTW9kZSgpLCBlYyk7CiAgICAgaWYgKCFpbWFnZSkKICAgICAgICAgcmV0 dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJl LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMVGV4dHVyZS5jcHAKaW5kZXgg OWFkNThiNGJjMTY0NzBlYTA0ZjY0ODk4MGI3Njk1MTI2YTNiZDJiNi4uNjM0ZDA3NDAxODJjNWU2 ZjQ0ZmI3NzE5MDgwZjc3MGVlM2IzNzcxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRt bC9jYW52YXMvV2ViR0xUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZh cy9XZWJHTFRleHR1cmUuY3BwCkBAIC0yMDcsNiArMjA3LDE0IEBAIEdDM0RzaXplaSBXZWJHTFRl eHR1cmU6OmdldEhlaWdodChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwpIGNvbnN0CiAg ICAgcmV0dXJuIGluZm8tPmhlaWdodDsKIH0KIAorYm9vbCBXZWJHTFRleHR1cmU6OmlzVmFsaWQo R0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdAoreworICAgIGNvbnN0IExldmVs SW5mbyogaW5mbyA9IGdldExldmVsSW5mbyh0YXJnZXQsIGxldmVsKTsKKyAgICBpZiAoIWluZm8p CisgICAgICAgIHJldHVybiAwOworICAgIHJldHVybiBpbmZvLT52YWxpZDsKK30KKwogYm9vbCBX ZWJHTFRleHR1cmU6OmlzTlBPVChHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQpCiB7 CiAgICAgQVNTRVJUKHdpZHRoID49IDAgJiYgaGVpZ2h0ID49IDApOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xUZXh0dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuaAppbmRleCBkMWRiOTUxZmZjMjBkMTk3ODcxOTk1MDM1 MDUyMTMxOGQxZjYwYzc3Li5hNGMxNTA3Y2YwZmM0MTFkNzRkNDI0YjhjNTFmMzNhNDkxMGI1OGUx IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFRleHR1cmUuaApAQCAtNTgsNiAr NTgsNyBAQCBwdWJsaWM6CiAgICAgR0MzRGVudW0gZ2V0VHlwZShHQzNEZW51bSB0YXJnZXQsIEdD M0RpbnQgbGV2ZWwpIGNvbnN0OwogICAgIEdDM0RzaXplaSBnZXRXaWR0aChHQzNEZW51bSB0YXJn ZXQsIEdDM0RpbnQgbGV2ZWwpIGNvbnN0OwogICAgIEdDM0RzaXplaSBnZXRIZWlnaHQoR0MzRGVu dW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsKKyAgICBib29sIGlzVmFsaWQoR0MzRGVu dW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsKSBjb25zdDsKIAogICAgIC8vIFdoZXRoZXIgd2lkdGgv aGVpZ2h0IGlzIE5vdFBvd2VyT2ZUd28uCiAgICAgc3RhdGljIGJvb2wgaXNOUE9UKEdDM0RzaXpl aSwgR0MzRHNpemVpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL01lZGlhUGxheWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01l ZGlhUGxheWVyLmNwcAppbmRleCA2OWI0ZDdiM2U3Zjc4YzFjMjUxNDhiYzFjYTFhODc3ZTRkYTg0 NGZmLi43Yzk0YjJiOTQ5NjA4Y2EzZDg5MmFmYzk2NGUwN2IxZjBjNThjYmY2IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuY3BwCkBAIC03Mjcs NiArNzI3LDExIEBAIHZvaWQgTWVkaWFQbGF5ZXI6OnBhaW50Q3VycmVudEZyYW1lSW5Db250ZXh0 KEdyYXBoaWNzQ29udGV4dCogcCwgY29uc3QgSW50UmVjdCYKICAgICBtX3ByaXZhdGUtPnBhaW50 Q3VycmVudEZyYW1lSW5Db250ZXh0KHAsIHIpOwogfQogCitib29sIE1lZGlhUGxheWVyOjpjb3B5 VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQs IFBsYXRmb3JtM0RPYmplY3QgdGV4dHVyZSwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0gdHlwZSwg R0MzRGVudW0gaW50ZXJuYWxGb3JtYXQsIGJvb2wgcHJlbXVsdGlwbHlBbHBoYSwgYm9vbCBmbGlw WSkKK3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5jb3B5VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRl eHR1cmUoY29udGV4dCwgdGV4dHVyZSwgbGV2ZWwsIHR5cGUsIGludGVybmFsRm9ybWF0LCBwcmVt dWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIE1lZGlhUGxheWVyOjpTdXBwb3J0c1R5cGUgTWVk aWFQbGF5ZXI6OnN1cHBvcnRzVHlwZShjb25zdCBDb250ZW50VHlwZSYgY29udGVudFR5cGUsIGNv bnN0IFN0cmluZyYga2V5U3lzdGVtLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IE1lZGlhUGxheWVy U3VwcG9ydHNUeXBlQ2xpZW50KiBjbGllbnQpCiB7CiAgICAgU3RyaW5nIHR5cGUgPSBjb250ZW50 VHlwZS50eXBlKCkubG93ZXIoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL01lZGlhUGxheWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9NZWRpYVBsYXllci5oCmluZGV4IDRiYTRmMjdiNmY2NTcyNTcwZmE2MGJlYzYzMzVjMDI0MmZh NDI5M2MuLjk5NGM4Y2RjNTkyN2YzNWQ2MjM5OTkxMjdkZjljODVlMjZiMzM5ZDAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaApAQCAtMjcsNyAr MjcsNyBAQAogI2RlZmluZSBNZWRpYVBsYXllcl9oCiAKICNpZiBFTkFCTEUoVklERU8pCi0KKyNp bmNsdWRlICJHcmFwaGljc1R5cGVzM0QuaCIKICNpZiBFTkFCTEUoUExVR0lOX1BST1hZX0ZPUl9W SURFTykKICNpbmNsdWRlICJNZWRpYVBsYXllclByb3h5LmgiCiAjZW5kaWYKQEAgLTEwNSw2ICsx MDUsNyBAQCBjbGFzcyBDYWNoZWRSZXNvdXJjZUxvYWRlcjsKIGNsYXNzIENvbnRlbnRUeXBlOwog Y2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgR3JhcGhpY3NDb250ZXh0OworY2xhc3MgR3JhcGhpY3ND b250ZXh0M0Q7CiBjbGFzcyBJbnRSZWN0OwogY2xhc3MgSW50U2l6ZTsKIGNsYXNzIE1lZGlhUGxh eWVyOwpAQCAtMzMzLDYgKzMzNCwyMSBAQCBwdWJsaWM6CiAgICAgdm9pZCBwYWludChHcmFwaGlj c0NvbnRleHQqLCBjb25zdCBJbnRSZWN0Jik7CiAgICAgdm9pZCBwYWludEN1cnJlbnRGcmFtZUlu Q29udGV4dChHcmFwaGljc0NvbnRleHQqLCBjb25zdCBJbnRSZWN0Jik7CiAKKyAgICAvLyBjb3B5 VmlkZW9UZXh0dXJlVG9QbGF0Zm9ybVRleHR1cmUoKSBpcyB1c2VkIHRvIGRvIHRoZSBHUFUtR1BV IHRleHR1cmVzIGNvcHkgd2l0aG91dCBhIHJlYWRiYWNrIHRvIHN5c3RlbSBtZW1vcnkuCisgICAg Ly8gVGhlIGZpcnN0IGZpdmUgcGFyYW1ldGVycyBkZW5vdGUgdGhlIGNvcnJlc3BvbmRpbmcgR3Jh cGhpY3NDb250ZXh0LCBkZXN0aW5hdGlvbiB0ZXh0dXJlLCByZXF1ZXN0ZWQgbGV2ZWwsIHJlcXVl c3RlZCB0eXBlIGFuZCB0aGUgcmVxdWlyZWQgaW50ZXJuYWxGb3JtYXQgZm9yIGRlc3RpbmF0aW9u IHRleHR1cmUuCisgICAgLy8gVGhlIGxhc3QgdHdvIHBhcmFtZXRlcnMgcHJlbXVsdGlwbHlBbHBo YSBhbmQgZmxpcFkgZGVub3RlIHdoZXRoZXIgYWRkdGlvbmFsIHByZW11bHRpcGx5QWxwaGEgYW5k IGZsaXAgb3BlcmF0aW9uIGFyZSByZXF1aXJlZCBkdXJpbmcgdGhlIGNvcHkuCisgICAgLy8gSXQg cmV0dXJucyB0cnVlIG9uIHN1Y2Nlc3MgYW5kIGZhbHNlIG9uIGZhaWx1cmUuCisKKyAgICAvLyBJ biB0aGUgR1BVLUdQVSB0ZXh0dXJlcyBjb3B5LCB0aGUgc291cmNlIHRleHR1cmUoVmlkZW8gdGV4 dHVyZSkgc2hvdWxkIGhhdmUgdmFsaWQgdGFyZ2V0LCBpbnRlcm5hbEZvcm1hdCBhbmQgc2l6ZSwg ZXRjLgorICAgIC8vIFRoZSBkZXN0aW5hdGlvbiB0ZXh0dXJlIG1heSBuZWVkIHRvIGJlIHJlc2l6 ZWQgdG8gdG8gdGhlIGRpbWVuc2lvbnMgb2YgdGhlIHNvdXJjZSB0ZXh0dXJlIG9yIHJlLWRlZmlu ZWQgdG8gdGhlIHJlcXVpcmVkIGludGVybmFsRm9ybWF0LgorICAgIC8vIFRoZSBjdXJyZW50IHJl c3RyaWN0aW9ucyByZXF1aXJlIHRoYXQgZm9ybWF0IHNob3VkIGJlIFJHQiBvciBSR0JBLCB0eXBl IHNob3VsZCBiZSBVTlNJR05FRF9CWVRFIGFuZCBsZXZlbCBzaG91bGQgYmUgMC4gSXQgbWF5IGJl IGxpZnRlZCBpbiB0aGUgZnV0dXJlLgorCisgICAgLy8gRWFjaCBwbGF0Zm9ybSBwb3J0IGNhbiBo YXZlIGl0cyBvd24gaW1wbGVtZW50YXRpb24gb24gdGhpcyBmdW5jdGlvbi4gVGhlIGRlZmF1bHQg aW1wbGVtZW50YXRpb24gZm9yIGl0IGlzIGEgc2luZ2xlICJyZXR1cm4gZmFsc2UiIGluIE1lZGlh UGxheWVyUHJpdmF0ZS5oLgorICAgIC8vIEluIGNocm9taXVtLCB0aGUgaW1wbGVtZW50YXRpb24g aXMgYmFzZWQgb24gR0xfQ0hST01JVU1fY29weV90ZXh0dXJlIGV4dGVuc2lvbiB3aGljaCBpcyBk b2N1bWVudGVkIGF0CisgICAgLy8gaHR0cDovL3NyYy5jaHJvbWl1bS5vcmcvdmlld3ZjL2Nocm9t ZS90cnVuay9zcmMvZ3B1L0dMRVMyL2V4dGVuc2lvbnMvQ0hST01JVU0vQ0hST01JVU1fY29weV90 ZXh0dXJlLnR4dCBhbmQgaW1wbGVtZW50ZWQgYXQKKyAgICAvLyBodHRwOi8vc3JjLmNocm9taXVt Lm9yZy92aWV3dmMvY2hyb21lL3RydW5rL3NyYy9ncHUvY29tbWFuZF9idWZmZXIvc2VydmljZS9n bGVzMl9jbWRfY29weV90ZXh0dXJlX2Nocm9taXVtLmNjIHZpYSBzaGFkZXJzLgorICAgIGJvb2wg Y29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEKiwgUGxh dGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSB0eXBlLCBHQzNE ZW51bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsK KwogICAgIGVudW0gTmV0d29ya1N0YXRlIHsgRW1wdHksIElkbGUsIExvYWRpbmcsIExvYWRlZCwg Rm9ybWF0RXJyb3IsIE5ldHdvcmtFcnJvciwgRGVjb2RlRXJyb3IgfTsKICAgICBOZXR3b3JrU3Rh dGUgbmV0d29ya1N0YXRlKCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL01lZGlhUGxheWVyUHJpdmF0ZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvTWVkaWFQbGF5ZXJQcml2YXRlLmgKaW5kZXggNzEwZGFhN2I5M2E2MzU1OWU0Mjg1 MTI1ZTc2MDVlM2Y4OWE1ZTU1OC4uODU3YjQ5NTUyZTg5Nzg5YWJkMWQ3ZDg5YjlmZmNiMzM0OWYx N2M0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQ bGF5ZXJQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVk aWFQbGF5ZXJQcml2YXRlLmgKQEAgLTEwNyw2ICsxMDcsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCB2b2lkIHBhaW50KEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IEludFJlY3QmKSA9IDA7CiAKICAg ICB2aXJ0dWFsIHZvaWQgcGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0 KiBjLCBjb25zdCBJbnRSZWN0JiByKSB7IHBhaW50KGMsIHIpOyB9CisgICAgdmlydHVhbCBib29s IGNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRCosIFBs YXRmb3JtM0RPYmplY3QsIEdDM0RpbnQsIEdDM0RlbnVtLCBHQzNEZW51bSwgYm9vbCwgYm9vbCkg eyByZXR1cm4gZmFsc2U7IH0KIAogICAgIHZpcnR1YWwgdm9pZCBzZXRQcmVsb2FkKE1lZGlhUGxh eWVyOjpQcmVsb2FkKSB7IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViTWVkaWFQbGF5ZXIuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl Yk1lZGlhUGxheWVyLmgKaW5kZXggZjg4YjcxNDkzZDk4NTdjOTBjNjA5YTRhNGRiOGFiYzNhYzNj OTkwMi4uNmM0MTAxOTk1OTZlYzI1Yzc0YTQwYTA4YjhkOGMyNWMxZTdkODczNCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXIuaAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllci5oCkBAIC00Nyw2ICs0 Nyw3IEBAIGNsYXNzIFdlYlN0cmluZzsKIGNsYXNzIFdlYlVSTDsKIHN0cnVjdCBXZWJSZWN0Owog c3RydWN0IFdlYlNpemU7CitjbGFzcyBXZWJHcmFwaGljc0NvbnRleHQzRDsKIAogY2xhc3MgV2Vi TWVkaWFQbGF5ZXIgewogcHVibGljOgpAQCAtMTgwLDYgKzE4MSw5IEBAIHB1YmxpYzoKICAgICAv LyBtZXRob2Qgc2hvdWxkIG5vIGxvbmdlciBiZSByZWZlcmVuY2VkIGFmdGVyIHRoZSBjYWxsIGlz IG1hZGUuCiAgICAgdmlydHVhbCB2b2lkIHB1dEN1cnJlbnRGcmFtZShXZWJWaWRlb0ZyYW1lKikg eyB9CiAKKyAgICAvLyBEbyBhIEdQVS1HUFUgdGV4dHVyZXMgY29weSBpZiBwb3NzaWJsZS4KKyAg ICB2aXJ0dWFsIGJvb2wgY29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKFdlYkdyYXBo aWNzQ29udGV4dDNEKiwgdW5zaWduZWQgdGV4dHVyZSwgdW5zaWduZWQgbGV2ZWwsIHVuc2lnbmVk IGludGVybmFsRm9ybWF0LCBib29sIHByZW11bHRpcGx5QWxwaGEsIGJvb2wgZmxpcFkpIHsgcmV0 dXJuIGZhbHNlOyB9CisKICAgICB2aXJ0dWFsIHZvaWQgc2V0U3RyZWFtVGV4dHVyZUNsaWVudChX ZWJTdHJlYW1UZXh0dXJlQ2xpZW50KikgeyB9CiAKICAgICB2aXJ0dWFsIFdlYkF1ZGlvU291cmNl UHJvdmlkZXIqIGF1ZGlvU291cmNlUHJvdmlkZXIoKSB7IHJldHVybiAwOyB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3Bw IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNw cAppbmRleCBlMjBmZGEzMDg2ZjYyZmEzZmZiODliMGJkM2UzODkwMWZiZWUwZjMyLi43NWNiMGYy YzZiNDc2NjA0YTNjMjBhNmQ5YWMwOWFkMzcxNGY1YzUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKQEAgLTEy LDYgKzEyLDcgQEAKICNpbmNsdWRlICJBdWRpb1NvdXJjZVByb3ZpZGVyQ2xpZW50LmgiCiAjaW5j bHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJH cmFwaGljc0NvbnRleHQzRFByaXZhdGUuaCIKICNpbmNsdWRlICJHcmFwaGljc0xheWVyQ2hyb21p dW0uaCIKICNpbmNsdWRlICJIVE1MTWVkaWFFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW50U2l6ZS5o IgpAQCAtNzY1LDYgKzc2NiwxNyBAQCB2b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6cGFp bnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250ZXh0KiBjb250ZQogICAgIH0KIH0K IAorYm9vbCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNvcHlWaWRlb1RleHR1cmVUb1BsYXRm b3JtVGV4dHVyZShXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgUGxhdGZvcm0z RE9iamVjdCB0ZXh0dXJlLCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSB0eXBlLCBHQzNEZW51bSBp bnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVtdWx0aXBseUFscGhhLCBib29sIGZsaXBZKQoreworICAg IGlmICghY29udGV4dCB8fCAhbV93ZWJNZWRpYVBsYXllcikKKyAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIEV4dGVuc2lvbnMzRCogZXh0ZW5zaW9ucyA9IGNvbnRleHQtPmdldEV4dGVuc2lvbnMo KTsKKyAgICBpZiAoIWV4dGVuc2lvbnMgfHwgIWV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9DSFJP TUlVTV9jb3B5X3RleHR1cmUiKSB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0NIUk9NSVVN X2ZsaXB5IikgfHwgIWNvbnRleHQtPm1ha2VDb250ZXh0Q3VycmVudCgpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgV2ViR3JhcGhpY3NDb250ZXh0M0QqIHdlYkdyYXBoaWNzQ29udGV4dDNE ID0gR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0Qo Y29udGV4dCk7CisgICAgcmV0dXJuIG1fd2ViTWVkaWFQbGF5ZXItPmNvcHlWaWRlb1RleHR1cmVU b1BsYXRmb3JtVGV4dHVyZSh3ZWJHcmFwaGljc0NvbnRleHQzRCwgdGV4dHVyZSwgbGV2ZWwsIGlu dGVybmFsRm9ybWF0LCBwcmVtdWx0aXBseUFscGhhLCBmbGlwWSk7Cit9CisKIHZvaWQgV2ViTWVk aWFQbGF5ZXJDbGllbnRJbXBsOjpzZXRQcmVsb2FkKE1lZGlhUGxheWVyOjpQcmVsb2FkIHByZWxv YWQpCiB7CiAgICAgbV9wcmVsb2FkID0gcHJlbG9hZDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKaW5kZXggOTlkMmU4YmRi ZTg0NTQ4MGI3NWQxM2FmZWU5YzUzZWRkOTRlMGY3Ni4uNTc4ZjhlNDFkOTIxNjQ2OTAxYjQ4ZDU2 OWM5ZjZjZDA1ZDhjNjE3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKQEAgLTEzMiw2ICsxMzIsNyBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIHNldFNpemUoY29uc3QgV2ViQ29yZTo6SW50U2l6ZSYpOwogICAg IHZpcnR1YWwgdm9pZCBwYWludChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQqLCBjb25zdCBXZWJD b3JlOjpJbnRSZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q3VycmVudEZyYW1lSW5Db250 ZXh0KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dCosIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKTsK KyAgICB2aXJ0dWFsIGJvb2wgY29weVZpZGVvVGV4dHVyZVRvUGxhdGZvcm1UZXh0dXJlKFdlYkNv cmU6OkdyYXBoaWNzQ29udGV4dDNEKiwgUGxhdGZvcm0zRE9iamVjdCB0ZXh0dXJlLCBHQzNEaW50 IGxldmVsLCBHQzNEZW51bSB0eXBlLCBHQzNEZW51bSBpbnRlcm5hbEZvcm1hdCwgYm9vbCBwcmVt dWx0aXBseUFscGhhLCBib29sIGZsaXBZKTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0UHJlbG9hZChX ZWJDb3JlOjpNZWRpYVBsYXllcjo6UHJlbG9hZCk7CiAgICAgdmlydHVhbCBib29sIGhhc1Npbmds ZVNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIGRpZFBhc3NDT1JTQWNj ZXNzQ2hlY2soKSBjb25zdDsK