97813 2012-09-27 13:16:26 -0700 Expose some GPU Information 2013-04-03 18:02:42 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 dino dino bajones cc-bugs gman hausmann igor.oliveira jamesr kbr laszlo.gombos noam ostap73 roger_fong thorton tonikitoo webkit-bug-importer webkit.review.bot zmo oldest_to_newest 729797 0 dino 2012-09-27 13:16:26 -0700 We have a few places where we're doing GPU vendor detection to work around bugs or enable features. I want to have a central place to store this information. Chromium has something like this in its feature_info/FeatureInfo class. I'd appreciate any advice on how to design this. I was going to add another class, say GPUInfo, that would hang off GraphicsContext3D. But we already have Extensions3D, so it seems weird to have two classes doing feature detection. I suggest renaming Extensions3D (and it's subclasses) to Features3D (or something) and adding new generic methods at the top, for things like isNVidia(), and maybe needsBuiltInFunctionTranslation(). The existing extension-related methods might need some renaming. e.g. supports() could potentially become supportsExtension() - although I don't think that's necessary. 729798 1 webkit-bug-importer 2012-09-27 13:16:55 -0700 <rdar://problem/12388705> 729806 2 kbr 2012-09-27 13:22:24 -0700 zmo necessarily added GPUInfo concepts to Chromium's implementation in order to implement the GPU blacklist. He might have some suggestions. One argument for adding a new GPUInfo class, and leaving Extensions3D alone, is that Extensions3D and subclasses necessarily have port-specific code. If the GPUInfo will just be a simple container for information that can be queried via the OpenGL API (or even the GraphicsContext3D API), then it may make sense to add it as a new concept in the port-independent code. 729818 3 dino 2012-09-27 13:32:24 -0700 (In reply to comment #2) > zmo necessarily added GPUInfo concepts to Chromium's implementation in order to implement the GPU blacklist. He might have some suggestions. > > One argument for adding a new GPUInfo class, and leaving Extensions3D alone, is that Extensions3D and subclasses necessarily have port-specific code. If the GPUInfo will just be a simple container for information that can be queried via the OpenGL API (or even the GraphicsContext3D API), then it may make sense to add it as a new concept in the port-independent code. That's what I originally thought, except when I started to fill out the implementation of GPUInfo I noticed I was writing port-specific code :) For example, I wanted a helper to detect if ANGLE should translate built-in functions. On OS X that depends on the card and the version of the OS :( 729882 4 kbr 2012-09-27 14:53:27 -0700 (In reply to comment #3) > > That's what I originally thought, except when I started to fill out the implementation of GPUInfo I noticed I was writing port-specific code :) > > For example, I wanted a helper to detect if ANGLE should translate built-in functions. On OS X that depends on the card and the version of the OS :( Darn. If we just need a couple of additional query methods then maybe the least painful course of action would be to add them to Extensions3D. Renaming that class to something like OptionalFeatures3D doesn't seem to me to add much semantic value, especially given that the class would still be holding all of the extensions' entry points. 729909 5 zmo 2012-09-27 15:16:18 -0700 I am fine with adding these functions to Extension3D or GraphicsContext3D. Functions like isNVidia() seems fit GraphicsContext3D better. I suspect we will end up writing port specific code anyway when we ask questions like needsBuiltInFunctionTranslation(). For chromium, the answer is passed down from browser instead of being decided at webkit level. 729953 6 dino 2012-09-27 15:54:34 -0700 Thanks. I'll take that approach then - adding to GC3D or renaming Extensions3D. 730081 7 166109 dino 2012-09-27 18:11:51 -0700 Created attachment 166109 Patch 730256 8 166109 hausmann 2012-09-27 22:54:17 -0700 Comment on attachment 166109 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=166109&action=review > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:71 > +#if PLATFORM(MAC) I think it would be nice if here (as well as in the other places in this patch) it would be #if OS(DARWIN) && !PLATFORM(CHROMIUM) because while Chromium may defer this due to its libGL wrapper I believe the other ports are all running on top of the platform libGL directly and would benefit from this kind of feature detection. Hm, oh wait, I don't think this file is event used in the Chromium build (in favour of Extensions3DChromium), so it might be even simpler and just OS(DARWIN) :) 730868 9 dino 2012-09-28 12:11:47 -0700 (In reply to comment #8) > (From update of attachment 166109 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=166109&action=review > > > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:71 > > +#if PLATFORM(MAC) > > I think it would be nice if here (as well as in the other places in this patch) it would be > > #if OS(DARWIN) && !PLATFORM(CHROMIUM) > > because while Chromium may defer this due to its libGL wrapper I believe the other ports are all running on top of the platform libGL directly and would benefit from this kind of feature detection. > > Hm, oh wait, I don't think this file is event used in the Chromium build (in favour of Extensions3DChromium), so it might be even simpler and just OS(DARWIN) :) I tend to be conservative in enabling/disabling features in other ports. For Chromium, you're right that it detects using another method, which is why the maySupportMultisampling returns true by default. I'd be slightly happier for other ports themselves to make the change you recommended. Obviously I suggest they follow our lead but, for example, they may decide that it is worth the risk to enable multisampling on all AMD cards on all OS builds. 731010 10 dino 2012-09-28 14:56:41 -0700 Anyone listening want to review this? It's no change in functionality, and I'm very open to suggestions on alternate APIs. 733085 11 166109 kbr 2012-10-02 14:36:32 -0700 Comment on attachment 166109 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=166109&action=review Sorry for the delay looking at this. Looks fine overall; a few comments. > Source/WebCore/platform/graphics/Extensions3D.h:198 > + virtual bool maySupportMultisampling() = 0; How about a little documentation for this method? i.e., "If this method returns false then the system definitely does not support multisampling. Otherwise, callers must attempt to construct multisampled renderbuffers and check framebuffer completeness." > Source/WebCore/platform/graphics/Extensions3D.h:199 > + virtual bool requiresBuiltInFunctionEmultation() = 0; Typo: Emultation -> Emulation. Here and throughout. > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:65 > + m_isNVidia = true; Are you sure the capitalization is correct? GL_VENDOR is "NVIDIA Corporation" on my laptop. > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:66 > + if (m_vendor.contains("ATI") || m_vendor.contains("AMD")) You'll need to be very careful if you address the above issue by lowercasing the GL_VENDOR string: watch out for "NVIDIA CorporATIon". Chromium now tokenizes the lowercased GL_VENDOR string and checks for strict equality with these vendors' names. 733132 12 dino 2012-10-02 15:13:17 -0700 (In reply to comment #11) > > Source/WebCore/platform/graphics/Extensions3D.h:198 > > + virtual bool maySupportMultisampling() = 0; > > How about a little documentation for this method? i.e., "If this method returns false then the system definitely does not support multisampling. Otherwise, callers must attempt to construct multisampled renderbuffers and check framebuffer completeness." Good suggestion. > > Source/WebCore/platform/graphics/Extensions3D.h:199 > > + virtual bool requiresBuiltInFunctionEmultation() = 0; > > Typo: Emultation -> Emulation. Here and throughout. Yikes! > > > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:65 > > + m_isNVidia = true; > > Are you sure the capitalization is correct? GL_VENDOR is "NVIDIA Corporation" on my laptop. You're correct. Shame on me for not testing on NV. > > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:66 > > + if (m_vendor.contains("ATI") || m_vendor.contains("AMD")) > > You'll need to be very careful if you address the above issue by lowercasing the GL_VENDOR string: watch out for "NVIDIA CorporATIon". Chromium now tokenizes the lowercased GL_VENDOR string and checks for strict equality with these vendors' names. Also a great point. Tim reminded me that Linux also returns the full name (e.g. "Advanced Micro Devices"). I'm not sure what I can do about this without Linux to test on. 733212 13 166776 dino 2012-10-02 16:40:27 -0700 Created attachment 166776 Patch 733222 14 166776 kbr 2012-10-02 16:50:37 -0700 Comment on attachment 166776 Patch Looks good to me. 733224 15 thorton 2012-10-02 16:52:02 -0700 View in context: https://bugs.webkit.org/attachment.cgi?id=166776&action=review > Source/WebCore/platform/graphics/Extensions3D.h:192 > + // Some helper methods to detect GPU functionality Comments end with periods, and I'm not sure this one is actually useful (and also, I wouldn't consider vendors "functionality", though the stuff below them is). > Source/WebCore/platform/graphics/Extensions3D.h:193 > + virtual bool isNVidia() = 0; NVIDIA spells their name with all caps. > Source/WebCore/platform/graphics/Extensions3D.h:200 > + // multisampled renderbuffers and check framebuffer completeness. Completeness? > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:71 > + if (vendorComponents.contains("nvidia")) > + m_isNVidia = true; > + if (vendorComponents.contains("ati") || vendorComponents.contains("amd")) > + m_isAMD = true; > + if (vendorComponents.contains("intel")) > + m_isIntel = true; This still won't work for some platforms, but, as you say, we can let them work it out, since we don't have their vendor names. > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h:60 > + // Some helper methods to detect GPU functionality Comments end with periods. Also not sure this one is really needed. > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h:83 > + bool m_isNVidia; Allll the capitalization. 733232 16 dino 2012-10-02 17:02:44 -0700 Committed r130235: <http://trac.webkit.org/changeset/130235> 733240 17 166776 ostap73 2012-10-02 17:11:24 -0700 Comment on attachment 166776 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=166776&action=review > Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp:71 > + if (vendorComponents.contains("nvidia")) > + m_isNVidia = true; > + if (vendorComponents.contains("ati") || vendorComponents.contains("amd")) > + m_isAMD = true; > + if (vendorComponents.contains("intel")) > + m_isIntel = true; Is it possible to have several vendors at the same time? Can both m_isAMD and m_isIntel (or m_isNVIDIA and m_isAMD) be true? If not, may be create single enum instead of 3 flags? Also, if multimple vendors are not possible then let's do "else if" chain placing AMD/ATI at the end in order to minimize detection errors. 733245 18 dino 2012-10-02 17:15:55 -0700 (In reply to comment #17) > > Is it possible to have several vendors at the same time? Can both m_isAMD and m_isIntel (or m_isNVIDIA and m_isAMD) be true? > If not, may be create single enum instead of 3 flags? > > Also, if multimple vendors are not possible then let's do "else if" chain placing AMD/ATI at the end in order to minimize detection errors. I did it this way in preparation for code that may well have multiple GPUs. Of course, that probably won't be exposed on this object and, as you say, not with two vendors on teh 733332 19 ostap73 2012-10-02 20:37:07 -0700 (In reply to comment #18) > (In reply to comment #17) > > > > Is it possible to have several vendors at the same time? Can both m_isAMD and m_isIntel (or m_isNVIDIA and m_isAMD) be true? > > If not, may be create single enum instead of 3 flags? > > > > Also, if multimple vendors are not possible then let's do "else if" chain placing AMD/ATI at the end in order to minimize detection errors. > > I did it this way in preparation for code that may well have multiple GPUs. Of course, that probably won't be exposed on this object and, as you say, not with two vendors on teh Is it possible to get context that talks to multiple devices? 733954 20 kbr 2012-10-03 12:55:25 -0700 (In reply to comment #19) > (In reply to comment #18) > > (In reply to comment #17) > > > > > > Is it possible to have several vendors at the same time? Can both m_isAMD and m_isIntel (or m_isNVIDIA and m_isAMD) be true? > > > If not, may be create single enum instead of 3 flags? > > > > > > Also, if multimple vendors are not possible then let's do "else if" chain placing AMD/ATI at the end in order to minimize detection errors. > > > > I did it this way in preparation for code that may well have multiple GPUs. Of course, that probably won't be exposed on this object and, as you say, not with two vendors on teh > > Is it possible to get context that talks to multiple devices? Not today with the way that dual-GPU support is implemented on any operating system. 734155 21 dino 2012-10-03 16:24:42 -0700 (In reply to comment #20) > (In reply to comment #19) > > > I did it this way in preparation for code that may well have multiple GPUs. Of course, that probably won't be exposed on this object and, as you say, not with two vendors on teh > > > > Is it possible to get context that talks to multiple devices? > > Not today with the way that dual-GPU support is implemented on any operating system. Yeah, sorry. It seems the last bit of my comment got cut off, but that is what I was saying. You've made good suggestions on the coding style. I'll fix it up when I start using the GPU vendor detection in practice. 868971 22 roger_fong 2013-04-03 17:43:08 -0700 Extensions3DOpenGLCommon::Extensions3DOpenGLCommon(GraphicsContext3D* context) : m_initializedAvailableExtensions(false) , m_context(context) , m_isNVIDIA(false) , m_isAMD(false) , m_isIntel(false) , , m_requiresBuiltInFunctionEmulation(false) did you mean, m_maySupportMultisampling(false) ? 868978 23 dino 2013-04-03 18:02:42 -0700 (In reply to comment #22) > Extensions3DOpenGLCommon::Extensions3DOpenGLCommon(GraphicsContext3D* context) > : m_initializedAvailableExtensions(false) > , m_context(context) > , m_isNVIDIA(false) > , m_isAMD(false) > , m_isIntel(false) > , > , m_requiresBuiltInFunctionEmulation(false) > > did you mean, > m_maySupportMultisampling(false) ? I probably did :( But at the same time, I was probably intending to make sure I didn't turn it off for other platforms. I can only make assumptions about Mac. 166109 2012-09-27 18:11:51 -0700 2012-10-02 16:40:21 -0700 Patch bug-97813-20120928111108.patch text/plain 15375 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMTI5ODI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODhkNWJiYjZlZDFkNjA3 N2I5Nzk5NWE1MTAyOWEwZDVhNDc5NGI1OC4uMTNlY2JjOGI2MDE1ODI4ZGQ0MzZjOTRjZTc4ZDY1 NWMyMmZjMzBlYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDEyLTA5LTI3ICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAgICBFeHBvc2Ugc29tZSBHUFUgSW5m b3JtYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTk3ODEzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg Q3VycmVudGx5IHRoZXJlIGFyZSBhIGZldyBwbGFjZXMgaW4gdGhlIFdlYkdMIGNvZGUgKGFuZCBl bHNld2hlcmUsIGxpa2UgQ1NTIGZpbHRlcnMpCisgICAgICAgIHdoZXJlIHdlIGRvIHNvbWUgZmVh dHVyZSBkZXRlY3Rpb24gYnkgZXhhbWluaW5nIHRoZSBHUFUgdmVuZG9yIGFuZCBpdHMgY2FwYWJp bGl0aWVzLgorICAgICAgICBUaGlzIHBhdGNoIHB1dHMgdGhpcyBkZXRlY3Rpb24gaW50byBvdXIg c2hhcmVkIEV4dGVuc2lvbnMzRCBvYmplY3QuCisKKyAgICAgICAgQ292ZXJlZCBieSBleGlzdGlu ZyB0ZXN0cy4gTm8gbmV3IGZ1bmN0aW9uYWxpdHkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9FeHRlbnNpb25zM0QuaDogQWRkcyB0aGUgbmV3IG1ldGhvZHMgZm9yIGRldGVjdGluZyB2 ZW5kb3IgYW5kIGZlYXR1cmVzLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNz Q29udGV4dDNELmg6CisgICAgICAgIChHcmFwaGljc0NvbnRleHQzRCk6IE5vIGxvbmdlciBuZWVk cyBmdW5jdGlvbiB0byBkZXRlY3QgbXVsdGlzYW1wbGluZyBvbiBBVEkuCisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaDogU3R1YiBpbXBs ZW1lbnRhdGlvbnMgb2YgYWxsCisgICAgICAgIHRoZSBuZXcgbWV0aG9kcy4gQ2hyb21pdW0gZG9l cyBpdHMgZGV0ZWN0aW9uIGVsc2V3aGVyZS4KKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMz RENocm9taXVtOjppc05WaWRpYSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNpb25zM0RDaHJv bWl1bTo6aXNBTUQpOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21pdW06Omlz SW50ZWwpOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21pdW06OnZlbmRvcik6 CisgICAgICAgIChFeHRlbnNpb25zM0RDaHJvbWl1bSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRl bnNpb25zM0RDaHJvbWl1bTo6bWF5U3VwcG9ydE11bHRpc2FtcGxpbmcpOgorICAgICAgICAoV2Vi Q29yZTo6RXh0ZW5zaW9uczNEQ2hyb21pdW06OnJlcXVpcmVzQnVpbHRJbkZ1bmN0aW9uRW11bHRh dGlvbik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZmlsdGVycy9GRUN1c3RvbUZpbHRl ci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGRUN1c3RvbUZpbHRlcjo6Y3JlYXRlTXVsdGlzYW1w bGVCdWZmZXIpOiBBZGQgdGVzdCBmb3Igc3lzdGVtIG11bHRpc2FtcGxpbmcgdG8KKyAgICAgICAg Y3VzdG9tIGZpbHRlciBjb2RlLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3 aW5nQnVmZmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRyYXdpbmdCdWZmZXI6OmNyZWF0ZSk6 IEFkZCB0ZXN0IGZvciBzeXN0ZW0gbXVsdGlzYW1wbGluZyB0byBkcmF3aW5nIGJ1ZmZlcidzCisg ICAgICAgIGNyZWF0aW9uIGNvZGUuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3Blbmds L0V4dGVuc2lvbnMzRE9wZW5HTENvbW1vbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNp b25zM0RPcGVuR0xDb21tb246OkV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbik6IERldGVjdHMgYWxs IHRoZSBmZWF0dXJlcworICAgICAgICBhcyB0aGUgb2JqZWN0IGlzIGNyZWF0ZWQuCisgICAgICAg IChXZWJDb3JlOjpFeHRlbnNpb25zM0RPcGVuR0xDb21tb246OmdldFRyYW5zbGF0ZWRTaGFkZXJT b3VyY2VBTkdMRSk6IENhbiBub3cgc2ltcGx5IGFzaworICAgICAgICBpdHNlbGYgaWYgaXQgbmVl ZHMgdG8gdHVybiBvbiBidWlsdC1pbiBmdW5jdGlvbiB0cmFuc2xhdGlvbi4KKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmg6CisgICAg ICAgIChFeHRlbnNpb25zM0RPcGVuR0xDb21tb24pOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5z aW9uczNET3BlbkdMQ29tbW9uOjppc05WaWRpYSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNp b25zM0RPcGVuR0xDb21tb246OmlzQU1EKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMz RE9wZW5HTENvbW1vbjo6aXNJbnRlbCk6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNpb25zM0RP cGVuR0xDb21tb246OnZlbmRvcik6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNpb25zM0RPcGVu R0xDb21tb246Om1heVN1cHBvcnRNdWx0aXNhbXBsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkV4 dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6cmVxdWlyZXNCdWlsdEluRnVuY3Rpb25FbXVsdGF0aW9u KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RP cGVuR0wuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OnZhbGlkYXRl QXR0cmlidXRlcyk6IEFzayB0aGUgZXh0ZW5zaW9uIG9iamVjdCBpbnN0ZWFkIG9mCisgICAgICAg IHRlc3RpbmcgZGlyZWN0bHkuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dy YXBoaWNzQ29udGV4dDNET3BlbkdMQ29tbW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDNEOjp2YWxpZGF0ZURlcHRoU3RlbmNpbCk6IEFzayB0aGUgZXh0ZW5zaW9uIG9i amVjdCBpbnN0ZWFkCisgICAgICAgIG9mIHRlc3RpbmcgZGlyZWN0bHkuCisKIDIwMTItMDktMjcg IE1hcmsgUGlsZ3JpbSAgPHBpbGdyaW1AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFtDaHJvbWl1 bV0gUmVtb3ZlIHNjcmVlbi1yZWxhdGVkIGZ1bmN0aW9ucyBmcm9tIFBsYXRmb3JtU3VwcG9ydApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRXh0ZW5zaW9uczNE LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaAppbmRl eCA1ZjI4YWZiM2IyZTNjY2QyNzI1ZjNmNjllMGMwYjZmOWNkOTM0MzE3Li45YWI2ZDE2YmQ0N2Uz NDZlN2FmNDYwMDkwM2U5YTIzZjJjNDYzMTkwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaApAQCAtMTg4LDYgKzE4OCwxNSBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIGluc2VydEV2ZW50TWFya2VyRVhUKGNvbnN0IFN0cmluZyYpID0g MDsKICAgICB2aXJ0dWFsIHZvaWQgcHVzaEdyb3VwTWFya2VyRVhUKGNvbnN0IFN0cmluZyYpID0g MDsKICAgICB2aXJ0dWFsIHZvaWQgcG9wR3JvdXBNYXJrZXJFWFQodm9pZCkgPSAwOworCisgICAg Ly8gU29tZSBoZWxwZXIgbWV0aG9kcyB0byBkZXRlY3QgR1BVIGZ1bmN0aW9uYWxpdHkKKyAgICB2 aXJ0dWFsIGJvb2wgaXNOVmlkaWEoKSA9IDA7CisgICAgdmlydHVhbCBib29sIGlzQU1EKCkgPSAw OworICAgIHZpcnR1YWwgYm9vbCBpc0ludGVsKCkgPSAwOworICAgIHZpcnR1YWwgU3RyaW5nIHZl bmRvcigpID0gMDsKKworICAgIHZpcnR1YWwgYm9vbCBtYXlTdXBwb3J0TXVsdGlzYW1wbGluZygp ID0gMDsKKyAgICB2aXJ0dWFsIGJvb2wgcmVxdWlyZXNCdWlsdEluRnVuY3Rpb25FbXVsdGF0aW9u KCkgPSAwOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmgKaW5kZXggNDIwNzZm Zjc4YThkMTk3YTEyNDY3NTU3ZDYyNGY4Y2M5MzkzMzY3MS4uNTMyN2YzYWUyNWFjMGJiNmU4N2Yz MTc0Y2YxYjhiMWJkYzkwMzk4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oCkBAIC0xMDI3LDcgKzEwMjcsNiBAQCBwdWJs aWM6CiAgICAgZnJpZW5kIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTsKICAgICBPd25Q dHI8R3JhcGhpY3NDb250ZXh0M0RQcml2YXRlPiBtX3ByaXZhdGU7CiAjZW5kaWYKLSAgICBib29s IHN5c3RlbUFsbG93c011bHRpc2FtcGxpbmdPbkFUSUNhcmRzKCkgY29uc3Q7CiB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAppbmRleCBl ZGQ2YzEzNWMxOGVjMzg4MGQzNDZmMzVlMjZiYjc3YThkOTkyNGVjLi4xOGE2ZjJjZWMyZGU5MmM4 YjNmZWFhZDVjNGNhODdlOTU0OWI0NzIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVt LmgKQEAgLTEzNyw2ICsxMzcsMTUgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBwdXNoR3Jv dXBNYXJrZXJFWFQoY29uc3QgU3RyaW5nJik7CiAgICAgdmlydHVhbCB2b2lkIHBvcEdyb3VwTWFy a2VyRVhUKHZvaWQpOwogCisgICAgLy8gU29tZSBoZWxwZXIgbWV0aG9kcyB0byBkZXRlY3QgR1BV IGZ1bmN0aW9uYWxpdHkKKyAgICB2aXJ0dWFsIGJvb2wgaXNOVmlkaWEoKSB7IHJldHVybiBmYWxz ZTsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0FNRCgpIHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmly dHVhbCBib29sIGlzSW50ZWwoKSB7IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgU3RyaW5n IHZlbmRvcigpIHsgcmV0dXJuICIiOyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgbWF5U3VwcG9ydE11 bHRpc2FtcGxpbmcoKSB7IHJldHVybiB0cnVlOyB9CisgICAgdmlydHVhbCBib29sIHJlcXVpcmVz QnVpbHRJbkZ1bmN0aW9uRW11bHRhdGlvbigpIHsgcmV0dXJuIGZhbHNlOyB9CisKIHByaXZhdGU6 CiAgICAgLy8gSW5zdGFuY2VzIG9mIHRoaXMgY2xhc3MgYXJlIHN0cmljdGx5IG93bmVkIGJ5IHRo ZSBHcmFwaGljc0NvbnRleHQzRCBpbXBsZW1lbnRhdGlvbiBhbmQgZG8gbm90CiAgICAgLy8gbmVl ZCB0byBiZSBpbnN0YW50aWF0ZWQgYnkgYW55IG90aGVyIGNvZGUuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZFQ3VzdG9tRmlsdGVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIu Y3BwCmluZGV4IGZiNTc2MGYwYjdkYjhiNTFjM2NkZDQ0YzNiMTI3MmQ5NDJmMTJlODMuLjNjZWI3 ZmEzNDU2YmVjMDhmNGU5YzcyMmFlNzNhYTg5YmFlNjk0NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIu Y3BwCkBAIC0yOTksNyArMjk5LDggQEAgYm9vbCBGRUN1c3RvbUZpbHRlcjo6Y3JlYXRlTXVsdGlz YW1wbGVCdWZmZXIoKQogICAgIG1fdHJpZWRNdWx0aXNhbXBsZUJ1ZmZlciA9IHRydWU7CiAKICAg ICBFeHRlbnNpb25zM0QqIGV4dGVuc2lvbnMgPSBtX2NvbnRleHQtPmdldEV4dGVuc2lvbnMoKTsK LSAgICBpZiAoIWV4dGVuc2lvbnMgCisgICAgaWYgKCFleHRlbnNpb25zCisgICAgICAgIHx8ICFl eHRlbnNpb25zLT5tYXlTdXBwb3J0TXVsdGlzYW1wbGluZygpCiAgICAgICAgIHx8ICFleHRlbnNp b25zLT5zdXBwb3J0cygiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKQogICAgICAg ICB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX2JsaXQiKQog ICAgICAgICB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX09FU19yZ2I4X3JnYmE4IikpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1 ZmZlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1 ZmZlci5jcHAKaW5kZXggZmU1MTEwNGYwMDAyN2ZiOThhYTQ4NzkzMTk4NTdlMWU1MmZhNmUxOC4u MjgyYmRlMDNmMmJkM2ZhOGYxMWQ0M2JjZTU3ZDU3ZTE2YmRiYWRiNCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcApA QCAtNTQsNyArNTQsMTAgQEAgc3RhdGljIGNvbnN0IGZsb2F0IHNfcmVzb3VyY2VBZGp1c3RlZFJh dGlvID0gMC41OwogUGFzc1JlZlB0cjxEcmF3aW5nQnVmZmVyPiBEcmF3aW5nQnVmZmVyOjpjcmVh dGUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIGNvbnN0IEludFNpemUmIHNpemUsIFByZXNl cnZlRHJhd2luZ0J1ZmZlciBwcmVzZXJ2ZSwgQWxwaGFSZXF1aXJlbWVudCBhbHBoYSkKIHsKICAg ICBFeHRlbnNpb25zM0QqIGV4dGVuc2lvbnMgPSBjb250ZXh0LT5nZXRFeHRlbnNpb25zKCk7Ci0g ICAgYm9vbCBtdWx0aXNhbXBsZVN1cHBvcnRlZCA9IGV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9B TkdMRV9mcmFtZWJ1ZmZlcl9ibGl0IikgJiYgZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xF X2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIikgJiYgZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX09F U19yZ2I4X3JnYmE4Iik7CisgICAgYm9vbCBtdWx0aXNhbXBsZVN1cHBvcnRlZCA9IGV4dGVuc2lv bnMtPm1heVN1cHBvcnRNdWx0aXNhbXBsaW5nKCkKKyAgICAgICAgJiYgZXh0ZW5zaW9ucy0+c3Vw cG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX2JsaXQiKQorICAgICAgICAmJiBleHRlbnNpb25z LT5zdXBwb3J0cygiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKQorICAgICAgICAm JiBleHRlbnNpb25zLT5zdXBwb3J0cygiR0xfT0VTX3JnYjhfcmdiYTgiKTsKICAgICBpZiAobXVs dGlzYW1wbGVTdXBwb3J0ZWQpIHsKICAgICAgICAgZXh0ZW5zaW9ucy0+ZW5zdXJlRW5hYmxlZCgi R0xfQU5HTEVfZnJhbWVidWZmZXJfYmxpdCIpOwogICAgICAgICBleHRlbnNpb25zLT5lbnN1cmVF bmFibGVkKCJHTF9BTkdMRV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZSIpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0V4dGVuc2lvbnMzRE9wZW5H TENvbW1vbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0 ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcAppbmRleCA2MGY2YmZhZjNhODE2YTdhMmNiZjM2NmUy NTgzNDMzZGVmNWQxMDYxLi5hYjg1OWQ4Y2NkNDMzYzBhMDFkNjdlZDllOWU2ZTViMDdjYjFkMTdj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0 ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcApAQCAtNTMsNyArNTMs NDQgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uOjpFeHRl bnNpb25zM0RPcGVuR0xDb21tb24oR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQpCiAgICAgOiBt X2luaXRpYWxpemVkQXZhaWxhYmxlRXh0ZW5zaW9ucyhmYWxzZSkKICAgICAsIG1fY29udGV4dChj b250ZXh0KQorICAgICwgbV9pc05WaWRpYShmYWxzZSkKKyAgICAsIG1faXNBTUQoZmFsc2UpCisg ICAgLCBtX2lzSW50ZWwoZmFsc2UpCisgICAgLCBtX21heVN1cHBvcnRNdWx0aXNhbXBsaW5nKHRy dWUpCisgICAgLCBtX3JlcXVpcmVzQnVpbHRJbkZ1bmN0aW9uRW11bGF0aW9uKGZhbHNlKQogewor ICAgIG1fdmVuZG9yID0gU3RyaW5nKHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KDo6Z2xH ZXRTdHJpbmcoR0xfVkVORE9SKSkpOworCisgICAgaWYgKG1fdmVuZG9yLmNvbnRhaW5zKCJOVmlk aWEiKSkKKyAgICAgICAgbV9pc05WaWRpYSA9IHRydWU7CisgICAgaWYgKG1fdmVuZG9yLmNvbnRh aW5zKCJBVEkiKSB8fCBtX3ZlbmRvci5jb250YWlucygiQU1EIikpCisgICAgICAgIG1faXNBTUQg PSB0cnVlOworICAgIGlmIChtX3ZlbmRvci5jb250YWlucygiSW50ZWwiKSkKKyAgICAgICAgbV9p c0ludGVsID0gdHJ1ZTsKKworI2lmIFBMQVRGT1JNKE1BQykKKyAgICBpZiAobV9pc0FNRCB8fCBt X2lzSW50ZWwpCisgICAgICAgIG1fcmVxdWlyZXNCdWlsdEluRnVuY3Rpb25FbXVsYXRpb24gPSB0 cnVlOworCisgICAgLy8gQ3VycmVudGx5IGluIE1hYyB3ZSBvbmx5IGFsbG93IG11bHRpc2FtcGxp bmcgaWYgdGhlIHZlbmRvciBpcyBOVklESUEsCisgICAgLy8gb3IgaWYgdGhlIHZlbmRvciBpcyBB TUQvQVRJIGFuZCB0aGUgc3lzdGVtIGlzIDEwLjcuMiBhbmQgYWJvdmUuCisKKyAgICBib29sIHN5 c3RlbVN1cHBvcnRzTXVsdGlzYW1wbGluZyA9IHRydWU7CisjaWYgIVBMQVRGT1JNKElPUykgJiYg X19NQUNfT1NfWF9WRVJTSU9OX01JTl9SRVFVSVJFRCA8IDEwODAKKyAgICBBU1NFUlQoaXNNYWlu VGhyZWFkKCkpOworICAgIHN0YXRpYyBTSW50MzIgdmVyc2lvbjsKKyAgICBpZiAoIXZlcnNpb24p IHsKKyAgICAgICAgaWYgKEdlc3RhbHQoZ2VzdGFsdFN5c3RlbVZlcnNpb24sICZ2ZXJzaW9uKSAh PSBub0VycikKKyAgICAgICAgICAgIHN5c3RlbVN1cHBvcnRzTXVsdGlzYW1wbGluZyA9IGZhbHNl OworICAgIH0KKyAgICAvLyBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTc3OTIyIGZvciBtb3JlIGRldGFpbHMKKyAgICBpZiAoc3lzdGVtU3VwcG9ydHNNdWx0aXNh bXBsaW5nKQorICAgICAgICBzeXN0ZW1TdXBwb3J0c011bHRpc2FtcGxpbmcgPSB2ZXJzaW9uID49 IDB4MTA3MjsKKyNlbmRpZiAvLyBTTk9XX0xFT1BBUkQgYW5kIExJT04KKworICAgIGlmIChtX2lz TlZpZGlhIHx8IChtX2lzQU1EICYmIHN5c3RlbVN1cHBvcnRzTXVsdGlzYW1wbGluZykpCisgICAg ICAgIG1fbWF5U3VwcG9ydE11bHRpc2FtcGxpbmcgPSB0cnVlOworI2VuZGlmCiB9CiAKIEV4dGVu c2lvbnMzRE9wZW5HTENvbW1vbjo6fkV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbigpCkBAIC0xMjMs MTEgKzE2MCw4IEBAIFN0cmluZyBFeHRlbnNpb25zM0RPcGVuR0xDb21tb246OmdldFRyYW5zbGF0 ZWRTaGFkZXJTb3VyY2VBTkdMRShQbGF0Zm9ybTNET2JqZWN0CiAgICAgU3RyaW5nIHNoYWRlcklu Zm9Mb2c7CiAgICAgaW50IGV4dHJhQ29tcGlsZU9wdGlvbnMgPSAwOwogCi0jaWYgUExBVEZPUk0o TUFDKQotICAgIGNvbnN0IGNoYXIqIHZlbmRvciA9IHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hh cio+KDo6Z2xHZXRTdHJpbmcoR0xfVkVORE9SKSk7Ci0gICAgaWYgKHZlbmRvciAmJiAoc3RkOjpz dHJzdHIodmVuZG9yLCAiQVRJIikgfHwgc3RkOjpzdHJzdHIodmVuZG9yLCAiQU1EIikgfHwgc3Rk OjpzdHJzdHIodmVuZG9yLCAiSW50ZWwiKSkpCisgICAgaWYgKG1fcmVxdWlyZXNCdWlsdEluRnVu Y3Rpb25FbXVsYXRpb24pCiAgICAgICAgIGV4dHJhQ29tcGlsZU9wdGlvbnMgfD0gU0hfRU1VTEFU RV9CVUlMVF9JTl9GVU5DVElPTlM7Ci0jZW5kaWYKIAogICAgIGJvb2wgaXNWYWxpZCA9IGNvbXBp bGVyLnZhbGlkYXRlU2hhZGVyU291cmNlKGVudHJ5LnNvdXJjZS51dGY4KCkuZGF0YSgpLCBzaGFk ZXJUeXBlLCB0cmFuc2xhdGVkU2hhZGVyU291cmNlLCBzaGFkZXJJbmZvTG9nLCBleHRyYUNvbXBp bGVPcHRpb25zKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3Mvb3BlbmdsL0V4dGVuc2lvbnMzRE9wZW5HTENvbW1vbi5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0V4dGVuc2lvbnMzRE9wZW5HTENvbW1vbi5oCmluZGV4IDc1 ODY5ZGUxOTk2ZTMxMThhZTRjMmMzZGIxOTc2YTcwNjY4Zjk0OTUuLmY1MDVhM2NiZWUxOWM4YTFh NmQxNjVjYzEyMjQyMGRmNjczZGJhZmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL29wZW5nbC9FeHRlbnNpb25zM0RPcGVuR0xDb21tb24uaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29t bW9uLmgKQEAgLTU3LDYgKzU3LDE1IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZ2V0blVu aWZvcm1mdkVYVChHQzNEdWludCBwcm9ncmFtLCBpbnQgbG9jYXRpb24sIEdDM0RzaXplaSBidWZT aXplLCBmbG9hdCAqcGFyYW1zKTsKICAgICB2aXJ0dWFsIHZvaWQgZ2V0blVuaWZvcm1pdkVYVChH QzNEdWludCBwcm9ncmFtLCBpbnQgbG9jYXRpb24sIEdDM0RzaXplaSBidWZTaXplLCBpbnQgKnBh cmFtcyk7CiAKKyAgICAvLyBTb21lIGhlbHBlciBtZXRob2RzIHRvIGRldGVjdCBHUFUgZnVuY3Rp b25hbGl0eQorICAgIHZpcnR1YWwgYm9vbCBpc05WaWRpYSgpIHsgcmV0dXJuIG1faXNOVmlkaWE7 IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNBTUQoKSB7IHJldHVybiBtX2lzQU1EOyB9CisgICAgdmly dHVhbCBib29sIGlzSW50ZWwoKSB7IHJldHVybiBtX2lzSW50ZWw7IH0KKyAgICB2aXJ0dWFsIFN0 cmluZyB2ZW5kb3IoKSB7IHJldHVybiBtX3ZlbmRvcjsgfQorCisgICAgdmlydHVhbCBib29sIG1h eVN1cHBvcnRNdWx0aXNhbXBsaW5nKCkgeyByZXR1cm4gbV9tYXlTdXBwb3J0TXVsdGlzYW1wbGlu ZzsgfQorICAgIHZpcnR1YWwgYm9vbCByZXF1aXJlc0J1aWx0SW5GdW5jdGlvbkVtdWx0YXRpb24o KSB7IHJldHVybiBtX3JlcXVpcmVzQnVpbHRJbkZ1bmN0aW9uRW11bGF0aW9uOyB9CisKIHByb3Rl Y3RlZDoKICAgICBmcmllbmQgY2xhc3MgRXh0ZW5zaW9uczNET3BlbkdMRVM7CiAgICAgRXh0ZW5z aW9uczNET3BlbkdMQ29tbW9uKEdyYXBoaWNzQ29udGV4dDNEKik7CkBAIC03MCw2ICs3OSwxNCBA QCBwcm90ZWN0ZWQ6CiAKICAgICAvLyBXZWFrIHBvaW50ZXIgYmFjayB0byBHcmFwaGljc0NvbnRl eHQzRAogICAgIEdyYXBoaWNzQ29udGV4dDNEKiBtX2NvbnRleHQ7CisKKyAgICBib29sIG1faXNO VmlkaWE7CisgICAgYm9vbCBtX2lzQU1EOworICAgIGJvb2wgbV9pc0ludGVsOworICAgIGJvb2wg bV9tYXlTdXBwb3J0TXVsdGlzYW1wbGluZzsKKyAgICBib29sIG1fcmVxdWlyZXNCdWlsdEluRnVu Y3Rpb25FbXVsYXRpb247CisKKyAgICBTdHJpbmcgbV92ZW5kb3I7CiB9OwogCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNET3BlbkdMLmNwcAppbmRleCA5 OGUxMTQ1YjNkYjI0ZTUxZDdiNzVmZDA2NzA4ZmZhZTI1NmFlYjEzLi41NGFmN2NhNTQ3ZjRkNmM2 MmMxMzY4NWQ1NGFmMmEyN2JmZGUxOTlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9w ZW5HTC5jcHAKQEAgLTU5LDEzICs1OSw3IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnZhbGlk YXRlQXR0cmlidXRlcygpCiAgICAgRXh0ZW5zaW9uczNEKiBleHRlbnNpb25zID0gZ2V0RXh0ZW5z aW9ucygpOwogICAgIHZhbGlkYXRlRGVwdGhTdGVuY2lsKCJHTF9FWFRfcGFja2VkX2RlcHRoX3N0 ZW5jaWwiKTsKICAgICBpZiAobV9hdHRycy5hbnRpYWxpYXMpIHsKLSAgICAgICAgYm9vbCBpc1Zh bGlkVmVuZG9yID0gdHJ1ZTsKLSAgICAgICAgLy8gQ3VycmVudGx5IGluIE1hYyB3ZSBvbmx5IHR1 cm4gb24gYW50aWFsaWFzIGlmIHZlbmRvciBpcyBOVklESUEsCi0gICAgICAgIC8vIG9yIGlmIEFU SSBhbmQgb24gMTAuNy4yIGFuZCBhYm92ZS4KLSAgICAgICAgY29uc3QgY2hhciogdmVuZG9yID0g cmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oOjpnbEdldFN0cmluZyhHTF9WRU5ET1IpKTsK LSAgICAgICAgaWYgKCF2ZW5kb3IgfHwgKCFzdGQ6OnN0cnN0cih2ZW5kb3IsICJOVklESUEiKSAm JiAhKHN0ZDo6c3Ryc3RyKHZlbmRvciwgIkFUSSIpICYmIHN5c3RlbUFsbG93c011bHRpc2FtcGxp bmdPbkFUSUNhcmRzKCkpKSkKLSAgICAgICAgICAgIGlzVmFsaWRWZW5kb3IgPSBmYWxzZTsKLSAg ICAgICAgaWYgKCFpc1ZhbGlkVmVuZG9yIHx8ICFleHRlbnNpb25zLT5zdXBwb3J0cygiR0xfQU5H TEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKSB8fCBpc0dMRVMyQ29tcGxpYW50KCkpCisgICAg ICAgIGlmICghZXh0ZW5zaW9ucy0+bWF5U3VwcG9ydE11bHRpc2FtcGxpbmcoKSB8fCAhZXh0ZW5z aW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIikgfHwgaXNH TEVTMkNvbXBsaWFudCgpKQogICAgICAgICAgICAgbV9hdHRycy5hbnRpYWxpYXMgPSBmYWxzZTsK ICAgICAgICAgZWxzZQogICAgICAgICAgICAgZXh0ZW5zaW9ucy0+ZW5zdXJlRW5hYmxlZCgiR0xf QU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKTsKQEAgLTI4MSwyNiArMjc1LDYgQEAgdm9p ZCBHcmFwaGljc0NvbnRleHQzRDo6Y2xlYXJEZXB0aChHQzNEY2xhbXBmIGRlcHRoKQogICAgIDo6 Z2xDbGVhckRlcHRoKGRlcHRoKTsKIH0KIAotYm9vbCBHcmFwaGljc0NvbnRleHQzRDo6c3lzdGVt QWxsb3dzTXVsdGlzYW1wbGluZ09uQVRJQ2FyZHMoKSBjb25zdAotewotI2lmIFBMQVRGT1JNKE1B QykKLSNpZiBQTEFURk9STShJT1MpIHx8IF9fTUFDX09TX1hfVkVSU0lPTl9NSU5fUkVRVUlSRUQg Pj0gMTA4MAotICAgIHJldHVybiB0cnVlOwotI2Vsc2UKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFk KCkpOwotICAgIHN0YXRpYyBTSW50MzIgdmVyc2lvbjsKLSAgICBpZiAoIXZlcnNpb24pIHsKLSAg ICAgICAgaWYgKEdlc3RhbHQoZ2VzdGFsdFN5c3RlbVZlcnNpb24sICZ2ZXJzaW9uKSAhPSBub0Vy cikKLSAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICB9Ci0gICAgLy8gU2VlIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzkyMiBmb3IgbW9yZSBkZXRhaWxzCi0g ICAgcmV0dXJuIHZlcnNpb24gPj0gMHgxMDcyOwotI2VuZGlmIC8vIFNOT1dfTEVPUEFSRCBhbmQg TElPTgotI2Vsc2UKLSAgICByZXR1cm4gZmFsc2U7Ci0jZW5kaWYgLy8gUExBVEZPUk0oTUFDKQot fQotCiBFeHRlbnNpb25zM0QqIEdyYXBoaWNzQ29udGV4dDNEOjpnZXRFeHRlbnNpb25zKCkKIHsK ICAgICBpZiAoIW1fZXh0ZW5zaW9ucykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTENvbW1vbi5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RP cGVuR0xDb21tb24uY3BwCmluZGV4IDRmZmZlZTQ3ZDBiZmRhZGNiOWI0ZmQyMDc4Yjk2NmY0YWQ2 MWNhY2EuLjhhMmFjODFlNjc2MDEzMzkyYjY2OGM2N2EwZWI1Y2NlYzk3MzJmZTYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRl eHQzRE9wZW5HTENvbW1vbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNET3BlbkdMQ29tbW9uLmNwcApAQCAtODgsMTMgKzg4 LDcgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6dmFsaWRhdGVEZXB0aFN0ZW5jaWwoY29uc3Qg Y2hhciogcGFja2VkRGVwdGhTdGVuY2lsRXh0ZW4KICAgICAgICAgICAgIG1fYXR0cnMuc3RlbmNp bCA9IGZhbHNlOwogICAgIH0KICAgICBpZiAobV9hdHRycy5hbnRpYWxpYXMpIHsKLSAgICAgICAg Ym9vbCBpc1ZhbGlkVmVuZG9yID0gdHJ1ZTsKLSAgICAgICAgLy8gQ3VycmVudGx5IGluIE1hYyB3 ZSBvbmx5IHR1cm4gb24gYW50aWFsaWFzIGlmIHZlbmRvciBpcyBOVklESUEsCi0gICAgICAgIC8v IG9yIGlmIEFUSSBhbmQgb24gMTAuNy4yIGFuZCBhYm92ZS4KLSAgICAgICAgY29uc3QgY2hhciog dmVuZG9yID0gcmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oOjpnbEdldFN0cmluZyhHTF9W RU5ET1IpKTsKLSAgICAgICAgaWYgKCF2ZW5kb3IgfHwgKCFzdGQ6OnN0cnN0cih2ZW5kb3IsICJO VklESUEiKSAmJiAhKHN0ZDo6c3Ryc3RyKHZlbmRvciwgIkFUSSIpICYmIHN5c3RlbUFsbG93c011 bHRpc2FtcGxpbmdPbkFUSUNhcmRzKCkpKSkKLSAgICAgICAgICAgIGlzVmFsaWRWZW5kb3IgPSBm YWxzZTsKLSAgICAgICAgaWYgKCFpc1ZhbGlkVmVuZG9yIHx8ICFleHRlbnNpb25zLT5zdXBwb3J0 cygiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKSB8fCBpc0dMRVMyQ29tcGxpYW50 KCkpCisgICAgICAgIGlmICghZXh0ZW5zaW9ucy0+bWF5U3VwcG9ydE11bHRpc2FtcGxpbmcoKSB8 fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxl IikgfHwgaXNHTEVTMkNvbXBsaWFudCgpKQogICAgICAgICAgICAgbV9hdHRycy5hbnRpYWxpYXMg PSBmYWxzZTsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgZXh0ZW5zaW9ucy0+ZW5zdXJlRW5h YmxlZCgiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKTsK 166776 2012-10-02 16:40:27 -0700 2012-10-02 17:11:23 -0700 Patch bug-97813-20121003093939.patch text/plain 16066 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMTMwMjI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODUxZDg2MmY1ODYxOWZl NTI1ZGRiNTkyN2EzZTZiZWIzNzM4ZGU1Ny4uZDNjZWZiMzI4YjAyN2FhY2RkZGUwMDZjMTkzYzYx NzA2N2FhNjcyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU0IEBACisyMDEyLTEwLTAyICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAgICBFeHBvc2Ugc29tZSBHUFUgSW5m b3JtYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTk3ODEzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZyBhbmQgS2VuIFJ1c3NlbGwu CisKKyAgICAgICAgQ3VycmVudGx5IHRoZXJlIGFyZSBhIGZldyBwbGFjZXMgaW4gdGhlIFdlYkdM IGNvZGUgKGFuZCBlbHNld2hlcmUsIGxpa2UgQ1NTIGZpbHRlcnMpCisgICAgICAgIHdoZXJlIHdl IGRvIHNvbWUgZmVhdHVyZSBkZXRlY3Rpb24gYnkgZXhhbWluaW5nIHRoZSBHUFUgdmVuZG9yIGFu ZCBpdHMgY2FwYWJpbGl0aWVzLgorICAgICAgICBUaGlzIHBhdGNoIHB1dHMgdGhpcyBkZXRlY3Rp b24gaW50byBvdXIgc2hhcmVkIEV4dGVuc2lvbnMzRCBvYmplY3QuCisKKyAgICAgICAgQ292ZXJl ZCBieSBleGlzdGluZyB0ZXN0cy4gTm8gbmV3IGZ1bmN0aW9uYWxpdHkuCisKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaDogQWRkcyB0aGUgbmV3IG1ldGhvZHMgZm9y IGRldGVjdGluZyB2ZW5kb3IgYW5kIGZlYXR1cmVzLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL0dyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChHcmFwaGljc0NvbnRleHQzRCk6IE5v IGxvbmdlciBuZWVkcyBmdW5jdGlvbiB0byBkZXRlY3QgbXVsdGlzYW1wbGluZyBvbiBBVEkuCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0u aDogU3R1YiBpbXBsZW1lbnRhdGlvbnMgb2YgYWxsCisgICAgICAgIHRoZSBuZXcgbWV0aG9kcy4g Q2hyb21pdW0gZG9lcyBpdHMgZGV0ZWN0aW9uIGVsc2V3aGVyZS4KKyAgICAgICAgKFdlYkNvcmU6 OkV4dGVuc2lvbnMzRENocm9taXVtOjppc05WaWRpYSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRl bnNpb25zM0RDaHJvbWl1bTo6aXNBTUQpOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNE Q2hyb21pdW06OmlzSW50ZWwpOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21p dW06OnZlbmRvcik6CisgICAgICAgIChFeHRlbnNpb25zM0RDaHJvbWl1bSk6CisgICAgICAgIChX ZWJDb3JlOjpFeHRlbnNpb25zM0RDaHJvbWl1bTo6bWF5U3VwcG9ydE11bHRpc2FtcGxpbmcpOgor ICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21pdW06OnJlcXVpcmVzQnVpbHRJbkZ1 bmN0aW9uRW11bGF0aW9uKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZF Q3VzdG9tRmlsdGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZFQ3VzdG9tRmlsdGVyOjpjcmVh dGVNdWx0aXNhbXBsZUJ1ZmZlcik6IEFkZCB0ZXN0IGZvciBzeXN0ZW0gbXVsdGlzYW1wbGluZyB0 bworICAgICAgICBjdXN0b20gZmlsdGVyIGNvZGUuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RHJhd2luZ0J1ZmZl cjo6Y3JlYXRlKTogQWRkIHRlc3QgZm9yIHN5c3RlbSBtdWx0aXNhbXBsaW5nIHRvIGRyYXdpbmcg YnVmZmVyJ3MKKyAgICAgICAgY3JlYXRpb24gY29kZS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6RXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uKTog RGV0ZWN0cyBhbGwgdGhlIGZlYXR1cmVzCisgICAgICAgIGFzIHRoZSBvYmplY3QgaXMgY3JlYXRl ZC4KKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6Z2V0VHJhbnNs YXRlZFNoYWRlclNvdXJjZUFOR0xFKTogQ2FuIG5vdyBzaW1wbHkgYXNrCisgICAgICAgIGl0c2Vs ZiBpZiBpdCBuZWVkcyB0byB0dXJuIG9uIGJ1aWx0LWluIGZ1bmN0aW9uIHRyYW5zbGF0aW9uLgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9FeHRlbnNpb25zM0RPcGVuR0xDb21t b24uaDoKKyAgICAgICAgKEV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbik6CisgICAgICAgIChXZWJD b3JlOjpFeHRlbnNpb25zM0RPcGVuR0xDb21tb246OmlzTlZpZGlhKToKKyAgICAgICAgKFdlYkNv cmU6OkV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6aXNBTUQpOgorICAgICAgICAoV2ViQ29yZTo6 RXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uOjppc0ludGVsKToKKyAgICAgICAgKFdlYkNvcmU6OkV4 dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6dmVuZG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVu c2lvbnMzRE9wZW5HTENvbW1vbjo6bWF5U3VwcG9ydE11bHRpc2FtcGxpbmcpOgorICAgICAgICAo V2ViQ29yZTo6RXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uOjpyZXF1aXJlc0J1aWx0SW5GdW5jdGlv bkVtdWxhdGlvbik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNz Q29udGV4dDNET3BlbkdMLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNE Ojp2YWxpZGF0ZUF0dHJpYnV0ZXMpOiBBc2sgdGhlIGV4dGVuc2lvbiBvYmplY3QgaW5zdGVhZCBv ZgorICAgICAgICB0ZXN0aW5nIGRpcmVjdGx5LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTENvbW1vbi5jcHA6CisgICAgICAgIChXZWJD b3JlOjpHcmFwaGljc0NvbnRleHQzRDo6dmFsaWRhdGVEZXB0aFN0ZW5jaWwpOiBBc2sgdGhlIGV4 dGVuc2lvbiBvYmplY3QgaW5zdGVhZAorICAgICAgICBvZiB0ZXN0aW5nIGRpcmVjdGx5LgorCiAy MDEyLTEwLTAyICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg aWZyYW1lcyB3aXRoIHNjcm9sbGluZz1ubyBjYW4ndCBzY3JvbGwgdG8gYW5jaG9ycwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRXh0ZW5zaW9uczNELmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaAppbmRleCA1ZjI4 YWZiM2IyZTNjY2QyNzI1ZjNmNjllMGMwYjZmOWNkOTM0MzE3Li4xNTIwNjRhNjcwNjYyZmUxNWI1 ZDE1MWU3M2FlMjAyNmQyMzM4OTA0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9FeHRlbnNpb25zM0QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9FeHRlbnNpb25zM0QuaApAQCAtMTg4LDYgKzE4OCwyMyBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCB2b2lkIGluc2VydEV2ZW50TWFya2VyRVhUKGNvbnN0IFN0cmluZyYpID0gMDsKICAg ICB2aXJ0dWFsIHZvaWQgcHVzaEdyb3VwTWFya2VyRVhUKGNvbnN0IFN0cmluZyYpID0gMDsKICAg ICB2aXJ0dWFsIHZvaWQgcG9wR3JvdXBNYXJrZXJFWFQodm9pZCkgPSAwOworCisgICAgLy8gU29t ZSBoZWxwZXIgbWV0aG9kcyB0byBkZXRlY3QgR1BVIGZ1bmN0aW9uYWxpdHkKKyAgICB2aXJ0dWFs IGJvb2wgaXNOVmlkaWEoKSA9IDA7CisgICAgdmlydHVhbCBib29sIGlzQU1EKCkgPSAwOworICAg IHZpcnR1YWwgYm9vbCBpc0ludGVsKCkgPSAwOworICAgIHZpcnR1YWwgU3RyaW5nIHZlbmRvcigp ID0gMDsKKworICAgIC8vIElmIHRoaXMgbWV0aG9kIHJldHVybnMgZmFsc2UgdGhlbiB0aGUgc3lz dGVtICpkZWZpbml0ZWx5KiBkb2VzIG5vdCBzdXBwb3J0IG11bHRpc2FtcGxpbmcuCisgICAgLy8g SXQgZG9lcyBub3QgbmVjZXNzYXJpbHkgc2F5IHRoZSBzeXN0ZW0gZG9lcyBzdXBwb3J0IGl0IC0g Y2FsbGVycyBtdXN0IGF0dGVtcHQgdG8gY29uc3RydWN0CisgICAgLy8gbXVsdGlzYW1wbGVkIHJl bmRlcmJ1ZmZlcnMgYW5kIGNoZWNrIGZyYW1lYnVmZmVyIGNvbXBsZXRlbmVzcy4KKyAgICAvLyBQ b3J0cyBzaG91bGQgaW1wbGVtZW50IHRoaXMgdG8gcmV0dXJuIGZhbHNlIG9uIGNvbmZpZ3VyYXRp b25zIHdoZXJlIGl0IGlzIGtub3duCisgICAgLy8gdGhhdCBtdWx0aXNhbXBsaW5nIGlzIG5vdCBh dmFpbGFibGUuCisgICAgdmlydHVhbCBib29sIG1heVN1cHBvcnRNdWx0aXNhbXBsaW5nKCkgPSAw OworCisgICAgLy8gU29tZSBjb25maWd1cmF0aW9ucyBoYXZlIGJ1Z3MgcmVnYXJkaW5nIGJ1aWx0 LWluIGZ1bmN0aW9ucyBpbiB0aGVpciBPcGVuR0wgZHJpdmVycworICAgIC8vIHRoYXQgbXVzdCBi ZSBhdm9pZGVkLiBQb3J0cyBzaG91bGQgaW1wbGVtZW50IHRoaXMgZmxhZyBzdWNoIGNvbmZpZ3Vy YXRpb25zLgorICAgIHZpcnR1YWwgYm9vbCByZXF1aXJlc0J1aWx0SW5GdW5jdGlvbkVtdWxhdGlv bigpID0gMDsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IDQyMDc2 ZmY3OGE4ZDE5N2ExMjQ2NzU1N2Q2MjRmOGNjOTM5MzM2NzEuLjUzMjdmM2FlMjVhYzBiYjZlODdm MzE3NGNmMWI4YjFiZGM5MDM5ODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtMTAyNyw3ICsxMDI3LDYgQEAgcHVi bGljOgogICAgIGZyaWVuZCBjbGFzcyBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU7CiAgICAgT3du UHRyPEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZT4gbV9wcml2YXRlOwogI2VuZGlmCi0gICAgYm9v bCBzeXN0ZW1BbGxvd3NNdWx0aXNhbXBsaW5nT25BVElDYXJkcygpIGNvbnN0OwogfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKaW5kZXgg ZWRkNmMxMzVjMThlYzM4ODBkMzQ2ZjM1ZTI2YmI3N2E4ZDk5MjRlYy4uMGFlNjU1MTJmZTBkNzU1 NWVhZmFjYjI3YmU3OTdiMTQwOTg2NmEwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1 bS5oCkBAIC0xMzcsNiArMTM3LDE1IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgcHVzaEdy b3VwTWFya2VyRVhUKGNvbnN0IFN0cmluZyYpOwogICAgIHZpcnR1YWwgdm9pZCBwb3BHcm91cE1h cmtlckVYVCh2b2lkKTsKIAorICAgIC8vIFNvbWUgaGVscGVyIG1ldGhvZHMgdG8gZGV0ZWN0IEdQ VSBmdW5jdGlvbmFsaXR5CisgICAgdmlydHVhbCBib29sIGlzTlZpZGlhKCkgeyByZXR1cm4gZmFs c2U7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNBTUQoKSB7IHJldHVybiBmYWxzZTsgfQorICAgIHZp cnR1YWwgYm9vbCBpc0ludGVsKCkgeyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIFN0cmlu ZyB2ZW5kb3IoKSB7IHJldHVybiAiIjsgfQorCisgICAgdmlydHVhbCBib29sIG1heVN1cHBvcnRN dWx0aXNhbXBsaW5nKCkgeyByZXR1cm4gdHJ1ZTsgfQorICAgIHZpcnR1YWwgYm9vbCByZXF1aXJl c0J1aWx0SW5GdW5jdGlvbkVtdWxhdGlvbigpIHsgcmV0dXJuIGZhbHNlOyB9CisKIHByaXZhdGU6 CiAgICAgLy8gSW5zdGFuY2VzIG9mIHRoaXMgY2xhc3MgYXJlIHN0cmljdGx5IG93bmVkIGJ5IHRo ZSBHcmFwaGljc0NvbnRleHQzRCBpbXBsZW1lbnRhdGlvbiBhbmQgZG8gbm90CiAgICAgLy8gbmVl ZCB0byBiZSBpbnN0YW50aWF0ZWQgYnkgYW55IG90aGVyIGNvZGUuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL0ZFQ3VzdG9tRmlsdGVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIu Y3BwCmluZGV4IGZiNTc2MGYwYjdkYjhiNTFjM2NkZDQ0YzNiMTI3MmQ5NDJmMTJlODMuLjNjZWI3 ZmEzNDU2YmVjMDhmNGU5YzcyMmFlNzNhYTg5YmFlNjk0NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvRkVDdXN0b21GaWx0ZXIu Y3BwCkBAIC0yOTksNyArMjk5LDggQEAgYm9vbCBGRUN1c3RvbUZpbHRlcjo6Y3JlYXRlTXVsdGlz YW1wbGVCdWZmZXIoKQogICAgIG1fdHJpZWRNdWx0aXNhbXBsZUJ1ZmZlciA9IHRydWU7CiAKICAg ICBFeHRlbnNpb25zM0QqIGV4dGVuc2lvbnMgPSBtX2NvbnRleHQtPmdldEV4dGVuc2lvbnMoKTsK LSAgICBpZiAoIWV4dGVuc2lvbnMgCisgICAgaWYgKCFleHRlbnNpb25zCisgICAgICAgIHx8ICFl eHRlbnNpb25zLT5tYXlTdXBwb3J0TXVsdGlzYW1wbGluZygpCiAgICAgICAgIHx8ICFleHRlbnNp b25zLT5zdXBwb3J0cygiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKQogICAgICAg ICB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX2JsaXQiKQog ICAgICAgICB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX09FU19yZ2I4X3JnYmE4IikpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1 ZmZlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1 ZmZlci5jcHAKaW5kZXggZmU1MTEwNGYwMDAyN2ZiOThhYTQ4NzkzMTk4NTdlMWU1MmZhNmUxOC4u MjgyYmRlMDNmMmJkM2ZhOGYxMWQ0M2JjZTU3ZDU3ZTE2YmRiYWRiNCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0RyYXdpbmdCdWZmZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmNwcApA QCAtNTQsNyArNTQsMTAgQEAgc3RhdGljIGNvbnN0IGZsb2F0IHNfcmVzb3VyY2VBZGp1c3RlZFJh dGlvID0gMC41OwogUGFzc1JlZlB0cjxEcmF3aW5nQnVmZmVyPiBEcmF3aW5nQnVmZmVyOjpjcmVh dGUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIGNvbnN0IEludFNpemUmIHNpemUsIFByZXNl cnZlRHJhd2luZ0J1ZmZlciBwcmVzZXJ2ZSwgQWxwaGFSZXF1aXJlbWVudCBhbHBoYSkKIHsKICAg ICBFeHRlbnNpb25zM0QqIGV4dGVuc2lvbnMgPSBjb250ZXh0LT5nZXRFeHRlbnNpb25zKCk7Ci0g ICAgYm9vbCBtdWx0aXNhbXBsZVN1cHBvcnRlZCA9IGV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9B TkdMRV9mcmFtZWJ1ZmZlcl9ibGl0IikgJiYgZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX0FOR0xF X2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIikgJiYgZXh0ZW5zaW9ucy0+c3VwcG9ydHMoIkdMX09F U19yZ2I4X3JnYmE4Iik7CisgICAgYm9vbCBtdWx0aXNhbXBsZVN1cHBvcnRlZCA9IGV4dGVuc2lv bnMtPm1heVN1cHBvcnRNdWx0aXNhbXBsaW5nKCkKKyAgICAgICAgJiYgZXh0ZW5zaW9ucy0+c3Vw cG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX2JsaXQiKQorICAgICAgICAmJiBleHRlbnNpb25z LT5zdXBwb3J0cygiR0xfQU5HTEVfZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUiKQorICAgICAgICAm JiBleHRlbnNpb25zLT5zdXBwb3J0cygiR0xfT0VTX3JnYjhfcmdiYTgiKTsKICAgICBpZiAobXVs dGlzYW1wbGVTdXBwb3J0ZWQpIHsKICAgICAgICAgZXh0ZW5zaW9ucy0+ZW5zdXJlRW5hYmxlZCgi R0xfQU5HTEVfZnJhbWVidWZmZXJfYmxpdCIpOwogICAgICAgICBleHRlbnNpb25zLT5lbnN1cmVF bmFibGVkKCJHTF9BTkdMRV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZSIpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0V4dGVuc2lvbnMzRE9wZW5H TENvbW1vbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0 ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcAppbmRleCA2MGY2YmZhZjNhODE2YTdhMmNiZjM2NmUy NTgzNDMzZGVmNWQxMDYxLi5iNjViM2I5NmU5ZTMxNDNmOTU4NWQ5Njg1MTg4N2E3YzU0NWE3ZjBh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0 ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmNwcApAQCAtNTMsNyArNTMs NDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uOjpFeHRl bnNpb25zM0RPcGVuR0xDb21tb24oR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQpCiAgICAgOiBt X2luaXRpYWxpemVkQXZhaWxhYmxlRXh0ZW5zaW9ucyhmYWxzZSkKICAgICAsIG1fY29udGV4dChj b250ZXh0KQorICAgICwgbV9pc05WaWRpYShmYWxzZSkKKyAgICAsIG1faXNBTUQoZmFsc2UpCisg ICAgLCBtX2lzSW50ZWwoZmFsc2UpCisgICAgLCBtX21heVN1cHBvcnRNdWx0aXNhbXBsaW5nKHRy dWUpCisgICAgLCBtX3JlcXVpcmVzQnVpbHRJbkZ1bmN0aW9uRW11bGF0aW9uKGZhbHNlKQogewor ICAgIG1fdmVuZG9yID0gU3RyaW5nKHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KDo6Z2xH ZXRTdHJpbmcoR0xfVkVORE9SKSkpOworCisgICAgVmVjdG9yPFN0cmluZz4gdmVuZG9yQ29tcG9u ZW50czsKKyAgICBtX3ZlbmRvci5sb3dlcigpLnNwbGl0KCcgJywgdmVuZG9yQ29tcG9uZW50cyk7 CisgICAgaWYgKHZlbmRvckNvbXBvbmVudHMuY29udGFpbnMoIm52aWRpYSIpKQorICAgICAgICBt X2lzTlZpZGlhID0gdHJ1ZTsKKyAgICBpZiAodmVuZG9yQ29tcG9uZW50cy5jb250YWlucygiYXRp IikgfHwgdmVuZG9yQ29tcG9uZW50cy5jb250YWlucygiYW1kIikpCisgICAgICAgIG1faXNBTUQg PSB0cnVlOworICAgIGlmICh2ZW5kb3JDb21wb25lbnRzLmNvbnRhaW5zKCJpbnRlbCIpKQorICAg ICAgICBtX2lzSW50ZWwgPSB0cnVlOworCisjaWYgUExBVEZPUk0oTUFDKQorICAgIGlmIChtX2lz QU1EIHx8IG1faXNJbnRlbCkKKyAgICAgICAgbV9yZXF1aXJlc0J1aWx0SW5GdW5jdGlvbkVtdWxh dGlvbiA9IHRydWU7CisKKyAgICAvLyBDdXJyZW50bHkgaW4gTWFjIHdlIG9ubHkgYWxsb3cgbXVs dGlzYW1wbGluZyBpZiB0aGUgdmVuZG9yIGlzIE5WSURJQSwKKyAgICAvLyBvciBpZiB0aGUgdmVu ZG9yIGlzIEFNRC9BVEkgYW5kIHRoZSBzeXN0ZW0gaXMgMTAuNy4yIGFuZCBhYm92ZS4KKworICAg IGJvb2wgc3lzdGVtU3VwcG9ydHNNdWx0aXNhbXBsaW5nID0gdHJ1ZTsKKyNpZiAhUExBVEZPUk0o SU9TKSAmJiBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JFUVVJUkVEIDwgMTA4MAorICAgIEFTU0VS VChpc01haW5UaHJlYWQoKSk7CisgICAgc3RhdGljIFNJbnQzMiB2ZXJzaW9uOworICAgIGlmICgh dmVyc2lvbikgeworICAgICAgICBpZiAoR2VzdGFsdChnZXN0YWx0U3lzdGVtVmVyc2lvbiwgJnZl cnNpb24pICE9IG5vRXJyKQorICAgICAgICAgICAgc3lzdGVtU3VwcG9ydHNNdWx0aXNhbXBsaW5n ID0gZmFsc2U7CisgICAgfQorICAgIC8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9Nzc5MjIgZm9yIG1vcmUgZGV0YWlscworICAgIGlmIChzeXN0ZW1TdXBwb3J0 c011bHRpc2FtcGxpbmcpCisgICAgICAgIHN5c3RlbVN1cHBvcnRzTXVsdGlzYW1wbGluZyA9IHZl cnNpb24gPj0gMHgxMDcyOworI2VuZGlmIC8vIFNOT1dfTEVPUEFSRCBhbmQgTElPTgorCisgICAg aWYgKG1faXNOVmlkaWEgfHwgKG1faXNBTUQgJiYgc3lzdGVtU3VwcG9ydHNNdWx0aXNhbXBsaW5n KSkKKyAgICAgICAgbV9tYXlTdXBwb3J0TXVsdGlzYW1wbGluZyA9IHRydWU7CisjZW5kaWYKIH0K IAogRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uOjp+RXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uKCkK QEAgLTEyMywxMSArMTYyLDggQEAgU3RyaW5nIEV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbjo6Z2V0 VHJhbnNsYXRlZFNoYWRlclNvdXJjZUFOR0xFKFBsYXRmb3JtM0RPYmplY3QKICAgICBTdHJpbmcg c2hhZGVySW5mb0xvZzsKICAgICBpbnQgZXh0cmFDb21waWxlT3B0aW9ucyA9IDA7CiAKLSNpZiBQ TEFURk9STShNQUMpCi0gICAgY29uc3QgY2hhciogdmVuZG9yID0gcmVpbnRlcnByZXRfY2FzdDxj b25zdCBjaGFyKj4oOjpnbEdldFN0cmluZyhHTF9WRU5ET1IpKTsKLSAgICBpZiAodmVuZG9yICYm IChzdGQ6OnN0cnN0cih2ZW5kb3IsICJBVEkiKSB8fCBzdGQ6OnN0cnN0cih2ZW5kb3IsICJBTUQi KSB8fCBzdGQ6OnN0cnN0cih2ZW5kb3IsICJJbnRlbCIpKSkKKyAgICBpZiAobV9yZXF1aXJlc0J1 aWx0SW5GdW5jdGlvbkVtdWxhdGlvbikKICAgICAgICAgZXh0cmFDb21waWxlT3B0aW9ucyB8PSBT SF9FTVVMQVRFX0JVSUxUX0lOX0ZVTkNUSU9OUzsKLSNlbmRpZgogCiAgICAgYm9vbCBpc1ZhbGlk ID0gY29tcGlsZXIudmFsaWRhdGVTaGFkZXJTb3VyY2UoZW50cnkuc291cmNlLnV0ZjgoKS5kYXRh KCksIHNoYWRlclR5cGUsIHRyYW5zbGF0ZWRTaGFkZXJTb3VyY2UsIHNoYWRlckluZm9Mb2csIGV4 dHJhQ29tcGlsZU9wdGlvbnMpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvRXh0ZW5zaW9uczNET3BlbkdMQ29tbW9uLmgK aW5kZXggNzU4NjlkZTE5OTZlMzExOGFlNGMyYzNkYjE5NzZhNzA2NjhmOTQ5NS4uOTlmODJhZWQx NmJiNTJiN2U2YmQ4YzQ1NjYwZTRhMDQ0ZjliYTc5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0V4dGVuc2lvbnMzRE9wZW5HTENvbW1vbi5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9FeHRlbnNpb25zM0RP cGVuR0xDb21tb24uaApAQCAtNTcsNiArNTcsMTUgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBnZXRuVW5pZm9ybWZ2RVhUKEdDM0R1aW50IHByb2dyYW0sIGludCBsb2NhdGlvbiwgR0MzRHNp emVpIGJ1ZlNpemUsIGZsb2F0ICpwYXJhbXMpOwogICAgIHZpcnR1YWwgdm9pZCBnZXRuVW5pZm9y bWl2RVhUKEdDM0R1aW50IHByb2dyYW0sIGludCBsb2NhdGlvbiwgR0MzRHNpemVpIGJ1ZlNpemUs IGludCAqcGFyYW1zKTsKIAorICAgIC8vIFNvbWUgaGVscGVyIG1ldGhvZHMgdG8gZGV0ZWN0IEdQ VSBmdW5jdGlvbmFsaXR5CisgICAgdmlydHVhbCBib29sIGlzTlZpZGlhKCkgeyByZXR1cm4gbV9p c05WaWRpYTsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0FNRCgpIHsgcmV0dXJuIG1faXNBTUQ7IH0K KyAgICB2aXJ0dWFsIGJvb2wgaXNJbnRlbCgpIHsgcmV0dXJuIG1faXNJbnRlbDsgfQorICAgIHZp cnR1YWwgU3RyaW5nIHZlbmRvcigpIHsgcmV0dXJuIG1fdmVuZG9yOyB9CisKKyAgICB2aXJ0dWFs IGJvb2wgbWF5U3VwcG9ydE11bHRpc2FtcGxpbmcoKSB7IHJldHVybiBtX21heVN1cHBvcnRNdWx0 aXNhbXBsaW5nOyB9CisgICAgdmlydHVhbCBib29sIHJlcXVpcmVzQnVpbHRJbkZ1bmN0aW9uRW11 bGF0aW9uKCkgeyByZXR1cm4gbV9yZXF1aXJlc0J1aWx0SW5GdW5jdGlvbkVtdWxhdGlvbjsgfQor CiBwcm90ZWN0ZWQ6CiAgICAgZnJpZW5kIGNsYXNzIEV4dGVuc2lvbnMzRE9wZW5HTEVTOwogICAg IEV4dGVuc2lvbnMzRE9wZW5HTENvbW1vbihHcmFwaGljc0NvbnRleHQzRCopOwpAQCAtNzAsNiAr NzksMTQgQEAgcHJvdGVjdGVkOgogCiAgICAgLy8gV2VhayBwb2ludGVyIGJhY2sgdG8gR3JhcGhp Y3NDb250ZXh0M0QKICAgICBHcmFwaGljc0NvbnRleHQzRCogbV9jb250ZXh0OworCisgICAgYm9v bCBtX2lzTlZpZGlhOworICAgIGJvb2wgbV9pc0FNRDsKKyAgICBib29sIG1faXNJbnRlbDsKKyAg ICBib29sIG1fbWF5U3VwcG9ydE11bHRpc2FtcGxpbmc7CisgICAgYm9vbCBtX3JlcXVpcmVzQnVp bHRJbkZ1bmN0aW9uRW11bGF0aW9uOworCisgICAgU3RyaW5nIG1fdmVuZG9yOwogfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNET3BlbkdMLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHAK aW5kZXggOThlMTE0NWIzZGIyNGU1MWQ3Yjc1ZmQwNjcwOGZmYWUyNTZhZWIxMy4uNTRhZjdjYTU0 N2Y0ZDZjNjJjMTM2ODVkNTRhZjJhMjdiZmRlMTk5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNET3BlbkdMLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250 ZXh0M0RPcGVuR0wuY3BwCkBAIC01OSwxMyArNTksNyBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDNE Ojp2YWxpZGF0ZUF0dHJpYnV0ZXMoKQogICAgIEV4dGVuc2lvbnMzRCogZXh0ZW5zaW9ucyA9IGdl dEV4dGVuc2lvbnMoKTsKICAgICB2YWxpZGF0ZURlcHRoU3RlbmNpbCgiR0xfRVhUX3BhY2tlZF9k ZXB0aF9zdGVuY2lsIik7CiAgICAgaWYgKG1fYXR0cnMuYW50aWFsaWFzKSB7Ci0gICAgICAgIGJv b2wgaXNWYWxpZFZlbmRvciA9IHRydWU7Ci0gICAgICAgIC8vIEN1cnJlbnRseSBpbiBNYWMgd2Ug b25seSB0dXJuIG9uIGFudGlhbGlhcyBpZiB2ZW5kb3IgaXMgTlZJRElBLAotICAgICAgICAvLyBv ciBpZiBBVEkgYW5kIG9uIDEwLjcuMiBhbmQgYWJvdmUuCi0gICAgICAgIGNvbnN0IGNoYXIqIHZl bmRvciA9IHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KDo6Z2xHZXRTdHJpbmcoR0xfVkVO RE9SKSk7Ci0gICAgICAgIGlmICghdmVuZG9yIHx8ICghc3RkOjpzdHJzdHIodmVuZG9yLCAiTlZJ RElBIikgJiYgIShzdGQ6OnN0cnN0cih2ZW5kb3IsICJBVEkiKSAmJiBzeXN0ZW1BbGxvd3NNdWx0 aXNhbXBsaW5nT25BVElDYXJkcygpKSkpCi0gICAgICAgICAgICBpc1ZhbGlkVmVuZG9yID0gZmFs c2U7Ci0gICAgICAgIGlmICghaXNWYWxpZFZlbmRvciB8fCAhZXh0ZW5zaW9ucy0+c3VwcG9ydHMo IkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIikgfHwgaXNHTEVTMkNvbXBsaWFudCgp KQorICAgICAgICBpZiAoIWV4dGVuc2lvbnMtPm1heVN1cHBvcnRNdWx0aXNhbXBsaW5nKCkgfHwg IWV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9BTkdMRV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZSIp IHx8IGlzR0xFUzJDb21wbGlhbnQoKSkKICAgICAgICAgICAgIG1fYXR0cnMuYW50aWFsaWFzID0g ZmFsc2U7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGV4dGVuc2lvbnMtPmVuc3VyZUVuYWJs ZWQoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIik7CkBAIC0yODEsMjYgKzI3NSw2 IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OmNsZWFyRGVwdGgoR0MzRGNsYW1wZiBkZXB0aCkK ICAgICA6OmdsQ2xlYXJEZXB0aChkZXB0aCk7CiB9CiAKLWJvb2wgR3JhcGhpY3NDb250ZXh0M0Q6 OnN5c3RlbUFsbG93c011bHRpc2FtcGxpbmdPbkFUSUNhcmRzKCkgY29uc3QKLXsKLSNpZiBQTEFU Rk9STShNQUMpCi0jaWYgUExBVEZPUk0oSU9TKSB8fCBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JF UVVJUkVEID49IDEwODAKLSAgICByZXR1cm4gdHJ1ZTsKLSNlbHNlCi0gICAgQVNTRVJUKGlzTWFp blRocmVhZCgpKTsKLSAgICBzdGF0aWMgU0ludDMyIHZlcnNpb247Ci0gICAgaWYgKCF2ZXJzaW9u KSB7Ci0gICAgICAgIGlmIChHZXN0YWx0KGdlc3RhbHRTeXN0ZW1WZXJzaW9uLCAmdmVyc2lvbikg IT0gbm9FcnIpCi0gICAgICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgfQotICAgIC8vIFNlZSBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzc5MjIgZm9yIG1vcmUgZGV0 YWlscwotICAgIHJldHVybiB2ZXJzaW9uID49IDB4MTA3MjsKLSNlbmRpZiAvLyBTTk9XX0xFT1BB UkQgYW5kIExJT04KLSNlbHNlCi0gICAgcmV0dXJuIGZhbHNlOwotI2VuZGlmIC8vIFBMQVRGT1JN KE1BQykKLX0KLQogRXh0ZW5zaW9uczNEKiBHcmFwaGljc0NvbnRleHQzRDo6Z2V0RXh0ZW5zaW9u cygpCiB7CiAgICAgaWYgKCFtX2V4dGVuc2lvbnMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0xDb21tb24u Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29u dGV4dDNET3BlbkdMQ29tbW9uLmNwcAppbmRleCA0ZmZmZWU0N2QwYmZkYWRjYjliNGZkMjA3OGI5 NjZmNGFkNjFjYWNhLi44YTJhYzgxZTY3NjAxMzM5MmI2NjhjNjdhMGViNWNjZWM5NzMyZmU2IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhp Y3NDb250ZXh0M0RPcGVuR0xDb21tb24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTENvbW1vbi5jcHAKQEAgLTg4 LDEzICs4OCw3IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnZhbGlkYXRlRGVwdGhTdGVuY2ls KGNvbnN0IGNoYXIqIHBhY2tlZERlcHRoU3RlbmNpbEV4dGVuCiAgICAgICAgICAgICBtX2F0dHJz LnN0ZW5jaWwgPSBmYWxzZTsKICAgICB9CiAgICAgaWYgKG1fYXR0cnMuYW50aWFsaWFzKSB7Ci0g ICAgICAgIGJvb2wgaXNWYWxpZFZlbmRvciA9IHRydWU7Ci0gICAgICAgIC8vIEN1cnJlbnRseSBp biBNYWMgd2Ugb25seSB0dXJuIG9uIGFudGlhbGlhcyBpZiB2ZW5kb3IgaXMgTlZJRElBLAotICAg ICAgICAvLyBvciBpZiBBVEkgYW5kIG9uIDEwLjcuMiBhbmQgYWJvdmUuCi0gICAgICAgIGNvbnN0 IGNoYXIqIHZlbmRvciA9IHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KDo6Z2xHZXRTdHJp bmcoR0xfVkVORE9SKSk7Ci0gICAgICAgIGlmICghdmVuZG9yIHx8ICghc3RkOjpzdHJzdHIodmVu ZG9yLCAiTlZJRElBIikgJiYgIShzdGQ6OnN0cnN0cih2ZW5kb3IsICJBVEkiKSAmJiBzeXN0ZW1B bGxvd3NNdWx0aXNhbXBsaW5nT25BVElDYXJkcygpKSkpCi0gICAgICAgICAgICBpc1ZhbGlkVmVu ZG9yID0gZmFsc2U7Ci0gICAgICAgIGlmICghaXNWYWxpZFZlbmRvciB8fCAhZXh0ZW5zaW9ucy0+ c3VwcG9ydHMoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIikgfHwgaXNHTEVTMkNv bXBsaWFudCgpKQorICAgICAgICBpZiAoIWV4dGVuc2lvbnMtPm1heVN1cHBvcnRNdWx0aXNhbXBs aW5nKCkgfHwgIWV4dGVuc2lvbnMtPnN1cHBvcnRzKCJHTF9BTkdMRV9mcmFtZWJ1ZmZlcl9tdWx0 aXNhbXBsZSIpIHx8IGlzR0xFUzJDb21wbGlhbnQoKSkKICAgICAgICAgICAgIG1fYXR0cnMuYW50 aWFsaWFzID0gZmFsc2U7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGV4dGVuc2lvbnMtPmVu c3VyZUVuYWJsZWQoIkdMX0FOR0xFX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlIik7Cg==