209438 2020-03-23 14:26:05 -0700 Fix various compiler warnings 2020-03-26 16:55:13 -0700 1 1 1 Unclassified WebKit WebKit Misc. WebKit Nightly Build PC Linux RESOLVED FIXED InRadar P2 Minor --- 1 mcatanzaro mcatanzaro benjamin cdumez cmarcelo darin esprehn+autocc ews-watchlist fred.wang jamesr kangil.han luiz mcatanzaro tonikitoo webkit-bug-importer oldest_to_newest 1633025 0 mcatanzaro 2020-03-23 14:26:05 -0700 Some of these are new warnings detected by GCC 10. Others are just newly-introduced. Turns out that GCC 10 is a very easy upgrade for us. There is usually a huge spam of new warnings when upgrading to a new major version of GCC. Not this time. 1633027 1 394303 mcatanzaro 2020-03-23 14:30:28 -0700 Created attachment 394303 Patch 1633036 2 394303 darin 2020-03-23 14:40:54 -0700 Comment on attachment 394303 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394303&action=review > Source/WebCore/dom/Element.cpp:3803 > - if (auto* animationData = animationRareData()) > + if (animationRareData()) > return &animationRareData()->webAnimations(); This is the wrong fix to this error. The right fix is to use the local variable on the next line, so the compiler doesn’t have to figure out the function doesn’t have to be called twice. Same for the other 5 instances below. > Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp:114 > + bool monitoringWheelEvents = isMonitoringWheelEvents(); > if (monitoringWheelEvents) No need for the local variable at all. > Source/WebCore/platform/network/HTTPParsers.h:175 > - return WTFMove(set); > + return set; This change seems wrong. The return value optimization doesn’t apply when the local variable type is HashSet and then return value type is Optional<HashSet>. Is GCC really giving a warning here? > Source/WebKit/UIProcess/API/C/WKPage.cpp:1208 > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > auto loaderClient = makeUnique<LoaderClient>(wkClient); > +ALLOW_DEPRECATED_DECLARATIONS_END What’s deprecated? This doesn’t make sense to me. > Source/WebKit/UIProcess/API/C/WKPage.cpp:1292 > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > toImpl(pageRef)->setPolicyClient(makeUnique<PolicyClient>(wkClient)); > +ALLOW_DEPRECATED_DECLARATIONS_END Ditto. 1633052 3 mcatanzaro 2020-03-23 14:58:52 -0700 (In reply to Darin Adler from comment #2) > This is the wrong fix to this error. The right fix is to use the local > variable on the next line, so the compiler doesn’t have to figure out the > function doesn’t have to be called twice. Same for the other 5 instances > below. Oops, yes, good catch! > > Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp:114 > > + bool monitoringWheelEvents = isMonitoringWheelEvents(); > > if (monitoringWheelEvents) > > No need for the local variable at all. Oops, yes, good catch! > > Source/WebCore/platform/network/HTTPParsers.h:175 > > - return WTFMove(set); > > + return set; > > This change seems wrong. The return value optimization doesn’t apply when > the local variable type is HashSet and then return value type is > Optional<HashSet>. Is GCC really giving a warning here? Are you sure that return value optimization doesn't apply? Yes, GCC warns that the move is redundant. I would not bet against GCC here. :) afaik it's never appropriate to use WTFMove() in a return statement? > > Source/WebKit/UIProcess/API/C/WKPage.cpp:1208 > > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > > auto loaderClient = makeUnique<LoaderClient>(wkClient); > > +ALLOW_DEPRECATED_DECLARATIONS_END > > What’s deprecated? This doesn’t make sense to me. GCC 10 is getting really aggressive with -Wdeprecated-declarations: [74/216] Building CXX object Source/WebKit/CMakeFiles/Web...es/WebKit/unified-sources/UnifiedSource-88d1702b-17.cpp.o In file included from DerivedSources/WebKit/unified-sources/UnifiedSource-88d1702b-17.cpp:1: /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp: In function ‘void WKPageSetPageLoaderClient(WKPageRef, const WKPageLoaderClientBase*)’: /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp:1206:36: warning: ‘void WKPageSetPageLoaderClient(WKPageRef, const WKPageLoaderClientBase*)’ is deprecated: use WKPageSetPageNavigationClient [-Wdeprecated-declarations] 1206 | auto loaderClient = makeUnique<LoaderClient>(wkClient); | ^~~~~~~~~~~~ /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp:1058:6: note: declared here 1058 | void WKPageSetPageLoaderClient(WKPageRef pageRef, const WKPageLoaderClientBase* wkClient) | ^~~~~~~~~~~~~~~~~~~~~~~~~ I agree it doesn't make a ton of sense, but it's easy to avoid. > > Source/WebKit/UIProcess/API/C/WKPage.cpp:1292 > > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > > toImpl(pageRef)->setPolicyClient(makeUnique<PolicyClient>(wkClient)); > > +ALLOW_DEPRECATED_DECLARATIONS_END > > Ditto. /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp: In function ‘void WKPageSetPagePolicyClient(WKPageRef, const WKPagePolicyClientBase*)’: /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp:1288:49: warning: ‘void WKPageSetPagePolicyClient(WKPageRef, const WKPagePolicyClientBase*)’ is deprecated: use WKPageSetPageNavigationClient [-Wdeprecated-declarations] 1288 | toImpl(pageRef)->setPolicyClient(makeUnique<PolicyClient>(wkClient)); | ^~~~~~~~~~~~ /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp:1223:6: note: declared here 1223 | void WKPageSetPagePolicyClient(WKPageRef pageRef, const WKPagePolicyClientBase* wkClient) | ^~~~~~~~~~~~~~~~~~~~~~~~~ 1633054 4 mcatanzaro 2020-03-23 15:01:17 -0700 (In reply to Michael Catanzaro from comment #3) > Are you sure that return value optimization doesn't apply? Yes, GCC warns > that the move is redundant. I would not bet against GCC here. :) afaik it's > never appropriate to use WTFMove() in a return statement? It looks like this: [1078/1697] Building CXX object Source/WebCore/CMakeFiles...es/WebCore/unified-sources/UnifiedSource-c57e08af-1.cpp.o In file included from DerivedSources/ForwardingHeaders/wtf/FastMalloc.h:26, from /home/mcatanzaro/Projects/WebKit/Source/WebCore/config.h:56, from /home/mcatanzaro/Projects/WebKit/Source/WebCore/loader/AdClickAttribution.cpp:26, from DerivedSources/WebCore/unified-sources/UnifiedSource-c57e08af-1.cpp:1: /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h: In instantiation of ‘WTF::Optional<WTF::HashSet<WTF::String, HashType> > WebCore::parseAccessControlAllowList(const WTF::String&) [with HashType = WTF::StringHash]’: /home/mcatanzaro/Projects/WebKit/Source/WebCore/loader/CrossOriginPreflightResultCache.cpp:57:115: required from here DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:495:64: warning: redundant move in return statement [-Wredundant-move] 495 | #define WTFMove(value) std::move<WTF::CheckMoveParameter>(value) | ^ /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h:175:12: note: in expansion of macro ‘WTFMove’ 175 | return WTFMove(set); | ^~~~~~~ DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:495:64: note: remove ‘std::move’ call 495 | #define WTFMove(value) std::move<WTF::CheckMoveParameter>(value) | ^ /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h:175:12: note: in expansion of macro ‘WTFMove’ 175 | return WTFMove(set); | ^~~~~~~ /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h: In instantiation of ‘WTF::Optional<WTF::HashSet<WTF::String, HashType> > WebCore::parseAccessControlAllowList(const WTF::String&) [with HashType = WTF::ASCIICaseInsensitiveHash]’: /home/mcatanzaro/Projects/WebKit/Source/WebCore/loader/CrossOriginPreflightResultCache.cpp:61:141: required from here DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:495:64: warning: redundant move in return statement [-Wredundant-move] 495 | #define WTFMove(value) std::move<WTF::CheckMoveParameter>(value) | ^ /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h:175:12: note: in expansion of macro ‘WTFMove’ 175 | return WTFMove(set); | ^~~~~~~ DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:495:64: note: remove ‘std::move’ call 495 | #define WTFMove(value) std::move<WTF::CheckMoveParameter>(value) | ^ /home/mcatanzaro/Projects/WebKit/Source/WebCore/platform/network/HTTPParsers.h:175:12: note: in expansion of macro ‘WTFMove’ 175 | return WTFMove(set); | ^~~~~~~ But it prints in many more places than that, again for each unified source bundle that includes HTTPParsers.h. -Wredundant-move is one of the most common warnings I see, because clang doesn't have this warning (clang only has -Wpessimizing-move) so Apple devs don't notice it. I have a lot of previous commits removing this warning all over the place. 1633055 5 394308 mcatanzaro 2020-03-23 15:04:45 -0700 Created attachment 394308 Patch 1633056 6 darin 2020-03-23 15:06:18 -0700 (In reply to Michael Catanzaro from comment #3) > (In reply to Darin Adler from comment #2) > > > Source/WebCore/platform/network/HTTPParsers.h:175 > > > - return WTFMove(set); > > > + return set; > > > > This change seems wrong. The return value optimization doesn’t apply when > > the local variable type is HashSet and then return value type is > > Optional<HashSet>. Is GCC really giving a warning here? > > Are you sure that return value optimization doesn't apply? Yes, GCC warns > that the move is redundant. I would not bet against GCC here. :) OK. > afaik it's > never appropriate to use WTFMove() in a return statement? I’m sure that broad generalization is wrong. You could have a return statement calling a function that takes an rvalue reference. 1633057 7 darin 2020-03-23 15:09:48 -0700 (In reply to Michael Catanzaro from comment #3) > > > Source/WebKit/UIProcess/API/C/WKPage.cpp:1208 > > > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > > > auto loaderClient = makeUnique<LoaderClient>(wkClient); > > > +ALLOW_DEPRECATED_DECLARATIONS_END > > > > What’s deprecated? This doesn’t make sense to me. > > GCC 10 is getting really aggressive with -Wdeprecated-declarations: > > [74/216] Building CXX object > Source/WebKit/CMakeFiles/Web...es/WebKit/unified-sources/UnifiedSource- > 88d1702b-17.cpp.o > In file included from > DerivedSources/WebKit/unified-sources/UnifiedSource-88d1702b-17.cpp:1: > /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp: > In function ‘void WKPageSetPageLoaderClient(WKPageRef, const > WKPageLoaderClientBase*)’: > /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp: > 1206:36: warning: ‘void WKPageSetPageLoaderClient(WKPageRef, const > WKPageLoaderClientBase*)’ is deprecated: use WKPageSetPageNavigationClient > [-Wdeprecated-declarations] > 1206 | auto loaderClient = makeUnique<LoaderClient>(wkClient); > | ^~~~~~~~~~~~ > /home/mcatanzaro/Projects/WebKit/Source/WebKit/UIProcess/API/C/WKPage.cpp: > 1058:6: note: declared here > 1058 | void WKPageSetPageLoaderClient(WKPageRef pageRef, const > WKPageLoaderClientBase* wkClient) > | ^~~~~~~~~~~~~~~~~~~~~~~~~ > > I agree it doesn't make a ton of sense, but it's easy to avoid. Where’s the call to WKPageSetPageLoaderClient? Seems like this beyond "aggressive", and just a bug, but maybe I’m missing something. 1633061 8 394308 darin 2020-03-23 15:15:35 -0700 Comment on attachment 394308 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394308&action=review Thanks, you resolved most of the issues I brought up in the first patch. > Source/WTF/wtf/ConcurrentBuffer.h:70 > - memcpy(newArray->data, array->data, sizeof(T) * array->size); > + memcpy(static_cast<void*>(newArray->data), array->data, sizeof(T) * array->size); This is peculiar enough that I think we need a comment in the code, not just in the change log. Might also be better to use warning-suppression macros instead of the static_cast. That might be more self-explanatory and possibly could allow us to omit the comment. > Source/WebKit/UIProcess/API/C/WKPage.cpp:1208 > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > auto loaderClient = makeUnique<LoaderClient>(wkClient); > +ALLOW_DEPRECATED_DECLARATIONS_END I’m still not OK with this change. I realize now that this entire function is implementing something deprecated. What I would expect is: ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN ALLOW_DEPRECATED_IMPLEMENTATIONS_END around the entire function. Putting ALLOW_DEPRECATED_DECLARATIONS_BEGIN around this one line makes no sense. > Source/WebKit/UIProcess/API/C/WKPage.cpp:1292 > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > toImpl(pageRef)->setPolicyClient(makeUnique<PolicyClient>(wkClient)); > +ALLOW_DEPRECATED_DECLARATIONS_END Ditto. 1633090 9 mcatanzaro 2020-03-23 15:57:29 -0700 (In reply to Darin Adler from comment #6) > I’m sure that broad generalization is wrong. You could have a return > statement calling a function that takes an rvalue reference. Well yes, of course that's fine. I just mean the final returned result should not use WTFMove(). (In reply to Darin Adler from comment #8) > > Source/WTF/wtf/ConcurrentBuffer.h:70 > > - memcpy(newArray->data, array->data, sizeof(T) * array->size); > > + memcpy(static_cast<void*>(newArray->data), array->data, sizeof(T) * array->size); > > This is peculiar enough that I think we need a comment in the code, not just > in the change log. Might also be better to use warning-suppression macros > instead of the static_cast. That might be more self-explanatory and possibly > could allow us to omit the comment. Hm, your choice! This is what I've historically been doing to suppress -Wclass-memaccess in WebKit, though, and I think it's idiomatic (casting the first arg to memcpy() should be familiar to developers who have seen it used to suppress this warning before): The -Wclass-memaccess option is enabled by -Wall. Explicitly casting the pointer to the class object to "void *" or to a type that can be safely accessed by the raw memory function suppresses the warning. Note that the warning is relatively new (GCC 8, I think) and Clang doesn't have it at all, so I agree the idiom won't be familiar to most developers. And ideally, developers wouldn't write code that triggers this warning in the first place. But we unfortunately have several other suspicious places in WebKit that do. You can find them with: $ cd WebKit/Source/ $ git grep 'static_cast<void\*>' The lines that use memcpy, memmove, memset, etc. are there for this warning. Full docs for this warning: -Wclass-memaccess (C++ and Objective-C++ only) Warn when the destination of a call to a raw memory function such as "memset" or "memcpy" is an object of class type, and when writing into such an object might bypass the class non-trivial or deleted constructor or copy assignment, violate const-correctness or encapsulation, or corrupt virtual table pointers. Modifying the representation of such objects may violate invariants maintained by member functions of the class. For example, the call to "memset" below is undefined because it modifies a non- trivial class object and is, therefore, diagnosed. The safe way to either initialize or clear the storage of objects of such types is by using the appropriate constructor or assignment operator, if one is available. std::string str = "abc"; memset (&str, 0, sizeof str); The -Wclass-memaccess option is enabled by -Wall. Explicitly casting the pointer to the class object to "void *" or to a type that can be safely accessed by the raw memory function suppresses the warning. > > Source/WebKit/UIProcess/API/C/WKPage.cpp:1208 > > +ALLOW_DEPRECATED_DECLARATIONS_BEGIN > > auto loaderClient = makeUnique<LoaderClient>(wkClient); > > +ALLOW_DEPRECATED_DECLARATIONS_END > > I’m still not OK with this change. I realize now that this entire function > is implementing something deprecated. What I would expect is: > > ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN > ALLOW_DEPRECATED_IMPLEMENTATIONS_END > > around the entire function. Putting ALLOW_DEPRECATED_DECLARATIONS_BEGIN > around this one line makes no sense. I agree, the warning does not make sense. :S Using ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN won't do anything, though, because this is not a -Wdeprecated-implementations warning, it's really -Wdeprecated-declarations. (GCC does not have -Wdeprecated-implementations.) I could add magic in Compiler.h to have ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN suppress -Wdeprecated-declarations instead of -Wdeprecated-implementations when the compiler is GCC, if you want. 1634480 10 mcatanzaro 2020-03-26 12:16:44 -0700 Darin, any further comments? If not, I'll add a comment about the static_cast<void*> to address your concern regarding its mysteriousness. I'll prefer to use that rather than add a new IGNORE_WARNINGS macro because static_cast<void*> is idiomatic. Then I won't make any changes to ALLOW_DEPRECATED_DECLARATIONS_BEGIN/END since it seems nicer to use the macro corresponding to the warning we actually want to suppress, rather than change ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN/END to suppress -Wdeprecated-declarations. But if you have other preferences, of course I'll implement what you prefer. 1634514 11 darin 2020-03-26 13:13:49 -0700 (In reply to Michael Catanzaro from comment #10) > If not, I'll add a comment about the static_cast<void*> to address your > concern regarding its mysteriousness. I'll prefer to use that rather than > add a new IGNORE_WARNINGS macro because static_cast<void*> is idiomatic. Not asking you to add a new IGNORE_WARNINGS macro. Could use IGNORE_GCC_WARNINGS_BEGIN/END here. I don’t know what you mean by "is idiomatic", but despite not fully understanding that I won’t try to stand in the way with landing a workaround for the warning as long as there’s a comment. I think, though, that in general, when trying to keep WebKit working with multiple compilers, changing code to sidestep warnings has been slightly more fragile and hard to understand than finding a way to turn the warnings off. > Then I won't make any changes to ALLOW_DEPRECATED_DECLARATIONS_BEGIN/END > since it seems nicer to use the macro corresponding to the warning we > actually want to suppress, rather than change > ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN/END to suppress > -Wdeprecated-declarations. The point of these macros is to create some compiler independence. The fact that on GCC when we try to compile an implementation of a function that we marked as deprecated, we get a "deprecated declaration" warning, is the kind of thing we are trying to abstract away. As I understand it, what this code *does* that is worth warning about is that it *implements* something that is deprecated. So the compiler-independent macro to use is ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN/END. In practice, I don’t know what that will have to expand to for each compiler to make that work, but the point of that macro is to abstract that away. It’s straight-up bizarre to use ALLOW_DEPRECATED_DECLARATIONS_BEGIN/END around a line of code that does *not* use something that’s deprecated. I don’t care if it quiets GCC down or not. It does not make sense. So that’s my thinking on how to quiet these GCC warnings. 1634608 12 mcatanzaro 2020-03-26 15:50:02 -0700 FWIW, I'm pretty sure the -Wdeprecated-declarations warning is a GCC bug. It's not attempting to warn us that we are implementing a deprecated API. It's just getting really confused and somehow accidentally doing that. So my suggestion is to keep using ALLOW_DEPRECATED_DECLARATIONS_BEGIN/END and just add a comment that it's addressing a compiler bug and should be removed in the future. I think this is OK since it's only two places in one file in our entire codebase. But of course I can change it to ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN/END if you want. It's just not what GCC is really trying to warn about. 1634612 13 394665 mcatanzaro 2020-03-26 15:53:09 -0700 Created attachment 394665 Patch 1634637 14 394665 mcatanzaro 2020-03-26 16:36:20 -0700 Comment on attachment 394665 Patch BTW thanks for the thorough reviews, as usual. Helps get the code quality as high as we can. ;) 1634650 15 ews-feeder 2020-03-26 16:54:24 -0700 Committed r259093: <https://trac.webkit.org/changeset/259093> All reviewed patches have been landed. Closing bug and clearing flags on attachment 394665. 1634651 16 webkit-bug-importer 2020-03-26 16:55:13 -0700 <rdar://problem/60943111> 394303 2020-03-23 14:30:28 -0700 2020-03-23 15:04:43 -0700 Patch bug-209438-20200323163028.patch text/plain 7890 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4ODY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGFkNGMyZjk1ODQ5MmEyODAzMDc3MjYx NTY4YTZiODFiNWNkYjM4NDcuLjk3YjE4ZjkwNGZiMmZlYzMwZmE0Y2NmNzU1ZDRmMTVmYmEyOGM3 YmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMjAtMDMtMjMgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgRml4IHZhcmlvdXMgY29tcGlsZXIgd2Fy bmluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw OTQzOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN1 cHByZXNzIC1XY2xhc3MtbWVtYWNjZXNzIHdhcm5pbmcuIENvbmN1cnJlbnRCdWZmZXIgaXMgZG9j dW1lbnRlZCB0byBzdXBwb3J0IHR5cGVzIHRoYXQgYXJlCisgICAgICAgIGJpdC1jb3B5YWJsZSBi dXQgbm90IGNvcHktY29uc3RydWN0YWJsZS4gVGhpcyBpcyBzdHJhbmdlLCBidXQgd2hvIGFtIEkg dG8gcXVlc3Rpb24gaXQ/CisKKyAgICAgICAgKiB3dGYvQ29uY3VycmVudEJ1ZmZlci5oOgorCiAy MDIwLTAzLTIzICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBS ZW5hbWUgYmxhbmtVUkwgdG8gYWJvdXRCbGFua1VSTApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGE3NDk5Y2M3OGQ3 MGIzZGViMjk0MTNlOGVmZTg5YWI0MjIyM2NiMDcuLjkwOWRkOGY0MTVkNTk2NmI3YTEyNTQwYmI0 MDMyZjJiMWVmODcxNmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAyMC0wMy0yMyAg TWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAgICAgICBGaXgg dmFyaW91cyBjb21waWxlciB3YXJuaW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjA5NDM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgKiBkb20vRWxlbWVudC5jcHA6IEZpeCAtV3VudXNlZC12YXJpYWJs ZSB3YXJuaW5ncy4KKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6OndlYkFuaW1hdGlvbnMgY29u c3QpOgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6Y3NzQW5pbWF0aW9ucyBjb25zdCk6Cisg ICAgICAgIChXZWJDb3JlOjpFbGVtZW50Ojp0cmFuc2l0aW9ucyBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpFbGVtZW50OjpoYXNDb21wbGV0ZWRUcmFuc2l0aW9uc0ZvclByb3BlcnR5IGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6Omhhc1J1bm5pbmdUcmFuc2l0aW9uc0ZvclBy b3BlcnR5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6Omhhc1J1bm5pbmdUcmFu c2l0aW9ucyBjb25zdCk6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvVGhyZWFkZWRTY3JvbGxp bmdUcmVlLmNwcDogRml4IC1XdW51c2VkLXZhcmlhYmxlIHdhcm5pbmcuCisgICAgICAgIChXZWJD b3JlOjpUaHJlYWRlZFNjcm9sbGluZ1RyZWU6OnNjcm9sbGluZ1RyZWVOb2RlRGlkU2Nyb2xsKToK KyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJzZXJzLmg6IEZpeCAtV3JlZHVuZGFu dC1tb3ZlIHdhcm5pbmcuCisgICAgICAgIChXZWJDb3JlOjpwYXJzZUFjY2Vzc0NvbnRyb2xBbGxv d0xpc3QpOgorCiAyMDIwLTAzLTIzICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4K IAogICAgICAgICBSZW5hbWUgYmxhbmtVUkwgdG8gYWJvdXRCbGFua1VSTApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCAz MGY5MWMzY2ZmNmE4NmVmNWI5NmEyZjlkNzc5MGRkYmU4YThkOWE3Li42MjMzMDliOTZlNWY1NjQ2 MjdkYzFkZGExZGVlYjRiOTVjNTA4NzlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDIw LTAzLTIzICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25vbWUub3JnPgorCisgICAg ICAgIEZpeCB2YXJpb3VzIGNvbXBpbGVyIHdhcm5pbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDk0MzgKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvQy9XS1BhZ2UuY3BwOiBJ Z25vcmUgLVdkZXByZWNhdGVkLWRlY2xhcmF0aW9uIHdhcm5pbmdzLgorICAgICAgICAoV0tQYWdl U2V0UGFnZUxvYWRlckNsaWVudCk6CisgICAgICAgIChXS1BhZ2VTZXRQYWdlUG9saWN5Q2xpZW50 KToKKwogMjAyMC0wMy0yMyAgeW91ZW5uIGZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+CiAKICAg ICAgICAgUmVuYW1lIGJsYW5rVVJMIHRvIGFib3V0QmxhbmtVUkwKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XVEYvd3RmL0NvbmN1cnJlbnRCdWZmZXIuaCBiL1NvdXJjZS9XVEYvd3RmL0NvbmN1cnJlbnRC dWZmZXIuaAppbmRleCBmNTc0OGYxYTIwNTMyYzZkMWY2MjNmYWEwZGQ1YmExNDQzOWVlMzU5Li4z NTljNWY3OGRhY2NkYzhmNzgzNDIzYzc3OTlkYTU0N2MyNzBhZmViIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV1RGL3d0Zi9Db25jdXJyZW50QnVmZmVyLmgKKysrIGIvU291cmNlL1dURi93dGYvQ29uY3Vy cmVudEJ1ZmZlci5oCkBAIC02Nyw3ICs2Nyw3IEBAIHB1YmxpYzoKICAgICAgICAgQXJyYXkqIG5l d0FycmF5ID0gY3JlYXRlQXJyYXkobmV3U2l6ZSk7CiAgICAgICAgIC8vIFRoaXMgYWxsb3dzIHVz IHRvIGRvIENvbmN1cnJlbnRCdWZmZXI8c3RkOjp1bmlxdWVfcHRyPD4+LgogICAgICAgICBpZiAo YXJyYXkpCi0gICAgICAgICAgICBtZW1jcHkobmV3QXJyYXktPmRhdGEsIGFycmF5LT5kYXRhLCBz aXplb2YoVCkgKiBhcnJheS0+c2l6ZSk7CisgICAgICAgICAgICBtZW1jcHkoc3RhdGljX2Nhc3Q8 dm9pZCo+KG5ld0FycmF5LT5kYXRhKSwgYXJyYXktPmRhdGEsIHNpemVvZihUKSAqIGFycmF5LT5z aXplKTsKICAgICAgICAgZm9yIChzaXplX3QgaSA9IGFycmF5ID8gYXJyYXktPnNpemUgOiAwOyBp IDwgbmV3U2l6ZTsgKytpKQogICAgICAgICAgICAgbmV3IChuZXdBcnJheS0+ZGF0YSArIGkpIFQo KTsKICAgICAgICAgV1RGOjpzdG9yZVN0b3JlRmVuY2UoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2RvbS9FbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcApp bmRleCBiNjRlYmIxMjM5YjEzOTU2YWU0NGEyMzRlMTUyNzI5NGY2ZTI3NDllLi5kNGQ3YjE0M2Uw ODI1YTgzZGRiMjgyMjZkYTc0MzE2MWM1ODlhYTBjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9kb20vRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuY3BwCkBA IC0zNzk5LDQyICszNzk5LDQyIEBAIE9wdGlvblNldDxBbmltYXRpb25JbXBhY3Q+IEVsZW1lbnQ6 OmFwcGx5S2V5ZnJhbWVFZmZlY3RzKFJlbmRlclN0eWxlJiB0YXJnZXRTdHlsCiAKIGNvbnN0IEFu aW1hdGlvbkNvbGxlY3Rpb24qIEVsZW1lbnQ6OndlYkFuaW1hdGlvbnMoKSBjb25zdAogewotICAg IGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKKyAgICBpZiAo YW5pbWF0aW9uUmFyZURhdGEoKSkKICAgICAgICAgcmV0dXJuICZhbmltYXRpb25SYXJlRGF0YSgp LT53ZWJBbmltYXRpb25zKCk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKIGNvbnN0IEFuaW1h dGlvbkNvbGxlY3Rpb24qIEVsZW1lbnQ6OmNzc0FuaW1hdGlvbnMoKSBjb25zdAogewotICAgIGlm IChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKKyAgICBpZiAoYW5p bWF0aW9uUmFyZURhdGEoKSkKICAgICAgICAgcmV0dXJuICZhbmltYXRpb25SYXJlRGF0YSgpLT5j c3NBbmltYXRpb25zKCk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKIGNvbnN0IEFuaW1hdGlv bkNvbGxlY3Rpb24qIEVsZW1lbnQ6OnRyYW5zaXRpb25zKCkgY29uc3QKIHsKLSAgICBpZiAoYXV0 byogYW5pbWF0aW9uRGF0YSA9IGFuaW1hdGlvblJhcmVEYXRhKCkpCisgICAgaWYgKGFuaW1hdGlv blJhcmVEYXRhKCkpCiAgICAgICAgIHJldHVybiAmYW5pbWF0aW9uUmFyZURhdGEoKS0+dHJhbnNp dGlvbnMoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNDb21w bGV0ZWRUcmFuc2l0aW9uc0ZvclByb3BlcnR5KENTU1Byb3BlcnR5SUQgcHJvcGVydHkpIGNvbnN0 CiB7Ci0gICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0YSgpKQor ICAgIGlmIChhbmltYXRpb25SYXJlRGF0YSgpKQogICAgICAgICByZXR1cm4gYW5pbWF0aW9uUmFy ZURhdGEoKS0+Y29tcGxldGVkVHJhbnNpdGlvbnNCeVByb3BlcnR5KCkuY29udGFpbnMocHJvcGVy dHkpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNSdW5uaW5nVHJh bnNpdGlvbnNGb3JQcm9wZXJ0eShDU1NQcm9wZXJ0eUlEIHByb3BlcnR5KSBjb25zdAogewotICAg IGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKKyAgICBpZiAo YW5pbWF0aW9uUmFyZURhdGEoKSkKICAgICAgICAgcmV0dXJuIGFuaW1hdGlvblJhcmVEYXRhKCkt PnJ1bm5pbmdUcmFuc2l0aW9uc0J5UHJvcGVydHkoKS5jb250YWlucyhwcm9wZXJ0eSk7CiAgICAg cmV0dXJuIGZhbHNlOwogfQogCiBib29sIEVsZW1lbnQ6Omhhc1J1bm5pbmdUcmFuc2l0aW9ucygp IGNvbnN0CiB7Ci0gICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0 YSgpKQorICAgIGlmIChhbmltYXRpb25SYXJlRGF0YSgpKQogICAgICAgICByZXR1cm4gIWFuaW1h dGlvblJhcmVEYXRhKCktPnJ1bm5pbmdUcmFuc2l0aW9uc0J5UHJvcGVydHkoKS5pc0VtcHR5KCk7 CiAgICAgcmV0dXJuIGZhbHNlOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9z Y3JvbGxpbmcvVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv c2Nyb2xsaW5nL1RocmVhZGVkU2Nyb2xsaW5nVHJlZS5jcHAKaW5kZXggNzI4YWIwOThlNjNjZTM5 NTEyMzViNTFkOTdhNTVhMTk2NzEzYWRmNi4uMzBhYmQ4MDJjMjQ2Yzg2NzE4ZGNjMzE2M2FhMjU2 YTU5NWMyOTRmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvVGhy ZWFkZWRTY3JvbGxpbmdUcmVlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGlu Zy9UaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3BwCkBAIC0xMDksOSArMTA5LDggQEAgdm9pZCBUaHJl YWRlZFNjcm9sbGluZ1RyZWU6OnNjcm9sbGluZ1RyZWVOb2RlRGlkU2Nyb2xsKFNjcm9sbGluZ1Ry ZWVTY3JvbGxpbmdOb2QKICAgICBpZiAoaXM8U2Nyb2xsaW5nVHJlZUZyYW1lU2Nyb2xsaW5nTm9k ZT4obm9kZSkpCiAgICAgICAgIGxheW91dFZpZXdwb3J0T3JpZ2luID0gZG93bmNhc3Q8U2Nyb2xs aW5nVHJlZUZyYW1lU2Nyb2xsaW5nTm9kZT4obm9kZSkubGF5b3V0Vmlld3BvcnQoKS5sb2NhdGlv bigpOwogCi0gICAgYm9vbCBtb25pdG9yaW5nV2hlZWxFdmVudHMgPSBmYWxzZTsKICNpZiBQTEFU Rk9STShNQUMpCi0gICAgbW9uaXRvcmluZ1doZWVsRXZlbnRzID0gaXNNb25pdG9yaW5nV2hlZWxF dmVudHMoKTsKKyAgICBib29sIG1vbml0b3JpbmdXaGVlbEV2ZW50cyA9IGlzTW9uaXRvcmluZ1do ZWVsRXZlbnRzKCk7CiAgICAgaWYgKG1vbml0b3JpbmdXaGVlbEV2ZW50cykKICAgICAgICAgZGVm ZXJXaGVlbEV2ZW50VGVzdENvbXBsZXRpb25Gb3JSZWFzb24ocmVpbnRlcnByZXRfY2FzdDxXaGVl bEV2ZW50VGVzdE1vbml0b3I6OlNjcm9sbGFibGVBcmVhSWRlbnRpZmllcj4obm9kZS5zY3JvbGxp bmdOb2RlSUQoKSksIFdoZWVsRXZlbnRUZXN0TW9uaXRvcjo6U2Nyb2xsaW5nVGhyZWFkU3luY05l ZWRlZCk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvSFRUUFBhcnNlcnMuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUFBh cnNlcnMuaAppbmRleCAyMGRiNzM5MWU3ZTJkMGYzOTQ2OGU5NTc0MmRhNDk5ZGEyMjFhNzhlLi5m ZjBhZjgzNTUzNGZmYjQwY2ZlOTA2ZTc3NDVjYzc4MzU0MjY3ZGM4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJzZXJzLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQUGFyc2Vycy5oCkBAIC0xNzIsNyArMTcyLDcgQEAg T3B0aW9uYWw8SGFzaFNldDxTdHJpbmcsIEhhc2hUeXBlPj4gcGFyc2VBY2Nlc3NDb250cm9sQWxs b3dMaXN0KGNvbnN0IFN0cmluZyYgc3QKICAgICAgICAgaWYgKCFhZGRUb0FjY2Vzc0NvbnRyb2xB bGxvd0xpc3Qoc3RyaW5nLCBzdGFydCwgc3RyaW5nLmxlbmd0aCgpIC0gMSwgc2V0KSkKICAgICAg ICAgICAgIHJldHVybiB7IH07CiAgICAgfQotICAgIHJldHVybiBXVEZNb3ZlKHNldCk7CisgICAg cmV0dXJuIHNldDsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv QVBJL0MvV0tQYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUGFnZS5j cHAKaW5kZXggOWNhMDNiNjAxZmMwMTc3N2ZkZTk5ZTk3ZmExZDU0NDZmMzEzZGJjZS4uZjM5YzIw MWJkYTA5OTU4MDFhMDI4MDY5ZmM1NjZiZWU5NTZlNzkxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvQVBJL0MvV0tQYWdlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQy9XS1BhZ2UuY3BwCkBAIC0xMjAzLDcgKzEyMDMsOSBAQCB2b2lkIFdLUGFnZVNl dFBhZ2VMb2FkZXJDbGllbnQoV0tQYWdlUmVmIHBhZ2VSZWYsIGNvbnN0IFdLUGFnZUxvYWRlckNs aWVudEJhc2UqCiAKICAgICBXZWJQYWdlUHJveHkqIHdlYlBhZ2VQcm94eSA9IHRvSW1wbChwYWdl UmVmKTsKIAorQUxMT1dfREVQUkVDQVRFRF9ERUNMQVJBVElPTlNfQkVHSU4KICAgICBhdXRvIGxv YWRlckNsaWVudCA9IG1ha2VVbmlxdWU8TG9hZGVyQ2xpZW50Pih3a0NsaWVudCk7CitBTExPV19E RVBSRUNBVEVEX0RFQ0xBUkFUSU9OU19FTkQKIAogICAgIC8vIEl0IHdvdWxkIGJlIG5pY2UgdG8g Z2V0IHJpZCBvZiB0aGlzIGNvZGUgYW5kIHRyYW5zaXRpb24gYWxsIGNsaWVudHMgdG8gdXNpbmcg ZGlkTGF5b3V0IGluc3RlYWQgb2YKICAgICAvLyBkaWRGaXJzdExheW91dEluRnJhbWUgYW5kIGRp ZEZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEluRnJhbWUuIEluIHRoZSBtZWFudGltZSwgdGhp cyBpcyByZXF1aXJlZApAQCAtMTI4NSw3ICsxMjg3LDkgQEAgdm9pZCBXS1BhZ2VTZXRQYWdlUG9s aWN5Q2xpZW50KFdLUGFnZVJlZiBwYWdlUmVmLCBjb25zdCBXS1BhZ2VQb2xpY3lDbGllbnRCYXNl KgogICAgICAgICB9CiAgICAgfTsKIAorQUxMT1dfREVQUkVDQVRFRF9ERUNMQVJBVElPTlNfQkVH SU4KICAgICB0b0ltcGwocGFnZVJlZiktPnNldFBvbGljeUNsaWVudChtYWtlVW5pcXVlPFBvbGlj eUNsaWVudD4od2tDbGllbnQpKTsKK0FMTE9XX0RFUFJFQ0FURURfREVDTEFSQVRJT05TX0VORAog fQogCiBuYW1lc3BhY2UgV2ViS2l0IHsK 394308 2020-03-23 15:04:45 -0700 2020-03-26 15:53:06 -0700 Patch bug-209438-20200323170444.patch text/plain 8137 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4ODc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGFkNGMyZjk1ODQ5MmEyODAzMDc3MjYx NTY4YTZiODFiNWNkYjM4NDcuLjk3YjE4ZjkwNGZiMmZlYzMwZmE0Y2NmNzU1ZDRmMTVmYmEyOGM3 YmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMjAtMDMtMjMgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgRml4IHZhcmlvdXMgY29tcGlsZXIgd2Fy bmluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw OTQzOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN1 cHByZXNzIC1XY2xhc3MtbWVtYWNjZXNzIHdhcm5pbmcuIENvbmN1cnJlbnRCdWZmZXIgaXMgZG9j dW1lbnRlZCB0byBzdXBwb3J0IHR5cGVzIHRoYXQgYXJlCisgICAgICAgIGJpdC1jb3B5YWJsZSBi dXQgbm90IGNvcHktY29uc3RydWN0YWJsZS4gVGhpcyBpcyBzdHJhbmdlLCBidXQgd2hvIGFtIEkg dG8gcXVlc3Rpb24gaXQ/CisKKyAgICAgICAgKiB3dGYvQ29uY3VycmVudEJ1ZmZlci5oOgorCiAy MDIwLTAzLTIzICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBS ZW5hbWUgYmxhbmtVUkwgdG8gYWJvdXRCbGFua1VSTApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDhmZTJlZWVmNmVk MzM2M2M1MDc5MTIxOTVlNTY1ZGIyMThhNGQwMzEuLmU4ZmFkYzNkNzg1MDhkNDQ5NjgzYTkzNGY5 MDQxMzkzN2VjNWQ0YzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAyMC0wMy0yMyAg TWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAgICAgICBGaXgg dmFyaW91cyBjb21waWxlciB3YXJuaW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjA5NDM4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgKiBkb20vRWxlbWVudC5jcHA6IEZpeCAtV3VudXNlZC12YXJpYWJs ZSB3YXJuaW5ncy4KKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6OndlYkFuaW1hdGlvbnMgY29u c3QpOgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6Y3NzQW5pbWF0aW9ucyBjb25zdCk6Cisg ICAgICAgIChXZWJDb3JlOjpFbGVtZW50Ojp0cmFuc2l0aW9ucyBjb25zdCk6CisgICAgICAgIChX ZWJDb3JlOjpFbGVtZW50OjpoYXNDb21wbGV0ZWRUcmFuc2l0aW9uc0ZvclByb3BlcnR5IGNvbnN0 KToKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6Omhhc1J1bm5pbmdUcmFuc2l0aW9uc0ZvclBy b3BlcnR5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6Omhhc1J1bm5pbmdUcmFu c2l0aW9ucyBjb25zdCk6CisgICAgICAgICogcGFnZS9zY3JvbGxpbmcvVGhyZWFkZWRTY3JvbGxp bmdUcmVlLmNwcDogRml4IC1XdW51c2VkLXZhcmlhYmxlIHdhcm5pbmcuCisgICAgICAgIChXZWJD b3JlOjpUaHJlYWRlZFNjcm9sbGluZ1RyZWU6OnNjcm9sbGluZ1RyZWVOb2RlRGlkU2Nyb2xsKToK KyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJzZXJzLmg6IEZpeCAtV3JlZHVuZGFu dC1tb3ZlIHdhcm5pbmcuCisgICAgICAgIChXZWJDb3JlOjpwYXJzZUFjY2Vzc0NvbnRyb2xBbGxv d0xpc3QpOgorCiAyMDIwLTAzLTIzICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25v bWUub3JnPgogCiAgICAgICAgIFtHVEtdIEFsbG93IGRpc3RyaWJ1dG9ycyB0byBicmFuZCB1c2Vy IGFnZW50CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJL aXQvQ2hhbmdlTG9nCmluZGV4IDc3NDliZjNkNTE4YTMwY2Q0Mjc4Yzg1MjQ0YThkOWY4YjQwYzNl ODAuLjQ0ZTE2NGRmNmQ4YjBiZjkzNTA4NGIzOWExMTI0ZjFhNWUzOTc1MWIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTQgQEAKKzIwMjAtMDMtMjMgIE1pY2hhZWwgQ2F0YW56YXJvICA8bWNhdGFuemFy b0Bnbm9tZS5vcmc+CisKKyAgICAgICAgRml4IHZhcmlvdXMgY29tcGlsZXIgd2FybmluZ3MKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwOTQzOAorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9DL1dLUGFnZS5jcHA6IElnbm9yZSAtV2RlcHJlY2F0ZWQtZGVjbGFyYXRpb24gd2Fybmlu Z3MuCisgICAgICAgIChXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KToKKyAgICAgICAgKFdLUGFn ZVNldFBhZ2VQb2xpY3lDbGllbnQpOgorCiAyMDIwLTAzLTIzICBEYW5pZWwgQmF0ZXMgIDxkYWJh dGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBTdXBwb3J0IGluc2VydGluZyB0ZXh0IG9yIGRpY3Rh dGlvbiBhbHRlcm5hdGl2ZSBieSBzaW11bGF0aW5nIGtleWJvYXJkIGlucHV0CmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9Db25jdXJyZW50QnVmZmVyLmggYi9Tb3VyY2UvV1RGL3d0Zi9Db25j dXJyZW50QnVmZmVyLmgKaW5kZXggZjU3NDhmMWEyMDUzMmM2ZDFmNjIzZmFhMGRkNWJhMTQ0Mzll ZTM1OS4uMzU5YzVmNzhkYWNjZGM4Zjc4MzQyM2M3Nzk5ZGE1NDdjMjcwYWZlYiAxMDA2NDQKLS0t IGEvU291cmNlL1dURi93dGYvQ29uY3VycmVudEJ1ZmZlci5oCisrKyBiL1NvdXJjZS9XVEYvd3Rm L0NvbmN1cnJlbnRCdWZmZXIuaApAQCAtNjcsNyArNjcsNyBAQCBwdWJsaWM6CiAgICAgICAgIEFy cmF5KiBuZXdBcnJheSA9IGNyZWF0ZUFycmF5KG5ld1NpemUpOwogICAgICAgICAvLyBUaGlzIGFs bG93cyB1cyB0byBkbyBDb25jdXJyZW50QnVmZmVyPHN0ZDo6dW5pcXVlX3B0cjw+Pi4KICAgICAg ICAgaWYgKGFycmF5KQotICAgICAgICAgICAgbWVtY3B5KG5ld0FycmF5LT5kYXRhLCBhcnJheS0+ ZGF0YSwgc2l6ZW9mKFQpICogYXJyYXktPnNpemUpOworICAgICAgICAgICAgbWVtY3B5KHN0YXRp Y19jYXN0PHZvaWQqPihuZXdBcnJheS0+ZGF0YSksIGFycmF5LT5kYXRhLCBzaXplb2YoVCkgKiBh cnJheS0+c2l6ZSk7CiAgICAgICAgIGZvciAoc2l6ZV90IGkgPSBhcnJheSA/IGFycmF5LT5zaXpl IDogMDsgaSA8IG5ld1NpemU7ICsraSkKICAgICAgICAgICAgIG5ldyAobmV3QXJyYXktPmRhdGEg KyBpKSBUKCk7CiAgICAgICAgIFdURjo6c3RvcmVTdG9yZUZlbmNlKCk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVu dC5jcHAKaW5kZXggYjY0ZWJiMTIzOWIxMzk1NmFlNDRhMjM0ZTE1MjcyOTRmNmUyNzQ5ZS4uNjBi ZmM3MTQ4ZjMwZjY0M2Q0YTVkZjRmZDMxN2ZiMDdkNzE5Mzc2YyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL0VsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50 LmNwcApAQCAtMzgwMCw0MiArMzgwMCw0MiBAQCBPcHRpb25TZXQ8QW5pbWF0aW9uSW1wYWN0PiBF bGVtZW50OjphcHBseUtleWZyYW1lRWZmZWN0cyhSZW5kZXJTdHlsZSYgdGFyZ2V0U3R5bAogY29u c3QgQW5pbWF0aW9uQ29sbGVjdGlvbiogRWxlbWVudDo6d2ViQW5pbWF0aW9ucygpIGNvbnN0CiB7 CiAgICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0YSgpKQotICAg ICAgICByZXR1cm4gJmFuaW1hdGlvblJhcmVEYXRhKCktPndlYkFuaW1hdGlvbnMoKTsKKyAgICAg ICAgcmV0dXJuICZhbmltYXRpb25EYXRhLT53ZWJBbmltYXRpb25zKCk7CiAgICAgcmV0dXJuIG51 bGxwdHI7CiB9CiAKIGNvbnN0IEFuaW1hdGlvbkNvbGxlY3Rpb24qIEVsZW1lbnQ6OmNzc0FuaW1h dGlvbnMoKSBjb25zdAogewogICAgIGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9u UmFyZURhdGEoKSkKLSAgICAgICAgcmV0dXJuICZhbmltYXRpb25SYXJlRGF0YSgpLT5jc3NBbmlt YXRpb25zKCk7CisgICAgICAgIHJldHVybiAmYW5pbWF0aW9uRGF0YS0+Y3NzQW5pbWF0aW9ucygp OwogICAgIHJldHVybiBudWxscHRyOwogfQogCiBjb25zdCBBbmltYXRpb25Db2xsZWN0aW9uKiBF bGVtZW50Ojp0cmFuc2l0aW9ucygpIGNvbnN0CiB7CiAgICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRh dGEgPSBhbmltYXRpb25SYXJlRGF0YSgpKQotICAgICAgICByZXR1cm4gJmFuaW1hdGlvblJhcmVE YXRhKCktPnRyYW5zaXRpb25zKCk7CisgICAgICAgIHJldHVybiAmYW5pbWF0aW9uRGF0YS0+dHJh bnNpdGlvbnMoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXND b21wbGV0ZWRUcmFuc2l0aW9uc0ZvclByb3BlcnR5KENTU1Byb3BlcnR5SUQgcHJvcGVydHkpIGNv bnN0CiB7CiAgICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0YSgp KQotICAgICAgICByZXR1cm4gYW5pbWF0aW9uUmFyZURhdGEoKS0+Y29tcGxldGVkVHJhbnNpdGlv bnNCeVByb3BlcnR5KCkuY29udGFpbnMocHJvcGVydHkpOworICAgICAgICByZXR1cm4gYW5pbWF0 aW9uRGF0YS0+Y29tcGxldGVkVHJhbnNpdGlvbnNCeVByb3BlcnR5KCkuY29udGFpbnMocHJvcGVy dHkpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNSdW5uaW5nVHJh bnNpdGlvbnNGb3JQcm9wZXJ0eShDU1NQcm9wZXJ0eUlEIHByb3BlcnR5KSBjb25zdAogewogICAg IGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKLSAgICAgICAg cmV0dXJuIGFuaW1hdGlvblJhcmVEYXRhKCktPnJ1bm5pbmdUcmFuc2l0aW9uc0J5UHJvcGVydHko KS5jb250YWlucyhwcm9wZXJ0eSk7CisgICAgICAgIHJldHVybiBhbmltYXRpb25EYXRhLT5ydW5u aW5nVHJhbnNpdGlvbnNCeVByb3BlcnR5KCkuY29udGFpbnMocHJvcGVydHkpOwogICAgIHJldHVy biBmYWxzZTsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNSdW5uaW5nVHJhbnNpdGlvbnMoKSBjb25z dAogewogICAgIGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkK LSAgICAgICAgcmV0dXJuICFhbmltYXRpb25SYXJlRGF0YSgpLT5ydW5uaW5nVHJhbnNpdGlvbnNC eVByb3BlcnR5KCkuaXNFbXB0eSgpOworICAgICAgICByZXR1cm4gIWFuaW1hdGlvbkRhdGEtPnJ1 bm5pbmdUcmFuc2l0aW9uc0J5UHJvcGVydHkoKS5pc0VtcHR5KCk7CiAgICAgcmV0dXJuIGZhbHNl OwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9UaHJlYWRl ZFNjcm9sbGluZ1RyZWUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvVGhyZWFk ZWRTY3JvbGxpbmdUcmVlLmNwcAppbmRleCA3MjhhYjA5OGU2M2NlMzk1MTIzNWI1MWQ5N2E1NWEx OTY3MTNhZGY2Li4xZDdjMzM1Mzk3ZDcyN2Y1ZTFlZWM1MTNlMDZmZTk5Y2M1Y2Q4NjY2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9UaHJlYWRlZFNjcm9sbGluZ1Ry ZWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1RocmVhZGVkU2Nyb2xs aW5nVHJlZS5jcHAKQEAgLTEwOSwxMCArMTA5LDggQEAgdm9pZCBUaHJlYWRlZFNjcm9sbGluZ1Ry ZWU6OnNjcm9sbGluZ1RyZWVOb2RlRGlkU2Nyb2xsKFNjcm9sbGluZ1RyZWVTY3JvbGxpbmdOb2QK ICAgICBpZiAoaXM8U2Nyb2xsaW5nVHJlZUZyYW1lU2Nyb2xsaW5nTm9kZT4obm9kZSkpCiAgICAg ICAgIGxheW91dFZpZXdwb3J0T3JpZ2luID0gZG93bmNhc3Q8U2Nyb2xsaW5nVHJlZUZyYW1lU2Ny b2xsaW5nTm9kZT4obm9kZSkubGF5b3V0Vmlld3BvcnQoKS5sb2NhdGlvbigpOwogCi0gICAgYm9v bCBtb25pdG9yaW5nV2hlZWxFdmVudHMgPSBmYWxzZTsKICNpZiBQTEFURk9STShNQUMpCi0gICAg bW9uaXRvcmluZ1doZWVsRXZlbnRzID0gaXNNb25pdG9yaW5nV2hlZWxFdmVudHMoKTsKLSAgICBp ZiAobW9uaXRvcmluZ1doZWVsRXZlbnRzKQorICAgIGlmIChpc01vbml0b3JpbmdXaGVlbEV2ZW50 cygpKQogICAgICAgICBkZWZlcldoZWVsRXZlbnRUZXN0Q29tcGxldGlvbkZvclJlYXNvbihyZWlu dGVycHJldF9jYXN0PFdoZWVsRXZlbnRUZXN0TW9uaXRvcjo6U2Nyb2xsYWJsZUFyZWFJZGVudGlm aWVyPihub2RlLnNjcm9sbGluZ05vZGVJRCgpKSwgV2hlZWxFdmVudFRlc3RNb25pdG9yOjpTY3Jv bGxpbmdUaHJlYWRTeW5jTmVlZGVkKTsKICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJzZXJzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL0hUVFBQYXJzZXJzLmgKaW5kZXggMjBkYjczOTFlN2UyZDBmMzk0NjhlOTU3 NDJkYTQ5OWRhMjIxYTc4ZS4uZmYwYWY4MzU1MzRmZmI0MGNmZTkwNmU3NzQ1Y2M3ODM1NDI2N2Rj OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQUGFyc2Vy cy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUFBhcnNlcnMuaApA QCAtMTcyLDcgKzE3Miw3IEBAIE9wdGlvbmFsPEhhc2hTZXQ8U3RyaW5nLCBIYXNoVHlwZT4+IHBh cnNlQWNjZXNzQ29udHJvbEFsbG93TGlzdChjb25zdCBTdHJpbmcmIHN0CiAgICAgICAgIGlmICgh YWRkVG9BY2Nlc3NDb250cm9sQWxsb3dMaXN0KHN0cmluZywgc3RhcnQsIHN0cmluZy5sZW5ndGgo KSAtIDEsIHNldCkpCiAgICAgICAgICAgICByZXR1cm4geyB9OwogICAgIH0KLSAgICByZXR1cm4g V1RGTW92ZShzZXQpOworICAgIHJldHVybiBzZXQ7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUGFnZS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9BUEkvQy9XS1BhZ2UuY3BwCmluZGV4IDljYTAzYjYwMWZjMDE3NzdmZGU5OWU5N2ZhMWQ1 NDQ2ZjMxM2RiY2UuLmYzOWMyMDFiZGEwOTk1ODAxYTAyODA2OWZjNTY2YmVlOTU2ZTc5MTkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9DL1dLUGFnZS5jcHAKKysrIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL0MvV0tQYWdlLmNwcApAQCAtMTIwMyw3ICsxMjAz LDkgQEAgdm9pZCBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KFdLUGFnZVJlZiBwYWdlUmVmLCBj b25zdCBXS1BhZ2VMb2FkZXJDbGllbnRCYXNlKgogCiAgICAgV2ViUGFnZVByb3h5KiB3ZWJQYWdl UHJveHkgPSB0b0ltcGwocGFnZVJlZik7CiAKK0FMTE9XX0RFUFJFQ0FURURfREVDTEFSQVRJT05T X0JFR0lOCiAgICAgYXV0byBsb2FkZXJDbGllbnQgPSBtYWtlVW5pcXVlPExvYWRlckNsaWVudD4o d2tDbGllbnQpOworQUxMT1dfREVQUkVDQVRFRF9ERUNMQVJBVElPTlNfRU5ECiAKICAgICAvLyBJ dCB3b3VsZCBiZSBuaWNlIHRvIGdldCByaWQgb2YgdGhpcyBjb2RlIGFuZCB0cmFuc2l0aW9uIGFs bCBjbGllbnRzIHRvIHVzaW5nIGRpZExheW91dCBpbnN0ZWFkIG9mCiAgICAgLy8gZGlkRmlyc3RM YXlvdXRJbkZyYW1lIGFuZCBkaWRGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXRJbkZyYW1lLiBJ biB0aGUgbWVhbnRpbWUsIHRoaXMgaXMgcmVxdWlyZWQKQEAgLTEyODUsNyArMTI4Nyw5IEBAIHZv aWQgV0tQYWdlU2V0UGFnZVBvbGljeUNsaWVudChXS1BhZ2VSZWYgcGFnZVJlZiwgY29uc3QgV0tQ YWdlUG9saWN5Q2xpZW50QmFzZSoKICAgICAgICAgfQogICAgIH07CiAKK0FMTE9XX0RFUFJFQ0FU RURfREVDTEFSQVRJT05TX0JFR0lOCiAgICAgdG9JbXBsKHBhZ2VSZWYpLT5zZXRQb2xpY3lDbGll bnQobWFrZVVuaXF1ZTxQb2xpY3lDbGllbnQ+KHdrQ2xpZW50KSk7CitBTExPV19ERVBSRUNBVEVE X0RFQ0xBUkFUSU9OU19FTkQKIH0KIAogbmFtZXNwYWNlIFdlYktpdCB7Cg== 394665 2020-03-26 15:53:09 -0700 2020-03-26 16:54:25 -0700 Patch bug-209438-20200326175308.patch text/plain 8889 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MDgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDljMmRmYWU4NmY1NTk1YzNhMTI3NDA4 NGYwNDM3Y2U3OGNjYWFjMzIuLmQ2Y2IxMDFlMmYyNmQ1OGQyYzlkMmY2N2JiMjgwNTVlNGQ4ZTVi MzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMjAtMDMtMjYgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgRml4IHZhcmlvdXMgY29tcGlsZXIgd2Fy bmluZ3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw OTQzOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN1 cHByZXNzIC1XY2xhc3MtbWVtYWNjZXNzIHdhcm5pbmcuIENvbmN1cnJlbnRCdWZmZXIgaXMgZG9j dW1lbnRlZCB0byBzdXBwb3J0IHR5cGVzIHRoYXQgYXJlCisgICAgICAgIGJpdC1jb3B5YWJsZSBi dXQgbm90IGNvcHktY29uc3RydWN0YWJsZS4gVGhpcyBpcyBzdHJhbmdlLCBidXQgd2hvIGFtIEkg dG8gcXVlc3Rpb24gaXQ/CisKKyAgICAgICAgKiB3dGYvQ29uY3VycmVudEJ1ZmZlci5oOgorCiAy MDIwLTAzLTI1ICBDaHJpc3RvcGhlciBSZWlkICA8Y2hyaXMucmVpZEBzb255LmNvbT4KIAogICAg ICAgICBbUGxheVN0YXRpb25dIFNwZWNpZnkgYSAxNiBLQiBtaW5pbXVtIHBhZ2Ugc2l6ZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IDQwNWJmZTg2MTNmMDRmMzdhZWM0ZjQ3MDgzNzBjZGMzYTllOWJmZjQuLmRiNWE0 YjkzNTg4NmM1NjBjZmIyNWRmM2JmODkwZDU2NDFiZGUxYzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyMiBAQAorMjAyMC0wMy0yNiAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21l Lm9yZz4KKworICAgICAgICBGaXggdmFyaW91cyBjb21waWxlciB3YXJuaW5ncworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA5NDM4CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBkb20vRWxlbWVudC5jcHA6 IEZpeCAtV3VudXNlZC12YXJpYWJsZSB3YXJuaW5ncy4KKyAgICAgICAgKFdlYkNvcmU6OkVsZW1l bnQ6OndlYkFuaW1hdGlvbnMgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6Y3Nz QW5pbWF0aW9ucyBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpFbGVtZW50Ojp0cmFuc2l0aW9u cyBjb25zdCk6CisgICAgICAgIChXZWJDb3JlOjpFbGVtZW50OjpoYXNDb21wbGV0ZWRUcmFuc2l0 aW9uc0ZvclByb3BlcnR5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6Omhhc1J1 bm5pbmdUcmFuc2l0aW9uc0ZvclByb3BlcnR5IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkVs ZW1lbnQ6Omhhc1J1bm5pbmdUcmFuc2l0aW9ucyBjb25zdCk6CisgICAgICAgICogcGFnZS9zY3Jv bGxpbmcvVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmNwcDogRml4IC1XdW51c2VkLXZhcmlhYmxlIHdh cm5pbmcuCisgICAgICAgIChXZWJDb3JlOjpUaHJlYWRlZFNjcm9sbGluZ1RyZWU6OnNjcm9sbGlu Z1RyZWVOb2RlRGlkU2Nyb2xsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJz ZXJzLmg6IEZpeCAtV3JlZHVuZGFudC1tb3ZlIHdhcm5pbmcuCisgICAgICAgIChXZWJDb3JlOjpw YXJzZUFjY2Vzc0NvbnRyb2xBbGxvd0xpc3QpOgorCiAyMDIwLTAzLTI2ICBDaHJpcyBEdW1leiAg PGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgW1N0cmVzc0dDXSBBU1NFUlRJT04gRkFJTEVE OiBtX3dyYXBwZXIgdW5kZXIgV2ViQ29yZTo6SFRNTE1lZGlhRWxlbWVudDo6ZGlzcGF0Y2hFdmVu dApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZwppbmRleCBlM2M3YTQxZTkyMzg3ZDZlMjM1OTc0MWY2MDNhM2ZmZjJjODg0Nzg0Li45 NDUyNzM0M2E4YjM1NTI1MTQ0ZmNiYmEzMDM5NjE4ODM4M2Y0OTNlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE0IEBACisyMDIwLTAzLTI2ICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25v bWUub3JnPgorCisgICAgICAgIEZpeCB2YXJpb3VzIGNvbXBpbGVyIHdhcm5pbmdzCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDk0MzgKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkv Qy9XS1BhZ2UuY3BwOiBTdXBwcmVzcyAtV2RlcHJlY2F0ZWQtZGVjbGFyYXRpb24gd2FybmluZ3Mu CisgICAgICAgIChXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KToKKyAgICAgICAgKFdLUGFnZVNl dFBhZ2VQb2xpY3lDbGllbnQpOgorCiAyMDIwLTAzLTI2ICBDaHJpcyBEdW1leiAgPGNkdW1lekBh cHBsZS5jb20+CiAKICAgICAgICAgUmVncmVzc2lvbihyMjU4OTQ5KSBTYWZhcmkgc29tZXRpbWVz IGNyYXNoZXMgd2hlbiBiZWNvbWluZyB0aGUgZm9yZWdyb3VuZCBhcHBsaWNhdGlvbgpkaWZmIC0t Z2l0IGEvU291cmNlL1dURi93dGYvQ29uY3VycmVudEJ1ZmZlci5oIGIvU291cmNlL1dURi93dGYv Q29uY3VycmVudEJ1ZmZlci5oCmluZGV4IGY1NzQ4ZjFhMjA1MzJjNmQxZjYyM2ZhYTBkZDViYTE0 NDM5ZWUzNTkuLjJjMDI5NmQ1NTk2YTE0OGFmYzY2MTJkMjVmNDY1NDI4ZGY4NDc0MjYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0NvbmN1cnJlbnRCdWZmZXIuaAorKysgYi9Tb3VyY2UvV1RG L3d0Zi9Db25jdXJyZW50QnVmZmVyLmgKQEAgLTY2LDggKzY2LDkgQEAgcHVibGljOgogICAgICAg ICAgICAgcmV0dXJuOwogICAgICAgICBBcnJheSogbmV3QXJyYXkgPSBjcmVhdGVBcnJheShuZXdT aXplKTsKICAgICAgICAgLy8gVGhpcyBhbGxvd3MgdXMgdG8gZG8gQ29uY3VycmVudEJ1ZmZlcjxz dGQ6OnVuaXF1ZV9wdHI8Pj4uCisgICAgICAgIC8vIHN0YXRpY19jYXN0PHZvaWQqPiBhdm9pZHMg dHJpZ2dlcmluZyAtV2NsYXNzLW1lbWFjY2Vzcy4KICAgICAgICAgaWYgKGFycmF5KQotICAgICAg ICAgICAgbWVtY3B5KG5ld0FycmF5LT5kYXRhLCBhcnJheS0+ZGF0YSwgc2l6ZW9mKFQpICogYXJy YXktPnNpemUpOworICAgICAgICAgICAgbWVtY3B5KHN0YXRpY19jYXN0PHZvaWQqPihuZXdBcnJh eS0+ZGF0YSksIGFycmF5LT5kYXRhLCBzaXplb2YoVCkgKiBhcnJheS0+c2l6ZSk7CiAgICAgICAg IGZvciAoc2l6ZV90IGkgPSBhcnJheSA/IGFycmF5LT5zaXplIDogMDsgaSA8IG5ld1NpemU7ICsr aSkKICAgICAgICAgICAgIG5ldyAobmV3QXJyYXktPmRhdGEgKyBpKSBUKCk7CiAgICAgICAgIFdU Rjo6c3RvcmVTdG9yZUZlbmNlKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRWxl bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKaW5kZXggYjY0ZWJiMTIz OWIxMzk1NmFlNDRhMjM0ZTE1MjcyOTRmNmUyNzQ5ZS4uNjBiZmM3MTQ4ZjMwZjY0M2Q0YTVkZjRm ZDMxN2ZiMDdkNzE5Mzc2YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcApAQCAtMzgwMCw0MiArMzgw MCw0MiBAQCBPcHRpb25TZXQ8QW5pbWF0aW9uSW1wYWN0PiBFbGVtZW50OjphcHBseUtleWZyYW1l RWZmZWN0cyhSZW5kZXJTdHlsZSYgdGFyZ2V0U3R5bAogY29uc3QgQW5pbWF0aW9uQ29sbGVjdGlv biogRWxlbWVudDo6d2ViQW5pbWF0aW9ucygpIGNvbnN0CiB7CiAgICAgaWYgKGF1dG8qIGFuaW1h dGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0YSgpKQotICAgICAgICByZXR1cm4gJmFuaW1hdGlv blJhcmVEYXRhKCktPndlYkFuaW1hdGlvbnMoKTsKKyAgICAgICAgcmV0dXJuICZhbmltYXRpb25E YXRhLT53ZWJBbmltYXRpb25zKCk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKIGNvbnN0IEFu aW1hdGlvbkNvbGxlY3Rpb24qIEVsZW1lbnQ6OmNzc0FuaW1hdGlvbnMoKSBjb25zdAogewogICAg IGlmIChhdXRvKiBhbmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKLSAgICAgICAg cmV0dXJuICZhbmltYXRpb25SYXJlRGF0YSgpLT5jc3NBbmltYXRpb25zKCk7CisgICAgICAgIHJl dHVybiAmYW5pbWF0aW9uRGF0YS0+Y3NzQW5pbWF0aW9ucygpOwogICAgIHJldHVybiBudWxscHRy OwogfQogCiBjb25zdCBBbmltYXRpb25Db2xsZWN0aW9uKiBFbGVtZW50Ojp0cmFuc2l0aW9ucygp IGNvbnN0CiB7CiAgICAgaWYgKGF1dG8qIGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0 YSgpKQotICAgICAgICByZXR1cm4gJmFuaW1hdGlvblJhcmVEYXRhKCktPnRyYW5zaXRpb25zKCk7 CisgICAgICAgIHJldHVybiAmYW5pbWF0aW9uRGF0YS0+dHJhbnNpdGlvbnMoKTsKICAgICByZXR1 cm4gbnVsbHB0cjsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNDb21wbGV0ZWRUcmFuc2l0aW9uc0Zv clByb3BlcnR5KENTU1Byb3BlcnR5SUQgcHJvcGVydHkpIGNvbnN0CiB7CiAgICAgaWYgKGF1dG8q IGFuaW1hdGlvbkRhdGEgPSBhbmltYXRpb25SYXJlRGF0YSgpKQotICAgICAgICByZXR1cm4gYW5p bWF0aW9uUmFyZURhdGEoKS0+Y29tcGxldGVkVHJhbnNpdGlvbnNCeVByb3BlcnR5KCkuY29udGFp bnMocHJvcGVydHkpOworICAgICAgICByZXR1cm4gYW5pbWF0aW9uRGF0YS0+Y29tcGxldGVkVHJh bnNpdGlvbnNCeVByb3BlcnR5KCkuY29udGFpbnMocHJvcGVydHkpOwogICAgIHJldHVybiBmYWxz ZTsKIH0KIAogYm9vbCBFbGVtZW50OjpoYXNSdW5uaW5nVHJhbnNpdGlvbnNGb3JQcm9wZXJ0eShD U1NQcm9wZXJ0eUlEIHByb3BlcnR5KSBjb25zdAogewogICAgIGlmIChhdXRvKiBhbmltYXRpb25E YXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKLSAgICAgICAgcmV0dXJuIGFuaW1hdGlvblJhcmVE YXRhKCktPnJ1bm5pbmdUcmFuc2l0aW9uc0J5UHJvcGVydHkoKS5jb250YWlucyhwcm9wZXJ0eSk7 CisgICAgICAgIHJldHVybiBhbmltYXRpb25EYXRhLT5ydW5uaW5nVHJhbnNpdGlvbnNCeVByb3Bl cnR5KCkuY29udGFpbnMocHJvcGVydHkpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogYm9vbCBF bGVtZW50OjpoYXNSdW5uaW5nVHJhbnNpdGlvbnMoKSBjb25zdAogewogICAgIGlmIChhdXRvKiBh bmltYXRpb25EYXRhID0gYW5pbWF0aW9uUmFyZURhdGEoKSkKLSAgICAgICAgcmV0dXJuICFhbmlt YXRpb25SYXJlRGF0YSgpLT5ydW5uaW5nVHJhbnNpdGlvbnNCeVByb3BlcnR5KCkuaXNFbXB0eSgp OworICAgICAgICByZXR1cm4gIWFuaW1hdGlvbkRhdGEtPnJ1bm5pbmdUcmFuc2l0aW9uc0J5UHJv cGVydHkoKS5pc0VtcHR5KCk7CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZy9UaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3BwIGIv U291cmNlL1dlYkNvcmUvcGFnZS9zY3JvbGxpbmcvVGhyZWFkZWRTY3JvbGxpbmdUcmVlLmNwcApp bmRleCA3MjhhYjA5OGU2M2NlMzk1MTIzNWI1MWQ5N2E1NWExOTY3MTNhZGY2Li4xZDdjMzM1Mzk3 ZDcyN2Y1ZTFlZWM1MTNlMDZmZTk5Y2M1Y2Q4NjY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL3Njcm9sbGluZy9UaHJlYWRlZFNjcm9sbGluZ1RyZWUuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2Uvc2Nyb2xsaW5nL1RocmVhZGVkU2Nyb2xsaW5nVHJlZS5jcHAKQEAgLTEwOSwx MCArMTA5LDggQEAgdm9pZCBUaHJlYWRlZFNjcm9sbGluZ1RyZWU6OnNjcm9sbGluZ1RyZWVOb2Rl RGlkU2Nyb2xsKFNjcm9sbGluZ1RyZWVTY3JvbGxpbmdOb2QKICAgICBpZiAoaXM8U2Nyb2xsaW5n VHJlZUZyYW1lU2Nyb2xsaW5nTm9kZT4obm9kZSkpCiAgICAgICAgIGxheW91dFZpZXdwb3J0T3Jp Z2luID0gZG93bmNhc3Q8U2Nyb2xsaW5nVHJlZUZyYW1lU2Nyb2xsaW5nTm9kZT4obm9kZSkubGF5 b3V0Vmlld3BvcnQoKS5sb2NhdGlvbigpOwogCi0gICAgYm9vbCBtb25pdG9yaW5nV2hlZWxFdmVu dHMgPSBmYWxzZTsKICNpZiBQTEFURk9STShNQUMpCi0gICAgbW9uaXRvcmluZ1doZWVsRXZlbnRz ID0gaXNNb25pdG9yaW5nV2hlZWxFdmVudHMoKTsKLSAgICBpZiAobW9uaXRvcmluZ1doZWVsRXZl bnRzKQorICAgIGlmIChpc01vbml0b3JpbmdXaGVlbEV2ZW50cygpKQogICAgICAgICBkZWZlcldo ZWVsRXZlbnRUZXN0Q29tcGxldGlvbkZvclJlYXNvbihyZWludGVycHJldF9jYXN0PFdoZWVsRXZl bnRUZXN0TW9uaXRvcjo6U2Nyb2xsYWJsZUFyZWFJZGVudGlmaWVyPihub2RlLnNjcm9sbGluZ05v ZGVJRCgpKSwgV2hlZWxFdmVudFRlc3RNb25pdG9yOjpTY3JvbGxpbmdUaHJlYWRTeW5jTmVlZGVk KTsKICNlbmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L0hUVFBQYXJzZXJzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBQYXJz ZXJzLmgKaW5kZXggMjBkYjczOTFlN2UyZDBmMzk0NjhlOTU3NDJkYTQ5OWRhMjIxYTc4ZS4uZmYw YWY4MzU1MzRmZmI0MGNmZTkwNmU3NzQ1Y2M3ODM1NDI2N2RjOCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQUGFyc2Vycy5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUFBhcnNlcnMuaApAQCAtMTcyLDcgKzE3Miw3IEBAIE9w dGlvbmFsPEhhc2hTZXQ8U3RyaW5nLCBIYXNoVHlwZT4+IHBhcnNlQWNjZXNzQ29udHJvbEFsbG93 TGlzdChjb25zdCBTdHJpbmcmIHN0CiAgICAgICAgIGlmICghYWRkVG9BY2Nlc3NDb250cm9sQWxs b3dMaXN0KHN0cmluZywgc3RhcnQsIHN0cmluZy5sZW5ndGgoKSAtIDEsIHNldCkpCiAgICAgICAg ICAgICByZXR1cm4geyB9OwogICAgIH0KLSAgICByZXR1cm4gV1RGTW92ZShzZXQpOworICAgIHJl dHVybiBzZXQ7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQ SS9DL1dLUGFnZS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvQy9XS1BhZ2UuY3Bw CmluZGV4IDljYTAzYjYwMWZjMDE3NzdmZGU5OWU5N2ZhMWQ1NDQ2ZjMxM2RiY2UuLjJlZTc5MmI5 NDFmMzM0N2RhMmI2YTg1Y2ZkOWY5OTc0NDk4NTI0OTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9DL1dLUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL0MvV0tQYWdlLmNwcApAQCAtMTIwMyw3ICsxMjAzLDEyIEBAIHZvaWQgV0tQYWdlU2V0 UGFnZUxvYWRlckNsaWVudChXS1BhZ2VSZWYgcGFnZVJlZiwgY29uc3QgV0tQYWdlTG9hZGVyQ2xp ZW50QmFzZSoKIAogICAgIFdlYlBhZ2VQcm94eSogd2ViUGFnZVByb3h5ID0gdG9JbXBsKHBhZ2VS ZWYpOwogCitBTExPV19ERVBSRUNBVEVEX0RFQ0xBUkFUSU9OU19CRUdJTgorICAgIC8vIEdDQyAx MCBnZXRzIGNvbmZ1c2VkIGhlcmUgYW5kIHdhcm5zIHRoYXQgV0tQYWdlU2V0UGFnZVBvbGljeUNs aWVudCBpcyBkZXByZWNhdGVkIHdoZW4gd2UgY2FsbAorICAgIC8vIG1ha2VVbmlxdWU8TG9hZGVy Q2xpZW50PigpLiBUaGlzIHNlZW1zIHRvIGJlIGEgR0NDIGJ1Zy4gSXQncyBub3QgcmVhbGx5IGFw cHJvcHJpYXRlIHRvIHVzZQorICAgIC8vIEFMTE9XX0RFUFJFQ0FURURfREVDTEFSQVRJT05TX0JF R0lOL0VORCBoZXJlIGJlY2F1c2Ugd2UgYXJlIG5vdCB1c2luZyBhIGRlcHJlY2F0ZWQgc3ltYm9s LgogICAgIGF1dG8gbG9hZGVyQ2xpZW50ID0gbWFrZVVuaXF1ZTxMb2FkZXJDbGllbnQ+KHdrQ2xp ZW50KTsKK0FMTE9XX0RFUFJFQ0FURURfREVDTEFSQVRJT05TX0VORAogCiAgICAgLy8gSXQgd291 bGQgYmUgbmljZSB0byBnZXQgcmlkIG9mIHRoaXMgY29kZSBhbmQgdHJhbnNpdGlvbiBhbGwgY2xp ZW50cyB0byB1c2luZyBkaWRMYXlvdXQgaW5zdGVhZCBvZgogICAgIC8vIGRpZEZpcnN0TGF5b3V0 SW5GcmFtZSBhbmQgZGlkRmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0SW5GcmFtZS4gSW4gdGhl IG1lYW50aW1lLCB0aGlzIGlzIHJlcXVpcmVkCkBAIC0xMjg1LDcgKzEyOTAsMTIgQEAgdm9pZCBX S1BhZ2VTZXRQYWdlUG9saWN5Q2xpZW50KFdLUGFnZVJlZiBwYWdlUmVmLCBjb25zdCBXS1BhZ2VQ b2xpY3lDbGllbnRCYXNlKgogICAgICAgICB9CiAgICAgfTsKIAorQUxMT1dfREVQUkVDQVRFRF9E RUNMQVJBVElPTlNfQkVHSU4KKyAgICAvLyBHQ0MgMTAgZ2V0cyBjb25mdXNlZCBoZXJlIGFuZCB3 YXJucyB0aGF0IFdLUGFnZVNldFBhZ2VQb2xpY3lDbGllbnQgaXMgZGVwcmVjYXRlZCB3aGVuIHdl IGNhbGwKKyAgICAvLyBtYWtlVW5pcXVlPFBvbGljeUNsaWVudD4oKS4gVGhpcyBzZWVtcyB0byBi ZSBhIEdDQyBidWcuIEl0J3Mgbm90IHJlYWxseSBhcHByb3ByaWF0ZSB0byB1c2UKKyAgICAvLyBB TExPV19ERVBSRUNBVEVEX0RFQ0xBUkFUSU9OU19CRUdJTi9FTkQgaGVyZSBiZWNhdXNlIHdlIGFy ZSBub3QgdXNpbmcgYSBkZXByZWNhdGVkIHN5bWJvbC4KICAgICB0b0ltcGwocGFnZVJlZiktPnNl dFBvbGljeUNsaWVudChtYWtlVW5pcXVlPFBvbGljeUNsaWVudD4od2tDbGllbnQpKTsKK0FMTE9X X0RFUFJFQ0FURURfREVDTEFSQVRJT05TX0VORAogfQogCiBuYW1lc3BhY2UgV2ViS2l0IHsK